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

package/src/integrations/ruvector/coverage-router.ts

@@ -1,594 +0,0 @@
-/**
- * Agentic QE v3 - Coverage Router for RuVector Integration
- *
- * Uses RuVector's ML capabilities for coverage-aware agent routing.
- * Falls back to rule-based routing when RuVector is unavailable.
- */
-
-import type {
-  CoverageRouter,
-  CoverageRoutingResult,
-  FileCoverage,
-  CoverageGap,
-  RuVectorConfig,
-} from './interfaces';
-import { FallbackCoverageRouter } from './fallback';
-import type { AgentType, DomainName, Severity, Priority } from '../../shared/types';
-
-// ============================================================================
-// Coverage Configuration
-// ============================================================================
-
-/**
- * Coverage thresholds for routing decisions
- */
-export interface CoverageThresholds {
-  /** Target line coverage */
-  lineCoverage: number;
-  /** Target branch coverage */
-  branchCoverage: number;
-  /** Target function coverage */
-  functionCoverage: number;
-  /** Critical threshold (below this is critical priority) */
-  criticalThreshold: number;
-  /** High threshold (below this is high priority) */
-  highThreshold: number;
-  /** Medium threshold (below this is medium priority) */
-  mediumThreshold: number;
-}
-
-const DEFAULT_THRESHOLDS: CoverageThresholds = {
-  lineCoverage: 80,
-  branchCoverage: 75,
-  functionCoverage: 90,
-  criticalThreshold: 30,
-  highThreshold: 50,
-  mediumThreshold: 70,
-};
-
-// ============================================================================
-// RuVector Coverage Router Implementation
-// ============================================================================
-
-/**
- * Coverage router that integrates with RuVector
- * Provides ML-enhanced coverage analysis and agent routing
- */
-export class RuVectorCoverageRouter implements CoverageRouter {
-  private readonly fallback: FallbackCoverageRouter;
-  private readonly thresholds: CoverageThresholds;
-  private readonly cache: Map<string, { result: CoverageRoutingResult; timestamp: number }> = new Map();
-
-  constructor(
-    private readonly config: RuVectorConfig,
-    thresholds?: Partial<CoverageThresholds>
-  ) {
-    this.fallback = new FallbackCoverageRouter();
-    this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
-  }
-
-  /**
-   * Analyze coverage and route agents
-   */
-  async analyzeCoverage(
-    coverageData: FileCoverage[],
-    targetCoverage: number = this.thresholds.lineCoverage
-  ): Promise<CoverageRoutingResult> {
-    if (!this.config.enabled) {
-      return this.fallback.analyzeCoverage(coverageData, targetCoverage);
-    }
-
-    // Check cache
-    const cacheKey = this.computeCacheKey(coverageData, targetCoverage);
-    if (this.config.cacheEnabled) {
-      const cached = this.cache.get(cacheKey);
-      if (cached && Date.now() - cached.timestamp < (this.config.cacheTtl || 300000)) {
-        return cached.result;
-      }
-    }
-
-    try {
-      const result = await this.performAnalysis(coverageData, targetCoverage);
-
-      // Cache result
-      if (this.config.cacheEnabled) {
-        this.cache.set(cacheKey, { result, timestamp: Date.now() });
-      }
-
-      return result;
-    } catch (error) {
-      console.warn('[RuVectorCoverageRouter] Analysis failed, using fallback:', error);
-      return this.fallback.analyzeCoverage(coverageData, targetCoverage);
-    }
-  }
-
-  /**
-   * Get coverage gaps
-   */
-  async getCoverageGaps(coverageData: FileCoverage[]): Promise<CoverageGap[]> {
-    const gaps: CoverageGap[] = [];
-
-    for (const coverage of coverageData) {
-      // Analyze line coverage gaps
-      const lineGaps = this.analyzeLineCoverageGaps(coverage);
-      gaps.push(...lineGaps);
-
-      // Analyze branch coverage gaps
-      const branchGaps = this.analyzeBranchCoverageGaps(coverage);
-      gaps.push(...branchGaps);
-
-      // Analyze function coverage gaps
-      const functionGaps = this.analyzeFunctionCoverageGaps(coverage);
-      gaps.push(...functionGaps);
-
-      // Detect integration test gaps
-      const integrationGaps = this.detectIntegrationGaps(coverage);
-      gaps.push(...integrationGaps);
-    }
-
-    // Sort by severity
-    return gaps.sort((a, b) => {
-      const severityOrder: Record<Severity, number> = {
-        critical: 0,
-        high: 1,
-        medium: 2,
-        low: 3,
-        info: 4,
-      };
-      return severityOrder[a.severity] - severityOrder[b.severity];
-    });
-  }
-
-  /**
-   * Prioritize files for coverage improvement
-   */
-  async prioritizeForCoverage(
-    files: string[],
-    coverageData: FileCoverage[]
-  ): Promise<string[]> {
-    const coverageMap = new Map(coverageData.map((c) => [c.filePath, c]));
-
-    // Score each file
-    const scored = files.map((file) => {
-      const coverage = coverageMap.get(file);
-      if (!coverage) {
-        return { file, score: 0.5, priority: 'p2' as Priority };
-      }
-
-      const score = this.calculatePriorityScore(coverage);
-      return { file, score, priority: this.scoreToPriority(score) };
-    });
-
-    // Sort by score (higher score = higher priority)
-    scored.sort((a, b) => b.score - a.score);
-
-    return scored.map((s) => s.file);
-  }
-
-  /**
-   * Suggest tests to improve coverage
-   */
-  async suggestTestsForCoverage(
-    filePath: string,
-    coverage: FileCoverage
-  ): Promise<Array<{ testType: string; target: string; expectedCoverageGain: number }>> {
-    const suggestions: Array<{ testType: string; target: string; expectedCoverageGain: number }> = [];
-
-    // Suggest unit tests for uncovered functions
-    for (const func of coverage.uncoveredFunctions) {
-      const gain = this.estimateCoverageGain(
-        coverage.functionCoverage,
-        coverage.uncoveredFunctions.length
-      );
-      suggestions.push({
-        testType: 'unit',
-        target: `${filePath}::${func}`,
-        expectedCoverageGain: gain,
-      });
-    }
-
-    // Suggest branch tests for uncovered branches
-    if (coverage.uncoveredBranches.length > 0) {
-      const branchGain = this.estimateCoverageGain(
-        coverage.branchCoverage,
-        coverage.uncoveredBranches.length
-      );
-      suggestions.push({
-        testType: 'branch',
-        target: `${filePath} - ${coverage.uncoveredBranches.length} branches`,
-        expectedCoverageGain: branchGain,
-      });
-    }
-
-    // Suggest line coverage tests for large gaps
-    if (coverage.uncoveredLines.length > 10) {
-      const lineRanges = this.getLineRanges(coverage.uncoveredLines);
-      for (const range of lineRanges.slice(0, 3)) {
-        suggestions.push({
-          testType: 'line',
-          target: `${filePath}:${range.start}-${range.end}`,
-          expectedCoverageGain: this.estimateLineCoverageGain(range, coverage),
-        });
-      }
-    }
-
-    // Suggest integration tests if function coverage is good but overall is not
-    if (
-      coverage.functionCoverage > 80 &&
-      coverage.lineCoverage < 60
-    ) {
-      suggestions.push({
-        testType: 'integration',
-        target: `${filePath} - internal paths`,
-        expectedCoverageGain: 15,
-      });
-    }
-
-    return suggestions.sort((a, b) => b.expectedCoverageGain - a.expectedCoverageGain);
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  /**
-   * Perform coverage analysis and routing
-   */
-  private async performAnalysis(
-    coverageData: FileCoverage[],
-    targetCoverage: number
-  ): Promise<CoverageRoutingResult> {
-    const gaps = await this.getCoverageGaps(coverageData);
-    const prioritizedFiles = this.prioritizeFilesForImprovement(coverageData, targetCoverage, gaps);
-    const testGenerationTargets = this.identifyTestGenerationTargets(coverageData);
-    const agentAssignments = this.assignAgentsForCoverage(prioritizedFiles, gaps);
-
-    return {
-      prioritizedFiles,
-      testGenerationTargets,
-      agentAssignments,
-      usedFallback: false,
-    };
-  }
-
-  /**
-   * Analyze line coverage gaps
-   */
-  private analyzeLineCoverageGaps(coverage: FileCoverage): CoverageGap[] {
-    if (coverage.uncoveredLines.length === 0) return [];
-
-    const severity = this.coverageToSeverity(coverage.lineCoverage);
-    const lineRanges = this.getLineRanges(coverage.uncoveredLines);
-
-    return lineRanges.map((range) => ({
-      filePath: coverage.filePath,
-      gapType: 'line' as const,
-      severity,
-      lines: Array.from(
-        { length: range.end - range.start + 1 },
-        (_, i) => range.start + i
-      ),
-      recommendation: `Add tests for lines ${range.start}-${range.end}`,
-    }));
-  }
-
-  /**
-   * Analyze branch coverage gaps
-   */
-  private analyzeBranchCoverageGaps(coverage: FileCoverage): CoverageGap[] {
-    if (coverage.uncoveredBranches.length === 0) return [];
-
-    const severity = this.coverageToSeverity(coverage.branchCoverage);
-
-    return [{
-      filePath: coverage.filePath,
-      gapType: 'branch' as const,
-      severity,
-      lines: coverage.uncoveredBranches.map((b) => b.line),
-      recommendation: `Add tests for ${coverage.uncoveredBranches.length} uncovered branches`,
-    }];
-  }
-
-  /**
-   * Analyze function coverage gaps
-   */
-  private analyzeFunctionCoverageGaps(coverage: FileCoverage): CoverageGap[] {
-    if (coverage.uncoveredFunctions.length === 0) return [];
-
-    const severity = this.coverageToSeverity(coverage.functionCoverage);
-
-    return [{
-      filePath: coverage.filePath,
-      gapType: 'function' as const,
-      severity,
-      functions: coverage.uncoveredFunctions,
-      recommendation: `Add tests for functions: ${coverage.uncoveredFunctions.slice(0, 3).join(', ')}${coverage.uncoveredFunctions.length > 3 ? '...' : ''}`,
-    }];
-  }
-
-  /**
-   * Detect integration test gaps
-   */
-  private detectIntegrationGaps(coverage: FileCoverage): CoverageGap[] {
-    // Detect when individual coverage is OK but there might be integration gaps
-    const hasHighFunctionCoverage = coverage.functionCoverage > 70;
-    const hasLowBranchCoverage = coverage.branchCoverage < 50;
-    const hasLowLineCoverage = coverage.lineCoverage < 60;
-
-    if (hasHighFunctionCoverage && (hasLowBranchCoverage || hasLowLineCoverage)) {
-      return [{
-        filePath: coverage.filePath,
-        gapType: 'integration' as const,
-        severity: 'medium',
-        recommendation: 'Functions are tested but internal paths may need integration tests',
-      }];
-    }
-
-    return [];
-  }
-
-  /**
-   * Prioritize files for coverage improvement
-   */
-  private prioritizeFilesForImprovement(
-    coverageData: FileCoverage[],
-    targetCoverage: number,
-    gaps: CoverageGap[]
-  ): Array<{
-    filePath: string;
-    currentCoverage: number;
-    targetCoverage: number;
-    gaps: CoverageGap[];
-    priority: Priority;
-  }> {
-    const gapsByFile = new Map<string, CoverageGap[]>();
-    for (const gap of gaps) {
-      const existing = gapsByFile.get(gap.filePath) || [];
-      existing.push(gap);
-      gapsByFile.set(gap.filePath, existing);
-    }
-
-    return coverageData
-      .filter((c) => c.lineCoverage < targetCoverage)
-      .map((c) => ({
-        filePath: c.filePath,
-        currentCoverage: c.lineCoverage,
-        targetCoverage,
-        gaps: gapsByFile.get(c.filePath) || [],
-        priority: this.coverageToPriority(c.lineCoverage),
-      }))
-      .sort((a, b) => {
-        // Sort by priority first, then by current coverage
-        const priorityOrder: Record<Priority, number> = { p0: 0, p1: 1, p2: 2, p3: 3 };
-        const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
-        if (priorityDiff !== 0) return priorityDiff;
-        return a.currentCoverage - b.currentCoverage;
-      });
-  }
-
-  /**
-   * Identify test generation targets
-   */
-  private identifyTestGenerationTargets(
-    coverageData: FileCoverage[]
-  ): Array<{ filePath: string; functions: string[]; reason: string }> {
-    return coverageData
-      .filter((c) => c.uncoveredFunctions.length > 0 || c.lineCoverage < 50)
-      .map((c) => ({
-        filePath: c.filePath,
-        functions: c.uncoveredFunctions,
-        reason: this.generateTargetReason(c),
-      }))
-      .sort((a, b) => b.functions.length - a.functions.length);
-  }
-
-  /**
-   * Assign agents for coverage improvement
-   */
-  private assignAgentsForCoverage(
-    prioritizedFiles: Array<{ filePath: string; priority: Priority }>,
-    gaps: CoverageGap[]
-  ): Array<{ agentType: AgentType; domain: DomainName; files: string[] }> {
-    const assignments: Array<{ agentType: AgentType; domain: DomainName; files: string[] }> = [];
-
-    // Group files by priority
-    const p0Files = prioritizedFiles.filter((f) => f.priority === 'p0').map((f) => f.filePath);
-    const p1Files = prioritizedFiles.filter((f) => f.priority === 'p1').map((f) => f.filePath);
-    const p2Files = prioritizedFiles.filter((f) => f.priority === 'p2').map((f) => f.filePath);
-    const p3Files = prioritizedFiles.filter((f) => f.priority === 'p3').map((f) => f.filePath);
-
-    // Critical priority: use generator agent for test creation
-    if (p0Files.length > 0) {
-      assignments.push({
-        agentType: 'generator',
-        domain: 'test-generation',
-        files: p0Files,
-      });
-    }
-
-    // High priority: use tester agent for coverage analysis
-    if (p1Files.length > 0) {
-      assignments.push({
-        agentType: 'tester',
-        domain: 'coverage-analysis',
-        files: p1Files,
-      });
-    }
-
-    // Medium priority: use specialist for targeted improvement
-    if (p2Files.length > 0) {
-      assignments.push({
-        agentType: 'specialist',
-        domain: 'test-execution',
-        files: p2Files,
-      });
-    }
-
-    // Low priority: batch processing
-    if (p3Files.length > 0) {
-      assignments.push({
-        agentType: 'optimizer',
-        domain: 'learning-optimization',
-        files: p3Files,
-      });
-    }
-
-    // Check for integration test needs
-    const integrationGaps = gaps.filter((g) => g.gapType === 'integration');
-    if (integrationGaps.length > 0) {
-      assignments.push({
-        agentType: 'tester',
-        domain: 'contract-testing',
-        files: integrationGaps.map((g) => g.filePath),
-      });
-    }
-
-    return assignments;
-  }
-
-  /**
-   * Calculate priority score for a file
-   */
-  private calculatePriorityScore(coverage: FileCoverage): number {
-    // Lower coverage = higher priority score
-    const lineScore = 1 - coverage.lineCoverage / 100;
-    const branchScore = 1 - coverage.branchCoverage / 100;
-    const functionScore = 1 - coverage.functionCoverage / 100;
-
-    // Weight function coverage slightly more
-    return lineScore * 0.35 + branchScore * 0.3 + functionScore * 0.35;
-  }
-
-  /**
-   * Convert score to priority
-   */
-  private scoreToPriority(score: number): Priority {
-    if (score >= 0.7) return 'p0';
-    if (score >= 0.5) return 'p1';
-    if (score >= 0.3) return 'p2';
-    return 'p3';
-  }
-
-  /**
-   * Convert coverage percentage to severity
-   */
-  private coverageToSeverity(coverage: number): Severity {
-    if (coverage < this.thresholds.criticalThreshold) return 'critical';
-    if (coverage < this.thresholds.highThreshold) return 'high';
-    if (coverage < this.thresholds.mediumThreshold) return 'medium';
-    if (coverage < this.thresholds.lineCoverage) return 'low';
-    return 'info';
-  }
-
-  /**
-   * Convert coverage percentage to priority
-   */
-  private coverageToPriority(coverage: number): Priority {
-    if (coverage < this.thresholds.criticalThreshold) return 'p0';
-    if (coverage < this.thresholds.highThreshold) return 'p1';
-    if (coverage < this.thresholds.mediumThreshold) return 'p2';
-    return 'p3';
-  }
-
-  /**
-   * Get contiguous line ranges
-   */
-  private getLineRanges(lines: number[]): Array<{ start: number; end: number }> {
-    if (lines.length === 0) return [];
-
-    const sorted = [...lines].sort((a, b) => a - b);
-    const ranges: Array<{ start: number; end: number }> = [];
-    let start = sorted[0];
-    let end = sorted[0];
-
-    for (let i = 1; i < sorted.length; i++) {
-      if (sorted[i] === end + 1) {
-        end = sorted[i];
-      } else {
-        ranges.push({ start, end });
-        start = sorted[i];
-        end = sorted[i];
-      }
-    }
-    ranges.push({ start, end });
-
-    return ranges;
-  }
-
-  /**
-   * Estimate coverage gain from testing a function
-   */
-  private estimateCoverageGain(currentCoverage: number, totalUncovered: number): number {
-    if (totalUncovered === 0) return 0;
-    const potentialGain = (100 - currentCoverage) / totalUncovered;
-    return Math.min(25, Math.round(potentialGain));
-  }
-
-  /**
-   * Estimate line coverage gain from testing a range
-   */
-  private estimateLineCoverageGain(
-    range: { start: number; end: number },
-    coverage: FileCoverage
-  ): number {
-    const rangeLines = range.end - range.start + 1;
-    const totalUncovered = coverage.uncoveredLines.length;
-
-    if (totalUncovered === 0) return 0;
-
-    const portionCovered = rangeLines / totalUncovered;
-    const maxGain = 100 - coverage.lineCoverage;
-
-    return Math.min(20, Math.round(portionCovered * maxGain));
-  }
-
-  /**
-   * Generate reason for test generation target
-   */
-  private generateTargetReason(coverage: FileCoverage): string {
-    const reasons: string[] = [];
-
-    if (coverage.uncoveredFunctions.length > 0) {
-      reasons.push(`${coverage.uncoveredFunctions.length} untested function(s)`);
-    }
-
-    if (coverage.lineCoverage < 50) {
-      reasons.push(`low line coverage (${coverage.lineCoverage.toFixed(0)}%)`);
-    }
-
-    if (coverage.branchCoverage < 50) {
-      reasons.push(`low branch coverage (${coverage.branchCoverage.toFixed(0)}%)`);
-    }
-
-    return reasons.join(', ') || 'coverage below target';
-  }
-
-  /**
-   * Compute cache key
-   */
-  private computeCacheKey(coverageData: FileCoverage[], targetCoverage: number): string {
-    const dataKey = coverageData
-      .map((c) => `${c.filePath}:${c.lineCoverage}:${c.branchCoverage}`)
-      .sort()
-      .join('|');
-
-    return `${targetCoverage}:${dataKey}`;
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create coverage router with optional RuVector integration
- */
-export function createCoverageRouter(
-  config: RuVectorConfig,
-  thresholds?: Partial<CoverageThresholds>
-): CoverageRouter {
-  if (config.enabled) {
-    return new RuVectorCoverageRouter(config, thresholds);
-  }
-  return new FallbackCoverageRouter();
-}