@paulduvall/claude-dev-toolkit 0.0.1-alpha.1 → 0.0.1-alpha.11

package/commands/experiments/xconstraints.md

@@ -0,0 +1,89 @@
+---
+description: Manage and enforce development constraints for quality and compliance
+tags: [constraints, quality, compliance, validation, governance]
+---
+
+Manage development constraints based on the arguments provided in $ARGUMENTS.
+
+First, check for existing constraint configuration:
+!ls -la .constraints.yml .constraints.yaml 2>/dev/null || echo "No constraint configuration found"
+!find . -name "*constraint*" -o -name "*rule*" | head -5
+
+Based on $ARGUMENTS, perform the appropriate constraint operation:
+
+## 1. Define New Constraints
+
+If defining constraints (--define):
+!touch .constraints.yml
+!echo "Adding constraint: $constraint_name" >> .constraints.yml
+
+Common constraint types to define:
+- Code complexity limits (max_complexity=10)
+- File size limits (max_lines=500)
+- Naming conventions (snake_case, camelCase)
+- Security patterns (no_secrets, https_only)
+- Architecture boundaries (no_direct_db_access)
+
+## 2. Enforce Constraints
+
+If enforcing constraints (--enforce):
+!python -m flake8 --max-complexity=10 . 2>/dev/null || echo "No Python linter available"
+!eslint --max-complexity 10 . 2>/dev/null || echo "No JavaScript linter available"
+!grep -r "password\|secret\|key" . --exclude-dir=.git | head -5 || echo "No hardcoded secrets found"
+
+Check for:
+- Code complexity violations
+- File size violations
+- Naming convention violations
+- Security violations
+- Architecture violations
+
+## 3. Validate Compliance
+
+If validating constraints (--validate):
+!find . -name "*.py" -exec wc -l {} \; | awk '$1 > 500 {print $2 ": " $1 " lines (exceeds 500)"}'
+!find . -name "*.js" -exec wc -l {} \; | awk '$1 > 300 {print $2 ": " $1 " lines (exceeds 300)"}'
+
+Validate:
+- Code meets complexity limits
+- Files are within size limits
+- Naming follows conventions
+- No security violations
+- Architecture boundaries respected
+
+## 4. List Current Constraints
+
+If listing constraints (--list):
+@.constraints.yml 2>/dev/null || echo "No constraints file found"
+!echo "Active constraints:"
+!echo "- Max complexity: 10"
+!echo "- Max file lines: 500"
+!echo "- Naming: snake_case (Python), camelCase (JavaScript)"
+!echo "- Security: No hardcoded secrets"
+
+## 5. Generate Compliance Report
+
+If generating report (--report):
+!date
+!echo "=== Constraint Compliance Report ==="
+!echo "Project: $(basename $(pwd))"
+
+Run constraint checks:
+!python -c "import ast; print('Python syntax check: OK')" 2>/dev/null || echo "Python syntax issues found"
+!node -c "console.log('JavaScript syntax check: OK')" 2>/dev/null || echo "JavaScript syntax issues found"
+
+Generate summary:
+- Total files checked
+- Violations found
+- Compliance percentage
+- Recommendations for fixes
+
+Think step by step about constraint violations and provide:
+- Current compliance status
+- Specific violations found
+- Prioritized fix recommendations
+- Prevention strategies
+- Integration suggestions
+
+Report overall constraint health and suggest improvements for maintaining code quality and compliance.
+

package/commands/experiments/xcoverage.md

