vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/analysis/reports/recommendation-generator.js

@@ -0,0 +1,283 @@
+/**
+ * Recommendation Generator
+ * 
+ * Generates refactoring recommendations based on analysis results.
+ */
+
+/**
+ * Recommendation Generator class
+ */
+class RecommendationGenerator {
+  constructor(report) {
+    this.report = report;
+  }
+
+  generateAllRecommendations() {
+    const recommendations = [];
+    
+    // File-level recommendations
+    recommendations.push(...this.generateFileRecommendations());
+    
+    // Package-level recommendations
+    recommendations.push(...this.generatePackageRecommendations());
+    
+    // Strategic recommendations
+    recommendations.push(...this.generateStrategicRecommendations());
+    
+    // Priority-based recommendations
+    recommendations.push(...this.generatePriorityRecommendations());
+    
+    return recommendations;
+  }
+
+  generateFileRecommendations() {
+    const recommendations = [];
+    const violatingFiles = this.report.fileAnalysis.filter(f => f.needsRefactoring);
+    
+    // Group files by size category
+    const sizeGroups = this.groupFilesBySize(violatingFiles);
+    
+    // Recommendations for extra-large files
+    if (sizeGroups.xlarge.length > 0) {
+      recommendations.push({
+        type: 'urgent',
+        category: 'file_size',
+        title: `Refactor ${sizeGroups.xlarge.length} extra-large files immediately`,
+        description: 'Files over 1000 lines should be split into smaller, focused modules',
+        affectedFiles: sizeGroups.xlarge.map(f => f.filePath),
+        estimatedEffort: this.calculateEffortForFiles(sizeGroups.xlarge),
+        priority: 'urgent'
+      });
+    }
+    
+    // Recommendations for large files
+    if (sizeGroups.large.length > 0) {
+      recommendations.push({
+        type: 'high',
+        category: 'file_size',
+        title: `Refactor ${sizeGroups.large.length} large files`,
+        description: 'Files between 556-1000 lines should be refactored to improve maintainability',
+        affectedFiles: sizeGroups.large.map(f => f.filePath),
+        estimatedEffort: this.calculateEffortForFiles(sizeGroups.large),
+        priority: 'high'
+      });
+    }
+    
+    // Complexity-based recommendations
+    const highComplexityFiles = violatingFiles.filter(f => 
+      f.getComplexityScore && f.getComplexityScore() > 50
+    );
+    
+    if (highComplexityFiles.length > 0) {
+      recommendations.push({
+        type: 'high',
+        category: 'complexity',
+        title: `Reduce complexity in ${highComplexityFiles.length} files`,
+        description: 'High complexity files are difficult to maintain and should be simplified',
+        affectedFiles: highComplexityFiles.map(f => f.filePath),
+        estimatedEffort: this.calculateEffortForFiles(highComplexityFiles),
+        priority: 'high'
+      });
+    }
+    
+    return recommendations;
+  }
+
+  generatePackageRecommendations() {
+    const recommendations = [];
+    const packages = this.report.packageAnalysis;
+    
+    // Find packages with many violations
+    const problematicPackages = Object.entries(packages)
+      .filter(([name, data]) => data.filesNeedingRefactoring > 0)
+      .sort(([,a], [,b]) => b.filesNeedingRefactoring - a.filesNeedingRefactoring);
+    
+    for (const [packageName, packageData] of problematicPackages) {
+      const violationRate = (packageData.filesNeedingRefactoring / packageData.files.length * 100).toFixed(1);
+      
+      if (violationRate > 50) {
+        recommendations.push({
+          type: 'high',
+          category: 'package_health',
+          title: `Comprehensive refactoring needed for ${packageName} package`,
+          description: `${violationRate}% of files in this package violate size limits`,
+          affectedPackage: packageName,
+          violationRate: parseFloat(violationRate),
+          estimatedEffort: packageData.filesNeedingRefactoring * 3, // 3 hours per file average
+          priority: 'high'
+        });
+      } else if (violationRate > 25) {
+        recommendations.push({
+          type: 'medium',
+          category: 'package_health',
+          title: `Partial refactoring recommended for ${packageName} package`,
+          description: `${violationRate}% of files in this package violate size limits`,
+          affectedPackage: packageName,
+          violationRate: parseFloat(violationRate),
+          estimatedEffort: packageData.filesNeedingRefactoring * 2, // 2 hours per file average
+          priority: 'medium'
+        });
+      }
+    }
+    
+    return recommendations;
+  }
+
+  generateStrategicRecommendations() {
+    const recommendations = [];
+    const complianceRate = parseFloat(this.report.summary.complianceRate);
+    
+    // Overall compliance strategy
+    if (complianceRate < 70) {
+      recommendations.push({
+        type: 'strategic',
+        category: 'compliance_strategy',
+        title: 'Implement comprehensive refactoring initiative',
+        description: 'With less than 70% compliance, a systematic approach is needed',
+        strategy: 'comprehensive',
+        phases: [
+          'Phase 1: Focus on urgent and high-priority files',
+          'Phase 2: Address medium-priority violations',
+          'Phase 3: Handle remaining low-priority files'
+        ],
+        estimatedTimeline: '8-12 weeks',
+        priority: 'urgent'
+      });
+    } else if (complianceRate < 90) {
+      recommendations.push({
+        type: 'strategic',
+        category: 'compliance_strategy',
+        title: 'Targeted refactoring initiative',
+        description: 'With good compliance baseline, focus on remaining violations',
+        strategy: 'targeted',
+        phases: [
+          'Phase 1: Address remaining high-priority files',
+          'Phase 2: Clean up medium and low priority files'
+        ],
+        estimatedTimeline: '4-6 weeks',
+        priority: 'high'
+      });
+    } else {
+      recommendations.push({
+        type: 'strategic',
+        category: 'compliance_strategy',
+        title: 'Final compliance push',
+        description: 'Near-complete compliance, focus on remaining edge cases',
+        strategy: 'cleanup',
+        phases: [
+          'Phase 1: Address final violations',
+          'Phase 2: Implement compliance monitoring'
+        ],
+        estimatedTimeline: '1-2 weeks',
+        priority: 'medium'
+      });
+    }
+    
+    // Process recommendations
+    recommendations.push({
+      type: 'process',
+      category: 'prevention',
+      title: 'Implement size validation in development workflow',
+      description: 'Prevent future violations by adding size checks to CI/CD and pre-commit hooks',
+      implementation: [
+        'Add pre-commit hook for file size validation',
+        'Integrate size checks into CI pipeline',
+        'Set up automated monitoring for new files',
+        'Establish size limits in code review guidelines'
+      ],
+      priority: 'medium'
+    });
+    
+    return recommendations;
+  }
+
+  generatePriorityRecommendations() {
+    const recommendations = [];
+    const violatingFiles = this.report.fileAnalysis.filter(f => f.needsRefactoring);
+    
+    // Urgent priority files
+    const urgentFiles = violatingFiles.filter(f => f.priority === 'urgent');
+    if (urgentFiles.length > 0) {
+      recommendations.push({
+        type: 'priority_action',
+        category: 'immediate',
+        title: `Immediate action required for ${urgentFiles.length} urgent files`,
+        description: 'These files pose the highest risk and should be addressed first',
+        files: urgentFiles.map(f => ({
+          path: f.filePath,
+          lines: f.lineCount,
+          complexity: f.getComplexityScore ? f.getComplexityScore() : 0,
+          reason: this.getUrgentReason(f)
+        })),
+        suggestedOrder: 'largest_first',
+        priority: 'urgent'
+      });
+    }
+    
+    // High priority files
+    const highPriorityFiles = violatingFiles.filter(f => f.priority === 'high');
+    if (highPriorityFiles.length > 0) {
+      recommendations.push({
+        type: 'priority_action',
+        category: 'short_term',
+        title: `Address ${highPriorityFiles.length} high-priority files next`,
+        description: 'These files should be addressed after urgent issues are resolved',
+        files: highPriorityFiles.map(f => ({
+          path: f.filePath,
+          lines: f.lineCount,
+          complexity: f.getComplexityScore ? f.getComplexityScore() : 0,
+          reason: this.getHighPriorityReason(f)
+        })),
+        suggestedOrder: 'complexity_first',
+        priority: 'high'
+      });
+    }
+    
+    return recommendations;
+  }
+
+  // Helper methods
+  groupFilesBySize(files) {
+    return {
+      small: files.filter(f => f.lineCount < 100),
+      medium: files.filter(f => f.lineCount >= 100 && f.lineCount <= 300),
+      large: files.filter(f => f.lineCount >= 301 && f.lineCount <= 1000),
+      xlarge: files.filter(f => f.lineCount > 1000)
+    };
+  }
+
+  calculateEffortForFiles(files) {
+    let totalEffort = 0;
+    for (const file of files) {
+      // Base effort: 1 hour per 100 lines
+      const baseEffort = Math.ceil(file.lineCount / 100);
+      
+      // Complexity multiplier
+      const complexity = file.getComplexityScore ? file.getComplexityScore() : 0;
+      const complexityMultiplier = complexity > 50 ? 2 : (complexity > 20 ? 1.5 : 1);
+      
+      totalEffort += baseEffort * complexityMultiplier;
+    }
+    return Math.ceil(totalEffort);
+  }
+
+  getUrgentReason(file) {
+    if (file.lineCount > 2000) return 'Extremely large file - immediate splitting required';
+    if (file.lineCount > 1000) return 'Very large file - high maintenance burden';
+    const complexity = file.getComplexityScore ? file.getComplexityScore() : 0;
+    if (complexity > 100) return 'Critical complexity - unmanageable code';
+    if (complexity > 50) return 'High complexity - difficult to maintain';
+    return 'Size and complexity thresholds exceeded';
+  }
+
+  getHighPriorityReason(file) {
+    if (file.lineCount > 800) return 'Large file - should be split soon';
+    if (file.lineCount > 600) return 'Approaching size limit - plan refactoring';
+    const complexity = file.getComplexityScore ? file.getComplexityScore() : 0;
+    if (complexity > 30) return 'Moderate-high complexity - simplification needed';
+    if (complexity > 20) return 'Moderate complexity - consider refactoring';
+    return 'Size limit exceeded - standard refactoring needed';
+  }
+}
+
+module.exports = RecommendationGenerator;

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

