tfmcp / rules

---
description: Rust coding standards and architecture guidelines for tfmcp.
globs: **/*.rs
alwaysApply: false
---

# 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.