@@ -0,0 +1,90 @@
+---
+description: Comprehensive dual coverage analysis for code and specifications
+tags: [coverage, testing, specifications, quality, metrics]
+---
+
+Perform dual coverage analysis based on the arguments provided in $ARGUMENTS.
+
+First, examine the project structure for test files and coverage tools:
+!find . -name "*test*" -o -name "*spec*" | grep -E "\.(py|js|ts)$" | head -10
+!ls -la | grep -E "(pytest|jest|coverage|nyc)"
+!which pytest 2>/dev/null || which npm 2>/dev/null || echo "No test runners found"
+
+Based on $ARGUMENTS, perform the appropriate coverage analysis:
+
+## 1. HTML Coverage Report Generation
+
+If generating HTML report (--html):
+!python -m pytest --cov=. --cov-report=html 2>/dev/null || npm test -- --coverage 2>/dev/null || echo "No coverage tools configured"
+!ls htmlcov/ 2>/dev/null && echo "HTML report generated in htmlcov/" || echo "No HTML coverage report found"
+
+## 2. Missing Coverage Analysis
+
+If checking missing coverage (--missing):
+!python -m pytest --cov=. --cov-report=term-missing 2>/dev/null || echo "Python coverage not available"
+!npm test -- --coverage --verbose 2>/dev/null || echo "JavaScript coverage not available"
+
+Show uncovered lines and specifications that need attention.
+
+## 3. Specification Coverage Analysis
+
+If checking specific specification (--spec):
+@specs/ 2>/dev/null || echo "No specs directory found"
+!find . -name "*test*" -exec grep -l "$spec_id" {} \; 2>/dev/null
+
+Analyze:
+- Tests linked to the specification
+- Code coverage for specification implementation
+- Traceability from spec to test to code
+
+## 4. Dual Coverage Metrics
+
+If showing dual coverage (--dual):
+!python -m pytest --cov=. --cov-report=term 2>/dev/null | grep "TOTAL" || echo "Code coverage not available"
+!find specs/ -name "*.md" 2>/dev/null | wc -l | xargs echo "Total specifications:"
+!find . -name "*test*" 2>/dev/null | wc -l | xargs echo "Total test files:"
+
+Calculate:
+- Code coverage percentage
+- Specification coverage percentage
+- Traceability coverage percentage
+- Combined dual coverage score
+
+## 5. Authority Level Coverage
+
+If checking by authority (--authority):
+!grep -r "authority=$authority_level" specs/ 2>/dev/null || echo "No authority specifications found"
+
+Break down coverage by:
+- System level specifications
+- Platform level specifications  
+- Developer level specifications
+
+## 6. Coverage Gaps Analysis
+
+If identifying gaps (--gaps):
+!find specs/ -name "*.md" -exec basename {} \; 2>/dev/null | sed 's/\.md$//' > /tmp/specs.txt
+!find . -name "*test*" -exec grep -l "spec" {} \; 2>/dev/null | xargs grep -o "spec[0-9a-zA-Z]*" | sort -u > /tmp/tested_specs.txt
+!comm -23 <(sort /tmp/specs.txt) <(sort /tmp/tested_specs.txt) 2>/dev/null || echo "Gap analysis not available"
+
+Identify:
+- Specifications without tests
+- Code without specification coverage
+- Missing traceability links
+
+## 7. Comprehensive Metrics Dashboard
+
+If generating metrics (--metrics):
+!uptime
+!date
+
+Think step by step about coverage analysis and provide:
+- Current code coverage percentage
+- Specification coverage percentage
+- Traceability coverage percentage
+- Gap analysis summary
+- Recommendations for improvement
+- Coverage trends and targets
+
+Generate a comprehensive coverage report with actionable insights and recommendations.
+

package/commands/experiments/xdb.md

