The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat(agents): add Rust language support (#523)
Ronaldo Martinsebd8c8c6fa26
diff --git a/.opencode/commands/rust-build.md b/.opencode/commands/rust-build.mdnew file mode 100644index 000000000..82a668df1--- /dev/null+++ b/.opencode/commands/rust-build.md@@ -0,0 +1,78 @@+---+description: Fix Rust build errors and borrow checker issues+agent: rust-build-resolver+subtask: true+---++# Rust Build Command++Fix Rust build, clippy, and dependency errors: $ARGUMENTS++## Your Task++1. **Run cargo check**: `cargo check 2>&1`+2. **Run cargo clippy**: `cargo clippy -- -D warnings 2>&1`+3. **Fix errors** one at a time+4. **Verify fixes** don't introduce new errors++## Common Rust Errors++### Borrow Checker+```+cannot borrow `x` as mutable because it is also borrowed as immutable+```+**Fix**: Restructure to end immutable borrow first; clone only if justified++### Type Mismatch+```+mismatched types: expected `T`, found `U`+```+**Fix**: Add `.into()`, `as`, or explicit type conversion++### Missing Import+```+unresolved import `crate::module`+```+**Fix**: Fix the `use` path or declare the module (add Cargo.toml deps only for external crates)++### Lifetime Errors+```+does not live long enough+```+**Fix**: Use owned type or add lifetime annotation++### Trait Not Implemented+```+the trait `X` is not implemented for `Y`+```+**Fix**: Add `#[derive(Trait)]` or implement manually++## Fix Order++1. **Build errors** - Code must compile+2. **Clippy warnings** - Fix suspicious constructs+3. **Formatting** - `cargo fmt` compliance++## Build Commands++```bash+cargo check 2>&1+cargo clippy -- -D warnings 2>&1+cargo fmt --check 2>&1+cargo tree --duplicates+cargo test+```++## Verification++After fixes:+```bash+cargo check # Should succeed+cargo clippy -- -D warnings # No warnings allowed+cargo fmt --check # Formatting should pass+cargo test # Tests should pass+```++---++**IMPORTANT**: Fix errors only. No refactoring, no improvements. Get the build green with minimal changes.diff --git a/.opencode/commands/rust-review.md b/.opencode/commands/rust-review.mdnew file mode 100644index 000000000..ad9c8ecec--- /dev/null+++ b/.opencode/commands/rust-review.md@@ -0,0 +1,65 @@+---+description: Rust code review for ownership, safety, and idiomatic patterns+agent: rust-reviewer+subtask: true+---++# Rust Review Command++Review Rust code for idiomatic patterns and best practices: $ARGUMENTS++## Your Task++1. **Analyze Rust code** for idioms and patterns+2. **Check ownership** - borrowing, lifetimes, unnecessary clones+3. **Review error handling** - proper `?` propagation, no unwrap in production+4. **Verify safety** - unsafe usage, injection, secrets++## Review Checklist++### Safety (CRITICAL)+- [ ] No unchecked `unwrap()`/`expect()` in production paths+- [ ] `unsafe` blocks have `// SAFETY:` comments+- [ ] No SQL/command injection+- [ ] No hardcoded secrets++### Ownership (HIGH)+- [ ] No unnecessary `.clone()` to satisfy borrow checker+- [ ] `&str` preferred over `String` in function parameters+- [ ] `&[T]` preferred over `Vec<T>` in function parameters+- [ ] No excessive lifetime annotations where elision works++### Error Handling (HIGH)+- [ ] Errors propagated with `?`; use `.context()` in `anyhow`/`eyre` application code+- [ ] No silenced errors (`let _ = result;`)+- [ ] `thiserror` for library errors, `anyhow` for applications++### Concurrency (HIGH)+- [ ] No blocking in async context+- [ ] Bounded channels preferred+- [ ] `Mutex` poisoning handled+- [ ] `Send`/`Sync` bounds correct++### Code Quality (MEDIUM)+- [ ] Functions under 50 lines+- [ ] No deep nesting (>4 levels)+- [ ] Exhaustive matching on business enums+- [ ] Clippy warnings addressed++## Report Format++### CRITICAL Issues+- [file:line] Issue description+ Suggestion: How to fix++### HIGH Issues+- [file:line] Issue description+ Suggestion: How to fix++### MEDIUM Issues+- [file:line] Issue description+ Suggestion: How to fix++---++**TIP**: Run `cargo clippy -- -D warnings` and `cargo fmt --check` for automated checks.diff --git a/.opencode/commands/rust-test.md b/.opencode/commands/rust-test.mdnew file mode 100644index 000000000..a1f2dbd2d--- /dev/null+++ b/.opencode/commands/rust-test.md@@ -0,0 +1,104 @@+---+description: Rust TDD workflow with unit and property tests+agent: tdd-guide+subtask: true+---++# Rust Test Command++Implement using Rust TDD methodology: $ARGUMENTS++## Your Task++Apply test-driven development with Rust idioms:++1. **Define types** - Structs, enums, traits+2. **Write tests** - Unit tests in `#[cfg(test)]` modules+3. **Implement minimal code** - Pass the tests+4. **Check coverage** - Target 80%+++## TDD Cycle for Rust++### Step 1: Define Interface+```rust+pub struct Input {+ // fields+}++pub fn process(input: &Input) -> Result<Output, Error> {+ todo!()+}+```++### Step 2: Write Tests+```rust+#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn valid_input_succeeds() {+ let input = Input { /* ... */ };+ let result = process(&input);+ assert!(result.is_ok());+ }++ #[test]+ fn invalid_input_returns_error() {+ let input = Input { /* ... */ };+ let result = process(&input);+ assert!(result.is_err());+ }+}+```++### Step 3: Run Tests (RED)+```bash+cargo test+```++### Step 4: Implement (GREEN)+```rust+pub fn process(input: &Input) -> Result<Output, Error> {+ // Minimal implementation that handles both paths+ validate(input)?;+ Ok(Output { /* ... */ })+}+```++### Step 5: Check Coverage+```bash+cargo llvm-cov+cargo llvm-cov --fail-under-lines 80+```++## Rust Testing Commands++```bash+cargo test # Run all tests+cargo test -- --nocapture # Show println output+cargo test test_name # Run specific test+cargo test --no-fail-fast # Don't stop on first failure+cargo test --lib # Unit tests only+cargo test --test integration # Integration tests only+cargo test --doc # Doc tests only+cargo bench # Run benchmarks+```++## Test File Organization++```+src/+├── lib.rs # Library root+├── service.rs # Implementation+└── service/+ └── tests.rs # Or inline #[cfg(test)] mod tests {}+tests/+└── integration.rs # Integration tests+benches/+└── benchmark.rs # Criterion benchmarks+```++---++**TIP**: Use `rstest` for parameterized tests and `proptest` for property-based testing.diff --git a/.opencode/prompts/agents/rust-build-resolver.txt b/.opencode/prompts/agents/rust-build-resolver.txtnew file mode 100644index 000000000..cca828d15--- /dev/null+++ b/.opencode/prompts/agents/rust-build-resolver.txt@@ -0,0 +1,93 @@+# Rust Build Error Resolver++You are an expert Rust build error resolution specialist. Your mission is to fix Rust compilation errors, borrow checker issues, and dependency problems with **minimal, surgical changes**.++## Core Responsibilities++1. Diagnose `cargo build` / `cargo check` errors+2. Fix borrow checker and lifetime errors+3. Resolve trait implementation mismatches+4. Handle Cargo dependency and feature issues+5. Fix `cargo clippy` warnings++## Diagnostic Commands++Run these in order:++```bash+cargo check 2>&1+cargo clippy -- -D warnings 2>&1+cargo fmt --check 2>&1+cargo tree --duplicates+if command -v cargo-audit >/dev/null; then cargo audit; else echo "cargo-audit not installed"; fi+```++## Resolution Workflow++```text+1. cargo check -> Parse error message and error code+2. Read affected file -> Understand ownership and lifetime context+3. Apply minimal fix -> Only what's needed+4. cargo check -> Verify fix+5. cargo clippy -> Check for warnings+6. cargo fmt --check -> Verify formatting+7. cargo test -> Ensure nothing broke+```++## Common Fix Patterns++| Error | Cause | Fix |+|-------|-------|-----|+| `cannot borrow as mutable` | Immutable borrow active | Restructure to end immutable borrow first, or use `Cell`/`RefCell` |+| `does not live long enough` | Value dropped while still borrowed | Extend lifetime scope, use owned type, or add lifetime annotation |+| `cannot move out of` | Moving from behind a reference | Use `.clone()`, `.to_owned()`, or restructure to take ownership |+| `mismatched types` | Wrong type or missing conversion | Add `.into()`, `as`, or explicit type conversion |+| `trait X is not implemented for Y` | Missing impl or derive | Add `#[derive(Trait)]` or implement trait manually |+| `unresolved import` | Missing dependency or wrong path | Add to Cargo.toml or fix `use` path |+| `unused variable` / `unused import` | Dead code | Remove or prefix with `_` |++## Borrow Checker Troubleshooting++```rust+// Problem: Cannot borrow as mutable because also borrowed as immutable+// Fix: Restructure to end immutable borrow before mutable borrow+let value = map.get("key").cloned();+if value.is_none() {+ map.insert("key".into(), default_value);+}++// Problem: Value does not live long enough+// Fix: Move ownership instead of borrowing+fn get_name() -> String {+ let name = compute_name();+ name // Not &name (dangling reference)+}+```++## Key Principles++- **Surgical fixes only** — don't refactor, just fix the error+- **Never** add `#[allow(unused)]` without explicit approval+- **Never** use `unsafe` to work around borrow checker errors+- **Never** add `.unwrap()` to silence type errors — propagate with `?`+- **Always** run `cargo check` after every fix attempt+- Fix root cause over suppressing symptoms++## Stop Conditions++Stop and report if:+- Same error persists after 3 fix attempts+- Fix introduces more errors than it resolves+- Error requires architectural changes beyond scope+- Borrow checker error requires redesigning data ownership model++## Output Format++```text+[FIXED] src/handler/user.rs:42+Error: E0502 — cannot borrow `map` as mutable because it is also borrowed as immutable+Fix: Cloned value from immutable borrow before mutable insert+Remaining errors: 3+```++Final: `Build Status: SUCCESS/FAILED | Errors Fixed: N | Files Modified: list`diff --git a/.opencode/prompts/agents/rust-reviewer.txt b/.opencode/prompts/agents/rust-reviewer.txtnew file mode 100644index 000000000..cab02f800--- /dev/null+++ b/.opencode/prompts/agents/rust-reviewer.txt@@ -0,0 +1,61 @@+You are a senior Rust code reviewer ensuring high standards of safety, idiomatic patterns, and performance.++When invoked:+1. Run `cargo check`, `cargo clippy -- -D warnings`, `cargo fmt --check`, and `cargo test` — if any fail, stop and report+2. Run `git diff HEAD~1 -- '*.rs'` (or `git diff main...HEAD -- '*.rs'` for PR review) to see recent Rust file changes+3. Focus on modified `.rs` files+4. Begin review++## Security Checks (CRITICAL)++- **SQL Injection**: String interpolation in queries+ ```rust+ // Bad+ format!("SELECT * FROM users WHERE id = {}", user_id)+ // Good: use parameterized queries via sqlx, diesel, etc.+ sqlx::query("SELECT * FROM users WHERE id = $1").bind(user_id)+ ```++- **Command Injection**: Unvalidated input in `std::process::Command`+ ```rust+ // Bad+ Command::new("sh").arg("-c").arg(format!("echo {}", user_input))+ // Good+ Command::new("echo").arg(user_input)+ ```++- **Unsafe without justification**: Missing `// SAFETY:` comment+- **Hardcoded secrets**: API keys, passwords, tokens in source+- **Use-after-free via raw pointers**: Unsafe pointer manipulation++## Error Handling (CRITICAL)++- **Silenced errors**: `let _ = result;` on `#[must_use]` types+- **Missing error context**: `return Err(e)` without `.context()` or `.map_err()`+- **Panic in production**: `panic!()`, `todo!()`, `unreachable!()` in production paths+- **`Box<dyn Error>` in libraries**: Use `thiserror` for typed errors++## Ownership and Lifetimes (HIGH)++- **Unnecessary cloning**: `.clone()` to satisfy borrow checker without understanding root cause+- **String instead of &str**: Taking `String` when `&str` suffices+- **Vec instead of slice**: Taking `Vec<T>` when `&[T]` suffices++## Concurrency (HIGH)++- **Blocking in async**: `std::thread::sleep`, `std::fs` in async context+- **Unbounded channels**: `mpsc::channel()`/`tokio::sync::mpsc::unbounded_channel()` need justification — prefer bounded channels+- **`Mutex` poisoning ignored**: Not handling `PoisonError`+- **Missing `Send`/`Sync` bounds**: Types shared across threads++## Code Quality (HIGH)++- **Large functions**: Over 50 lines+- **Wildcard match on business enums**: `_ =>` hiding new variants+- **Dead code**: Unused functions, imports, variables++## Approval Criteria++- **Approve**: No CRITICAL or HIGH issues+- **Warning**: MEDIUM issues only+- **Block**: CRITICAL or HIGH issues founddiff --git a/AGENTS.md b/AGENTS.mdindex 8e9e9fd10..56e7bb45a 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -1,6 +1,6 @@# Everything Claude Code (ECC) — Agent Instructions-This is a **production-ready AI coding plugin** providing 16 specialized agents, 65+ skills, 40 commands, and automated hook workflows for software development.+This is a **production-ready AI coding plugin** providing 20 specialized agents, 65+ skills, 51 commands, and automated hook workflows for software development.## Core Principles@@ -25,11 +25,15 @@ This is a **production-ready AI coding plugin** providing 16 specialized agents,| doc-updater | Documentation and codemaps | Updating docs || go-reviewer | Go code review | Go projects || go-build-resolver | Go build errors | Go build failures |+| kotlin-reviewer | Kotlin code review | Kotlin/Android/KMP projects |+| kotlin-build-resolver | Kotlin/Gradle build errors | Kotlin build failures || database-reviewer | PostgreSQL/Supabase specialist | Schema design, query optimization || python-reviewer | Python code review | Python projects || chief-of-staff | Communication triage and drafts | Multi-channel email, Slack, LINE, Messenger || loop-operator | Autonomous loop execution | Run loops safely, monitor stalls, intervene || harness-optimizer | Harness config tuning | Reliability, cost, throughput |+| rust-reviewer | Rust code review | Rust projects |+| rust-build-resolver | Rust build errors | Rust build failures |## Agent Orchestration@@ -128,9 +132,9 @@ Troubleshoot failures: check test isolation → verify mocks → fix implementat## Project Structure```-agents/ — 13 specialized subagents+agents/ — 20 specialized subagentsskills/ — 65+ workflow skills and domain knowledge-commands/ — 40 slash commands+commands/ — 51 slash commandshooks/ — Trigger-based automationsrules/ — Always-follow guidelines (common + per-language)scripts/ — Cross-platform Node.js utilitiesdiff --git a/agents/rust-build-resolver.md b/agents/rust-build-resolver.mdnew file mode 100644index 000000000..4fdc961d9--- /dev/null+++ b/agents/rust-build-resolver.md@@ -0,0 +1,148 @@+---+name: rust-build-resolver+description: Rust build, compilation, and dependency error resolution specialist. Fixes cargo build errors, borrow checker issues, and Cargo.toml problems with minimal changes. Use when Rust builds fail.+tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"]+model: sonnet+---++# Rust Build Error Resolver++You are an expert Rust build error resolution specialist. Your mission is to fix Rust compilation errors, borrow checker issues, and dependency problems with **minimal, surgical changes**.++## Core Responsibilities++1. Diagnose `cargo build` / `cargo check` errors+2. Fix borrow checker and lifetime errors+3. Resolve trait implementation mismatches+4. Handle Cargo dependency and feature issues+5. Fix `cargo clippy` warnings++## Diagnostic Commands++Run these in order:++```bash+cargo check 2>&1+cargo clippy -- -D warnings 2>&1+cargo fmt --check 2>&1+cargo tree --duplicates 2>&1+if command -v cargo-audit >/dev/null; then cargo audit; else echo "cargo-audit not installed"; fi+```++## Resolution Workflow++```text+1. cargo check -> Parse error message and error code+2. Read affected file -> Understand ownership and lifetime context+3. Apply minimal fix -> Only what's needed+4. cargo check -> Verify fix+5. cargo clippy -> Check for warnings+6. cargo test -> Ensure nothing broke+```++## Common Fix Patterns++| Error | Cause | Fix |+|-------|-------|-----|+| `cannot borrow as mutable` | Immutable borrow active | Restructure to end immutable borrow first, or use `Cell`/`RefCell` |+| `does not live long enough` | Value dropped while still borrowed | Extend lifetime scope, use owned type, or add lifetime annotation |+| `cannot move out of` | Moving from behind a reference | Use `.clone()`, `.to_owned()`, or restructure to take ownership |+| `mismatched types` | Wrong type or missing conversion | Add `.into()`, `as`, or explicit type conversion |+| `trait X is not implemented for Y` | Missing impl or derive | Add `#[derive(Trait)]` or implement trait manually |+| `unresolved import` | Missing dependency or wrong path | Add to Cargo.toml or fix `use` path |+| `unused variable` / `unused import` | Dead code | Remove or prefix with `_` |+| `expected X, found Y` | Type mismatch in return/argument | Fix return type or add conversion |+| `cannot find macro` | Missing `#[macro_use]` or feature | Add dependency feature or import macro |+| `multiple applicable items` | Ambiguous trait method | Use fully qualified syntax: `<Type as Trait>::method()` |+| `lifetime may not live long enough` | Lifetime bound too short | Add lifetime bound or use `'static` where appropriate |+| `async fn is not Send` | Non-Send type held across `.await` | Restructure to drop non-Send values before `.await` |+| `the trait bound is not satisfied` | Missing generic constraint | Add trait bound to generic parameter |+| `no method named X` | Missing trait import | Add `use Trait;` import |++## Borrow Checker Troubleshooting++```rust+// Problem: Cannot borrow as mutable because also borrowed as immutable+// Fix: Restructure to end immutable borrow before mutable borrow+let value = map.get("key").cloned(); // Clone ends the immutable borrow+if value.is_none() {+ map.insert("key".into(), default_value);+}++// Problem: Value does not live long enough+// Fix: Move ownership instead of borrowing+fn get_name() -> String { // Return owned String+ let name = compute_name();+ name // Not &name (dangling reference)+}++// Problem: Cannot move out of index+// Fix: Use swap_remove, clone, or take+let item = vec.swap_remove(index); // Takes ownership+// Or: let item = vec[index].clone();+```++## Cargo.toml Troubleshooting++```bash+# Check dependency tree for conflicts+cargo tree -d # Show duplicate dependencies+cargo tree -i some_crate # Invert — who depends on this?++# Feature resolution+cargo tree -f "{p} {f}" # Show features enabled per crate+cargo check --features "feat1,feat2" # Test specific feature combination++# Workspace issues+cargo check --workspace # Check all workspace members+cargo check -p specific_crate # Check single crate in workspace++# Lock file issues+cargo update -p specific_crate # Update one dependency (preferred)+cargo update # Full refresh (last resort — broad changes)+```++## Edition and MSRV Issues++```bash+# Check edition in Cargo.toml (2024 is the current default for new projects)+grep "edition" Cargo.toml++# Check minimum supported Rust version+rustc --version+grep "rust-version" Cargo.toml++# Common fix: update edition for new syntax (check rust-version first!)+# In Cargo.toml: edition = "2024" # Requires rustc 1.85++```++## Key Principles++- **Surgical fixes only** — don't refactor, just fix the error+- **Never** add `#[allow(unused)]` without explicit approval+- **Never** use `unsafe` to work around borrow checker errors+- **Never** add `.unwrap()` to silence type errors — propagate with `?`+- **Always** run `cargo check` after every fix attempt+- Fix root cause over suppressing symptoms+- Prefer the simplest fix that preserves the original intent++## Stop Conditions++Stop and report if:+- Same error persists after 3 fix attempts+- Fix introduces more errors than it resolves+- Error requires architectural changes beyond scope+- Borrow checker error requires redesigning data ownership model++## Output Format++```text+[FIXED] src/handler/user.rs:42+Error: E0502 — cannot borrow `map` as mutable because it is also borrowed as immutable+Fix: Cloned value from immutable borrow before mutable insert+Remaining errors: 3+```++Final: `Build Status: SUCCESS/FAILED | Errors Fixed: N | Files Modified: list`++For detailed Rust error patterns and code examples, see `skill: rust-patterns`.diff --git a/agents/rust-reviewer.md b/agents/rust-reviewer.mdnew file mode 100644index 000000000..85f1840ad--- /dev/null+++ b/agents/rust-reviewer.md@@ -0,0 +1,93 @@+---+name: rust-reviewer+description: Expert Rust code reviewer specializing in ownership, lifetimes, error handling, unsafe usage, and idiomatic patterns. Use for all Rust code changes. MUST BE USED for Rust projects.+tools: ["Read", "Grep", "Glob", "Bash"]+model: sonnet+---++You are a senior Rust code reviewer ensuring high standards of safety, idiomatic patterns, and performance.++When invoked:+1. Run `cargo check`, `cargo clippy -- -D warnings`, `cargo fmt --check`, and `cargo test` — if any fail, stop and report+2. Run `git diff HEAD~1 -- '*.rs'` (or `git diff main...HEAD -- '*.rs'` for PR review) to see recent Rust file changes+3. Focus on modified `.rs` files+4. Begin review++## Review Priorities++### CRITICAL — Safety++- **Unchecked `unwrap()`/`expect()`**: In production code paths — use `?` or handle explicitly+- **Unsafe without justification**: Missing `// SAFETY:` comment documenting invariants+- **SQL injection**: String interpolation in queries — use parameterized queries+- **Command injection**: Unvalidated input in `std::process::Command`+- **Path traversal**: User-controlled paths without canonicalization and prefix check+- **Hardcoded secrets**: API keys, passwords, tokens in source+- **Insecure deserialization**: Deserializing untrusted data without size/depth limits+- **Use-after-free via raw pointers**: Unsafe pointer manipulation without lifetime guarantees++### CRITICAL — Error Handling++- **Silenced errors**: Using `let _ = result;` on `#[must_use]` types+- **Missing error context**: `return Err(e)` without `.context()` or `.map_err()`+- **Panic for recoverable errors**: `panic!()`, `todo!()`, `unreachable!()` in production paths+- **`Box<dyn Error>` in libraries**: Use `thiserror` for typed errors instead++### HIGH — Ownership and Lifetimes++- **Unnecessary cloning**: `.clone()` to satisfy borrow checker without understanding the root cause+- **String instead of &str**: Taking `String` when `&str` or `impl AsRef<str>` suffices+- **Vec instead of slice**: Taking `Vec<T>` when `&[T]` suffices+- **Missing `Cow`**: Allocating when `Cow<'_, str>` would avoid it+- **Lifetime over-annotation**: Explicit lifetimes where elision rules apply++### HIGH — Concurrency++- **Blocking in async**: `std::thread::sleep`, `std::fs` in async context — use tokio equivalents+- **Unbounded channels**: `mpsc::channel()`/`tokio::sync::mpsc::unbounded_channel()` need justification — prefer bounded channels (`tokio::sync::mpsc::channel(n)` in async, `sync_channel(n)` in sync)+- **`Mutex` poisoning ignored**: Not handling `PoisonError` from `.lock()`+- **Missing `Send`/`Sync` bounds**: Types shared across threads without proper bounds+- **Deadlock patterns**: Nested lock acquisition without consistent ordering++### HIGH — Code Quality++- **Large functions**: Over 50 lines+- **Deep nesting**: More than 4 levels+- **Wildcard match on business enums**: `_ =>` hiding new variants+- **Non-exhaustive matching**: Catch-all where explicit handling is needed+- **Dead code**: Unused functions, imports, or variables++### MEDIUM — Performance++- **Unnecessary allocation**: `to_string()` / `to_owned()` in hot paths+- **Repeated allocation in loops**: String or Vec creation inside loops+- **Missing `with_capacity`**: `Vec::new()` when size is known — use `Vec::with_capacity(n)`+- **Excessive cloning in iterators**: `.cloned()` / `.clone()` when borrowing suffices+- **N+1 queries**: Database queries in loops++### MEDIUM — Best Practices++- **Clippy warnings unaddressed**: Suppressed with `#[allow]` without justification+- **Missing `#[must_use]`**: On non-`must_use` return types where ignoring values is likely a bug+- **Derive order**: Should follow `Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize`+- **Public API without docs**: `pub` items missing `///` documentation+- **`format!` for simple concatenation**: Use `push_str`, `concat!`, or `+` for simple cases++## Diagnostic Commands++```bash+cargo clippy -- -D warnings+cargo fmt --check+cargo test+if command -v cargo-audit >/dev/null; then cargo audit; else echo "cargo-audit not installed"; fi+if command -v cargo-deny >/dev/null; then cargo deny check; else echo "cargo-deny not installed"; fi+cargo build --release 2>&1 | head -50+```++## Approval Criteria++- **Approve**: No CRITICAL or HIGH issues+- **Warning**: MEDIUM issues only+- **Block**: CRITICAL or HIGH issues found++For detailed Rust code examples and anti-patterns, see `skill: rust-patterns`.diff --git a/commands/rust-build.md b/commands/rust-build.mdnew file mode 100644index 000000000..5bdb9e37c--- /dev/null+++ b/commands/rust-build.md@@ -0,0 +1,187 @@+---+description: Fix Rust build errors, borrow checker issues, and dependency problems incrementally. Invokes the rust-build-resolver agent for minimal, surgical fixes.+---++# Rust Build and Fix++This command invokes the **rust-build-resolver** agent to incrementally fix Rust build errors with minimal changes.++## What This Command Does++1. **Run Diagnostics**: Execute `cargo check`, `cargo clippy`, `cargo fmt --check`+2. **Parse Errors**: Identify error codes and affected files+3. **Fix Incrementally**: One error at a time+4. **Verify Each Fix**: Re-run `cargo check` after each change+5. **Report Summary**: Show what was fixed and what remains++## When to Use++Use `/rust-build` when:+- `cargo build` or `cargo check` fails with errors+- `cargo clippy` reports warnings+- Borrow checker or lifetime errors block compilation+- Cargo dependency resolution fails+- After pulling changes that break the build++## Diagnostic Commands Run++```bash+# Primary build check+cargo check 2>&1++# Lints and suggestions+cargo clippy -- -D warnings 2>&1++# Formatting check+cargo fmt --check 2>&1++# Dependency issues+cargo tree --duplicates++# Security audit (if available)+if command -v cargo-audit >/dev/null; then cargo audit; else echo "cargo-audit not installed"; fi+```++## Example Session++````text+User: /rust-build++Agent:+# Rust Build Resolution++## Initial Diagnostics++```bash+$ cargo check+error[E0502]: cannot borrow `map` as mutable because it is also borrowed as immutable+ --> src/service/cache.rs:25:5+error[E0308]: mismatched types+ --> src/handler/api.rs:42:12+error[E0425]: cannot find value `db` in this scope+ --> src/handler/api.rs:58:9+```++Errors found: 3++## Fix 1: Borrow Checker Error++File: src/service/cache.rs:25+Error: E0502 — cannot borrow `map` as mutable because also borrowed as immutable+Cause: Immutable borrow still active during mutable insert++```rust+// Changed: restructured to end immutable borrow before mutable access+if !map.contains_key("key") {+ map.insert("key".into(), default);+}+```++```bash+$ cargo check+# 2 errors remaining+```++## Fix 2: Type Mismatch++File: src/handler/api.rs:42+Error: E0308 — mismatched types: expected `usize`, found `&str`++```rust+// Changed+let count = params.get("count");+// To+let count: usize = params.get("count")+ .and_then(|s| s.parse().ok())+ .unwrap_or(0);+```++```bash+$ cargo check+# 1 error remaining+```++## Fix 3: Unresolved Name++File: src/handler/api.rs:58+Error: E0425 — cannot find value `db` in this scope+Cause: Missing import++```rust+// Added+use crate::db;+```++```bash+$ cargo check+# Build successful!+```++## Final Verification++```bash+$ cargo clippy -- -D warnings+# No warnings++$ cargo test+running 6 tests+test service::cache::tests::test_insert ... ok+test service::cache::tests::test_get ... ok+test handler::api::tests::test_parse_count ... ok+test handler::api::tests::test_missing_count ... ok+test handler::api::tests::test_db_import ... ok+test handler::api::tests::test_response ... ok++test result: ok. 6 passed; 0 failed; 0 ignored+```++## Summary++| Metric | Count |+|--------|-------|+| Build errors fixed | 3 |+| Clippy warnings fixed | 0 |+| Files modified | 2 |+| Remaining issues | 0 |++Build Status: SUCCESS+````++## Common Errors Fixed++| Error | Typical Fix |+|-------|-------------|+| `cannot borrow as mutable` | Restructure to end immutable borrow first; clone only if justified |+| `does not live long enough` | Use owned type or add lifetime annotation |+| `cannot move out of` | Restructure to take ownership; clone only as last resort |+| `mismatched types` | Add `.into()`, `as`, or explicit conversion |+| `trait X not implemented` | Add `#[derive(Trait)]` or implement manually |+| `unresolved import` | Add to Cargo.toml or fix `use` path |+| `cannot find value` | Add import or fix path |++## Fix Strategy++1. **Build errors first** - Code must compile+2. **Clippy warnings second** - Fix suspicious constructs+3. **Formatting third** - `cargo fmt` compliance+4. **One fix at a time** - Verify each change+5. **Minimal changes** - Don't refactor, just fix++## Stop Conditions++The agent will stop and report if:+- Same error persists after 3 attempts+- Fix introduces more errors+- Requires architectural changes+- Borrow checker error requires redesigning data ownership++## Related Commands++- `/rust-test` - Run tests after build succeeds+- `/rust-review` - Review code quality+- `/verify` - Full verification loop++## Related++- Agent: `agents/rust-build-resolver.md`+- Skill: `skills/rust-patterns/`diff --git a/commands/rust-review.md b/commands/rust-review.mdnew file mode 100644index 000000000..5d91d7d9e--- /dev/null+++ b/commands/rust-review.md@@ -0,0 +1,142 @@+---+description: Comprehensive Rust code review for ownership, lifetimes, error handling, unsafe usage, and idiomatic patterns. Invokes the rust-reviewer agent.+---++# Rust Code Review++This command invokes the **rust-reviewer** agent for comprehensive Rust-specific code review.++## What This Command Does++1. **Verify Automated Checks**: Run `cargo check`, `cargo clippy -- -D warnings`, `cargo fmt --check`, and `cargo test` — stop if any fail+2. **Identify Rust Changes**: Find modified `.rs` files via `git diff HEAD~1` (or `git diff main...HEAD` for PRs)+3. **Run Security Audit**: Execute `cargo audit` if available+4. **Security Scan**: Check for unsafe usage, command injection, hardcoded secrets+5. **Ownership Review**: Analyze unnecessary clones, lifetime issues, borrowing patterns+6. **Generate Report**: Categorize issues by severity++## When to Use++Use `/rust-review` when:+- After writing or modifying Rust code+- Before committing Rust changes+- Reviewing pull requests with Rust code+- Onboarding to a new Rust codebase+- Learning idiomatic Rust patterns++## Review Categories++### CRITICAL (Must Fix)+- Unchecked `unwrap()`/`expect()` in production code paths+- `unsafe` without `// SAFETY:` comment documenting invariants+- SQL injection via string interpolation in queries+- Command injection via unvalidated input in `std::process::Command`+- Hardcoded credentials+- Use-after-free via raw pointers++### HIGH (Should Fix)+- Unnecessary `.clone()` to satisfy borrow checker+- `String` parameter where `&str` or `impl AsRef<str>` suffices+- Blocking in async context (`std::thread::sleep`, `std::fs`)+- Missing `Send`/`Sync` bounds on shared types+- Wildcard `_ =>` match on business-critical enums+- Large functions (>50 lines)++### MEDIUM (Consider)+- Unnecessary allocation in hot paths+- Missing `with_capacity` when size is known+- Suppressed clippy warnings without justification+- Public API without `///` documentation+- Consider `#[must_use]` on non-`must_use` return types where ignoring values is likely a bug++## Automated Checks Run++```bash+# Build gate (must pass before review)+cargo check++# Lints and suggestions+cargo clippy -- -D warnings++# Formatting+cargo fmt --check++# Tests+cargo test++# Security audit (if available)+if command -v cargo-audit >/dev/null; then cargo audit; else echo "cargo-audit not installed"; fi+```++## Example Usage++````text+User: /rust-review++Agent:+# Rust Code Review Report++## Files Reviewed+- src/service/user.rs (modified)+- src/handler/api.rs (modified)++## Static Analysis Results+- Build: Successful+- Clippy: No warnings+- Formatting: Passed+- Tests: All passing++## Issues Found++[CRITICAL] Unchecked unwrap in Production Path+File: src/service/user.rs:28+Issue: Using `.unwrap()` on database query result+```rust+let user = db.find_by_id(id).unwrap(); // Panics on missing user+```+Fix: Propagate error with context+```rust+let user = db.find_by_id(id)+ .context("failed to fetch user")?;+```++[HIGH] Unnecessary Clone+File: src/handler/api.rs:45+Issue: Cloning String to satisfy borrow checker+```rust+let name = user.name.clone();+process(&user, &name);+```+Fix: Restructure to avoid clone+```rust+let result = process_name(&user.name);+use_user(&user, result);+```++## Summary+- CRITICAL: 1+- HIGH: 1+- MEDIUM: 0++Recommendation: Block merge until CRITICAL issue is fixed+````++## Approval Criteria++| Status | Condition |+|--------|-----------|+| Approve | No CRITICAL or HIGH issues |+| Warning | Only MEDIUM issues (merge with caution) |+| Block | CRITICAL or HIGH issues found |++## Integration with Other Commands++- Use `/rust-test` first to ensure tests pass+- Use `/rust-build` if build errors occur+- Use `/rust-review` before committing+- Use `/code-review` for non-Rust-specific concerns++## Related++- Agent: `agents/rust-reviewer.md`+- Skills: `skills/rust-patterns/`, `skills/rust-testing/`diff --git a/commands/rust-test.md b/commands/rust-test.mdnew file mode 100644index 000000000..8a238479b--- /dev/null+++ b/commands/rust-test.md@@ -0,0 +1,308 @@+---+description: Enforce TDD workflow for Rust. Write tests first, then implement. Verify 80%+ coverage with cargo-llvm-cov.+---++# Rust TDD Command++This command enforces test-driven development methodology for Rust code using `#[test]`, rstest, proptest, and mockall.++## What This Command Does++1. **Define Types/Traits**: Scaffold function signatures with `todo!()`+2. **Write Tests**: Create comprehensive test module (RED)+3. **Run Tests**: Verify tests fail for the right reason+4. **Implement Code**: Write minimal code to pass (GREEN)+5. **Refactor**: Improve while keeping tests green+6. **Check Coverage**: Ensure 80%+ coverage with cargo-llvm-cov++## When to Use++Use `/rust-test` when:+- Implementing new Rust functions, methods, or traits+- Adding test coverage to existing Rust code+- Fixing bugs (write failing test first)+- Building critical business logic+- Learning TDD workflow in Rust++## TDD Cycle++```+RED -> Write failing test first+GREEN -> Implement minimal code to pass+REFACTOR -> Improve code, tests stay green+REPEAT -> Next test case+```++## Example Session++````text+User: /rust-test I need a function to validate user registration++Agent:+# TDD Session: Registration Validator++## Step 1: Define Interface++```rust+// src/validator.rs+pub struct RegistrationRequest {+ pub name: String,+ pub email: String,+ pub password: String,+}++pub enum ValidationResult {+ Valid,+ Invalid(Vec<String>),+}++pub fn validate_registration(request: &RegistrationRequest) -> ValidationResult {+ todo!()+}+```++## Step 2: Write Tests (RED)++```rust+#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn valid_registration_returns_valid() {+ let request = RegistrationRequest {+ name: "Alice".into(),+ email: "[email protected]".into(),+ password: "SecureP@ss1".into(),+ };+ assert!(matches!(validate_registration(&request), ValidationResult::Valid));+ }++ #[test]+ fn blank_name_returns_invalid() {+ let request = RegistrationRequest {+ name: "".into(),+ email: "[email protected]".into(),+ password: "SecureP@ss1".into(),+ };+ match validate_registration(&request) {+ ValidationResult::Invalid(errors) => {+ assert!(errors.contains(&"Name is required".to_string()));+ }+ ValidationResult::Valid => panic!("expected Invalid"),+ }+ }++ #[test]+ fn invalid_email_returns_invalid() {+ let request = RegistrationRequest {+ name: "Alice".into(),+ email: "not-an-email".into(),+ password: "SecureP@ss1".into(),+ };+ assert!(matches!(+ validate_registration(&request),+ ValidationResult::Invalid(_)+ ));+ }++ #[test]+ fn short_password_returns_invalid() {+ let request = RegistrationRequest {+ name: "Alice".into(),+ email: "[email protected]".into(),+ password: "short".into(),+ };+ assert!(matches!(+ validate_registration(&request),+ ValidationResult::Invalid(_)+ ));+ }+}+```++## Step 3: Run Tests — Verify FAIL++```bash+$ cargo test+running 4 tests+test tests::valid_registration_returns_valid ... FAILED (not yet implemented)+test tests::blank_name_returns_invalid ... FAILED+test tests::invalid_email_returns_invalid ... FAILED+test tests::short_password_returns_invalid ... FAILED+```++Tests fail as expected (todo! panic).++## Step 4: Implement Minimal Code (GREEN)++```rust+pub fn validate_registration(request: &RegistrationRequest) -> ValidationResult {+ let mut errors = Vec::new();++ if request.name.trim().is_empty() {+ errors.push("Name is required".into());+ }+ if !request.email.contains('@') {+ errors.push("Invalid email format".into());+ }+ if request.password.len() < 8 {+ errors.push("Password must be at least 8 characters".into());+ }++ if errors.is_empty() {+ ValidationResult::Valid+ } else {+ ValidationResult::Invalid(errors)+ }+}+```++## Step 5: Run Tests — Verify PASS++```bash+$ cargo test+running 4 tests+test tests::valid_registration_returns_valid ... ok+test tests::blank_name_returns_invalid ... ok+test tests::invalid_email_returns_invalid ... ok+test tests::short_password_returns_invalid ... ok++test result: ok. 4 passed; 0 failed+```++All tests passing!++## Step 6: Check Coverage++```bash+$ cargo llvm-cov+Coverage: 100.0% of lines+```++Coverage: 100%++## TDD Complete!+````++## Test Patterns++### Unit Tests++```rust+#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn adds_two_numbers() {+ assert_eq!(add(2, 3), 5);+ }++ #[test]+ fn handles_error() -> Result<(), Box<dyn std::error::Error>> {+ let result = parse_config(r#"port = 8080"#)?;+ assert_eq!(result.port, 8080);+ Ok(())+ }+}+```++### Parameterized Tests with rstest++```rust+use rstest::{rstest, fixture};++#[rstest]+#[case("hello", 5)]+#[case("", 0)]+#[case("rust", 4)]+fn test_string_length(#[case] input: &str, #[case] expected: usize) {+ assert_eq!(input.len(), expected);+}+```++### Async Tests++```rust+#[tokio::test]+async fn fetches_data_successfully() {+ let client = TestClient::new().await;+ let result = client.get("/data").await;+ assert!(result.is_ok());+}+```++### Property-Based Tests++```rust+use proptest::prelude::*;++proptest! {+ #[test]+ fn encode_decode_roundtrip(input in ".*") {+ let encoded = encode(&input);+ let decoded = decode(&encoded).unwrap();+ assert_eq!(input, decoded);+ }+}+```++## Coverage Commands++```bash+# Summary report+cargo llvm-cov++# HTML report+cargo llvm-cov --html++# Fail if below threshold+cargo llvm-cov --fail-under-lines 80++# Run specific test+cargo test test_name++# Run with output+cargo test -- --nocapture++# Run without stopping on first failure+cargo test --no-fail-fast+```++## Coverage Targets++| Code Type | Target |+|-----------|--------|+| Critical business logic | 100% |+| Public API | 90%+ |+| General code | 80%+ |+| Generated / FFI bindings | Exclude |++## TDD Best Practices++**DO:**+- Write test FIRST, before any implementation+- Run tests after each change+- Use `assert_eq!` over `assert!` for better error messages+- Use `?` in tests that return `Result` for cleaner output+- Test behavior, not implementation+- Include edge cases (empty, boundary, error paths)++**DON'T:**+- Write implementation before tests+- Skip the RED phase+- Use `#[should_panic]` when `Result::is_err()` works+- Use `sleep()` in tests — use channels or `tokio::time::pause()`+- Mock everything — prefer integration tests when feasible++## Related Commands++- `/rust-build` - Fix build errors+- `/rust-review` - Review code after implementation+- `/verify` - Run full verification loop++## Related++- Skill: `skills/rust-testing/`+- Skill: `skills/rust-patterns/`diff --git a/skills/rust-patterns/SKILL.md b/skills/rust-patterns/SKILL.mdnew file mode 100644index 000000000..a9427da19--- /dev/null+++ b/skills/rust-patterns/SKILL.md@@ -0,0 +1,500 @@+---+name: rust-patterns+description: Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications.+origin: ECC+---++# Rust Development Patterns++Idiomatic Rust patterns and best practices for building safe, performant, and maintainable applications.++## When to Use++- Writing new Rust code+- Reviewing Rust code+- Refactoring existing Rust code+- Designing crate structure and module layout++## How It Works++This skill enforces idiomatic Rust conventions across six key areas: ownership and borrowing to prevent data races at compile time, `Result`/`?` error propagation with `thiserror` for libraries and `anyhow` for applications, enums and exhaustive pattern matching to make illegal states unrepresentable, traits and generics for zero-cost abstraction, safe concurrency via `Arc<Mutex<T>>`, channels, and async/await, and minimal `pub` surfaces organized by domain.++## Core Principles++### 1. Ownership and Borrowing++Rust's ownership system prevents data races and memory bugs at compile time.++```rust+// Good: Pass references when you don't need ownership+fn process(data: &[u8]) -> usize {+ data.len()+}++// Good: Take ownership only when you need to store or consume+fn store(data: Vec<u8>) -> Record {+ Record { payload: data }+}++// Bad: Cloning unnecessarily to avoid borrow checker+fn process_bad(data: &Vec<u8>) -> usize {+ let cloned = data.clone(); // Wasteful — just borrow+ cloned.len()+}+```+++### Use `Cow` for Flexible Ownership++```rust+use std::borrow::Cow;++fn normalize(input: &str) -> Cow<'_, str> {+ if input.contains(' ') {+ Cow::Owned(input.replace(' ', "_"))+ } else {+ Cow::Borrowed(input) // Zero-cost when no mutation needed+ }+}+```++## Error Handling++### Use `Result` and `?` — Never `unwrap()` in Production++```rust+// Good: Propagate errors with context+use anyhow::{Context, Result};++fn load_config(path: &str) -> Result<Config> {+ let content = std::fs::read_to_string(path)+ .with_context(|| format!("failed to read config from {path}"))?;+ let config: Config = toml::from_str(&content)+ .with_context(|| format!("failed to parse config from {path}"))?;+ Ok(config)+}++// Bad: Panics on error+fn load_config_bad(path: &str) -> Config {+ let content = std::fs::read_to_string(path).unwrap(); // Panics!+ toml::from_str(&content).unwrap()+}+```++### Library Errors with `thiserror`, Application Errors with `anyhow`++```rust+// Library code: structured, typed errors+use thiserror::Error;++#[derive(Debug, Error)]+pub enum StorageError {+ #[error("record not found: {id}")]+ NotFound { id: String },+ #[error("connection failed")]+ Connection(#[from] std::io::Error),+ #[error("invalid data: {0}")]+ InvalidData(String),+}++// Application code: flexible error handling+use anyhow::{bail, Result};++fn run() -> Result<()> {+ let config = load_config("app.toml")?;+ if config.workers == 0 {+ bail!("worker count must be > 0");+ }+ Ok(())+}+```++### `Option` Combinators Over Nested Matching++```rust+// Good: Combinator chain+fn find_user_email(users: &[User], id: u64) -> Option<String> {+ users.iter()+ .find(|u| u.id == id)+ .map(|u| u.email.clone())+}++// Bad: Deeply nested matching+fn find_user_email_bad(users: &[User], id: u64) -> Option<String> {+ match users.iter().find(|u| u.id == id) {+ Some(user) => match &user.email {+ email => Some(email.clone()),+ },+ None => None,+ }+}+```++## Enums and Pattern Matching++### Model States as Enums++```rust+// Good: Impossible states are unrepresentable+enum ConnectionState {+ Disconnected,+ Connecting { attempt: u32 },+ Connected { session_id: String },+ Failed { reason: String, retries: u32 },+}++fn handle(state: &ConnectionState) {+ match state {+ ConnectionState::Disconnected => connect(),+ ConnectionState::Connecting { attempt } if *attempt > 3 => abort(),+ ConnectionState::Connecting { .. } => wait(),+ ConnectionState::Connected { session_id } => use_session(session_id),+ ConnectionState::Failed { retries, .. } if *retries < 5 => retry(),+ ConnectionState::Failed { reason, .. } => log_failure(reason),+ }+}+```++### Exhaustive Matching — No Catch-All for Business Logic++```rust+// Good: Handle every variant explicitly+match command {+ Command::Start => start_service(),+ Command::Stop => stop_service(),+ Command::Restart => restart_service(),+ // Adding a new variant forces handling here+}++// Bad: Wildcard hides new variants+match command {+ Command::Start => start_service(),+ _ => {} // Silently ignores Stop, Restart, and future variants+}+```++## Traits and Generics++### Accept Generics, Return Concrete Types++```rust+// Good: Generic input, concrete output+fn read_all(reader: &mut impl Read) -> std::io::Result<Vec<u8>> {+ let mut buf = Vec::new();+ reader.read_to_end(&mut buf)?;+ Ok(buf)+}++// Good: Trait bounds for multiple constraints+fn process<T: Display + Send + 'static>(item: T) -> String {+ format!("processed: {item}")+}+```++### Trait Objects for Dynamic Dispatch++```rust+// Use when you need heterogeneous collections or plugin systems+trait Handler: Send + Sync {+ fn handle(&self, request: &Request) -> Response;+}++struct Router {+ handlers: Vec<Box<dyn Handler>>,+}++// Use generics when you need performance (monomorphization)+fn fast_process<H: Handler>(handler: &H, request: &Request) -> Response {+ handler.handle(request)+}+```++### Newtype Pattern for Type Safety++```rust+// Good: Distinct types prevent mixing up arguments+struct UserId(u64);+struct OrderId(u64);++fn get_order(user: UserId, order: OrderId) -> Result<Order> {+ // Can't accidentally swap user and order IDs+ todo!()+}++// Bad: Easy to swap arguments+fn get_order_bad(user_id: u64, order_id: u64) -> Result<Order> {+ todo!()+}+```++## Structs and Data Modeling++### Builder Pattern for Complex Construction++```rust+struct ServerConfig {+ host: String,+ port: u16,+ max_connections: usize,+}++impl ServerConfig {+ fn builder(host: impl Into<String>, port: u16) -> ServerConfigBuilder {+ ServerConfigBuilder { host: host.into(), port, max_connections: 100 }+ }+}++struct ServerConfigBuilder { host: String, port: u16, max_connections: usize }++impl ServerConfigBuilder {+ fn max_connections(mut self, n: usize) -> Self { self.max_connections = n; self }+ fn build(self) -> ServerConfig {+ ServerConfig { host: self.host, port: self.port, max_connections: self.max_connections }+ }+}++// Usage: ServerConfig::builder("localhost", 8080).max_connections(200).build()+```++## Iterators and Closures++### Prefer Iterator Chains Over Manual Loops++```rust+// Good: Declarative, lazy, composable+let active_emails: Vec<String> = users.iter()+ .filter(|u| u.is_active)+ .map(|u| u.email.clone())+ .collect();++// Bad: Imperative accumulation+let mut active_emails = Vec::new();+for user in &users {+ if user.is_active {+ active_emails.push(user.email.clone());+ }+}+```++### Use `collect()` with Type Annotation++```rust+// Collect into different types+let names: Vec<_> = items.iter().map(|i| &i.name).collect();+let lookup: HashMap<_, _> = items.iter().map(|i| (i.id, i)).collect();+let combined: String = parts.iter().copied().collect();++// Collect Results — short-circuits on first error+let parsed: Result<Vec<i32>, _> = strings.iter().map(|s| s.parse()).collect();+```++## Concurrency++### `Arc<Mutex<T>>` for Shared Mutable State++```rust+use std::sync::{Arc, Mutex};++let counter = Arc::new(Mutex::new(0));+let handles: Vec<_> = (0..10).map(|_| {+ let counter = Arc::clone(&counter);+ std::thread::spawn(move || {+ let mut num = counter.lock().expect("mutex poisoned");+ *num += 1;+ })+}).collect();++for handle in handles {+ handle.join().expect("worker thread panicked");+}+```++### Channels for Message Passing++```rust+use std::sync::mpsc;++let (tx, rx) = mpsc::sync_channel(16); // Bounded channel with backpressure++for i in 0..5 {+ let tx = tx.clone();+ std::thread::spawn(move || {+ tx.send(format!("message {i}")).expect("receiver disconnected");+ });+}+drop(tx); // Close sender so rx iterator terminates++for msg in rx {+ println!("{msg}");+}+```++### Async with Tokio++```rust+use tokio::time::Duration;++async fn fetch_with_timeout(url: &str) -> Result<String> {+ let response = tokio::time::timeout(+ Duration::from_secs(5),+ reqwest::get(url),+ )+ .await+ .context("request timed out")?+ .context("request failed")?;++ response.text().await.context("failed to read body")+}++// Spawn concurrent tasks+async fn fetch_all(urls: Vec<String>) -> Vec<Result<String>> {+ let handles: Vec<_> = urls.into_iter()+ .map(|url| tokio::spawn(async move {+ fetch_with_timeout(&url).await+ }))+ .collect();++ let mut results = Vec::with_capacity(handles.len());+ for handle in handles {+ results.push(handle.await.unwrap_or_else(|e| panic!("spawned task panicked: {e}")));+ }+ results+}+```++## Unsafe Code++### When Unsafe Is Acceptable++```rust+// Acceptable: FFI boundary with documented invariants (Rust 2024+)+/// # Safety+/// `ptr` must be a valid, aligned pointer to an initialized `Widget`.+unsafe fn widget_from_raw<'a>(ptr: *const Widget) -> &'a Widget {+ // SAFETY: caller guarantees ptr is valid and aligned+ unsafe { &*ptr }+}++// Acceptable: Performance-critical path with proof of correctness+// SAFETY: index is always < len due to the loop bound+unsafe { slice.get_unchecked(index) }+```++### When Unsafe Is NOT Acceptable++```rust+// Bad: Using unsafe to bypass borrow checker+// Bad: Using unsafe for convenience+// Bad: Using unsafe without a Safety comment+// Bad: Transmuting between unrelated types+```++## Module System and Crate Structure++### Organize by Domain, Not by Type++```text+my_app/+├── src/+│ ├── main.rs+│ ├── lib.rs+│ ├── auth/ # Domain module+│ │ ├── mod.rs+│ │ ├── token.rs+│ │ └── middleware.rs+│ ├── orders/ # Domain module+│ │ ├── mod.rs+│ │ ├── model.rs+│ │ └── service.rs+│ └── db/ # Infrastructure+│ ├── mod.rs+│ └── pool.rs+├── tests/ # Integration tests+├── benches/ # Benchmarks+└── Cargo.toml+```++### Visibility — Expose Minimally++```rust+// Good: pub(crate) for internal sharing+pub(crate) fn validate_input(input: &str) -> bool {+ !input.is_empty()+}++// Good: Re-export public API from lib.rs+pub mod auth;+pub use auth::AuthMiddleware;++// Bad: Making everything pub+pub fn internal_helper() {} // Should be pub(crate) or private+```++## Tooling Integration++### Essential Commands++```bash+# Build and check+cargo build+cargo check # Fast type checking without codegen+cargo clippy # Lints and suggestions+cargo fmt # Format code++# Testing+cargo test+cargo test -- --nocapture # Show println output+cargo test --lib # Unit tests only+cargo test --test integration # Integration tests only++# Dependencies+cargo audit # Security audit+cargo tree # Dependency tree+cargo update # Update dependencies++# Performance+cargo bench # Run benchmarks+```++## Quick Reference: Rust Idioms++| Idiom | Description |+|-------|-------------|+| Borrow, don't clone | Pass `&T` instead of cloning unless ownership is needed |+| Make illegal states unrepresentable | Use enums to model valid states only |+| `?` over `unwrap()` | Propagate errors, never panic in library/production code |+| Parse, don't validate | Convert unstructured data to typed structs at the boundary |+| Newtype for type safety | Wrap primitives in newtypes to prevent argument swaps |+| Prefer iterators over loops | Declarative chains are clearer and often faster |+| `#[must_use]` on Results | Ensure callers handle return values |+| `Cow` for flexible ownership | Avoid allocations when borrowing suffices |+| Exhaustive matching | No wildcard `_` for business-critical enums |+| Minimal `pub` surface | Use `pub(crate)` for internal APIs |++## Anti-Patterns to Avoid++```rust+// Bad: .unwrap() in production code+let value = map.get("key").unwrap();++// Bad: .clone() to satisfy borrow checker without understanding why+let data = expensive_data.clone();+process(&original, &data);++// Bad: Using String when &str suffices+fn greet(name: String) { /* should be &str */ }++// Bad: Box<dyn Error> in libraries (use thiserror instead)+fn parse(input: &str) -> Result<Data, Box<dyn std::error::Error>> { todo!() }++// Bad: Ignoring must_use warnings+let _ = validate(input); // Silently discarding a Result++// Bad: Blocking in async context+async fn bad_async() {+ std::thread::sleep(Duration::from_secs(1)); // Blocks the executor!+ // Use: tokio::time::sleep(Duration::from_secs(1)).await;+}+```++**Remember**: If it compiles, it's probably correct — but only if you avoid `unwrap()`, minimize `unsafe`, and let the type system work for you.diff --git a/skills/rust-testing/SKILL.md b/skills/rust-testing/SKILL.mdnew file mode 100644index 000000000..21b484a1c--- /dev/null+++ b/skills/rust-testing/SKILL.md@@ -0,0 +1,500 @@+---+name: rust-testing+description: Rust testing patterns including unit tests, integration tests, async testing, property-based testing, mocking, and coverage. Follows TDD methodology.+origin: ECC+---++# Rust Testing Patterns++Comprehensive Rust testing patterns for writing reliable, maintainable tests following TDD methodology.++## When to Use++- Writing new Rust functions, methods, or traits+- Adding test coverage to existing code+- Creating benchmarks for performance-critical code+- Implementing property-based tests for input validation+- Following TDD workflow in Rust projects++## How It Works++1. **Identify target code** — Find the function, trait, or module to test+2. **Write a test** — Use `#[test]` in a `#[cfg(test)]` module, rstest for parameterized tests, or proptest for property-based tests+3. **Mock dependencies** — Use mockall to isolate the unit under test+4. **Run tests (RED)** — Verify the test fails with the expected error+5. **Implement (GREEN)** — Write minimal code to pass+6. **Refactor** — Improve while keeping tests green+7. **Check coverage** — Use cargo-llvm-cov, target 80%+++## TDD Workflow for Rust++### The RED-GREEN-REFACTOR Cycle++```+RED → Write a failing test first+GREEN → Write minimal code to pass the test+REFACTOR → Improve code while keeping tests green+REPEAT → Continue with next requirement+```++### Step-by-Step TDD in Rust++```rust+// RED: Write test first, use todo!() as placeholder+pub fn add(a: i32, b: i32) -> i32 { todo!() }++#[cfg(test)]+mod tests {+ use super::*;+ #[test]+ fn test_add() { assert_eq!(add(2, 3), 5); }+}+// cargo test → panics at 'not yet implemented'+```++```rust+// GREEN: Replace todo!() with minimal implementation+pub fn add(a: i32, b: i32) -> i32 { a + b }+// cargo test → PASS, then REFACTOR while keeping tests green+```++## Unit Tests++### Module-Level Test Organization++```rust+// src/user.rs+pub struct User {+ pub name: String,+ pub email: String,+}++impl User {+ pub fn new(name: impl Into<String>, email: impl Into<String>) -> Result<Self, String> {+ let email = email.into();+ if !email.contains('@') {+ return Err(format!("invalid email: {email}"));+ }+ Ok(Self { name: name.into(), email })+ }++ pub fn display_name(&self) -> &str {+ &self.name+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn creates_user_with_valid_email() {+ let user = User::new("Alice", "[email protected]").unwrap();+ assert_eq!(user.display_name(), "Alice");+ assert_eq!(user.email, "[email protected]");+ }++ #[test]+ fn rejects_invalid_email() {+ let result = User::new("Bob", "not-an-email");+ assert!(result.is_err());+ assert!(result.unwrap_err().contains("invalid email"));+ }+}+```++### Assertion Macros++```rust+assert_eq!(2 + 2, 4); // Equality+assert_ne!(2 + 2, 5); // Inequality+assert!(vec![1, 2, 3].contains(&2)); // Boolean+assert_eq!(value, 42, "expected 42 but got {value}"); // Custom message+assert!((0.1_f64 + 0.2 - 0.3).abs() < f64::EPSILON); // Float comparison+```++## Error and Panic Testing++### Testing `Result` Returns++```rust+#[test]+fn parse_returns_error_for_invalid_input() {+ let result = parse_config("}{invalid");+ assert!(result.is_err());++ // Assert specific error variant+ let err = result.unwrap_err();+ assert!(matches!(err, ConfigError::ParseError(_)));+}++#[test]+fn parse_succeeds_for_valid_input() -> Result<(), Box<dyn std::error::Error>> {+ let config = parse_config(r#"{"port": 8080}"#)?;+ assert_eq!(config.port, 8080);+ Ok(()) // Test fails if any ? returns Err+}+```++### Testing Panics++```rust+#[test]+#[should_panic]+fn panics_on_empty_input() {+ process(&[]);+}++#[test]+#[should_panic(expected = "index out of bounds")]+fn panics_with_specific_message() {+ let v: Vec<i32> = vec![];+ let _ = v[0];+}+```++## Integration Tests++### File Structure++```text+my_crate/+├── src/+│ └── lib.rs+├── tests/ # Integration tests+│ ├── api_test.rs # Each file is a separate test binary+│ ├── db_test.rs+│ └── common/ # Shared test utilities+│ └── mod.rs+```++### Writing Integration Tests++```rust+// tests/api_test.rs+use my_crate::{App, Config};++#[test]+fn full_request_lifecycle() {+ let config = Config::test_default();+ let app = App::new(config);++ let response = app.handle_request("/health");+ assert_eq!(response.status, 200);+ assert_eq!(response.body, "OK");+}+```++## Async Tests++### With Tokio++```rust+#[tokio::test]+async fn fetches_data_successfully() {+ let client = TestClient::new().await;+ let result = client.get("/data").await;+ assert!(result.is_ok());+ assert_eq!(result.unwrap().items.len(), 3);+}++#[tokio::test]+async fn handles_timeout() {+ use std::time::Duration;+ let result = tokio::time::timeout(+ Duration::from_millis(100),+ slow_operation(),+ ).await;++ assert!(result.is_err(), "should have timed out");+}+```++## Test Organization Patterns++### Parameterized Tests with `rstest`++```rust+use rstest::{rstest, fixture};++#[rstest]+#[case("hello", 5)]+#[case("", 0)]+#[case("rust", 4)]+fn test_string_length(#[case] input: &str, #[case] expected: usize) {+ assert_eq!(input.len(), expected);+}++// Fixtures+#[fixture]+fn test_db() -> TestDb {+ TestDb::new_in_memory()+}++#[rstest]+fn test_insert(test_db: TestDb) {+ test_db.insert("key", "value");+ assert_eq!(test_db.get("key"), Some("value".into()));+}+```++### Test Helpers++```rust+#[cfg(test)]+mod tests {+ use super::*;++ /// Creates a test user with sensible defaults.+ fn make_user(name: &str) -> User {+ User::new(name, &format!("{name}@test.com")).unwrap()+ }++ #[test]+ fn user_display() {+ let user = make_user("alice");+ assert_eq!(user.display_name(), "alice");+ }+}+```++## Property-Based Testing with `proptest`++### Basic Property Tests++```rust+use proptest::prelude::*;++proptest! {+ #[test]+ fn encode_decode_roundtrip(input in ".*") {+ let encoded = encode(&input);+ let decoded = decode(&encoded).unwrap();+ assert_eq!(input, decoded);+ }++ #[test]+ fn sort_preserves_length(mut vec in prop::collection::vec(any::<i32>(), 0..100)) {+ let original_len = vec.len();+ vec.sort();+ assert_eq!(vec.len(), original_len);+ }++ #[test]+ fn sort_produces_ordered_output(mut vec in prop::collection::vec(any::<i32>(), 0..100)) {+ vec.sort();+ for window in vec.windows(2) {+ assert!(window[0] <= window[1]);+ }+ }+}+```++### Custom Strategies++```rust+use proptest::prelude::*;++fn valid_email() -> impl Strategy<Value = String> {+ ("[a-z]{1,10}", "[a-z]{1,5}")+ .prop_map(|(user, domain)| format!("{user}@{domain}.com"))+}++proptest! {+ #[test]+ fn accepts_valid_emails(email in valid_email()) {+ assert!(User::new("Test", &email).is_ok());+ }+}+```++## Mocking with `mockall`++### Trait-Based Mocking++```rust+use mockall::{automock, predicate::eq};++#[automock]+trait UserRepository {+ fn find_by_id(&self, id: u64) -> Option<User>;+ fn save(&self, user: &User) -> Result<(), StorageError>;+}++#[test]+fn service_returns_user_when_found() {+ let mut mock = MockUserRepository::new();+ mock.expect_find_by_id()+ .with(eq(42))+ .times(1)+ .returning(|_| Some(User { id: 42, name: "Alice".into() }));++ let service = UserService::new(Box::new(mock));+ let user = service.get_user(42).unwrap();+ assert_eq!(user.name, "Alice");+}++#[test]+fn service_returns_none_when_not_found() {+ let mut mock = MockUserRepository::new();+ mock.expect_find_by_id()+ .returning(|_| None);++ let service = UserService::new(Box::new(mock));+ assert!(service.get_user(99).is_none());+}+```++## Doc Tests++### Executable Documentation++```rust+/// Adds two numbers together.+///+/// # Examples+///+/// ```+/// use my_crate::add;+///+/// assert_eq!(add(2, 3), 5);+/// assert_eq!(add(-1, 1), 0);+/// ```+pub fn add(a: i32, b: i32) -> i32 {+ a + b+}++/// Parses a config string.+///+/// # Errors+///+/// Returns `Err` if the input is not valid TOML.+///+/// ```no_run+/// use my_crate::parse_config;+///+/// let config = parse_config(r#"port = 8080"#).unwrap();+/// assert_eq!(config.port, 8080);+/// ```+///+/// ```no_run+/// use my_crate::parse_config;+///+/// assert!(parse_config("}{invalid").is_err());+/// ```+pub fn parse_config(input: &str) -> Result<Config, ParseError> {+ todo!()+}+```++## Benchmarking with Criterion++```toml+# Cargo.toml+[dev-dependencies]+criterion = { version = "0.5", features = ["html_reports"] }++[[bench]]+name = "benchmark"+harness = false+```++```rust+// benches/benchmark.rs+use criterion::{black_box, criterion_group, criterion_main, Criterion};++fn fibonacci(n: u64) -> u64 {+ match n {+ 0 | 1 => n,+ _ => fibonacci(n - 1) + fibonacci(n - 2),+ }+}++fn bench_fibonacci(c: &mut Criterion) {+ c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));+}++criterion_group!(benches, bench_fibonacci);+criterion_main!(benches);+```++## Test Coverage++### Running Coverage++```bash+# Install: cargo install cargo-llvm-cov (or use taiki-e/install-action in CI)+cargo llvm-cov # Summary+cargo llvm-cov --html # HTML report+cargo llvm-cov --lcov > lcov.info # LCOV format for CI+cargo llvm-cov --fail-under-lines 80 # Fail if below threshold+```++### Coverage Targets++| Code Type | Target |+|-----------|--------|+| Critical business logic | 100% |+| Public API | 90%+ |+| General code | 80%+ |+| Generated / FFI bindings | Exclude |++## Testing Commands++```bash+cargo test # Run all tests+cargo test -- --nocapture # Show println output+cargo test test_name # Run tests matching pattern+cargo test --lib # Unit tests only+cargo test --test api_test # Integration tests only+cargo test --doc # Doc tests only+cargo test --no-fail-fast # Don't stop on first failure+cargo test -- --ignored # Run ignored tests+```++## Best Practices++**DO:**+- Write tests FIRST (TDD)+- Use `#[cfg(test)]` modules for unit tests+- Test behavior, not implementation+- Use descriptive test names that explain the scenario+- Prefer `assert_eq!` over `assert!` for better error messages+- Use `?` in tests that return `Result` for cleaner error output+- Keep tests independent — no shared mutable state++**DON'T:**+- Use `#[should_panic]` when you can test `Result::is_err()` instead+- Mock everything — prefer integration tests when feasible+- Ignore flaky tests — fix or quarantine them+- Use `sleep()` in tests — use channels, barriers, or `tokio::time::pause()`+- Skip error path testing++## CI Integration++```yaml+# GitHub Actions+test:+ runs-on: ubuntu-latest+ steps:+ - uses: actions/checkout@v4+ - uses: dtolnay/rust-toolchain@stable+ with:+ components: clippy, rustfmt++ - name: Check formatting+ run: cargo fmt --check++ - name: Clippy+ run: cargo clippy -- -D warnings++ - name: Run tests+ run: cargo test++ - uses: taiki-e/install-action@cargo-llvm-cov++ - name: Coverage+ run: cargo llvm-cov --fail-under-lines 80+```++**Remember**: Tests are documentation. They show how your code is meant to be used. Write them clearly and keep them up to date.