tlc-claude-code 1.2.29 → 1.4.0

package/server/lib/impact-scorer.js

@@ -0,0 +1,184 @@
+/**
+ * Impact Scorer
+ * Calculate priority score for refactoring opportunities
+ */
+
+const { execSync } = require('child_process');
+
+class ImpactScorer {
+  constructor(options = {}) {
+    this.weights = {
+      complexityReduction: options.complexityWeight || 0.30,
+      blastRadius: options.blastRadiusWeight || 0.25,
+      changeFrequency: options.frequencyWeight || 0.25,
+      risk: options.riskWeight || 0.20,
+    };
+    this.exec = options.exec || this.defaultExec.bind(this);
+  }
+
+  defaultExec(command) {
+    try {
+      return execSync(command, { encoding: 'utf-8' });
+    } catch {
+      return '';
+    }
+  }
+
+  /**
+   * Calculate impact score for a refactoring opportunity
+   * @param {Object} opportunity - Refactoring opportunity
+   * @returns {Object} Score breakdown and total
+   */
+  score(opportunity) {
+    const complexityScore = this.scoreComplexityReduction(opportunity);
+    const blastRadiusScore = this.scoreBlastRadius(opportunity);
+    const frequencyScore = this.scoreChangeFrequency(opportunity);
+    const riskScore = this.scoreRisk(opportunity);
+
+    const total = Math.round(
+      complexityScore * this.weights.complexityReduction +
+      blastRadiusScore * this.weights.blastRadius +
+      frequencyScore * this.weights.changeFrequency +
+      riskScore * this.weights.risk
+    );
+
+    return {
+      total: Math.min(100, Math.max(0, total)),
+      breakdown: {
+        complexityReduction: complexityScore,
+        blastRadius: blastRadiusScore,
+        changeFrequency: frequencyScore,
+        risk: riskScore,
+      },
+      weights: this.weights,
+    };
+  }
+
+  /**
+   * Score based on complexity reduction potential
+   * Higher complexity = higher score (more to gain)
+   */
+  scoreComplexityReduction(opportunity) {
+    const { complexity, targetComplexity } = opportunity;
+
+    if (!complexity) return 50; // Default middle score
+
+    const reduction = complexity - (targetComplexity || 1);
+
+    // Scale: 0-5 reduction = 0-50, 5-15 = 50-80, 15+ = 80-100
+    if (reduction <= 0) return 20;
+    if (reduction <= 5) return 20 + (reduction * 10);
+    if (reduction <= 15) return 70 + ((reduction - 5) * 2);
+    return 90 + Math.min(10, (reduction - 15));
+  }
+
+  /**
+   * Score based on blast radius (files affected)
+   */
+  scoreBlastRadius(opportunity) {
+    const { filesAffected, linesAffected } = opportunity;
+
+    // More files affected = higher impact
+    let score = 30; // base
+
+    if (filesAffected) {
+      if (filesAffected === 1) score = 40;
+      else if (filesAffected <= 3) score = 60;
+      else if (filesAffected <= 10) score = 80;
+      else score = 95;
+    }
+
+    // Adjust for lines affected
+    if (linesAffected) {
+      if (linesAffected > 100) score = Math.min(100, score + 10);
+      if (linesAffected > 500) score = Math.min(100, score + 10);
+    }
+
+    return score;
+  }
+
+  /**
+   * Score based on change frequency from git history
+   */
+  scoreChangeFrequency(opportunity) {
+    const { filePath, changeCount } = opportunity;
+
+    // If changeCount provided, use it
+    if (changeCount !== undefined) {
+      if (changeCount === 0) return 30;
+      if (changeCount <= 5) return 50;
+      if (changeCount <= 20) return 70;
+      if (changeCount <= 50) return 85;
+      return 95;
+    }
+
+    // Otherwise try to get from git
+    if (filePath) {
+      try {
+        const output = this.exec(`git log --oneline "${filePath}" 2>/dev/null | wc -l`);
+        const commits = parseInt(output.trim(), 10) || 0;
+
+        if (commits === 0) return 30;
+        if (commits <= 5) return 50;
+        if (commits <= 20) return 70;
+        if (commits <= 50) return 85;
+        return 95;
+      } catch {
+        return 50; // Default if git fails
+      }
+    }
+
+    return 50;
+  }
+
+  /**
+   * Score based on risk (test coverage, criticality)
+   * Lower coverage = higher risk = higher priority to refactor safely
+   */
+  scoreRisk(opportunity) {
+    const { testCoverage, isCritical } = opportunity;
+
+    let score = 50;
+
+    // Lower test coverage = higher risk score
+    if (testCoverage !== undefined) {
+      if (testCoverage >= 80) score = 30;
+      else if (testCoverage >= 60) score = 50;
+      else if (testCoverage >= 40) score = 70;
+      else if (testCoverage >= 20) score = 85;
+      else score = 95;
+    }
+
+    // Critical paths get higher score
+    if (isCritical) {
+      score = Math.min(100, score + 15);
+    }
+
+    return score;
+  }
+
+  /**
+   * Score multiple opportunities and sort by impact
+   * @param {Array} opportunities - Array of opportunities
+   * @returns {Array} Sorted opportunities with scores
+   */
+  scoreAll(opportunities) {
+    return opportunities
+      .map(opp => ({
+        ...opp,
+        impact: this.score(opp),
+      }))
+      .sort((a, b) => b.impact.total - a.impact.total);
+  }
+
+  /**
+   * Get priority tier from score
+   */
+  static getTier(score) {
+    if (score >= 80) return 'high';
+    if (score >= 50) return 'medium';
+    return 'low';
+  }
+}
+
+module.exports = { ImpactScorer };

