tlc-claude-code 2.4.2 → 2.4.4

package/server/lib/orchestration/codex-orchestrator.test.js

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi } from 'vitest';
+import { dispatchToCodex, resumeSession } from './codex-orchestrator.js';
+
+function createMockSpawn({
+  stdoutChunks = [],
+  stderrChunks = [],
+  exitCode = 0,
+  delay = 0,
+  error = null,
+} = {}) {
+  return vi.fn(() => {
+    const listeners = {};
+    const stdinChunks = [];
+
+    const proc = {
+      stdin: {
+        write(data) { stdinChunks.push(data); },
+        end() { stdinChunks.push(null); },
+        on(event, cb) { listeners[`stdin:${event}`] = cb; },
+      },
+      stdout: {
+        on(event, cb) { listeners[`stdout:${event}`] = cb; },
+      },
+      stderr: {
+        on(event, cb) { listeners[`stderr:${event}`] = cb; },
+      },
+      on(event, cb) { listeners[event] = cb; },
+      kill: vi.fn(() => {
+        listeners._killed = true;
+      }),
+      _stdinChunks: stdinChunks,
+      _listeners: listeners,
+    };
+
+    setTimeout(() => {
+      if (error) {
+        listeners.error?.(error);
+        return;
+      }
+
+      stdoutChunks.forEach((chunk) => {
+        listeners['stdout:data']?.(Buffer.from(chunk));
+      });
+
+      stderrChunks.forEach((chunk) => {
+        listeners['stderr:data']?.(Buffer.from(chunk));
+      });
+
+      if (!listeners._killed) {
+        listeners.close?.(exitCode);
+      }
+    }, delay);
+
+    return proc;
+  });
+}
+
+describe('codex-orchestrator', () => {
+  describe('dispatchToCodex', () => {
+    it('builds correct command args', async () => {
+      const spawn = createMockSpawn();
+
+      await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Implement the task',
+        spawn,
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'codex',
+        ['exec', '--json', '--full-auto', '-C', '/tmp/worktree'],
+        {}
+      );
+    });
+
+    it('pipes prompt via stdin', async () => {
+      const spawn = createMockSpawn();
+
+      await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Review this change',
+        spawn,
+      });
+
+      const proc = spawn.mock.results[0].value;
+      expect(proc._stdinChunks).toContain('Review this change');
+      expect(proc._stdinChunks).toContain(null);
+    });
+
+    it('extracts thread_id from JSON stream', async () => {
+      const spawn = createMockSpawn({
+        stdoutChunks: [
+          '{"type":"status","message":"booting"}\n',
+          '{"type":"thread.started","thread_id":"thread_123"}\n',
+          '{"type":"message.delta","delta":"done"}\n',
+        ],
+      });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Do work',
+        spawn,
+      });
+
+      expect(result.threadId).toBe('thread_123');
+      expect(result.stdout).toContain('"thread_id":"thread_123"');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('ignores invalid JSON lines and still extracts thread_id', async () => {
+      const spawn = createMockSpawn({
+        stdoutChunks: [
+          'not-json\n',
+          '{"type":"thread.started","thread_id":"thread_abc"}\n',
+        ],
+      });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Do work',
+        spawn,
+      });
+
+      expect(result.threadId).toBe('thread_abc');
+    });
+
+    it('timeout kills process and returns error', async () => {
+      const spawn = createMockSpawn({ delay: 1000 });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Slow task',
+        timeout: 25,
+        spawn,
+      });
+
+      const proc = spawn.mock.results[0].value;
+      expect(proc.kill).toHaveBeenCalledTimes(1);
+      expect(result.exitCode).toBe(-1);
+      expect(result.error).toEqual(
+        expect.objectContaining({ code: 'PROCESS_TIMEOUT' })
+      );
+      expect(result.stderr).toContain('timed out');
+    });
+
+    it('missing codex CLI returns structured error', async () => {
+      const spawn = createMockSpawn({
+        error: Object.assign(new Error('spawn codex ENOENT'), { code: 'ENOENT' }),
+      });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Task',
+        spawn,
+      });
+
+      expect(result.exitCode).toBe(-1);
+      expect(result.threadId).toBeNull();
+      expect(result.error).toEqual({
+        code: 'CODEX_CLI_NOT_FOUND',
+        message: 'Codex CLI is not installed or not available on PATH',
+      });
+      expect(result.stderr).toContain('ENOENT');
+    });
+
+    it('captures non-zero exit without throwing', async () => {
+      const spawn = createMockSpawn({
+        stderrChunks: ['process failed'],
+        exitCode: 17,
+      });
+
+      const result = await dispatchToCodex({
+        worktreePath: '/tmp/worktree',
+        prompt: 'Task',
+        spawn,
+      });
+
+      expect(result.exitCode).toBe(17);
+      expect(result.stderr).toBe('process failed');
+      expect(result.error).toBeNull();
+    });
+  });
+
+  describe('resumeSession', () => {
+    it('builds correct resume command', async () => {
+      const spawn = createMockSpawn();
+
+      await resumeSession({
+        threadId: 'thread_123',
+        prompt: 'Continue',
+        spawn,
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'codex',
+        ['exec', 'resume', 'thread_123', 'Continue'],
+        {}
+      );
+    });
+
+    it('passes prompt correctly', async () => {
+      const spawn = createMockSpawn({
+        stdoutChunks: ['resumed'],
+      });
+
+      const result = await resumeSession({
+        threadId: 'thread_123',
+        prompt: 'Follow up task',
+        spawn,
+      });
+
+      expect(spawn).toHaveBeenCalledWith(
+        'codex',
+        ['exec', 'resume', 'thread_123', 'Follow up task'],
+        {}
+      );
+      expect(result.stdout).toBe('resumed');
+      expect(result.exitCode).toBe(0);
+    });
+  });
+});

