tlc-claude-code 2.6.1 → 2.8.0

package/server/lib/workspace-manifest.js

@@ -0,0 +1,138 @@
+const fs = require('fs');
+const path = require('path');
+
+const MANIFEST_FILENAME = '.tlc-workspace.json';
+
+/**
+ * Validate the parsed workspace manifest structure.
+ *
+ * @param {object} manifest - Parsed manifest JSON.
+ * @returns {object} The validated manifest object.
+ */
+function validateManifest(manifest) {
+  if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+    throw new Error(`Invalid workspace manifest: expected object in ${MANIFEST_FILENAME}`);
+  }
+
+  if (!manifest.repos || typeof manifest.repos !== 'object' || Array.isArray(manifest.repos)) {
+    throw new Error(`Invalid workspace manifest: missing repos key in ${MANIFEST_FILENAME}`);
+  }
+
+  return manifest;
+}
+
+/**
+ * Discover and parse the nearest workspace manifest by walking up the tree.
+ *
+ * @param {string} startDir - Directory to start searching from.
+ * @returns {object|null} Parsed workspace manifest, or null when not found.
+ */
+function discoverWorkspace(startDir) {
+  let currentDir = path.resolve(startDir);
+
+  try {
+    if (!fs.statSync(currentDir).isDirectory()) {
+      currentDir = path.dirname(currentDir);
+    }
+  } catch {
+    currentDir = path.dirname(currentDir);
+  }
+
+  while (true) {
+    const manifestPath = path.join(currentDir, MANIFEST_FILENAME);
+
+    if (fs.existsSync(manifestPath)) {
+      let parsed;
+
+      try {
+        parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      } catch (error) {
+        throw new Error(
+          `Failed to parse workspace manifest at ${manifestPath}: ${error.message}`
+        );
+      }
+
+      return validateManifest(parsed);
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+/**
+ * Resolve a repository definition by prefix.
+ *
+ * @param {object} manifest - Parsed workspace manifest.
+ * @param {string} prefix - Repo prefix to look up.
+ * @returns {{ path: string, prefix: string, role: string }|null} Repo metadata or null.
+ */
+function resolveRepo(manifest, prefix) {
+  if (!manifest || !manifest.repos || !prefix) {
+    return null;
+  }
+
+  for (const repoConfig of Object.values(manifest.repos)) {
+    if (repoConfig && repoConfig.prefix === prefix) {
+      return {
+        path: repoConfig.path,
+        prefix: repoConfig.prefix,
+        role: repoConfig.role,
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Resolve a phase identifier into repo, prefix, and phase components.
+ *
+ * @param {object} manifest - Parsed workspace manifest.
+ * @param {string} phaseId - Phase identifier such as "CORE-2" or "108".
+ * @param {string} currentRepoPrefix - Prefix of the current repo for unprefixed phase IDs.
+ * @returns {{ repo: string, prefix: string, phase: string }|null} Resolved phase metadata or null.
+ */
+function resolvePhase(manifest, phaseId, currentRepoPrefix) {
+  if (!manifest || !manifest.repos || typeof phaseId !== 'string' || phaseId.length === 0) {
+    return null;
+  }
+
+  const prefixedMatch = /^([A-Z]+)-(.+)$/.exec(phaseId);
+  if (prefixedMatch) {
+    const [, prefix, phase] = prefixedMatch;
+
+    for (const [repo, repoConfig] of Object.entries(manifest.repos)) {
+      if (repoConfig && repoConfig.prefix === prefix) {
+        return { repo, prefix, phase };
+      }
+    }
+
+    return null;
+  }
+
+  if (!currentRepoPrefix) {
+    return null;
+  }
+
+  for (const [repo, repoConfig] of Object.entries(manifest.repos)) {
+    if (repoConfig && repoConfig.prefix === currentRepoPrefix) {
+      return {
+        repo,
+        prefix: currentRepoPrefix,
+        phase: phaseId,
+      };
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  discoverWorkspace,
+  resolveRepo,
+  resolvePhase,
+};

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

@@ -0,0 +1,179 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const {
+  discoverWorkspace,
+  resolveRepo,
+  resolvePhase,
+} = await import('./workspace-manifest.js');
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'workspace-manifest-'));
+}
+
+function writeJson(filePath, value) {
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2));
+}
+
+function removeDir(dirPath) {
+  fs.rmSync(dirPath, { recursive: true, force: true });
+}
+
+function createManifest(overrides = {}) {
+  return {
+    workspace: 'tlc-platform',
+    repos: {
+      TLC: { path: 'TLC', prefix: 'TLC', role: 'Runtime library' },
+      'tlc-core': { path: 'tlc-core', prefix: 'CORE', role: 'Execution substrate' },
+      'tlc-standalone': {
+        path: 'tlc-standalone',
+        prefix: 'SA',
+        role: 'Provider-agnostic CLI',
+      },
+    },
+    orchestrator: { url: 'http://localhost:3100', provider: 'tlc-core' },
+    ...overrides,
+  };
+}
+
+describe('workspace-manifest', () => {
+  const tempDirs = [];
+
+  afterEach(() => {
+    while (tempDirs.length > 0) {
+      removeDir(tempDirs.pop());
+    }
+  });
+
+  it('discoverWorkspace from subdirectory finds manifest at parent', () => {
+    const rootDir = makeTmpDir();
+    tempDirs.push(rootDir);
+
+    const nestedDir = path.join(rootDir, 'TLC', 'server', 'lib');
+    fs.mkdirSync(nestedDir, { recursive: true });
+    writeJson(path.join(rootDir, '.tlc-workspace.json'), createManifest());
+
+    const manifest = discoverWorkspace(nestedDir);
+
+    expect(manifest).not.toBeNull();
+    expect(manifest.workspace).toBe('tlc-platform');
+    expect(manifest.repos.TLC.path).toBe('TLC');
+    expect(manifest.repos['tlc-core'].prefix).toBe('CORE');
+  });
+
+  it('resolveRepo("CORE") returns tlc-core metadata', () => {
+    const manifest = createManifest();
+
+    expect(resolveRepo(manifest, 'CORE')).toEqual({
+      path: 'tlc-core',
+      prefix: 'CORE',
+      role: 'Execution substrate',
+    });
+  });
+
+  it('resolvePhase("CORE-2") parses correctly', () => {
+    const manifest = createManifest();
+
+    expect(resolvePhase(manifest, 'CORE-2', 'TLC')).toEqual({
+      repo: 'tlc-core',
+      prefix: 'CORE',
+      phase: '2',
+    });
+  });
+
+  it('resolvePhase("108", "TLC") returns TLC-108', () => {
+    const manifest = createManifest();
+
+    expect(resolvePhase(manifest, '108', 'TLC')).toEqual({
+      repo: 'TLC',
+      prefix: 'TLC',
+      phase: '108',
+    });
+  });
+
+  it('discoverWorkspace from /tmp returns null when no manifest exists in tree', () => {
+    const rootDir = makeTmpDir();
+    tempDirs.push(rootDir);
+
+    const nestedDir = path.join(rootDir, 'lonely', 'child');
+    fs.mkdirSync(nestedDir, { recursive: true });
+
+    expect(discoverWorkspace(nestedDir)).toBeNull();
+  });
+
+  it('resolveRepo("UNKNOWN") returns null', () => {
+    const manifest = createManifest();
+
+    expect(resolveRepo(manifest, 'UNKNOWN')).toBeNull();
+  });
+
+  it('resolvePhase("NOPE-1") returns null', () => {
+    const manifest = createManifest();
+
+    expect(resolvePhase(manifest, 'NOPE-1', 'TLC')).toBeNull();
+  });
+
+  it('invalid JSON throws descriptive error', () => {
+    const rootDir = makeTmpDir();
+    tempDirs.push(rootDir);
+
+    fs.writeFileSync(
+      path.join(rootDir, '.tlc-workspace.json'),
+      '{"workspace":"tlc-platform","repos":'
+    );
+
+    expect(() => discoverWorkspace(rootDir)).toThrow(/parse workspace manifest/i);
+  });
+
+  it('manifest missing repos key throws descriptive error', () => {
+    const rootDir = makeTmpDir();
+    tempDirs.push(rootDir);
+
+    writeJson(path.join(rootDir, '.tlc-workspace.json'), {
+      workspace: 'tlc-platform',
+      orchestrator: { url: 'http://localhost:3100', provider: 'tlc-core' },
+    });
+
+    expect(() => discoverWorkspace(rootDir)).toThrow(/missing repos key/i);
+  });
+
+  it('discoverWorkspace accepts a file path and searches from its parent directory', () => {
+    const rootDir = makeTmpDir();
+    tempDirs.push(rootDir);
+
+    const repoDir = path.join(rootDir, 'TLC');
+    const filePath = path.join(repoDir, 'server', 'lib', 'workspace-manifest.js');
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, '// fixture');
+    writeJson(path.join(rootDir, '.tlc-workspace.json'), createManifest());
+
+    const manifest = discoverWorkspace(filePath);
+
+    expect(manifest.repos['tlc-standalone']).toEqual({
+      path: 'tlc-standalone',
+      prefix: 'SA',
+      role: 'Provider-agnostic CLI',
+    });
+  });
+
+  it('resolvePhase returns null for unprefixed phase when current repo prefix is unknown', () => {
+    const manifest = createManifest();
+
+    expect(resolvePhase(manifest, '108', 'NOPE')).toBeNull();
+  });
+
+  it('resolvePhase returns null when current repo prefix is not provided for unprefixed phase', () => {
+    const manifest = createManifest();
+
+    expect(resolvePhase(manifest, '108')).toBeNull();
+  });
+
+  it('resolveRepo returns null when prefix is missing', () => {
+    const manifest = createManifest();
+
+    expect(resolveRepo(manifest)).toBeNull();
+    expect(resolveRepo(manifest, '')).toBeNull();
+  });
+});