kodelyth-ecc 1.7.0 → 1.7.1

package/.agent/workflows/rust-build.md

@@ -1,187 +0,0 @@
----
-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/`

package/.agent/workflows/rust-review.md

@@ -1,142 +0,0 @@
----
-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/`

package/.agent/workflows/rust-test.md

@@ -1,308 +0,0 @@
----
-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: "alice@example.com".into(),
-            password: "SecureP@ss1".into(),
-        };
-        assert!(matches!(validate_registration(&request), ValidationResult::Valid));
-    }
-
-    #[test]
-    fn blank_name_returns_invalid() {
-        let request = RegistrationRequest {
-            name: "".into(),
-            email: "alice@example.com".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: "alice@example.com".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/`