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

package/src/integrations/ruvector/ast-complexity.ts

@@ -1,470 +0,0 @@
-/**
- * Agentic QE v3 - AST Complexity Analyzer for RuVector Integration
- *
- * Uses RuVector's AST analysis capabilities to compute code complexity metrics.
- * Falls back to estimation-based analysis when RuVector is unavailable.
- */
-
-import type {
-  ASTComplexityAnalyzer,
-  FileComplexityResult,
-  ComplexityMetrics,
-  RuVectorConfig,
-} from './interfaces';
-import { FallbackASTComplexityAnalyzer } from './fallback';
-import type { Severity, Priority } from '../../shared/types';
-
-// ============================================================================
-// Complexity Thresholds
-// ============================================================================
-
-export interface ComplexityThresholds {
-  cyclomatic: { low: number; medium: number; high: number; critical: number };
-  cognitive: { low: number; medium: number; high: number; critical: number };
-  linesOfCode: { low: number; medium: number; high: number; critical: number };
-  maintainabilityIndex: { critical: number; high: number; medium: number; low: number };
-}
-
-const DEFAULT_THRESHOLDS: ComplexityThresholds = {
-  cyclomatic: { low: 5, medium: 10, high: 20, critical: 30 },
-  cognitive: { low: 8, medium: 15, high: 25, critical: 40 },
-  linesOfCode: { low: 100, medium: 200, high: 500, critical: 1000 },
-  maintainabilityIndex: { critical: 20, high: 40, medium: 60, low: 80 },
-};
-
-// ============================================================================
-// RuVector AST Complexity Analyzer Implementation
-// ============================================================================
-
-/**
- * AST-based complexity analyzer that integrates with RuVector
- * Provides detailed code complexity metrics for test prioritization
- */
-export class RuVectorASTComplexityAnalyzer implements ASTComplexityAnalyzer {
-  private readonly fallback: FallbackASTComplexityAnalyzer;
-  private readonly thresholds: ComplexityThresholds;
-  private readonly cache: Map<string, { result: FileComplexityResult; timestamp: number }> = new Map();
-
-  constructor(
-    private readonly config: RuVectorConfig,
-    thresholds?: Partial<ComplexityThresholds>
-  ) {
-    this.fallback = new FallbackASTComplexityAnalyzer();
-    this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
-  }
-
-  /**
-   * Analyze complexity of a single file
-   */
-  async analyzeFile(filePath: string): Promise<FileComplexityResult> {
-    if (!this.config.enabled) {
-      return this.fallback.analyzeFile(filePath);
-    }
-
-    // Check cache
-    if (this.config.cacheEnabled) {
-      const cached = this.cache.get(filePath);
-      if (cached && Date.now() - cached.timestamp < (this.config.cacheTtl || 300000)) {
-        return cached.result;
-      }
-    }
-
-    try {
-      const result = await this.performAnalysis(filePath);
-
-      // Cache result
-      if (this.config.cacheEnabled) {
-        this.cache.set(filePath, { result, timestamp: Date.now() });
-      }
-
-      return result;
-    } catch (error) {
-      console.warn('[RuVectorASTComplexityAnalyzer] Analysis failed, using fallback:', error);
-      return this.fallback.analyzeFile(filePath);
-    }
-  }
-
-  /**
-   * Analyze complexity of multiple files
-   */
-  async analyzeFiles(filePaths: string[]): Promise<FileComplexityResult[]> {
-    return Promise.all(filePaths.map((fp) => this.analyzeFile(fp)));
-  }
-
-  /**
-   * Get complexity ranking for test prioritization
-   */
-  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);
-  }
-
-  /**
-   * Suggest test focus areas based on complexity
-   */
-  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 || r.hotspots.length > 0)
-      .map((r) => ({
-        filePath: r.filePath,
-        functions: r.hotspots.map((h) => h.name),
-        reason: this.generateTestFocusReason(r),
-      }));
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  /**
-   * Perform AST-based complexity analysis
-   */
-  private async performAnalysis(filePath: string): Promise<FileComplexityResult> {
-    // Determine file type for appropriate analysis
-    const fileType = this.getFileType(filePath);
-
-    // Analyze based on file patterns and heuristics
-    // In a real implementation, this would use RuVector's AST analysis
-    const metrics = await this.computeMetrics(filePath, fileType);
-    const overallScore = this.calculateOverallScore(metrics);
-    const riskLevel = this.metricsToRiskLevel(metrics);
-    const hotspots = this.identifyHotspots(filePath, metrics);
-    const recommendations = this.generateRecommendations(metrics, riskLevel);
-
-    return {
-      filePath,
-      metrics,
-      overallScore,
-      riskLevel,
-      hotspots,
-      recommendations,
-      analyzedAt: new Date(),
-      usedFallback: false,
-    };
-  }
-
-  /**
-   * Get file type for analysis
-   */
-  private getFileType(filePath: string): 'typescript' | 'javascript' | 'json' | 'other' {
-    if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) return 'typescript';
-    if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) return 'javascript';
-    if (filePath.endsWith('.json')) return 'json';
-    return 'other';
-  }
-
-  /**
-   * Compute complexity metrics
-   */
-  private async computeMetrics(
-    filePath: string,
-    fileType: string
-  ): Promise<ComplexityMetrics> {
-    // Base metrics estimation (would use RuVector AST in real impl)
-    const baseComplexity = this.estimateBaseComplexity(filePath);
-
-    // Adjust based on file type
-    const typeMultiplier = fileType === 'typescript' ? 1.1 : fileType === 'json' ? 0.3 : 1.0;
-
-    // Compute individual metrics
-    const cyclomatic = Math.max(1, Math.round(baseComplexity * typeMultiplier));
-    const cognitive = Math.round(cyclomatic * 1.3);
-    const linesOfCode = Math.round(baseComplexity * 40);
-
-    // Compute derived metrics
-    const dependencies = this.estimateDependencies(filePath);
-    const inheritanceDepth = this.estimateInheritanceDepth(filePath);
-    const coupling = this.calculateCoupling(dependencies, linesOfCode);
-    const cohesion = this.calculateCohesion(cyclomatic, linesOfCode);
-    const halsteadDifficulty = cyclomatic * 2 + dependencies;
-    const maintainabilityIndex = this.calculateMaintainabilityIndex(
-      cyclomatic,
-      linesOfCode,
-      halsteadDifficulty
-    );
-
-    return {
-      cyclomatic,
-      cognitive,
-      linesOfCode,
-      dependencies,
-      inheritanceDepth,
-      coupling,
-      cohesion,
-      halsteadDifficulty,
-      maintainabilityIndex,
-    };
-  }
-
-  /**
-   * Estimate base complexity from file path
-   */
-  private estimateBaseComplexity(filePath: string): number {
-    let complexity = 5; // Default
-
-    // File patterns that indicate complexity
-    if (filePath.includes('service')) complexity += 5;
-    if (filePath.includes('handler')) complexity += 4;
-    if (filePath.includes('controller')) complexity += 4;
-    if (filePath.includes('validator')) complexity += 3;
-    if (filePath.includes('coordinator')) complexity += 6;
-    if (filePath.includes('engine')) complexity += 7;
-
-    // Patterns that indicate simplicity
-    if (filePath.includes('types') || filePath.includes('interfaces')) complexity -= 3;
-    if (filePath.includes('constants') || filePath.includes('config')) complexity -= 4;
-    if (filePath.includes('.test.') || filePath.includes('.spec.')) complexity -= 2;
-    if (filePath.includes('utils') || filePath.includes('helpers')) complexity -= 1;
-
-    // Path depth factor
-    const depth = filePath.split('/').length;
-    complexity += Math.min(depth * 0.5, 3);
-
-    return Math.max(1, complexity);
-  }
-
-  /**
-   * Estimate number of dependencies
-   */
-  private estimateDependencies(filePath: string): number {
-    let deps = 3; // Base
-
-    if (filePath.includes('service')) deps += 4;
-    if (filePath.includes('coordinator')) deps += 6;
-    if (filePath.includes('index.ts')) deps += 2;
-
-    return Math.min(20, deps);
-  }
-
-  /**
-   * Estimate inheritance depth
-   */
-  private estimateInheritanceDepth(filePath: string): number {
-    if (filePath.includes('Base')) return 0;
-    if (filePath.includes('Abstract')) return 1;
-    if (filePath.includes('service') || filePath.includes('handler')) return 2;
-    return 1;
-  }
-
-  /**
-   * Calculate coupling score (0-1)
-   */
-  private calculateCoupling(dependencies: number, linesOfCode: number): number {
-    // More dependencies relative to size = higher coupling
-    const ratio = dependencies / Math.max(1, linesOfCode / 50);
-    return Math.min(1, ratio / 5);
-  }
-
-  /**
-   * Calculate cohesion score (0-1)
-   */
-  private calculateCohesion(cyclomatic: number, linesOfCode: number): number {
-    // Higher cyclomatic relative to LOC = lower cohesion
-    const ratio = cyclomatic / Math.max(1, linesOfCode / 20);
-    return Math.max(0.2, 1 - ratio / 10);
-  }
-
-  /**
-   * Calculate maintainability index (0-100)
-   */
-  private calculateMaintainabilityIndex(
-    cyclomatic: number,
-    linesOfCode: number,
-    halstead: number
-  ): number {
-    // Simplified MI formula
-    const hvol = Math.log(Math.max(1, halstead)) * 2;
-    const cc = Math.log(Math.max(1, cyclomatic));
-    const loc = Math.log(Math.max(1, linesOfCode));
-
-    const mi = Math.max(0, 171 - 5.2 * hvol - 0.23 * cc - 16.2 * loc);
-    return Math.min(100, mi);
-  }
-
-  /**
-   * Calculate overall complexity score (0-1)
-   */
-  private calculateOverallScore(metrics: ComplexityMetrics): number {
-    // Normalize each metric
-    const cyclomaticNorm = Math.min(1, metrics.cyclomatic / this.thresholds.cyclomatic.critical);
-    const cognitiveNorm = Math.min(1, metrics.cognitive / this.thresholds.cognitive.critical);
-    const locNorm = Math.min(1, metrics.linesOfCode / this.thresholds.linesOfCode.critical);
-    const miNorm = 1 - (metrics.maintainabilityIndex / 100);
-
-    // Weighted average
-    return (
-      cyclomaticNorm * 0.25 +
-      cognitiveNorm * 0.25 +
-      locNorm * 0.15 +
-      metrics.coupling * 0.15 +
-      (1 - metrics.cohesion) * 0.1 +
-      miNorm * 0.1
-    );
-  }
-
-  /**
-   * Convert metrics to risk level
-   */
-  private metricsToRiskLevel(metrics: ComplexityMetrics): Severity {
-    const score = this.calculateOverallScore(metrics);
-
-    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';
-  }
-
-  /**
-   * Convert score to priority
-   */
-  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';
-  }
-
-  /**
-   * Identify complexity hotspots
-   */
-  private identifyHotspots(
-    filePath: string,
-    metrics: ComplexityMetrics
-  ): Array<{ name: string; line: number; complexity: number; recommendation?: string }> {
-    const hotspots: Array<{ name: string; line: number; complexity: number; recommendation?: string }> = [];
-
-    // Identify based on high cyclomatic complexity
-    if (metrics.cyclomatic > this.thresholds.cyclomatic.high) {
-      hotspots.push({
-        name: 'Main function',
-        line: 1,
-        complexity: metrics.cyclomatic,
-        recommendation: 'Consider breaking into smaller functions',
-      });
-    }
-
-    // Identify based on low maintainability
-    if (metrics.maintainabilityIndex < this.thresholds.maintainabilityIndex.high) {
-      hotspots.push({
-        name: 'Module structure',
-        line: 1,
-        complexity: Math.round(100 - metrics.maintainabilityIndex),
-        recommendation: 'Refactor to improve maintainability',
-      });
-    }
-
-    // Identify based on high coupling
-    if (metrics.coupling > 0.7) {
-      hotspots.push({
-        name: 'Dependencies',
-        line: 1,
-        complexity: Math.round(metrics.coupling * 100),
-        recommendation: 'Consider dependency injection to reduce coupling',
-      });
-    }
-
-    return hotspots;
-  }
-
-  /**
-   * Generate recommendations based on metrics
-   */
-  private generateRecommendations(metrics: ComplexityMetrics, riskLevel: Severity): string[] {
-    const recommendations: string[] = [];
-
-    if (metrics.cyclomatic > this.thresholds.cyclomatic.medium) {
-      recommendations.push(
-        `High cyclomatic complexity (${metrics.cyclomatic}): ` +
-        'Break down complex conditional logic into smaller functions'
-      );
-    }
-
-    if (metrics.cognitive > this.thresholds.cognitive.medium) {
-      recommendations.push(
-        `High cognitive complexity (${metrics.cognitive}): ` +
-        'Simplify nested structures and reduce cognitive load'
-      );
-    }
-
-    if (metrics.coupling > 0.6) {
-      recommendations.push(
-        `High coupling (${(metrics.coupling * 100).toFixed(0)}%): ` +
-        'Consider using dependency injection and interface abstractions'
-      );
-    }
-
-    if (metrics.cohesion < 0.5) {
-      recommendations.push(
-        `Low cohesion (${(metrics.cohesion * 100).toFixed(0)}%): ` +
-        'Module may have multiple responsibilities - consider splitting'
-      );
-    }
-
-    if (metrics.maintainabilityIndex < this.thresholds.maintainabilityIndex.medium) {
-      recommendations.push(
-        `Low maintainability index (${metrics.maintainabilityIndex.toFixed(0)}): ` +
-        'Add documentation and improve code organization'
-      );
-    }
-
-    if (riskLevel === 'critical' || riskLevel === 'high') {
-      recommendations.push('Prioritize comprehensive unit test coverage for this file');
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * Generate reason for test focus
-   */
-  private generateTestFocusReason(result: FileComplexityResult): string {
-    const reasons: string[] = [];
-
-    if (result.metrics.cyclomatic > this.thresholds.cyclomatic.medium) {
-      reasons.push(`high cyclomatic complexity (${result.metrics.cyclomatic})`);
-    }
-
-    if (result.hotspots.length > 0) {
-      reasons.push(`${result.hotspots.length} complexity hotspot(s)`);
-    }
-
-    if (result.riskLevel === 'critical' || result.riskLevel === 'high') {
-      reasons.push(`${result.riskLevel} risk level`);
-    }
-
-    return reasons.length > 0
-      ? `Focus testing due to: ${reasons.join(', ')}`
-      : 'Elevated complexity score suggests focused testing';
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create AST complexity analyzer with optional RuVector integration
- */
-export function createASTComplexityAnalyzer(
-  config: RuVectorConfig,
-  thresholds?: Partial<ComplexityThresholds>
-): ASTComplexityAnalyzer {
-  if (config.enabled) {
-    return new RuVectorASTComplexityAnalyzer(config, thresholds);
-  }
-  return new FallbackASTComplexityAnalyzer();
-}