vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/analysis/priority-calculator.js

@@ -0,0 +1,679 @@
+/**
+ * Priority Calculator
+ * 
+ * Calculates refactoring priorities based on multiple factors.
+ * Provides consistent, data-driven priority assessment.
+ */
+
+const RefactoringConfig = require('../config/refactoring-config');
+
+/**
+ * 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;
+    this.weights = this.getDefaultWeights();
+    this.thresholds = this.getDefaultThresholds();
+  }
+
+  /**
+   * Get default factor weights
+   */
+  getDefaultWeights() {
+    return {
+      [PRIORITY_FACTORS.SIZE_VIOLATION]: 0.4,
+      [PRIORITY_FACTORS.COMPLEXITY]: 0.25,
+      [PRIORITY_FACTORS.DEPENDENCY_COUNT]: 0.15,
+      [PRIORITY_FACTORS.PACKAGE_IMPORTANCE]: 0.1,
+      [PRIORITY_FACTORS.CHANGE_FREQUENCY]: 0.05,
+      [PRIORITY_FACTORS.TEST_COVERAGE]: 0.03,
+      [PRIORITY_FACTORS.BUSINESS_IMPACT]: 0.02
+    };
+  }
+
+  /**
+   * Get default priority thresholds
+   */
+  getDefaultThresholds() {
+    return {
+      [PRIORITY_LEVELS.CRITICAL]: 0.8,
+      [PRIORITY_LEVELS.HIGH]: 0.6,
+      [PRIORITY_LEVELS.MEDIUM]: 0.4,
+      [PRIORITY_LEVELS.LOW]: 0.2,
+      [PRIORITY_LEVELS.NONE]: 0
+    };
+  }
+
+  /**
+   * 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
+    const totalScore = result.getTotalWeightedScore();
+    
+    // Determine priority based on thresholds
+    const priority = this.determinePriority(totalScore);
+    
+    result.setPriority(priority, totalScore);
+    this.generateReasonsAndRecommendations(fileAnalysis, 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;
+    }
+    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;
+  }
+
+  /**
+   * Get priority summary
+   */
+  getPrioritySummary(priorityResults) {
+    const summary = {
+      total: priorityResults.length,
+      byPriority: {
+        [PRIORITY_LEVELS.CRITICAL]: 0,
+        [PRIORITY_LEVELS.HIGH]: 0,
+        [PRIORITY_LEVELS.MEDIUM]: 0,
+        [PRIORITY_LEVELS.LOW]: 0,
+        [PRIORITY_LEVELS.NONE]: 0
+      },
+      averageScore: 0,
+      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,
+      [PRIORITY_LEVELS.HIGH]: 1,
+      [PRIORITY_LEVELS.MEDIUM]: 2,
+      [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
+      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);
+  }
+}
+
+module.exports = {
+  PriorityCalculator,
+  PriorityResult,
+  PRIORITY_LEVELS,
+  PRIORITY_FACTORS
+};