vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/analysis/report/statistics-generator.js

@@ -0,0 +1,515 @@
+/**
+ * Statistics and Trends Generator for Analysis Reports
+ */
+
+/**
+ * Generate comprehensive statistics and trend analysis
+ */
+class StatisticsGenerator {
+  constructor() {
+    this.trendData = new Map();
+  }
+
+  /**
+   * Generate comprehensive statistics
+   * @param {Object} analysisData - Complete analysis data
+   * @returns {Object} Statistics object
+   */
+  generateStatistics(analysisData) {
+    const files = analysisData.files || [];
+    
+    return {
+      overview: this.generateOverviewStats(files),
+      sizeDistribution: this.generateSizeDistribution(files),
+      complexityDistribution: this.generateComplexityDistribution(files),
+      complianceMetrics: this.generateComplianceMetrics(files),
+      packageMetrics: this.generatePackageMetrics(files),
+      violationMetrics: this.generateViolationMetrics(files),
+      riskMetrics: this.generateRiskMetrics(files),
+      effortEstimates: this.generateEffortEstimates(files)
+    };
+  }
+
+  /**
+   * Generate overview statistics
+   * @param {Array} files - Files to analyze
+   * @returns {Object} Overview statistics
+   */
+  generateOverviewStats(files) {
+    const totalFiles = files.length;
+    const totalLines = files.reduce((sum, f) => sum + f.lineCount, 0);
+    const averageLines = totalFiles > 0 ? Math.round(totalLines / totalFiles) : 0;
+    
+    const filesNeedingRefactoring = files.filter(f => f.needsRefactoring).length;
+    const urgentFiles = files.filter(f => f.urgentRefactoring).length;
+    const complianceRate = totalFiles > 0 ? Math.round(((totalFiles - filesNeedingRefactoring) / totalFiles) * 100) : 0;
+    
+    return {
+      totalFiles,
+      totalLines,
+      averageLines,
+      filesNeedingRefactoring,
+      urgentFiles,
+      complianceRate,
+      status: this.getOverallStatus(complianceRate, urgentFiles)
+    };
+  }
+
+  /**
+   * Generate size distribution statistics
+   * @param {Array} files - Files to analyze
+   * @returns {Object} Size distribution
+   */
+  generateSizeDistribution(files) {
+    const distribution = {
+      SMALL: { count: 0, lines: 0, percentage: 0 },
+      MEDIUM: { count: 0, lines: 0, percentage: 0 },
+      LARGE: { count: 0, lines: 0, percentage: 0 },
+      XLARGE: { count: 0, lines: 0, percentage: 0 }
+    };
+    
+    for (const file of files) {
+      const category = file.sizeCategory || 'UNKNOWN';
+      if (distribution[category]) {
+        distribution[category].count += 1;
+        distribution[category].lines += file.lineCount;
+      }
+    }
+    
+    // Calculate percentages
+    const totalFiles = files.length;
+    for (const category of Object.keys(distribution)) {
+      distribution[category].percentage = totalFiles > 0 
+        ? Math.round((distribution[category].count / totalFiles) * 100)
+        : 0;
+    }
+    
+    return distribution;
+  }
+
+  /**
+   * Generate complexity distribution statistics
+   * @param {Array} files - Files to analyze
+   * @returns {Object} Complexity distribution
+   */
+  generateComplexityDistribution(files) {
+    const scores = files
+      .map(f => f.getComplexityScore ? f.getComplexityScore() : 0)
+      .filter(score => score > 0);
+    
+    if (scores.length === 0) {
+      return {
+        average: 0,
+        median: 0,
+        min: 0,
+        max: 0,
+        distribution: {
+          LOW: 0,
+          MEDIUM: 0,
+          HIGH: 0,
+          VERY_HIGH: 0
+        }
+      };
+    }
+    
+    scores.sort((a, b) => a - b);
+    
+    const average = Math.round(scores.reduce((sum, score) => sum + score, 0) / scores.length);
+    const median = scores[Math.floor(scores.length / 2)];
+    const min = scores[0];
+    const max = scores[scores.length - 1];
+    
+    const distribution = {
+      LOW: scores.filter(s => s <= 25).length,
+      MEDIUM: scores.filter(s => s > 25 && s <= 50).length,
+      HIGH: scores.filter(s => s > 50 && s <= 75).length,
+      VERY_HIGH: scores.filter(s => s > 75).length
+    };
+    
+    return {
+      average,
+      median,
+      min,
+      max,
+      distribution,
+      totalFiles: scores.length
+    };
+  }
+
+  /**
+   * Generate compliance metrics
+   * @param {Array} files - Files to analyze
+   * @returns {Object} Compliance metrics
+   */
+  generateComplianceMetrics(files) {
+    const totalFiles = files.length;
+    const compliantFiles = files.filter(f => !f.needsRefactoring).length;
+    const nonCompliantFiles = totalFiles - compliantFiles;
+    
+    const complianceRate = totalFiles > 0 ? Math.round((compliantFiles / totalFiles) * 100) : 0;
+    
+    // Compliance by size category
+    const complianceBySize = {};
+    const sizeCategories = ['SMALL', 'MEDIUM', 'LARGE', 'XLARGE'];
+    
+    for (const category of sizeCategories) {
+      const categoryFiles = files.filter(f => f.sizeCategory === category);
+      const categoryCompliant = categoryFiles.filter(f => !f.needsRefactoring).length;
+      const categoryTotal = categoryFiles.length;
+      
+      complianceBySize[category] = {
+        total: categoryTotal,
+        compliant: categoryCompliant,
+        nonCompliant: categoryTotal - categoryCompliant,
+        complianceRate: categoryTotal > 0 ? Math.round((categoryCompliant / categoryTotal) * 100) : 0
+      };
+    }
+    
+    return {
+      totalFiles,
+      compliantFiles,
+      nonCompliantFiles,
+      complianceRate,
+      complianceBySize,
+      status: this.getComplianceStatus(complianceRate)
+    };
+  }
+
+  /**
+   * Generate package metrics
+   * @param {Array} files - Files to analyze
+   * @returns {Object} Package metrics
+   */
+  generatePackageMetrics(files) {
+    const packageMap = new Map();
+    
+    // Group files by package
+    for (const file of files) {
+      const packageName = this.extractPackageName(file.filePath);
+      
+      if (!packageMap.has(packageName)) {
+        packageMap.set(packageName, {
+          packageName,
+          totalFiles: 0,
+          totalLines: 0,
+          compliantFiles: 0,
+          urgentFiles: 0,
+          averageComplexity: 0,
+          complexityScores: []
+        });
+      }
+      
+      const packageData = packageMap.get(packageName);
+      packageData.totalFiles += 1;
+      packageData.totalLines += file.lineCount;
+      
+      if (!file.needsRefactoring) {
+        packageData.compliantFiles += 1;
+      }
+      
+      if (file.urgentRefactoring) {
+        packageData.urgentFiles += 1;
+      }
+      
+      if (file.getComplexityScore) {
+        packageData.complexityScores.push(file.getComplexityScore());
+      }
+    }
+    
+    // Calculate package metrics
+    const packages = {};
+    for (const [packageName, data] of packageMap) {
+      data.complianceRate = data.totalFiles > 0 ? Math.round((data.compliantFiles / data.totalFiles) * 100) : 0;
+      data.averageComplexity = data.complexityScores.length > 0
+        ? Math.round(data.complexityScores.reduce((sum, score) => sum + score, 0) / data.complexityScores.length)
+        : 0;
+      data.status = this.getPackageStatus(data.complianceRate, data.urgentFiles);
+      
+      packages[packageName] = data;
+    }
+    
+    return {
+      totalPackages: Object.keys(packages).length,
+      packages,
+      ranking: this.getPackageRanking(packages)
+    };
+  }
+
+  /**
+   * Generate violation metrics
+   * @param {Array} files - Files to analyze
+   * @returns {Object} Violation metrics
+   */
+  generateViolationMetrics(files) {
+    const allViolations = [];
+    const violationTypes = new Map();
+    const violationSeverity = new Map();
+    
+    for (const file of files) {
+      if (file.violations) {
+        for (const violation of file.violations) {
+          allViolations.push(violation);
+          
+          // Count by type
+          const type = violation.type || 'UNKNOWN';
+          violationTypes.set(type, (violationTypes.get(type) || 0) + 1);
+          
+          // Count by severity
+          const severity = violation.severity || 'LOW';
+          violationSeverity.set(severity, (violationSeverity.get(severity) || 0) + 1);
+        }
+      }
+    }
+    
+    return {
+      totalViolations: allViolations.length,
+      filesWithViolations: files.filter(f => f.violations && f.violations.length > 0).length,
+      violationTypes: Object.fromEntries(violationTypes),
+      violationSeverity: Object.fromEntries(violationSeverity),
+      averageViolationsPerFile: files.length > 0 ? Math.round((allViolations.length / files.length) * 10) / 10 : 0
+    };
+  }
+
+  /**
+   * Generate risk metrics
+   * @param {Array} files - Files to analyze
+   * @returns {Object} Risk metrics
+   */
+  generateRiskMetrics(files) {
+    const riskScores = files.map(f => this.calculateFileRiskScore(f));
+    
+    const totalRisk = riskScores.reduce((sum, score) => sum + score, 0);
+    const averageRisk = files.length > 0 ? Math.round(totalRisk / files.length) : 0;
+    
+    const riskDistribution = {
+      LOW: riskScores.filter(s => s <= 25).length,
+      MEDIUM: riskScores.filter(s => s > 25 && s <= 50).length,
+      HIGH: riskScores.filter(s => s > 50 && s <= 75).length,
+      CRITICAL: riskScores.filter(s => s > 75).length
+    };
+    
+    const highRiskFiles = files.filter(f => this.calculateFileRiskScore(f) > 50);
+    
+    return {
+      totalRisk,
+      averageRisk,
+      riskDistribution,
+      highRiskFiles: highRiskFiles.length,
+      riskLevel: this.getOverallRiskLevel(averageRisk)
+    };
+  }
+
+  /**
+   * Generate effort estimates
+   * @param {Array} files - Files to analyze
+   * @returns {Object} Effort estimates
+   */
+  generateEffortEstimates(files) {
+    const filesNeedingRefactoring = files.filter(f => f.needsRefactoring);
+    const totalLines = filesNeedingRefactoring.reduce((sum, f) => sum + f.lineCount, 0);
+    
+    // Estimate effort in person-hours (rough estimate: 1 hour per 50 lines)
+    const baseHours = Math.round(totalLines / 50);
+    
+    // Adjust for complexity
+    const complexityMultiplier = 1.5; // Complex files take longer
+    
+    // Adjust for dependencies
+    const dependencyMultiplier = 1.2; // Files with many dependencies take longer
+    
+    const adjustedHours = Math.round(baseHours * complexityMultiplier * dependencyMultiplier);
+    
+    return {
+      totalFiles: filesNeedingRefactoring.length,
+      totalLines,
+      estimatedHours: adjustedHours,
+      estimatedDays: Math.round(adjustedHours / 8), // Assuming 8-hour work days
+      effortLevel: this.getEffortLevel(adjustedHours),
+      breakdown: this.getEffortBreakdown(filesNeedingRefactoring)
+    };
+  }
+
+  /**
+   * Extract package name from file path
+   * @param {string} filePath - File path
+   * @returns {string} Package name
+   */
+  extractPackageName(filePath) {
+    const parts = filePath.split('/');
+    const packagesIndex = parts.findIndex(part => part === 'packages');
+    
+    if (packagesIndex !== -1 && parts.length > packagesIndex + 1) {
+      return parts[packagesIndex + 1];
+    }
+    
+    return 'unknown';
+  }
+
+  /**
+   * Get overall status
+   * @param {number} complianceRate - Compliance rate
+   * @param {number} urgentFiles - Number of urgent files
+   * @returns {string} Overall status
+   */
+  getOverallStatus(complianceRate, urgentFiles) {
+    if (complianceRate === 100 && urgentFiles === 0) {
+      return 'COMPLIANT';
+    } else if (urgentFiles > 0) {
+      return 'URGENT_ATTENTION';
+    } else if (complianceRate >= 90) {
+      return 'MOSTLY_COMPLIANT';
+    } else if (complianceRate >= 70) {
+      return 'PARTIALLY_COMPLIANT';
+    } else {
+      return 'NON_COMPLIANT';
+    }
+  }
+
+  /**
+   * Get compliance status
+   * @param {number} complianceRate - Compliance rate
+   * @returns {string} Compliance status
+   */
+  getComplianceStatus(complianceRate) {
+    if (complianceRate === 100) return 'COMPLIANT';
+    if (complianceRate >= 90) return 'MOSTLY_COMPLIANT';
+    if (complianceRate >= 70) return 'PARTIALLY_COMPLIANT';
+    return 'NON_COMPLIANT';
+  }
+
+  /**
+   * Get package status
+   * @param {number} complianceRate - Compliance rate
+   * @param {number} urgentFiles - Number of urgent files
+   * @returns {string} Package status
+   */
+  getPackageStatus(complianceRate, urgentFiles) {
+    if (complianceRate === 100 && urgentFiles === 0) {
+      return 'COMPLIANT';
+    } else if (urgentFiles > 0) {
+      return 'URGENT_ATTENTION';
+    } else if (complianceRate >= 90) {
+      return 'MOSTLY_COMPLIANT';
+    } else if (complianceRate >= 70) {
+      return 'PARTIALLY_COMPLIANT';
+    } else {
+      return 'NON_COMPLIANT';
+    }
+  }
+
+  /**
+   * Get package ranking by priority
+   * @param {Object} packages - Package metrics
+   * @returns {Array} Sorted packages
+   */
+  getPackageRanking(packages) {
+    return Object.entries(packages)
+      .map(([name, data]) => ({
+        name,
+        ...data,
+        priority: this.calculatePackagePriority(data)
+      }))
+      .sort((a, b) => b.priority - a.priority);
+  }
+
+  /**
+   * Calculate package priority
+   * @param {Object} packageData - Package data
+   * @returns {number} Priority score
+   */
+  calculatePackagePriority(packageData) {
+    let priority = 0;
+    
+    // Priority from urgent files
+    priority += packageData.urgentFiles * 50;
+    
+    // Priority from non-compliance
+    priority += (100 - packageData.complianceRate) * 2;
+    
+    // Priority from complexity
+    priority += packageData.averageComplexity * 0.5;
+    
+    // Priority from size
+    priority += Math.log(packageData.totalLines + 1) * 0.1;
+    
+    return Math.round(priority);
+  }
+
+  /**
+   * Calculate file risk score
+   * @param {Object} file - File analysis
+   * @returns {number} Risk score (0-100)
+   */
+  calculateFileRiskScore(file) {
+    let riskScore = 0;
+    
+    // Risk from size
+    if (file.sizeCategory === 'XLARGE') riskScore += 40;
+    else if (file.sizeCategory === 'LARGE') riskScore += 20;
+    
+    // Risk from urgency
+    if (file.urgentRefactoring) riskScore += 30;
+    
+    // Risk from complexity
+    const complexity = file.getComplexityScore ? file.getComplexityScore() : 0;
+    riskScore += Math.min(complexity * 0.5, 30);
+    
+    // Risk from violations
+    if (file.violations) {
+      riskScore += Math.min(file.violations.length * 5, 25);
+    }
+    
+    return Math.min(100, Math.round(riskScore));
+  }
+
+  /**
+   * Get overall risk level
+   * @param {number} averageRisk - Average risk score
+   * @returns {string} Risk level
+   */
+  getOverallRiskLevel(averageRisk) {
+    if (averageRisk <= 25) return 'LOW';
+    if (averageRisk <= 50) return 'MEDIUM';
+    if (averageRisk <= 75) return 'HIGH';
+    return 'CRITICAL';
+  }
+
+  /**
+   * Get effort level
+   * @param {number} hours - Estimated hours
+   * @returns {string} Effort level
+   */
+  getEffortLevel(hours) {
+    if (hours <= 8) return 'LOW';
+    if (hours <= 40) return 'MEDIUM';
+    if (hours <= 160) return 'HIGH';
+    return 'VERY_HIGH';
+  }
+
+  /**
+   * Get effort breakdown
+   * @param {Array} files - Files needing refactoring
+   * @returns {Object} Effort breakdown
+   */
+  getEffortBreakdown(files) {
+    const breakdown = {
+      SMALL: { files: 0, lines: 0, hours: 0 },
+      MEDIUM: { files: 0, lines: 0, hours: 0 },
+      LARGE: { files: 0, lines: 0, hours: 0 },
+      XLARGE: { files: 0, lines: 0, hours: 0 }
+    };
+    
+    for (const file of files) {
+      const category = file.sizeCategory || 'UNKNOWN';
+      if (breakdown[category]) {
+        breakdown[category].files += 1;
+        breakdown[category].lines += file.lineCount;
+        breakdown[category].hours += Math.round(file.lineCount / 50);
+      }
+    }
+    
+    return breakdown;
+  }
+}
+
+module.exports = StatisticsGenerator;

