vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,250 @@
+/**
+ * Analysis Report Data Structure
+ */
+
+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 = {};
+  }
+
+  /**
+   * Add file analysis to report
+   * @param {Object} analysis - File analysis data
+   */
+  addFileAnalysis(analysis) {
+    this.fileAnalysis.push(analysis);
+    this.updateSummary();
+  }
+
+  /**
+   * Update report summary
+   */
+  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.urgentRefactoring).length;
+    this.summary.complianceRate = this.calculateComplianceRate();
+    this.summary.averageComplexity = this.calculateAverageComplexity();
+  }
+
+  /**
+   * Calculate compliance rate
+   * @returns {string} Compliance rate as percentage
+   */
+  calculateComplianceRate() {
+    if (this.summary.totalFiles === 0) return 0;
+    const compliantFiles = this.fileAnalysis.filter(f => !f.needsRefactoring).length;
+    return (compliantFiles / this.summary.totalFiles * 100).toFixed(1);
+  }
+
+  /**
+   * Calculate average complexity
+   * @returns {number} Average complexity score
+   */
+  calculateAverageComplexity() {
+    if (this.fileAnalysis.length === 0) return 0;
+    const totalComplexity = this.fileAnalysis.reduce((sum, f) => {
+      return sum + (f.getComplexityScore ? f.getComplexityScore() : 0);
+    }, 0);
+    return Math.round(totalComplexity / this.fileAnalysis.length);
+  }
+
+  /**
+   * Add package analysis
+   * @param {string} packageName - Package name
+   * @param {Object} analysis - Package analysis data
+   */
+  addPackageAnalysis(packageName, analysis) {
+    this.packageAnalysis[packageName] = analysis;
+  }
+
+  /**
+   * Add recommendation
+   * @param {Object} recommendation - Recommendation data
+   */
+  addRecommendation(recommendation) {
+    this.recommendations.push(recommendation);
+  }
+
+  /**
+   * Add strategy
+   * @param {Object} strategy - Strategy data
+   */
+  addStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+
+  /**
+   * Add statistics
+   * @param {Object} statistics - Statistics data
+   */
+  addStatistics(statistics) {
+    this.statistics = { ...this.statistics, ...statistics };
+  }
+
+  /**
+   * Add violation
+   * @param {Object} violation - Violation data
+   */
+  addViolation(violation) {
+    this.violations.push(violation);
+  }
+
+  /**
+   * Add trend data
+   * @param {Object} trends - Trend data
+   */
+  addTrends(trends) {
+    this.trends = { ...this.trends, ...trends };
+  }
+
+  /**
+   * Get files needing refactoring
+   * @returns {Array} Files that need refactoring
+   */
+  getFilesNeedingRefactoring() {
+    return this.fileAnalysis.filter(f => f.needsRefactoring);
+  }
+
+  /**
+   * Get urgent refactoring files
+   * @returns {Array} Files needing urgent refactoring
+   */
+  getUrgentRefactoringFiles() {
+    return this.fileAnalysis.filter(f => f.urgentRefactoring);
+  }
+
+  /**
+   * Get files by size category
+   * @param {string} category - Size category (SMALL, MEDIUM, LARGE, XLARGE)
+   * @returns {Array} Files in the specified category
+   */
+  getFilesBySizeCategory(category) {
+    return this.fileAnalysis.filter(f => f.sizeCategory === category);
+  }
+
+  /**
+   * Get compliance summary
+   * @returns {Object} Compliance summary
+   */
+  getComplianceSummary() {
+    const total = this.summary.totalFiles;
+    const compliant = total - this.summary.filesNeedingRefactoring;
+    const urgent = this.summary.urgentRefactoring;
+    
+    return {
+      total,
+      compliant,
+      nonCompliant: this.summary.filesNeedingRefactoring,
+      urgent,
+      complianceRate: parseFloat(this.summary.complianceRate),
+      status: this.getComplianceStatus()
+    };
+  }
+
+  /**
+   * Get compliance status
+   * @returns {string} Compliance status
+   */
+  getComplianceStatus() {
+    const rate = parseFloat(this.summary.complianceRate);
+    if (rate === 100) return 'COMPLIANT';
+    if (rate >= 90) return 'MOSTLY_COMPLIANT';
+    if (rate >= 70) return 'PARTIALLY_COMPLIANT';
+    return 'NON_COMPLIANT';
+  }
+
+  /**
+   * Get package summary
+   * @returns {Object} Package summary
+   */
+  getPackageSummary() {
+    const summary = {};
+    
+    for (const [packageName, analysis] of Object.entries(this.packageAnalysis)) {
+      summary[packageName] = {
+        totalFiles: analysis.totalFiles || 0,
+        totalLines: analysis.totalLines || 0,
+        filesNeedingRefactoring: analysis.filesNeedingRefactoring || 0,
+        complianceRate: analysis.complianceRate || 0,
+        status: analysis.status || 'UNKNOWN'
+      };
+    }
+    
+    return summary;
+  }
+
+  /**
+   * Get violation summary
+   * @returns {Object} Violation summary
+   */
+  getViolationSummary() {
+    const summary = {
+      total: this.violations.length,
+      byType: {},
+      bySeverity: {},
+      byPackage: {}
+    };
+    
+    for (const violation of this.violations) {
+      // Count by type
+      summary.byType[violation.type] = (summary.byType[violation.type] || 0) + 1;
+      
+      // Count by severity
+      summary.bySeverity[violation.severity] = (summary.bySeverity[violation.severity] || 0) + 1;
+      
+      // Count by package
+      summary.byPackage[violation.packageName] = (summary.byPackage[violation.packageName] || 0) + 1;
+    }
+    
+    return summary;
+  }
+
+  /**
+   * Convert to JSON
+   * @returns {Object} Report as JSON object
+   */
+  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;

