@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/domains/test-execution/services/test-executor.ts

@@ -1,885 +0,0 @@
-/**
- * Agentic QE v3 - Test Executor Service
- * Implements ITestExecutionService for running test suites
- */
-
-import { spawn, ChildProcess } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { v4 as uuidv4 } from 'uuid';
-import { Result, ok, err } from '../../../shared/types';
-import {
-  ExecuteTestsRequest,
-  ParallelExecutionRequest,
-  TestRunResult,
-  FailedTest,
-  ExecutionStats,
-} from '../interfaces';
-import { MemoryBackend } from '../../../kernel/interfaces';
-
-// ============================================================================
-// Configuration
-// ============================================================================
-
-/**
- * Configuration for the test executor service
- */
-export interface TestExecutorConfig {
-  /**
-   * When true, simulates test execution with random outcomes (for unit testing).
-   * When false (default), returns deterministic results or structured errors
-   * indicating no real test runner is available.
-   */
-  simulateForTesting: boolean;
-  /**
-   * Base number of tests to report per file in simulation mode.
-   * Defaults to 5.
-   */
-  simulatedTestsPerFile: number;
-  /**
-   * Simulated failure rate (0-1) when simulateForTesting is true.
-   * Defaults to 0.2 (20% chance of failure per file).
-   */
-  simulatedFailureRate: number;
-  /**
-   * Simulated skip rate (0-1) when simulateForTesting is true.
-   * Defaults to 0.1 (10% chance of skip per file).
-   */
-  simulatedSkipRate: number;
-}
-
-const DEFAULT_CONFIG: TestExecutorConfig = {
-  simulateForTesting: false,
-  simulatedTestsPerFile: 5,
-  simulatedFailureRate: 0.2,
-  simulatedSkipRate: 0.1,
-};
-
-// ============================================================================
-// Interfaces
-// ============================================================================
-
-export interface ITestExecutionService {
-  /** Execute test suite */
-  execute(request: ExecuteTestsRequest): Promise<Result<TestRunResult, Error>>;
-
-  /** Execute tests in parallel */
-  executeParallel(request: ParallelExecutionRequest): Promise<Result<TestRunResult, Error>>;
-
-  /** Get execution results by run ID */
-  getResults(runId: string): Promise<Result<TestRunResult, Error>>;
-
-  /** Get execution statistics */
-  getStats(runId: string): Promise<Result<ExecutionStats, Error>>;
-}
-
-// ============================================================================
-// Test Executor Service
-// ============================================================================
-
-export class TestExecutorService implements ITestExecutionService {
-  private readonly runResults = new Map<string, TestRunResult>();
-  private readonly runStats = new Map<string, ExecutionStats>();
-  private readonly config: TestExecutorConfig;
-
-  constructor(
-    private readonly memory: MemoryBackend,
-    config: Partial<TestExecutorConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Execute a test suite sequentially
-   */
-  async execute(request: ExecuteTestsRequest): Promise<Result<TestRunResult, Error>> {
-    const runId = uuidv4();
-    const startTime = new Date();
-
-    try {
-      // Validate request
-      const validation = this.validateRequest(request);
-      if (validation.success === false) {
-        return err(validation.error);
-      }
-
-      // Execute tests
-      const results = await this.runTests(request);
-
-      // Create run result
-      const endTime = new Date();
-      const duration = endTime.getTime() - startTime.getTime();
-
-      const runResult: TestRunResult = {
-        runId,
-        status: results.failed > 0 ? 'failed' : 'passed',
-        total: results.total,
-        passed: results.passed,
-        failed: results.failed,
-        skipped: results.skipped,
-        duration,
-        failedTests: results.failedTests,
-        coverage: results.coverage,
-      };
-
-      // Store results
-      this.runResults.set(runId, runResult);
-      await this.storeResults(runId, runResult);
-
-      // Create and store stats
-      const stats: ExecutionStats = {
-        runId,
-        startTime,
-        endTime,
-        duration,
-        testsPerSecond: results.total / (duration / 1000),
-        workers: 1,
-        memoryUsage: process.memoryUsage?.().heapUsed ?? 0,
-      };
-      this.runStats.set(runId, stats);
-
-      return ok(runResult);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Execute tests in parallel across multiple workers
-   */
-  async executeParallel(request: ParallelExecutionRequest): Promise<Result<TestRunResult, Error>> {
-    const runId = uuidv4();
-    const startTime = new Date();
-
-    try {
-      // Validate request
-      const validation = this.validateParallelRequest(request);
-      if (validation.success === false) {
-        return err(validation.error);
-      }
-
-      const { workers, sharding = 'file', isolation = 'process' } = request;
-
-      // Shard tests across workers
-      const shards = this.shardTests(request.testFiles, workers, sharding);
-
-      // Execute shards in parallel
-      const shardResults = await Promise.all(
-        shards.map((shard, index) =>
-          this.executeWorker(shard, index, isolation, request)
-        )
-      );
-
-      // Aggregate results
-      const aggregated = this.aggregateResults(shardResults);
-
-      const endTime = new Date();
-      const duration = endTime.getTime() - startTime.getTime();
-
-      const runResult: TestRunResult = {
-        runId,
-        status: aggregated.failed > 0 ? 'failed' : 'passed',
-        total: aggregated.total,
-        passed: aggregated.passed,
-        failed: aggregated.failed,
-        skipped: aggregated.skipped,
-        duration,
-        failedTests: aggregated.failedTests,
-        coverage: aggregated.coverage,
-      };
-
-      // Store results
-      this.runResults.set(runId, runResult);
-      await this.storeResults(runId, runResult);
-
-      // Create and store stats
-      const stats: ExecutionStats = {
-        runId,
-        startTime,
-        endTime,
-        duration,
-        testsPerSecond: aggregated.total / (duration / 1000),
-        workers,
-        memoryUsage: process.memoryUsage?.().heapUsed ?? 0,
-      };
-      this.runStats.set(runId, stats);
-
-      return ok(runResult);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Get results for a specific run
-   */
-  async getResults(runId: string): Promise<Result<TestRunResult, Error>> {
-    // Check in-memory cache first
-    const cached = this.runResults.get(runId);
-    if (cached) {
-      return ok(cached);
-    }
-
-    // Check persistent storage
-    try {
-      const stored = await this.memory.get<TestRunResult>(`test-run:${runId}`);
-      if (stored) {
-        this.runResults.set(runId, stored);
-        return ok(stored);
-      }
-    } catch {
-      // Continue to error
-    }
-
-    return err(new Error(`Test run not found: ${runId}`));
-  }
-
-  /**
-   * Get execution statistics for a run
-   */
-  async getStats(runId: string): Promise<Result<ExecutionStats, Error>> {
-    const cached = this.runStats.get(runId);
-    if (cached) {
-      return ok(cached);
-    }
-
-    try {
-      const stored = await this.memory.get<ExecutionStats>(`test-stats:${runId}`);
-      if (stored) {
-        this.runStats.set(runId, stored);
-        return ok(stored);
-      }
-    } catch {
-      // Continue to error
-    }
-
-    return err(new Error(`Test stats not found: ${runId}`));
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  private validateRequest(request: ExecuteTestsRequest): Result<void, Error> {
-    if (!request.testFiles || request.testFiles.length === 0) {
-      return err(new Error('No test files specified'));
-    }
-    if (!request.framework) {
-      return err(new Error('Framework not specified'));
-    }
-    return ok(undefined);
-  }
-
-  private validateParallelRequest(request: ParallelExecutionRequest): Result<void, Error> {
-    const baseValidation = this.validateRequest(request);
-    if (!baseValidation.success) {
-      return baseValidation;
-    }
-    if (request.workers < 1) {
-      return err(new Error('Workers must be at least 1'));
-    }
-    if (request.workers > 32) {
-      return err(new Error('Workers cannot exceed 32'));
-    }
-    return ok(undefined);
-  }
-
-  private async runTests(request: ExecuteTestsRequest): Promise<TestExecutionResult> {
-    const { testFiles, framework, timeout = 30000 } = request;
-
-    const failedTests: FailedTest[] = [];
-    let passed = 0;
-    let failed = 0;
-    let skipped = 0;
-
-    for (const file of testFiles) {
-      const result = await this.executeTestFile(file, framework, timeout);
-      passed += result.passed;
-      failed += result.failed;
-      skipped += result.skipped;
-      failedTests.push(...result.failedTests);
-    }
-
-    return {
-      total: passed + failed + skipped,
-      passed,
-      failed,
-      skipped,
-      failedTests,
-      coverage: this.aggregateCoverage([]),
-    };
-  }
-
-  private async executeTestFile(
-    file: string,
-    framework: string,
-    timeout: number
-  ): Promise<TestExecutionResult> {
-    // In simulation mode (for unit testing), use random behavior
-    if (this.config.simulateForTesting) {
-      return this.simulateTestExecution(file);
-    }
-
-    // Production mode: spawn actual test runner process
-    const result = await this.spawnTestRunner(file, framework, timeout);
-    if (result.success === false) {
-      throw result.error;
-    }
-    return result.value;
-  }
-
-  /**
-   * Spawn actual test runner process (vitest, jest, mocha)
-   */
-  private async spawnTestRunner(
-    file: string,
-    framework: string,
-    timeout: number
-  ): Promise<Result<TestExecutionResult, Error>> {
-    // Verify test file exists
-    if (!existsSync(file)) {
-      return err(new Error(`Test file not found: ${file}`));
-    }
-
-    // Build command based on framework
-    const { command, args } = this.buildTestCommand(file, framework);
-
-    return new Promise((resolve) => {
-      let stdout = '';
-      let stderr = '';
-      let killed = false;
-
-      // Spawn the test runner process
-      // Note: shell: false (default) to prevent command injection (CWE-78)
-      // Arguments are passed as array to avoid shell interpretation
-      const proc: ChildProcess = spawn(command, args, {
-        cwd: process.cwd(),
-        env: {
-          ...process.env,
-          FORCE_COLOR: '0', // Disable color codes for easier parsing
-          CI: 'true', // Enable CI mode for consistent output
-        },
-      });
-
-      // Set timeout
-      const timeoutId = setTimeout(() => {
-        killed = true;
-        proc.kill('SIGTERM');
-        resolve(err(new Error(`Test execution timed out after ${timeout}ms for file: ${file}`)));
-      }, timeout);
-
-      proc.stdout?.on('data', (data: Buffer) => {
-        stdout += data.toString();
-      });
-
-      proc.stderr?.on('data', (data: Buffer) => {
-        stderr += data.toString();
-      });
-
-      proc.on('close', (code: number | null) => {
-        clearTimeout(timeoutId);
-
-        if (killed) {
-          return; // Already handled by timeout
-        }
-
-        // Parse results based on framework
-        const parseResult = this.parseTestOutput(stdout, stderr, file, framework, code);
-        resolve(parseResult);
-      });
-
-      proc.on('error', (error: Error) => {
-        clearTimeout(timeoutId);
-        resolve(err(new Error(`Failed to spawn test runner: ${error.message}. Is '${command}' installed?`)));
-      });
-    });
-  }
-
-  /**
-   * Build test command based on framework
-   */
-  private buildTestCommand(file: string, framework: string): { command: string; args: string[] } {
-    switch (framework.toLowerCase()) {
-      case 'vitest':
-        return {
-          command: 'npx',
-          args: ['vitest', 'run', file, '--reporter=json', '--no-color'],
-        };
-      case 'jest':
-        return {
-          command: 'npx',
-          args: ['jest', file, '--json', '--no-colors', '--testLocationInResults'],
-        };
-      case 'mocha':
-        return {
-          command: 'npx',
-          args: ['mocha', file, '--reporter=json'],
-        };
-      default:
-        // Default to vitest
-        return {
-          command: 'npx',
-          args: ['vitest', 'run', file, '--reporter=json', '--no-color'],
-        };
-    }
-  }
-
-  /**
-   * Parse test runner output to extract results
-   */
-  private parseTestOutput(
-    stdout: string,
-    stderr: string,
-    file: string,
-    framework: string,
-    exitCode: number | null
-  ): Result<TestExecutionResult, Error> {
-    try {
-      switch (framework.toLowerCase()) {
-        case 'vitest':
-          return this.parseVitestOutput(stdout, stderr, file, exitCode);
-        case 'jest':
-          return this.parseJestOutput(stdout, stderr, file, exitCode);
-        case 'mocha':
-          return this.parseMochaOutput(stdout, stderr, file, exitCode);
-        default:
-          return this.parseVitestOutput(stdout, stderr, file, exitCode);
-      }
-    } catch (error) {
-      return err(new Error(
-        `Failed to parse test output for ${file}: ${error instanceof Error ? error.message : String(error)}\n` +
-        `stdout: ${stdout.slice(0, 500)}\nstderr: ${stderr.slice(0, 500)}`
-      ));
-    }
-  }
-
-  /**
-   * Parse vitest JSON output
-   */
-  private parseVitestOutput(
-    stdout: string,
-    stderr: string,
-    file: string,
-    exitCode: number | null
-  ): Result<TestExecutionResult, Error> {
-    // Try to extract JSON from output
-    const jsonMatch = stdout.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
-
-    if (jsonMatch) {
-      try {
-        const json = JSON.parse(jsonMatch[0]);
-        const testResults = json.testResults || [];
-
-        let passed = 0;
-        let failed = 0;
-        let skipped = 0;
-        const failedTests: FailedTest[] = [];
-
-        for (const result of testResults) {
-          for (const assertion of result.assertionResults || []) {
-            if (assertion.status === 'passed') {
-              passed++;
-            } else if (assertion.status === 'failed') {
-              failed++;
-              failedTests.push({
-                testId: uuidv4(),
-                testName: assertion.fullName || assertion.title || 'Unknown test',
-                file: result.name || file,
-                error: assertion.failureMessages?.join('\n') || 'Test failed',
-                stack: assertion.failureMessages?.join('\n') || '',
-                duration: assertion.duration || 0,
-              });
-            } else if (assertion.status === 'skipped' || assertion.status === 'pending') {
-              skipped++;
-            }
-          }
-        }
-
-        return ok({
-          total: passed + failed + skipped,
-          passed,
-          failed,
-          skipped,
-          failedTests,
-          coverage: undefined,
-        });
-      } catch {
-        // JSON parse failed, fall through to line parsing
-      }
-    }
-
-    // Fallback: parse summary line from vitest output
-    // Example: "Tests  5 passed | 1 failed | 1 skipped (7)"
-    return this.parseTestSummaryLine(stdout, stderr, file, exitCode);
-  }
-
-  /**
-   * Parse jest JSON output
-   */
-  private parseJestOutput(
-    stdout: string,
-    stderr: string,
-    file: string,
-    exitCode: number | null
-  ): Result<TestExecutionResult, Error> {
-    try {
-      // Jest outputs JSON to stdout when --json flag is used
-      const json = JSON.parse(stdout);
-
-      let passed = 0;
-      let failed = 0;
-      let skipped = 0;
-      const failedTests: FailedTest[] = [];
-
-      for (const result of json.testResults || []) {
-        for (const assertion of result.assertionResults || []) {
-          if (assertion.status === 'passed') {
-            passed++;
-          } else if (assertion.status === 'failed') {
-            failed++;
-            failedTests.push({
-              testId: uuidv4(),
-              testName: assertion.fullName || assertion.title || 'Unknown test',
-              file: result.name || file,
-              error: assertion.failureMessages?.join('\n') || 'Test failed',
-              stack: assertion.failureMessages?.join('\n') || '',
-              duration: assertion.duration || 0,
-            });
-          } else if (assertion.status === 'skipped' || assertion.status === 'pending') {
-            skipped++;
-          }
-        }
-      }
-
-      return ok({
-        total: passed + failed + skipped,
-        passed,
-        failed,
-        skipped,
-        failedTests,
-        coverage: undefined,
-      });
-    } catch {
-      return this.parseTestSummaryLine(stdout, stderr, file, exitCode);
-    }
-  }
-
-  /**
-   * Parse mocha JSON output
-   */
-  private parseMochaOutput(
-    stdout: string,
-    stderr: string,
-    file: string,
-    exitCode: number | null
-  ): Result<TestExecutionResult, Error> {
-    try {
-      const json = JSON.parse(stdout);
-
-      const passed = json.stats?.passes || 0;
-      const failed = json.stats?.failures || 0;
-      const skipped = json.stats?.pending || 0;
-      const failedTests: FailedTest[] = [];
-
-      for (const failure of json.failures || []) {
-        failedTests.push({
-          testId: uuidv4(),
-          testName: failure.fullTitle || failure.title || 'Unknown test',
-          file: failure.file || file,
-          error: failure.err?.message || 'Test failed',
-          stack: failure.err?.stack || '',
-          duration: failure.duration || 0,
-        });
-      }
-
-      return ok({
-        total: passed + failed + skipped,
-        passed,
-        failed,
-        skipped,
-        failedTests,
-        coverage: undefined,
-      });
-    } catch {
-      return this.parseTestSummaryLine(stdout, stderr, file, exitCode);
-    }
-  }
-
-  /**
-   * Fallback: parse test summary line from text output
-   */
-  private parseTestSummaryLine(
-    stdout: string,
-    stderr: string,
-    file: string,
-    exitCode: number | null
-  ): Result<TestExecutionResult, Error> {
-    // Look for common patterns in test output
-    // Vitest: "Tests  5 passed | 1 failed | 1 skipped (7)"
-    // Jest: "Tests:       1 failed, 5 passed, 6 total"
-
-    const combinedOutput = stdout + '\n' + stderr;
-
-    // Vitest pattern
-    const vitestMatch = combinedOutput.match(/Tests\s+(\d+)\s+passed(?:\s*\|\s*(\d+)\s+failed)?(?:\s*\|\s*(\d+)\s+skipped)?/i);
-    if (vitestMatch) {
-      const passed = parseInt(vitestMatch[1], 10) || 0;
-      const failed = parseInt(vitestMatch[2], 10) || 0;
-      const skipped = parseInt(vitestMatch[3], 10) || 0;
-
-      return ok({
-        total: passed + failed + skipped,
-        passed,
-        failed,
-        skipped,
-        failedTests: failed > 0 ? this.createGenericFailures(file, failed, combinedOutput) : [],
-        coverage: undefined,
-      });
-    }
-
-    // Jest pattern
-    const jestMatch = combinedOutput.match(/Tests:\s+(?:(\d+)\s+failed,\s+)?(?:(\d+)\s+skipped,\s+)?(\d+)\s+passed,\s+(\d+)\s+total/i);
-    if (jestMatch) {
-      const failed = parseInt(jestMatch[1], 10) || 0;
-      const skipped = parseInt(jestMatch[2], 10) || 0;
-      const passed = parseInt(jestMatch[3], 10) || 0;
-
-      return ok({
-        total: passed + failed + skipped,
-        passed,
-        failed,
-        skipped,
-        failedTests: failed > 0 ? this.createGenericFailures(file, failed, combinedOutput) : [],
-        coverage: undefined,
-      });
-    }
-
-    // Check for common error indicators
-    if (exitCode !== 0) {
-      const errorMessages = [
-        'Cannot find module',
-        'SyntaxError',
-        'Error:',
-        'FAIL',
-        'failed',
-      ];
-
-      for (const indicator of errorMessages) {
-        if (combinedOutput.includes(indicator)) {
-          return err(new Error(
-            `Test execution failed for ${file} (exit code ${exitCode}):\n${combinedOutput.slice(0, 1000)}`
-          ));
-        }
-      }
-    }
-
-    // If we got here with exit code 0 but no parseable output,
-    // it might mean the file had no tests or an unsupported format
-    if (exitCode === 0) {
-      // Check if output indicates no tests
-      if (combinedOutput.includes('No test') || combinedOutput.includes('0 tests')) {
-        return err(new Error(`No tests found in file: ${file}`));
-      }
-    }
-
-    // Could not parse output - return error with details
-    return err(new Error(
-      `Unable to parse test results for ${file}. Exit code: ${exitCode}\n` +
-      `Output: ${combinedOutput.slice(0, 500)}`
-    ));
-  }
-
-  /**
-   * Create generic failure entries when we know tests failed but can't parse details
-   */
-  private createGenericFailures(file: string, count: number, output: string): FailedTest[] {
-    const failures: FailedTest[] = [];
-
-    // Try to extract failure details from output
-    const failurePattern = /FAIL\s+(.+?)(?:\n|$)|AssertionError[:\s]+(.+?)(?:\n|$)|Error[:\s]+(.+?)(?:\n|$)/gi;
-    const matches = Array.from(output.matchAll(failurePattern));
-
-    for (const match of matches) {
-      if (failures.length >= count) break;
-      failures.push({
-        testId: uuidv4(),
-        testName: match[1] || match[2] || match[3] || `Test #${failures.length + 1}`,
-        file,
-        error: match[0].trim(),
-        stack: '',
-        duration: 0,
-      });
-    }
-
-    // Fill remaining with generic entries
-    while (failures.length < count) {
-      failures.push({
-        testId: uuidv4(),
-        testName: `Failed test #${failures.length + 1}`,
-        file,
-        error: 'Test failed (details not available)',
-        stack: '',
-        duration: 0,
-      });
-    }
-
-    return failures;
-  }
-
-  /**
-   * Simulate test execution with random outcomes (for unit testing only)
-   */
-  private simulateTestExecution(file: string): TestExecutionResult {
-    const testCount = Math.floor(Math.random() * 10) + 1;
-    const failCount = Math.random() > (1 - this.config.simulatedFailureRate) ? 1 : 0;
-    const skipCount = Math.random() > (1 - this.config.simulatedSkipRate) ? 1 : 0;
-
-    const failedTests: FailedTest[] = [];
-    if (failCount > 0) {
-      failedTests.push({
-        testId: uuidv4(),
-        testName: `test in ${file}`,
-        file,
-        error: 'Assertion failed',
-        stack: `Error: Assertion failed\n    at ${file}:10:5`,
-        duration: Math.random() * 1000,
-      });
-    }
-
-    return {
-      total: testCount,
-      passed: testCount - failCount - skipCount,
-      failed: failCount,
-      skipped: skipCount,
-      failedTests,
-      coverage: undefined,
-    };
-  }
-
-  private shardTests(
-    testFiles: string[],
-    workers: number,
-    strategy: 'file' | 'test' | 'time-balanced'
-  ): string[][] {
-    const shards: string[][] = Array.from({ length: workers }, () => []);
-
-    switch (strategy) {
-      case 'file':
-        // Simple round-robin distribution
-        testFiles.forEach((file, index) => {
-          shards[index % workers].push(file);
-        });
-        break;
-
-      case 'test':
-        // For test-level sharding, we'd need to parse test files
-        // Fall back to file sharding for now
-        testFiles.forEach((file, index) => {
-          shards[index % workers].push(file);
-        });
-        break;
-
-      case 'time-balanced':
-        // Would need historical timing data
-        // Fall back to file sharding for now
-        testFiles.forEach((file, index) => {
-          shards[index % workers].push(file);
-        });
-        break;
-    }
-
-    return shards;
-  }
-
-  private async executeWorker(
-    files: string[],
-    _workerIndex: number,
-    _isolation: 'process' | 'worker' | 'none',
-    request: ParallelExecutionRequest
-  ): Promise<TestExecutionResult> {
-    const results = await Promise.all(
-      files.map(file =>
-        this.executeTestFile(file, request.framework, request.timeout ?? 30000)
-      )
-    );
-
-    return this.aggregateResults(results);
-  }
-
-  private aggregateResults(results: TestExecutionResult[]): TestExecutionResult {
-    const aggregated: TestExecutionResult = {
-      total: 0,
-      passed: 0,
-      failed: 0,
-      skipped: 0,
-      failedTests: [],
-      coverage: undefined,
-    };
-
-    for (const result of results) {
-      aggregated.total += result.total;
-      aggregated.passed += result.passed;
-      aggregated.failed += result.failed;
-      aggregated.skipped += result.skipped;
-      aggregated.failedTests.push(...result.failedTests);
-    }
-
-    aggregated.coverage = this.aggregateCoverage(
-      results.map(r => r.coverage).filter((c): c is NonNullable<typeof c> => c !== undefined)
-    );
-
-    return aggregated;
-  }
-
-  private aggregateCoverage(coverages: Array<{
-    line: number;
-    branch: number;
-    function: number;
-    statement: number;
-  }>): { line: number; branch: number; function: number; statement: number } | undefined {
-    if (coverages.length === 0) {
-      return undefined;
-    }
-
-    const sum = coverages.reduce(
-      (acc, cov) => ({
-        line: acc.line + cov.line,
-        branch: acc.branch + cov.branch,
-        function: acc.function + cov.function,
-        statement: acc.statement + cov.statement,
-      }),
-      { line: 0, branch: 0, function: 0, statement: 0 }
-    );
-
-    return {
-      line: sum.line / coverages.length,
-      branch: sum.branch / coverages.length,
-      function: sum.function / coverages.length,
-      statement: sum.statement / coverages.length,
-    };
-  }
-
-  private async storeResults(runId: string, result: TestRunResult): Promise<void> {
-    await this.memory.set(`test-run:${runId}`, result, {
-      namespace: 'test-execution',
-      persist: true,
-    });
-  }
-}
-
-// ============================================================================
-// Internal Types
-// ============================================================================
-
-interface TestExecutionResult {
-  total: number;
-  passed: number;
-  failed: number;
-  skipped: number;
-  failedTests: FailedTest[];
-  coverage?: {
-    line: number;
-    branch: number;
-    function: number;
-    statement: number;
-  };
-}