tlc-claude-code 1.2.29 → 1.4.0

package/server/lib/refactor-reporter.test.js

@@ -0,0 +1,247 @@
+/**
+ * Refactor Reporter Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+
+describe('RefactorReporter', () => {
+  describe('plain English summaries', () => {
+    it('generates plain English: Extracted X from Y', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const summary = reporter.describeChange({
+        type: 'extract',
+        name: 'validateEmail',
+        source: 'createUser',
+        lines: 15,
+      });
+
+      expect(summary).toContain('Extracted');
+      expect(summary).toContain('validateEmail');
+      expect(summary).toContain('createUser');
+    });
+
+    it('generates summary for rename', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const summary = reporter.describeChange({
+        type: 'rename',
+        oldName: 'x',
+        newName: 'userCount',
+        filesAffected: 3,
+      });
+
+      expect(summary).toContain('Renamed');
+      expect(summary).toContain('x');
+      expect(summary).toContain('userCount');
+      expect(summary).toContain('3');
+    });
+
+    it('generates summary for split', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const summary = reporter.describeChange({
+        type: 'split',
+        source: 'handlers.js',
+        targets: ['userHandlers.js', 'authHandlers.js'],
+      });
+
+      expect(summary).toContain('Split');
+      expect(summary).toContain('handlers.js');
+      expect(summary).toContain('2');
+    });
+  });
+
+  describe('diff generation', () => {
+    it('generates unified diff format', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const diff = reporter.generateDiff({
+        file: 'test.js',
+        before: 'const x = 1;',
+        after: 'const count = 1;',
+      });
+
+      expect(diff).toContain('--- a/test.js');
+      expect(diff).toContain('+++ b/test.js');
+      expect(diff).toContain('-const x = 1;');
+      expect(diff).toContain('+const count = 1;');
+    });
+
+    it('handles empty before/after', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const diff = reporter.generateDiff({
+        file: 'test.js',
+      });
+
+      expect(diff).toBe('');
+    });
+  });
+
+  describe('Mermaid diagrams', () => {
+    it('generates Mermaid diagram for function relationships', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const diagram = reporter.generateMermaidDiagram([
+        { type: 'extract', source: 'main', name: 'helper' },
+        { type: 'extract', source: 'main', name: 'utils' },
+      ]);
+
+      expect(diagram).toContain('graph TD');
+      expect(diagram).toContain('main --> helper');
+      expect(diagram).toContain('main --> utils');
+    });
+
+    it('handles split operations', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const diagram = reporter.generateMermaidDiagram([
+        { type: 'split', source: 'handlers', targets: [{ name: 'userHandlers' }, { name: 'authHandlers' }] },
+      ]);
+
+      expect(diagram).toContain('handlers --> userHandlers');
+      expect(diagram).toContain('handlers --> authHandlers');
+    });
+
+    it('returns empty for non-structural changes', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const diagram = reporter.generateMermaidDiagram([
+        { type: 'rename', oldName: 'x', newName: 'y' },
+      ]);
+
+      expect(diagram).toBe('');
+    });
+  });
+
+  describe('Markdown output', () => {
+    it('outputs valid Markdown', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const md = reporter.toMarkdown([
+        { type: 'extract', source: 'main.js', name: 'helper' },
+      ]);
+
+      expect(md).toContain('# Refactoring Report');
+      expect(md).toContain('## Summary');
+      expect(md).toContain('## Changes');
+    });
+
+    it('includes collapsible diff sections', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const md = reporter.toMarkdown([
+        { type: 'rename', oldName: 'x', newName: 'y', file: 'test.js', before: 'x', after: 'y' },
+      ]);
+
+      expect(md).toContain('<details>');
+      expect(md).toContain('View Diff');
+      expect(md).toContain('</details>');
+    });
+  });
+
+  describe('JSON output', () => {
+    it('outputs valid JSON', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const json = reporter.toJson([
+        { type: 'extract', source: 'main.js', name: 'helper' },
+      ]);
+
+      const parsed = JSON.parse(json);
+      expect(parsed.summary).toBeDefined();
+      expect(parsed.changes).toBeDefined();
+      expect(parsed.generatedAt).toBeDefined();
+    });
+
+    it('includes descriptions in JSON', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const json = reporter.toJson([
+        { type: 'rename', oldName: 'x', newName: 'count' },
+      ]);
+
+      const parsed = JSON.parse(json);
+      expect(parsed.changes[0].description).toContain('Renamed');
+    });
+  });
+
+  describe('HTML output', () => {
+    it('outputs valid HTML', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const html = reporter.toHtml([
+        { type: 'extract', source: 'main.js', name: 'helper' },
+      ]);
+
+      expect(html).toContain('<!DOCTYPE html>');
+      expect(html).toContain('<html>');
+      expect(html).toContain('</html>');
+      expect(html).toContain('<title>Refactoring Report</title>');
+    });
+
+    it('escapes HTML entities', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const escaped = reporter.escapeHtml('<script>alert("xss")</script>');
+
+      expect(escaped).not.toContain('<script>');
+      expect(escaped).toContain('&lt;script&gt;');
+    });
+  });
+
+  describe('before/after comparisons', () => {
+    it('includes before/after code blocks', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const comparison = reporter.generateComparison({
+        file: 'test.js',
+        type: 'rename',
+        before: 'const x = 1;',
+        after: 'const count = 1;',
+      });
+
+      expect(comparison.before).toBe('const x = 1;');
+      expect(comparison.after).toBe('const count = 1;');
+      expect(comparison.file).toBe('test.js');
+    });
+  });
+
+  describe('generate method', () => {
+    it('defaults to markdown format', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const output = reporter.generate([{ type: 'extract', name: 'test', source: 'main' }]);
+
+      expect(output).toContain('# Refactoring Report');
+    });
+
+    it('respects format parameter', async () => {
+      const { RefactorReporter } = await import('./refactor-reporter.js');
+      const reporter = new RefactorReporter();
+
+      const json = reporter.generate([{ type: 'extract', name: 'test', source: 'main' }], 'json');
+      expect(() => JSON.parse(json)).not.toThrow();
+
+      const html = reporter.generate([{ type: 'extract', name: 'test', source: 'main' }], 'html');
+      expect(html).toContain('<!DOCTYPE html>');
+    });
+  });
+});

package/server/lib/repo-dependency-tracker.js

@@ -0,0 +1,261 @@
+/**
+ * Repo Dependency Tracker - Track dependencies between repos in a workspace
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class RepoDependencyTracker {
+  constructor(workspaceRoot, repos) {
+    this.workspaceRoot = workspaceRoot;
+    this.repos = repos;
+    this.repoPackages = new Map(); // repo -> package.json data
+    this.repoNames = new Map(); // package name -> repo directory
+    this.dependencyGraph = {}; // repo -> [dependencies]
+
+    this.loadRepoData();
+    this.buildDependencyGraph();
+  }
+
+  /**
+   * Load package.json for all repos
+   */
+  loadRepoData() {
+    for (const repo of this.repos) {
+      const pkgPath = path.join(this.workspaceRoot, repo, 'package.json');
+
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+          this.repoPackages.set(repo, pkg);
+          if (pkg.name) {
+            this.repoNames.set(pkg.name, repo);
+          }
+        } catch (err) {
+          // Invalid JSON, skip
+          this.repoPackages.set(repo, {});
+        }
+      } else {
+        this.repoPackages.set(repo, {});
+      }
+    }
+  }
+
+  /**
+   * Build dependency graph from repo data
+   */
+  buildDependencyGraph() {
+    for (const repo of this.repos) {
+      this.dependencyGraph[repo] = [];
+      const pkg = this.repoPackages.get(repo) || {};
+
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+        ...pkg.peerDependencies,
+      };
+
+      for (const [depName, depVersion] of Object.entries(allDeps || {})) {
+        // Check for workspace: protocol
+        if (typeof depVersion === 'string' && depVersion.startsWith('workspace:')) {
+          const depRepo = this.repoNames.get(depName);
+          if (depRepo && depRepo !== repo) {
+            this.dependencyGraph[repo].push(depRepo);
+          }
+        }
+
+        // Check for file: protocol pointing to another repo
+        if (typeof depVersion === 'string' && depVersion.startsWith('file:')) {
+          const filePath = depVersion.slice(5); // Remove 'file:'
+          const resolvedPath = path.resolve(path.join(this.workspaceRoot, repo), filePath);
+          const relativePath = path.relative(this.workspaceRoot, resolvedPath);
+
+          // Check if it points to one of our repos
+          for (const otherRepo of this.repos) {
+            if (relativePath === otherRepo || relativePath.startsWith(otherRepo + path.sep)) {
+              if (otherRepo !== repo) {
+                this.dependencyGraph[repo].push(otherRepo);
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Get dependencies of a repo
+   * @param {string} repo - Repo directory name
+   * @returns {string[]} Array of repo names this repo depends on
+   */
+  getDependencies(repo) {
+    return this.dependencyGraph[repo] || [];
+  }
+
+  /**
+   * Check if repoA depends on repoB
+   * @param {string} repoA
+   * @param {string} repoB
+   * @returns {boolean}
+   */
+  dependsOn(repoA, repoB) {
+    const deps = this.getDependencies(repoA);
+    return deps.includes(repoB);
+  }
+
+  /**
+   * Get repos that depend on the given repo
+   * @param {string} repo
+   * @returns {string[]}
+   */
+  getDependents(repo) {
+    const dependents = [];
+
+    for (const [r, deps] of Object.entries(this.dependencyGraph)) {
+      if (deps.includes(repo)) {
+        dependents.push(r);
+      }
+    }
+
+    return dependents;
+  }
+
+  /**
+   * Get all repos affected when the given repo changes (transitive dependents)
+   * @param {string} repo
+   * @returns {string[]}
+   */
+  getAffectedRepos(repo) {
+    const affected = new Set();
+    const queue = [repo];
+    const visited = new Set([repo]);
+
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const dependents = this.getDependents(current);
+
+      for (const dep of dependents) {
+        if (!visited.has(dep)) {
+          visited.add(dep);
+          affected.add(dep);
+          queue.push(dep);
+        }
+      }
+    }
+
+    return Array.from(affected);
+  }
+
+  /**
+   * Get topological order for build/test runs
+   * @returns {string[]}
+   */
+  getTopologicalOrder() {
+    const visited = new Set();
+    const result = [];
+
+    const visit = (repo) => {
+      if (visited.has(repo)) return;
+      visited.add(repo);
+
+      const deps = this.getDependencies(repo);
+      for (const dep of deps) {
+        visit(dep);
+      }
+
+      result.push(repo);
+    };
+
+    for (const repo of this.repos) {
+      visit(repo);
+    }
+
+    return result;
+  }
+
+  /**
+   * Detect circular dependencies
+   * @returns {string[][]} Array of cycles found
+   */
+  detectCircularDependencies() {
+    const cycles = [];
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+
+    const dfs = (repo) => {
+      visited.add(repo);
+      recursionStack.add(repo);
+      path.push(repo);
+
+      const deps = this.getDependencies(repo);
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          const cycle = dfs(dep);
+          if (cycle) return cycle;
+        } else if (recursionStack.has(dep)) {
+          // Found cycle
+          const cycleStart = path.indexOf(dep);
+          const cycle = path.slice(cycleStart);
+          cycle.push(dep); // Complete the cycle
+          cycles.push(cycle);
+          return cycle;
+        }
+      }
+
+      path.pop();
+      recursionStack.delete(repo);
+      return null;
+    };
+
+    for (const repo of this.repos) {
+      if (!visited.has(repo)) {
+        dfs(repo);
+      }
+    }
+
+    return cycles;
+  }
+
+  /**
+   * Generate Mermaid diagram of dependencies
+   * @returns {string}
+   */
+  generateMermaidDiagram() {
+    const lines = ['graph TD'];
+
+    // Add all nodes
+    for (const repo of this.repos) {
+      lines.push(`  ${this.sanitizeId(repo)}[${repo}]`);
+    }
+
+    // Add edges
+    for (const [repo, deps] of Object.entries(this.dependencyGraph)) {
+      for (const dep of deps) {
+        lines.push(`  ${this.sanitizeId(repo)} --> ${this.sanitizeId(dep)}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Sanitize repo name for Mermaid ID
+   */
+  sanitizeId(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, '_');
+  }
+
+  /**
+   * Get the full dependency graph
+   * @returns {Object}
+   */
+  getDependencyGraph() {
+    return { ...this.dependencyGraph };
+  }
+}
+
+module.exports = {
+  RepoDependencyTracker,
+};