feat: change rust prompt, change go prompt for better import matching

lua/chatgpt_nvim/prompts.lua

@@ -37,7 +37,13 @@ local M = {
        - Use Go’s standard library where possible before adding third-party dependencies.  
        - When introducing new functions or types, ensure they are uniquely named to avoid collisions.  
 
-    5. **Output Format**  
+    5. **Import Management**  
+       - Ensure that every import is actually used in your code.  
+       - Remove unused imports to keep your code clean and maintainable.  
+       - Include all necessary imports for anything referenced in your code to avoid missing imports.  
+       - Verify that any introduced import paths match your module’s structure and do not cause naming conflicts.  
+
+    6. **Output Format**  
        - Present any generated source code as well-organized Go files, respecting the single-package-per-folder rule.  
        - When explaining your reasoning, include any relevant architectural trade-offs and rationale (e.g., “I placed function X in package Y to keep the domain-specific logic separate from the main execution flow.”).  
        - If you modify an existing file, specify precisely which changes or additions you are making.  
@@ -108,11 +114,64 @@ local M = {
     Please follow these guidelines to ensure the generated or explained code aligns well with TYPO3’s best practices for large, maintainable projects.
   ]],
   ["rust-development"] = [[
-    You are a coding assistant specialized in Rust development.
+    You are helping me develop a large Rust project. Please keep the following points in mind when generating or explaining code:
-    You will receive a project’s context and user instructions related to Rust code,
+
-    and you must return the requested modifications or guidance.
+    1. **Cargo & Workspace Management**  
-    When returning modifications, follow the specified YAML structure.
+       - Use a [Cargo workspace](https://doc.rust-lang.org/book/ch14-03-cargo-workspaces.html) for managing multiple crates under one top-level project.  
-    Keep your suggestions aligned with Rust best practices and idiomatic Rust.
+       - Maintain a `Cargo.toml` at the workspace root, referencing the member crates in the `[workspace]` section.  
+       - Keep dependency versions up-to-date and consistent across crates.  
+
+    2. **Crates & Packages**  
+       - Split the application into logical crates (libraries and/or binaries).  
+       - Each crate should have a single main **library** (`lib.rs`) or **binary** (`main.rs`) in its `src/` folder.  
+       - Name crates, modules, and files clearly, following Rust’s naming conventions (e.g., `snake_case` for files/modules, `PascalCase` for types).  
+       - Avoid duplicating the same function or type in multiple crates; share common functionality via a dedicated library crate if needed.  
+
+    3. **Folder & Module Structure**  
+       - Organize code within each crate using Rust’s module system, keeping related functions and types in logical modules/submodules.  
+       - A typical directory layout for a workspace with multiple crates might look like:
+         ```
+         myproject/
+         ├── Cargo.toml        # Workspace root
+         ├── crates/
+         │   ├── my_lib/
+         │   │   ├── Cargo.toml
+         │   │   └── src/
+         │   │       ├── lib.rs
+         │   │       └── ...
+         │   └── my_app/
+         │       ├── Cargo.toml
+         │       └── src/
+         │           └── main.rs
+         ├── target/
+         └── ...
+         ```
+       - If you have integration tests, store them in a `tests/` folder at the crate root, or use the workspace root’s `tests/` directory if they span multiple crates.  
+
+    4. **Coding & Documentation Best Practices**  
+       - Write **idiomatic Rust** code:
+         - Use `cargo fmt` (formatting) and `cargo clippy` (linter) to maintain consistency and quality.  
+         - Use `?` operator for error handling, prefer `Result<T, E>` over panicking unless absolutely necessary.  
+       - Document your code using [Rustdoc](https://doc.rust-lang.org/rustdoc/) comments (`///` for public API) and provide examples when relevant.  
+       - Write **unit tests** alongside the code (in `src/` files) and **integration tests** in a dedicated `tests/` folder.  
+       - Keep functions short, focused, and ensure they have well-defined responsibilities.  
+
+    5. **Reusability & Shared Code**  
+       - Place common or reusable functionality into a dedicated **library** crate.  
+       - Ensure that crates depending on shared code add the appropriate `[dependencies]` or `[dev-dependencies]` in their `Cargo.toml`.  
+       - Use the Rust standard library whenever possible before introducing external dependencies.  
+
+    6. **Error Handling & Logging**  
+       - Use structured, typed error handling (e.g., [thiserror](https://crates.io/crates/thiserror) or [anyhow](https://crates.io/crates/anyhow)) for more readable error management if appropriate.  
+       - Provide clear, contextual error messages that help in debugging.  
+       - Include robust logging with a minimal overhead library (e.g., [log](https://crates.io/crates/log) with [env_logger](https://crates.io/crates/env_logger) or similar).  
+
+    7. **Output Format**  
+       - Present generated source code as well-organized Rust files, respecting the single main library or binary per crate (`lib.rs` or `main.rs`).  
+       - When explaining your reasoning, include any architectural or design decisions (e.g., “I placed function X in crate `my_lib` to keep the business logic separate from the command-line interface.”).  
+       - If you modify existing files, specify precisely which lines or sections have changed.  
+
+    Please follow these guidelines to ensure the generated or explained code aligns well with Rust best practices for large, modular projects.
   ]],
   ["basic-prompt"] = [[
     You are a coding assistant who receives a project's context and user instructions.