vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/analysis/reports/trend-analyzer.js

@@ -0,0 +1,219 @@
+/**
+ * Trend Analyzer
+ * 
+ * Analyzes trends in file sizes, complexity, and refactoring progress.
+ */
+
+/**
+ * Trend Analyzer class
+ */
+class TrendAnalyzer {
+  constructor(report) {
+    this.report = report;
+  }
+
+  analyzeAllTrends() {
+    return {
+      sizeTrends: this.analyzeSizeTrends(),
+      complexityTrends: this.analyzeComplexityTrends(),
+      packageTrends: this.analyzePackageTrends(),
+      refactoringTrends: this.analyzeRefactoringTrends(),
+      complianceTrends: this.analyzeComplianceTrends()
+    };
+  }
+
+  analyzeSizeTrends() {
+    // For now, provide baseline analysis
+    // In future versions, this could compare with historical data
+    const files = this.report.fileAnalysis;
+    const sizeCategories = this.categorizeFileSizes(files);
+    
+    return {
+      increasing: 0, // Would need historical data
+      decreasing: 0, // Would need historical data
+      stable: files.length,
+      sizeDistribution: sizeCategories,
+      averageGrowthRate: 0, // Would need historical data
+      largestGrowthFile: null,
+      largestReductionFile: null
+    };
+  }
+
+  analyzeComplexityTrends() {
+    // For now, provide baseline analysis
+    const files = this.report.fileAnalysis;
+    const complexityCategories = this.categorizeComplexity(files);
+    
+    return {
+      improving: 0, // Would need historical data
+      degrading: 0, // Would need historical data
+      stable: files.length,
+      complexityDistribution: complexityCategories,
+      averageComplexityChange: 0,
+      mostImprovedFile: null,
+      mostDegradedFile: null
+    };
+  }
+
+  analyzePackageTrends() {
+    const packages = this.report.packageAnalysis;
+    
+    return {
+      growing: Object.keys(packages).length,
+      shrinking: 0,
+      stable: 0,
+      packageCountTrend: 'stable',
+      averagePackageSize: this.calculateAveragePackageSize(packages),
+      largestGrowingPackage: null,
+      fastestShrinkingPackage: null
+    };
+  }
+
+  analyzeRefactoringTrends() {
+    // For now, provide baseline analysis
+    const filesNeedingRefactoring = this.report.summary.filesNeedingRefactoring;
+    
+    return {
+      completed: 0, // Would need historical data
+      inProgress: 0, // Would need historical data
+      planned: filesNeedingRefactoring,
+      completionRate: 0,
+      averageRefactoringTime: 0,
+      estimatedTotalTime: this.estimateTotalRefactoringTime(),
+      refactoringVelocity: 0
+    };
+  }
+
+  analyzeComplianceTrends() {
+    const currentCompliance = parseFloat(this.report.summary.complianceRate);
+    
+    return {
+      currentComplianceRate: currentCompliance,
+      targetComplianceRate: 100,
+      gapToTarget: 100 - currentCompliance,
+      improvementRate: 0, // Would need historical data
+      estimatedTimeToCompliance: this.estimateTimeToCompliance(currentCompliance),
+      complianceTrajectory: 'stable'
+    };
+  }
+
+  // Helper methods
+  categorizeFileSizes(files) {
+    const categories = {
+      small: 0,    // < 100 lines
+      medium: 0,   // 100-300 lines
+      large: 0,    // 301-555 lines
+      xlarge: 0    // > 555 lines
+    };
+
+    for (const file of files) {
+      if (file.lineCount < 100) categories.small++;
+      else if (file.lineCount <= 300) categories.medium++;
+      else if (file.lineCount <= 555) categories.large++;
+      else categories.xlarge++;
+    }
+
+    return categories;
+  }
+
+  categorizeComplexity(files) {
+    const categories = {
+      low: 0,      // 0-20
+      medium: 0,   // 21-50
+      high: 0,     // 51-100
+      critical: 0  // > 100
+    };
+
+    for (const file of files) {
+      const complexity = file.getComplexityScore ? file.getComplexityScore() : 0;
+      if (complexity <= 20) categories.low++;
+      else if (complexity <= 50) categories.medium++;
+      else if (complexity <= 100) categories.high++;
+      else categories.critical++;
+    }
+
+    return categories;
+  }
+
+  calculateAveragePackageSize(packages) {
+    const packageSizes = Object.values(packages).map(p => p.totalLines);
+    if (packageSizes.length === 0) return 0;
+    
+    const total = packageSizes.reduce((sum, size) => sum + size, 0);
+    return Math.round(total / packageSizes.length);
+  }
+
+  estimateTotalRefactoringTime() {
+    const filesNeedingRefactoring = this.report.summary.filesNeedingRefactoring;
+    const totalLines = this.report.fileAnalysis
+      .filter(f => f.needsRefactoring)
+      .reduce((sum, f) => sum + f.lineCount, 0);
+    
+    // Estimate: 1 hour per 100 lines, plus complexity factor
+    const baseTime = Math.ceil(totalLines / 100);
+    const complexityFactor = this.calculateComplexityFactor();
+    
+    return baseTime * complexityFactor;
+  }
+
+  calculateComplexityFactor() {
+    const avgComplexity = parseFloat(this.report.summary.averageComplexity);
+    
+    // Complexity multiplier based on average complexity
+    if (avgComplexity <= 20) return 1.0;
+    if (avgComplexity <= 50) return 1.5;
+    if (avgComplexity <= 100) return 2.0;
+    return 3.0;
+  }
+
+  estimateTimeToCompliance(currentCompliance) {
+    if (currentCompliance >= 100) return 0;
+    
+    const filesNeedingRefactoring = this.report.summary.filesNeedingRefactoring;
+    const estimatedTimePerFile = 2; // hours per file average
+    
+    const totalHours = filesNeedingRefactoring * estimatedTimePerFile;
+    const days = Math.ceil(totalHours / 8); // Assuming 8-hour workdays
+    
+    return days;
+  }
+
+  generateTrendSummary() {
+    const trends = this.analyzeAllTrends();
+    
+    return {
+      overall: 'stable',
+      keyInsights: [
+        `${this.report.summary.filesNeedingRefactoring} files need refactoring to achieve 100% compliance`,
+        `Estimated ${trends.refactoringTrends.estimatedTotalTime} hours of refactoring work remaining`,
+        `Current compliance rate: ${this.report.summary.complianceRate}%`,
+        `${trends.complianceTrends.estimatedTimeToCompliance} days estimated to reach full compliance`
+      ],
+      recommendations: this.generateTrendRecommendations(trends)
+    };
+  }
+
+  generateTrendRecommendations(trends) {
+    const recommendations = [];
+    
+    if (trends.complianceTrends.currentComplianceRate < 80) {
+      recommendations.push('Focus on high-priority files first to improve compliance rate quickly');
+    }
+    
+    if (trends.refactoringTrends.estimatedTotalTime > 40) {
+      recommendations.push('Consider parallel refactoring efforts to reduce total time');
+    }
+    
+    if (trends.sizeTrends.sizeDistribution.xlarge > 10) {
+      recommendations.push('Prioritize extra-large files as they contribute most to violations');
+    }
+    
+    if (trends.complexityTrends.complexityDistribution.critical > 5) {
+      recommendations.push('Address critical complexity files early to prevent further issues');
+    }
+    
+    return recommendations;
+  }
+}
+
+module.exports = TrendAnalyzer;