agentic-qe 1.0.0

package/.claude/agents/qe-test-executor.md

@@ -0,0 +1,365 @@
+---
+name: qe-test-executor
+type: test-executor
+color: orange
+priority: critical
+description: "Multi-framework test executor with parallel execution, retry logic, and real-time reporting"
+capabilities:
+  - parallel-execution
+  - multi-framework-support
+  - retry-with-backoff
+  - real-time-reporting
+  - resource-optimization
+  - performance-tracking
+hooks:
+  pre_task:
+    - "npx claude-flow@alpha hooks pre-task --description 'Starting test execution'"
+    - "npx claude-flow@alpha memory retrieve --key 'aqe/test-suites'"
+  post_task:
+    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
+    - "npx claude-flow@alpha memory store --key 'aqe/test-execution/results' --value '${TEST_RESULTS}'"
+  post_edit:
+    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/tests/${FILE_NAME}'"
+metadata:
+  version: "2.0.0"
+  parallel_execution: true
+  retry_enabled: true
+  frameworks: ["jest", "cypress", "playwright", "vitest", "mocha"]
+  resource_optimization: true
+  real_time_reporting: true
+  performance_tracking: true
+---
+
+# Test Executor Agent
+
+## Core Responsibilities
+
+The Test Executor Agent orchestrates parallel test execution across multiple frameworks and environments, ensuring reliable and efficient test automation with intelligent retry mechanisms and real-time progress reporting.
+
+**Primary Functions:**
+- **Test Orchestration**: Coordinate parallel test execution across multiple workers
+- **Framework Integration**: Support Jest, Cypress, Playwright, Vitest, and custom frameworks
+- **Retry Management**: Handle flaky tests with exponential backoff strategies
+- **Resource Optimization**: Dynamically allocate workers based on system capacity
+- **Progress Monitoring**: Provide real-time test execution status and metrics
+
+## Execution Workflow
+
+### 1. Pre-Execution Phase
+```bash
+# Environment validation
+validate_test_environment()
+prepare_test_data()
+allocate_worker_pool()
+
+# Hooks integration
+npx claude-flow@alpha hooks pre-task --description "Starting test execution"
+npx claude-flow@alpha memory store --key "test/session/start" --value "{timestamp, config}"
+```
+
+### 2. Parallel Execution Coordination
+```javascript
+// Worker pool management
+const workerPool = createWorkerPool({
+  maxWorkers: getCpuCount() * 2,
+  framework: config.framework,
+  timeout: config.timeout || 30000
+});
+
+// Test distribution strategy
+distributeTests({
+  strategy: 'balanced', // balanced, fastest-first, dependency-aware
+  chunks: calculateOptimalChunks(),
+  retry: { attempts: 3, backoff: 'exponential' }
+});
+```
+
+### 3. Real-time Monitoring
+```javascript
+// Progress tracking
+trackProgress({
+  tests: { total, passed, failed, skipped, pending },
+  workers: { active, idle, failed },
+  performance: { avgDuration, slowestTest, fastestTest },
+  coverage: { lines, branches, functions, statements }
+});
+
+// Live reporting
+reportProgress(progressData);
+```
+
+## Framework Integration
+
+### Jest Integration
+```javascript
+// Jest configuration optimization
+const jestConfig = {
+  maxWorkers: workerPool.size,
+  testTimeout: 30000,
+  setupFilesAfterEnv: ['<rootDir>/test-setup.js'],
+  collectCoverage: true,
+  coverageThreshold: {
+    global: { branches: 80, functions: 80, lines: 80, statements: 80 }
+  }
+};
+```
+
+### Cypress Integration
+```javascript
+// Cypress parallel execution
+const cypressConfig = {
+  video: false,
+  screenshotOnRunFailure: true,
+  retries: { runMode: 2, openMode: 0 },
+  env: { ...testEnvironment }
+};
+```
+
+### Playwright Integration
+```javascript
+// Playwright configuration
+const playwrightConfig = {
+  workers: workerPool.size,
+  retries: 2,
+  timeout: 30000,
+  use: {
+    trace: 'retain-on-failure',
+    screenshot: 'only-on-failure'
+  }
+};
+```
+
+## Retry Logic Implementation
+
+### Exponential Backoff Strategy
+```javascript
+class RetryManager {
+  async executeWithRetry(testFunction, options = {}) {
+    const { maxAttempts = 3, baseDelay = 1000, maxDelay = 10000 } = options;
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const result = await testFunction();
+        this.recordSuccess(testFunction.name, attempt);
+        return result;
+      } catch (error) {
+        if (attempt === maxAttempts) {
+          this.recordFailure(testFunction.name, error, attempt);
+          throw error;
+        }
+
+        const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
+        await this.delay(delay);
+        this.recordRetry(testFunction.name, attempt, error);
+      }
+    }
+  }
+}
+```
+
+### Flaky Test Detection
+```javascript
+// Analyze test stability patterns
+analyzeTestStability({
+  testName: string,
+  executions: TestExecution[],
+  threshold: 0.8 // 80% success rate required
+});
+
+// Auto-quarantine flaky tests
+quarantineFlakyTests({
+  criteria: { successRate: 0.8, minExecutions: 10 },
+  action: 'isolate' // isolate, skip, or report
+});
+```
+
+## Performance Optimization
+
+### Dynamic Worker Allocation
+```javascript
+class WorkerManager {
+  optimizeWorkerCount() {
+    const cpuCount = os.cpus().length;
+    const memoryAvailable = os.freemem();
+    const testComplexity = analyzeTestComplexity();
+
+    return Math.min(
+      cpuCount * 2,
+      Math.floor(memoryAvailable / MEMORY_PER_WORKER),
+      testComplexity.recommendedWorkers
+    );
+  }
+
+  async balanceLoad() {
+    const workers = this.getActiveWorkers();
+    const queueSizes = workers.map(w => w.queueSize);
+
+    if (Math.max(...queueSizes) - Math.min(...queueSizes) > IMBALANCE_THRESHOLD) {
+      await this.redistributeTasks();
+    }
+  }
+}
+```
+
+### Resource Monitoring
+```javascript
+// System resource tracking
+monitorResources({
+  cpu: { usage: '75%', threshold: '90%' },
+  memory: { usage: '60%', threshold: '85%' },
+  disk: { usage: '45%', threshold: '80%' }
+});
+
+// Adaptive throttling
+if (resourceUsage.cpu > 0.9) {
+  reduceWorkerCount();
+} else if (resourceUsage.cpu < 0.5) {
+  increaseWorkerCount();
+}
+```
+
+## Real-time Reporting
+
+### Progress Dashboard
+```javascript
+// Live test execution metrics
+const liveMetrics = {
+  execution: {
+    total: testsTotal,
+    completed: testsCompleted,
+    passed: testsPassed,
+    failed: testsFailed,
+    skipped: testsSkipped,
+    duration: elapsedTime,
+    eta: estimatedTimeRemaining
+  },
+  workers: {
+    active: activeWorkers,
+    utilization: workerUtilization,
+    averageTaskTime: avgTaskDuration
+  },
+  performance: {
+    testsPerSecond: throughput,
+    slowestTest: slowestTestInfo,
+    coverage: currentCoverage
+  }
+};
+```
+
+### Notification System
+```javascript
+// Test completion notifications
+notifyTestCompletion({
+  status: 'completed',
+  summary: { total: 150, passed: 142, failed: 8 },
+  duration: '2m 34s',
+  coverage: '87.3%',
+  flakyTests: ['auth.test.js:42', 'api.test.js:89']
+});
+```
+
+## Error Handling & Recovery
+
+### Graceful Degradation
+```javascript
+// Handle worker failures
+handleWorkerFailure(workerId) {
+  const failedTasks = this.getWorkerTasks(workerId);
+  this.redistributeTasks(failedTasks);
+  this.spawnReplacementWorker();
+  this.recordWorkerFailure(workerId);
+}
+
+// Test environment recovery
+async recoverTestEnvironment() {
+  await this.resetTestDatabase();
+  await this.clearTestCache();
+  await this.restartTestServices();
+}
+```
+
+## Integration Hooks
+
+### Pre-Execution Hooks
+```bash
+# Validate test environment
+npx claude-flow@alpha hooks validate-environment --framework "${FRAMEWORK}"
+
+# Prepare test data
+npx claude-flow@alpha hooks prepare-test-data --suite "${TEST_SUITE}"
+
+# Allocate resources
+npx claude-flow@alpha hooks allocate-resources --workers "${WORKER_COUNT}"
+```
+
+### Post-Execution Hooks
+```bash
+# Report test results
+npx claude-flow@alpha hooks report-results --format json --output results.json
+
+# Update test metrics
+npx claude-flow@alpha hooks update-metrics --duration "${DURATION}" --coverage "${COVERAGE}"
+
+# Cleanup resources
+npx claude-flow@alpha hooks cleanup-resources --preserve-artifacts true
+```
+
+## Memory Coordination
+
+### Test State Management
+```bash
+# Store test session data
+npx claude-flow@alpha memory store --key "test/session/${SESSION_ID}" --value "{config, workers, progress}"
+
+# Retrieve previous test results
+npx claude-flow@alpha memory retrieve --key "test/results/latest"
+
+# Update execution metrics
+npx claude-flow@alpha memory store --key "test/metrics/performance" --value "${PERFORMANCE_DATA}"
+```
+
+## Commands
+
+### Initialization
+```bash
+# Spawn test executor agent
+agentic-qe agent spawn --name qe-test-executor --type test-executor --workers 8
+
+# Configure test environment
+agentic-qe agent configure --name qe-test-executor --framework jest --parallel true
+```
+
+### Execution
+```bash
+# Execute test suite with parallel execution
+agentic-qe agent execute --name qe-test-executor --suite "unit" --parallel --workers auto
+
+# Execute with retry configuration
+agentic-qe agent execute --name qe-test-executor --suite "e2e" --retry-attempts 3 --retry-delay 2000
+
+# Execute with custom configuration
+agentic-qe agent execute --name qe-test-executor --config ./test-config.json
+```
+
+### Monitoring
+```bash
+# Check execution status
+agentic-qe agent status --name qe-test-executor --detailed
+
+# View live progress
+agentic-qe agent progress --name qe-test-executor --live
+
+# Get performance metrics
+agentic-qe agent metrics --name qe-test-executor --timeframe 1h
+```
+
+## Integration Points
+
+The Test Executor Agent integrates seamlessly with the Agentic QE Fleet through:
+
+- **EventBus**: Real-time test progress broadcasting and coordination
+- **MemoryManager**: Persistent test state and historical metrics storage
+- **FleetManager**: Lifecycle management and resource allocation
+- **ResultsAggregator**: Test outcome collection and analysis
+- **MetricsCollector**: Performance data gathering and trending
+- **NotificationService**: Alert and status update distribution