package/src/analysis/report/package-analyzer.js

@@ -0,0 +1,278 @@
+/**
+ * Package Analysis for Reports
+ */
+
+/**
+ * Analyze packages and generate package-level insights
+ */
+class PackageAnalyzer {
+  constructor() {
+    this.packageMetrics = new Map();
+  }
+
+  /**
+   * Analyze package from file analyses
+   * @param {Array} fileAnalyses - Array of file analyses
+   * @returns {Object} Package analysis results
+   */
+  analyzePackages(fileAnalyses) {
+    const packageMap = new Map();
+    
+    // Group files by package
+    for (const fileAnalysis of fileAnalyses) {
+      const packageName = this.extractPackageName(fileAnalysis.filePath);
+      
+      if (!packageMap.has(packageName)) {
+        packageMap.set(packageName, {
+          packageName,
+          files: [],
+          totalLines: 0,
+          totalFiles: 0,
+          filesNeedingRefactoring: 0,
+          urgentRefactoring: 0,
+          sizeDistribution: {
+            SMALL: 0,
+            MEDIUM: 0,
+            LARGE: 0,
+            XLARGE: 0
+          },
+          complexityScores: [],
+          violations: []
+        });
+      }
+      
+      const packageData = packageMap.get(packageName);
+      packageData.files.push(fileAnalysis);
+      packageData.totalLines += fileAnalysis.lineCount;
+      packageData.totalFiles += 1;
+      
+      if (fileAnalysis.needsRefactoring) {
+        packageData.filesNeedingRefactoring += 1;
+      }
+      
+      if (fileAnalysis.urgentRefactoring) {
+        packageData.urgentRefactoring += 1;
+      }
+      
+      // Track size distribution
+      if (fileAnalysis.sizeCategory) {
+        packageData.sizeDistribution[fileAnalysis.sizeCategory] += 1;
+      }
+      
+      // Track complexity
+      if (fileAnalysis.getComplexityScore) {
+        packageData.complexityScores.push(fileAnalysis.getComplexityScore());
+      }
+      
+      // Track violations
+      if (fileAnalysis.violations) {
+        packageData.violations.push(...fileAnalysis.violations);
+      }
+    }
+    
+    // Calculate package metrics
+    const results = {};
+    for (const [packageName, data] of packageMap) {
+      results[packageName] = this.calculatePackageMetrics(data);
+    }
+    
+    return results;
+  }
+
+  /**
+   * 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';
+  }
+
+  /**
+   * Calculate package metrics
+   * @param {Object} packageData - Package data
+   * @returns {Object} Package metrics
+   */
+  calculatePackageMetrics(packageData) {
+    const complianceRate = packageData.totalFiles > 0 
+      ? ((packageData.totalFiles - packageData.filesNeedingRefactoring) / packageData.totalFiles * 100).toFixed(1)
+      : 0;
+    
+    const averageComplexity = packageData.complexityScores.length > 0
+      ? Math.round(packageData.complexityScores.reduce((sum, score) => sum + score, 0) / packageData.complexityScores.length)
+      : 0;
+    
+    const status = this.getPackageStatus(complianceRate, packageData.urgentRefactoring);
+    
+    return {
+      packageName: packageData.packageName,
+      totalFiles: packageData.totalFiles,
+      totalLines: packageData.totalLines,
+      filesNeedingRefactoring: packageData.filesNeedingRefactoring,
+      urgentRefactoring: packageData.urgentRefactoring,
+      complianceRate: parseFloat(complianceRate),
+      averageComplexity,
+      status,
+      sizeDistribution: packageData.sizeDistribution,
+      violationCount: packageData.violations.length,
+      riskScore: this.calculateRiskScore(packageData, complianceRate),
+      recommendations: this.generatePackageRecommendations(packageData, complianceRate)
+    };
+  }
+
+  /**
+   * Get package status based on metrics
+   * @param {number} complianceRate - Compliance rate
+   * @param {number} urgentRefactoring - Number of urgent refactoring files
+   * @returns {string} Package status
+   */
+  getPackageStatus(complianceRate, urgentRefactoring) {
+    if (complianceRate === 100 && urgentRefactoring === 0) {
+      return 'COMPLIANT';
+    } else if (complianceRate >= 90 && urgentRefactoring === 0) {
+      return 'MOSTLY_COMPLIANT';
+    } else if (urgentRefactoring > 0) {
+      return 'URGENT_ATTENTION';
+    } else if (complianceRate >= 70) {
+      return 'PARTIALLY_COMPLIANT';
+    } else {
+      return 'NON_COMPLIANT';
+    }
+  }
+
+  /**
+   * Calculate risk score for package
+   * @param {Object} packageData - Package data
+   * @param {number} complianceRate - Compliance rate
+   * @returns {number} Risk score (0-100)
+   */
+  calculateRiskScore(packageData, complianceRate) {
+    let riskScore = 0;
+    
+    // Base risk from non-compliance
+    riskScore += (100 - complianceRate) * 0.5;
+    
+    // Risk from urgent files
+    riskScore += packageData.urgentRefactoring * 10;
+    
+    // Risk from large files
+    riskScore += packageData.sizeDistribution.XLARGE * 15;
+    riskScore += packageData.sizeDistribution.LARGE * 8;
+    
+    // Risk from violations
+    riskScore += packageData.violations.length * 5;
+    
+    // Risk from complexity
+    if (packageData.averageComplexity > 50) {
+      riskScore += 20;
+    } else if (packageData.averageComplexity > 30) {
+      riskScore += 10;
+    }
+    
+    return Math.min(100, Math.round(riskScore));
+  }
+
+  /**
+   * Generate package recommendations
+   * @param {Object} packageData - Package data
+   * @param {number} complianceRate - Compliance rate
+   * @returns {Array} Array of recommendations
+   */
+  generatePackageRecommendations(packageData, complianceRate) {
+    const recommendations = [];
+    
+    if (packageData.urgentRefactoring > 0) {
+      recommendations.push({
+        type: 'URGENT',
+        priority: 'HIGH',
+        message: `Package has ${packageData.urgentRefactoring} files requiring urgent refactoring`,
+        action: 'Address urgent files first to reduce technical debt'
+      });
+    }
+    
+    if (packageData.sizeDistribution.XLARGE > 0) {
+      recommendations.push({
+        type: 'SIZE',
+        priority: 'HIGH',
+        message: `Package contains ${packageData.sizeDistribution.XLARGE} XLARGE files (>1000 lines)`,
+        action: 'Break down large files into smaller, focused modules'
+      });
+    }
+    
+    if (packageData.sizeDistribution.LARGE > 2) {
+      recommendations.push({
+        type: 'SIZE',
+        priority: 'MEDIUM',
+        message: `Package contains ${packageData.sizeDistribution.LARGE} LARGE files (555-1000 lines)`,
+        action: 'Consider refactoring large files to improve maintainability'
+      });
+    }
+    
+    if (complianceRate < 70) {
+      recommendations.push({
+        type: 'COMPLIANCE',
+        priority: 'HIGH',
+        message: `Package compliance rate is ${complianceRate}%`,
+        action: 'Focus on bringing files under the 555-line limit'
+      });
+    }
+    
+    if (packageData.violations.length > 5) {
+      recommendations.push({
+        type: 'VIOLATIONS',
+        priority: 'MEDIUM',
+        message: `Package has ${packageData.violations.length} code violations`,
+        action: 'Address code quality issues to improve maintainability'
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Get package ranking by priority
+   * @param {Object} packageAnalyses - Package analysis results
+   * @returns {Array} Sorted package list by priority
+   */
+  getPackageRanking(packageAnalyses) {
+    return Object.entries(packageAnalyses)
+      .map(([packageName, analysis]) => ({
+        packageName,
+        ...analysis,
+        priority: this.calculatePackagePriority(analysis)
+      }))
+      .sort((a, b) => b.priority - a.priority);
+  }
+
+  /**
+   * Calculate package priority for refactoring
+   * @param {Object} analysis - Package analysis
+   * @returns {number} Priority score
+   */
+  calculatePackagePriority(analysis) {
+    let priority = 0;
+    
+    // Priority from urgent files
+    priority += analysis.urgentRefactoring * 50;
+    
+    // Priority from non-compliance
+    priority += (100 - analysis.complianceRate) * 2;
+    
+    // Priority from risk score
+    priority += analysis.riskScore * 0.5;
+    
+    // Priority from total lines (larger packages get higher priority)
+    priority += Math.log(analysis.totalLines + 1) * 0.1;
+    
+    return Math.round(priority);
+  }
+}
+
+module.exports = PackageAnalyzer;