vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/analysis/priority/factor-calculators.js

@@ -0,0 +1,204 @@
+/**
+ * Priority factor calculation functions.
+ * Each function adds one factor to the PriorityResult.
+ */
+
+const { PRIORITY_FACTORS } = require('./priority-constants');
+const { calculateComplexityScore, assessCouplingRisk, findTestFile } = require('./factor-helpers');
+
+function calculateSizeViolationFactor(fileAnalysis, result, weights, config) {
+  const limits = config.limits;
+  let score = 0;
+  const 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 {
+    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, weights[PRIORITY_FACTORS.SIZE_VIOLATION], details);
+}
+
+function calculateComplexityFactor(fileAnalysis, result, weights, _config) {
+  const complexityScore = fileAnalysis.getComplexityScore
+    ? fileAnalysis.getComplexityScore()
+    : calculateComplexityScore(fileAnalysis);
+  let score = 0;
+  let level = 'very_low';
+  if (complexityScore >= 80) {
+    score = 1.0;
+    level = 'very_high';
+  } else if (complexityScore >= 60) {
+    score = 0.8;
+    level = 'high';
+  } else if (complexityScore >= 40) {
+    score = 0.6;
+    level = 'medium';
+  } else if (complexityScore >= 20) {
+    score = 0.3;
+    level = 'low';
+  }
+  const details = {
+    complexityScore,
+    cyclomaticComplexity: fileAnalysis.cyclomaticComplexity || 0,
+    nestingDepth: fileAnalysis.nestingDepth || 0,
+    functionCount: fileAnalysis.functionCount || 0,
+    classCount: fileAnalysis.classCount || 0,
+    level
+  };
+  result.addFactor(PRIORITY_FACTORS.COMPLEXITY, score, weights[PRIORITY_FACTORS.COMPLEXITY], details);
+}
+
+function calculateDependencyFactor(fileAnalysis, result, weights, _config) {
+  const dependencyCount = fileAnalysis.dependencyCount || fileAnalysis.imports?.length || 0;
+  const dependentCount = fileAnalysis.dependents?.length || 0;
+  const totalDependencies = dependencyCount + dependentCount;
+  let score = 0;
+  let level = 'very_low';
+  if (totalDependencies > 20) {
+    score = 1.0;
+    level = 'very_high';
+  } else if (totalDependencies > 15) {
+    score = 0.8;
+    level = 'high';
+  } else if (totalDependencies > 10) {
+    score = 0.6;
+    level = 'medium';
+  } else if (totalDependencies > 5) {
+    score = 0.3;
+    level = 'low';
+  }
+  const details = {
+    dependencyCount,
+    dependentCount,
+    totalDependencies,
+    couplingRisk: assessCouplingRisk(totalDependencies),
+    level
+  };
+  result.addFactor(PRIORITY_FACTORS.DEPENDENCY_COUNT, score, weights[PRIORITY_FACTORS.DEPENDENCY_COUNT], details);
+}
+
+function calculatePackageImportanceFactor(fileAnalysis, result, weights, _config) {
+  const packageName = fileAnalysis.package || 'root';
+  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
+  };
+  const score = packageImportance[packageName] || 0.2;
+  const details = {
+    packageName,
+    importance: score >= 0.8 ? 'critical' : score >= 0.6 ? 'high' : score >= 0.4 ? 'medium' : 'low',
+    isCorePackage: packageName === 'core'
+  };
+  result.addFactor(PRIORITY_FACTORS.PACKAGE_IMPORTANCE, score, weights[PRIORITY_FACTORS.PACKAGE_IMPORTANCE], details);
+}
+
+function calculateChangeFrequencyFactor(fileAnalysis, result, weights, _config) {
+  const filePath = fileAnalysis.filePath;
+  const highFrequencyPatterns = [/config\//, /\/bin\//, /\/src\/main\//, /package\.json$/, /README\.md$/, /\.config\./];
+  const mediumFrequencyPatterns = [/\/src\/utils\//, /\/src\/helpers\//, /\/src\/services\//];
+  let score = 0.2;
+  let frequency = 'low';
+  if (highFrequencyPatterns.some(p => p.test(filePath))) {
+    score = 0.8;
+    frequency = 'high';
+  } else if (mediumFrequencyPatterns.some(p => p.test(filePath))) {
+    score = 0.5;
+    frequency = 'medium';
+  }
+  const details = { filePath, lastModified: fileAnalysis.lastModified, frequency };
+  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, weights[PRIORITY_FACTORS.CHANGE_FREQUENCY], details);
+}
+
+function calculateTestCoverageFactor(fileAnalysis, result, weights, _config) {
+  const filePath = fileAnalysis.filePath;
+  const isTestFile = fileAnalysis.isTestFile || /test|spec/.test(filePath);
+  let score = 0;
+  const details = { filePath, isTestFile };
+  if (isTestFile) {
+    details.coverage = 'test_file';
+  } else {
+    const testFile = findTestFile(filePath);
+    if (testFile) {
+      score = 0.2;
+      details.coverage = 'good';
+      details.testFile = testFile;
+    } else {
+      score = 0.6;
+      details.coverage = 'poor';
+      details.testFile = null;
+    }
+  }
+  details.impact = score > 0.4 ? 'high_risk' : 'low_risk';
+  result.addFactor(PRIORITY_FACTORS.TEST_COVERAGE, score, weights[PRIORITY_FACTORS.TEST_COVERAGE], details);
+}
+
+function calculateBusinessImpactFactor(fileAnalysis, result, weights, _config) {
+  const filePath = fileAnalysis.filePath;
+  const criticalPatterns = [/\/bin\//, /\/src\/main\//, /\/src\/app\//, /\/src\/index\./, /\/server\./, /\/app\./];
+  const importantPatterns = [/\/src\/api\//, /\/src\/controllers\//, /\/src\/services\//, /\/src\/models\//];
+  let score = 0.2;
+  let impact = 'standard';
+  if (criticalPatterns.some(p => p.test(filePath))) {
+    score = 0.8;
+    impact = 'critical';
+  } else if (importantPatterns.some(p => p.test(filePath))) {
+    score = 0.5;
+    impact = 'important';
+  }
+  const details = { filePath, impact, isBusinessCritical: score >= 0.8 };
+  result.addFactor(PRIORITY_FACTORS.BUSINESS_IMPACT, score, weights[PRIORITY_FACTORS.BUSINESS_IMPACT], details);
+}
+
+function runAllFactors(fileAnalysis, result, weights, config) {
+  calculateSizeViolationFactor(fileAnalysis, result, weights, config);
+  calculateComplexityFactor(fileAnalysis, result, weights, config);
+  calculateDependencyFactor(fileAnalysis, result, weights, config);
+  calculatePackageImportanceFactor(fileAnalysis, result, weights, config);
+  calculateChangeFrequencyFactor(fileAnalysis, result, weights, config);
+  calculateTestCoverageFactor(fileAnalysis, result, weights, config);
+  calculateBusinessImpactFactor(fileAnalysis, result, weights, config);
+}
+
+module.exports = {
+  runAllFactors,
+  calculateSizeViolationFactor,
+  calculateComplexityFactor,
+  calculateDependencyFactor,
+  calculatePackageImportanceFactor,
+  calculateChangeFrequencyFactor,
+  calculateTestCoverageFactor,
+  calculateBusinessImpactFactor
+};

package/src/analysis/priority/factor-helpers.js

@@ -0,0 +1,71 @@
+/**
+ * Helper functions used by priority factor calculators.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Calculate complexity score for a file (0-100)
+ */
+function calculateComplexityScore(fileAnalysis) {
+  let score = 0;
+  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;
+  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;
+  const classCount = fileAnalysis.classCount || 0;
+  if (classCount > 5) score += 15;
+  else if (classCount > 3) score += 10;
+  else if (classCount > 1) score += 5;
+  const nestingDepth = fileAnalysis.nestingDepth || 0;
+  if (nestingDepth > 8) score += 15;
+  else if (nestingDepth > 5) score += 10;
+  else if (nestingDepth > 3) score += 5;
+  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);
+}
+
+function 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';
+}
+
+function findTestFile(filePath) {
+  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;
+}
+
+module.exports = {
+  calculateComplexityScore,
+  assessCouplingRisk,
+  findTestFile
+};

package/src/analysis/priority/priority-constants.js

@@ -0,0 +1,73 @@
+/**
+ * Priority constants and result model for refactoring priority calculation.
+ */
+
+const PRIORITY_LEVELS = {
+  CRITICAL: 'critical',
+  HIGH: 'high',
+  MEDIUM: 'medium',
+  LOW: 'low',
+  NONE: 'none'
+};
+
+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'
+};
+
+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);
+  }
+}
+
+module.exports = {
+  PRIORITY_LEVELS,
+  PRIORITY_FACTORS,
+  PriorityResult
+};