package/src/analysis/reports/analysis-report-model.js

@@ -0,0 +1,101 @@
+/**
+ * Analysis Report Model
+ * 
+ * Data model for analysis reports with metadata, summary, and file analysis.
+ */
+
+const RefactoringConfig = require('../../config/refactoring-config');
+
+/**
+ * Analysis report class
+ */
+class AnalysisReport {
+  constructor() {
+    this.metadata = {
+      generatedAt: new Date().toISOString(),
+      version: '1.0.0',
+      analysisScope: 'full_codebase',
+      config: RefactoringConfig.limits
+    };
+    
+    this.summary = {
+      totalFiles: 0,
+      totalLines: 0,
+      filesNeedingRefactoring: 0,
+      urgentRefactoring: 0,
+      complianceRate: 0,
+      averageComplexity: 0
+    };
+    
+    this.fileAnalysis = [];
+    this.packageAnalysis = {};
+    this.recommendations = [];
+    this.strategies = [];
+    this.statistics = {};
+    this.violations = [];
+    this.trends = {};
+  }
+
+  addFileAnalysis(analysis) {
+    this.fileAnalysis.push(analysis);
+    this.updateSummary();
+  }
+
+  updateSummary() {
+    this.summary.totalFiles = this.fileAnalysis.length;
+    this.summary.totalLines = this.fileAnalysis.reduce((sum, f) => sum + f.lineCount, 0);
+    this.summary.filesNeedingRefactoring = this.fileAnalysis.filter(f => f.needsRefactoring).length;
+    this.summary.urgentRefactoring = this.fileAnalysis.filter(f => f.priority === 'urgent').length;
+    this.summary.complianceRate = this.summary.totalFiles > 0 ? 
+      ((this.summary.totalFiles - this.summary.filesNeedingRefactoring) / this.summary.totalFiles * 100).toFixed(2) : 100;
+    this.summary.averageComplexity = this.calculateAverageComplexity();
+  }
+
+  calculateAverageComplexity() {
+    if (this.fileAnalysis.length === 0) return 0;
+    const totalComplexity = this.fileAnalysis.reduce((sum, f) => {
+      return sum + (f.getComplexityScore ? f.getComplexityScore() : 0);
+    }, 0);
+    return (totalComplexity / this.fileAnalysis.length).toFixed(2);
+  }
+
+  addPackageAnalysis(packageName, analysis) {
+    this.packageAnalysis[packageName] = analysis;
+  }
+
+  addRecommendation(recommendation) {
+    this.recommendations.push(recommendation);
+  }
+
+  addStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+
+  addViolation(violation) {
+    this.violations.push(violation);
+  }
+
+  setStatistics(stats) {
+    this.statistics = stats;
+  }
+
+  setTrends(trends) {
+    this.trends = trends;
+  }
+
+  toJSON() {
+    return {
+      metadata: this.metadata,
+      summary: this.summary,
+      fileAnalysis: this.fileAnalysis,
+      packageAnalysis: this.packageAnalysis,
+      recommendations: this.recommendations,
+      strategies: this.strategies,
+      statistics: this.statistics,
+      violations: this.violations,
+      trends: this.trends
+    };
+  }
+}
+
+module.exports = AnalysisReport;