@@ -0,0 +1,102 @@
+---
+description: Comprehensive database management, migrations, and performance operations
+tags: [database, schema, migration, performance, backup]
+---
+
+Perform database operations based on the arguments provided in $ARGUMENTS.
+
+First, examine the project for database configuration and tools:
+!ls -la | grep -E "(database|db|migration|schema)"
+!find . -name "*.sql" -o -name "*migration*" -o -name "*schema*" | head -10
+!which psql 2>/dev/null || which mysql 2>/dev/null || which sqlite3 2>/dev/null || echo "No database clients found"
+
+Based on $ARGUMENTS, perform the appropriate database operation:
+
+## 1. Schema Management
+
+If managing schema (--schema):
+!find . -name "schema.sql" -o -name "*.schema" | head -5
+!ls models/ 2>/dev/null || ls app/models/ 2>/dev/null || echo "No models directory found"
+
+For schema operations:
+- Check existing schema files
+- Validate schema syntax
+- Generate schema documentation
+- Compare schema versions
+
+## 2. Migration Operations
+
+If handling migrations (--migrate):
+!find . -name "*migration*" -o -path "*/migrations/*" | head -10
+!python manage.py showmigrations 2>/dev/null || rails db:migrate:status 2>/dev/null || echo "No migration framework detected"
+
+Migration tasks:
+- Check migration status
+- Run pending migrations
+- Create new migration files
+- Rollback migrations if needed
+
+## 3. Data Seeding
+
+If seeding data (--seed):
+!find . -name "*seed*" -o -name "*fixture*" | head -5
+!python manage.py loaddata 2>/dev/null || rails db:seed 2>/dev/null || echo "No seeding framework detected"
+
+Seeding operations:
+- Load test fixtures
+- Populate sample data
+- Environment-specific seeding
+- Data validation after seeding
+
+## 4. Performance Analysis
+
+If analyzing performance (--performance):
+!ps aux | grep -E "(postgres|mysql|sqlite)" | head -3
+!top -l 1 | grep -E "(CPU|Memory)" 2>/dev/null || echo "System stats not available"
+
+Performance checks:
+- Database connection status
+- Query performance analysis
+- Index optimization suggestions
+- Resource usage monitoring
+
+## 5. Backup Operations
+
+If performing backup (--backup):
+!ls -la *.sql *.dump 2>/dev/null || echo "No backup files found"
+!which pg_dump 2>/dev/null || which mysqldump 2>/dev/null || echo "No backup tools found"
+
+Backup tasks:
+- Create database backups
+- Verify backup integrity
+- Schedule automated backups
+- Test restore procedures
+
+## 6. Database Testing
+
+If testing database (--test):
+!python -m pytest tests/test_*db* 2>/dev/null || npm test 2>/dev/null || echo "No database tests found"
+!find . -name "*test*" | grep -i db | head -5
+
+Testing operations:
+- Run database unit tests
+- Test migration scripts
+- Validate data integrity
+- Check constraint violations
+
+## 7. Connection and Status
+
+Check database connectivity:
+!python -c "import sqlite3; print('SQLite available')" 2>/dev/null || echo "SQLite not available"
+!python -c "import psycopg2; print('PostgreSQL client available')" 2>/dev/null || echo "PostgreSQL client not available"
+!python -c "import pymongo; print('MongoDB client available')" 2>/dev/null || echo "MongoDB client not available"
+
+Think step by step about database operations and provide:
+- Current database status
+- Available operations for detected database type
+- Recommendations for database optimization
+- Best practices for data management
+- Security considerations
+
+Generate database management report with actionable recommendations.
+

package/commands/experiments/xdesign.md

