@agentic-qe/v3 3.0.0-alpha.3

package/src/integrations/ruvector/fallback.ts

@@ -0,0 +1,942 @@
+/**
+ * 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(),
+  };
+}