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

package/src/domains/defect-intelligence/services/defect-predictor.ts

@@ -1,852 +0,0 @@
-/**
- * Agentic QE v3 - Defect Prediction Service
- * ML-based defect prediction using code metrics and historical data
- * Uses GitAnalyzer for real git history analysis
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { Result, ok, err, Severity } from '../../../shared/types';
-import { MemoryBackend } from '../../../kernel/interfaces';
-import {
-  PredictRequest,
-  PredictionResult,
-  FilePrediction,
-  PredictionFeature,
-  RegressionRequest,
-  RegressionRisk,
-  ImpactedArea,
-} from '../interfaces';
-import { GitAnalyzer } from '../../../shared/git';
-import { FileReader } from '../../../shared/io';
-import { TypeScriptParser } from '../../../shared/parsers';
-
-/**
- * Interface for the defect prediction service
- */
-export interface IDefectPredictorService {
-  predictDefects(request: PredictRequest): Promise<Result<PredictionResult, Error>>;
-  analyzeRegressionRisk(request: RegressionRequest): Promise<Result<RegressionRisk, Error>>;
-  updateModel(feedback: PredictionFeedback): Promise<Result<void, Error>>;
-  getModelMetrics(): Promise<ModelMetrics>;
-}
-
-/**
- * Prediction feedback for model improvement
- */
-export interface PredictionFeedback {
-  predictionId: string;
-  file: string;
-  predictedProbability: number;
-  actualDefect: boolean;
-  defectType?: string;
-}
-
-/**
- * Model performance metrics
- */
-export interface ModelMetrics {
-  accuracy: number;
-  precision: number;
-  recall: number;
-  f1Score: number;
-  totalPredictions: number;
-  lastUpdated: Date;
-}
-
-/**
- * Configuration for the defect predictor
- */
-export interface DefectPredictorConfig {
-  defaultThreshold: number;
-  maxPredictionsPerBatch: number;
-  enableHistoricalAnalysis: boolean;
-  modelNamespace: string;
-  featureWeights: Record<string, number>;
-}
-
-const DEFAULT_CONFIG: DefectPredictorConfig = {
-  defaultThreshold: 0.5,
-  maxPredictionsPerBatch: 100,
-  enableHistoricalAnalysis: true,
-  modelNamespace: 'defect-intelligence:predictor',
-  featureWeights: {
-    codeComplexity: 0.25,
-    changeFrequency: 0.20,
-    developerExperience: 0.15,
-    testCoverage: 0.20,
-    codeAge: 0.10,
-    bugHistory: 0.10,
-  },
-};
-
-/**
- * Default prediction features
- */
-const DEFAULT_FEATURES: PredictionFeature[] = [
-  { name: 'codeComplexity', weight: 0.25 },
-  { name: 'changeFrequency', weight: 0.20 },
-  { name: 'developerExperience', weight: 0.15 },
-  { name: 'testCoverage', weight: 0.20 },
-  { name: 'codeAge', weight: 0.10 },
-  { name: 'bugHistory', weight: 0.10 },
-];
-
-/**
- * Defect Prediction Service Implementation
- * Uses ML-based heuristics to predict defect probability in code files
- */
-export class DefectPredictorService implements IDefectPredictorService {
-  private readonly config: DefectPredictorConfig;
-  private readonly gitAnalyzer: GitAnalyzer;
-  private readonly fileReader: FileReader;
-  private readonly tsParser: TypeScriptParser;
-  private modelMetrics: ModelMetrics = {
-    accuracy: 0.75,
-    precision: 0.72,
-    recall: 0.78,
-    f1Score: 0.75,
-    totalPredictions: 0,
-    lastUpdated: new Date(),
-  };
-
-  constructor(
-    private readonly memory: MemoryBackend,
-    config: Partial<DefectPredictorConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.gitAnalyzer = new GitAnalyzer({ enableCache: true });
-    this.fileReader = new FileReader();
-    this.tsParser = new TypeScriptParser();
-  }
-
-  /**
-   * Predict defect probability for given files
-   */
-  async predictDefects(request: PredictRequest): Promise<Result<PredictionResult, Error>> {
-    try {
-      const {
-        files,
-        features = DEFAULT_FEATURES,
-        threshold = this.config.defaultThreshold,
-      } = request;
-
-      if (files.length === 0) {
-        return err(new Error('No files provided for prediction'));
-      }
-
-      if (files.length > this.config.maxPredictionsPerBatch) {
-        return err(new Error(`Too many files. Maximum: ${this.config.maxPredictionsPerBatch}`));
-      }
-
-      const predictions: FilePrediction[] = [];
-      const factors: Set<string> = new Set();
-
-      for (const file of files) {
-        const prediction = await this.predictForFile(file, features, threshold);
-        predictions.push(prediction);
-        prediction.factors.forEach((f) => factors.add(f.name));
-      }
-
-      // Calculate model confidence based on historical accuracy
-      const modelConfidence = this.calculateModelConfidence(predictions);
-
-      // Store prediction for potential feedback
-      await this.storePrediction(predictions);
-
-      // Update metrics
-      this.modelMetrics.totalPredictions += predictions.length;
-      this.modelMetrics.lastUpdated = new Date();
-
-      return ok({
-        predictions,
-        modelConfidence,
-        factors: Array.from(factors),
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Analyze regression risk for a changeset
-   */
-  async analyzeRegressionRisk(
-    request: RegressionRequest
-  ): Promise<Result<RegressionRisk, Error>> {
-    try {
-      const { changeset, baseline, depth = 'shallow' } = request;
-
-      if (changeset.length === 0) {
-        return err(new Error('No files in changeset'));
-      }
-
-      // Analyze each changed file
-      const impactedAreas: ImpactedArea[] = [];
-      let totalRisk = 0;
-
-      for (const file of changeset) {
-        const fileAnalysis = await this.analyzeFileImpact(file, depth);
-        impactedAreas.push(...fileAnalysis.areas);
-        totalRisk += fileAnalysis.risk;
-      }
-
-      // Consider baseline if provided
-      if (baseline && this.config.enableHistoricalAnalysis) {
-        const baselineRisk = await this.getBaselineRisk(baseline);
-        totalRisk = (totalRisk + baselineRisk) / 2;
-      }
-
-      // Normalize overall risk
-      const overallRisk = Math.min(1, totalRisk / changeset.length);
-      const riskLevel = this.riskToSeverity(overallRisk);
-
-      // Generate test recommendations based on impacted areas
-      const recommendedTests = this.generateTestRecommendations(impactedAreas);
-
-      // Calculate confidence based on analysis depth
-      const confidence = depth === 'deep' ? 0.85 : 0.70;
-
-      return ok({
-        overallRisk,
-        riskLevel,
-        impactedAreas,
-        recommendedTests,
-        confidence,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Update the prediction model with feedback
-   */
-  async updateModel(feedback: PredictionFeedback): Promise<Result<void, Error>> {
-    try {
-      // Store feedback for model improvement
-      const feedbackKey = `${this.config.modelNamespace}:feedback:${feedback.predictionId}`;
-      await this.memory.set(feedbackKey, feedback, {
-        namespace: 'defect-intelligence',
-        persist: true,
-      });
-
-      // Update model metrics based on feedback
-      await this.recalculateMetrics(feedback);
-
-      return ok(undefined);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Get current model performance metrics
-   */
-  async getModelMetrics(): Promise<ModelMetrics> {
-    // Try to load persisted metrics
-    const storedMetrics = await this.memory.get<ModelMetrics>(
-      `${this.config.modelNamespace}:metrics`
-    );
-
-    if (storedMetrics) {
-      this.modelMetrics = {
-        ...storedMetrics,
-        lastUpdated: new Date(storedMetrics.lastUpdated),
-      };
-    }
-
-    return { ...this.modelMetrics };
-  }
-
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-
-  private async predictForFile(
-    file: string,
-    features: PredictionFeature[],
-    threshold: number
-  ): Promise<FilePrediction> {
-    // Extract file metrics
-    const fileMetrics = await this.extractFileMetrics(file);
-
-    // Calculate probability based on weighted features
-    const featureContributions: { name: string; contribution: number }[] = [];
-    let probability = 0;
-
-    for (const feature of features) {
-      const metricValue = fileMetrics[feature.name] ?? 0;
-      const contribution = metricValue * feature.weight;
-      probability += contribution;
-      featureContributions.push({
-        name: feature.name,
-        contribution: Math.round(contribution * 100) / 100,
-      });
-    }
-
-    // Normalize probability to 0-1 range
-    probability = Math.max(0, Math.min(1, probability));
-
-    // Determine risk level
-    const riskLevel = this.probabilityToRisk(probability, threshold);
-
-    // Generate recommendations based on high-contributing factors
-    const recommendations = this.generateRecommendations(featureContributions, probability);
-
-    return {
-      file,
-      probability,
-      riskLevel,
-      factors: featureContributions.filter((f) => f.contribution > 0.05),
-      recommendations,
-    };
-  }
-
-  private async extractFileMetrics(file: string): Promise<Record<string, number>> {
-    // Try to get cached metrics
-    const cachedMetrics = await this.memory.get<Record<string, number>>(
-      `${this.config.modelNamespace}:file-metrics:${file}`
-    );
-
-    if (cachedMetrics) {
-      return cachedMetrics;
-    }
-
-    // Calculate metrics using real code analysis and git history
-    const metrics: Record<string, number> = {
-      codeComplexity: await this.calculateComplexity(file),
-      changeFrequency: await this.getChangeFrequency(file),
-      developerExperience: await this.getDeveloperExperience(file),
-      testCoverage: await this.getTestCoverage(file),
-      codeAge: await this.getCodeAge(file),
-      bugHistory: await this.getBugHistory(file),
-    };
-
-    // Cache metrics
-    await this.memory.set(
-      `${this.config.modelNamespace}:file-metrics:${file}`,
-      metrics,
-      { namespace: 'defect-intelligence', ttl: 3600 } // 1 hour cache
-    );
-
-    return metrics;
-  }
-
-  /**
-   * Calculate code complexity using TypeScript AST analysis
-   * Falls back to path-based heuristics if file cannot be parsed
-   */
-  private async calculateComplexity(file: string): Promise<number> {
-    const extension = file.split('.').pop()?.toLowerCase();
-
-    // For TypeScript/JavaScript files, use AST analysis
-    if (extension && ['ts', 'tsx', 'js', 'jsx'].includes(extension)) {
-      const fileResult = await this.fileReader.readFile(file);
-
-      if (fileResult.success) {
-        try {
-          const fileName = file.split('/').pop() || file;
-          const ast = this.tsParser.parseFile(fileName, fileResult.value);
-
-          // Extract structural metrics
-          const functions = this.tsParser.extractFunctions(ast);
-          const classes = this.tsParser.extractClasses(ast);
-
-          // Calculate complexity factors
-          const lines = fileResult.value.split('\n').length;
-          const functionCount = functions.length;
-          const classCount = classes.length;
-          const methodCount = classes.reduce((sum, cls) => sum + cls.methods.length, 0);
-          const asyncCount = functions.filter((f) => f.isAsync).length;
-
-          // Count complexity indicators in code
-          const content = fileResult.value;
-          const ifCount = (content.match(/\bif\s*\(/g) || []).length;
-          const loopCount = (content.match(/\b(for|while|do)\s*[\(\{]/g) || []).length;
-          const switchCount = (content.match(/\bswitch\s*\(/g) || []).length;
-          const catchCount = (content.match(/\bcatch\s*\(/g) || []).length;
-          const ternaryCount = (content.match(/\?[^?:]+:/g) || []).length;
-
-          // Calculate cyclomatic complexity proxy
-          const cyclomaticProxy = ifCount + loopCount * 2 + switchCount * 2 + catchCount + ternaryCount;
-
-          // Normalize metrics to 0-1 scale
-          const lineComplexity = Math.min(1, lines / 500); // 500 lines = max
-          const functionComplexity = Math.min(1, (functionCount + methodCount) / 30); // 30 functions = max
-          const branchComplexity = Math.min(1, cyclomaticProxy / 50); // 50 branches = max
-          const asyncComplexity = asyncCount > 0 ? 0.1 : 0; // Async adds complexity
-
-          // Weighted average
-          const complexity =
-            lineComplexity * 0.2 +
-            functionComplexity * 0.25 +
-            branchComplexity * 0.4 +
-            asyncComplexity +
-            (classCount > 3 ? 0.05 : 0); // Many classes add complexity
-
-          return Math.max(0, Math.min(1, complexity));
-        } catch {
-          // Fall through to heuristics if parsing fails
-        }
-      }
-    }
-
-    // Fallback: Path-based heuristics for non-TS/JS files or parse failures
-    return this.estimateComplexityFromPath(file);
-  }
-
-  /**
-   * Estimate complexity based on file path heuristics (fallback)
-   */
-  private estimateComplexityFromPath(file: string): number {
-    const pathParts = file.split('/');
-    const filename = pathParts[pathParts.length - 1];
-
-    let complexity = 0.3;
-    if (file.includes('controller') || file.includes('service')) complexity += 0.2;
-    if (file.includes('coordinator') || file.includes('orchestrator')) complexity += 0.15;
-    if (file.includes('utils') || file.includes('helper')) complexity -= 0.1;
-    if (file.includes('types') || file.includes('interfaces')) complexity -= 0.15;
-    if (filename.length > 30) complexity += 0.1;
-
-    return Math.max(0, Math.min(1, complexity));
-  }
-
-  /**
-   * Get change frequency for a file using git history
-   * Falls back to memory cache if git is not available
-   */
-  private async getChangeFrequency(file: string): Promise<number> {
-    // Try git analysis first
-    const gitFrequency = await this.gitAnalyzer.getChangeFrequency(file);
-    if (gitFrequency !== 0.4) {
-      // Cache the result
-      await this.memory.set(
-        `${this.config.modelNamespace}:history:${file}`,
-        { changes: Math.round(gitFrequency * 30) },
-        { ttl: 3600 }
-      );
-      return gitFrequency;
-    }
-
-    // Fallback to cached value
-    const historyKey = `${this.config.modelNamespace}:history:${file}`;
-    const history = await this.memory.get<{ changes: number }>(historyKey);
-    if (history) {
-      return Math.min(1, history.changes / 50);
-    }
-
-    return 0.4;
-  }
-
-  /**
-   * Get developer experience score for a file using git blame
-   * Falls back to memory cache if git is not available
-   */
-  private async getDeveloperExperience(file: string): Promise<number> {
-    // Try git analysis first
-    const gitExp = await this.gitAnalyzer.getDeveloperExperience(file);
-    if (gitExp !== 0.5) {
-      // Cache the result
-      await this.memory.set(
-        `${this.config.modelNamespace}:developer-exp:${file}`,
-        { score: gitExp },
-        { ttl: 3600 }
-      );
-      return gitExp;
-    }
-
-    // Fallback to cached value
-    const expKey = `${this.config.modelNamespace}:developer-exp:${file}`;
-    const exp = await this.memory.get<{ score: number }>(expKey);
-    if (exp) {
-      return exp.score;
-    }
-
-    return 0.5;
-  }
-
-  /**
-   * Get test coverage for a file from coverage reports
-   */
-  private async getTestCoverage(file: string): Promise<number> {
-    const coverageKey = `coverage-analysis:file:${file}`;
-    const coverage = await this.memory.get<{ percentage: number }>(coverageKey);
-
-    if (coverage) {
-      // Invert: low coverage = high defect risk
-      return 1 - coverage.percentage / 100;
-    }
-
-    // Default to medium coverage (inverted)
-    return 0.4;
-  }
-
-  /**
-   * Get code age for a file using git history
-   * Falls back to memory cache if git is not available
-   */
-  private async getCodeAge(file: string): Promise<number> {
-    // Try git analysis first
-    const gitAge = await this.gitAnalyzer.getCodeAge(file);
-    if (gitAge !== 0.4) {
-      return gitAge;
-    }
-
-    // Fallback to cached value
-    const ageKey = `${this.config.modelNamespace}:age:${file}`;
-    const age = await this.memory.get<{ days: number }>(ageKey);
-
-    if (age) {
-      if (age.days < 7) return 0.7; // New code
-      if (age.days > 365) return 0.3; // Stable code
-      return 0.4;
-    }
-
-    return 0.4;
-  }
-
-  /**
-   * Get bug history for a file using git commit messages
-   * Falls back to memory cache if git is not available
-   */
-  private async getBugHistory(file: string): Promise<number> {
-    // Try git analysis first
-    const gitBugs = await this.gitAnalyzer.getBugHistory(file);
-    if (gitBugs !== 0.2) {
-      // Cache the result
-      await this.memory.set(
-        `${this.config.modelNamespace}:bugs:${file}`,
-        { count: Math.round(gitBugs * 10) },
-        { ttl: 3600 }
-      );
-      return gitBugs;
-    }
-
-    // Fallback to cached value
-    const bugKey = `${this.config.modelNamespace}:bugs:${file}`;
-    const bugs = await this.memory.get<{ count: number }>(bugKey);
-
-    if (bugs) {
-      return Math.min(1, bugs.count / 10);
-    }
-
-    return 0.2;
-  }
-
-  private probabilityToRisk(probability: number, threshold: number): Severity {
-    if (probability >= threshold + 0.3) return 'critical';
-    if (probability >= threshold + 0.15) return 'high';
-    if (probability >= threshold) return 'medium';
-    if (probability >= threshold - 0.2) return 'low';
-    return 'info';
-  }
-
-  private riskToSeverity(risk: number): Severity {
-    if (risk >= 0.8) return 'critical';
-    if (risk >= 0.6) return 'high';
-    if (risk >= 0.4) return 'medium';
-    if (risk >= 0.2) return 'low';
-    return 'info';
-  }
-
-  private generateRecommendations(
-    factors: { name: string; contribution: number }[],
-    probability: number
-  ): string[] {
-    const recommendations: string[] = [];
-
-    // Sort factors by contribution
-    const sortedFactors = [...factors].sort((a, b) => b.contribution - a.contribution);
-
-    for (const factor of sortedFactors.slice(0, 3)) {
-      switch (factor.name) {
-        case 'codeComplexity':
-          if (factor.contribution > 0.1) {
-            recommendations.push('Consider refactoring to reduce cyclomatic complexity');
-            recommendations.push('Break down large functions into smaller, testable units');
-          }
-          break;
-        case 'changeFrequency':
-          if (factor.contribution > 0.1) {
-            recommendations.push('High churn area - add comprehensive regression tests');
-            recommendations.push('Consider stabilizing the interface before further changes');
-          }
-          break;
-        case 'testCoverage':
-          if (factor.contribution > 0.1) {
-            recommendations.push('Increase test coverage to reduce defect risk');
-            recommendations.push('Add unit tests for critical paths');
-          }
-          break;
-        case 'bugHistory':
-          if (factor.contribution > 0.1) {
-            recommendations.push('Review past bug fixes for patterns');
-            recommendations.push('Add regression tests for previously fixed issues');
-          }
-          break;
-        case 'codeAge':
-          if (factor.contribution > 0.1) {
-            recommendations.push('New code requires thorough review and testing');
-          }
-          break;
-        case 'developerExperience':
-          if (factor.contribution > 0.1) {
-            recommendations.push('Request code review from senior developer');
-          }
-          break;
-      }
-    }
-
-    if (probability > 0.7) {
-      recommendations.push('CRITICAL: Schedule immediate code review');
-    }
-
-    return recommendations;
-  }
-
-  private async analyzeFileImpact(
-    file: string,
-    depth: 'shallow' | 'deep'
-  ): Promise<{ areas: ImpactedArea[]; risk: number }> {
-    const areas: ImpactedArea[] = [];
-    let risk = 0;
-
-    // Determine impacted areas based on file path
-    const area = this.categorizeFile(file);
-    const fileRisk = (await this.extractFileMetrics(file)).codeComplexity;
-
-    areas.push({
-      area,
-      files: [file],
-      risk: fileRisk,
-      reason: `Modified file in ${area} area`,
-    });
-
-    risk += fileRisk;
-
-    // Deep analysis includes dependency analysis
-    if (depth === 'deep') {
-      const dependencies = await this.analyzeDependencies(file);
-      for (const dep of dependencies) {
-        const depRisk = (await this.extractFileMetrics(dep)).codeComplexity * 0.5;
-        areas.push({
-          area: this.categorizeFile(dep),
-          files: [dep],
-          risk: depRisk,
-          reason: `Dependency of ${file}`,
-        });
-        risk += depRisk;
-      }
-    }
-
-    return { areas, risk };
-  }
-
-  private categorizeFile(file: string): string {
-    if (file.includes('controller')) return 'API Layer';
-    if (file.includes('service')) return 'Business Logic';
-    if (file.includes('repository') || file.includes('dao')) return 'Data Access';
-    if (file.includes('model') || file.includes('entity')) return 'Domain Model';
-    if (file.includes('util') || file.includes('helper')) return 'Utilities';
-    if (file.includes('test')) return 'Tests';
-    if (file.includes('config')) return 'Configuration';
-    return 'General';
-  }
-
-  private async analyzeDependencies(file: string): Promise<string[]> {
-    // Check cache first
-    const depsKey = `code-intelligence:dependencies:${file}`;
-    const cachedDeps = await this.memory.get<string[]>(depsKey);
-    if (cachedDeps && cachedDeps.length > 0) {
-      return cachedDeps;
-    }
-
-    // Parse the file to extract imports
-    const dependencies: string[] = [];
-    try {
-      const fileResult = await this.fileReader.readFile(file);
-      if (!fileResult.success) {
-        return [];
-      }
-
-      const fileName = file.split('/').pop() || file;
-      const ast = this.tsParser.parseFile(fileName, fileResult.value);
-      const imports = this.tsParser.extractImports(ast);
-
-      for (const importInfo of imports) {
-        // Resolve relative imports to actual file paths
-        if (importInfo.module.startsWith('.')) {
-          const resolvedPath = this.resolveRelativeImport(file, importInfo.module);
-          dependencies.push(resolvedPath);
-        } else if (!importInfo.module.startsWith('node:')) {
-          // External package dependencies
-          dependencies.push(importInfo.module);
-        }
-      }
-
-      // Cache the dependencies for future lookups
-      if (dependencies.length > 0) {
-        await this.memory.set(depsKey, dependencies, {
-          namespace: 'code-intelligence',
-          ttl: 3600, // Cache for 1 hour
-        });
-      }
-    } catch (error) {
-      // Log but don't fail - return empty array
-      console.error(`Failed to analyze dependencies for ${file}:`, error);
-    }
-
-    return dependencies;
-  }
-
-  /**
-   * Resolve a relative import path to an absolute file path
-   */
-  private resolveRelativeImport(fromFile: string, importPath: string): string {
-    const fromDir = fromFile.substring(0, fromFile.lastIndexOf('/'));
-    const segments = fromDir.split('/');
-
-    // Process the relative path
-    const importSegments = importPath.split('/');
-    for (const segment of importSegments) {
-      if (segment === '.') {
-        continue;
-      } else if (segment === '..') {
-        segments.pop();
-      } else {
-        segments.push(segment);
-      }
-    }
-
-    let resolved = segments.join('/');
-
-    // Add file extension if not present
-    if (!resolved.endsWith('.ts') && !resolved.endsWith('.tsx') && !resolved.endsWith('.js')) {
-      // Check common extensions - prefer .ts
-      resolved = resolved + '.ts';
-    }
-
-    return resolved;
-  }
-
-  private async getBaselineRisk(baseline: string): Promise<number> {
-    const baselineKey = `${this.config.modelNamespace}:baseline:${baseline}`;
-    const baselineData = await this.memory.get<{ risk: number }>(baselineKey);
-    return baselineData?.risk ?? 0.3;
-  }
-
-  private generateTestRecommendations(areas: ImpactedArea[]): string[] {
-    const recommendations: string[] = [];
-    const areaNames = new Set(areas.map((a) => a.area));
-
-    for (const area of areaNames) {
-      switch (area) {
-        case 'API Layer':
-          recommendations.push('Run API integration tests');
-          recommendations.push('Verify endpoint response contracts');
-          break;
-        case 'Business Logic':
-          recommendations.push('Run unit tests for business rules');
-          recommendations.push('Execute scenario-based tests');
-          break;
-        case 'Data Access':
-          recommendations.push('Run database integration tests');
-          recommendations.push('Verify data integrity constraints');
-          break;
-        case 'Domain Model':
-          recommendations.push('Run entity validation tests');
-          recommendations.push('Check serialization/deserialization');
-          break;
-      }
-    }
-
-    // Add general recommendations based on risk
-    const highRiskAreas = areas.filter((a) => a.risk > 0.6);
-    if (highRiskAreas.length > 0) {
-      recommendations.push('Run full regression test suite');
-      recommendations.push('Consider exploratory testing for edge cases');
-    }
-
-    return [...new Set(recommendations)];
-  }
-
-  private calculateModelConfidence(predictions: FilePrediction[]): number {
-    // Base confidence from model metrics
-    let confidence = this.modelMetrics.accuracy;
-
-    // Adjust based on prediction spread
-    const probabilities = predictions.map((p) => p.probability);
-    const variance = this.calculateVariance(probabilities);
-
-    // High variance indicates uncertain predictions
-    if (variance > 0.2) confidence *= 0.9;
-
-    // More predictions generally mean better confidence
-    if (predictions.length > 10) confidence *= 1.05;
-
-    return Math.min(1, Math.max(0, confidence));
-  }
-
-  private calculateVariance(values: number[]): number {
-    if (values.length === 0) return 0;
-    const mean = values.reduce((a, b) => a + b, 0) / values.length;
-    const squareDiffs = values.map((v) => Math.pow(v - mean, 2));
-    return squareDiffs.reduce((a, b) => a + b, 0) / values.length;
-  }
-
-  private async storePrediction(predictions: FilePrediction[]): Promise<void> {
-    const predictionId = uuidv4();
-    await this.memory.set(
-      `${this.config.modelNamespace}:prediction:${predictionId}`,
-      {
-        id: predictionId,
-        predictions,
-        timestamp: new Date().toISOString(),
-      },
-      { namespace: 'defect-intelligence', ttl: 86400 * 7 } // 7 days
-    );
-  }
-
-  private async recalculateMetrics(feedback: PredictionFeedback): Promise<void> {
-    // Simple online update of accuracy
-    const predicted = feedback.predictedProbability >= this.config.defaultThreshold;
-    const correct = predicted === feedback.actualDefect;
-
-    // Moving average update
-    const alpha = 0.01; // Learning rate
-    this.modelMetrics.accuracy =
-      this.modelMetrics.accuracy * (1 - alpha) + (correct ? 1 : 0) * alpha;
-
-    // Update precision/recall
-    if (predicted && feedback.actualDefect) {
-      // True positive
-      this.modelMetrics.precision =
-        this.modelMetrics.precision * (1 - alpha) + 1 * alpha;
-      this.modelMetrics.recall =
-        this.modelMetrics.recall * (1 - alpha) + 1 * alpha;
-    } else if (predicted && !feedback.actualDefect) {
-      // False positive
-      this.modelMetrics.precision =
-        this.modelMetrics.precision * (1 - alpha) + 0 * alpha;
-    } else if (!predicted && feedback.actualDefect) {
-      // False negative
-      this.modelMetrics.recall =
-        this.modelMetrics.recall * (1 - alpha) + 0 * alpha;
-    }
-
-    // Calculate F1
-    this.modelMetrics.f1Score =
-      (2 * this.modelMetrics.precision * this.modelMetrics.recall) /
-      (this.modelMetrics.precision + this.modelMetrics.recall || 1);
-
-    this.modelMetrics.lastUpdated = new Date();
-
-    // Persist metrics
-    await this.memory.set(
-      `${this.config.modelNamespace}:metrics`,
-      this.modelMetrics,
-      { namespace: 'defect-intelligence', persist: true }
-    );
-  }
-}