@@ -0,0 +1,121 @@
+---
+description: Apply design patterns and architectural principles to improve code quality
+tags: [design-patterns, architecture, solid, refactoring, best-practices]
+---
+
+Analyze code structure and apply design patterns based on the arguments provided in $ARGUMENTS.
+
+First, examine the project structure and identify current patterns:
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" -o -name "*.java" | head -15
+!ls -la src/ app/ lib/ 2>/dev/null || echo "No standard source directories found"
+
+Based on $ARGUMENTS, perform the appropriate design analysis:
+
+## 1. Pattern Analysis and Suggestions
+
+If analyzing patterns (--patterns, --analyze):
+!grep -r "class" . --include="*.py" --include="*.js" --include="*.ts" | head -10
+!grep -r "interface\|abstract" . --include="*.py" --include="*.js" --include="*.ts" | head -5
+
+Analyze current code for:
+- Existing design patterns
+- Anti-patterns and code smells
+- Opportunities for pattern application
+- Architectural structure
+
+## 2. SOLID Principles Assessment
+
+If checking SOLID principles (--solid, --principles):
+!find . -name "*.py" -exec grep -l "class" {} \; | head -5
+!python -c "import ast; print('Analyzing class structures...')" 2>/dev/null || echo "Python AST analysis not available"
+
+Check for:
+- Single Responsibility Principle violations
+- Open/Closed Principle compliance
+- Liskov Substitution Principle adherence
+- Interface Segregation implementation
+- Dependency Inversion usage
+
+## 3. Code Quality Analysis
+
+If checking DRY violations (--dry):
+!grep -r "def\|function" . --include="*.py" --include="*.js" | cut -d: -f2 | sort | uniq -c | sort -nr | head -10
+!find . -name "*.py" -exec grep -l "copy\|duplicate" {} \; 2>/dev/null
+
+Identify:
+- Duplicated code blocks
+- Similar functions/methods
+- Copy-paste patterns
+- Refactoring opportunities
+
+## 4. Coupling and Cohesion Analysis
+
+If analyzing coupling (--coupling):
+!find . -name "*.py" -exec grep -c "import" {} \; | sort -nr | head -10
+!grep -r "from.*import" . --include="*.py" | wc -l
+
+Evaluate:
+- Module dependencies
+- Import complexity
+- Circular dependencies
+- Cohesion within modules
+
+## 5. Refactoring Suggestions
+
+If providing refactoring guidance (--refactor):
+!find . -name "*.py" -exec wc -l {} \; | awk '$1 > 100 {print $2 ": " $1 " lines (consider refactoring)"}'
+!grep -r "def" . --include="*.py" | wc -l | xargs echo "Total functions:"
+
+Suggest:
+- Extract method opportunities
+- Class decomposition
+- Interface extraction
+- Dependency injection improvements
+
+## 6. Specific Pattern Implementation
+
+If implementing specific patterns (--factory, --observer, --strategy):
+@src/ 2>/dev/null || @app/ 2>/dev/null || echo "No source directory to analyze"
+
+Pattern suggestions based on context:
+- Factory patterns for object creation
+- Observer patterns for event handling
+- Strategy patterns for algorithm selection
+- Repository patterns for data access
+- Decorator patterns for feature extension
+
+## 7. Architecture Pattern Assessment
+
+If checking architecture patterns (--mvc, --repository):
+!find . -name "*model*" -o -name "*view*" -o -name "*controller*" | head -10
+!find . -name "*repository*" -o -name "*service*" -o -name "*dao*" | head -5
+
+Assess current architecture:
+- MVC pattern implementation
+- Layer separation
+- Service layer design
+- Data access patterns
+
+## 8. Best Practices Review
+
+If reviewing best practices (--best-practices, --clean-code):
+!python -m flake8 . 2>/dev/null | head -10 || echo "No Python linting available"
+!eslint . 2>/dev/null | head -10 || echo "No JavaScript linting available"
+
+Review:
+- Naming conventions
+- Function/method length
+- Class responsibilities
+- Code complexity
+- Documentation quality
+
+Think step by step about design improvements and provide:
+- Current design pattern usage
+- Anti-pattern identification
+- SOLID principle compliance
+- Refactoring recommendations
+- Architecture improvement suggestions
+- Implementation guidance for suggested patterns
+
+Generate a comprehensive design analysis with actionable recommendations for code quality improvement.
+

package/commands/experiments/xevaluate.md

