tlc-claude-code 1.3.0 → 1.4.0

package/server/lib/workspace-config.js

@@ -0,0 +1,270 @@
+/**
+ * Workspace Configuration - Define and persist multi-repo workspace structure
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_FILENAME = '.tlc-workspace.json';
+const IGNORE_DIRS = ['node_modules', '.git', '.svn', '.hg', 'dist', 'build', 'coverage'];
+
+class WorkspaceConfig {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.configPath = path.join(rootDir, CONFIG_FILENAME);
+    this.config = this.load();
+  }
+
+  /**
+   * Load existing config or return null
+   */
+  load() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const data = fs.readFileSync(this.configPath, 'utf-8');
+        return JSON.parse(data);
+      }
+    } catch (err) {
+      console.error('Failed to load workspace config:', err.message);
+    }
+    return null;
+  }
+
+  /**
+   * Save config to file
+   */
+  save() {
+    try {
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
+    } catch (err) {
+      console.error('Failed to save workspace config:', err.message);
+    }
+  }
+
+  /**
+   * Initialize a new workspace
+   */
+  init() {
+    this.config = {
+      root: this.rootDir,
+      repos: [],
+      createdAt: new Date().toISOString(),
+    };
+    this.save();
+  }
+
+  /**
+   * Get current config
+   */
+  getConfig() {
+    return this.config || { root: this.rootDir, repos: [] };
+  }
+
+  /**
+   * Add a repo to the workspace
+   * @param {string} repoPath - Relative or absolute path to repo
+   */
+  addRepo(repoPath) {
+    if (!this.config) {
+      throw new Error('Workspace not initialized. Run init() first.');
+    }
+
+    // Convert to relative path
+    const relativePath = this.toRelativePath(repoPath);
+    const absolutePath = path.join(this.rootDir, relativePath);
+
+    // Validate repo exists
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Repository not found: ${repoPath}`);
+    }
+
+    // Add if not already present
+    if (!this.config.repos.includes(relativePath)) {
+      this.config.repos.push(relativePath);
+      this.save();
+    }
+  }
+
+  /**
+   * Remove a repo from the workspace
+   * @param {string} repoPath - Relative or absolute path to repo
+   */
+  removeRepo(repoPath) {
+    if (!this.config) return;
+
+    const relativePath = this.toRelativePath(repoPath);
+    this.config.repos = this.config.repos.filter(r => r !== relativePath);
+    this.save();
+  }
+
+  /**
+   * Convert absolute path to relative
+   */
+  toRelativePath(inputPath) {
+    if (path.isAbsolute(inputPath)) {
+      return path.relative(this.rootDir, inputPath);
+    }
+    return inputPath;
+  }
+
+  /**
+   * Discover repos in subdirectories
+   * @returns {string[]} Array of relative paths to discovered repos
+   */
+  discoverRepos() {
+    const discovered = [];
+
+    try {
+      const entries = fs.readdirSync(this.rootDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith('.')) continue; // Skip hidden
+        if (IGNORE_DIRS.includes(entry.name)) continue;
+
+        const subDir = path.join(this.rootDir, entry.name);
+
+        // Check if it has package.json (Node.js project)
+        if (fs.existsSync(path.join(subDir, 'package.json'))) {
+          discovered.push(entry.name);
+          continue;
+        }
+
+        // Check if it has pyproject.toml or setup.py (Python project)
+        if (
+          fs.existsSync(path.join(subDir, 'pyproject.toml')) ||
+          fs.existsSync(path.join(subDir, 'setup.py'))
+        ) {
+          discovered.push(entry.name);
+          continue;
+        }
+
+        // Check if it has go.mod (Go project)
+        if (fs.existsSync(path.join(subDir, 'go.mod'))) {
+          discovered.push(entry.name);
+          continue;
+        }
+      }
+    } catch (err) {
+      console.error('Failed to discover repos:', err.message);
+    }
+
+    return discovered;
+  }
+
+  /**
+   * Expand glob pattern to matching paths
+   * @param {string} pattern - Glob pattern like "packages/*"
+   * @returns {string[]} Matching relative paths
+   */
+  expandGlob(pattern) {
+    const results = [];
+
+    // Simple glob expansion for "dir/*" pattern
+    if (pattern.endsWith('/*')) {
+      const baseDir = pattern.slice(0, -2);
+      const absoluteBase = path.join(this.rootDir, baseDir);
+
+      if (fs.existsSync(absoluteBase)) {
+        try {
+          const entries = fs.readdirSync(absoluteBase, { withFileTypes: true });
+
+          for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+            if (entry.name.startsWith('.')) continue;
+
+            const subPath = path.join(baseDir, entry.name);
+            const absolutePath = path.join(this.rootDir, subPath);
+
+            // Check if it's a valid project
+            if (
+              fs.existsSync(path.join(absolutePath, 'package.json')) ||
+              fs.existsSync(path.join(absolutePath, 'pyproject.toml')) ||
+              fs.existsSync(path.join(absolutePath, 'go.mod'))
+            ) {
+              results.push(subPath);
+            }
+          }
+        } catch (err) {
+          console.error('Failed to expand glob:', err.message);
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Detect npm/pnpm/yarn workspaces from root package.json
+   * @returns {string[]} Workspace package paths
+   */
+  detectNpmWorkspaces() {
+    const packageJsonPath = path.join(this.rootDir, 'package.json');
+
+    if (!fs.existsSync(packageJsonPath)) {
+      return [];
+    }
+
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+      const workspaces = packageJson.workspaces;
+
+      if (!workspaces) {
+        return [];
+      }
+
+      // Handle array of patterns
+      const patterns = Array.isArray(workspaces) ? workspaces : workspaces.packages || [];
+      const results = [];
+
+      for (const pattern of patterns) {
+        const expanded = this.expandGlob(pattern);
+        results.push(...expanded);
+      }
+
+      return results;
+    } catch (err) {
+      console.error('Failed to detect npm workspaces:', err.message);
+      return [];
+    }
+  }
+
+  /**
+   * Get info about a specific repo
+   * @param {string} repoPath - Relative path to repo
+   * @returns {Object} Repo info
+   */
+  getRepoInfo(repoPath) {
+    const absolutePath = path.join(this.rootDir, repoPath);
+    const info = {
+      path: repoPath,
+      name: repoPath,
+      hasTlc: false,
+      hasPackageJson: false,
+    };
+
+    // Check for package.json
+    const packageJsonPath = path.join(absolutePath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      info.hasPackageJson = true;
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        info.name = pkg.name || repoPath;
+        info.version = pkg.version;
+      } catch (err) {
+        // Ignore parse errors
+      }
+    }
+
+    // Check for .tlc.json
+    const tlcPath = path.join(absolutePath, '.tlc.json');
+    info.hasTlc = fs.existsSync(tlcPath);
+
+    return info;
+  }
+}
+
+module.exports = {
+  WorkspaceConfig,
+  CONFIG_FILENAME,
+};

package/server/lib/workspace-config.test.js

@@ -0,0 +1,312 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const { WorkspaceConfig } = await import('./workspace-config.js');
+
+describe('WorkspaceConfig', () => {
+  let tempDir;
+  let workspaceConfig;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workspace-config-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('initialization', () => {
+    it('creates workspace config file', () => {
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+
+      const configPath = path.join(tempDir, '.tlc-workspace.json');
+      expect(fs.existsSync(configPath)).toBe(true);
+    });
+
+    it('initializes with empty repos list', () => {
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+
+      const config = workspaceConfig.getConfig();
+      expect(config.repos).toEqual([]);
+    });
+
+    it('sets workspace root in config', () => {
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+
+      const config = workspaceConfig.getConfig();
+      expect(config.root).toBe(tempDir);
+    });
+  });
+
+  describe('addRepo', () => {
+    it('adds repo to workspace', () => {
+      // Create a mock repo directory
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "my-repo"}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+      workspaceConfig.addRepo('my-repo');
+
+      const config = workspaceConfig.getConfig();
+      expect(config.repos).toContain('my-repo');
+    });
+
+    it('stores relative paths only', () => {
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+      workspaceConfig.addRepo(repoPath); // absolute path
+
+      const config = workspaceConfig.getConfig();
+      expect(config.repos).toContain('my-repo'); // stored as relative
+    });
+
+    it('rejects non-existent repo path', () => {
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+
+      expect(() => workspaceConfig.addRepo('non-existent')).toThrow(/not found|does not exist/i);
+    });
+
+    it('prevents duplicate repos', () => {
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+      workspaceConfig.addRepo('my-repo');
+      workspaceConfig.addRepo('my-repo'); // duplicate
+
+      const config = workspaceConfig.getConfig();
+      expect(config.repos.filter(r => r === 'my-repo').length).toBe(1);
+    });
+  });
+
+  describe('removeRepo', () => {
+    it('removes repo from workspace', () => {
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+      workspaceConfig.addRepo('my-repo');
+      workspaceConfig.removeRepo('my-repo');
+
+      const config = workspaceConfig.getConfig();
+      expect(config.repos).not.toContain('my-repo');
+    });
+
+    it('handles removing non-existent repo gracefully', () => {
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+
+      expect(() => workspaceConfig.removeRepo('not-there')).not.toThrow();
+    });
+  });
+
+  describe('auto-discovery', () => {
+    it('auto-discovers repos in subdirectories', () => {
+      // Create subdirectories with package.json
+      fs.mkdirSync(path.join(tempDir, 'repo-a'));
+      fs.writeFileSync(path.join(tempDir, 'repo-a', 'package.json'), '{"name": "repo-a"}');
+      fs.mkdirSync(path.join(tempDir, 'repo-b'));
+      fs.writeFileSync(path.join(tempDir, 'repo-b', 'package.json'), '{"name": "repo-b"}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const discovered = workspaceConfig.discoverRepos();
+
+      expect(discovered).toContain('repo-a');
+      expect(discovered).toContain('repo-b');
+    });
+
+    it('detects package.json in subdirs', () => {
+      fs.mkdirSync(path.join(tempDir, 'my-app'));
+      fs.writeFileSync(path.join(tempDir, 'my-app', 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const discovered = workspaceConfig.discoverRepos();
+
+      expect(discovered).toContain('my-app');
+    });
+
+    it('ignores node_modules directory', () => {
+      fs.mkdirSync(path.join(tempDir, 'node_modules'));
+      fs.mkdirSync(path.join(tempDir, 'node_modules', 'some-pkg'));
+      fs.writeFileSync(path.join(tempDir, 'node_modules', 'some-pkg', 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const discovered = workspaceConfig.discoverRepos();
+
+      expect(discovered).not.toContain('node_modules');
+      expect(discovered).not.toContain(path.join('node_modules', 'some-pkg'));
+    });
+
+    it('ignores .git directory', () => {
+      fs.mkdirSync(path.join(tempDir, '.git'));
+      fs.writeFileSync(path.join(tempDir, '.git', 'config'), '');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const discovered = workspaceConfig.discoverRepos();
+
+      expect(discovered).not.toContain('.git');
+    });
+
+    it('ignores hidden directories', () => {
+      fs.mkdirSync(path.join(tempDir, '.hidden-repo'));
+      fs.writeFileSync(path.join(tempDir, '.hidden-repo', 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const discovered = workspaceConfig.discoverRepos();
+
+      expect(discovered).not.toContain('.hidden-repo');
+    });
+  });
+
+  describe('glob patterns', () => {
+    it('expands glob patterns (packages/*)', () => {
+      fs.mkdirSync(path.join(tempDir, 'packages'));
+      fs.mkdirSync(path.join(tempDir, 'packages', 'core'));
+      fs.writeFileSync(path.join(tempDir, 'packages', 'core', 'package.json'), '{}');
+      fs.mkdirSync(path.join(tempDir, 'packages', 'utils'));
+      fs.writeFileSync(path.join(tempDir, 'packages', 'utils', 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const expanded = workspaceConfig.expandGlob('packages/*');
+
+      expect(expanded).toContain('packages/core');
+      expect(expanded).toContain('packages/utils');
+    });
+  });
+
+  describe('npm workspaces detection', () => {
+    it('detects npm workspaces from root package.json', () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'package.json'),
+        JSON.stringify({
+          name: 'monorepo',
+          workspaces: ['packages/*'],
+        })
+      );
+      fs.mkdirSync(path.join(tempDir, 'packages'));
+      fs.mkdirSync(path.join(tempDir, 'packages', 'api'));
+      fs.writeFileSync(path.join(tempDir, 'packages', 'api', 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const workspaces = workspaceConfig.detectNpmWorkspaces();
+
+      expect(workspaces).toContain('packages/api');
+    });
+
+    it('returns empty array if no workspaces defined', () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'package.json'),
+        JSON.stringify({ name: 'simple-project' })
+      );
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const workspaces = workspaceConfig.detectNpmWorkspaces();
+
+      expect(workspaces).toEqual([]);
+    });
+
+    it('handles missing root package.json', () => {
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const workspaces = workspaceConfig.detectNpmWorkspaces();
+
+      expect(workspaces).toEqual([]);
+    });
+  });
+
+  describe('persistence', () => {
+    it('saves config to .tlc-workspace.json', () => {
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+      workspaceConfig.addRepo('my-repo');
+
+      // Read file directly
+      const configPath = path.join(tempDir, '.tlc-workspace.json');
+      const saved = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+
+      expect(saved.repos).toContain('my-repo');
+    });
+
+    it('loads existing config on construction', () => {
+      // Pre-create config file
+      const configPath = path.join(tempDir, '.tlc-workspace.json');
+      fs.writeFileSync(
+        configPath,
+        JSON.stringify({ root: tempDir, repos: ['existing-repo'] })
+      );
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      const config = workspaceConfig.getConfig();
+
+      expect(config.repos).toContain('existing-repo');
+    });
+  });
+
+  describe('getRepoInfo', () => {
+    it('returns info about a repo', () => {
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(
+        path.join(repoPath, 'package.json'),
+        JSON.stringify({ name: 'my-repo', version: '1.0.0' })
+      );
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+      workspaceConfig.addRepo('my-repo');
+
+      const info = workspaceConfig.getRepoInfo('my-repo');
+
+      expect(info.name).toBe('my-repo');
+      expect(info.path).toBe('my-repo');
+    });
+
+    it('detects if repo has TLC config', () => {
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{}');
+      fs.writeFileSync(path.join(repoPath, '.tlc.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+      workspaceConfig.addRepo('my-repo');
+
+      const info = workspaceConfig.getRepoInfo('my-repo');
+
+      expect(info.hasTlc).toBe(true);
+    });
+
+    it('detects if repo is missing TLC config', () => {
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{}');
+
+      workspaceConfig = new WorkspaceConfig(tempDir);
+      workspaceConfig.init();
+      workspaceConfig.addRepo('my-repo');
+
+      const info = workspaceConfig.getRepoInfo('my-repo');
+
+      expect(info.hasTlc).toBe(false);
+    });
+  });
+});