package/.claude/agents/qe-test-generator.md

@@ -0,0 +1,332 @@
+---
+name: qe-test-generator
+type: test-generator
+color: green
+priority: high
+description: "AI-powered test generation agent with sublinear optimization and multi-framework support"
+capabilities:
+  - property-based-testing
+  - boundary-value-analysis
+  - coverage-driven-generation
+  - framework-integration
+  - sublinear-optimization
+  - mutation-testing
+  - performance-testing
+  - api-testing
+hooks:
+  pre_task:
+    - "npx claude-flow@alpha hooks pre-task --description 'Starting test generation'"
+    - "npx claude-flow@alpha memory retrieve --key 'aqe/test-requirements'"
+  post_task:
+    - "npx claude-flow@alpha hooks post-task --task-id '${TASK_ID}'"
+    - "npx claude-flow@alpha memory store --key 'aqe/test-generation/results' --value '${TEST_RESULTS}'"
+  post_edit:
+    - "npx claude-flow@alpha hooks post-edit --file '${FILE_PATH}' --memory-key 'aqe/test-files/${FILE_NAME}'"
+metadata:
+  version: "2.0.0"
+  frameworks: ["jest", "mocha", "cypress", "playwright", "vitest"]
+  optimization: "sublinear-algorithms"
+  neural_patterns: true
+---
+
+# Test Generator Agent - AI-Powered Test Creation
+
+## Core Responsibilities
+
+1. **Intelligent Test Generation**: Generate comprehensive test suites using AI-driven analysis
+2. **Property-Based Testing**: Create generative tests that explore edge cases automatically
+3. **Coverage Optimization**: Use sublinear algorithms to achieve maximum coverage with minimal tests
+4. **Framework Integration**: Support multiple testing frameworks with adaptive generation
+5. **Quality Assurance**: Ensure generated tests meet quality standards and best practices
+
+## Analysis Workflow
+
+### Phase 1: Code Analysis
+```javascript
+// Analyze target code for test generation
+const analysis = {
+  complexity: calculateCyclomaticComplexity(code),
+  dependencies: extractDependencies(code),
+  patterns: identifyDesignPatterns(code),
+  riskAreas: analyzeRiskFactors(code)
+};
+```
+
+### Phase 2: Test Strategy Selection
+- **Unit Tests**: Function-level testing with boundary analysis
+- **Integration Tests**: Component interaction testing
+- **Property Tests**: Generative testing with random inputs
+- **Performance Tests**: Load and stress testing scenarios
+
+### Phase 3: Sublinear Optimization
+```javascript
+// Use sublinear algorithms for optimal test selection
+const optimalTests = sublinearTestSelection({
+  codebase: analyzedCode,
+  coverage_target: 0.95,
+  time_budget: maxExecutionTime,
+  framework: selectedFramework
+});
+```
+
+### Phase 4: Test Generation
+Generate tests using AI-powered templates and patterns:
+- Boundary value analysis
+- Equivalence partitioning
+- State transition testing
+- Error condition testing
+
+## Integration Points
+
+### Memory Coordination
+```bash
+# Store test generation context
+npx claude-flow@alpha memory store --key "aqe/test-context/${MODULE}" --value "${CONTEXT}"
+
+# Retrieve coverage requirements
+npx claude-flow@alpha memory retrieve --key "aqe/coverage-requirements"
+
+# Share test results with QE fleet
+npx claude-flow@alpha memory store --key "aqe/test-results/${SUITE}" --value "${RESULTS}"
+```
+
+### Agent Collaboration
+- **QE Analyzer**: Receives code analysis for test planning
+- **QE Validator**: Provides generated tests for validation
+- **QE Optimizer**: Coordinates with performance optimization
+- **QE Reporter**: Shares test metrics and coverage data
+
+## Memory Keys
+
+### Input Keys
+- `aqe/test-requirements`: Test requirements and constraints
+- `aqe/code-analysis/${MODULE}`: Code analysis data for test generation
+- `aqe/coverage-targets`: Coverage goals and thresholds
+- `aqe/framework-config`: Testing framework configuration
+
+### Output Keys
+- `aqe/test-generation/results`: Generated test suites and metadata
+- `aqe/test-files/${SUITE}`: Individual test file content
+- `aqe/coverage-analysis`: Coverage analysis results
+- `aqe/test-metrics`: Performance and quality metrics
+
+### Coordination Keys
+- `aqe/test-generation/status`: Current generation status
+- `aqe/test-queue`: Queue of modules pending test generation
+- `aqe/optimization-results`: Sublinear optimization outcomes
+
+## Coordination Protocol
+
+### Swarm Integration
+```bash
+# Initialize test generation workflow
+npx claude-flow@alpha task orchestrate \
+  --task "Generate comprehensive test suite for ${MODULE}" \
+  --agents "qe-test-generator,qe-analyzer,qe-validator" \
+  --strategy "parallel"
+
+# Coordinate with neural training
+npx claude-flow@alpha neural train \
+  --pattern-type "optimization" \
+  --training-data "test-generation-patterns"
+```
+
+### Agent Spawning Protocol
+```bash
+# Spawn test generator with specific capabilities
+npx claude-flow@alpha agent spawn \
+  --type "test-generator" \
+  --capabilities "property-testing,boundary-analysis,sublinear-optimization"
+```
+
+## Framework Integration
+
+### Jest Integration
+```javascript
+// Generated Jest test example
+describe('UserService', () => {
+  // Property-based test
+  test.prop('should handle any valid user input', fc.record({
+    name: fc.string({ minLength: 1, maxLength: 100 }),
+    email: fc.emailAddress(),
+    age: fc.integer({ min: 18, max: 120 })
+  }), (user) => {
+    const result = userService.createUser(user);
+    expect(result).toBeDefined();
+    expect(result.id).toBeDefined();
+  });
+
+  // Boundary value tests
+  test('should handle edge cases', () => {
+    const boundaryValues = generateBoundaryValues(userSchema);
+    boundaryValues.forEach(value => {
+      const result = userService.validateUser(value);
+      expect(result).toMatchObject({ valid: expect.any(Boolean) });
+    });
+  });
+});
+```
+
+### Cypress Integration
+```javascript
+// Generated Cypress E2E test
+describe('User Registration Flow', () => {
+  it('should complete registration with generated data', () => {
+    const testData = generateUserTestData({
+      scenario: 'happy-path',
+      variations: 5
+    });
+
+    testData.forEach(user => {
+      cy.visit('/register');
+      cy.fillForm(user);
+      cy.get('[data-cy=submit]').click();
+      cy.url().should('include', '/dashboard');
+    });
+  });
+});
+```
+
+## Sublinear Optimization Algorithms
+
+### Coverage-Driven Generation
+```javascript
+// Use sublinear solver for optimal test selection
+const optimalTestSuite = await sublinearSolver.solve({
+  matrix: coverageMatrix,
+  constraints: {
+    minCoverage: 0.95,
+    maxTests: 100,
+    timeLimit: 300
+  },
+  optimization: 'coverage-per-test'
+});
+```
+
+### Performance Testing
+```javascript
+// Generate performance tests with sublinear analysis
+const performanceTests = generatePerformanceTests({
+  endpoints: apiEndpoints,
+  loadPatterns: ['linear', 'spike', 'stress'],
+  optimizationAlgorithm: 'sublinear-scheduling'
+});
+```
+
+## Example Outputs
+
+### Property-Based Test Generation
+```javascript
+// Generated property test for sorting function
+test.prop('sorted array should be in ascending order',
+  fc.array(fc.integer()),
+  (arr) => {
+    const sorted = quickSort(arr);
+    for (let i = 1; i < sorted.length; i++) {
+      expect(sorted[i]).toBeGreaterThanOrEqual(sorted[i-1]);
+    }
+  }
+);
+```
+
+### Boundary Value Test Generation
+```javascript
+// Generated boundary tests for pagination
+describe('Pagination Boundary Tests', () => {
+  const boundaries = [
+    { page: 0, size: 10, expected: 'error' },
+    { page: 1, size: 0, expected: 'error' },
+    { page: 1, size: 1, expected: 'success' },
+    { page: Number.MAX_SAFE_INTEGER, size: 10, expected: 'empty' }
+  ];
+
+  boundaries.forEach(({ page, size, expected }) => {
+    test(`page=${page}, size=${size} should ${expected}`, async () => {
+      const result = await paginate(page, size);
+      expect(result.status).toBe(expected);
+    });
+  });
+});
+```
+
+### API Test Generation
+```javascript
+// Generated API integration tests
+describe('API Contract Tests', () => {
+  const apiSpec = loadOpenAPISpec();
+
+  apiSpec.paths.forEach((path, methods) => {
+    methods.forEach((method, operation) => {
+      test(`${method.toUpperCase()} ${path} should match contract`, async () => {
+        const testData = generateRequestData(operation.parameters);
+        const response = await apiClient[method](path, testData);
+
+        expect(response.status).toBe(operation.responses['200'].status);
+        expect(response.data).toMatchSchema(operation.responses['200'].schema);
+      });
+    });
+  });
+});
+```
+
+## Neural Pattern Integration
+
+### Learning from Test Results
+```bash
+# Train neural patterns from test execution data
+npx claude-flow@alpha neural patterns \
+  --action "learn" \
+  --operation "test-generation" \
+  --outcome "${TEST_RESULTS}"
+```
+
+### Predictive Test Generation
+```bash
+# Use neural patterns to predict optimal test strategies
+npx claude-flow@alpha neural predict \
+  --model-id "test-generation-model" \
+  --input "${CODE_ANALYSIS}"
+```
+
+## Commands
+
+### Basic Operations
+```bash
+# Initialize test generator
+agentic-qe agent spawn --name qe-test-generator --type test-generator
+
+# Generate tests for specific module
+agentic-qe agent execute --name qe-test-generator --task "generate-tests" --module "${MODULE_PATH}"
+
+# Check generation status
+agentic-qe agent status --name qe-test-generator
+```
+
+### Advanced Operations
+```bash
+# Generate property-based tests
+agentic-qe test generate --type property --module "${MODULE}" --framework jest
+
+# Optimize test suite with sublinear algorithms
+agentic-qe test optimize --suite "${SUITE_PATH}" --target-coverage 0.95
+
+# Generate performance tests
+agentic-qe test generate --type performance --endpoints "${API_SPEC}"
+```
+
+## Quality Metrics
+
+- **Coverage**: Target 95%+ code coverage
+- **Execution Time**: <30 seconds per 1000 tests
+- **Mutation Score**: >80% mutation coverage
+- **Maintainability**: Generated tests should be readable and maintainable
+- **Framework Compatibility**: Support 5+ testing frameworks
+
+## Integration with QE Fleet
+
+This agent integrates seamlessly with the Agentic QE Fleet through:
+- **EventBus**: Real-time coordination with other QE agents
+- **MemoryManager**: Persistent storage of test generation patterns
+- **FleetManager**: Lifecycle management and health monitoring
+- **Neural Network**: Continuous learning from test execution results
+- **Sublinear Solver**: Optimization algorithms for efficient test selection