vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/validation/metrics-calculator.js

@@ -1,11 +1,14 @@
 /**
  * Compliance Metrics Calculator
  * 
- * Calculates and analyzes various compliance metrics for the codebase,
- * providing insights into file size compliance, code quality, and trends.
+ * Orchestrates metrics calculation using specialized calculator modules.
  */
 
-const { COMPLIANCE_STATUS, COMPLIANCE_CATEGORIES } = require('../models/compliance-report');
+const OverviewCalculator = require('./metrics/overview-calculator');
+const SizeCalculator = require('./metrics/size-calculator');
+const CategoryCalculator = require('./metrics/category-calculator');
+const QualityCalculator = require('./metrics/quality-calculator');
+const metricsHelpers = require('./metrics/metrics-helpers');
 
 /**
  * Metrics calculator class
@@ -18,6 +21,12 @@ class MetricsCalculator {
       criticalThreshold: options.criticalThreshold || 800,
       ...options
     };
+
+    // Initialize specialized calculators
+    this.overviewCalculator = new OverviewCalculator(this.options);
+    this.sizeCalculator = new SizeCalculator(this.options);
+    this.categoryCalculator = new CategoryCalculator(this.options);
+    this.qualityCalculator = new QualityCalculator(this.options);
   }
 
   /**
@@ -25,14 +34,14 @@ class MetricsCalculator {
    */
   calculateMetrics(complianceReport) {
     const metrics = {
-      overview: this.calculateOverviewMetrics(complianceReport),
-      fileMetrics: this.calculateFileMetrics(complianceReport),
-      sizeMetrics: this.calculateSizeMetrics(complianceReport),
-      categoryMetrics: this.calculateCategoryMetrics(complianceReport),
-      severityMetrics: this.calculateSeverityMetrics(complianceReport),
+      overview: this.overviewCalculator.calculateOverviewMetrics(complianceReport),
+      fileMetrics: this.overviewCalculator.calculateFileMetrics(complianceReport, metricsHelpers),
+      sizeMetrics: this.sizeCalculator.calculateSizeMetrics(complianceReport),
+      categoryMetrics: this.categoryCalculator.calculateCategoryMetrics(complianceReport),
+      severityMetrics: this.categoryCalculator.calculateSeverityMetrics(complianceReport),
       trendMetrics: this.calculateTrendMetrics(complianceReport),
-      performanceMetrics: this.calculatePerformanceMetrics(complianceReport),
-      qualityMetrics: this.calculateQualityMetrics(complianceReport)
+      performanceMetrics: this.qualityCalculator.calculatePerformanceMetrics(complianceReport.fileSummaries),
+      qualityMetrics: this.qualityCalculator.calculateQualityMetrics(complianceReport.fileSummaries)
     };
 
     return {
@@ -43,173 +52,6 @@ class MetricsCalculator {
     };
   }
 
-  /**
-   * 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)
    */
@@ -217,7 +59,7 @@ class MetricsCalculator {
     // This would typically compare with previous reports
     // For now, return placeholder metrics
     return {
-      trendDirection: 'stable', // 'improving', 'degrading', 'stable'
+      trendDirection: 'stable',
       complianceScoreChange: 0,
       issueCountChange: 0,
       fileCountChange: 0,
@@ -226,52 +68,18 @@ class MetricsCalculator {
     };
   }
 
-  /**
-   * 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) {
+    const overallScore = metricsHelpers.calculateOverallScore(metrics);
+    
     return {
-      overallScore: this.calculateOverallScore(metrics),
-      riskLevel: this.assessRiskLevel(metrics),
-      healthGrade: this.assignHealthGrade(metrics),
-      keyInsights: this.extractKeyInsights(metrics),
-      priorityActions: this.identifyPriorityActions(metrics)
+      overallScore,
+      riskLevel: metricsHelpers.assessRiskLevel(overallScore),
+      healthGrade: metricsHelpers.assignHealthGrade(overallScore),
+      keyInsights: metricsHelpers.extractKeyInsights(metrics),
+      priorityActions: metricsHelpers.identifyPriorityActions(metrics)
     };
   }
 
@@ -323,338 +131,6 @@ class MetricsCalculator {
 
     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;