tlc-claude-code 1.3.0 → 1.4.1

package/server/lib/workspace-command.js

@@ -0,0 +1,249 @@
+/**
+ * Workspace Command - CLI interface for workspace operations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { WorkspaceConfig } = require('./workspace-config.js');
+const { BulkRepoInit } = require('./bulk-repo-init.js');
+const { WorkspaceTestRunner } = require('./workspace-test-runner.js');
+const { RepoDependencyTracker } = require('./repo-dependency-tracker.js');
+
+const CONFIG_FILENAME = '.tlc-workspace.json';
+
+class WorkspaceCommand {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.configPath = path.join(rootDir, CONFIG_FILENAME);
+    this.config = null;
+    this._loadConfig();
+  }
+
+  /**
+   * Load existing workspace config
+   */
+  _loadConfig() {
+    if (fs.existsSync(this.configPath)) {
+      try {
+        this.config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+      } catch (err) {
+        this.config = null;
+      }
+    }
+  }
+
+  /**
+   * Save workspace config
+   */
+  _saveConfig() {
+    fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
+  }
+
+  /**
+   * Check if workspace is initialized
+   */
+  isInitialized() {
+    return this.config !== null;
+  }
+
+  /**
+   * Get current config
+   */
+  getConfig() {
+    return this.config;
+  }
+
+  /**
+   * Initialize workspace - scan, detect, and optionally bulk-init repos
+   */
+  async init(options = {}) {
+    const { dryRun = false, confirm = false } = options;
+
+    const workspaceConfig = new WorkspaceConfig(this.rootDir);
+    const bulkInit = new BulkRepoInit(this.rootDir);
+
+    // Discover repos
+    const discovered = workspaceConfig.discoverRepos();
+
+    // Find uninitialized repos
+    const needsInit = bulkInit.findUninitializedRepos();
+
+    const result = {
+      discovered,
+      needsInit,
+      initialized: 0,
+      skipped: discovered.length - needsInit.length,
+      errors: [],
+    };
+
+    if (dryRun) {
+      return result;
+    }
+
+    if (confirm) {
+      // Initialize all uninitialized repos
+      if (needsInit.length > 0) {
+        const initResult = bulkInit.initializeAll();
+        result.initialized = initResult.initialized;
+        result.errors = initResult.errors;
+      }
+
+      // Create workspace config
+      this.config = {
+        root: this.rootDir,
+        repos: discovered,
+        createdAt: new Date().toISOString(),
+      };
+      this._saveConfig();
+    }
+
+    return result;
+  }
+
+  /**
+   * Add a repo to the workspace
+   */
+  async add(repoPath) {
+    if (!this.isInitialized()) {
+      throw new Error('Workspace not initialized. Run init first.');
+    }
+
+    const absolutePath = path.isAbsolute(repoPath)
+      ? repoPath
+      : path.join(this.rootDir, repoPath);
+
+    const relativePath = path.relative(this.rootDir, absolutePath);
+
+    // Check repo exists
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Repository not found: ${repoPath}`);
+    }
+
+    // Auto-initialize if no .tlc.json
+    const tlcPath = path.join(absolutePath, '.tlc.json');
+    if (!fs.existsSync(tlcPath)) {
+      const bulkInit = new BulkRepoInit(this.rootDir);
+      bulkInit.initializeRepo(relativePath);
+    }
+
+    // Add to config if not already present
+    if (!this.config.repos.includes(relativePath)) {
+      this.config.repos.push(relativePath);
+      this._saveConfig();
+    }
+  }
+
+  /**
+   * Remove a repo from the workspace (does not delete files)
+   */
+  async remove(repoPath) {
+    if (!this.isInitialized()) {
+      throw new Error('Workspace not initialized. Run init first.');
+    }
+
+    const relativePath = path.isAbsolute(repoPath)
+      ? path.relative(this.rootDir, repoPath)
+      : repoPath;
+
+    this.config.repos = this.config.repos.filter(r => r !== relativePath);
+    this._saveConfig();
+  }
+
+  /**
+   * List all repos with status
+   */
+  async list() {
+    if (!this.isInitialized()) {
+      throw new Error('Workspace not initialized. Run init first.');
+    }
+
+    const repos = [];
+
+    for (const repoName of this.config.repos) {
+      const repoPath = path.join(this.rootDir, repoName);
+      const info = {
+        name: repoName,
+        path: repoName,
+        status: 'ready',
+        hasTlc: false,
+        packageName: repoName,
+      };
+
+      // Check .tlc.json
+      const tlcPath = path.join(repoPath, '.tlc.json');
+      info.hasTlc = fs.existsSync(tlcPath);
+      info.status = info.hasTlc ? 'ready' : 'needs-init';
+
+      // Get package name
+      const pkgPath = path.join(repoPath, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+          if (pkg.name) {
+            info.packageName = pkg.name;
+          }
+        } catch (err) {
+          // Ignore
+        }
+      }
+
+      repos.push(info);
+    }
+
+    return repos;
+  }
+
+  /**
+   * Run tests across workspace
+   */
+  async test(options = {}) {
+    if (!this.isInitialized()) {
+      throw new Error('Workspace not initialized. Run init first.');
+    }
+
+    const runner = new WorkspaceTestRunner(this.rootDir, this.config.repos);
+    return runner.runTests(options);
+  }
+
+  /**
+   * Generate dependency graph (Mermaid)
+   */
+  async graph() {
+    if (!this.isInitialized()) {
+      throw new Error('Workspace not initialized. Run init first.');
+    }
+
+    const tracker = new RepoDependencyTracker(this.rootDir, this.config.repos);
+    return tracker.generateMermaidDiagram();
+  }
+
+  /**
+   * Get workspace status overview
+   */
+  async status() {
+    if (!this.isInitialized()) {
+      throw new Error('Workspace not initialized. Run init first.');
+    }
+
+    const repoList = await this.list();
+    const tracker = new RepoDependencyTracker(this.rootDir, this.config.repos);
+
+    return {
+      root: this.rootDir,
+      repoCount: this.config.repos.length,
+      repos: repoList.map(r => ({
+        name: r.name,
+        hasTlc: r.hasTlc,
+        status: r.status,
+        dependencies: tracker.getDependencies(r.name),
+        dependents: tracker.getDependents(r.name),
+      })),
+      dependencyGraph: tracker.getDependencyGraph(),
+      cycles: tracker.detectCircularDependencies(),
+    };
+  }
+}
+
+module.exports = {
+  WorkspaceCommand,
+};

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

@@ -0,0 +1,264 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const { WorkspaceCommand } = await import('./workspace-command.js');
+
+describe('WorkspaceCommand', () => {
+  let tempDir;
+  let command;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workspace-cmd-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  function createRepo(name, options = {}) {
+    const repoPath = path.join(tempDir, name);
+    fs.mkdirSync(repoPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(repoPath, 'package.json'),
+      JSON.stringify({
+        name: options.packageName || name,
+        version: '1.0.0',
+        scripts: { test: 'echo "pass"' },
+        dependencies: options.dependencies || {},
+      }, null, 2)
+    );
+
+    if (options.hasTlc) {
+      fs.writeFileSync(
+        path.join(repoPath, '.tlc.json'),
+        JSON.stringify({ project: name }, null, 2)
+      );
+    }
+
+    return repoPath;
+  }
+
+  describe('init', () => {
+    it('scans subdirectories for repos', async () => {
+      createRepo('repo-a');
+      createRepo('repo-b');
+
+      command = new WorkspaceCommand(tempDir);
+      const result = await command.init({ dryRun: true });
+
+      expect(result.discovered).toContain('repo-a');
+      expect(result.discovered).toContain('repo-b');
+    });
+
+    it('shows which repos need TLC setup', async () => {
+      createRepo('initialized', { hasTlc: true });
+      createRepo('uninitialized', { hasTlc: false });
+
+      command = new WorkspaceCommand(tempDir);
+      const result = await command.init({ dryRun: true });
+
+      expect(result.needsInit).toContain('uninitialized');
+      expect(result.needsInit).not.toContain('initialized');
+    });
+
+    it('bulk-initializes repos on confirm', async () => {
+      createRepo('new-repo-1');
+      createRepo('new-repo-2');
+
+      command = new WorkspaceCommand(tempDir);
+      const result = await command.init({ confirm: true });
+
+      expect(fs.existsSync(path.join(tempDir, 'new-repo-1', '.tlc.json'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'new-repo-2', '.tlc.json'))).toBe(true);
+      expect(result.initialized).toBe(2);
+    });
+
+    it('creates .tlc-workspace.json', async () => {
+      createRepo('my-repo');
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+
+      const configPath = path.join(tempDir, '.tlc-workspace.json');
+      expect(fs.existsSync(configPath)).toBe(true);
+
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      expect(config.repos).toContain('my-repo');
+    });
+
+    it('skips hidden directories and node_modules', async () => {
+      createRepo('valid-repo');
+      fs.mkdirSync(path.join(tempDir, '.hidden'));
+      fs.writeFileSync(path.join(tempDir, '.hidden', 'package.json'), '{}');
+      fs.mkdirSync(path.join(tempDir, 'node_modules'));
+      fs.writeFileSync(path.join(tempDir, 'node_modules', 'package.json'), '{}');
+
+      command = new WorkspaceCommand(tempDir);
+      const result = await command.init({ dryRun: true });
+
+      expect(result.discovered).toContain('valid-repo');
+      expect(result.discovered).not.toContain('.hidden');
+      expect(result.discovered).not.toContain('node_modules');
+    });
+  });
+
+  describe('add', () => {
+    it('adds repo to workspace', async () => {
+      createRepo('existing-repo', { hasTlc: true });
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      await command.add('existing-repo');
+
+      const config = command.getConfig();
+      expect(config.repos).toContain('existing-repo');
+    });
+
+    it('auto-initializes repo if no .tlc.json', async () => {
+      createRepo('uninit-repo');
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      await command.add('uninit-repo');
+
+      expect(fs.existsSync(path.join(tempDir, 'uninit-repo', '.tlc.json'))).toBe(true);
+    });
+
+    it('throws if repo does not exist', async () => {
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+
+      await expect(command.add('nonexistent')).rejects.toThrow(/not found/i);
+    });
+  });
+
+  describe('remove', () => {
+    it('removes repo from config', async () => {
+      createRepo('to-remove', { hasTlc: true });
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      await command.remove('to-remove');
+
+      const config = command.getConfig();
+      expect(config.repos).not.toContain('to-remove');
+    });
+
+    it('does not delete repo files', async () => {
+      createRepo('keep-files', { hasTlc: true });
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      await command.remove('keep-files');
+
+      // Files should still exist
+      expect(fs.existsSync(path.join(tempDir, 'keep-files', 'package.json'))).toBe(true);
+    });
+  });
+
+  describe('list', () => {
+    it('shows repos with status (ready/needs-init)', async () => {
+      createRepo('ready-repo', { hasTlc: true });
+      createRepo('needs-init-repo', { hasTlc: false });
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      const list = await command.list();
+
+      const readyRepo = list.find(r => r.name === 'ready-repo');
+      const needsInitRepo = list.find(r => r.name === 'needs-init-repo');
+
+      expect(readyRepo.status).toBe('ready');
+      // After init with confirm, all repos should be ready
+      expect(needsInitRepo.status).toBe('ready');
+    });
+
+    it('shows repo names and paths', async () => {
+      createRepo('my-app', { packageName: '@org/my-app' });
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      const list = await command.list();
+
+      const repo = list.find(r => r.name === 'my-app');
+      expect(repo.packageName).toBe('@org/my-app');
+      expect(repo.path).toBe('my-app');
+    });
+  });
+
+  describe('test', () => {
+    it('runs unified test runner', async () => {
+      createRepo('test-repo');
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      const result = await command.test();
+
+      expect(result.summary.total).toBe(1);
+      expect(result.summary.passed).toBe(1);
+    });
+
+    it('passes options to test runner', async () => {
+      createRepo('repo-1');
+      createRepo('repo-2');
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      const result = await command.test({ filter: ['repo-1'] });
+
+      expect(Object.keys(result.repos)).toEqual(['repo-1']);
+    });
+  });
+
+  describe('graph', () => {
+    it('outputs Mermaid diagram', async () => {
+      createRepo('core', { packageName: 'core' });
+      createRepo('api', {
+        packageName: 'api',
+        dependencies: { core: 'workspace:*' },
+      });
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      const diagram = await command.graph();
+
+      expect(diagram).toContain('graph TD');
+      expect(diagram).toContain('api');
+      expect(diagram).toContain('core');
+      expect(diagram).toContain('-->');
+    });
+  });
+
+  describe('status', () => {
+    it('shows repo health overview', async () => {
+      createRepo('healthy-repo', { hasTlc: true });
+
+      command = new WorkspaceCommand(tempDir);
+      await command.init({ confirm: true });
+      const status = await command.status();
+
+      expect(status.repos).toHaveLength(1);
+      expect(status.repos[0].name).toBe('healthy-repo');
+      expect(status.repos[0].hasTlc).toBe(true);
+    });
+  });
+
+  describe('error handling', () => {
+    it('handles workspace not initialized error', async () => {
+      command = new WorkspaceCommand(tempDir);
+
+      await expect(command.list()).rejects.toThrow(/not initialized/i);
+    });
+
+    it('handles empty workspace', async () => {
+      command = new WorkspaceCommand(tempDir);
+      const result = await command.init({ confirm: true });
+
+      expect(result.discovered).toEqual([]);
+      expect(result.initialized).toBe(0);
+    });
+  });
+});