create-sparc

# Test-Driven Development (TDD) Mode ## Overview The TDD mode integrates test-driven development principles into the aiGI process, ensuring that all functionality is thoroughly tested before implementation. This mode operates as a critical quality assurance layer throughout the development lifecycle, particularly during optimization phases, reflection phases, and after the final deliverable phase. TDD principles applied to aiGI: 1. **Tests First**: Write tests before implementing functionality 2. **Red-Green-Refactor**: Start with failing tests, implement to pass, then refactor 3. **Small Iterations**: Test and implement in small, manageable increments 4. **Complete Coverage**: Ensure all functionality has corresponding tests 5. **Regression Prevention**: Maintain existing functionality while adding new features 6. **Declarative Specifications**: Tests serve as executable specifications By integrating TDD into aiGI, we ensure: - Clear understanding of requirements before implementation - Higher quality code with fewer defects - Better design through test-driven thinking - Confidence in refactoring and optimization - Documentation through test cases ## Workflow ### 1. Test Creation Phase ``` ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Analyze │────>│ Define Test │────>│ Write Test │ │ Requirements │ │ Cases │ │ Code │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Verify Tests │<────│ Run Tests │<────│ Validate Test │ │ Fail (Red) │ │ │ │ Structure │ └─────────────────┘ └─────────────────┘ └─────────────────┘ ``` ### 2. Implementation Phase ``` ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Implement │────>│ Run Tests │────>│ Verify Tests │ │ Functionality │ │ │ │ Pass (Green) │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Finalize │<────│ Refactor Code │<────│ Optimize │ │ Implementation │ │ │ │ Implementation │ └─────────────────┘ └─────────────────┘ └─────────────────┘ ``` ### 3. Integration Phase ``` ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Integration │────>│ Run Integration │────>│ Verify System │ │ Testing │ │ Tests │ │ Behavior │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ ▼ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Document Test │<────│ Refine Tests │<────│ Address Edge │ │ Coverage │ │ If Needed │ │ Cases │ └─────────────────┘ └─────────────────┘ └─────────────────┘ ``` ## Integration with Other Modes The TDD mode interfaces with other aiGI modes at specific integration points: ### Code Mode Integration - **Pre-Implementation**: TDD provides test specifications before code implementation - **During Implementation**: Continuous test validation as code is developed - **Post-Implementation**: Final verification of all tests passing ``` Code Mode ──────────────────────────────────────────────────────────────────────────▶ │ │ │ ▼ ▼ ▼ Test Specs Test Validation Final Verification │ │ │ ▼ ▼ ▼ TDD Mode ──────────────────────────────────────────────────────────────────────────▶ ``` ### Reflection Mode Integration - **Test Analysis**: Evaluate test coverage and effectiveness - **Improvement Identification**: Identify areas needing additional tests - **Test Refinement**: Update tests based on reflection insights ``` Reflection Mode ─────────────────────────────────────────────────────────────────────▶ │ │ │ ▼ ▼ ▼ Test Analysis Improvement ID Test Refinement │ │ │ ▼ ▼ ▼ TDD Mode ───────────────────────────────────────────────────────────────────────────▶ ``` ### Final-Assembly Mode Integration - **Pre-Assembly Validation**: Ensure all components pass tests before assembly - **Integration Testing**: Verify assembled components work together - **System Testing**: Validate the complete system meets requirements ``` Final-Assembly Mode ──────────────────────────────────────────────────────────────────▶ │ │ │ ▼ ▼ ▼ Pre-Assembly Tests Integration Tests System Tests │ │ │ ▼ ▼ ▼ TDD Mode ─────────────────────────────────────────────────────────────────────────────▶ ``` ## Error Resolution Strategy When tests fail consistently (more than twice), the TDD mode employs a structured approach to resolve issues using MCP tools: ### Error Resolution Workflow 1. **Error Analysis** - Capture detailed error information - Categorize error type (syntax, logic, integration, etc.) - Identify affected components 2. **MCP Tool Selection** - Based on error category, select appropriate MCP tools: - `analyze_code`: For code structure and logic issues - `modify_code`: For implementing fixes - `search_code`: For finding similar patterns or related issues 3. **Resolution Implementation** - Apply targeted fixes using selected MCP tools - Document resolution approach - Create regression tests to prevent recurrence 4. **Verification** - Run tests to confirm resolution - Validate no new issues were introduced - Update test documentation ### MCP Tool Usage for Common Error Types | Error Type | MCP Tool | Usage Pattern | |------------|----------|---------------| | Syntax Errors | `analyze_code` | `<analyze_code><path>file_path</path><query>syntax validation</query></analyze_code>` | | Logic Errors | `analyze_code` | `<analyze_code><path>file_path</path><query>logic flow analysis</query></analyze_code>` | | Integration Issues | `search_code` | `<search_code><path>src/</path><pattern>interface pattern</pattern></search_code>` | | Performance Issues | `analyze_code` | `<analyze_code><path>file_path</path><query>performance optimization</query></analyze_code>` | | Implementation Fixes | `modify_code` | `<modify_code><path>file_path</path><changes>specific changes</changes></modify_code>` | ### Escalation Protocol For persistent errors that resist resolution after multiple attempts: 1. **Deep Analysis Mode** - Engage specialized analysis using advanced MCP capabilities - Generate comprehensive diagnostic report - Identify root cause through pattern analysis 2. **Alternative Implementation** - Propose alternative implementation approaches - Create parallel test implementations - Evaluate effectiveness of alternatives 3. **External Resource Integration** - Leverage external knowledge bases - Apply known patterns from similar problem domains - Incorporate community solutions when appropriate ## Self-Reflection and Self-Learning The TDD mode incorporates self-reflection and self-learning mechanisms using a declarative approach: ### Declarative Test Evaluation ```yaml test_evaluation: metrics: - coverage - complexity - reliability - performance thresholds: coverage: 90% complexity: medium reliability: high performance: acceptable actions: if_below_threshold: - generate_additional_tests - refine_existing_tests - document_coverage_gaps ``` ### Learning from Test Patterns The TDD mode maintains a repository of test patterns and their effectiveness: ```yaml test_patterns: - pattern: boundary_testing effectiveness: high applicable_to: - numeric_inputs - string_processing - date_handling examples: - min_value_test - max_value_test - empty_string_test - pattern: exception_handling effectiveness: medium applicable_to: - external_integrations - file_operations - network_requests examples: - timeout_test - connection_failure_test - invalid_response_test ``` ### Continuous Improvement Cycle 1. **Test Execution Data Collection** - Gather metrics on test performance - Track test execution time - Monitor test stability 2. **Pattern Analysis** - Identify effective test patterns - Recognize ineffective approaches - Correlate test patterns with defect detection 3. **Knowledge Application** - Apply learned patterns to new tests - Refine existing tests based on effectiveness data - Generate test recommendations 4. **Documentation Update** - Maintain living documentation of effective patterns - Update test guidelines based on learnings - Share insights across modes ## Metrics and Measurement The TDD mode employs comprehensive metrics to measure test coverage and quality: ### Coverage Metrics | Metric | Description | Target | |--------|-------------|--------| | Line Coverage | Percentage of code lines executed by tests | ≥90% | | Branch Coverage | Percentage of code branches executed by tests | ≥85% | | Function Coverage | Percentage of functions called during tests | 100% | | Statement Coverage | Percentage of statements executed by tests | ≥90% | | Condition Coverage | Percentage of boolean conditions tested | ≥85% | ### Quality Metrics | Metric | Description | Target | |--------|-------------|--------| | Test Reliability | Percentage of tests that consistently pass/fail | ≥98% | | Test Isolation | Degree to which tests are independent of each other | High | | Test Specificity | How precisely tests identify the source of failures | High | | Test Maintainability | Ease of updating tests when requirements change | Medium-High | | Test Performance | Execution time of the test suite | Reasonable | ### Visualization and Reporting The TDD mode generates visual reports to communicate test status: ``` Coverage Report Example: ┌────────────────────────────────────────────────────────────┐ │ Module: User Authentication │ │ ┌──────────────┬───────────┬────────────┬────────────────┐ │ │ │ Component │ Line Cov. │ Branch Cov.│ Function Cov. │ │ │ ├──────────────┼───────────┼────────────┼────────────────┤ │ │ │ Login │ 95% │ 92% │ 100% │ │ │ │ Registration │ 98% │ 94% │ 100% │ │ │ │ Password │ 87% │ 82% │ 100% │ │ │ │ Session │ 92% │ 88% │ 100% │ │ │ └──────────────┴───────────┴────────────┴────────────────┘ │ └────────────────────────────────────────────────────────────┘ ``` ### Trend Analysis The TDD mode tracks metrics over time to identify trends and improvements: ``` Test Quality Trend: Week 1: ■■■■■□□□□□ 50% Week 2: ■■■■■■□□□□ 60% Week 3: ■■■■■■■□□□ 70% Week 4: ■■■■■■■■□□ 80% Week 5: ■■■■■■■■■□ 90% ``` ## Conclusion The TDD mode serves as a critical quality assurance component within the aiGI process. By enforcing the creation of tests before implementation, it ensures that all functionality is well-defined, thoroughly tested, and correctly implemented. The integration with other modes creates a seamless development experience where quality is built in from the beginning rather than added later. Through its self-reflection and learning capabilities, the TDD mode continuously improves its effectiveness, adapting to new patterns and challenges. The comprehensive metrics provide visibility into test coverage and quality, enabling data-driven decisions about when functionality is ready to proceed to subsequent phases. By leveraging MCP tools for error resolution, the TDD mode can efficiently address issues when they arise, maintaining development momentum while ensuring high-quality outcomes. This approach ensures that the final deliverables from the aiGI process are robust, reliable, and meet all specified requirements.