agentic-qe 1.0.0

package/.claude/commands/aqe-generate.md

@@ -0,0 +1,301 @@
+---
+name: aqe-generate
+description: Generate comprehensive test suites using AI-powered analysis and sublinear optimization
+---
+
+# AQE Generate Tests
+
+Generate comprehensive test suites using AI-powered analysis and sublinear optimization algorithms.
+
+## Usage
+
+```bash
+aqe generate <target> [options]
+# or
+/aqe-generate <target> [options]
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `target` | path | **required** | Source code path to generate tests for |
+| `--type` | enum | `unit` | Test type: unit, integration, e2e, performance, security |
+| `--framework` | string | `jest` | Testing framework: jest, mocha, cypress, playwright, vitest |
+| `--coverage` | number | `95` | Target coverage percentage (0-100) |
+| `--property-based` | boolean | `false` | Enable property-based testing |
+| `--mutation` | boolean | `false` | Enable mutation testing |
+| `--parallel` | boolean | `true` | Generate tests in parallel |
+| `--output` | path | `./tests` | Output directory for generated tests |
+| `--swagger` | path | - | OpenAPI/Swagger spec for API testing |
+| `--dry-run` | boolean | `false` | Preview without writing files |
+
+## Examples
+
+### Basic Unit Test Generation
+
+```bash
+aqe generate src/services/user-service.ts
+```
+
+Generates unit tests for a single service file using default settings (Jest, 95% coverage).
+
+### E2E Tests from API Spec
+
+```bash
+aqe generate src/api --type e2e --swagger api-spec.yaml --framework cypress
+```
+
+Generates end-to-end tests from OpenAPI specification using Cypress.
+
+### Property-Based Testing
+
+```bash
+aqe generate src/utils --type unit --property-based --coverage 98
+```
+
+Generates property-based tests for utility functions with high coverage target.
+
+### Security Test Suite
+
+```bash
+aqe generate src/ --type security --framework jest --mutation
+```
+
+Generates comprehensive security tests with mutation testing enabled.
+
+### Multi-Framework Generation
+
+```bash
+# Generate Jest unit tests
+aqe generate src/services --type unit --framework jest
+
+# Generate Cypress E2E tests
+aqe generate src/features --type e2e --framework cypress
+
+# Generate Playwright integration tests
+aqe generate src/api --type integration --framework playwright
+```
+
+## Integration with Claude Code
+
+### Spawning Test Generator Agent
+
+```javascript
+// Use Claude Code's Task tool to spawn the test generator agent
+Task("Generate comprehensive test suite", `
+  Generate tests for the user authentication module:
+  - Path: src/services/auth/
+  - Framework: Jest
+  - Coverage target: 95%
+  - Include property-based tests
+  - Generate boundary tests for edge cases
+
+  Coordinate with coverage analyzer for gap analysis.
+  Store results in memory under: aqe/test-generation/auth-module
+`, "qe-test-generator")
+```
+
+### Parallel Generation Workflow
+
+```javascript
+// Spawn multiple test generators in parallel for different modules
+[Single Message]:
+  Task("Generate API tests", "Create tests for API endpoints", "qe-test-generator")
+  Task("Generate Service tests", "Create tests for service layer", "qe-test-generator")
+  Task("Generate Utils tests", "Create tests for utilities", "qe-test-generator")
+
+  TodoWrite({ todos: [
+    {content: "Generate API tests", status: "in_progress", activeForm: "Generating API tests"},
+    {content: "Generate Service tests", status: "in_progress", activeForm: "Generating Service tests"},
+    {content: "Generate Utils tests", status: "in_progress", activeForm: "Generating Utils tests"},
+    {content: "Analyze coverage gaps", status: "pending", activeForm: "Analyzing coverage gaps"}
+  ]})
+```
+
+## Agent Coordination
+
+### Primary Agent
+- **qe-test-generator**: Main agent responsible for test generation
+
+### Supporting Agents
+- **qe-coverage-analyzer**: Analyzes existing coverage to identify gaps
+- **qe-quality-gate**: Validates generated test quality
+
+### Coordination Flow
+
+```
+1. Pre-Task Hook
+   ├─> Retrieve existing coverage data
+   ├─> Retrieve test patterns from neural learning
+   └─> Analyze source code structure
+
+2. Test Generation
+   ├─> Parse source code and dependencies
+   ├─> Generate test cases using AI
+   ├─> Apply framework-specific patterns
+   └─> Validate test syntax
+
+3. Post-Task Hook
+   ├─> Store generated tests in memory
+   ├─> Update coverage projections
+   ├─> Train neural patterns
+   └─> Notify fleet of completion
+```
+
+## Memory Operations
+
+### Input Memory Keys
+
+```bash
+# Retrieve existing coverage baseline
+npx claude-flow@alpha memory retrieve --key "aqe/coverage-baseline"
+
+# Retrieve learned test patterns
+npx claude-flow@alpha memory retrieve --key "aqe/test-patterns"
+
+# Retrieve source code analysis
+npx claude-flow@alpha memory retrieve --key "aqe/source-code/${target}"
+```
+
+### Output Memory Keys
+
+```bash
+# Store generation results
+npx claude-flow@alpha memory store \
+  --key "aqe/test-generation/results" \
+  --value '{"tasksGenerated": 45, "projectedCoverage": 96}'
+
+# Store generated test suite metadata
+npx claude-flow@alpha memory store \
+  --key "aqe/test-suite/${target}" \
+  --value '{"framework": "jest", "testCount": 45, "timestamp": "2025-09-30T10:00:00Z"}'
+
+# Store coverage projection
+npx claude-flow@alpha memory store \
+  --key "aqe/coverage-projection" \
+  --value '{"before": 78, "after": 96, "improvement": 18}'
+```
+
+## Hooks and Coordination
+
+### Pre-Task Hook
+
+```bash
+npx claude-flow@alpha hooks pre-task \
+  --description "Generate tests for ${target}" \
+  --agent "qe-test-generator"
+```
+
+### Post-Edit Hook (for each generated test file)
+
+```bash
+npx claude-flow@alpha hooks post-edit \
+  --file "${TEST_FILE}" \
+  --memory-key "aqe/test-files/${FILE_NAME}"
+```
+
+### Post-Task Hook
+
+```bash
+npx claude-flow@alpha hooks post-task \
+  --task-id "${TASK_ID}" \
+  --results "${GENERATION_RESULTS}"
+```
+
+### Notify Fleet
+
+```bash
+npx claude-flow@alpha hooks notify \
+  --message "Generated ${TEST_COUNT} tests with ${COVERAGE}% projected coverage"
+```
+
+## Expected Outputs
+
+### Success Output
+
+```
+🚀 Initializing test generation for src/services/user-service.ts...
+🧠 Analyzing source code...
+📝 Generating test cases...
+   ✓ Generated 12 unit tests
+   ✓ Generated 5 integration tests
+   ✓ Generated 3 edge case tests
+✅ Test generation completed successfully!
+   Tests: 20
+   Coverage: 96%
+   Framework: jest
+   Output: ./tests/unit
+```
+
+### Generated Files
+
+```
+tests/
+└── unit/
+    └── services/
+        ├── user-service.test.ts
+        ├── user-service.integration.test.ts
+        └── user-service.edge-cases.test.ts
+```
+
+### Metadata Output
+
+```json
+{
+  "taskId": "qe-gen-1727683200-12345",
+  "target": "src/services/user-service.ts",
+  "testsGenerated": 20,
+  "projectedCoverage": 96,
+  "framework": "jest",
+  "testTypes": ["unit", "integration", "edge-cases"],
+  "files": [
+    "tests/unit/services/user-service.test.ts",
+    "tests/unit/services/user-service.integration.test.ts",
+    "tests/unit/services/user-service.edge-cases.test.ts"
+  ],
+  "executionTime": "8.3s",
+  "timestamp": "2025-09-30T10:00:00Z"
+}
+```
+
+## Error Handling
+
+### Invalid Target Path
+
+```bash
+❌ Error: Target 'src/nonexistent.ts' not found
+```
+
+**Solution:** Verify the target path exists and is accessible.
+
+### Framework Not Installed
+
+```bash
+⚠️  Warning: cypress not installed
+   Installing cypress...
+```
+
+**Solution:** The command will auto-install missing frameworks.
+
+### Coverage Target Validation
+
+```bash
+❌ Error: Coverage must be 0-100 (provided: 150)
+```
+
+**Solution:** Use a valid coverage percentage (0-100).
+
+## Performance Characteristics
+
+- **Time Complexity**: O(log n) for large codebases using sublinear algorithms
+- **Target Time**: <10s for 10 files
+- **Memory Usage**: ~512MB peak
+- **Parallel Support**: Yes (4-8 workers recommended)
+
+## See Also
+
+- `/aqe-execute` - Execute generated tests
+- `/aqe-analyze` - Analyze test coverage
+- `/aqe-optimize` - Optimize test suite
+- `/aqe-report` - Generate quality reports

package/.claude/commands/aqe-optimize.md

@@ -0,0 +1,361 @@
+---
+name: aqe-optimize
+description: Optimize test suites using sublinear algorithms to maximize coverage while minimizing test count and execution time
+---
+
+# AQE Optimize Test Suite
+
+Optimize test suites using sublinear algorithms to maximize coverage while minimizing test count and execution time.
+
+## Usage
+
+```bash
+aqe optimize <target> [options]
+# or
+/aqe-optimize <target> [options]
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `target` | string | **required** | Optimization target: suite, coverage, performance, flakiness |
+| `--path` | path | `./tests` | Test suite path |
+| `--algorithm` | string | `sublinear` | Algorithm: sublinear, genetic, greedy, heuristic |
+| `--objective` | string | `coverage-per-test` | Objective: coverage-per-test, execution-time, reliability |
+| `--budget` | number | - | Time/test budget constraint (seconds) |
+| `--aggressive` | boolean | `false` | Aggressive optimization (may remove tests) |
+| `--dry-run` | boolean | `false` | Preview optimization without applying |
+
+## Examples
+
+### Optimize Test Suite
+
+```bash
+aqe optimize suite --path tests/unit --algorithm sublinear
+```
+
+Optimizes test suite using sublinear algorithms for maximum efficiency.
+
+### Maximize Coverage Efficiency
+
+```bash
+aqe optimize coverage --objective coverage-per-test --aggressive
+```
+
+Aggressively optimizes for maximum coverage per test ratio.
+
+### Reduce Execution Time
+
+```bash
+aqe optimize performance --budget 300 --algorithm genetic
+```
+
+Optimizes to meet 300-second execution budget using genetic algorithm.
+
+### Remove Flaky Tests
+
+```bash
+aqe optimize flakiness --dry-run
+```
+
+Identifies and previews removal of flaky tests without modifying suite.
+
+### Multi-Objective Optimization
+
+```bash
+aqe optimize suite --objective coverage-per-test --budget 180
+```
+
+Optimizes for both coverage efficiency and time budget.
+
+## Integration with Claude Code
+
+### Spawning Optimizer Agent
+
+```javascript
+// Use Claude Code's Task tool to spawn the optimizer agent
+Task("Optimize test suite for efficiency", `
+  Perform comprehensive test suite optimization:
+  - Use sublinear algorithms for O(log n) performance
+  - Maximize coverage while minimizing test count
+  - Target: Reduce execution time by 30%
+  - Maintain 95% coverage threshold
+
+  Store optimization results: aqe/optimization/results
+  Coordinate with test executor to validate optimized suite.
+`, "qe-coverage-analyzer")
+```
+
+### Coordinated Optimization Workflow
+
+```javascript
+// Optimize suite and validate results
+[Single Message]:
+  Task("Optimize test suite", "Use sublinear algorithms to reduce redundancy", "qe-coverage-analyzer")
+  Task("Validate optimized suite", "Ensure coverage maintained after optimization", "qe-test-executor")
+
+  TodoWrite({ todos: [
+    {content: "Analyze test redundancy", status: "in_progress", activeForm: "Analyzing redundancy"},
+    {content: "Apply sublinear optimization", status: "in_progress", activeForm: "Optimizing suite"},
+    {content: "Validate optimized suite", status: "pending", activeForm: "Validating optimization"},
+    {content: "Measure performance improvement", status: "pending", activeForm: "Measuring improvement"}
+  ]})
+```
+
+## Agent Coordination
+
+### Primary Agent
+- **qe-coverage-analyzer**: Main agent with optimization module
+
+### Supporting Agents
+- **qe-test-executor**: Validates optimized suite
+- **qe-performance-tester**: Measures performance impact
+
+### Coordination Flow
+
+```
+1. Pre-Task Hook
+   ├─> Retrieve test suite metadata
+   ├─> Retrieve coverage matrix
+   ├─> Retrieve execution history
+   └─> Load optimization parameters
+
+2. Optimization Process
+   ├─> Build test-coverage matrix
+   ├─> Apply sublinear optimization algorithm
+   ├─> Calculate minimal test set for target coverage
+   ├─> Identify redundant tests
+   └─> Generate optimized suite
+
+3. Validation Phase
+   ├─> Execute optimized suite
+   ├─> Verify coverage maintained
+   ├─> Measure performance improvement
+   └─> Compare metrics before/after
+
+4. Post-Task Hook
+   ├─> Store optimization results
+   ├─> Update test suite metadata
+   ├─> Train neural patterns
+   └─> Notify fleet of improvements
+```
+
+## Memory Operations
+
+### Input Memory Keys
+
+```bash
+# Retrieve test suite metadata
+npx claude-flow@alpha memory retrieve --key "aqe/test-suite/${suite}"
+
+# Retrieve coverage matrix
+npx claude-flow@alpha memory retrieve --key "aqe/coverage-matrix"
+
+# Retrieve execution history
+npx claude-flow@alpha memory retrieve --key "aqe/execution-history"
+```
+
+### Output Memory Keys
+
+```bash
+# Store optimization results
+npx claude-flow@alpha memory store \
+  --key "aqe/optimization/results" \
+  --value '{"testsBefore": 120, "testsAfter": 85, "coverageDelta": 0.2}'
+
+# Store optimized suite
+npx claude-flow@alpha memory store \
+  --key "aqe/optimized-suite" \
+  --value '{"tests": ["test1.ts", "test2.ts"], "metadata": {}}'
+
+# Store optimization metrics
+npx claude-flow@alpha memory store \
+  --key "aqe/optimization-metrics" \
+  --value '{"timeSaved": 45, "testsRemoved": 35}'
+```
+
+## Hooks and Coordination
+
+### Pre-Task Hook
+
+```bash
+npx claude-flow@alpha hooks pre-task \
+  --description "Optimize ${target} with ${algorithm}" \
+  --agent "qe-coverage-analyzer"
+```
+
+### Post-Task Hook
+
+```bash
+npx claude-flow@alpha hooks post-task \
+  --task-id "${OPT_ID}" \
+  --results "${OPT_RESULTS}"
+```
+
+### Notify Fleet
+
+```bash
+npx claude-flow@alpha hooks notify \
+  --message "Optimization: ${TEST_REDUCTION}% fewer tests, ${TIME_SAVED}s saved"
+```
+
+## Expected Outputs
+
+### Success Output
+
+```
+⚡ Optimizing suite...
+🧮 Running sublinear optimization algorithm...
+
+📊 Optimization Results:
+   Algorithm: sublinear
+   Objective: coverage-per-test
+
+   Tests Before: 120
+   Tests After: 85
+   Reduction: 29.2%
+
+   Coverage Before: 93.5%
+   Coverage After: 93.7%
+   Delta: +0.2%
+
+   Time Saved: 45s per run
+
+✅ Optimization successful! Fewer tests with improved coverage.
+```
+
+### Dry-Run Output
+
+```
+🔍 Optimization Preview (Dry Run):
+
+Would remove 35 tests:
+  ✓ 15 redundant tests (duplicate coverage)
+  ✓ 12 low-value tests (minimal coverage gain)
+  ✓ 8 flaky tests (unreliable)
+
+Projected outcome:
+  • Tests: 120 → 85 (-29.2%)
+  • Coverage: 93.5% → 93.7% (+0.2%)
+  • Execution time: 180s → 135s (-25%)
+
+Run without --dry-run to apply changes.
+```
+
+### Optimization Report
+
+```json
+{
+  "optimizationId": "qe-opt-1727683200-12345",
+  "algorithm": "sublinear",
+  "objective": "coverage-per-test",
+  "before": {
+    "testCount": 120,
+    "coverage": 93.5,
+    "executionTime": 180,
+    "redundantTests": 15
+  },
+  "after": {
+    "testCount": 85,
+    "coverage": 93.7,
+    "executionTime": 135,
+    "redundantTests": 0
+  },
+  "metrics": {
+    "testReduction": 29.2,
+    "coverageDelta": 0.2,
+    "timeSaved": 45,
+    "testsRemoved": [
+      "tests/unit/duplicate-user-test.ts",
+      "tests/unit/redundant-auth-test.ts"
+    ]
+  },
+  "recommendations": [
+    "Consider merging similar test cases",
+    "Review remaining flaky tests",
+    "Monitor coverage after optimization"
+  ],
+  "timestamp": "2025-09-30T10:15:00Z"
+}
+```
+
+## Error Handling
+
+### Optimization Would Reduce Coverage
+
+```bash
+⚠️  Warning: Optimization would reduce coverage by 2.5%
+   Current: 95.0% → Optimized: 92.5%
+
+💡 Options:
+   1. Adjust optimization parameters
+   2. Use less aggressive settings
+   3. Set minimum coverage constraint
+```
+
+**Solution:** Use `--objective coverage-per-test` to prioritize coverage.
+
+### No Redundant Tests Found
+
+```bash
+ℹ️  No optimization opportunities found
+   Suite is already optimal
+
+Metrics:
+   • All tests provide unique coverage
+   • No flaky tests detected
+   • Execution time within budget
+```
+
+**Solution:** Suite is already optimized, no action needed.
+
+### Time Budget Cannot Be Met
+
+```bash
+❌ Error: Cannot meet time budget of 60s
+   Minimum execution time: 85s (with optimal suite)
+
+💡 Suggestions:
+   1. Increase budget to 90s
+   2. Reduce test scope
+   3. Improve test performance
+```
+
+**Solution:** Adjust budget or optimize individual test performance.
+
+## Performance Characteristics
+
+- **Time Complexity**: O(log n) using sublinear algorithms
+- **Target Time**: <15s for 500 tests
+- **Memory Usage**: ~512MB peak
+- **Parallel Support**: Yes (analysis phase)
+
+## Optimization Algorithms
+
+### Sublinear (Default)
+- **Complexity**: O(log n)
+- **Best for**: Large test suites (>100 tests)
+- **Approach**: Minimal set cover with logarithmic search
+
+### Genetic
+- **Complexity**: O(n × generations)
+- **Best for**: Multi-objective optimization
+- **Approach**: Evolutionary algorithm with fitness function
+
+### Greedy
+- **Complexity**: O(n²)
+- **Best for**: Quick optimization
+- **Approach**: Iterative test removal by coverage impact
+
+### Heuristic
+- **Complexity**: O(n)
+- **Best for**: Simple redundancy removal
+- **Approach**: Rule-based test filtering
+
+## See Also
+
+- `/aqe-analyze` - Analyze coverage gaps
+- `/aqe-execute` - Execute optimized suite
+- `/aqe-report` - Generate optimization reports
+- `/aqe-benchmark` - Measure performance improvements