tlc-claude-code 1.2.28 → 1.3.0

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');
+    });
+  });
+});

package/server/lib/mermaid-generator.js

@@ -0,0 +1,358 @@
+/**
+ * Mermaid Diagram Generator
+ * Generate Mermaid diagrams from dependency data
+ */
+
+const path = require('path');
+
+class MermaidGenerator {
+  constructor(options = {}) {
+    this.options = {
+      direction: options.direction || 'TD', // TB, BT, LR, RL
+      maxNodes: options.maxNodes || 100,
+      showExternal: options.showExternal !== false,
+      groupByDirectory: options.groupByDirectory !== false,
+      highlightCycles: options.highlightCycles !== false,
+      highlightHubs: options.highlightHubs || false,
+      hubThreshold: options.hubThreshold || 5,
+      ...options,
+    };
+  }
+
+  /**
+   * Generate flowchart from dependency graph
+   * @param {Object} graph - Graph from DependencyGraph.getGraph()
+   * @param {Object} options - Generation options
+   * @returns {string} Mermaid diagram code
+   */
+  generateFlowchart(graph, options = {}) {
+    const opts = { ...this.options, ...options };
+    const { nodes, edges, external } = graph;
+
+    // Truncate if too large
+    const displayNodes = nodes.slice(0, opts.maxNodes);
+    const nodeIds = new Set(displayNodes.map(n => n.id));
+    const displayEdges = edges.filter(e => nodeIds.has(e.from) && nodeIds.has(e.to));
+
+    let mermaid = `flowchart ${opts.direction}\n`;
+
+    // Add styling
+    mermaid += this.generateStyles(opts);
+
+    // Group by directory if enabled
+    if (opts.groupByDirectory) {
+      mermaid += this.generateSubgraphs(displayNodes, displayEdges, opts);
+    } else {
+      mermaid += this.generateFlatNodes(displayNodes, opts);
+      mermaid += this.generateEdges(displayEdges, opts);
+    }
+
+    // Highlight cycles if provided
+    if (opts.cycles && opts.cycles.length > 0 && opts.highlightCycles) {
+      mermaid += this.generateCycleHighlights(opts.cycles);
+    }
+
+    // Show external deps if enabled
+    if (opts.showExternal && external && external.length > 0) {
+      mermaid += this.generateExternalSubgraph(external.slice(0, 20));
+    }
+
+    // Truncation notice
+    if (nodes.length > opts.maxNodes) {
+      mermaid += `\n    %% Showing ${opts.maxNodes} of ${nodes.length} files\n`;
+    }
+
+    return mermaid;
+  }
+
+  /**
+   * Generate styles section
+   */
+  generateStyles(opts) {
+    let styles = '';
+
+    if (opts.highlightCycles) {
+      styles += '    classDef cycle fill:#f96,stroke:#f00,stroke-width:2px\n';
+    }
+
+    if (opts.highlightHubs) {
+      styles += '    classDef hub fill:#9f6,stroke:#090,stroke-width:2px\n';
+    }
+
+    styles += '    classDef external fill:#ddd,stroke:#999\n';
+
+    return styles;
+  }
+
+  /**
+   * Generate subgraphs for directories
+   */
+  generateSubgraphs(nodes, edges, opts) {
+    let mermaid = '';
+    const directories = this.groupByDirectory(nodes);
+    const nodeIdMap = new Map();
+
+    // Generate subgraphs
+    for (const [dir, dirNodes] of directories.entries()) {
+      const safeDirId = this.sanitizeId(dir || 'root');
+      const dirLabel = dir || 'Root';
+
+      mermaid += `    subgraph ${safeDirId}[${this.escapeLabel(dirLabel)}]\n`;
+
+      for (const node of dirNodes) {
+        const nodeId = this.sanitizeId(node.name);
+        nodeIdMap.set(node.id, nodeId);
+        const label = path.basename(node.name);
+        mermaid += `        ${nodeId}[${this.escapeLabel(label)}]\n`;
+      }
+
+      mermaid += '    end\n';
+    }
+
+    // Generate edges
+    for (const edge of edges) {
+      const fromId = nodeIdMap.get(edge.from);
+      const toId = nodeIdMap.get(edge.to);
+      if (fromId && toId) {
+        mermaid += `    ${fromId} --> ${toId}\n`;
+      }
+    }
+
+    return mermaid;
+  }
+
+  /**
+   * Generate flat node list (no subgraphs)
+   */
+  generateFlatNodes(nodes, opts) {
+    let mermaid = '';
+
+    for (const node of nodes) {
+      const nodeId = this.sanitizeId(node.name);
+      const label = node.name;
+      mermaid += `    ${nodeId}[${this.escapeLabel(label)}]\n`;
+
+      // Mark hubs
+      if (opts.highlightHubs && node.importedBy >= opts.hubThreshold) {
+        mermaid += `    class ${nodeId} hub\n`;
+      }
+    }
+
+    return mermaid;
+  }
+
+  /**
+   * Generate edges
+   */
+  generateEdges(edges, opts) {
+    let mermaid = '';
+
+    for (const edge of edges) {
+      const fromId = this.sanitizeId(edge.fromName);
+      const toId = this.sanitizeId(edge.toName);
+      mermaid += `    ${fromId} --> ${toId}\n`;
+    }
+
+    return mermaid;
+  }
+
+  /**
+   * Highlight cycle nodes
+   */
+  generateCycleHighlights(cycles) {
+    let mermaid = '\n    %% Circular dependencies\n';
+    const cycleNodes = new Set();
+
+    for (const cycle of cycles) {
+      for (const node of cycle.path || cycle) {
+        cycleNodes.add(this.sanitizeId(node));
+      }
+    }
+
+    for (const nodeId of cycleNodes) {
+      mermaid += `    class ${nodeId} cycle\n`;
+    }
+
+    return mermaid;
+  }
+
+  /**
+   * Generate external dependencies subgraph
+   */
+  generateExternalSubgraph(external) {
+    let mermaid = '\n    subgraph external[External Dependencies]\n';
+
+    for (const dep of external) {
+      const nodeId = this.sanitizeId(`ext_${dep}`);
+      mermaid += `        ${nodeId}[${this.escapeLabel(dep)}]:::external\n`;
+    }
+
+    mermaid += '    end\n';
+    return mermaid;
+  }
+
+  /**
+   * Group nodes by directory
+   */
+  groupByDirectory(nodes) {
+    const directories = new Map();
+
+    for (const node of nodes) {
+      const dir = path.dirname(node.name);
+      if (!directories.has(dir)) {
+        directories.set(dir, []);
+      }
+      directories.get(dir).push(node);
+    }
+
+    return directories;
+  }
+
+  /**
+   * Generate module-filtered diagram
+   * @param {Object} graph - Full graph
+   * @param {string} modulePath - Module path to filter to
+   * @returns {string} Mermaid diagram
+   */
+  generateModuleDiagram(graph, modulePath, options = {}) {
+    const { nodes, edges } = graph;
+
+    // Filter to nodes in or related to module
+    const moduleNodes = nodes.filter(n =>
+      n.name.startsWith(modulePath) ||
+      n.name.includes(`/${modulePath}/`)
+    );
+
+    const moduleNodeIds = new Set(moduleNodes.map(n => n.id));
+
+    // Include nodes that import or are imported by module nodes
+    const relatedEdges = edges.filter(e =>
+      moduleNodeIds.has(e.from) || moduleNodeIds.has(e.to)
+    );
+
+    const relatedNodeIds = new Set();
+    for (const edge of relatedEdges) {
+      relatedNodeIds.add(edge.from);
+      relatedNodeIds.add(edge.to);
+    }
+
+    const filteredNodes = nodes.filter(n => relatedNodeIds.has(n.id));
+    const filteredEdges = edges.filter(e =>
+      relatedNodeIds.has(e.from) && relatedNodeIds.has(e.to)
+    );
+
+    return this.generateFlowchart(
+      { nodes: filteredNodes, edges: filteredEdges, external: [] },
+      { ...options, groupByDirectory: false }
+    );
+  }
+
+  /**
+   * Generate coupling matrix diagram
+   * @param {Object} couplingData - From CouplingCalculator
+   * @returns {string} Mermaid diagram
+   */
+  generateCouplingMatrix(couplingData) {
+    const { matrix, modules } = couplingData;
+
+    if (!matrix || modules.length === 0) {
+      return 'flowchart TD\n    empty[No coupling data]\n';
+    }
+
+    let mermaid = 'flowchart LR\n';
+
+    // Create nodes for each module
+    for (const mod of modules) {
+      const nodeId = this.sanitizeId(mod.name);
+      const label = `${mod.name}\\nCa:${mod.afferent} Ce:${mod.efferent}`;
+      mermaid += `    ${nodeId}[${this.escapeLabel(label)}]\n`;
+    }
+
+    // Create edges from matrix
+    for (let i = 0; i < modules.length; i++) {
+      for (let j = 0; j < modules.length; j++) {
+        if (matrix[i][j] > 0) {
+          const fromId = this.sanitizeId(modules[i].name);
+          const toId = this.sanitizeId(modules[j].name);
+          mermaid += `    ${fromId} -->|${matrix[i][j]}| ${toId}\n`;
+        }
+      }
+    }
+
+    return mermaid;
+  }
+
+  /**
+   * Generate service boundary diagram
+   * @param {Object} boundaryData - From BoundaryDetector
+   * @returns {string} Mermaid diagram
+   */
+  generateBoundaryDiagram(boundaryData) {
+    const { services, shared } = boundaryData;
+
+    if (!services || services.length === 0) {
+      return 'flowchart TD\n    empty[No services detected]\n';
+    }
+
+    let mermaid = 'flowchart TB\n';
+
+    // Shared kernel
+    if (shared && shared.length > 0) {
+      mermaid += '    subgraph shared[Shared Kernel]\n';
+      for (const file of shared.slice(0, 10)) {
+        const nodeId = this.sanitizeId(`shared_${file}`);
+        mermaid += `        ${nodeId}[${this.escapeLabel(path.basename(file))}]\n`;
+      }
+      mermaid += '    end\n\n';
+    }
+
+    // Services
+    for (const service of services) {
+      const serviceId = this.sanitizeId(`svc_${service.name}`);
+      mermaid += `    subgraph ${serviceId}[${this.escapeLabel(service.name)}]\n`;
+
+      for (const file of (service.files || []).slice(0, 10)) {
+        const nodeId = this.sanitizeId(file);
+        mermaid += `        ${nodeId}[${this.escapeLabel(path.basename(file))}]\n`;
+      }
+
+      mermaid += '    end\n';
+    }
+
+    // Service dependencies
+    for (const service of services) {
+      const fromId = this.sanitizeId(`svc_${service.name}`);
+      for (const dep of service.dependencies || []) {
+        const toId = this.sanitizeId(`svc_${dep}`);
+        mermaid += `    ${fromId} --> ${toId}\n`;
+      }
+    }
+
+    return mermaid;
+  }
+
+  /**
+   * Sanitize string for use as Mermaid ID
+   */
+  sanitizeId(str) {
+    return str
+      .replace(/[^a-zA-Z0-9]/g, '_')
+      .replace(/^_+|_+$/g, '')
+      .replace(/_+/g, '_')
+      || 'node';
+  }
+
+  /**
+   * Escape label for Mermaid
+   */
+  escapeLabel(str) {
+    return str
+      .replace(/"/g, "'")
+      .replace(/\[/g, '(')
+      .replace(/\]/g, ')')
+      .replace(/>/g, ')')
+      .replace(/</g, '(');
+  }
+}
+
+module.exports = { MermaidGenerator };