Implement Feature Command

Implement Feature Command

Implement features to pass specified tests following Test-Driven Development workflow with multi-component integration support.

Usage

`/implement-feature [feature-type] [integration-points] [tdd-phase]`

Parameters

• test-path (required): Path to test file or test module (e.g., tests/crypto/ml_kem_test.rs)
• feature-type (optional): Type of feature - crypto, network, dag, protocol, integration
• integration-points (optional): Components that need integration - crypto, dag, network, protocol (comma-separated)
• tdd-phase (optional): TDD phase to execute - red, green, refactor, all (default: all)

Instructions

When this command is invoked:

1. **Analyze test requirements and integration needs**:

   • Read the specified test file to understand requirements
   • Identify expected behavior and API contracts
   • Map integration points if multi-component test
   • Determine implementation scope and dependencies

2. **Execute TDD workflow phases**:

   RED Phase - Ensure tests fail appropriately

   # Run tests to verify they fail as expected
   cargo test --test $(basename $test_path .rs) -- --nocapture
   
   # Analyze failure patterns
   # Document expected behavior
   # Identify missing implementations

   GREEN Phase - Implement minimal code to pass tests

   # Create/modify implementation files
   # Add core functionality
   # Handle edge cases from tests
   # Ensure all tests pass
   cargo test --test $(basename $test_path .rs)

   REFACTOR Phase - Optimize and clean up

   # Improve code structure
   # Optimize performance
   # Enhance documentation
   # Verify tests still pass
   cargo test --workspace

3. **Implement feature based on test type**:

   Unit Test Implementation

   // Implement in appropriate module
   pub struct FeatureName {
       // Internal state
   }
   
   impl FeatureName {
       pub fn new() -> Self {
           // Constructor implementation
       }
       
       pub fn operation(&self) -> Result {
           // Core functionality matching test expectations
       }
   }

   Integration Test Implementation

   // Integration layer implementation
   pub struct IntegratedFeature {
       crypto: Arc,
       network: Arc,
       dag: Arc,
   }
   
   impl IntegratedFeature {
       pub async fn execute(&self) -> Result<()> {
           // Coordinate components
           let crypto_result = self.crypto.process().await?;
           let network_result = self.network.send(crypto_result).await?;
           let dag_result = self.dag.add_transaction(network_result).await?;
           Ok(())
       }
   }

4. **Coordinate multi-agent implementation**:

   • Integration agent coordinates overall implementation
   • Delegate component-specific work to specialist agents:
     • crypto_agent: Crypt