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

package/src/integrations/ruvector/diff-risk-classifier.ts

@@ -1,759 +0,0 @@
-/**
- * Agentic QE v3 - Diff Risk Classifier for RuVector Integration
- *
- * Uses RuVector's ML capabilities to classify risk in code changes.
- * Falls back to rule-based classification when RuVector is unavailable.
- */
-
-import type {
-  DiffRiskClassifier,
-  RiskClassification,
-  DiffContext,
-  FileChange,
-  RuVectorConfig,
-} from './interfaces';
-import { FallbackDiffRiskClassifier } from './fallback';
-import type { Severity, Priority } from '../../shared/types';
-
-// ============================================================================
-// Risk Classification Patterns
-// ============================================================================
-
-/**
- * Pattern definitions for risk classification
- */
-export interface RiskPatterns {
-  /** High-risk code patterns (security, auth, etc.) */
-  highRisk: RegExp[];
-  /** Sensitive file patterns */
-  sensitiveFiles: RegExp[];
-  /** Critical path patterns */
-  criticalPaths: RegExp[];
-  /** Architectural boundary patterns */
-  boundaryPatterns: RegExp[];
-}
-
-const DEFAULT_RISK_PATTERNS: RiskPatterns = {
-  highRisk: [
-    /auth/i,
-    /security/i,
-    /password/i,
-    /token/i,
-    /secret/i,
-    /key/i,
-    /payment/i,
-    /billing/i,
-    /crypto/i,
-    /encrypt/i,
-    /decrypt/i,
-    /database/i,
-    /migration/i,
-    /schema/i,
-    /sql/i,
-    /permission/i,
-    /role/i,
-    /access/i,
-    /admin/i,
-    /credential/i,
-    /certificate/i,
-    /oauth/i,
-    /jwt/i,
-    /session/i,
-  ],
-  sensitiveFiles: [
-    /\.env/,
-    /config.*\.(ts|js|json)$/,
-    /secrets?\./,
-    /credentials?\./,
-    /\.pem$/,
-    /\.key$/,
-    /\.crt$/,
-    /password/i,
-    /api[_-]?key/i,
-  ],
-  criticalPaths: [
-    /kernel/i,
-    /core/i,
-    /engine/i,
-    /foundation/i,
-    /infrastructure/i,
-    /bootstrap/i,
-    /init/i,
-    /startup/i,
-  ],
-  boundaryPatterns: [
-    /interface/i,
-    /contract/i,
-    /api/i,
-    /public/i,
-    /external/i,
-    /gateway/i,
-    /adapter/i,
-  ],
-};
-
-// ============================================================================
-// RuVector Diff Risk Classifier Implementation
-// ============================================================================
-
-/**
- * Diff risk classifier that integrates with RuVector
- * Provides ML-enhanced risk classification for code changes
- */
-export class RuVectorDiffRiskClassifier implements DiffRiskClassifier {
-  private readonly fallback: FallbackDiffRiskClassifier;
-  private readonly patterns: RiskPatterns;
-  private readonly cache: Map<string, { result: RiskClassification; timestamp: number }> = new Map();
-
-  constructor(
-    private readonly config: RuVectorConfig,
-    patterns?: Partial<RiskPatterns>
-  ) {
-    this.fallback = new FallbackDiffRiskClassifier();
-    this.patterns = { ...DEFAULT_RISK_PATTERNS, ...patterns };
-  }
-
-  /**
-   * Classify risk of a diff/changeset
-   */
-  async classifyDiff(context: DiffContext): Promise<RiskClassification> {
-    if (!this.config.enabled) {
-      return this.fallback.classifyDiff(context);
-    }
-
-    // Check cache
-    const cacheKey = this.computeCacheKey(context);
-    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.performClassification(context);
-
-      // Cache result
-      if (this.config.cacheEnabled) {
-        this.cache.set(cacheKey, { result, timestamp: Date.now() });
-      }
-
-      return result;
-    } catch (error) {
-      console.warn('[RuVectorDiffRiskClassifier] Classification failed, using fallback:', error);
-      return this.fallback.classifyDiff(context);
-    }
-  }
-
-  /**
-   * Get files sorted by risk
-   */
-  async rankFilesByRisk(
-    files: FileChange[]
-  ): Promise<Array<{ filePath: string; riskScore: number; riskLevel: Severity }>> {
-    const rankings = await Promise.all(
-      files.map(async (file) => {
-        const score = await this.calculateFileRisk(file);
-        return {
-          filePath: file.filePath,
-          riskScore: score,
-          riskLevel: this.scoreToLevel(score),
-        };
-      })
-    );
-
-    return rankings.sort((a, b) => b.riskScore - a.riskScore);
-  }
-
-  /**
-   * Check if change requires security review
-   */
-  async requiresSecurityReview(context: DiffContext): Promise<boolean> {
-    const securityIndicators = [
-      // Check for security-related file changes
-      context.files.some((f) =>
-        this.patterns.highRisk.some((p) => p.test(f.filePath))
-      ),
-      // Check for sensitive files
-      context.files.some((f) =>
-        this.patterns.sensitiveFiles.some((p) => p.test(f.filePath))
-      ),
-      // Check commit message for security keywords
-      context.message &&
-        /security|vulnerability|cve|exploit|patch|fix.*auth|fix.*token/i.test(context.message),
-      // Check for large changes to critical code
-      context.files.some(
-        (f) =>
-          this.patterns.criticalPaths.some((p) => p.test(f.filePath)) &&
-          f.additions + f.deletions > 50
-      ),
-    ];
-
-    return securityIndicators.some(Boolean);
-  }
-
-  /**
-   * Get recommended reviewers based on risk
-   */
-  async getRecommendedReviewers(context: DiffContext): Promise<string[]> {
-    const reviewers: Set<string> = new Set();
-
-    // Determine reviewer types based on change characteristics
-    const hasSecurityChanges = context.files.some((f) =>
-      this.patterns.highRisk.some((p) => p.test(f.filePath))
-    );
-    const hasAPIChanges = context.files.some((f) =>
-      this.patterns.boundaryPatterns.some((p) => p.test(f.filePath))
-    );
-    const hasCoreChanges = context.files.some((f) =>
-      this.patterns.criticalPaths.some((p) => p.test(f.filePath))
-    );
-
-    // Add reviewer roles based on change types
-    if (hasSecurityChanges) {
-      reviewers.add('security-team');
-    }
-    if (hasAPIChanges) {
-      reviewers.add('api-owner');
-    }
-    if (hasCoreChanges) {
-      reviewers.add('tech-lead');
-    }
-
-    // Add domain-specific reviewers
-    const domains = this.identifyDomains(context.files);
-    for (const domain of domains) {
-      reviewers.add(`${domain}-owner`);
-    }
-
-    return Array.from(reviewers);
-  }
-
-  /**
-   * Predict potential defects in change
-   */
-  async predictDefects(
-    context: DiffContext
-  ): Promise<Array<{
-    filePath: string;
-    probability: number;
-    type: string;
-    location?: { line: number; column: number };
-  }>> {
-    const predictions: Array<{
-      filePath: string;
-      probability: number;
-      type: string;
-      location?: { line: number; column: number };
-    }> = [];
-
-    for (const file of context.files) {
-      const riskScore = await this.calculateFileRisk(file);
-
-      // High-risk changes have higher defect probability
-      if (riskScore > 0.5) {
-        predictions.push({
-          filePath: file.filePath,
-          probability: riskScore,
-          type: this.predictDefectType(file, riskScore),
-          location: this.estimateDefectLocation(file),
-        });
-      }
-
-      // Large additions are prone to new-code defects
-      if (file.additions > 100) {
-        predictions.push({
-          filePath: file.filePath,
-          probability: Math.min(0.8, file.additions / 500),
-          type: 'new-code-defect',
-        });
-      }
-
-      // Large deletions might cause regressions
-      if (file.deletions > 50 && file.status !== 'deleted') {
-        predictions.push({
-          filePath: file.filePath,
-          probability: Math.min(0.6, file.deletions / 200),
-          type: 'regression',
-        });
-      }
-    }
-
-    return predictions.sort((a, b) => b.probability - a.probability);
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  /**
-   * Perform risk classification
-   */
-  private async performClassification(context: DiffContext): Promise<RiskClassification> {
-    const factors: Array<{ name: string; weight: number; description: string }> = [];
-    let totalWeight = 0;
-    let weightedSum = 0;
-
-    // Factor: Total change size
-    const totalChanges = context.files.reduce(
-      (sum, f) => sum + f.additions + f.deletions,
-      0
-    );
-    const changeSizeFactor = this.calculateChangeSizeFactor(totalChanges);
-    if (changeSizeFactor.weight > 0) {
-      factors.push(changeSizeFactor);
-      weightedSum += changeSizeFactor.weight * changeSizeFactor.score;
-      totalWeight += changeSizeFactor.weight;
-    }
-
-    // Factor: Security-sensitive code
-    const securityFactor = this.calculateSecurityFactor(context.files);
-    if (securityFactor.weight > 0) {
-      factors.push(securityFactor);
-      weightedSum += securityFactor.weight * securityFactor.score;
-      totalWeight += securityFactor.weight;
-    }
-
-    // Factor: Critical path changes
-    const criticalPathFactor = this.calculateCriticalPathFactor(context.files);
-    if (criticalPathFactor.weight > 0) {
-      factors.push(criticalPathFactor);
-      weightedSum += criticalPathFactor.weight * criticalPathFactor.score;
-      totalWeight += criticalPathFactor.weight;
-    }
-
-    // Factor: API boundary changes
-    const boundaryFactor = this.calculateBoundaryFactor(context.files);
-    if (boundaryFactor.weight > 0) {
-      factors.push(boundaryFactor);
-      weightedSum += boundaryFactor.weight * boundaryFactor.score;
-      totalWeight += boundaryFactor.weight;
-    }
-
-    // Factor: File diversity
-    const diversityFactor = this.calculateDiversityFactor(context.files);
-    if (diversityFactor.weight > 0) {
-      factors.push(diversityFactor);
-      weightedSum += diversityFactor.weight * diversityFactor.score;
-      totalWeight += diversityFactor.weight;
-    }
-
-    // Factor: Deleted files
-    const deletionFactor = this.calculateDeletionFactor(context.files);
-    if (deletionFactor.weight > 0) {
-      factors.push(deletionFactor);
-      weightedSum += deletionFactor.weight * deletionFactor.score;
-      totalWeight += deletionFactor.weight;
-    }
-
-    const score = totalWeight > 0 ? weightedSum / totalWeight : 0.2;
-    const level = this.scoreToLevel(score);
-    const highRiskFiles = await this.identifyHighRiskFiles(context.files);
-    const recommendedTests = this.generateTestRecommendations(context, level);
-
-    return {
-      level,
-      score: Math.min(1, score),
-      factors: factors.map((f) => ({
-        name: f.name,
-        weight: f.weight,
-        description: f.description,
-      })),
-      highRiskFiles,
-      recommendedTests,
-      usedFallback: false,
-    };
-  }
-
-  /**
-   * Calculate change size risk factor
-   */
-  private calculateChangeSizeFactor(totalChanges: number): {
-    name: string;
-    weight: number;
-    score: number;
-    description: string;
-  } {
-    if (totalChanges > 1000) {
-      return {
-        name: 'very-large-change',
-        weight: 0.35,
-        score: 1,
-        description: `Very large changeset with ${totalChanges} lines modified`,
-      };
-    }
-    if (totalChanges > 500) {
-      return {
-        name: 'large-change',
-        weight: 0.3,
-        score: 0.8,
-        description: `Large changeset with ${totalChanges} lines modified`,
-      };
-    }
-    if (totalChanges > 200) {
-      return {
-        name: 'moderate-change',
-        weight: 0.2,
-        score: 0.5,
-        description: `Moderate changeset with ${totalChanges} lines modified`,
-      };
-    }
-    return {
-      name: 'small-change',
-      weight: 0,
-      score: 0,
-      description: '',
-    };
-  }
-
-  /**
-   * Calculate security-sensitive code factor
-   */
-  private calculateSecurityFactor(files: FileChange[]): {
-    name: string;
-    weight: number;
-    score: number;
-    description: string;
-  } {
-    const sensitiveFiles = files.filter((f) =>
-      this.patterns.highRisk.some((p) => p.test(f.filePath))
-    );
-
-    if (sensitiveFiles.length === 0) {
-      return { name: '', weight: 0, score: 0, description: '' };
-    }
-
-    const sensitiveFileNames = sensitiveFiles.map((f) => f.filePath).slice(0, 3);
-    const score = Math.min(1, sensitiveFiles.length / 3);
-
-    return {
-      name: 'security-sensitive',
-      weight: 0.4,
-      score,
-      description: `${sensitiveFiles.length} security-sensitive file(s): ${sensitiveFileNames.join(', ')}`,
-    };
-  }
-
-  /**
-   * Calculate critical path factor
-   */
-  private calculateCriticalPathFactor(files: FileChange[]): {
-    name: string;
-    weight: number;
-    score: number;
-    description: string;
-  } {
-    const criticalFiles = files.filter((f) =>
-      this.patterns.criticalPaths.some((p) => p.test(f.filePath))
-    );
-
-    if (criticalFiles.length === 0) {
-      return { name: '', weight: 0, score: 0, description: '' };
-    }
-
-    return {
-      name: 'critical-path',
-      weight: 0.35,
-      score: Math.min(1, criticalFiles.length / 2),
-      description: `${criticalFiles.length} file(s) in critical paths`,
-    };
-  }
-
-  /**
-   * Calculate API boundary factor
-   */
-  private calculateBoundaryFactor(files: FileChange[]): {
-    name: string;
-    weight: number;
-    score: number;
-    description: string;
-  } {
-    const boundaryFiles = files.filter((f) =>
-      this.patterns.boundaryPatterns.some((p) => p.test(f.filePath))
-    );
-
-    if (boundaryFiles.length === 0) {
-      return { name: '', weight: 0, score: 0, description: '' };
-    }
-
-    return {
-      name: 'api-boundary',
-      weight: 0.25,
-      score: Math.min(1, boundaryFiles.length / 5),
-      description: `${boundaryFiles.length} API boundary file(s) modified`,
-    };
-  }
-
-  /**
-   * Calculate file diversity factor
-   */
-  private calculateDiversityFactor(files: FileChange[]): {
-    name: string;
-    weight: number;
-    score: number;
-    description: string;
-  } {
-    // Get unique directories
-    const directories = new Set(
-      files.map((f) => f.filePath.split('/').slice(0, -1).join('/'))
-    );
-
-    if (directories.size <= 3) {
-      return { name: '', weight: 0, score: 0, description: '' };
-    }
-
-    return {
-      name: 'high-diversity',
-      weight: 0.2,
-      score: Math.min(1, directories.size / 10),
-      description: `Changes span ${directories.size} different directories`,
-    };
-  }
-
-  /**
-   * Calculate deletion factor
-   */
-  private calculateDeletionFactor(files: FileChange[]): {
-    name: string;
-    weight: number;
-    score: number;
-    description: string;
-  } {
-    const deletedFiles = files.filter((f) => f.status === 'deleted');
-
-    if (deletedFiles.length === 0) {
-      return { name: '', weight: 0, score: 0, description: '' };
-    }
-
-    return {
-      name: 'file-deletions',
-      weight: 0.2,
-      score: Math.min(1, deletedFiles.length / 5),
-      description: `${deletedFiles.length} file(s) deleted`,
-    };
-  }
-
-  /**
-   * Calculate risk score for a single file
-   */
-  private async calculateFileRisk(file: FileChange): Promise<number> {
-    let risk = 0.2; // Base risk
-
-    // Sensitive file patterns
-    if (this.patterns.sensitiveFiles.some((p) => p.test(file.filePath))) {
-      risk += 0.35;
-    }
-
-    // High-risk code patterns
-    if (this.patterns.highRisk.some((p) => p.test(file.filePath))) {
-      risk += 0.25;
-    }
-
-    // Critical paths
-    if (this.patterns.criticalPaths.some((p) => p.test(file.filePath))) {
-      risk += 0.2;
-    }
-
-    // Change size factor
-    const changes = file.additions + file.deletions;
-    if (changes > 200) risk += 0.2;
-    else if (changes > 100) risk += 0.1;
-    else if (changes > 50) risk += 0.05;
-
-    // File type factor
-    if (file.filePath.endsWith('.sql') || file.filePath.endsWith('.migration')) {
-      risk += 0.15;
-    }
-
-    // Deleted files have inherent risk
-    if (file.status === 'deleted') risk += 0.1;
-
-    return Math.min(1, risk);
-  }
-
-  /**
-   * Identify high-risk files
-   */
-  private async identifyHighRiskFiles(files: FileChange[]): Promise<string[]> {
-    const riskScores = await Promise.all(
-      files.map(async (f) => ({
-        path: f.filePath,
-        score: await this.calculateFileRisk(f),
-      }))
-    );
-
-    return riskScores
-      .filter((r) => r.score >= 0.6)
-      .sort((a, b) => b.score - a.score)
-      .map((r) => r.path);
-  }
-
-  /**
-   * Convert score to risk level
-   */
-  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';
-  }
-
-  /**
-   * Generate test recommendations
-   */
-  private generateTestRecommendations(
-    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;
-    }> = [];
-
-    // Unit tests always recommended
-    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 across boundaries',
-      });
-    }
-
-    // Security tests for security-related changes
-    if (
-      context.files.some((f) =>
-        this.patterns.highRisk.some((p) => p.test(f.filePath))
-      )
-    ) {
-      tests.push({
-        type: 'security',
-        priority: 'p0',
-        reason: 'Changes affect security-sensitive code paths',
-      });
-    }
-
-    // E2E tests for critical/high risk
-    if (level === 'critical' || level === 'high') {
-      tests.push({
-        type: 'e2e',
-        priority: level === 'critical' ? 'p0' : 'p1',
-        reason: 'High-risk changes require end-to-end validation',
-      });
-    }
-
-    // Performance tests for large changes to core code
-    if (
-      context.files.some(
-        (f) =>
-          this.patterns.criticalPaths.some((p) => p.test(f.filePath)) &&
-          f.additions + f.deletions > 100
-      )
-    ) {
-      tests.push({
-        type: 'performance',
-        priority: 'p1',
-        reason: 'Large changes to core code may impact performance',
-      });
-    }
-
-    return tests;
-  }
-
-  /**
-   * Predict defect type based on file and risk score
-   */
-  private predictDefectType(file: FileChange, riskScore: number): string {
-    if (this.patterns.highRisk.some((p) => p.test(file.filePath))) {
-      return 'security-vulnerability';
-    }
-    if (file.status === 'deleted' || file.deletions > file.additions) {
-      return 'regression';
-    }
-    if (riskScore > 0.7) {
-      return 'logic-error';
-    }
-    return 'new-code-defect';
-  }
-
-  /**
-   * Estimate defect location in file
-   */
-  private estimateDefectLocation(
-    file: FileChange
-  ): { line: number; column: number } | undefined {
-    if (file.hunks && file.hunks.length > 0) {
-      // Estimate defect near middle of first hunk
-      const hunk = file.hunks[0];
-      return {
-        line: Math.round((hunk.startLine + hunk.endLine) / 2),
-        column: 1,
-      };
-    }
-    return undefined;
-  }
-
-  /**
-   * Identify domains touched by changes
-   */
-  private identifyDomains(files: FileChange[]): string[] {
-    const domains = new Set<string>();
-
-    for (const file of files) {
-      // Extract domain from path patterns
-      const match = file.filePath.match(/domains?\/([^/]+)/i);
-      if (match) {
-        domains.add(match[1]);
-      }
-
-      // Check for known domain patterns
-      if (file.filePath.includes('auth')) domains.add('auth');
-      if (file.filePath.includes('payment')) domains.add('payment');
-      if (file.filePath.includes('user')) domains.add('user');
-      if (file.filePath.includes('api')) domains.add('api');
-    }
-
-    return Array.from(domains);
-  }
-
-  /**
-   * Compute cache key for context
-   */
-  private computeCacheKey(context: DiffContext): string {
-    const fileKeys = context.files
-      .map((f) => `${f.filePath}:${f.status}:${f.additions}:${f.deletions}`)
-      .sort()
-      .join('|');
-
-    return `${context.commitHash || 'unknown'}:${fileKeys}`;
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create diff risk classifier with optional RuVector integration
- */
-export function createDiffRiskClassifier(
-  config: RuVectorConfig,
-  patterns?: Partial<RiskPatterns>
-): DiffRiskClassifier {
-  if (config.enabled) {
-    return new RuVectorDiffRiskClassifier(config, patterns);
-  }
-  return new FallbackDiffRiskClassifier();
-}