001_rust

Rust Coding Style Guide

Code Style

• Follow the Rust style guide as enforced by rustfmt and cargo fmt.
• Use 4 spaces for indentation, not tabs.
• Maximum line length is 100 characters.
• Always run cargo fmt before committing code.

Error Handling

• Use Result and Option types appropriately.
• Propagate errors with the ? operator where appropriate.
• Create custom error types in modules with complex error handling.
• Use thiserror for defining error types.
• Use anyhow for error propagation in application code.

Documentation

• Document all public functions, methods, and types with rustdoc comments.
• Include examples in documentation when useful.
• Document complex or non-obvious code sections.

Best Practices

• Prefer immutable variables (let instead of let mut) when possible.
• Use strong typing rather than type aliases for clarity.
• Leverage Rust's ownership system properly.
• Avoid unsafe code unless absolutely necessary.
• Use clippy to catch common mistakes.

Rust Architecture Guidelines

Project Structure

• Follow the modular structure in src/:
  • core/: Core tfmcp functionality and abstractions
  • mcp/: Model Context Protocol implementation
  • terraform/: Terraform integration services
  • config/: Configuration handling
  • shared/: Shared utilities

Module Organization

• Each module should have a clear, single responsibility.
• Public APIs should be exposed through the module's mod.rs or lib.rs.
• Keep implementation details private whenever possible.
• Use feature flags for optional functionality.

Dependencies

• Be conservative with external dependencies.
• Evaluate new dependencies carefully:
  • Is it actively maintained?
  • Is it widely used/trusted?
  • Would it be better to implement the functionality ourselves?
• Pin dependency versions in Cargo.toml for reproducible builds.

Asynchronous Programming

• Use async/await for asynchronous code.
• Use tokio for async runtime.
• Be careful with blocking operations in async contexts.
• Consider using channels for communication between components.