vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

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

@@ -0,0 +1,382 @@
+/**
+ * Recommendation Generator for Analysis Reports
+ */
+
+/**
+ * Generate refactoring recommendations based on analysis data
+ */
+class RecommendationGenerator {
+  constructor() {
+    this.recommendationTypes = {
+      URGENT: 'Files requiring immediate attention',
+      SIZE: 'File size violations',
+      COMPLEXITY: 'High complexity files',
+      DEPENDENCY: 'Dependency issues',
+      VIOLATION: 'Code quality violations',
+      STRATEGY: 'Refactoring strategies'
+    };
+  }
+
+  /**
+   * Generate all recommendations
+   * @param {Object} analysisData - Complete analysis data
+   * @returns {Array} Array of recommendations
+   */
+  generateRecommendations(analysisData) {
+    const recommendations = [];
+    
+    // Generate urgent file recommendations
+    recommendations.push(...this.generateUrgentRecommendations(analysisData));
+    
+    // Generate size-based recommendations
+    recommendations.push(...this.generateSizeRecommendations(analysisData));
+    
+    // Generate complexity recommendations
+    recommendations.push(...this.generateComplexityRecommendations(analysisData));
+    
+    // Generate dependency recommendations
+    recommendations.push(...this.generateDependencyRecommendations(analysisData));
+    
+    // Generate violation recommendations
+    recommendations.push(...this.generateViolationRecommendations(analysisData));
+    
+    // Generate strategic recommendations
+    recommendations.push(...this.generateStrategicRecommendations(analysisData));
+    
+    // Sort by priority
+    return recommendations.sort((a, b) => this.getPriorityScore(b) - this.getPriorityScore(a));
+  }
+
+  /**
+   * Generate urgent file recommendations
+   * @param {Object} analysisData - Analysis data
+   * @returns {Array} Urgent recommendations
+   */
+  generateUrgentRecommendations(analysisData) {
+    const recommendations = [];
+    const urgentFiles = analysisData.files ? analysisData.files.filter(f => f.urgentRefactoring) : [];
+    
+    if (urgentFiles.length > 0) {
+      recommendations.push({
+        type: 'URGENT',
+        priority: 'CRITICAL',
+        title: 'Urgent Refactoring Required',
+        message: `${urgentFiles.length} files require immediate refactoring attention`,
+        details: {
+          fileCount: urgentFiles.length,
+          totalLines: urgentFiles.reduce((sum, f) => sum + f.lineCount, 0),
+          files: urgentFiles.map(f => ({
+            path: f.filePath,
+            lines: f.lineCount,
+            violations: f.violations ? f.violations.length : 0
+          }))
+        },
+        action: 'Address these files first to reduce technical debt',
+        estimatedEffort: this.estimateEffort(urgentFiles)
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Generate size-based recommendations
+   * @param {Object} analysisData - Analysis data
+   * @returns {Array} Size recommendations
+   */
+  generateSizeRecommendations(analysisData) {
+    const recommendations = [];
+    const files = analysisData.files || [];
+    
+    // XLARGE files (>1000 lines)
+    const xlargeFiles = files.filter(f => f.sizeCategory === 'XLARGE');
+    if (xlargeFiles.length > 0) {
+      recommendations.push({
+        type: 'SIZE',
+        priority: 'HIGH',
+        title: 'XLARGE Files Detected',
+        message: `${xlargeFiles.length} files exceed 1000 lines`,
+        details: {
+          fileCount: xlargeFiles.length,
+          totalLines: xlargeFiles.reduce((sum, f) => sum + f.lineCount, 0),
+          averageLines: Math.round(xlargeFiles.reduce((sum, f) => sum + f.lineCount, 0) / xlargeFiles.length),
+          files: xlargeFiles.map(f => ({
+            path: f.filePath,
+            lines: f.lineCount
+          }))
+        },
+        action: 'Break down XLARGE files into smaller, focused modules',
+        estimatedEffort: this.estimateEffort(xlargeFiles)
+      });
+    }
+    
+    // LARGE files (555-1000 lines)
+    const largeFiles = files.filter(f => f.sizeCategory === 'LARGE');
+    if (largeFiles.length > 0) {
+      recommendations.push({
+        type: 'SIZE',
+        priority: 'MEDIUM',
+        title: 'LARGE Files Detected',
+        message: `${largeFiles.length} files exceed 555 lines`,
+        details: {
+          fileCount: largeFiles.length,
+          totalLines: largeFiles.reduce((sum, f) => sum + f.lineCount, 0),
+          averageLines: Math.round(largeFiles.reduce((sum, f) => sum + f.lineCount, 0) / largeFiles.length),
+          files: largeFiles.map(f => ({
+            path: f.filePath,
+            lines: f.lineCount
+          }))
+        },
+        action: 'Consider refactoring LARGE files to improve maintainability',
+        estimatedEffort: this.estimateEffort(largeFiles)
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Generate complexity recommendations
+   * @param {Object} analysisData - Analysis data
+   * @returns {Array} Complexity recommendations
+   */
+  generateComplexityRecommendations(analysisData) {
+    const recommendations = [];
+    const files = analysisData.files || [];
+    
+    // High complexity files
+    const highComplexityFiles = files.filter(f => {
+      const score = f.getComplexityScore ? f.getComplexityScore() : 0;
+      return score > 50;
+    });
+    
+    if (highComplexityFiles.length > 0) {
+      recommendations.push({
+        type: 'COMPLEXITY',
+        priority: 'MEDIUM',
+        title: 'High Complexity Files',
+        message: `${highComplexityFiles.length} files have high complexity scores`,
+        details: {
+          fileCount: highComplexityFiles.length,
+          averageComplexity: Math.round(highComplexityFiles.reduce((sum, f) => sum + (f.getComplexityScore ? f.getComplexityScore() : 0), 0) / highComplexityFiles.length),
+          files: highComplexityFiles.map(f => ({
+            path: f.filePath,
+            complexity: f.getComplexityScore ? f.getComplexityScore() : 0,
+            lines: f.lineCount
+          }))
+        },
+        action: 'Simplify complex files through better separation of concerns',
+        estimatedEffort: this.estimateEffort(highComplexityFiles)
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Generate dependency recommendations
+   * @param {Object} analysisData - Analysis data
+   * @returns {Array} Dependency recommendations
+   */
+  generateDependencyRecommendations(analysisData) {
+    const recommendations = [];
+    const files = analysisData.files || [];
+    
+    // Files with circular dependencies
+    const circularDepFiles = files.filter(f => f.hasCircularDependencies);
+    if (circularDepFiles.length > 0) {
+      recommendations.push({
+        type: 'DEPENDENCY',
+        priority: 'HIGH',
+        title: 'Circular Dependencies Detected',
+        message: `${circularDepFiles.length} files have circular dependencies`,
+        details: {
+          fileCount: circularDepFiles.length,
+          files: circularDepFiles.map(f => ({
+            path: f.filePath,
+            circularDependencies: f.circularDependencies || []
+          }))
+        },
+        action: 'Resolve circular dependencies to improve code structure',
+        estimatedEffort: this.estimateEffort(circularDepFiles)
+      });
+    }
+    
+    // Files with too many dependencies
+    const highDepFiles = files.filter(f => f.dependencyCount && f.dependencyCount > 20);
+    if (highDepFiles.length > 0) {
+      recommendations.push({
+        type: 'DEPENDENCY',
+        priority: 'MEDIUM',
+        title: 'High Dependency Count',
+        message: `${highDepFiles.length} files have excessive dependencies`,
+        details: {
+          fileCount: highDepFiles.length,
+          averageDependencies: Math.round(highDepFiles.reduce((sum, f) => sum + (f.dependencyCount || 0), 0) / highDepFiles.length),
+          files: highDepFiles.map(f => ({
+            path: f.filePath,
+            dependencies: f.dependencyCount || 0
+          }))
+        },
+        action: 'Reduce dependencies through better encapsulation',
+        estimatedEffort: this.estimateEffort(highDepFiles)
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Generate violation recommendations
+   * @param {Object} analysisData - Analysis data
+   * @returns {Array} Violation recommendations
+   */
+  generateViolationRecommendations(analysisData) {
+    const recommendations = [];
+    const files = analysisData.files || [];
+    
+    // Files with violations
+    const violationFiles = files.filter(f => f.violations && f.violations.length > 0);
+    if (violationFiles.length > 0) {
+      const totalViolations = violationFiles.reduce((sum, f) => sum + f.violations.length, 0);
+      
+      recommendations.push({
+        type: 'VIOLATION',
+        priority: 'MEDIUM',
+        title: 'Code Quality Violations',
+        message: `${totalViolations} code quality violations found`,
+        details: {
+          fileCount: violationFiles.length,
+          totalViolations,
+          violationTypes: this.categorizeViolations(violationFiles),
+          files: violationFiles.map(f => ({
+            path: f.filePath,
+            violations: f.violations.length,
+            types: f.violations.map(v => v.type)
+          }))
+        },
+        action: 'Address code quality violations to improve maintainability',
+        estimatedEffort: this.estimateEffort(violationFiles)
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Generate strategic recommendations
+   * @param {Object} analysisData - Analysis data
+   * @returns {Array} Strategic recommendations
+   */
+  generateStrategicRecommendations(analysisData) {
+    const recommendations = [];
+    const files = analysisData.files || [];
+    
+    // Overall compliance strategy
+    const complianceRate = this.calculateComplianceRate(files);
+    if (complianceRate < 80) {
+      recommendations.push({
+        type: 'STRATEGY',
+        priority: 'HIGH',
+        title: 'Compliance Improvement Strategy',
+        message: `Overall compliance rate is ${complianceRate}%`,
+        details: {
+          currentRate: complianceRate,
+          targetRate: 100,
+          gap: 100 - complianceRate,
+          filesToAddress: files.filter(f => f.needsRefactoring).length
+        },
+        action: 'Implement systematic refactoring approach to achieve 100% compliance',
+        estimatedEffort: 'Medium to High'
+      });
+    }
+    
+    // Package-level strategy
+    if (analysisData.packageAnalysis) {
+      const highRiskPackages = Object.entries(analysisData.packageAnalysis)
+        .filter(([_, analysis]) => analysis.riskScore > 50);
+      
+      if (highRiskPackages.length > 0) {
+        recommendations.push({
+          type: 'STRATEGY',
+          priority: 'MEDIUM',
+          title: 'Package-Level Refactoring Strategy',
+          message: `${highRiskPackages.length} packages require strategic refactoring`,
+          details: {
+            packageCount: highRiskPackages.length,
+            packages: highRiskPackages.map(([name, analysis]) => ({
+              name,
+              riskScore: analysis.riskScore,
+              complianceRate: analysis.complianceRate
+            }))
+          },
+          action: 'Focus on high-risk packages first for maximum impact',
+          estimatedEffort: 'Medium'
+        });
+      }
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Categorize violations
+   * @param {Array} files - Files with violations
+   * @returns {Object} Violation categories
+   */
+  categorizeViolations(files) {
+    const categories = {};
+    
+    for (const file of files) {
+      for (const violation of file.violations || []) {
+        const type = violation.type || 'UNKNOWN';
+        categories[type] = (categories[type] || 0) + 1;
+      }
+    }
+    
+    return categories;
+  }
+
+  /**
+   * Calculate compliance rate
+   * @param {Array} files - Files to analyze
+   * @returns {number} Compliance rate percentage
+   */
+  calculateComplianceRate(files) {
+    if (files.length === 0) return 100;
+    const compliantFiles = files.filter(f => !f.needsRefactoring).length;
+    return Math.round((compliantFiles / files.length) * 100);
+  }
+
+  /**
+   * Estimate refactoring effort
+   * @param {Array} files - Files to refactor
+   * @returns {string} Effort estimate
+   */
+  estimateEffort(files) {
+    const totalLines = files.reduce((sum, f) => sum + f.lineCount, 0);
+    
+    if (totalLines < 500) return 'Low';
+    if (totalLines < 2000) return 'Medium';
+    if (totalLines < 5000) return 'High';
+    return 'Very High';
+  }
+
+  /**
+   * Get priority score for sorting
+   * @param {Object} recommendation - Recommendation object
+   * @returns {number} Priority score
+   */
+  getPriorityScore(recommendation) {
+    const priorityScores = {
+      'CRITICAL': 100,
+      'HIGH': 75,
+      'MEDIUM': 50,
+      'LOW': 25
+    };
+    
+    return priorityScores[recommendation.priority] || 0;
+  }
+}
+
+module.exports = RecommendationGenerator;