package/server/lib/impact-scorer.test.js

@@ -0,0 +1,211 @@
+/**
+ * Impact Scorer Tests
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+
+describe('ImpactScorer', () => {
+  describe('complexity reduction scoring', () => {
+    it('high complexity reduction gives high score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        complexity: 25,
+        targetComplexity: 5,
+      });
+
+      expect(result.breakdown.complexityReduction).toBeGreaterThan(70);
+    });
+
+    it('low complexity reduction gives low score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        complexity: 3,
+        targetComplexity: 2,
+      });
+
+      expect(result.breakdown.complexityReduction).toBeLessThan(50);
+    });
+  });
+
+  describe('blast radius scoring', () => {
+    it('many files affected gives higher score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        filesAffected: 15,
+      });
+
+      expect(result.breakdown.blastRadius).toBeGreaterThan(80);
+    });
+
+    it('single file gives lower score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        filesAffected: 1,
+      });
+
+      expect(result.breakdown.blastRadius).toBeLessThan(60);
+    });
+  });
+
+  describe('change frequency scoring', () => {
+    it('frequently changed files get higher score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        changeCount: 100,
+      });
+
+      expect(result.breakdown.changeFrequency).toBeGreaterThan(80);
+    });
+
+    it('rarely changed files get lower score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        changeCount: 2,
+      });
+
+      expect(result.breakdown.changeFrequency).toBeLessThan(60);
+    });
+  });
+
+  describe('risk scoring', () => {
+    it('low test coverage gives higher risk score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        testCoverage: 10,
+      });
+
+      expect(result.breakdown.risk).toBeGreaterThan(80);
+    });
+
+    it('high test coverage gives lower risk score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        testCoverage: 90,
+      });
+
+      expect(result.breakdown.risk).toBeLessThan(50);
+    });
+
+    it('critical paths get boosted score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const regular = scorer.score({ testCoverage: 50 });
+      const critical = scorer.score({ testCoverage: 50, isCritical: true });
+
+      expect(critical.breakdown.risk).toBeGreaterThan(regular.breakdown.risk);
+    });
+  });
+
+  describe('combined scoring', () => {
+    it('combines factors into single 0-100 score', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        complexity: 20,
+        filesAffected: 5,
+        changeCount: 30,
+        testCoverage: 40,
+      });
+
+      expect(result.total).toBeGreaterThanOrEqual(0);
+      expect(result.total).toBeLessThanOrEqual(100);
+      expect(typeof result.total).toBe('number');
+    });
+
+    it('returns breakdown of individual scores', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const result = scorer.score({
+        complexity: 10,
+        filesAffected: 3,
+      });
+
+      expect(result.breakdown).toBeDefined();
+      expect(result.breakdown.complexityReduction).toBeDefined();
+      expect(result.breakdown.blastRadius).toBeDefined();
+      expect(result.breakdown.changeFrequency).toBeDefined();
+      expect(result.breakdown.risk).toBeDefined();
+    });
+  });
+
+  describe('git history', () => {
+    it('handles missing git history gracefully', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+
+      const execMock = vi.fn().mockReturnValue('');
+      const scorer = new ImpactScorer({ exec: execMock });
+
+      const result = scorer.score({
+        filePath: 'nonexistent.js',
+      });
+
+      expect(result.total).toBeGreaterThanOrEqual(0);
+      // Empty git output returns 0 commits = score 30
+      expect(result.breakdown.changeFrequency).toBe(30);
+    });
+
+    it('uses git log for file history when available', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+
+      const execMock = vi.fn().mockReturnValue('25\n');
+      const scorer = new ImpactScorer({ exec: execMock });
+
+      const result = scorer.score({
+        filePath: 'src/api/users.js',
+      });
+
+      expect(execMock).toHaveBeenCalledWith(expect.stringContaining('git log'));
+      expect(result.breakdown.changeFrequency).toBeGreaterThan(60);
+    });
+  });
+
+  describe('scoreAll', () => {
+    it('scores and sorts multiple opportunities', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+      const scorer = new ImpactScorer();
+
+      const opportunities = [
+        { complexity: 5, filesAffected: 1 },
+        { complexity: 30, filesAffected: 10, changeCount: 50 },
+        { complexity: 10, filesAffected: 3 },
+      ];
+
+      const scored = scorer.scoreAll(opportunities);
+
+      expect(scored).toHaveLength(3);
+      expect(scored[0].impact.total).toBeGreaterThanOrEqual(scored[1].impact.total);
+      expect(scored[1].impact.total).toBeGreaterThanOrEqual(scored[2].impact.total);
+    });
+  });
+
+  describe('getTier', () => {
+    it('returns correct priority tier', async () => {
+      const { ImpactScorer } = await import('./impact-scorer.js');
+
+      expect(ImpactScorer.getTier(90)).toBe('high');
+      expect(ImpactScorer.getTier(80)).toBe('high');
+      expect(ImpactScorer.getTier(65)).toBe('medium');
+      expect(ImpactScorer.getTier(50)).toBe('medium');
+      expect(ImpactScorer.getTier(30)).toBe('low');
+    });
+  });
+});