vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/validation/metrics-calculator.js

@@ -0,0 +1,660 @@
+/**
+ * Compliance Metrics Calculator
+ * 
+ * Calculates and analyzes various compliance metrics for the codebase,
+ * providing insights into file size compliance, code quality, and trends.
+ */
+
+const { COMPLIANCE_STATUS, COMPLIANCE_CATEGORIES } = require('../models/compliance-report');
+
+/**
+ * Metrics calculator class
+ */
+class MetricsCalculator {
+  constructor(options = {}) {
+    this.options = {
+      maxFileSize: options.maxFileSize || 555,
+      warningThreshold: options.warningThreshold || 500,
+      criticalThreshold: options.criticalThreshold || 800,
+      ...options
+    };
+  }
+
+  /**
+   * Calculate comprehensive compliance metrics
+   */
+  calculateMetrics(complianceReport) {
+    const metrics = {
+      overview: this.calculateOverviewMetrics(complianceReport),
+      fileMetrics: this.calculateFileMetrics(complianceReport),
+      sizeMetrics: this.calculateSizeMetrics(complianceReport),
+      categoryMetrics: this.calculateCategoryMetrics(complianceReport),
+      severityMetrics: this.calculateSeverityMetrics(complianceReport),
+      trendMetrics: this.calculateTrendMetrics(complianceReport),
+      performanceMetrics: this.calculatePerformanceMetrics(complianceReport),
+      qualityMetrics: this.calculateQualityMetrics(complianceReport)
+    };
+
+    return {
+      ...metrics,
+      summary: this.calculateMetricsSummary(metrics),
+      recommendations: this.generateMetricsRecommendations(metrics),
+      calculatedAt: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Calculate overview metrics
+   */
+  calculateOverviewMetrics(report) {
+    const totalFiles = report.summary.totalFiles;
+    const compliantFiles = report.summary.compliantFiles;
+    const totalIssues = report.summary.totalIssues;
+
+    return {
+      totalFiles,
+      compliantFiles,
+      nonCompliantFiles: totalFiles - compliantFiles,
+      totalIssues,
+      overallComplianceScore: report.summary.overallComplianceScore,
+      complianceRate: totalFiles > 0 ? (compliantFiles / totalFiles * 100) : 100,
+      averageIssuesPerFile: totalFiles > 0 ? (totalIssues / totalFiles) : 0,
+      healthStatus: this.getHealthStatus(report.summary.overallComplianceScore)
+    };
+  }
+
+  /**
+   * Calculate file-specific metrics
+   */
+  calculateFileMetrics(report) {
+    const fileSummaries = report.fileSummaries;
+    
+    // Sort files by various criteria
+    const filesBySize = [...fileSummaries].sort((a, b) => b.lineCount - a.lineCount);
+    const filesByCompliance = [...fileSummaries].sort((a, b) => a.complianceScore - b.complianceScore);
+    const filesByIssues = [...fileSummaries].sort((a, b) => b.totalIssues - a.totalIssues);
+
+    return {
+      largestFiles: filesBySize.slice(0, 10).map(f => ({
+        filePath: f.filePath,
+        lineCount: f.lineCount,
+        status: f.status,
+        complianceScore: f.complianceScore
+      })),
+      smallestFiles: filesBySize.slice(-10).reverse().map(f => ({
+        filePath: f.filePath,
+        lineCount: f.lineCount,
+        status: f.status,
+        complianceScore: f.complianceScore
+      })),
+      leastCompliantFiles: filesByCompliance.slice(0, 10).map(f => ({
+        filePath: f.filePath,
+        complianceScore: f.complianceScore,
+        status: f.status,
+        totalIssues: f.totalIssues
+      })),
+      mostProblematicFiles: filesByIssues.slice(0, 10).map(f => ({
+        filePath: f.filePath,
+        totalIssues: f.totalIssues,
+        status: f.status,
+        complianceScore: f.complianceScore
+      })),
+      averageFileSize: fileSummaries.length > 0 ? 
+        fileSummaries.reduce((sum, f) => sum + f.lineCount, 0) / fileSummaries.length : 0,
+      medianFileSize: this.calculateMedian(fileSummaries.map(f => f.lineCount)),
+      fileSizeDistribution: this.calculateSizeDistribution(fileSummaries)
+    };
+  }
+
+  /**
+   * Calculate size-specific metrics
+   */
+  calculateSizeMetrics(report) {
+    const fileSummaries = report.fileSummaries;
+    const maxLimit = this.options.maxFileSize;
+    const warningThreshold = this.options.warningThreshold;
+    const criticalThreshold = this.options.criticalThreshold;
+
+    const sizeCategories = {
+      small: fileSummaries.filter(f => f.lineCount <= warningThreshold * 0.5).length,
+      medium: fileSummaries.filter(f => f.lineCount > warningThreshold * 0.5 && f.lineCount <= warningThreshold).length,
+      large: fileSummaries.filter(f => f.lineCount > warningThreshold && f.lineCount <= maxLimit).length,
+      oversized: fileSummaries.filter(f => f.lineCount > maxLimit && f.lineCount <= criticalThreshold).length,
+      critical: fileSummaries.filter(f => f.lineCount > criticalThreshold).length
+    };
+
+    const totalLines = fileSummaries.reduce((sum, f) => sum + f.lineCount, 0);
+    const excessLines = fileSummaries
+      .filter(f => f.lineCount > maxLimit)
+      .reduce((sum, f) => sum + (f.lineCount - maxLimit), 0);
+
+    return {
+      sizeCategories,
+      totalLines,
+      excessLines,
+      averageExcessPerOversizedFile: sizeCategories.oversized > 0 ? 
+        excessLines / (sizeCategories.oversized + sizeCategories.critical) : 0,
+      sizeComplianceRate: ((sizeCategories.small + sizeCategories.medium + sizeCategories.large) / fileSummaries.length * 100),
+      criticalSizeFiles: sizeCategories.critical,
+      oversizedFiles: sizeCategories.oversized,
+      sizeRiskScore: this.calculateSizeRiskScore(sizeCategories, fileSummaries.length)
+    };
+  }
+
+  /**
+   * Calculate category-specific metrics
+   */
+  calculateCategoryMetrics(report) {
+    const categories = {};
+    const totalIssues = report.summary.totalIssues;
+
+    // Calculate metrics for each category
+    for (const [category, issueCount] of Object.entries(report.issuesByCategory)) {
+      if (issueCount > 0) {
+        const categoryFiles = report.fileSummaries.filter(f => 
+          f.issues.some(issue => issue.category === category)
+        );
+
+        categories[category] = {
+          issueCount,
+          percentage: totalIssues > 0 ? (issueCount / totalIssues * 100) : 0,
+          affectedFiles: categoryFiles.length,
+          averageIssuesPerAffectedFile: categoryFiles.length > 0 ? 
+            (issueCount / categoryFiles.length) : 0,
+          severity: this.getCategorySeverity(category, issueCount, report.summary.totalFiles)
+        };
+      }
+    }
+
+    return {
+      categories,
+      mostProblematicCategory: this.getMostProblematicCategory(categories),
+      categoryDistribution: this.calculateCategoryDistribution(categories)
+    };
+  }
+
+  /**
+   * Calculate severity-specific metrics
+   */
+  calculateSeverityMetrics(report) {
+    const summary = report.summary;
+    const totalIssues = report.summary.totalIssues;
+
+    const severities = {
+      critical: {
+        count: summary.criticalFiles,
+        issues: report.fileSummaries.reduce((sum, f) => sum + f.criticalIssues, 0),
+        percentage: totalIssues > 0 ? (summary.criticalFiles / summary.totalFiles * 100) : 0
+      },
+      error: {
+        count: summary.violationFiles,
+        issues: report.fileSummaries.reduce((sum, f) => sum + f.violationIssues, 0),
+        percentage: totalIssues > 0 ? (summary.violationFiles / summary.totalFiles * 100) : 0
+      },
+      warning: {
+        count: summary.warningFiles,
+        issues: report.fileSummaries.reduce((sum, f) => sum + f.warningIssues, 0),
+        percentage: totalIssues > 0 ? (summary.warningFiles / summary.totalFiles * 100) : 0
+      },
+      info: {
+        count: summary.compliantFiles,
+        issues: report.fileSummaries.reduce((sum, f) => sum + f.compliantIssues, 0),
+        percentage: totalIssues > 0 ? (summary.compliantFiles / summary.totalFiles * 100) : 0
+      }
+    };
+
+    return {
+      severities,
+      severityRiskScore: this.calculateSeverityRiskScore(severities),
+      escalationRisk: this.calculateEscalationRisk(severities)
+    };
+  }
+
+  /**
+   * Calculate trend metrics (if historical data available)
+   */
+  calculateTrendMetrics(report) {
+    // This would typically compare with previous reports
+    // For now, return placeholder metrics
+    return {
+      trendDirection: 'stable', // 'improving', 'degrading', 'stable'
+      complianceScoreChange: 0,
+      issueCountChange: 0,
+      fileCountChange: 0,
+      trendPeriod: 'unknown',
+      trendData: []
+    };
+  }
+
+  /**
+   * Calculate performance metrics
+   */
+  calculatePerformanceMetrics(report) {
+    const fileSummaries = report.fileSummaries;
+    
+    return {
+      averageAnalysisTime: 0, // Would be populated by actual timing data
+      totalAnalysisTime: 0,
+      filesPerSecond: 0,
+      memoryUsage: {
+        estimated: this.estimateMemoryUsage(fileSummaries),
+        peak: 0
+      },
+      efficiency: {
+        issuesDetectedPerMinute: 0,
+        filesProcessedPerMinute: 0
+      }
+    };
+  }
+
+  /**
+   * Calculate quality metrics
+   */
+  calculateQualityMetrics(report) {
+    const fileSummaries = report.fileSummaries;
+    
+    return {
+      codeQualityScore: this.calculateCodeQualityScore(fileSummaries),
+      maintainabilityIndex: this.calculateMaintainabilityIndex(fileSummaries),
+      technicalDebt: this.calculateTechnicalDebt(fileSummaries),
+      complexityMetrics: this.calculateComplexityMetrics(fileSummaries),
+      documentationCoverage: this.calculateDocumentationCoverage(fileSummaries)
+    };
+  }
+
+  /**
+   * Calculate overall metrics summary
+   */
+  calculateMetricsSummary(metrics) {
+    return {
+      overallScore: this.calculateOverallScore(metrics),
+      riskLevel: this.assessRiskLevel(metrics),
+      healthGrade: this.assignHealthGrade(metrics),
+      keyInsights: this.extractKeyInsights(metrics),
+      priorityActions: this.identifyPriorityActions(metrics)
+    };
+  }
+
+  /**
+   * Generate metrics-based recommendations
+   */
+  generateMetricsRecommendations(metrics) {
+    const recommendations = [];
+
+    // Size-related recommendations
+    if (metrics.sizeMetrics.criticalSizeFiles > 0) {
+      recommendations.push({
+        type: 'critical',
+        category: 'file_size',
+        title: 'Address Critical File Size Violations',
+        description: `${metrics.sizeMetrics.criticalSizeFiles} files exceed critical size threshold.`,
+        impact: 'high',
+        effort: 'high',
+        priority: 1
+      });
+    }
+
+    // Compliance-related recommendations
+    if (metrics.overview.complianceRate < 80) {
+      recommendations.push({
+        type: 'high',
+        category: 'compliance',
+        title: 'Improve Overall Compliance',
+        description: `Compliance rate is ${metrics.overview.complianceRate.toFixed(1)}%. Target is >90%.`,
+        impact: 'high',
+        effort: 'medium',
+        priority: 2
+      });
+    }
+
+    // Category-specific recommendations
+    const mostProblematic = metrics.categoryMetrics.mostProblematicCategory;
+    if (mostProblematic && mostProblematic.issueCount > 0) {
+      recommendations.push({
+        type: 'medium',
+        category: mostProblematic.category,
+        title: `Address ${mostProblematic.category} Issues`,
+        description: `${mostProblematic.issueCount} issues in ${mostProblematic.category} category.`,
+        impact: 'medium',
+        effort: 'medium',
+        priority: 3
+      });
+    }
+
+    return recommendations.sort((a, b) => a.priority - b.priority);
+  }
+
+  /**
+   * Helper methods
+   */
+  getHealthStatus(complianceScore) {
+    if (complianceScore >= 95) return 'excellent';
+    if (complianceScore >= 85) return 'good';
+    if (complianceScore >= 70) return 'fair';
+    if (complianceScore >= 50) return 'poor';
+    return 'critical';
+  }
+
+  calculateMedian(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? 
+      (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  }
+
+  calculateSizeDistribution(fileSummaries) {
+    const sizes = fileSummaries.map(f => f.lineCount);
+    const max = Math.max(...sizes);
+    const min = Math.min(...sizes);
+    const ranges = 10;
+    const rangeSize = Math.ceil((max - min) / ranges);
+    
+    const distribution = [];
+    for (let i = 0; i < ranges; i++) {
+      const lower = min + (i * rangeSize);
+      const upper = lower + rangeSize;
+      const count = sizes.filter(s => s >= lower && s < upper).length;
+      
+      distribution.push({
+        range: `${lower}-${upper}`,
+        count,
+        percentage: (count / fileSummaries.length * 100).toFixed(1)
+      });
+    }
+    
+    return distribution;
+  }
+
+  calculateSizeRiskScore(sizeCategories, totalFiles) {
+    const weights = {
+      small: 0,
+      medium: 0,
+      large: 1,
+      oversized: 5,
+      critical: 10
+    };
+    
+    let riskScore = 0;
+    for (const [category, count] of Object.entries(sizeCategories)) {
+      riskScore += weights[category] * count;
+    }
+    
+    return totalFiles > 0 ? (riskScore / totalFiles) : 0;
+  }
+
+  getCategorySeverity(category, issueCount, totalFiles) {
+    const severityRatio = issueCount / totalFiles;
+    if (severityRatio > 0.1) return 'high';
+    if (severityRatio > 0.05) return 'medium';
+    return 'low';
+  }
+
+  getMostProblematicCategory(categories) {
+    return Object.entries(categories)
+      .sort(([,a], [,b]) => b.issueCount - a.issueCount)[0]?.[1];
+  }
+
+  calculateCategoryDistribution(categories) {
+    const total = Object.values(categories).reduce((sum, cat) => sum + cat.issueCount, 0);
+    const distribution = {};
+    
+    for (const [name, category] of Object.entries(categories)) {
+      distribution[name] = {
+        count: category.issueCount,
+        percentage: total > 0 ? (category.issueCount / total * 100) : 0
+      };
+    }
+    
+    return distribution;
+  }
+
+  calculateSeverityRiskScore(severities) {
+    const weights = {
+      critical: 10,
+      error: 5,
+      warning: 2,
+      info: 0
+    };
+    
+    let riskScore = 0;
+    for (const [severity, data] of Object.entries(severities)) {
+      riskScore += weights[severity] * data.count;
+    }
+    
+    return riskScore;
+  }
+
+  calculateEscalationRisk(severities) {
+    // Risk of warnings escalating to errors, errors to critical
+    const warningToErrorRatio = severities.warning.count > 0 ? 
+      severities.error.count / severities.warning.count : 0;
+    const errorToCriticalRatio = severities.error.count > 0 ? 
+      severities.critical.count / severities.error.count : 0;
+    
+    return {
+      warningEscalationRisk: Math.min(warningToErrorRatio * 100, 100),
+      errorEscalationRisk: Math.min(errorToCriticalRatio * 100, 100),
+      overallEscalationRisk: (warningToErrorRatio + errorToCriticalRatio) / 2 * 100
+    };
+  }
+
+  estimateMemoryUsage(fileSummaries) {
+    // Rough estimation based on file sizes and issue counts
+    const baseMemory = 50 * 1024 * 1024; // 50MB base
+    const perFileMemory = 1024; // 1KB per file
+    const perIssueMemory = 512; // 512 bytes per issue
+    
+    const totalIssues = fileSummaries.reduce((sum, f) => sum + f.totalIssues, 0);
+    
+    return baseMemory + (fileSummaries.length * perFileMemory) + (totalIssues * perIssueMemory);
+  }
+
+  calculateCodeQualityScore(fileSummaries) {
+    const totalFiles = fileSummaries.length;
+    const compliantFiles = fileSummaries.filter(f => f.status === COMPLIANCE_STATUS.COMPLIANT).length;
+    const totalIssues = fileSummaries.reduce((sum, f) => sum + f.totalIssues, 0);
+    
+    // Base score from compliance
+    let score = (compliantFiles / totalFiles) * 100;
+    
+    // Penalize for high issue density
+    const avgIssuesPerFile = totalIssues / totalFiles;
+    score -= Math.min(avgIssuesPerFile * 5, 30);
+    
+    return Math.max(0, Math.min(100, score));
+  }
+
+  calculateMaintainabilityIndex(fileSummaries) {
+    // Simplified maintainability index based on file sizes and issues
+    let totalIndex = 0;
+    
+    for (const file of fileSummaries) {
+      let fileIndex = 100;
+      
+      // Reduce based on file size
+      if (file.lineCount > 555) {
+        fileIndex -= ((file.lineCount - 555) / 555) * 30;
+      }
+      
+      // Reduce based on issues
+      fileIndex -= file.totalIssues * 2;
+      
+      totalIndex += Math.max(0, fileIndex);
+    }
+    
+    return fileSummaries.length > 0 ? totalIndex / fileSummaries.length : 100;
+  }
+
+  calculateTechnicalDebt(fileSummaries) {
+    // Estimate technical debt in hours based on violations
+    let totalDebt = 0;
+    
+    for (const file of fileSummaries) {
+      // Base debt per file
+      let fileDebt = 0;
+      
+      // Size-related debt
+      if (file.lineCount > 555) {
+        fileDebt += (file.lineCount - 555) * 0.1; // 6 minutes per excess line
+      }
+      
+      // Issue-related debt
+      fileDebt += file.criticalIssues * 4; // 4 hours per critical issue
+      fileDebt += file.violationIssues * 2; // 2 hours per violation
+      fileDebt += file.warningIssues * 0.5; // 30 minutes per warning
+      
+      totalDebt += fileDebt;
+    }
+    
+    return {
+      totalHours: totalDebt,
+      totalDays: totalDebt / 8,
+      estimatedCost: totalDebt * 100, // $100/hour assumption
+      priorityFiles: fileSummaries
+        .filter(f => f.lineCount > 555 || f.totalIssues > 5)
+        .map(f => ({
+          filePath: f.filePath,
+          estimatedHours: (f.lineCount > 555 ? (f.lineCount - 555) * 0.1 : 0) + 
+                          (f.criticalIssues * 4) + 
+                          (f.violationIssues * 2) + 
+                          (f.warningIssues * 0.5)
+        }))
+        .sort((a, b) => b.estimatedHours - a.estimatedHours)
+        .slice(0, 10)
+    };
+  }
+
+  calculateComplexityMetrics(fileSummaries) {
+    return {
+      averageComplexity: fileSummaries.length > 0 ? 
+        fileSummaries.reduce((sum, f) => sum + (f.lineCount / 100), 0) / fileSummaries.length : 0,
+      highComplexityFiles: fileSummaries.filter(f => f.lineCount > 500).length,
+      complexityDistribution: this.calculateComplexityDistribution(fileSummaries)
+    };
+  }
+
+  calculateComplexityDistribution(fileSummaries) {
+    const complexity = fileSummaries.map(f => f.lineCount / 100);
+    const distribution = {
+      low: complexity.filter(c => c < 2).length,
+      medium: complexity.filter(c => c >= 2 && c < 5).length,
+      high: complexity.filter(c => c >= 5 && c < 10).length,
+      veryHigh: complexity.filter(c => c >= 10).length
+    };
+    
+    return distribution;
+  }
+
+  calculateDocumentationCoverage(fileSummaries) {
+    const totalFiles = fileSummaries.length;
+    const documentedFiles = fileSummaries.filter(f => 
+      f.issues.some(issue => issue.category === COMPLIANCE_CATEGORIES.DOCUMENTATION)
+    ).length;
+    
+    return {
+      coveragePercentage: totalFiles > 0 ? (documentedFiles / totalFiles * 100) : 100,
+      documentedFiles,
+      undocumentedFiles: totalFiles - documentedFiles
+    };
+  }
+
+  calculateOverallScore(metrics) {
+    const weights = {
+      compliance: 0.3,
+      size: 0.25,
+      severity: 0.2,
+      quality: 0.15,
+      category: 0.1
+    };
+    
+    const scores = {
+      compliance: metrics.overview.complianceRate,
+      size: Math.max(0, 100 - metrics.sizeMetrics.sizeRiskScore * 10),
+      severity: Math.max(0, 100 - metrics.severityMetrics.severityRiskScore),
+      quality: metrics.qualityMetrics.codeQualityScore,
+      category: 100 - (metrics.categoryMetrics.mostProblematicCategory?.issueCount || 0) * 5
+    };
+    
+    let overallScore = 0;
+    for (const [metric, weight] of Object.entries(weights)) {
+      overallScore += scores[metric] * weight;
+    }
+    
+    return Math.max(0, Math.min(100, overallScore));
+  }
+
+  assessRiskLevel(metrics) {
+    const overallScore = this.calculateOverallScore(metrics);
+    if (overallScore >= 90) return 'low';
+    if (overallScore >= 70) return 'medium';
+    if (overallScore >= 50) return 'high';
+    return 'critical';
+  }
+
+  assignHealthGrade(metrics) {
+    const overallScore = this.calculateOverallScore(metrics);
+    if (overallScore >= 95) return 'A+';
+    if (overallScore >= 90) return 'A';
+    if (overallScore >= 85) return 'B+';
+    if (overallScore >= 80) return 'B';
+    if (overallScore >= 75) return 'C+';
+    if (overallScore >= 70) return 'C';
+    if (overallScore >= 60) return 'D';
+    return 'F';
+  }
+
+  extractKeyInsights(metrics) {
+    const insights = [];
+    
+    if (metrics.overview.complianceRate < 80) {
+      insights.push('Compliance rate below target - requires immediate attention');
+    }
+    
+    if (metrics.sizeMetrics.criticalSizeFiles > 0) {
+      insights.push(`${metrics.sizeMetrics.criticalSizeFiles} files require immediate refactoring`);
+    }
+    
+    if (metrics.severityMetrics.severities.critical.count > 0) {
+      insights.push('Critical violations detected - address immediately');
+    }
+    
+    const mostProblematic = metrics.categoryMetrics.mostProblematicCategory;
+    if (mostProblematic && mostProblematic.issueCount > 5) {
+      insights.push(`${mostProblematic.category} category has highest violation count`);
+    }
+    
+    return insights;
+  }
+
+  identifyPriorityActions(metrics) {
+    const actions = [];
+    
+    if (metrics.sizeMetrics.criticalSizeFiles > 0) {
+      actions.push({
+        action: 'Refactor critical files',
+        priority: 1,
+        description: 'Address files exceeding critical size threshold'
+      });
+    }
+    
+    if (metrics.severityMetrics.severities.critical.count > 0) {
+      actions.push({
+        action: 'Fix critical violations',
+        priority: 2,
+        description: 'Resolve all critical compliance issues'
+      });
+    }
+    
+    if (metrics.overview.complianceRate < 80) {
+      actions.push({
+        action: 'Improve compliance rate',
+        priority: 3,
+        description: 'Focus on improving overall compliance to >90%'
+      });
+    }
+    
+    return actions;
+  }
+}
+
+module.exports = MetricsCalculator;