@@ -0,0 +1,191 @@
+/**
+ * Report Generators
+ * 
+ * Handles generation of different report formats (JSON, HTML, CSV).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { ReportGenerator } = require('../../utils/report-generator');
+
+/**
+ * JSON Report Generator
+ */
+class JSONReportGenerator {
+  constructor(report) {
+    this.report = report;
+  }
+
+  generate(outputPath) {
+    const jsonContent = JSON.stringify(this.report.toJSON(), null, 2);
+    
+    if (outputPath) {
+      fs.writeFileSync(outputPath, jsonContent, 'utf8');
+      return { success: true, path: outputPath, format: 'json' };
+    }
+    
+    return { success: true, content: jsonContent, format: 'json' };
+  }
+}
+
+/**
+ * HTML Report Generator
+ */
+class HTMLReportGenerator {
+  constructor(report) {
+    this.report = report;
+  }
+
+  generate(outputPath) {
+    const html = this.generateHTMLContent();
+    
+    if (outputPath) {
+      fs.writeFileSync(outputPath, html, 'utf8');
+      return { success: true, path: outputPath, format: 'html' };
+    }
+    
+    return { success: true, content: html, format: 'html' };
+  }
+
+  generateHTMLContent() {
+    const report = this.report;
+    
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>File Size Analysis Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; }
+        .summary { background: #f5f5f5; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
+        .metric { display: inline-block; margin: 10px; padding: 10px; background: white; border-radius: 3px; }
+        .file-item { margin: 5px 0; padding: 8px; border-left: 3px solid #ccc; }
+        .urgent { border-left-color: #d32f2f; }
+        .high { border-left-color: #f57c00; }
+        .medium { border-left-color: #fbc02d; }
+        .low { border-left-color: #388e3c; }
+        table { width: 100%; border-collapse: collapse; margin: 10px 0; }
+        th, td { padding: 8px; text-align: left; border-bottom: 1px solid #ddd; }
+        th { background-color: #f2f2f2; }
+    </style>
+</head>
+<body>
+    <h1>File Size Analysis Report</h1>
+    
+    <div class="summary">
+        <h2>Summary</h2>
+        <div class="metric">Total Files: ${report.summary.totalFiles}</div>
+        <div class="metric">Total Lines: ${report.summary.totalLines.toLocaleString()}</div>
+        <div class="metric">Files Needing Refactoring: ${report.summary.filesNeedingRefactoring}</div>
+        <div class="metric">Compliance Rate: ${report.summary.complianceRate}%</div>
+        <div class="metric">Average Complexity: ${report.summary.averageComplexity}</div>
+    </div>
+
+    <h2>Files Requiring Refactoring</h2>
+    <table>
+        <thead>
+            <tr>
+                <th>File</th>
+                <th>Lines</th>
+                <th>Priority</th>
+                <th>Complexity</th>
+                <th>Recommendation</th>
+            </tr>
+        </thead>
+        <tbody>
+            ${report.fileAnalysis
+              .filter(f => f.needsRefactoring)
+              .map(f => `
+                <tr class="file-item ${f.priority}">
+                    <td>${f.filePath}</td>
+                    <td>${f.lineCount}</td>
+                    <td>${f.priority.toUpperCase()}</td>
+                    <td>${f.getComplexityScore ? f.getComplexityScore() : 'N/A'}</td>
+                    <td>${f.recommendation || 'See detailed analysis'}</td>
+                </tr>
+              `).join('')}
+        </tbody>
+    </table>
+
+    <h2>Package Analysis</h2>
+    <table>
+        <thead>
+            <tr>
+                <th>Package</th>
+                <th>Files</th>
+                <th>Total Lines</th>
+                <th>Files Needing Refactoring</th>
+                <th>Priority</th>
+            </tr>
+        </thead>
+        <tbody>
+            ${Object.entries(report.packageAnalysis)
+              .map(([name, data]) => `
+                <tr>
+                    <td>${name}</td>
+                    <td>${data.files.length}</td>
+                    <td>${data.totalLines.toLocaleString()}</td>
+                    <td>${data.filesNeedingRefactoring}</td>
+                    <td>${data.priority.toUpperCase()}</td>
+                </tr>
+              `).join('')}
+        </tbody>
+    </table>
+
+    <h2>Recommendations</h2>
+    <ul>
+        ${report.recommendations.map(r => `<li>${r}</li>`).join('')}
+    </ul>
+
+    <div style="margin-top: 30px; font-size: 12px; color: #666;">
+        Report generated on ${report.metadata.generatedAt}<br>
+        Analysis version: ${report.metadata.version}
+    </div>
+</body>
+</html>`;
+  }
+}
+
+/**
+ * CSV Report Generator
+ */
+class CSVReportGenerator {
+  constructor(report) {
+    this.report = report;
+  }
+
+  generate(outputPath) {
+    const csv = this.generateCSVContent();
+    
+    if (outputPath) {
+      fs.writeFileSync(outputPath, csv, 'utf8');
+      return { success: true, path: outputPath, format: 'csv' };
+    }
+    
+    return { success: true, content: csv, format: 'csv' };
+  }
+
+  generateCSVContent() {
+    const headers = ['File Path', 'Lines', 'Priority', 'Complexity', 'Needs Refactoring', 'Recommendation'];
+    const rows = this.report.fileAnalysis.map(f => [
+      f.filePath,
+      f.lineCount,
+      f.priority,
+      f.getComplexityScore ? f.getComplexityScore() : '',
+      f.needsRefactoring ? 'Yes' : 'No',
+      f.recommendation || ''
+    ]);
+
+    const csvContent = [headers, ...rows]
+      .map(row => row.map(cell => `"${cell}"`).join(','))
+      .join('\n');
+
+    return csvContent;
+  }
+}
+
+module.exports = {
+  JSONReportGenerator,
+  HTMLReportGenerator,
+  CSVReportGenerator
+};

package/src/analysis/reports/statistics-calculator.js

@@ -0,0 +1,231 @@
+/**
+ * Statistics Calculator
+ * 
+ * Calculates various statistics and metrics for analysis reports.
+ */
+
+/**
+ * Statistics Calculator class
+ */
+class StatisticsCalculator {
+  constructor(report) {
+    this.report = report;
+  }
+
+  calculateAllStatistics() {
+    return {
+      fileStatistics: this.calculateFileStatistics(),
+      packageStatistics: this.calculatePackageStatistics(),
+      complexityStatistics: this.calculateComplexityStatistics(),
+      sizeStatistics: this.calculateSizeStatistics(),
+      complianceStatistics: this.calculateComplianceStatistics()
+    };
+  }
+
+  calculateFileStatistics() {
+    const files = this.report.fileAnalysis;
+    
+    return {
+      totalFiles: files.length,
+      filesNeedingRefactoring: files.filter(f => f.needsRefactoring).length,
+      averageFileSize: this.calculateAverage(files.map(f => f.lineCount)),
+      medianFileSize: this.calculateMedian(files.map(f => f.lineCount)),
+      largestFile: this.findLargestFile(),
+      smallestFile: this.findSmallestFile(),
+      sizeDistribution: this.calculateDistribution(files.map(f => f.lineCount))
+    };
+  }
+
+  calculatePackageStatistics() {
+    const packages = this.report.packageAnalysis;
+    
+    return {
+      totalPackages: Object.keys(packages).length,
+      packagePriorityDistribution: this.calculatePackagePriorityDistribution(),
+      largestPackage: this.findLargestPackage(),
+      mostComplexPackage: this.findMostComplexPackage(),
+      packagesNeedingRefactoring: Object.values(packages).filter(p => p.filesNeedingRefactoring > 0).length
+    };
+  }
+
+  calculateComplexityStatistics() {
+    const complexities = this.report.fileAnalysis
+      .map(f => f.getComplexityScore ? f.getComplexityScore() : 0)
+      .filter(c => c > 0);
+
+    return {
+      averageComplexity: this.calculateAverage(complexities),
+      medianComplexity: this.calculateMedian(complexities),
+      highestComplexity: Math.max(...complexities, 0),
+      lowestComplexity: Math.min(...complexities, 0),
+      complexityDistribution: this.calculateDistribution(complexities)
+    };
+  }
+
+  calculateSizeStatistics() {
+    const totalLines = this.report.summary.totalLines;
+    const filesNeedingRefactoring = this.report.summary.filesNeedingRefactoring;
+    
+    return {
+      totalLinesOfCode: totalLines,
+      linesInViolatingFiles: this.calculateLinesInViolatingFiles(),
+      refactoringEffort: this.calculateTotalEffort(),
+      potentialLineReduction: this.calculatePotentialLineReduction()
+    };
+  }
+
+  calculateComplianceStatistics() {
+    const totalFiles = this.report.summary.totalFiles;
+    const compliantFiles = totalFiles - this.report.summary.filesNeedingRefactoring;
+    
+    return {
+      complianceRate: this.report.summary.complianceRate,
+      compliantFiles,
+      nonCompliantFiles: this.report.summary.filesNeedingRefactoring,
+      urgentFiles: this.report.summary.urgentRefactoring,
+      highPriorityFiles: this.report.fileAnalysis.filter(f => f.priority === 'high').length,
+      mediumPriorityFiles: this.report.fileAnalysis.filter(f => f.priority === 'medium').length,
+      lowPriorityFiles: this.report.fileAnalysis.filter(f => f.priority === 'low').length
+    };
+  }
+
+  // Helper methods
+  calculateAverage(values) {
+    if (values.length === 0) return 0;
+    return values.reduce((sum, val) => sum + val, 0) / values.length;
+  }
+
+  calculateMedian(values) {
+    if (values.length === 0) return 0;
+    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];
+  }
+
+  calculateDistribution(values) {
+    const distribution = { '0-5': 0, '6-10': 0, '11-20': 0, '21+': 0 };
+    for (const value of values) {
+      if (value <= 5) distribution['0-5']++;
+      else if (value <= 10) distribution['6-10']++;
+      else if (value <= 20) distribution['11-20']++;
+      else distribution['21+']++;
+    }
+    return distribution;
+  }
+
+  findLargestFile() {
+    let largest = null;
+    let maxLines = 0;
+    
+    for (const fileAnalysis of this.report.fileAnalysis) {
+      if (fileAnalysis.lineCount > maxLines) {
+        maxLines = fileAnalysis.lineCount;
+        largest = {
+          path: fileAnalysis.filePath,
+          lines: fileAnalysis.lineCount,
+          priority: fileAnalysis.priority
+        };
+      }
+    }
+    
+    return largest;
+  }
+
+  findSmallestFile() {
+    let smallest = null;
+    let minLines = Infinity;
+    
+    for (const fileAnalysis of this.report.fileAnalysis) {
+      if (fileAnalysis.lineCount < minLines) {
+        minLines = fileAnalysis.lineCount;
+        smallest = {
+          path: fileAnalysis.filePath,
+          lines: fileAnalysis.lineCount,
+          priority: fileAnalysis.priority
+        };
+      }
+    }
+    
+    return smallest;
+  }
+
+  calculatePackagePriorityDistribution() {
+    const distribution = { critical: 0, high: 0, medium: 0, low: 0 };
+    for (const packageData of Object.values(this.report.packageAnalysis)) {
+      distribution[packageData.priority]++;
+    }
+    return distribution;
+  }
+
+  findLargestPackage() {
+    let largest = null;
+    let maxLines = 0;
+    
+    for (const [packageName, packageData] of Object.entries(this.report.packageAnalysis)) {
+      if (packageData.totalLines > maxLines) {
+        maxLines = packageData.totalLines;
+        largest = { 
+          name: packageName, 
+          lines: packageData.totalLines, 
+          files: packageData.files.length 
+        };
+      }
+    }
+    
+    return largest;
+  }
+
+  findMostComplexPackage() {
+    let mostComplex = null;
+    let maxComplexity = 0;
+    
+    for (const [packageName, packageData] of Object.entries(this.report.packageAnalysis)) {
+      if (packageData.averageComplexity > maxComplexity) {
+        maxComplexity = packageData.averageComplexity;
+        mostComplex = { 
+          name: packageName, 
+          complexity: packageData.averageComplexity 
+        };
+      }
+    }
+    
+    return mostComplex;
+  }
+
+  calculateLinesInViolatingFiles() {
+    return this.report.fileAnalysis
+      .filter(f => f.needsRefactoring)
+      .reduce((sum, f) => sum + f.lineCount, 0);
+  }
+
+  calculateTotalEffort() {
+    let totalEffort = 0;
+    for (const fileAnalysis of this.report.fileAnalysis) {
+      if (fileAnalysis.needsRefactoring) {
+        // Simple effort calculation based on line count and complexity
+        const lineEffort = Math.ceil(fileAnalysis.lineCount / 100);
+        const complexity = fileAnalysis.getComplexityScore ? fileAnalysis.getComplexityScore() : 0;
+        const complexityEffort = Math.ceil(complexity / 20);
+        totalEffort += lineEffort + complexityEffort;
+      }
+    }
+    return totalEffort;
+  }
+
+  calculatePotentialLineReduction() {
+    // Estimate potential line reduction from refactoring
+    const violatingFiles = this.report.fileAnalysis.filter(f => f.needsRefactoring);
+    let potentialReduction = 0;
+    
+    for (const file of violatingFiles) {
+      // Assume 10-30% reduction based on file size and complexity
+      const reductionRate = file.lineCount > 1000 ? 0.3 : (file.lineCount > 500 ? 0.2 : 0.1);
+      potentialReduction += Math.floor(file.lineCount * reductionRate);
+    }
+    
+    return potentialReduction;
+  }
+}
+
+module.exports = StatisticsCalculator;