package/server/lib/orchestration/dep-linker.js

@@ -0,0 +1,61 @@
+const path = require('path');
+
+const DEP_DIRS = ['node_modules', 'vendor', '.venv'];
+
+function pathExists(fs, targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function readExistingLinkTarget(fs, linkPath) {
+  try {
+    return path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+  } catch {
+    return null;
+  }
+}
+
+function symlinkDeps({ worktreePath, mainRepoPath, fs = require('fs') }) {
+  const linked = [];
+  const skipped = [];
+  const symlinkType = process.platform === 'win32' ? 'junction' : 'dir';
+
+  for (const depDir of DEP_DIRS) {
+    const sourcePath = path.join(mainRepoPath, depDir);
+    const targetPath = path.join(worktreePath, depDir);
+
+    if (!pathExists(fs, sourcePath)) {
+      skipped.push(depDir);
+      continue;
+    }
+
+    let targetStats = null;
+    try {
+      targetStats = fs.lstatSync(targetPath);
+    } catch {
+      targetStats = null;
+    }
+
+    if (targetStats) {
+      if (targetStats.isSymbolicLink()) {
+        if (readExistingLinkTarget(fs, targetPath) === sourcePath) {
+          skipped.push(depDir);
+          continue;
+        }
+
+        fs.rmSync(targetPath, { recursive: true, force: true });
+      } else {
+        skipped.push(depDir);
+        continue;
+      }
+    }
+
+    fs.symlinkSync(sourcePath, targetPath, symlinkType);
+    linked.push(depDir);
+  }
+
+  return { linked, skipped };
+}
+
+module.exports = {
+  symlinkDeps,
+};

package/server/lib/orchestration/dep-linker.test.js

@@ -0,0 +1,174 @@
+import { afterEach, describe, expect, it } from 'vitest';
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { symlinkDeps } = require('./dep-linker.js');
+
+const tempPaths = [];
+
+function makeTempDir() {
+  const dirPath = path.join(os.tmpdir(), `dep-linker-${crypto.randomUUID()}`);
+  fs.mkdirSync(dirPath, { recursive: true });
+  tempPaths.push(dirPath);
+  return dirPath;
+}
+
+function createRepoPair() {
+  const rootPath = makeTempDir();
+  const mainRepoPath = path.join(rootPath, 'main');
+  const worktreePath = path.join(rootPath, 'worktree');
+
+  fs.mkdirSync(mainRepoPath, { recursive: true });
+  fs.mkdirSync(worktreePath, { recursive: true });
+
+  return { mainRepoPath, worktreePath };
+}
+
+function makeDir(targetPath) {
+  fs.mkdirSync(targetPath, { recursive: true });
+}
+
+function readLinkTarget(linkPath) {
+  return path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+}
+
+afterEach(() => {
+  while (tempPaths.length > 0) {
+    fs.rmSync(tempPaths.pop(), { recursive: true, force: true });
+  }
+});
+
+describe('dep-linker', () => {
+  it('symlinks node_modules when exists in main', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const sourcePath = path.join(mainRepoPath, 'node_modules');
+    const linkPath = path.join(worktreePath, 'node_modules');
+
+    makeDir(sourcePath);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual(['node_modules']);
+    expect(result.skipped).toEqual(['vendor', '.venv']);
+    expect(fs.lstatSync(linkPath).isSymbolicLink()).toBe(true);
+    expect(readLinkTarget(linkPath)).toBe(sourcePath);
+  });
+
+  it('skips node_modules when missing from main', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual([]);
+    expect(result.skipped).toEqual(['node_modules', 'vendor', '.venv']);
+    expect(fs.existsSync(path.join(worktreePath, 'node_modules'))).toBe(false);
+  });
+
+  it('symlinks vendor when exists', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const sourcePath = path.join(mainRepoPath, 'vendor');
+    const linkPath = path.join(worktreePath, 'vendor');
+
+    makeDir(sourcePath);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual(['vendor']);
+    expect(result.skipped).toEqual(['node_modules', '.venv']);
+    expect(fs.lstatSync(linkPath).isSymbolicLink()).toBe(true);
+    expect(readLinkTarget(linkPath)).toBe(sourcePath);
+  });
+
+  it('symlinks .venv when exists', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const sourcePath = path.join(mainRepoPath, '.venv');
+    const linkPath = path.join(worktreePath, '.venv');
+
+    makeDir(sourcePath);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual(['.venv']);
+    expect(result.skipped).toEqual(['node_modules', 'vendor']);
+    expect(fs.lstatSync(linkPath).isSymbolicLink()).toBe(true);
+    expect(readLinkTarget(linkPath)).toBe(sourcePath);
+  });
+
+  it('returns correct linked and skipped arrays', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+
+    makeDir(path.join(mainRepoPath, 'node_modules'));
+    makeDir(path.join(mainRepoPath, 'vendor'));
+
+    expect(symlinkDeps({ worktreePath, mainRepoPath, fs })).toEqual({
+      linked: ['node_modules', 'vendor'],
+      skipped: ['.venv'],
+    });
+  });
+
+  it('skips when worktree already has real directory', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const existingPath = path.join(worktreePath, 'node_modules');
+
+    makeDir(path.join(mainRepoPath, 'node_modules'));
+    makeDir(existingPath);
+    fs.writeFileSync(path.join(existingPath, 'keep.txt'), 'present');
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual([]);
+    expect(result.skipped).toEqual(['node_modules', 'vendor', '.venv']);
+    expect(fs.lstatSync(existingPath).isDirectory()).toBe(true);
+    expect(fs.lstatSync(existingPath).isSymbolicLink()).toBe(false);
+    expect(fs.readFileSync(path.join(existingPath, 'keep.txt'), 'utf8')).toBe('present');
+  });
+
+  it('skips when correct symlink already exists', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+    const sourcePath = path.join(mainRepoPath, 'node_modules');
+    const linkPath = path.join(worktreePath, 'node_modules');
+    const symlinkType = process.platform === 'win32' ? 'junction' : 'dir';
+
+    makeDir(sourcePath);
+    fs.symlinkSync(sourcePath, linkPath, symlinkType);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual([]);
+    expect(result.skipped).toEqual(['node_modules', 'vendor', '.venv']);
+    expect(readLinkTarget(linkPath)).toBe(sourcePath);
+  });
+
+  it('handles all three dirs in one call', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+
+    makeDir(path.join(mainRepoPath, 'node_modules'));
+    makeDir(path.join(mainRepoPath, 'vendor'));
+    makeDir(path.join(mainRepoPath, '.venv'));
+
+    expect(symlinkDeps({ worktreePath, mainRepoPath, fs })).toEqual({
+      linked: ['node_modules', 'vendor', '.venv'],
+      skipped: [],
+    });
+
+    expect(fs.lstatSync(path.join(worktreePath, 'node_modules')).isSymbolicLink()).toBe(true);
+    expect(fs.lstatSync(path.join(worktreePath, 'vendor')).isSymbolicLink()).toBe(true);
+    expect(fs.lstatSync(path.join(worktreePath, '.venv')).isSymbolicLink()).toBe(true);
+  });
+
+  it('works with empty worktree dir', () => {
+    const { mainRepoPath, worktreePath } = createRepoPair();
+
+    makeDir(path.join(mainRepoPath, 'node_modules'));
+
+    expect(fs.readdirSync(worktreePath)).toEqual([]);
+
+    const result = symlinkDeps({ worktreePath, mainRepoPath, fs });
+
+    expect(result.linked).toEqual(['node_modules']);
+    expect(result.skipped).toEqual(['vendor', '.venv']);
+    expect(fs.lstatSync(path.join(worktreePath, 'node_modules')).isSymbolicLink()).toBe(true);
+  });
+});

