tlc-claude-code 1.3.0 → 1.4.1

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,
+};

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

@@ -0,0 +1,350 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const { RepoDependencyTracker } = await import('./repo-dependency-tracker.js');
+
+describe('RepoDependencyTracker', () => {
+  let tempDir;
+  let tracker;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'repo-dep-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  function createRepo(name, packageJson) {
+    const repoPath = path.join(tempDir, name);
+    fs.mkdirSync(repoPath, { recursive: true });
+    fs.writeFileSync(
+      path.join(repoPath, 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+    return repoPath;
+  }
+
+  describe('dependency detection', () => {
+    it('detects workspace:* dependencies', () => {
+      createRepo('core', { name: '@myorg/core', version: '1.0.0' });
+      createRepo('api', {
+        name: '@myorg/api',
+        version: '1.0.0',
+        dependencies: {
+          '@myorg/core': 'workspace:*',
+        },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['core', 'api']);
+      const deps = tracker.getDependencies('api');
+
+      expect(deps).toContain('core');
+    });
+
+    it('detects file:../other-repo dependencies', () => {
+      createRepo('shared', { name: 'shared-lib', version: '1.0.0' });
+      createRepo('app', {
+        name: 'my-app',
+        version: '1.0.0',
+        dependencies: {
+          'shared-lib': 'file:../shared',
+        },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['shared', 'app']);
+      const deps = tracker.getDependencies('app');
+
+      expect(deps).toContain('shared');
+    });
+
+    it('detects workspace:^ dependencies', () => {
+      createRepo('utils', { name: '@myorg/utils', version: '2.0.0' });
+      createRepo('web', {
+        name: '@myorg/web',
+        version: '1.0.0',
+        dependencies: {
+          '@myorg/utils': 'workspace:^',
+        },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['utils', 'web']);
+      const deps = tracker.getDependencies('web');
+
+      expect(deps).toContain('utils');
+    });
+
+    it('detects dependencies in devDependencies', () => {
+      createRepo('test-utils', { name: '@myorg/test-utils', version: '1.0.0' });
+      createRepo('service', {
+        name: '@myorg/service',
+        version: '1.0.0',
+        devDependencies: {
+          '@myorg/test-utils': 'workspace:*',
+        },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['test-utils', 'service']);
+      const deps = tracker.getDependencies('service');
+
+      expect(deps).toContain('test-utils');
+    });
+  });
+
+  describe('dependency direction', () => {
+    it('identifies dependency direction (A depends on B)', () => {
+      createRepo('base', { name: 'base', version: '1.0.0' });
+      createRepo('derived', {
+        name: 'derived',
+        version: '1.0.0',
+        dependencies: { base: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['base', 'derived']);
+
+      expect(tracker.dependsOn('derived', 'base')).toBe(true);
+      expect(tracker.dependsOn('base', 'derived')).toBe(false);
+    });
+
+    it('gets dependents of a repo', () => {
+      createRepo('core', { name: 'core', version: '1.0.0' });
+      createRepo('api', {
+        name: 'api',
+        version: '1.0.0',
+        dependencies: { core: 'workspace:*' },
+      });
+      createRepo('web', {
+        name: 'web',
+        version: '1.0.0',
+        dependencies: { core: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['core', 'api', 'web']);
+      const dependents = tracker.getDependents('core');
+
+      expect(dependents).toContain('api');
+      expect(dependents).toContain('web');
+    });
+  });
+
+  describe('affected repos', () => {
+    it('calculates affected repos when one changes', () => {
+      createRepo('core', { name: 'core', version: '1.0.0' });
+      createRepo('utils', {
+        name: 'utils',
+        version: '1.0.0',
+        dependencies: { core: 'workspace:*' },
+      });
+      createRepo('api', {
+        name: 'api',
+        version: '1.0.0',
+        dependencies: { utils: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['core', 'utils', 'api']);
+      const affected = tracker.getAffectedRepos('core');
+
+      expect(affected).toContain('utils');
+      expect(affected).toContain('api');
+      expect(affected).not.toContain('core'); // Changed repo not in affected
+    });
+
+    it('returns empty array for repo with no dependents', () => {
+      createRepo('standalone', { name: 'standalone', version: '1.0.0' });
+
+      tracker = new RepoDependencyTracker(tempDir, ['standalone']);
+      const affected = tracker.getAffectedRepos('standalone');
+
+      expect(affected).toEqual([]);
+    });
+  });
+
+  describe('topological sort', () => {
+    it('generates topological sort for build order', () => {
+      createRepo('a', { name: 'a', version: '1.0.0' });
+      createRepo('b', {
+        name: 'b',
+        version: '1.0.0',
+        dependencies: { a: 'workspace:*' },
+      });
+      createRepo('c', {
+        name: 'c',
+        version: '1.0.0',
+        dependencies: { b: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['a', 'b', 'c']);
+      const order = tracker.getTopologicalOrder();
+
+      const aIndex = order.indexOf('a');
+      const bIndex = order.indexOf('b');
+      const cIndex = order.indexOf('c');
+
+      expect(aIndex).toBeLessThan(bIndex);
+      expect(bIndex).toBeLessThan(cIndex);
+    });
+
+    it('handles independent repos in topological sort', () => {
+      createRepo('x', { name: 'x', version: '1.0.0' });
+      createRepo('y', { name: 'y', version: '1.0.0' });
+      createRepo('z', { name: 'z', version: '1.0.0' });
+
+      tracker = new RepoDependencyTracker(tempDir, ['x', 'y', 'z']);
+      const order = tracker.getTopologicalOrder();
+
+      expect(order).toHaveLength(3);
+      expect(order).toContain('x');
+      expect(order).toContain('y');
+      expect(order).toContain('z');
+    });
+  });
+
+  describe('circular dependencies', () => {
+    it('detects circular dependencies', () => {
+      createRepo('a', {
+        name: 'a',
+        version: '1.0.0',
+        dependencies: { b: 'workspace:*' },
+      });
+      createRepo('b', {
+        name: 'b',
+        version: '1.0.0',
+        dependencies: { a: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['a', 'b']);
+      const cycles = tracker.detectCircularDependencies();
+
+      expect(cycles.length).toBeGreaterThan(0);
+    });
+
+    it('returns empty array when no circular dependencies', () => {
+      createRepo('base', { name: 'base', version: '1.0.0' });
+      createRepo('app', {
+        name: 'app',
+        version: '1.0.0',
+        dependencies: { base: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['base', 'app']);
+      const cycles = tracker.detectCircularDependencies();
+
+      expect(cycles).toEqual([]);
+    });
+
+    it('detects transitive circular dependencies', () => {
+      createRepo('a', {
+        name: 'a',
+        version: '1.0.0',
+        dependencies: { b: 'workspace:*' },
+      });
+      createRepo('b', {
+        name: 'b',
+        version: '1.0.0',
+        dependencies: { c: 'workspace:*' },
+      });
+      createRepo('c', {
+        name: 'c',
+        version: '1.0.0',
+        dependencies: { a: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['a', 'b', 'c']);
+      const cycles = tracker.detectCircularDependencies();
+
+      expect(cycles.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Mermaid diagram generation', () => {
+    it('generates Mermaid dependency diagram', () => {
+      createRepo('core', { name: 'core', version: '1.0.0' });
+      createRepo('api', {
+        name: 'api',
+        version: '1.0.0',
+        dependencies: { core: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['core', 'api']);
+      const diagram = tracker.generateMermaidDiagram();
+
+      expect(diagram).toContain('graph');
+      expect(diagram).toContain('api');
+      expect(diagram).toContain('core');
+      expect(diagram).toContain('-->');
+    });
+
+    it('generates empty diagram for no dependencies', () => {
+      createRepo('standalone', { name: 'standalone', version: '1.0.0' });
+
+      tracker = new RepoDependencyTracker(tempDir, ['standalone']);
+      const diagram = tracker.generateMermaidDiagram();
+
+      expect(diagram).toContain('graph');
+      expect(diagram).toContain('standalone');
+    });
+  });
+
+  describe('error handling', () => {
+    it('handles missing dependencies gracefully', () => {
+      createRepo('app', {
+        name: 'app',
+        version: '1.0.0',
+        dependencies: { 'non-existent': 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['app']);
+      const deps = tracker.getDependencies('app');
+
+      // Should not throw, non-workspace deps are ignored
+      expect(deps).toEqual([]);
+    });
+
+    it('handles missing package.json', () => {
+      const repoPath = path.join(tempDir, 'no-pkg');
+      fs.mkdirSync(repoPath);
+
+      tracker = new RepoDependencyTracker(tempDir, ['no-pkg']);
+      const deps = tracker.getDependencies('no-pkg');
+
+      expect(deps).toEqual([]);
+    });
+
+    it('handles malformed package.json', () => {
+      const repoPath = path.join(tempDir, 'bad-pkg');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), 'not valid json');
+
+      tracker = new RepoDependencyTracker(tempDir, ['bad-pkg']);
+      const deps = tracker.getDependencies('bad-pkg');
+
+      expect(deps).toEqual([]);
+    });
+  });
+
+  describe('dependency graph', () => {
+    it('builds complete dependency graph', () => {
+      createRepo('a', { name: 'a', version: '1.0.0' });
+      createRepo('b', {
+        name: 'b',
+        version: '1.0.0',
+        dependencies: { a: 'workspace:*' },
+      });
+      createRepo('c', {
+        name: 'c',
+        version: '1.0.0',
+        dependencies: { a: 'workspace:*', b: 'workspace:*' },
+      });
+
+      tracker = new RepoDependencyTracker(tempDir, ['a', 'b', 'c']);
+      const graph = tracker.getDependencyGraph();
+
+      expect(graph.a).toEqual([]);
+      expect(graph.b).toContain('a');
+      expect(graph.c).toContain('a');
+      expect(graph.c).toContain('b');
+    });
+  });
+});