vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/analysis/priority-calculator.js

@@ -1,88 +1,15 @@
 /**
  * Priority Calculator
- * 
+ *
  * Calculates refactoring priorities based on multiple factors.
- * Provides consistent, data-driven priority assessment.
+ * Factor logic lives in analysis/priority/ (factor-calculators, reasons-generator).
  */
 
 const RefactoringConfig = require('../config/refactoring-config');
+const { PRIORITY_LEVELS, PRIORITY_FACTORS, PriorityResult } = require('./priority/priority-constants');
+const { runAllFactors } = require('./priority/factor-calculators');
+const { generateReasonsAndRecommendations } = require('./priority/reasons-generator');
 
-/**
- * Priority levels
- */
-const PRIORITY_LEVELS = {
-  CRITICAL: 'critical',
-  HIGH: 'high',
-  MEDIUM: 'medium',
-  LOW: 'low',
-  NONE: 'none'
-};
-
-/**
- * Priority factors
- */
-const PRIORITY_FACTORS = {
-  SIZE_VIOLATION: 'size_violation',
-  COMPLEXITY: 'complexity',
-  DEPENDENCY_COUNT: 'dependency_count',
-  CHANGE_FREQUENCY: 'change_frequency',
-  PACKAGE_IMPORTANCE: 'package_importance',
-  TEST_COVERAGE: 'test_coverage',
-  BUSINESS_IMPACT: 'business_impact'
-};
-
-/**
- * Priority calculation result class
- */
-class PriorityResult {
-  constructor(filePath) {
-    this.filePath = filePath;
-    this.priority = PRIORITY_LEVELS.NONE;
-    this.score = 0;
-    this.factors = {};
-    this.reasons = [];
-    this.recommendations = [];
-    this.metadata = {
-      calculatedAt: new Date().toISOString(),
-      version: '1.0.0'
-    };
-  }
-
-  addFactor(factorName, score, weight, details = {}) {
-    this.factors[factorName] = {
-      score,
-      weight,
-      weightedScore: score * weight,
-      details
-    };
-  }
-
-  addReason(reason) {
-    this.reasons.push(reason);
-  }
-
-  addRecommendation(recommendation) {
-    this.recommendations.push(recommendation);
-  }
-
-  setPriority(priority, score) {
-    this.priority = priority;
-    this.score = score;
-  }
-
-  getFactorScore(factorName) {
-    return this.factors[factorName]?.weightedScore || 0;
-  }
-
-  getTotalWeightedScore() {
-    return Object.values(this.factors)
-      .reduce((sum, factor) => sum + factor.weightedScore, 0);
-  }
-}
-
-/**
- * Priority calculator class
- */
 class PriorityCalculator {
   constructor(config = RefactoringConfig) {
     this.config = config;
@@ -90,9 +17,6 @@ class PriorityCalculator {
     this.thresholds = this.getDefaultThresholds();
   }
 
-  /**
-   * Get default factor weights
-   */
   getDefaultWeights() {
     return {
       [PRIORITY_FACTORS.SIZE_VIOLATION]: 0.4,
@@ -105,9 +29,6 @@ class PriorityCalculator {
     };
   }
 
-  /**
-   * Get default priority thresholds
-   */
   getDefaultThresholds() {
     return {
       [PRIORITY_LEVELS.CRITICAL]: 0.8,
@@ -118,499 +39,28 @@ class PriorityCalculator {
     };
   }
 
-  /**
-   * Calculate priority for a file analysis
-   */
   calculatePriority(fileAnalysis) {
     const result = new PriorityResult(fileAnalysis.filePath);
-
-    // Calculate each factor
-    this.calculateSizeViolationFactor(fileAnalysis, result);
-    this.calculateComplexityFactor(fileAnalysis, result);
-    this.calculateDependencyFactor(fileAnalysis, result);
-    this.calculatePackageImportanceFactor(fileAnalysis, result);
-    this.calculateChangeFrequencyFactor(fileAnalysis, result);
-    this.calculateTestCoverageFactor(fileAnalysis, result);
-    this.calculateBusinessImpactFactor(fileAnalysis, result);
-
-    // Calculate total weighted score
+    runAllFactors(fileAnalysis, result, this.weights, this.config);
     const totalScore = result.getTotalWeightedScore();
-    
-    // Determine priority based on thresholds
     const priority = this.determinePriority(totalScore);
-    
     result.setPriority(priority, totalScore);
-    this.generateReasonsAndRecommendations(fileAnalysis, result);
-
+    generateReasonsAndRecommendations(result);
     return result;
   }
 
-  /**
-   * Calculate size violation factor
-   */
-  calculateSizeViolationFactor(fileAnalysis, result) {
-    const limits = this.config.limits;
-    let score = 0;
-    let details = {};
-
-    if (fileAnalysis.lineCount > limits.criticalThreshold) {
-      score = 1.0;
-      details.violation = 'critical';
-      details.excessLines = fileAnalysis.lineCount - limits.maxFileSize;
-      details.severity = 'critical';
-    } else if (fileAnalysis.lineCount > limits.maxFileSize) {
-      score = 0.8;
-      details.violation = 'major';
-      details.excessLines = fileAnalysis.lineCount - limits.maxFileSize;
-      details.severity = 'major';
-    } else if (fileAnalysis.lineCount > limits.warningThreshold) {
-      score = 0.6;
-      details.violation = 'minor';
-      details.excessLines = fileAnalysis.lineCount - limits.warningThreshold;
-      details.severity = 'minor';
-    } else if (fileAnalysis.lineCount > limits.mediumFileMax) {
-      score = 0.3;
-      details.violation = 'approaching';
-      details.excessLines = 0;
-      details.severity = 'low';
-    } else {
-      score = 0.0;
-      details.violation = 'none';
-      details.excessLines = 0;
-      details.severity = 'none';
-    }
-
-    details.lineCount = fileAnalysis.lineCount;
-    details.limit = limits.maxFileSize;
-    details.warningThreshold = limits.warningThreshold;
-
-    result.addFactor(PRIORITY_FACTORS.SIZE_VIOLATION, score, this.weights[PRIORITY_FACTORS.SIZE_VIOLATION], details);
-  }
-
-  /**
-   * Calculate complexity factor
-   */
-  calculateComplexityFactor(fileAnalysis, result) {
-    let score = 0;
-    let details = {};
-
-    // Use complexity score if available, otherwise calculate
-    const complexityScore = fileAnalysis.getComplexityScore ? 
-      fileAnalysis.getComplexityScore() : 
-      this.calculateComplexityScore(fileAnalysis);
-
-    if (complexityScore >= 80) {
-      score = 1.0;
-      details.level = 'very_high';
-    } else if (complexityScore >= 60) {
-      score = 0.8;
-      details.level = 'high';
-    } else if (complexityScore >= 40) {
-      score = 0.6;
-      details.level = 'medium';
-    } else if (complexityScore >= 20) {
-      score = 0.3;
-      details.level = 'low';
-    } else {
-      score = 0.0;
-      details.level = 'very_low';
-    }
-
-    details.complexityScore = complexityScore;
-    details.cyclomaticComplexity = fileAnalysis.cyclomaticComplexity || 0;
-    details.nestingDepth = fileAnalysis.nestingDepth || 0;
-    details.functionCount = fileAnalysis.functionCount || 0;
-    details.classCount = fileAnalysis.classCount || 0;
-
-    result.addFactor(PRIORITY_FACTORS.COMPLEXITY, score, this.weights[PRIORITY_FACTORS.COMPLEXITY], details);
-  }
-
-  /**
-   * Calculate dependency factor
-   */
-  calculateDependencyFactor(fileAnalysis, result) {
-    let score = 0;
-    let details = {};
-
-    const dependencyCount = fileAnalysis.dependencyCount || fileAnalysis.imports?.length || 0;
-    const dependentCount = fileAnalysis.dependents?.length || 0;
-
-    // Score based on total dependencies (incoming + outgoing)
-    const totalDependencies = dependencyCount + dependentCount;
-
-    if (totalDependencies > 20) {
-      score = 1.0;
-      details.level = 'very_high';
-    } else if (totalDependencies > 15) {
-      score = 0.8;
-      details.level = 'high';
-    } else if (totalDependencies > 10) {
-      score = 0.6;
-      details.level = 'medium';
-    } else if (totalDependencies > 5) {
-      score = 0.3;
-      details.level = 'low';
-    } else {
-      score = 0.0;
-      details.level = 'very_low';
-    }
-
-    details.dependencyCount = dependencyCount;
-    details.dependentCount = dependentCount;
-    details.totalDependencies = totalDependencies;
-    details.couplingRisk = this.assessCouplingRisk(totalDependencies);
-
-    result.addFactor(PRIORITY_FACTORS.DEPENDENCY_COUNT, score, this.weights[PRIORITY_FACTORS.DEPENDENCY_COUNT], details);
-  }
-
-  /**
-   * Calculate package importance factor
-   */
-  calculatePackageImportanceFactor(fileAnalysis, result) {
-    let score = 0;
-    let details = {};
-
-    const packageName = fileAnalysis.package || 'root';
-
-    // Package importance scoring
-    const packageImportance = {
-      'core': 1.0,
-      'cli': 0.8,
-      'electron-app': 0.7,
-      'web': 0.6,
-      'api-server': 0.6,
-      'chrome-extension': 0.5,
-      'mobile': 0.5,
-      'vscode-extension': 0.4,
-      'admin': 0.3,
-      'root': 0.2
-    };
-
-    score = packageImportance[packageName] || 0.2;
-    
-    details.packageName = packageName;
-    details.importance = score >= 0.8 ? 'critical' :
-                      score >= 0.6 ? 'high' :
-                      score >= 0.4 ? 'medium' : 'low';
-    details.isCorePackage = packageName === 'core';
-
-    result.addFactor(PRIORITY_FACTORS.PACKAGE_IMPORTANCE, score, this.weights[PRIORITY_FACTORS.PACKAGE_IMPORTANCE], details);
-  }
-
-  /**
-   * Calculate change frequency factor
-   */
-  calculateChangeFrequencyFactor(fileAnalysis, result) {
-    let score = 0;
-    let details = {};
-
-    // For now, use a simple heuristic based on file type and location
-    // In a real implementation, this would use git history or other metrics
-    const filePath = fileAnalysis.filePath;
-    
-    // Files that tend to change frequently
-    const highFrequencyPatterns = [
-      /config\//,
-      /\/bin\//,
-      /\/src\/main\//,
-      /package\.json$/,
-      /README\.md$/,
-      /\.config\./
-    ];
-
-    const mediumFrequencyPatterns = [
-      /\/src\/utils\//,
-      /\/src\/helpers\//,
-      /\/src\/services\//
-    ];
-
-    if (highFrequencyPatterns.some(pattern => pattern.test(filePath))) {
-      score = 0.8;
-      details.frequency = 'high';
-    } else if (mediumFrequencyPatterns.some(pattern => pattern.test(filePath))) {
-      score = 0.5;
-      details.frequency = 'medium';
-    } else {
-      score = 0.2;
-      details.frequency = 'low';
-    }
-
-    details.filePath = filePath;
-    details.lastModified = fileAnalysis.lastModified;
-    
-    // If we have last modified, use it to adjust score
-    if (fileAnalysis.lastModified) {
-      const daysSinceModified = (Date.now() - new Date(fileAnalysis.lastModified)) / (1000 * 60 * 60 * 24);
-      if (daysSinceModified < 7) {
-        score = Math.min(1.0, score + 0.2);
-        details.recentlyModified = true;
-      } else if (daysSinceModified < 30) {
-        score = Math.min(1.0, score + 0.1);
-        details.recentlyModified = false;
-      }
-    }
-
-    result.addFactor(PRIORITY_FACTORS.CHANGE_FREQUENCY, score, this.weights[PRIORITY_FACTORS.CHANGE_FREQUENCY], details);
-  }
-
-  /**
-   * Calculate test coverage factor
-   */
-  calculateTestCoverageFactor(fileAnalysis, result) {
-    let score = 0;
-    let details = {};
-
-    // Simple heuristic based on file type and naming
-    const filePath = fileAnalysis.filePath;
-    const isTestFile = fileAnalysis.isTestFile || /test|spec/.test(filePath);
-    
-    if (isTestFile) {
-      score = 0.0; // Test files themselves don't need refactoring priority
-      details.coverage = 'test_file';
-    } else {
-      // Look for corresponding test files
-      const hasTestFile = this.hasCorrespondingTestFile(filePath);
-      
-      if (hasTestFile) {
-        score = 0.2; // Lower priority if well tested
-        details.coverage = 'good';
-        details.testFile = this.findTestFile(filePath);
-      } else {
-        score = 0.6; // Higher priority if no tests
-        details.coverage = 'poor';
-        details.testFile = null;
-      }
-    }
-
-    details.filePath = filePath;
-    details.isTestFile = isTestFile;
-    details.impact = score > 0.4 ? 'high_risk' : 'low_risk';
-
-    result.addFactor(PRIORITY_FACTORS.TEST_COVERAGE, score, this.weights[PRIORITY_FACTORS.TEST_COVERAGE], details);
-  }
-
-  /**
-   * Calculate business impact factor
-   */
-  calculateBusinessImpactFactor(fileAnalysis, result) {
-    let score = 0;
-    let details = {};
-
-    const filePath = fileAnalysis.filePath;
-    
-    // Business critical file patterns
-    const criticalPatterns = [
-      /\/bin\//,
-      /\/src\/main\//,
-      /\/src\/app\//,
-      /\/src\/index\./,
-      /\/server\./,
-      /\/app\./
-    ];
-
-    // Important but not critical patterns
-    const importantPatterns = [
-      /\/src\/api\//,
-      /\/src\/controllers\//,
-      /\/src\/services\//,
-      /\/src\/models\//
-    ];
-
-    if (criticalPatterns.some(pattern => pattern.test(filePath))) {
-      score = 0.8;
-      details.impact = 'critical';
-    } else if (importantPatterns.some(pattern => pattern.test(filePath))) {
-      score = 0.5;
-      details.impact = 'important';
-    } else {
-      score = 0.2;
-      details.impact = 'standard';
-    }
-
-    details.filePath = filePath;
-    details.isBusinessCritical = score >= 0.8;
-
-    result.addFactor(PRIORITY_FACTORS.BUSINESS_IMPACT, score, this.weights[PRIORITY_FACTORS.BUSINESS_IMPACT], details);
-  }
-
-  /**
-   * Determine priority from score
-   */
   determinePriority(score) {
-    if (score >= this.thresholds[PRIORITY_LEVELS.CRITICAL]) {
-      return PRIORITY_LEVELS.CRITICAL;
-    } else if (score >= this.thresholds[PRIORITY_LEVELS.HIGH]) {
-      return PRIORITY_LEVELS.HIGH;
-    } else if (score >= this.thresholds[PRIORITY_LEVELS.MEDIUM]) {
-      return PRIORITY_LEVELS.MEDIUM;
-    } else if (score >= this.thresholds[PRIORITY_LEVELS.LOW]) {
-      return PRIORITY_LEVELS.LOW;
-    }
+    if (score >= this.thresholds[PRIORITY_LEVELS.CRITICAL]) return PRIORITY_LEVELS.CRITICAL;
+    if (score >= this.thresholds[PRIORITY_LEVELS.HIGH]) return PRIORITY_LEVELS.HIGH;
+    if (score >= this.thresholds[PRIORITY_LEVELS.MEDIUM]) return PRIORITY_LEVELS.MEDIUM;
+    if (score >= this.thresholds[PRIORITY_LEVELS.LOW]) return PRIORITY_LEVELS.LOW;
     return PRIORITY_LEVELS.NONE;
   }
 
-  /**
-   * Generate reasons and recommendations
-   */
-  generateReasonsAndRecommendations(fileAnalysis, result) {
-    const reasons = [];
-    const recommendations = [];
-
-    // Size-related reasons
-    const sizeFactor = result.factors[PRIORITY_FACTORS.SIZE_VIOLATION];
-    if (sizeFactor && sizeFactor.score > 0.6) {
-      reasons.push(`File has ${sizeFactor.details.excessLines} excess lines beyond limit`);
-      recommendations.push('Consider splitting large functions or extracting modules');
-    }
-
-    // Complexity-related reasons
-    const complexityFactor = result.factors[PRIORITY_FACTORS.COMPLEXITY];
-    if (complexityFactor && complexityFactor.score > 0.6) {
-      reasons.push(`File has ${complexityFactor.details.level} complexity`);
-      recommendations.push('Reduce complexity through better organization and smaller functions');
-    }
-
-    // Dependency-related reasons
-    const dependencyFactor = result.factors[PRIORITY_FACTORS.DEPENDENCY_COUNT];
-    if (dependencyFactor && dependencyFactor.score > 0.6) {
-      reasons.push(`File has ${dependencyFactor.details.totalDependencies} total dependencies`);
-      recommendations.push('Consider reducing dependencies through better separation of concerns');
-    }
-
-    // Package importance reasons
-    const packageFactor = result.factors[PRIORITY_FACTORS.PACKAGE_IMPORTANCE];
-    if (packageFactor && packageFactor.score > 0.8) {
-      reasons.push(`File is in ${packageFactor.details.importance} package (${packageFactor.details.packageName})`);
-      recommendations.push('Ensure high code quality for critical package files');
-    }
-
-    // Test coverage reasons
-    const testFactor = result.factors[PRIORITY_FACTORS.TEST_COVERAGE];
-    if (testFactor && testFactor.score > 0.4) {
-      reasons.push('File has poor or no test coverage');
-      recommendations.push('Add test coverage before refactoring to ensure safety');
-    }
-
-    // Business impact reasons
-    const businessFactor = result.factors[PRIORITY_FACTORS.BUSINESS_IMPACT];
-    if (businessFactor && businessFactor.score > 0.6) {
-      reasons.push(`File has ${businessFactor.details.impact} business impact`);
-      recommendations.push('Exercise extra caution when refactoring business-critical code');
-    }
-
-    result.reasons = reasons;
-    result.recommendations = recommendations;
-  }
-
-  /**
-   * Calculate complexity score for a file
-   */
-  calculateComplexityScore(fileAnalysis) {
-    let score = 0;
-    
-    // Line count contribution
-    if (fileAnalysis.lineCount > 1000) score += 30;
-    else if (fileAnalysis.lineCount > 555) score += 25;
-    else if (fileAnalysis.lineCount > 300) score += 15;
-    else if (fileAnalysis.lineCount > 100) score += 5;
-    
-    // Function count contribution
-    const functionCount = fileAnalysis.functionCount || 0;
-    if (functionCount > 20) score += 20;
-    else if (functionCount > 10) score += 15;
-    else if (functionCount > 5) score += 10;
-    else if (functionCount > 2) score += 5;
-    
-    // Class count contribution
-    const classCount = fileAnalysis.classCount || 0;
-    if (classCount > 5) score += 15;
-    else if (classCount > 3) score += 10;
-    else if (classCount > 1) score += 5;
-    
-    // Nesting depth contribution
-    const nestingDepth = fileAnalysis.nestingDepth || 0;
-    if (nestingDepth > 8) score += 15;
-    else if (nestingDepth > 5) score += 10;
-    else if (nestingDepth > 3) score += 5;
-    
-    // Dependency count contribution
-    const dependencyCount = fileAnalysis.dependencyCount || 0;
-    if (dependencyCount > 20) score += 20;
-    else if (dependencyCount > 10) score += 15;
-    else if (dependencyCount > 5) score += 10;
-    else if (dependencyCount > 2) score += 5;
-    
-    return Math.min(score, 100);
-  }
-
-  /**
-   * Assess coupling risk
-   */
-  assessCouplingRisk(dependencyCount) {
-    if (dependencyCount > 20) return 'very_high';
-    if (dependencyCount > 15) return 'high';
-    if (dependencyCount > 10) return 'medium';
-    if (dependencyCount > 5) return 'low';
-    return 'very_low';
-  }
-
-  /**
-   * Check if file has corresponding test file
-   */
-  hasCorrespondingTestFile(filePath) {
-    const testFile = this.findTestFile(filePath);
-    return testFile !== null;
-  }
-
-  /**
-   * Find test file for a given source file
-   */
-  findTestFile(filePath) {
-    const fs = require('fs');
-    const path = require('path');
-    
-    const dir = path.dirname(filePath);
-    const basename = path.basename(filePath, path.extname(filePath));
-    
-    const testPatterns = [
-      path.join(dir, `${basename}.test.js`),
-      path.join(dir, `${basename}.spec.js`),
-      path.join(dir, `${basename}.test.ts`),
-      path.join(dir, `${basename}.spec.ts`),
-      path.join(dir, '__tests__', `${basename}.js`),
-      path.join(dir, '__tests__', `${basename}.ts`),
-      path.join(dir, 'test', `${basename}.js`),
-      path.join(dir, 'test', `${basename}.ts`),
-      path.join(dir, 'tests', `${basename}.js`),
-      path.join(dir, 'tests', `${basename}.ts`)
-    ];
-    
-    for (const testPath of testPatterns) {
-      if (fs.existsSync(testPath)) {
-        return testPath;
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Calculate priorities for multiple files
-   */
   calculatePriorities(fileAnalyses) {
-    const results = [];
-    
-    for (const fileAnalysis of fileAnalyses) {
-      const result = this.calculatePriority(fileAnalysis);
-      results.push(result);
-    }
-    
-    return results;
+    return fileAnalyses.map(fa => this.calculatePriority(fa));
   }
 
-  /**
-   * Get priority summary
-   */
   getPrioritySummary(priorityResults) {
     const summary = {
       total: priorityResults.length,
@@ -625,24 +75,17 @@ class PriorityCalculator {
       highestScore: 0,
       lowestScore: 100
     };
-    
     let totalScore = 0;
-    
     for (const result of priorityResults) {
       summary.byPriority[result.priority]++;
       totalScore += result.score;
       summary.highestScore = Math.max(summary.highestScore, result.score);
       summary.lowestScore = Math.min(summary.lowestScore, result.score);
     }
-    
     summary.averageScore = summary.total > 0 ? totalScore / summary.total : 0;
-    
     return summary;
   }
 
-  /**
-   * Sort files by priority
-   */
   sortByPriority(priorityResults, descending = true) {
     const priorityOrder = {
       [PRIORITY_LEVELS.CRITICAL]: 0,
@@ -651,23 +94,15 @@ class PriorityCalculator {
       [PRIORITY_LEVELS.LOW]: 3,
       [PRIORITY_LEVELS.NONE]: 4
     };
-    
     return [...priorityResults].sort((a, b) => {
-      const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
-      if (priorityDiff !== 0) {
-        return priorityDiff;
-      }
-      
-      // If same priority, sort by score
+      const diff = priorityOrder[a.priority] - priorityOrder[b.priority];
+      if (diff !== 0) return diff;
       return descending ? b.score - a.score : a.score - b.score;
     });
   }
 
-  /**
-   * Get files by priority level
-   */
   getFilesByPriority(priorityResults, priorityLevel) {
-    return priorityResults.filter(result => result.priority === priorityLevel);
+    return priorityResults.filter(r => r.priority === priorityLevel);
   }
 }