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

package/src/integrations/ruvector/fallback.ts

@@ -1,942 +0,0 @@
-/**
- * Agentic QE v3 - RuVector Fallback Logic
- *
- * Rule-based fallback implementations when RuVector is unavailable.
- * All QE features MUST work without RuVector - this provides the baseline.
- */
-
-import type {
-  TestTask,
-  AgentRoutingResult,
-  FileComplexityResult,
-  ComplexityMetrics,
-  RiskClassification,
-  DiffContext,
-  FileChange,
-  CoverageRoutingResult,
-  FileCoverage,
-  CoverageGap,
-  GraphBoundariesResult,
-  ModuleBoundary,
-  BoundaryCrossing,
-  QLearningRouter,
-  ASTComplexityAnalyzer,
-  DiffRiskClassifier,
-  CoverageRouter,
-  GraphBoundariesAnalyzer,
-  QLearningState,
-  QLearningAction,
-} from './interfaces';
-import type { AgentType, DomainName, Severity, Priority } from '../../shared/types';
-
-// ============================================================================
-// Fallback Q-Learning Router
-// ============================================================================
-
-/**
- * Rule-based fallback for Q-Learning router
- * Uses simple heuristics instead of ML-based routing
- */
-export class FallbackQLearningRouter implements QLearningRouter {
-  private feedback: Map<string, { success: boolean; durationMs: number; quality: number }[]> = new Map();
-
-  async routeTask(task: TestTask): Promise<AgentRoutingResult> {
-    const routing = this.computeRuleBasedRouting(task);
-    return {
-      ...routing,
-      usedFallback: true,
-    };
-  }
-
-  async routeTasks(tasks: TestTask[]): Promise<AgentRoutingResult[]> {
-    return Promise.all(tasks.map((task) => this.routeTask(task)));
-  }
-
-  async provideFeedback(
-    taskId: string,
-    result: { success: boolean; durationMs: number; quality: number }
-  ): Promise<void> {
-    const existing = this.feedback.get(taskId) || [];
-    existing.push(result);
-    this.feedback.set(taskId, existing);
-  }
-
-  getQValue(_state: QLearningState, _action: QLearningAction): number {
-    // Fallback returns neutral Q-value
-    return 0.5;
-  }
-
-  async reset(): Promise<void> {
-    this.feedback.clear();
-  }
-
-  async exportModel(): Promise<Record<string, unknown>> {
-    return {
-      type: 'fallback',
-      feedback: Object.fromEntries(this.feedback),
-    };
-  }
-
-  async importModel(_model: Record<string, unknown>): Promise<void> {
-    // Fallback does not support model import
-  }
-
-  private computeRuleBasedRouting(task: TestTask): Omit<AgentRoutingResult, 'usedFallback'> {
-    const { agentType, domain, confidence, reasoning } = this.mapTaskToAgent(task);
-
-    const alternatives = this.getAlternatives(task, agentType, domain);
-
-    return {
-      agentType,
-      domain,
-      confidence,
-      reasoning,
-      alternatives,
-    };
-  }
-
-  private mapTaskToAgent(task: TestTask): {
-    agentType: AgentType;
-    domain: DomainName;
-    confidence: number;
-    reasoning: string;
-  } {
-    // Rule-based mapping based on task type
-    switch (task.type) {
-      case 'unit':
-        return {
-          agentType: 'tester',
-          domain: task.domain || 'test-execution',
-          confidence: 0.8,
-          reasoning: `Unit test task routed to tester agent based on task type`,
-        };
-
-      case 'integration':
-        return {
-          agentType: 'tester',
-          domain: 'contract-testing',
-          confidence: 0.75,
-          reasoning: `Integration test routed to contract-testing domain`,
-        };
-
-      case 'e2e':
-        return {
-          agentType: 'tester',
-          domain: 'visual-accessibility',
-          confidence: 0.7,
-          reasoning: `E2E test may involve visual/accessibility checks`,
-        };
-
-      case 'performance':
-        return {
-          agentType: 'analyzer',
-          domain: 'chaos-resilience',
-          confidence: 0.8,
-          reasoning: `Performance test routed to chaos-resilience domain`,
-        };
-
-      case 'security':
-        return {
-          agentType: 'validator',
-          domain: 'security-compliance',
-          confidence: 0.85,
-          reasoning: `Security test routed to security-compliance domain`,
-        };
-
-      case 'accessibility':
-        return {
-          agentType: 'validator',
-          domain: 'visual-accessibility',
-          confidence: 0.85,
-          reasoning: `Accessibility test routed to visual-accessibility domain`,
-        };
-
-      default:
-        return {
-          agentType: 'tester',
-          domain: 'test-execution',
-          confidence: 0.6,
-          reasoning: `Default routing for unknown task type`,
-        };
-    }
-  }
-
-  private getAlternatives(
-    task: TestTask,
-    primaryAgent: AgentType,
-    primaryDomain: DomainName
-  ): Array<{ agentType: AgentType; domain: DomainName; confidence: number }> {
-    const alternatives: Array<{ agentType: AgentType; domain: DomainName; confidence: number }> = [];
-
-    // Add analyzer as alternative for complex tasks
-    if ((task.complexity || 0) > 0.7 && primaryAgent !== 'analyzer') {
-      alternatives.push({
-        agentType: 'analyzer',
-        domain: 'code-intelligence',
-        confidence: 0.6,
-      });
-    }
-
-    // Add validator as alternative for high-priority tasks
-    if (task.priority === 'p0' && primaryAgent !== 'validator') {
-      alternatives.push({
-        agentType: 'validator',
-        domain: primaryDomain,
-        confidence: 0.65,
-      });
-    }
-
-    // Add specialist as generic alternative
-    if (primaryAgent !== 'specialist') {
-      alternatives.push({
-        agentType: 'specialist',
-        domain: primaryDomain,
-        confidence: 0.5,
-      });
-    }
-
-    return alternatives;
-  }
-}
-
-// ============================================================================
-// Fallback AST Complexity Analyzer
-// ============================================================================
-
-/**
- * Rule-based fallback for AST complexity analysis
- * Uses simple heuristics based on file size and patterns
- */
-export class FallbackASTComplexityAnalyzer implements ASTComplexityAnalyzer {
-  async analyzeFile(filePath: string): Promise<FileComplexityResult> {
-    // Estimate complexity based on file path patterns
-    const metrics = this.estimateComplexity(filePath);
-    const overallScore = this.calculateOverallScore(metrics);
-    const riskLevel = this.scoreToRiskLevel(overallScore);
-
-    return {
-      filePath,
-      metrics,
-      overallScore,
-      riskLevel,
-      hotspots: [],
-      recommendations: this.generateRecommendations(overallScore),
-      analyzedAt: new Date(),
-      usedFallback: true,
-    };
-  }
-
-  async analyzeFiles(filePaths: string[]): Promise<FileComplexityResult[]> {
-    return Promise.all(filePaths.map((fp) => this.analyzeFile(fp)));
-  }
-
-  async getComplexityRanking(
-    filePaths: string[]
-  ): Promise<Array<{ filePath: string; score: number; priority: Priority }>> {
-    const results = await this.analyzeFiles(filePaths);
-    return results
-      .map((r) => ({
-        filePath: r.filePath,
-        score: r.overallScore,
-        priority: this.scoreToPriority(r.overallScore),
-      }))
-      .sort((a, b) => b.score - a.score);
-  }
-
-  async suggestTestFocus(
-    filePaths: string[]
-  ): Promise<Array<{ filePath: string; functions: string[]; reason: string }>> {
-    const results = await this.analyzeFiles(filePaths);
-    return results
-      .filter((r) => r.overallScore > 0.5)
-      .map((r) => ({
-        filePath: r.filePath,
-        functions: [], // Fallback cannot identify specific functions
-        reason: `High complexity score (${r.overallScore.toFixed(2)}) suggests focused testing`,
-      }));
-  }
-
-  private estimateComplexity(filePath: string): ComplexityMetrics {
-    // Estimate complexity based on file patterns
-    const isTestFile = filePath.includes('.test.') || filePath.includes('.spec.');
-    const isConfigFile = filePath.includes('config') || filePath.endsWith('.json');
-    const isTypeFile = filePath.endsWith('.d.ts') || filePath.includes('types');
-
-    let baseComplexity = 5;
-
-    // Adjust based on file type
-    if (isTestFile) baseComplexity = 3;
-    if (isConfigFile) baseComplexity = 2;
-    if (isTypeFile) baseComplexity = 1;
-
-    // Adjust based on path depth (deeper = potentially more complex)
-    const depth = filePath.split('/').length;
-    baseComplexity += Math.min(depth * 0.5, 5);
-
-    // Adjust based on known complex patterns
-    if (filePath.includes('service') || filePath.includes('handler')) baseComplexity += 3;
-    if (filePath.includes('util') || filePath.includes('helper')) baseComplexity -= 2;
-
-    return {
-      cyclomatic: Math.max(1, Math.round(baseComplexity)),
-      cognitive: Math.max(1, Math.round(baseComplexity * 1.2)),
-      linesOfCode: Math.round(baseComplexity * 50),
-      dependencies: Math.max(0, Math.round(baseComplexity * 2)),
-      inheritanceDepth: Math.min(3, Math.max(0, Math.round(baseComplexity / 5))),
-      coupling: Math.min(1, baseComplexity / 20),
-      cohesion: Math.max(0.3, 1 - baseComplexity / 30),
-      halsteadDifficulty: baseComplexity * 2,
-      maintainabilityIndex: Math.max(20, 100 - baseComplexity * 5),
-    };
-  }
-
-  private calculateOverallScore(metrics: ComplexityMetrics): number {
-    // Weighted average of normalized metrics
-    const cyclomaticNorm = Math.min(1, metrics.cyclomatic / 20);
-    const cognitiveNorm = Math.min(1, metrics.cognitive / 30);
-    const couplingScore = metrics.coupling;
-    const cohesionPenalty = 1 - metrics.cohesion;
-    const maintainabilityPenalty = 1 - metrics.maintainabilityIndex / 100;
-
-    return (
-      cyclomaticNorm * 0.25 +
-      cognitiveNorm * 0.25 +
-      couplingScore * 0.2 +
-      cohesionPenalty * 0.15 +
-      maintainabilityPenalty * 0.15
-    );
-  }
-
-  private scoreToRiskLevel(score: number): Severity {
-    if (score >= 0.8) return 'critical';
-    if (score >= 0.6) return 'high';
-    if (score >= 0.4) return 'medium';
-    if (score >= 0.2) return 'low';
-    return 'info';
-  }
-
-  private scoreToPriority(score: number): Priority {
-    if (score >= 0.8) return 'p0';
-    if (score >= 0.6) return 'p1';
-    if (score >= 0.4) return 'p2';
-    return 'p3';
-  }
-
-  private generateRecommendations(score: number): string[] {
-    const recommendations: string[] = [];
-
-    if (score >= 0.6) {
-      recommendations.push('Consider breaking down complex functions into smaller units');
-      recommendations.push('Add unit tests for high-complexity code paths');
-    }
-
-    if (score >= 0.4) {
-      recommendations.push('Review and document complex logic');
-      recommendations.push('Consider refactoring to reduce coupling');
-    }
-
-    return recommendations;
-  }
-}
-
-// ============================================================================
-// Fallback Diff Risk Classifier
-// ============================================================================
-
-/**
- * Rule-based fallback for diff risk classification
- */
-export class FallbackDiffRiskClassifier implements DiffRiskClassifier {
-  private readonly HIGH_RISK_PATTERNS = [
-    'auth', 'security', 'password', 'token', 'secret', 'key',
-    'payment', 'billing', 'crypto', 'encrypt', 'decrypt',
-    'database', 'migration', 'schema', 'sql',
-    'permission', 'role', 'access', 'admin',
-  ];
-
-  private readonly SENSITIVE_FILE_PATTERNS = [
-    /\.env/,
-    /config.*\.(ts|js|json)$/,
-    /secrets?\./,
-    /credentials?\./,
-    /\.pem$/,
-    /\.key$/,
-  ];
-
-  async classifyDiff(context: DiffContext): Promise<RiskClassification> {
-    const { score, factors } = this.calculateRiskScore(context);
-    const level = this.scoreToLevel(score);
-    const highRiskFiles = this.identifyHighRiskFiles(context.files);
-    const recommendedTests = this.getRecommendedTests(context, level);
-
-    return {
-      level,
-      score,
-      factors,
-      highRiskFiles,
-      recommendedTests,
-      usedFallback: true,
-    };
-  }
-
-  async rankFilesByRisk(
-    files: FileChange[]
-  ): Promise<Array<{ filePath: string; riskScore: number; riskLevel: Severity }>> {
-    return files
-      .map((file) => {
-        const riskScore = this.calculateFileRisk(file);
-        return {
-          filePath: file.filePath,
-          riskScore,
-          riskLevel: this.scoreToLevel(riskScore),
-        };
-      })
-      .sort((a, b) => b.riskScore - a.riskScore);
-  }
-
-  async requiresSecurityReview(context: DiffContext): Promise<boolean> {
-    return context.files.some((file) => {
-      const path = file.filePath.toLowerCase();
-      return this.HIGH_RISK_PATTERNS.some((pattern) => path.includes(pattern));
-    });
-  }
-
-  async getRecommendedReviewers(_context: DiffContext): Promise<string[]> {
-    // Fallback cannot determine specific reviewers
-    return [];
-  }
-
-  async predictDefects(
-    context: DiffContext
-  ): Promise<Array<{ filePath: string; probability: number; type: string; location?: { line: number; column: number } }>> {
-    return context.files
-      .filter((f) => f.additions > 50 || f.deletions > 50)
-      .map((file) => ({
-        filePath: file.filePath,
-        probability: Math.min(0.8, (file.additions + file.deletions) / 200),
-        type: file.additions > file.deletions ? 'new-code-defect' : 'regression',
-      }));
-  }
-
-  private calculateRiskScore(context: DiffContext): {
-    score: number;
-    factors: Array<{ name: string; weight: number; description: string }>;
-  } {
-    const factors: Array<{ name: string; weight: number; description: string }> = [];
-    let totalWeight = 0;
-    let weightedSum = 0;
-
-    // Factor: Total lines changed
-    const totalChanges = context.files.reduce(
-      (sum, f) => sum + f.additions + f.deletions,
-      0
-    );
-    if (totalChanges > 500) {
-      const weight = 0.3;
-      factors.push({
-        name: 'large-change',
-        weight,
-        description: `Large changeset with ${totalChanges} lines modified`,
-      });
-      weightedSum += weight;
-      totalWeight += weight;
-    }
-
-    // Factor: Files with sensitive patterns
-    const sensitiveFiles = context.files.filter((f) =>
-      this.SENSITIVE_FILE_PATTERNS.some((pattern) => pattern.test(f.filePath))
-    );
-    if (sensitiveFiles.length > 0) {
-      const weight = 0.4;
-      factors.push({
-        name: 'sensitive-files',
-        weight,
-        description: `${sensitiveFiles.length} sensitive files modified`,
-      });
-      weightedSum += weight;
-      totalWeight += weight;
-    }
-
-    // Factor: High-risk code patterns
-    const highRiskFiles = context.files.filter((f) =>
-      this.HIGH_RISK_PATTERNS.some((pattern) =>
-        f.filePath.toLowerCase().includes(pattern)
-      )
-    );
-    if (highRiskFiles.length > 0) {
-      const weight = 0.35;
-      factors.push({
-        name: 'high-risk-patterns',
-        weight,
-        description: `${highRiskFiles.length} files touch security-sensitive areas`,
-      });
-      weightedSum += weight;
-      totalWeight += weight;
-    }
-
-    // Factor: Deleted files
-    const deletedFiles = context.files.filter((f) => f.status === 'deleted');
-    if (deletedFiles.length > 0) {
-      const weight = 0.2;
-      factors.push({
-        name: 'file-deletions',
-        weight,
-        description: `${deletedFiles.length} files deleted`,
-      });
-      weightedSum += weight * 0.7;
-      totalWeight += weight;
-    }
-
-    // Factor: File count
-    if (context.files.length > 10) {
-      const weight = 0.15;
-      factors.push({
-        name: 'many-files',
-        weight,
-        description: `${context.files.length} files modified`,
-      });
-      weightedSum += weight * 0.6;
-      totalWeight += weight;
-    }
-
-    const score = totalWeight > 0 ? weightedSum / totalWeight : 0.2;
-    return { score: Math.min(1, score), factors };
-  }
-
-  private calculateFileRisk(file: FileChange): number {
-    let risk = 0.2; // Base risk
-
-    // Sensitive file patterns
-    if (this.SENSITIVE_FILE_PATTERNS.some((p) => p.test(file.filePath))) {
-      risk += 0.4;
-    }
-
-    // High-risk code patterns
-    if (this.HIGH_RISK_PATTERNS.some((p) => file.filePath.toLowerCase().includes(p))) {
-      risk += 0.3;
-    }
-
-    // Large changes
-    const totalChanges = file.additions + file.deletions;
-    if (totalChanges > 100) risk += 0.2;
-    if (totalChanges > 500) risk += 0.2;
-
-    // Deleted files
-    if (file.status === 'deleted') risk += 0.1;
-
-    return Math.min(1, risk);
-  }
-
-  private scoreToLevel(score: number): Severity {
-    if (score >= 0.8) return 'critical';
-    if (score >= 0.6) return 'high';
-    if (score >= 0.4) return 'medium';
-    if (score >= 0.2) return 'low';
-    return 'info';
-  }
-
-  private identifyHighRiskFiles(files: FileChange[]): string[] {
-    return files
-      .filter((f) => this.calculateFileRisk(f) >= 0.6)
-      .map((f) => f.filePath);
-  }
-
-  private getRecommendedTests(
-    context: DiffContext,
-    level: Severity
-  ): Array<{ type: 'unit' | 'integration' | 'e2e' | 'security' | 'performance'; priority: Priority; reason: string }> {
-    const tests: Array<{
-      type: 'unit' | 'integration' | 'e2e' | 'security' | 'performance';
-      priority: Priority;
-      reason: string;
-    }> = [];
-
-    // Always recommend unit tests
-    tests.push({
-      type: 'unit',
-      priority: level === 'critical' || level === 'high' ? 'p0' : 'p1',
-      reason: 'Verify core functionality of changed code',
-    });
-
-    // Integration tests for moderate+ risk
-    if (level !== 'info' && level !== 'low') {
-      tests.push({
-        type: 'integration',
-        priority: level === 'critical' ? 'p0' : 'p1',
-        reason: 'Verify component interactions',
-      });
-    }
-
-    // Security tests for security-related changes
-    if (
-      context.files.some((f) =>
-        this.HIGH_RISK_PATTERNS.some((p) => f.filePath.toLowerCase().includes(p))
-      )
-    ) {
-      tests.push({
-        type: 'security',
-        priority: 'p0',
-        reason: 'Changes affect security-sensitive code',
-      });
-    }
-
-    // E2E for high risk
-    if (level === 'critical' || level === 'high') {
-      tests.push({
-        type: 'e2e',
-        priority: 'p1',
-        reason: 'High-risk changes require end-to-end validation',
-      });
-    }
-
-    return tests;
-  }
-}
-
-// ============================================================================
-// Fallback Coverage Router
-// ============================================================================
-
-/**
- * Rule-based fallback for coverage routing
- */
-export class FallbackCoverageRouter implements CoverageRouter {
-  private readonly DEFAULT_TARGET_COVERAGE = 80;
-
-  async analyzeCoverage(
-    coverageData: FileCoverage[],
-    targetCoverage: number = this.DEFAULT_TARGET_COVERAGE
-  ): Promise<CoverageRoutingResult> {
-    const gaps = await this.getCoverageGaps(coverageData);
-    const prioritizedFiles = this.prioritizeFiles(coverageData, targetCoverage, gaps);
-    const testGenerationTargets = this.getTestGenerationTargets(coverageData);
-    const agentAssignments = this.assignAgents(prioritizedFiles);
-
-    return {
-      prioritizedFiles,
-      testGenerationTargets,
-      agentAssignments,
-      usedFallback: true,
-    };
-  }
-
-  async getCoverageGaps(coverageData: FileCoverage[]): Promise<CoverageGap[]> {
-    const gaps: CoverageGap[] = [];
-
-    for (const coverage of coverageData) {
-      // Line coverage gaps
-      if (coverage.uncoveredLines.length > 0) {
-        gaps.push({
-          filePath: coverage.filePath,
-          gapType: 'line',
-          severity: this.gapSeverity(coverage.lineCoverage),
-          lines: coverage.uncoveredLines,
-          recommendation: `Add tests for ${coverage.uncoveredLines.length} uncovered lines`,
-        });
-      }
-
-      // Branch coverage gaps
-      if (coverage.uncoveredBranches.length > 0) {
-        gaps.push({
-          filePath: coverage.filePath,
-          gapType: 'branch',
-          severity: this.gapSeverity(coverage.branchCoverage),
-          lines: coverage.uncoveredBranches.map((b) => b.line),
-          recommendation: `Add tests for ${coverage.uncoveredBranches.length} uncovered branches`,
-        });
-      }
-
-      // Function coverage gaps
-      if (coverage.uncoveredFunctions.length > 0) {
-        gaps.push({
-          filePath: coverage.filePath,
-          gapType: 'function',
-          severity: this.gapSeverity(coverage.functionCoverage),
-          functions: coverage.uncoveredFunctions,
-          recommendation: `Add tests for functions: ${coverage.uncoveredFunctions.join(', ')}`,
-        });
-      }
-    }
-
-    return gaps;
-  }
-
-  async prioritizeForCoverage(
-    files: string[],
-    coverageData: FileCoverage[]
-  ): Promise<string[]> {
-    const coverageMap = new Map(coverageData.map((c) => [c.filePath, c]));
-
-    return files.sort((a, b) => {
-      const coverageA = coverageMap.get(a);
-      const coverageB = coverageMap.get(b);
-
-      if (!coverageA && !coverageB) return 0;
-      if (!coverageA) return 1;
-      if (!coverageB) return -1;
-
-      // Lower coverage = higher priority (comes first)
-      return coverageA.lineCoverage - coverageB.lineCoverage;
-    });
-  }
-
-  async suggestTestsForCoverage(
-    filePath: string,
-    coverage: FileCoverage
-  ): Promise<Array<{ testType: string; target: string; expectedCoverageGain: number }>> {
-    const suggestions: Array<{ testType: string; target: string; expectedCoverageGain: number }> = [];
-
-    // Suggest tests for uncovered functions
-    for (const func of coverage.uncoveredFunctions) {
-      suggestions.push({
-        testType: 'unit',
-        target: `${filePath}:${func}`,
-        expectedCoverageGain: Math.min(20, 100 / Math.max(1, coverage.uncoveredFunctions.length)),
-      });
-    }
-
-    // Suggest branch coverage tests
-    if (coverage.uncoveredBranches.length > 0) {
-      suggestions.push({
-        testType: 'branch',
-        target: `${filePath} branches`,
-        expectedCoverageGain: Math.min(15, (100 - coverage.branchCoverage) / 3),
-      });
-    }
-
-    return suggestions;
-  }
-
-  private prioritizeFiles(
-    coverageData: FileCoverage[],
-    targetCoverage: number,
-    gaps: CoverageGap[]
-  ): Array<{
-    filePath: string;
-    currentCoverage: number;
-    targetCoverage: number;
-    gaps: CoverageGap[];
-    priority: Priority;
-  }> {
-    return coverageData
-      .filter((c) => c.lineCoverage < targetCoverage)
-      .map((c) => ({
-        filePath: c.filePath,
-        currentCoverage: c.lineCoverage,
-        targetCoverage,
-        gaps: gaps.filter((g) => g.filePath === c.filePath),
-        priority: this.coverageToPriority(c.lineCoverage),
-      }))
-      .sort((a, b) => a.currentCoverage - b.currentCoverage);
-  }
-
-  private getTestGenerationTargets(
-    coverageData: FileCoverage[]
-  ): Array<{ filePath: string; functions: string[]; reason: string }> {
-    return coverageData
-      .filter((c) => c.uncoveredFunctions.length > 0)
-      .map((c) => ({
-        filePath: c.filePath,
-        functions: c.uncoveredFunctions,
-        reason: `${c.uncoveredFunctions.length} untested functions`,
-      }));
-  }
-
-  private assignAgents(
-    prioritizedFiles: Array<{
-      filePath: string;
-      currentCoverage: number;
-      priority: Priority;
-    }>
-  ): 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 otherFiles = prioritizedFiles.filter((f) => f.priority !== 'p0' && f.priority !== 'p1').map((f) => f.filePath);
-
-    if (p0Files.length > 0) {
-      assignments.push({
-        agentType: 'generator',
-        domain: 'test-generation',
-        files: p0Files,
-      });
-    }
-
-    if (p1Files.length > 0) {
-      assignments.push({
-        agentType: 'tester',
-        domain: 'coverage-analysis',
-        files: p1Files,
-      });
-    }
-
-    if (otherFiles.length > 0) {
-      assignments.push({
-        agentType: 'specialist',
-        domain: 'test-execution',
-        files: otherFiles,
-      });
-    }
-
-    return assignments;
-  }
-
-  private gapSeverity(coverage: number): Severity {
-    if (coverage < 30) return 'critical';
-    if (coverage < 50) return 'high';
-    if (coverage < 70) return 'medium';
-    if (coverage < 80) return 'low';
-    return 'info';
-  }
-
-  private coverageToPriority(coverage: number): Priority {
-    if (coverage < 30) return 'p0';
-    if (coverage < 50) return 'p1';
-    if (coverage < 70) return 'p2';
-    return 'p3';
-  }
-}
-
-// ============================================================================
-// Fallback Graph Boundaries Analyzer
-// ============================================================================
-
-/**
- * Rule-based fallback for graph boundaries analysis
- */
-export class FallbackGraphBoundariesAnalyzer implements GraphBoundariesAnalyzer {
-  async analyzeBoundaries(entryPoints: string[]): Promise<GraphBoundariesResult> {
-    const modules = this.inferModules(entryPoints);
-    const boundaries = this.inferBoundaries(modules);
-    const criticalBoundaries = boundaries
-      .filter((b) => b.riskScore > 0.6)
-      .map((b) => `${b.fromModule}->${b.toModule}`);
-
-    return {
-      modules,
-      boundaries,
-      criticalBoundaries,
-      integrationTestSuggestions: this.suggestTests(boundaries),
-      violations: [],
-      usedFallback: true,
-    };
-  }
-
-  async getBoundaryCrossings(modules: string[]): Promise<BoundaryCrossing[]> {
-    // Fallback cannot determine actual crossings
-    return modules.slice(0, -1).map((mod, i) => ({
-      fromModule: mod,
-      toModule: modules[i + 1],
-      crossings: [],
-      riskScore: 0.5,
-      requiresIntegrationTest: true,
-    }));
-  }
-
-  async getCriticalPaths(): Promise<Array<{ path: string[]; importance: number; reason: string }>> {
-    // Fallback cannot determine critical paths
-    return [];
-  }
-
-  async suggestIntegrationTests(): Promise<Array<{
-    location: string;
-    modules: string[];
-    priority: Priority;
-    reason: string;
-  }>> {
-    return [];
-  }
-
-  async detectViolations(): Promise<Array<{
-    type: string;
-    location: string;
-    severity: Severity;
-    suggestion: string;
-  }>> {
-    // Fallback cannot detect violations without actual graph analysis
-    return [];
-  }
-
-  private inferModules(entryPoints: string[]): ModuleBoundary[] {
-    // Infer modules from directory structure
-    const moduleMap = new Map<string, string[]>();
-
-    for (const entry of entryPoints) {
-      const parts = entry.split('/');
-      const moduleName = parts.length > 1 ? parts[parts.length - 2] : 'root';
-
-      const existing = moduleMap.get(moduleName) || [];
-      existing.push(entry);
-      moduleMap.set(moduleName, existing);
-    }
-
-    return Array.from(moduleMap.entries()).map(([module, files]) => ({
-      module,
-      files,
-      publicAPIs: [],
-      dependencies: [],
-      couplingScore: 0.5, // Default
-      cohesionScore: 0.7, // Default
-    }));
-  }
-
-  private inferBoundaries(modules: ModuleBoundary[]): BoundaryCrossing[] {
-    const boundaries: BoundaryCrossing[] = [];
-
-    // Create boundaries between adjacent modules
-    for (let i = 0; i < modules.length; i++) {
-      for (let j = i + 1; j < modules.length; j++) {
-        boundaries.push({
-          fromModule: modules[i].module,
-          toModule: modules[j].module,
-          crossings: [],
-          riskScore: 0.5,
-          requiresIntegrationTest: true,
-        });
-      }
-    }
-
-    return boundaries;
-  }
-
-  private suggestTests(boundaries: BoundaryCrossing[]): Array<{
-    fromModule: string;
-    toModule: string;
-    reason: string;
-    priority: Priority;
-  }> {
-    return boundaries
-      .filter((b) => b.requiresIntegrationTest)
-      .map((b) => ({
-        fromModule: b.fromModule,
-        toModule: b.toModule,
-        reason: 'Cross-module boundary should be tested',
-        priority: b.riskScore > 0.7 ? 'p0' : 'p1',
-      }));
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create fallback implementations for all RuVector components
- */
-export function createFallbackComponents(): {
-  qLearningRouter: QLearningRouter;
-  astComplexityAnalyzer: ASTComplexityAnalyzer;
-  diffRiskClassifier: DiffRiskClassifier;
-  coverageRouter: CoverageRouter;
-  graphBoundariesAnalyzer: GraphBoundariesAnalyzer;
-} {
-  return {
-    qLearningRouter: new FallbackQLearningRouter(),
-    astComplexityAnalyzer: new FallbackASTComplexityAnalyzer(),
-    diffRiskClassifier: new FallbackDiffRiskClassifier(),
-    coverageRouter: new FallbackCoverageRouter(),
-    graphBoundariesAnalyzer: new FallbackGraphBoundariesAnalyzer(),
-  };
-}