package/src/analysis/priority/priority-factor-calculators.js

@@ -0,0 +1,301 @@
+/**
+ * Priority factor calculation functions for refactoring priority.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { PRIORITY_FACTORS } = require('./priority-constants');
+
+function calculateComplexityScore(fileAnalysis) {
+  let score = 0;
+  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;
+  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;
+  const classCount = fileAnalysis.classCount || 0;
+  if (classCount > 5) score += 15;
+  else if (classCount > 3) score += 10;
+  else if (classCount > 1) score += 5;
+  const nestingDepth = fileAnalysis.nestingDepth || 0;
+  if (nestingDepth > 8) score += 15;
+  else if (nestingDepth > 5) score += 10;
+  else if (nestingDepth > 3) score += 5;
+  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);
+}
+
+function 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';
+}
+
+function findTestFile(filePath) {
+  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;
+}
+
+function calculateSizeViolationFactor(fileAnalysis, result, weights, config) {
+  const limits = config.limits;
+  let score = 0;
+  const 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, weights[PRIORITY_FACTORS.SIZE_VIOLATION], details);
+}
+
+function calculateComplexityFactor(fileAnalysis, result, weights, calculateComplexityScoreFn) {
+  const complexityScore = fileAnalysis.getComplexityScore
+    ? fileAnalysis.getComplexityScore()
+    : calculateComplexityScoreFn(fileAnalysis);
+  let score = 0;
+  const details = {};
+  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, weights[PRIORITY_FACTORS.COMPLEXITY], details);
+}
+
+function calculateDependencyFactor(fileAnalysis, result, weights, assessCouplingRiskFn) {
+  const dependencyCount = fileAnalysis.dependencyCount || fileAnalysis.imports?.length || 0;
+  const dependentCount = fileAnalysis.dependents?.length || 0;
+  const totalDependencies = dependencyCount + dependentCount;
+  let score = 0;
+  const details = {};
+  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 = assessCouplingRiskFn(totalDependencies);
+  result.addFactor(PRIORITY_FACTORS.DEPENDENCY_COUNT, score, weights[PRIORITY_FACTORS.DEPENDENCY_COUNT], details);
+}
+
+function calculatePackageImportanceFactor(fileAnalysis, result, weights) {
+  const packageName = fileAnalysis.package || 'root';
+  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
+  };
+  const score = packageImportance[packageName] || 0.2;
+  const details = {
+    packageName,
+    importance: score >= 0.8 ? 'critical' : score >= 0.6 ? 'high' : score >= 0.4 ? 'medium' : 'low',
+    isCorePackage: packageName === 'core'
+  };
+  result.addFactor(PRIORITY_FACTORS.PACKAGE_IMPORTANCE, score, weights[PRIORITY_FACTORS.PACKAGE_IMPORTANCE], details);
+}
+
+function calculateChangeFrequencyFactor(fileAnalysis, result, weights) {
+  const filePath = fileAnalysis.filePath;
+  const highFrequencyPatterns = [/config\//, /\/bin\//, /\/src\/main\//, /package\.json$/, /README\.md$/, /\.config\./];
+  const mediumFrequencyPatterns = [/\/src\/utils\//, /\/src\/helpers\//, /\/src\/services\//];
+  let score = 0.2;
+  const details = { filePath, lastModified: fileAnalysis.lastModified };
+  if (highFrequencyPatterns.some(p => p.test(filePath))) {
+    score = 0.8;
+    details.frequency = 'high';
+  } else if (mediumFrequencyPatterns.some(p => p.test(filePath))) {
+    score = 0.5;
+    details.frequency = 'medium';
+  } else {
+    details.frequency = 'low';
+  }
+  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, weights[PRIORITY_FACTORS.CHANGE_FREQUENCY], details);
+}
+
+function calculateTestCoverageFactor(fileAnalysis, result, weights, findTestFileFn) {
+  const filePath = fileAnalysis.filePath;
+  const isTestFile = fileAnalysis.isTestFile || /test|spec/.test(filePath);
+  let score = 0;
+  const details = { filePath, isTestFile };
+  if (isTestFile) {
+    score = 0.0;
+    details.coverage = 'test_file';
+  } else {
+    const testFile = findTestFileFn(filePath);
+    if (testFile) {
+      score = 0.2;
+      details.coverage = 'good';
+      details.testFile = testFile;
+    } else {
+      score = 0.6;
+      details.coverage = 'poor';
+      details.testFile = null;
+    }
+  }
+  details.impact = score > 0.4 ? 'high_risk' : 'low_risk';
+  result.addFactor(PRIORITY_FACTORS.TEST_COVERAGE, score, weights[PRIORITY_FACTORS.TEST_COVERAGE], details);
+}
+
+function calculateBusinessImpactFactor(fileAnalysis, result, weights) {
+  const filePath = fileAnalysis.filePath;
+  const criticalPatterns = [/\/bin\//, /\/src\/main\//, /\/src\/app\//, /\/src\/index\./, /\/server\./, /\/app\./];
+  const importantPatterns = [/\/src\/api\//, /\/src\/controllers\//, /\/src\/services\//, /\/src\/models\//];
+  let score = 0.2;
+  const details = { filePath, impact: 'standard' };
+  if (criticalPatterns.some(p => p.test(filePath))) {
+    score = 0.8;
+    details.impact = 'critical';
+  } else if (importantPatterns.some(p => p.test(filePath))) {
+    score = 0.5;
+    details.impact = 'important';
+  }
+  details.isBusinessCritical = score >= 0.8;
+  result.addFactor(PRIORITY_FACTORS.BUSINESS_IMPACT, score, weights[PRIORITY_FACTORS.BUSINESS_IMPACT], details);
+}
+
+function generateReasonsAndRecommendations(fileAnalysis, result) {
+  const reasons = [];
+  const recommendations = [];
+  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');
+  }
+  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');
+  }
+  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');
+  }
+  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');
+  }
+  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');
+  }
+  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;
+}
+
+module.exports = {
+  calculateComplexityScore,
+  assessCouplingRisk,
+  findTestFile,
+  calculateSizeViolationFactor,
+  calculateComplexityFactor,
+  calculateDependencyFactor,
+  calculatePackageImportanceFactor,
+  calculateChangeFrequencyFactor,
+  calculateTestCoverageFactor,
+  calculateBusinessImpactFactor,
+  generateReasonsAndRecommendations
+};

package/src/analysis/priority/reasons-generator.js

@@ -0,0 +1,44 @@
+/**
+ * Generates reasons and recommendations for priority results.
+ */
+
+const { PRIORITY_FACTORS } = require('./priority-constants');
+
+function generateReasonsAndRecommendations(result) {
+  const reasons = [];
+  const recommendations = [];
+  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');
+  }
+  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');
+  }
+  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');
+  }
+  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');
+  }
+  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');
+  }
+  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;
+}
+
+module.exports = { generateReasonsAndRecommendations };