package/server/lib/orchestration/prompt-builder.js

@@ -0,0 +1,118 @@
+const path = require('path');
+const { packagePrompt } = require('../prompt-packager.js');
+
+function formatBulletList(items = []) {
+  return items.map((item) => `  - ${item}`).join('\n');
+}
+
+function buildTaskPrompt({ goal, files = [], criteria = [], testCases = [] }) {
+  return [
+    `Goal: ${goal}`,
+    '',
+    'Files to work with:',
+    formatBulletList(files),
+    '',
+    'Acceptance criteria:',
+    formatBulletList(criteria),
+    '',
+    'Test cases:',
+    formatBulletList(testCases),
+    '',
+    'Methodology: Write tests first (red → green → refactor). You MUST write the test before implementing any code. Test-first is required.',
+  ].join('\n');
+}
+
+function buildContextPrompt({
+  agentPrompt,
+  projectDoc,
+  planDoc,
+  codingStandards,
+  files,
+  tokenBudget = 100000,
+}) {
+  return packagePrompt({
+    agentPrompt,
+    projectDoc,
+    planDoc,
+    codingStandards,
+    files,
+    tokenBudget,
+  });
+}
+
+function readOptionalFile(fsImpl, filePath) {
+  if (!fsImpl.existsSync(filePath)) {
+    return null;
+  }
+  return fsImpl.readFileSync(filePath, 'utf-8');
+}
+
+function findPlanPath(projectDir, phase, fsImpl) {
+  if (!phase) {
+    return path.join(projectDir, 'PLAN.md');
+  }
+
+  const phasesDir = path.join(projectDir, '.planning', 'phases');
+  const exactPath = path.join(phasesDir, `${phase}-PLAN.md`);
+  if (fsImpl.existsSync(exactPath)) {
+    return exactPath;
+  }
+
+  if (!fsImpl.existsSync(phasesDir)) {
+    return path.join(projectDir, 'PLAN.md');
+  }
+
+  try {
+    const padded = String(phase).padStart(2, '0');
+    const match = fsImpl.readdirSync(phasesDir).find(
+      (name) =>
+        (name.startsWith(`${padded}-`) || name.startsWith(`${phase}-`)) &&
+        name.endsWith('-PLAN.md')
+    );
+
+    if (match) {
+      return path.join(phasesDir, match);
+    }
+  } catch {
+    return path.join(projectDir, 'PLAN.md');
+  }
+
+  return path.join(projectDir, 'PLAN.md');
+}
+
+function readRelevantFiles(fsImpl, projectDir, filePaths = []) {
+  return filePaths.reduce((acc, filePath) => {
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(projectDir, filePath);
+    if (!fsImpl.existsSync(absolutePath)) {
+      return acc;
+    }
+
+    acc.push({
+      path: filePath,
+      content: fsImpl.readFileSync(absolutePath, 'utf-8'),
+    });
+    return acc;
+  }, []);
+}
+
+function buildFullPrompt({ task, projectDir, phase, fs: fsImpl = require('fs') }) {
+  const agentPrompt = buildTaskPrompt(task);
+  const projectDoc = readOptionalFile(fsImpl, path.join(projectDir, 'PROJECT.md'));
+  const planDoc = readOptionalFile(fsImpl, findPlanPath(projectDir, phase, fsImpl));
+  const codingStandards = readOptionalFile(fsImpl, path.join(projectDir, 'CODING-STANDARDS.md'));
+  const files = readRelevantFiles(fsImpl, projectDir, task.files);
+
+  return buildContextPrompt({
+    agentPrompt,
+    projectDoc,
+    planDoc,
+    codingStandards,
+    files,
+  });
+}
+
+module.exports = {
+  buildTaskPrompt,
+  buildContextPrompt,
+  buildFullPrompt,
+};