@@ -0,0 +1,111 @@
+---
+description: Comprehensive evaluation and assessment tools for code quality and project health
+tags: [evaluation, assessment, quality, metrics, analysis]
+---
+
+Perform comprehensive evaluation and assessment based on the arguments provided in $ARGUMENTS.
+
+First, examine the project structure and available metrics:
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | head -15
+!ls -la | grep -E "(test|spec|coverage|metrics)"
+!git log --oneline -10 2>/dev/null || echo "No git repository found"
+
+Based on $ARGUMENTS, perform the appropriate evaluation:
+
+## 1. Code Quality Assessment
+
+If evaluating quality (--quality):
+!python -m flake8 . --count 2>/dev/null || echo "No Python linting available"
+!eslint . --format compact 2>/dev/null || echo "No JavaScript linting available"
+!find . -name "*.py" -exec wc -l {} \; | awk '{sum+=$1} END {print "Total Python lines:", sum}'
+
+Analyze code quality metrics:
+- Code complexity and maintainability
+- Test coverage percentage
+- Linting and style violations
+- Documentation coverage
+- Technical debt indicators
+
+## 2. Project Health Evaluation
+
+If evaluating project health (--project):
+!git log --since="30 days ago" --pretty=format:"%h %s" | wc -l
+!git log --since="30 days ago" --pretty=format:"%an" | sort | uniq -c | sort -nr
+!find . -name "TODO" -o -name "FIXME" | xargs grep -i "todo\|fixme" | wc -l 2>/dev/null || echo "0"
+
+Assess project health indicators:
+- Development velocity and commit frequency
+- Issue resolution rate
+- Technical debt accumulation
+- Team collaboration patterns
+- Release readiness
+
+## 3. Team Performance Assessment
+
+If evaluating team performance (--team):
+!git shortlog -sn --since="30 days ago" 2>/dev/null || echo "No git history available"
+!git log --since="7 days ago" --pretty=format:"%ad" --date=short | sort | uniq -c
+
+Evaluate team metrics:
+- Individual and team velocity
+- Code review participation
+- Knowledge sharing patterns
+- Skill development indicators
+- Collaboration effectiveness
+
+## 4. Process Effectiveness Analysis
+
+If evaluating process (--process):
+!find . -name "*.yml" -o -name "*.yaml" | grep -E "(ci|pipeline|workflow)" | head -5
+!ls -la .github/workflows/ 2>/dev/null || echo "No GitHub workflows found"
+!find . -name "*test*" | wc -l
+
+Analyze development processes:
+- CI/CD pipeline effectiveness
+- Testing process maturity
+- Code review process efficiency
+- Release management effectiveness
+- Incident response capabilities
+
+## 5. Comprehensive Reporting
+
+If generating reports (--report):
+!date
+!uptime
+!df -h . | tail -1
+
+Generate evaluation metrics:
+- Overall project health score
+- Quality trend analysis
+- Risk assessment summary
+- Improvement recommendations
+- Benchmarking against industry standards
+
+Think step by step about the evaluation results and provide:
+
+1. **Current Status Assessment**:
+   - Overall health score (0-100)
+   - Key strengths identified
+   - Critical areas for improvement
+   - Risk factors and mitigation strategies
+
+2. **Trend Analysis**:
+   - Performance trends over time
+   - Quality trajectory
+   - Team productivity patterns
+   - Process improvement opportunities
+
+3. **Actionable Recommendations**:
+   - Prioritized improvement actions
+   - Resource allocation suggestions
+   - Timeline for improvements
+   - Success metrics and KPIs
+
+4. **Benchmarking Results**:
+   - Industry standard comparisons
+   - Best practice alignment
+   - Competitive positioning
+   - Excellence opportunities
+
+Generate comprehensive evaluation report with specific, actionable insights and improvement roadmap.
+

package/commands/experiments/xfootnote.md

