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

package/src/domains/security-compliance/services/semgrep-integration.ts

@@ -1,289 +0,0 @@
-/**
- * Agentic QE v3 - Semgrep Integration
- *
- * REAL IMPLEMENTATION that integrates with Semgrep SAST scanner.
- * Semgrep is an open-source static analysis tool that finds bugs and enforces code standards.
- *
- * This module shells out to semgrep when available, with graceful fallback
- * to pattern-based scanning when semgrep is not installed.
- *
- * @module security-compliance/semgrep-integration
- */
-
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import * as path from 'path';
-
-const execAsync = promisify(exec);
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export interface SemgrepFinding {
-  check_id: string;
-  path: string;
-  start: { line: number; col: number };
-  end: { line: number; col: number };
-  extra: {
-    message: string;
-    severity: 'ERROR' | 'WARNING' | 'INFO';
-    lines: string;
-    metadata?: {
-      cwe?: string[];
-      owasp?: string[];
-      category?: string;
-      description?: string;
-      fix?: string;
-      references?: string[];
-      confidence?: string;
-    };
-  };
-}
-
-export interface SemgrepResult {
-  success: boolean;
-  findings: SemgrepFinding[];
-  errors: string[];
-  version?: string;
-}
-
-export interface SemgrepConfig {
-  /** Target directory to scan */
-  target: string;
-  /** Semgrep config (default: 'auto') */
-  config: string;
-  /** Patterns to exclude */
-  exclude: string[];
-  /** Maximum file size to scan (bytes) */
-  maxFileSize?: number;
-  /** Timeout in seconds */
-  timeout?: number;
-  /** Include verbose output */
-  verbose?: boolean;
-}
-
-// ============================================================================
-// Semgrep Integration
-// ============================================================================
-
-/**
- * Check if semgrep is installed and available
- */
-export async function isSemgrepAvailable(): Promise<boolean> {
-  try {
-    await execAsync('semgrep --version', { timeout: 5000 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get semgrep version if available
- */
-export async function getSemgrepVersion(): Promise<string | null> {
-  try {
-    const { stdout } = await execAsync('semgrep --version', { timeout: 5000 });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Run semgrep scan on target directory
- */
-export async function runSemgrep(config: Partial<SemgrepConfig>): Promise<SemgrepResult> {
-  const fullConfig: SemgrepConfig = {
-    target: config.target || '.',
-    config: config.config || 'auto',
-    exclude: config.exclude || ['node_modules', '.git', 'dist', 'build', 'coverage'],
-    maxFileSize: config.maxFileSize || 5000000, // 5MB
-    timeout: config.timeout || 300,
-    verbose: config.verbose || false,
-  };
-
-  // Check availability
-  const available = await isSemgrepAvailable();
-  if (!available) {
-    return {
-      success: false,
-      findings: [],
-      errors: ['Semgrep is not installed. Install with: pip install semgrep'],
-    };
-  }
-
-  try {
-    // Build command
-    const excludeArgs = fullConfig.exclude.map((e) => `--exclude="${e}"`).join(' ');
-    const cmd = [
-      'semgrep scan',
-      `--config=${fullConfig.config}`,
-      '--json',
-      excludeArgs,
-      fullConfig.verbose ? '--verbose' : '--quiet',
-      `--max-target-bytes=${fullConfig.maxFileSize}`,
-      fullConfig.target,
-    ].join(' ');
-
-    const timeoutMs = (fullConfig.timeout ?? 300) * 1000;
-    const { stdout, stderr } = await execAsync(cmd, {
-      timeout: timeoutMs,
-      maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large results
-      cwd: path.isAbsolute(fullConfig.target) ? undefined : process.cwd(),
-    });
-
-    const result = parseSemgrepOutput(stdout);
-    if (stderr && fullConfig.verbose) {
-      result.errors.push(stderr);
-    }
-
-    result.version = await getSemgrepVersion() || undefined;
-    return result;
-  } catch (error: any) {
-    // Semgrep exits with non-zero if findings exist
-    if (error.stdout) {
-      try {
-        const result = parseSemgrepOutput(error.stdout);
-        result.version = await getSemgrepVersion() || undefined;
-        return result;
-      } catch {
-        // Parse failed, return error
-      }
-    }
-
-    return {
-      success: false,
-      findings: [],
-      errors: [error instanceof Error ? error.message : String(error)],
-    };
-  }
-}
-
-/**
- * Parse semgrep JSON output
- */
-function parseSemgrepOutput(stdout: string): SemgrepResult {
-  try {
-    const parsed = JSON.parse(stdout);
-
-    // Handle different output formats
-    const results = parsed.results || parsed.findings || [];
-    const errors = parsed.errors?.map((e: any) => e.message || String(e)) || [];
-
-    return {
-      success: true,
-      findings: results.map((r: any) => ({
-        check_id: r.check_id || r.rule_id || 'unknown',
-        path: r.path,
-        start: { line: r.start?.line || 1, col: r.start?.col || 1 },
-        end: { line: r.end?.line || r.start?.line || 1, col: r.end?.col || 1 },
-        extra: {
-          message: r.extra?.message || r.message || 'Security issue detected',
-          severity: r.extra?.severity || r.severity || 'WARNING',
-          lines: r.extra?.lines || '',
-          metadata: {
-            cwe: r.extra?.metadata?.cwe || r.metadata?.cwe,
-            owasp: r.extra?.metadata?.owasp || r.metadata?.owasp,
-            category: r.extra?.metadata?.category || r.metadata?.category,
-            description: r.extra?.metadata?.description || r.metadata?.description,
-            fix: r.extra?.metadata?.fix || r.extra?.fix,
-            references: r.extra?.metadata?.references || r.metadata?.references,
-            confidence: r.extra?.metadata?.confidence || r.metadata?.confidence,
-          },
-        },
-      })),
-      errors,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      findings: [],
-      errors: [`Failed to parse semgrep output: ${error instanceof Error ? error.message : String(error)}`],
-    };
-  }
-}
-
-/**
- * Run semgrep with specific rule sets
- */
-export async function runSemgrepWithRules(
-  target: string,
-  rules: string[],
-  options?: Partial<SemgrepConfig>
-): Promise<SemgrepResult> {
-  // Map rule IDs to semgrep configs
-  const configMapping: Record<string, string> = {
-    'owasp-top-10': 'p/owasp-top-ten',
-    'cwe-sans-25': 'p/cwe-top-25',
-    'nodejs-security': 'p/nodejs',
-    'typescript-security': 'p/typescript',
-    'javascript-security': 'p/javascript',
-    'react-security': 'p/react',
-    'express-security': 'p/express',
-    'secrets': 'p/secrets',
-    'sql-injection': 'p/sql-injection',
-    'xss': 'p/xss',
-    'command-injection': 'p/command-injection',
-    'path-traversal': 'p/path-traversal',
-  };
-
-  // Convert rule IDs to semgrep configs
-  const configs = rules
-    .map((r) => configMapping[r] || `p/${r}`)
-    .join(',');
-
-  return runSemgrep({
-    ...options,
-    target,
-    config: configs || 'auto',
-  });
-}
-
-/**
- * Map semgrep severity to standard severity
- */
-export function mapSemgrepSeverity(
-  severity: 'ERROR' | 'WARNING' | 'INFO'
-): 'critical' | 'high' | 'medium' | 'low' {
-  const mapping: Record<string, 'critical' | 'high' | 'medium' | 'low'> = {
-    ERROR: 'high',
-    WARNING: 'medium',
-    INFO: 'low',
-  };
-  return mapping[severity] || 'medium';
-}
-
-/**
- * Convert semgrep findings to a generic format
- */
-export function convertSemgrepFindings(findings: SemgrepFinding[]): Array<{
-  id: string;
-  title: string;
-  description: string;
-  severity: 'critical' | 'high' | 'medium' | 'low';
-  file: string;
-  line: number;
-  column: number;
-  snippet: string;
-  cweId?: string;
-  owaspCategory?: string;
-  remediation: string;
-  references: string[];
-}> {
-  return findings.map((f) => ({
-    id: f.check_id,
-    title: f.check_id.split('.').pop() || f.check_id,
-    description: f.extra.message,
-    severity: mapSemgrepSeverity(f.extra.severity),
-    file: f.path,
-    line: f.start.line,
-    column: f.start.col,
-    snippet: f.extra.lines,
-    cweId: f.extra.metadata?.cwe?.[0],
-    owaspCategory: f.extra.metadata?.owasp?.[0],
-    remediation: f.extra.metadata?.fix || 'Review and fix the identified security issue',
-    references: f.extra.metadata?.references || [],
-  }));
-}

package/src/domains/test-execution/coordinator.ts

@@ -1,426 +0,0 @@
-/**
- * Agentic QE v3 - Test Execution Coordinator
- * Orchestrates test execution workflow and publishes domain events
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { Result, ok, err } from '../../shared/types';
-import {
-  TestExecutionAPI,
-  ExecuteTestsRequest,
-  ParallelExecutionRequest,
-  TestRunResult,
-  FlakyDetectionRequest,
-  FlakyTestReport,
-  RetryRequest,
-  RetryResult,
-  ExecutionStats,
-} from './interfaces';
-import {
-  TestExecutionEvents,
-  TestRunStartedPayload,
-  TestRunCompletedPayload,
-  FlakyTestDetectedPayload,
-  createEvent,
-} from '../../shared/events';
-import { EventBus, MemoryBackend } from '../../kernel/interfaces';
-import { TestExecutorService, TestExecutorConfig } from './services/test-executor';
-import { FlakyDetectorService, FlakyDetectorConfig } from './services/flaky-detector';
-import { RetryHandlerService, RetryHandlerConfig } from './services/retry-handler';
-
-// ============================================================================
-// Coordinator Configuration
-// ============================================================================
-
-/**
- * Configuration for the test execution coordinator
- */
-export interface TestExecutionCoordinatorConfig {
-  /**
-   * When true, enables simulation mode for all services (for unit testing).
-   * When false (default), services operate in deterministic production mode.
-   */
-  simulateForTesting: boolean;
-  /**
-   * Optional executor-specific config overrides
-   */
-  executorConfig?: Partial<TestExecutorConfig>;
-  /**
-   * Optional flaky detector-specific config overrides
-   */
-  flakyDetectorConfig?: Partial<FlakyDetectorConfig>;
-  /**
-   * Optional retry handler-specific config overrides
-   */
-  retryHandlerConfig?: Partial<RetryHandlerConfig>;
-}
-
-const DEFAULT_COORDINATOR_CONFIG: TestExecutionCoordinatorConfig = {
-  simulateForTesting: false,
-};
-
-// ============================================================================
-// Coordinator Interface
-// ============================================================================
-
-export interface ITestExecutionCoordinator extends TestExecutionAPI {
-  /** Initialize the coordinator */
-  initialize(): Promise<void>;
-
-  /** Dispose resources */
-  dispose(): Promise<void>;
-
-  /** Get active runs */
-  getActiveRuns(): string[];
-
-  /** Cancel a running test */
-  cancelRun(runId: string): Promise<Result<void, Error>>;
-}
-
-// ============================================================================
-// Test Execution Coordinator
-// ============================================================================
-
-export class TestExecutionCoordinator implements ITestExecutionCoordinator {
-  private readonly executor: TestExecutorService;
-  private readonly flakyDetector: FlakyDetectorService;
-  private readonly retryHandler: RetryHandlerService;
-  private readonly activeRuns = new Set<string>();
-  private initialized = false;
-
-  constructor(
-    private readonly eventBus: EventBus,
-    memory: MemoryBackend,
-    config: Partial<TestExecutionCoordinatorConfig> = {}
-  ) {
-    const fullConfig = { ...DEFAULT_COORDINATOR_CONFIG, ...config };
-
-    // Create services with appropriate configuration
-    this.executor = new TestExecutorService(memory, {
-      simulateForTesting: fullConfig.simulateForTesting,
-      ...fullConfig.executorConfig,
-    });
-    this.flakyDetector = new FlakyDetectorService(memory, {
-      simulateForTesting: fullConfig.simulateForTesting,
-      ...fullConfig.flakyDetectorConfig,
-    });
-    this.retryHandler = new RetryHandlerService(memory, {
-      simulateForTesting: fullConfig.simulateForTesting,
-      ...fullConfig.retryHandlerConfig,
-    });
-  }
-
-  /**
-   * Initialize the coordinator
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    // Subscribe to relevant events from other domains
-    this.subscribeToEvents();
-
-    this.initialized = true;
-  }
-
-  /**
-   * Dispose resources
-   */
-  async dispose(): Promise<void> {
-    // Cancel all active runs
-    for (const runId of this.activeRuns) {
-      await this.cancelRun(runId);
-    }
-
-    this.activeRuns.clear();
-    this.initialized = false;
-  }
-
-  /**
-   * Get list of active run IDs
-   */
-  getActiveRuns(): string[] {
-    return Array.from(this.activeRuns);
-  }
-
-  /**
-   * Cancel a running test execution
-   */
-  async cancelRun(runId: string): Promise<Result<void, Error>> {
-    if (!this.activeRuns.has(runId)) {
-      return err(new Error(`Run not found or already completed: ${runId}`));
-    }
-
-    // In a real implementation, would signal the test runner to stop
-    this.activeRuns.delete(runId);
-
-    // Publish cancellation event
-    await this.publishEvent<{ runId: string }>(
-      'test-execution.TestRunCancelled',
-      { runId }
-    );
-
-    return ok(undefined);
-  }
-
-  // ============================================================================
-  // TestExecutionAPI Implementation
-  // ============================================================================
-
-  /**
-   * Execute a test suite
-   */
-  async execute(request: ExecuteTestsRequest): Promise<Result<TestRunResult, Error>> {
-    const runId = uuidv4();
-    this.activeRuns.add(runId);
-
-    try {
-      // Publish start event
-      await this.publishEvent<TestRunStartedPayload>(
-        TestExecutionEvents.TestRunStarted,
-        {
-          runId,
-          testCount: request.testFiles.length,
-          parallel: false,
-          workers: 1,
-        }
-      );
-
-      // Execute tests
-      const result = await this.executor.execute(request);
-
-      // Remove from active runs
-      this.activeRuns.delete(runId);
-
-      if (result.success) {
-        // Publish completion event
-        await this.publishEvent<TestRunCompletedPayload>(
-          TestExecutionEvents.TestRunCompleted,
-          {
-            runId: result.value.runId,
-            passed: result.value.passed,
-            failed: result.value.failed,
-            skipped: result.value.skipped,
-            duration: result.value.duration,
-          }
-        );
-
-        // Record failed tests for flaky analysis
-        for (const failed of result.value.failedTests) {
-          await this.flakyDetector.recordExecution(failed.testId, {
-            runId: result.value.runId,
-            passed: false,
-            duration: failed.duration,
-            error: failed.error,
-            timestamp: new Date(),
-          });
-        }
-      }
-
-      return result;
-    } catch (error) {
-      this.activeRuns.delete(runId);
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Execute tests in parallel
-   */
-  async executeParallel(request: ParallelExecutionRequest): Promise<Result<TestRunResult, Error>> {
-    const runId = uuidv4();
-    this.activeRuns.add(runId);
-
-    try {
-      // Publish start event
-      await this.publishEvent<TestRunStartedPayload>(
-        TestExecutionEvents.TestRunStarted,
-        {
-          runId,
-          testCount: request.testFiles.length,
-          parallel: true,
-          workers: request.workers,
-        }
-      );
-
-      // Execute tests in parallel
-      const result = await this.executor.executeParallel(request);
-
-      // Remove from active runs
-      this.activeRuns.delete(runId);
-
-      if (result.success) {
-        // Publish completion event
-        await this.publishEvent<TestRunCompletedPayload>(
-          TestExecutionEvents.TestRunCompleted,
-          {
-            runId: result.value.runId,
-            passed: result.value.passed,
-            failed: result.value.failed,
-            skipped: result.value.skipped,
-            duration: result.value.duration,
-          }
-        );
-
-        // Check for flaky tests based on history
-        for (const failed of result.value.failedTests) {
-          const flakinessScore = await this.flakyDetector.getFlakinessScore(failed.testId);
-
-          if (flakinessScore > 0.3) {
-            await this.publishEvent<FlakyTestDetectedPayload>(
-              TestExecutionEvents.FlakyTestDetected,
-              {
-                testId: failed.testId,
-                testFile: failed.file,
-                failureRate: flakinessScore,
-                pattern: 'unknown',
-              }
-            );
-          }
-        }
-      }
-
-      return result;
-    } catch (error) {
-      this.activeRuns.delete(runId);
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Detect flaky tests
-   */
-  async detectFlaky(request: FlakyDetectionRequest): Promise<Result<FlakyTestReport, Error>> {
-    const result = await this.flakyDetector.detectFlaky(request);
-
-    if (result.success) {
-      // Publish events for detected flaky tests
-      for (const flaky of result.value.flakyTests) {
-        await this.publishEvent<FlakyTestDetectedPayload>(
-          TestExecutionEvents.FlakyTestDetected,
-          {
-            testId: flaky.testId,
-            testFile: flaky.file,
-            failureRate: flaky.failureRate,
-            pattern: flaky.pattern,
-          }
-        );
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Retry failed tests
-   */
-  async retry(request: RetryRequest): Promise<Result<RetryResult, Error>> {
-    // Get original run results to get failed test details
-    const runResult = await this.executor.getResults(request.runId);
-
-    if (!runResult.success) {
-      return err(new Error(`Original run not found: ${request.runId}`));
-    }
-
-    // Filter failed tests that were requested for retry
-    const testsToRetry = runResult.value.failedTests.filter(
-      t => request.failedTests.includes(t.testId)
-    );
-
-    if (testsToRetry.length === 0) {
-      return ok({
-        originalFailed: 0,
-        retried: 0,
-        nowPassing: 0,
-        stillFailing: 0,
-        flakyDetected: [],
-      });
-    }
-
-    // Publish retry triggered event
-    await this.publishEvent<{ runId: string; testCount: number }>(
-      TestExecutionEvents.RetryTriggered,
-      {
-        runId: request.runId,
-        testCount: testsToRetry.length,
-      }
-    );
-
-    // Execute retries
-    const result = await this.retryHandler.executeWithRetry({
-      runId: request.runId,
-      failedTests: testsToRetry,
-      maxRetries: request.maxRetries,
-      backoff: request.backoff ?? 'exponential',
-      onRetry: (testId, attempt) => {
-        // Could publish individual retry events here
-        void testId;
-        void attempt;
-      },
-    });
-
-    // Publish flaky test events for tests that passed on retry
-    if (result.success) {
-      for (const flakyTestId of result.value.flakyDetected) {
-        const testInfo = testsToRetry.find(t => t.testId === flakyTestId);
-
-        await this.publishEvent<FlakyTestDetectedPayload>(
-          TestExecutionEvents.FlakyTestDetected,
-          {
-            testId: flakyTestId,
-            testFile: testInfo?.file ?? 'unknown',
-            failureRate: 0.5, // Approximate - passed on retry
-            pattern: 'unknown',
-          }
-        );
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Get execution statistics
-   */
-  async getStats(runId: string): Promise<Result<ExecutionStats, Error>> {
-    return this.executor.getStats(runId);
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  private subscribeToEvents(): void {
-    // Subscribe to test generation events
-    this.eventBus.subscribe('test-generation.TestSuiteCreated', async (event) => {
-      // Could auto-execute newly generated tests
-      const payload = event.payload as { suiteId: string; testCount: number };
-      void payload; // Available for future auto-execution feature
-    });
-
-    // Subscribe to coverage analysis requests
-    this.eventBus.subscribe('coverage-analysis.CoverageGapDetected', async (event) => {
-      // Could trigger targeted test execution for uncovered areas
-      const payload = event.payload as { file: string; uncoveredLines: number[] };
-      void payload; // Available for future targeted execution feature
-    });
-  }
-
-  private async publishEvent<T>(type: string, payload: T): Promise<void> {
-    const event = createEvent(type, 'test-execution', payload);
-    await this.eventBus.publish(event);
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-export function createTestExecutionCoordinator(
-  eventBus: EventBus,
-  memory: MemoryBackend,
-  config?: Partial<TestExecutionCoordinatorConfig>
-): ITestExecutionCoordinator {
-  return new TestExecutionCoordinator(eventBus, memory, config);
-}