vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/validation/metrics/metrics-helpers.js

@@ -0,0 +1,155 @@
+/**
+ * Metrics Helper Functions
+ * Shared utility functions for metrics calculations
+ */
+
+class MetricsHelpers {
+  /**
+   * Calculate median value from array
+   */
+  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];
+  }
+
+  /**
+   * Calculate size distribution
+   */
+  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;
+  }
+
+  /**
+   * Calculate overall score from metrics
+   */
+  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));
+  }
+
+  /**
+   * Assess risk level from metrics
+   */
+  assessRiskLevel(overallScore) {
+    if (overallScore >= 90) return 'low';
+    if (overallScore >= 70) return 'medium';
+    if (overallScore >= 50) return 'high';
+    return 'critical';
+  }
+
+  /**
+   * Assign health grade from metrics
+   */
+  assignHealthGrade(overallScore) {
+    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';
+  }
+
+  /**
+   * Extract key insights from metrics
+   */
+  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;
+  }
+
+  /**
+   * Identify priority actions from metrics
+   */
+  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 = new MetricsHelpers();

package/src/validation/metrics/overview-calculator.js

@@ -0,0 +1,85 @@
+/**
+ * Overview Metrics Calculator
+ * Calculates overview and file-specific metrics
+ */
+
+const { COMPLIANCE_STATUS } = require('../../models/compliance-report');
+
+class OverviewCalculator {
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  /**
+   * 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, helpers) {
+    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: helpers.calculateMedian(fileSummaries.map(f => f.lineCount)),
+      fileSizeDistribution: helpers.calculateSizeDistribution(fileSummaries)
+    };
+  }
+
+  getHealthStatus(complianceScore) {
+    if (complianceScore >= 95) return 'excellent';
+    if (complianceScore >= 85) return 'good';
+    if (complianceScore >= 70) return 'fair';
+    if (complianceScore >= 50) return 'poor';
+    return 'critical';
+  }
+}
+
+module.exports = OverviewCalculator;

package/src/validation/metrics/overview-metrics.js

@@ -0,0 +1,41 @@
+/**
+ * Overview Metrics Calculator
+ * 
+ * Calculates high-level overview metrics for compliance reports.
+ */
+
+/**
+ * Calculate overview metrics
+ */
+function calculateOverviewMetrics(report, options = {}) {
+  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: getHealthStatus(report.summary.overallComplianceScore)
+  };
+}
+
+/**
+ * Get health status based on compliance score
+ */
+function getHealthStatus(complianceScore) {
+  if (complianceScore >= 95) return 'excellent';
+  if (complianceScore >= 85) return 'good';
+  if (complianceScore >= 70) return 'fair';
+  if (complianceScore >= 50) return 'poor';
+  return 'critical';
+}
+
+module.exports = {
+  calculateOverviewMetrics,
+  getHealthStatus
+};

package/src/validation/metrics/quality-calculator.js

@@ -0,0 +1,166 @@
+/**
+ * Quality Metrics Calculator
+ * Calculates quality, maintainability, and technical debt metrics
+ */
+
+const { COMPLIANCE_STATUS, COMPLIANCE_CATEGORIES } = require('../../models/compliance-report');
+
+class QualityCalculator {
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  /**
+   * Calculate quality metrics
+   */
+  calculateQualityMetrics(fileSummaries) {
+    return {
+      codeQualityScore: this.calculateCodeQualityScore(fileSummaries),
+      maintainabilityIndex: this.calculateMaintainabilityIndex(fileSummaries),
+      technicalDebt: this.calculateTechnicalDebt(fileSummaries),
+      complexityMetrics: this.calculateComplexityMetrics(fileSummaries),
+      documentationCoverage: this.calculateDocumentationCoverage(fileSummaries)
+    };
+  }
+
+  /**
+   * Calculate performance metrics
+   */
+  calculatePerformanceMetrics(fileSummaries) {
+    return {
+      averageAnalysisTime: 0,
+      totalAnalysisTime: 0,
+      filesPerSecond: 0,
+      memoryUsage: {
+        estimated: this.estimateMemoryUsage(fileSummaries),
+        peak: 0
+      },
+      efficiency: {
+        issuesDetectedPerMinute: 0,
+        filesProcessedPerMinute: 0
+      }
+    };
+  }
+
+  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,
+      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
+    };
+  }
+
+  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);
+  }
+}
+
+module.exports = QualityCalculator;

package/src/validation/metrics/size-calculator.js

@@ -0,0 +1,69 @@
+/**
+ * Size Metrics Calculator
+ * Calculates size-specific metrics and risk scores
+ */
+
+class SizeCalculator {
+  constructor(options = {}) {
+    this.options = {
+      maxFileSize: options.maxFileSize || 555,
+      warningThreshold: options.warningThreshold || 500,
+      criticalThreshold: options.criticalThreshold || 800,
+      ...options
+    };
+  }
+
+  /**
+   * 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)
+    };
+  }
+
+  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;
+  }
+}
+
+module.exports = SizeCalculator;