@@ -0,0 +1,12 @@
+---
+description: Track machine-readable requirement links for SpecDriven AI development
+tags: [requirements, traceability, specifications, footnotes, coverage]
+---
+
+Track and manage requirement links based on the arguments provided in $ARGUMENTS.
+
+First, verify this is a SpecDriven AI project structure:
+!ls -la specs/ 2>/dev/null || echo "No specs directory found"
+!find specs/specifications/ -name "*.md" 2>/dev/null | head -5 || echo "No specifications found"
+
+Based on $ARGUMENTS, perform the appropriate footnote operation:\n\n## 1. Find Requirements by ID\n\nIf finding requirements (--find):\n!grep -r \"#{#$footnote_id\" specs/specifications/ 2>/dev/null || echo \"Footnote ID not found\"\n!grep -r \"authority=\" specs/specifications/ | grep \"$footnote_id\" | head -1\n\nSearch for:\n- Specification containing the footnote ID\n- Authority level (system/platform/developer)\n- Context and description\n- Related requirements\n\n## 2. Generate Next Available ID\n\nIf generating next ID (--next):\n!find specs/specifications/ -name \"*.md\" -exec grep -o \"#{#[a-z]\\{3\\}[0-9][a-z]\" {} \\; 2>/dev/null | sort | tail -5\n\nGenerate next footnote ID:\n- Extract component prefix (first 3 chars)\n- Find highest existing sequence number\n- Generate next available ID with proper format\n- Validate format: ^[a-z]{3}[0-9][a-z]\n\n## 3. Trace Test Implementations\n\nIf tracing implementations (--trace):\n!grep -r \"$footnote_id\" specs/tests/ 2>/dev/null || echo \"No tests found for $footnote_id\"\n!grep -r \"$footnote_id\" . --exclude-dir=specs --exclude-dir=.git 2>/dev/null | head -5\n\nTrace requirement implementation:\n- Find tests referencing the footnote ID\n- Locate code implementing the requirement\n- Check traceability links\n- Count implementation coverage\n\n## 4. Validate ID Format\n\nIf validating format (--validate):\n!echo \"$footnote_id\" | grep -E \"^[a-z]{3}[0-9][a-z]$\" >/dev/null && echo \"Valid format\" || echo \"Invalid format\"\n\nValidate footnote ID:\n- Check format compliance (3 letters + 1 digit + 1 letter)\n- Extract component prefix\n- Verify sequence number\n- Confirm version suffix\n\n## 5. Check Authority Level\n\nIf checking authority (--authority):\n!grep -r \"#{#$footnote_id.*authority=\" specs/specifications/ 2>/dev/null | grep -o \"authority=[^}]*\"\n\nDetermine authority level:\n- system: Critical system requirements (highest)\n- platform: Framework/infrastructure requirements (medium)\n- developer: Application/feature requirements (lowest)\n\n## 6. Dual Coverage Analysis\n\nIf checking coverage (--coverage):\n!grep -r \"$footnote_id\" specs/tests/ >/dev/null && echo \"✓ Has tests\" || echo \"✗ No tests\"\n!python -m pytest specs/tests/ --cov=. -q 2>/dev/null | grep \"TOTAL\" || echo \"Coverage analysis not available\"\n\nAnalyze dual coverage:\n- Specification coverage (tests exist for requirement)\n- Code coverage (tests execute relevant code)\n- Traceability coverage (links between spec-test-code)\n\nThink step by step about requirement traceability and provide:\n\n1. **Requirement Status**:\n   - Specification exists and is well-defined\n   - Authority level and compliance requirements\n   - Implementation completeness\n\n2. **Test Coverage**:\n   - Tests exist for the requirement\n   - Test quality and completeness\n   - Code coverage achieved by tests\n\n3. **Traceability Links**:\n   - Clear links from specification to tests\n   - Code references to requirement ID\n   - End-to-end traceability validation\n\n4. **Recommendations**:\n   - Missing tests or implementations\n   - Coverage improvement opportunities\n   - Traceability enhancement suggestions\n\nGenerate requirement traceability report with coverage metrics and improvement recommendations.\n\nIf no specific operation is provided, show available footnote IDs and their status.

package/commands/experiments/xgenerate.md

@@ -0,0 +1,117 @@
+---
+description: Auto-generate code, tests, and documentation from specifications using AI
+tags: [generation, ai, code, tests, documentation, automation]
+---
+
+Generate code, tests, and documentation based on the arguments provided in $ARGUMENTS.
+
+First, examine the project structure and identify generation targets:
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | head -10
+!ls -la specs/ 2>/dev/null || echo "No specs directory found"
+!find specs/specifications/ -name "*.md" 2>/dev/null | head -5 || echo "No specifications found"
+
+Based on $ARGUMENTS, perform the appropriate code generation:
+
+## 1. Generate Tests from Specifications
+
+If generating tests (--test):
+!find specs/specifications/ -name "*.md" -exec grep -l "$spec_id" {} \; 2>/dev/null || echo "Specification not found"
+@specs/specifications/$specification_file 2>/dev/null || echo "Unable to read specification"
+
+Generate test file:
+- Extract requirements from specification
+- Create test cases covering all scenarios
+- Include proper traceability links to specification ID
+- Follow testing framework conventions (pytest, jest, etc.)
+- Add assertion patterns based on specification authority
+
+## 2. Generate Implementation Code
+
+If generating code (--code):
+!find . -name "*test*" | grep "$test_name" | head -1
+@$test_file 2>/dev/null || echo "Test file not found"
+
+Generate minimal implementation:
+- Analyze test requirements and assertions
+- Create minimal code to satisfy all tests
+- Follow project coding standards
+- Include proper error handling
+- Add docstrings and type hints
+
+## 3. Generate Schema Definitions
+
+If generating schema (--schema):
+!find . -name "*.py" -exec grep -l "$model_name" {} \; | head -3
+!python -c "import inspect; print('Python inspection available')" 2>/dev/null || echo "Python not available"
+
+Generate Pydantic schema:
+- Extract field definitions from existing models
+- Add proper type annotations
+- Include validation rules
+- Add field descriptions and examples
+- Handle relationships and dependencies
+
+## 4. Generate Documentation
+
+If generating documentation (--docs):
+!find . -name "*.py" -o -name "*.js" -o -name "*.ts" | xargs grep -l "$component" | head -5
+!python -c "import ast; print('AST parsing available')" 2>/dev/null || echo "AST parsing not available"
+
+Generate component documentation:
+- Extract docstrings and comments
+- Generate API reference documentation
+- Create usage examples
+- Add parameter and return type documentation
+- Include integration examples
+
+## 5. Generate Configuration Files
+
+If generating config (--config):
+!ls -la | grep -E "(config|env|yml|yaml|json|toml)"
+!find . -name "*.example" -o -name "*.template" | head -3
+
+Generate configuration:
+- Create environment-specific config files
+- Add validation schemas
+- Include default values and examples
+- Add documentation comments
+- Handle sensitive data properly
+
+## 6. Template-Based Generation
+
+Check for existing templates:
+!find . -name "*template*" -o -name "*scaffold*" | head -5
+!ls -la templates/ 2>/dev/null || echo "No templates directory"
+
+Use templates when available:
+- Load appropriate template for generation type
+- Replace placeholders with actual values
+- Customize based on project structure
+- Maintain consistent formatting
+
+Think step by step about the generation requirements and:
+
+1. **Analyze Input**:
+   - Understand the specification or test requirements
+   - Identify the target output format and structure
+   - Determine dependencies and relationships
+
+2. **Generate Content**:
+   - Create minimal, focused implementation
+   - Follow established patterns and conventions
+   - Include proper error handling and validation
+   - Add comprehensive documentation
+
+3. **Ensure Quality**:
+   - Validate generated code syntax
+   - Check compliance with project standards
+   - Verify traceability links are maintained
+   - Test generated code functionality
+
+4. **Integration**:
+   - Place generated files in appropriate locations
+   - Update imports and dependencies
+   - Integrate with existing codebase
+   - Maintain project structure consistency
+
+Generate high-quality, well-documented code that follows SpecDriven AI principles and integrates seamlessly with the existing project structure.