tlc-claude-code 2.4.10 → 2.6.0

package/server/lib/orchestration/result-verifier.test.js

@@ -0,0 +1,291 @@
+import { describe, it, expect, vi } from 'vitest';
+
+const { takeSnapshot, verifyResult } = require('./result-verifier.js');
+
+describe('result-verifier', () => {
+  describe('takeSnapshot', () => {
+    it('returns git state with hash, tracked, and untracked files', () => {
+      const exec = vi.fn()
+        .mockReturnValueOnce('abc1234')                   // git rev-parse HEAD
+        .mockReturnValueOnce('src/a.js\nsrc/b.js\n')      // git ls-files
+        .mockReturnValueOnce('new-file.js\n');             // git ls-files --others --exclude-standard
+
+      const snapshot = takeSnapshot({ worktreePath: '/tmp/wt', exec });
+
+      expect(exec).toHaveBeenCalledWith('git rev-parse HEAD', { cwd: '/tmp/wt' });
+      expect(exec).toHaveBeenCalledWith('git ls-files', { cwd: '/tmp/wt' });
+      expect(exec).toHaveBeenCalledWith(
+        'git ls-files --others --exclude-standard',
+        { cwd: '/tmp/wt' }
+      );
+      expect(snapshot).toEqual({
+        gitHash: 'abc1234',
+        trackedFiles: ['src/a.js', 'src/b.js'],
+        untrackedFiles: ['new-file.js'],
+      });
+    });
+
+    it('handles empty repos gracefully', () => {
+      const exec = vi.fn()
+        .mockReturnValueOnce('def5678')
+        .mockReturnValueOnce('')
+        .mockReturnValueOnce('');
+
+      const snapshot = takeSnapshot({ worktreePath: '/tmp/empty', exec });
+
+      expect(snapshot).toEqual({
+        gitHash: 'def5678',
+        trackedFiles: [],
+        untrackedFiles: [],
+      });
+    });
+  });
+
+  describe('verifyResult', () => {
+    function makePreSnapshot(overrides = {}) {
+      return {
+        gitHash: 'aaa1111',
+        trackedFiles: ['src/main.js'],
+        untrackedFiles: [],
+        ...overrides,
+      };
+    }
+
+    function makeExec({ diffOutput = '', testExitCode = 0 } = {}) {
+      const fn = vi.fn().mockImplementation((cmd) => {
+        if (cmd.startsWith('git diff')) {
+          return diffOutput;
+        }
+        if (cmd.startsWith('git rev-parse')) {
+          return 'bbb2222';
+        }
+        if (cmd.startsWith('git ls-files --others')) {
+          return '';
+        }
+        if (cmd.startsWith('git ls-files')) {
+          return 'src/main.js\n';
+        }
+        // Test runner
+        if (testExitCode !== 0) {
+          const err = new Error('tests failed');
+          err.status = testExitCode;
+          throw err;
+        }
+        return 'Tests passed';
+      });
+      return fn;
+    }
+
+    it('detects file changes via git diff', () => {
+      const exec = makeExec({
+        diffOutput: 'src/main.js\nsrc/utils.js\nsrc/utils.test.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.filesChanged).toEqual(['src/main.js', 'src/utils.js', 'src/utils.test.js']);
+      expect(result.success).toBe(true);
+    });
+
+    it('detects no changes and returns failure', () => {
+      const exec = makeExec({ diffOutput: '' });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('no_changes');
+      expect(result.filesChanged).toEqual([]);
+    });
+
+    it('detects test files added', () => {
+      const exec = makeExec({
+        diffOutput: 'src/widget.js\nsrc/widget.test.js\nsrc/widget.spec.ts\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.testsAdded).toEqual(['src/widget.test.js', 'src/widget.spec.ts']);
+      expect(result.success).toBe(true);
+    });
+
+    it('detects no test files and returns partial failure', () => {
+      const exec = makeExec({
+        diffOutput: 'src/feature.js\nsrc/helpers.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('no_tests');
+      expect(result.testsAdded).toEqual([]);
+      expect(result.filesChanged).toEqual(['src/feature.js', 'src/helpers.js']);
+    });
+
+    it('detects test failures', () => {
+      const exec = vi.fn().mockImplementation((cmd) => {
+        if (cmd.startsWith('git diff')) {
+          return 'src/foo.js\nsrc/foo.test.js\n';
+        }
+        if (cmd.startsWith('git rev-parse')) {
+          return 'bbb2222';
+        }
+        if (cmd.startsWith('git ls-files --others')) {
+          return '';
+        }
+        if (cmd.startsWith('git ls-files')) {
+          return 'src/main.js\nsrc/foo.js\nsrc/foo.test.js\n';
+        }
+        // test runner command fails
+        const err = new Error('test suite failed');
+        err.status = 1;
+        throw err;
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+        runTests: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('tests_failing');
+      expect(result.testsPassing).toBe(false);
+    });
+
+    it('returns success when files changed and tests pass', () => {
+      const exec = vi.fn().mockImplementation((cmd) => {
+        if (cmd.startsWith('git diff')) {
+          return 'src/api.js\nsrc/api.test.js\n';
+        }
+        if (cmd.startsWith('git rev-parse')) {
+          return 'ccc3333';
+        }
+        if (cmd.startsWith('git ls-files --others')) {
+          return '';
+        }
+        if (cmd.startsWith('git ls-files')) {
+          return 'src/main.js\nsrc/api.js\nsrc/api.test.js\n';
+        }
+        return 'All tests passed';
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+        runTests: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.testsPassing).toBe(true);
+      expect(result.failureReason).toBeNull();
+      expect(result.filesChanged).toEqual(['src/api.js', 'src/api.test.js']);
+      expect(result.testsAdded).toEqual(['src/api.test.js']);
+    });
+
+    it('handles exec timeout by returning timeout failure', () => {
+      const exec = vi.fn().mockImplementation((cmd) => {
+        if (cmd.startsWith('git diff')) {
+          const err = new Error('Command timed out');
+          err.code = 'ETIMEDOUT';
+          throw err;
+        }
+        if (cmd.startsWith('git rev-parse')) {
+          return 'abc123';
+        }
+        if (cmd.startsWith('git ls-files --others')) {
+          return '';
+        }
+        if (cmd.startsWith('git ls-files')) {
+          return '';
+        }
+        return '';
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('timeout');
+    });
+
+    it('returns partial when implementation exists but no tests', () => {
+      const exec = makeExec({
+        diffOutput: 'src/new-module.js\nlib/helpers.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('no_tests');
+      expect(result.filesChanged.length).toBe(2);
+      expect(result.testsAdded).toEqual([]);
+    });
+
+    it('produces a human-readable summary', () => {
+      const exec = makeExec({
+        diffOutput: 'src/component.js\nsrc/component.test.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(typeof result.summary).toBe('string');
+      expect(result.summary.length).toBeGreaterThan(0);
+      expect(result.summary).toContain('2');  // file count
+    });
+
+    it('skips test execution when runTests is false or omitted', () => {
+      const exec = makeExec({
+        diffOutput: 'src/api.js\nsrc/api.test.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+        // runTests is not set — defaults to false
+      });
+
+      expect(result.testsPassing).toBeNull();
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/server/lib/orchestration/session-dispatcher.js

@@ -0,0 +1,99 @@
+const fs = require('fs/promises');
+const path = require('path');
+
+async function readActiveSessions(activeSessionsPath) {
+  try {
+    const raw = await fs.readFile(activeSessionsPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+async function writeActiveSessions(activeSessionsPath, sessions) {
+  await fs.mkdir(path.dirname(activeSessionsPath), { recursive: true });
+  await fs.writeFile(activeSessionsPath, JSON.stringify(sessions, null, 2));
+}
+
+async function dispatchToOrchestrator({
+  orchestratorUrl,
+  project,
+  tasks = [],
+  phaseBranch,
+  activeSessionsPath,
+  fetch = globalThis.fetch,
+}) {
+  void phaseBranch;
+
+  if (tasks.length === 0) {
+    return {
+      dispatched: 0,
+      sessions: [],
+      errors: [],
+    };
+  }
+
+  const baseUrl = String(orchestratorUrl).replace(/\/+$/, '');
+  const sessions = [];
+  const activeSessions = [];
+  const errors = [];
+
+  for (const task of tasks) {
+    try {
+      const response = await fetch(`${baseUrl}/sessions`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          project,
+          pool: 'local-tmux',
+          command: task.provider,
+          prompt: task.prompt,
+        }),
+      });
+
+      if (!response || !response.ok) {
+        errors.push(`${task.name}: ${response ? response.status : 'request failed'}`);
+        continue;
+      }
+
+      const payload = await response.json();
+      if (!payload || !payload.id) {
+        errors.push(`${task.name}: invalid session response`);
+        continue;
+      }
+
+      sessions.push({ id: payload.id, taskName: task.name });
+      activeSessions.push({
+        sessionId: payload.id,
+        taskName: task.name,
+        startedAt: new Date().toISOString(),
+      });
+    } catch (error) {
+      if (sessions.length === 0 && errors.length === 0) {
+        return {
+          dispatched: 0,
+          errors: ['orchestrator unreachable'],
+          fallback: true,
+        };
+      }
+
+      errors.push(`${task.name}: ${error.message}`);
+    }
+  }
+
+  if (activeSessions.length > 0) {
+    const existing = await readActiveSessions(activeSessionsPath);
+    await writeActiveSessions(activeSessionsPath, [...existing, ...activeSessions]);
+  }
+
+  return {
+    dispatched: sessions.length,
+    sessions,
+    errors,
+  };
+}
+
+module.exports = {
+  dispatchToOrchestrator,
+};

package/server/lib/orchestration/session-dispatcher.test.js

@@ -0,0 +1,215 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const { dispatchToOrchestrator } = require('./session-dispatcher.js');
+
+function makeTask(overrides = {}) {
+  return {
+    name: 'Task 1',
+    provider: 'codex',
+    prompt: 'Implement feature',
+    ...overrides,
+  };
+}
+
+describe('session-dispatcher', () => {
+  const tempDirs = [];
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    while (tempDirs.length > 0) {
+      fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+    }
+  });
+
+  function makeActiveSessionsPath() {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'session-dispatcher-test-'));
+    tempDirs.push(tempDir);
+    return path.join(tempDir, '.tlc', '.active-sessions.json');
+  }
+
+  it('dispatches 3 tasks and creates 3 sessions', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const tasks = [
+      makeTask({ name: 'Task 1', provider: 'claude', prompt: 'Prompt 1' }),
+      makeTask({ name: 'Task 2', provider: 'codex', prompt: 'Prompt 2' }),
+      makeTask({ name: 'Task 3', provider: 'gemini', prompt: 'Prompt 3' }),
+    ];
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-1' }) })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-2' }) })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-3' }) });
+
+    const result = await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test/',
+      project: 'tlc',
+      tasks,
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    expect(fetch).toHaveBeenCalledTimes(3);
+    expect(fetch).toHaveBeenNthCalledWith(1, 'http://orchestrator.test/sessions', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: 'tlc',
+        pool: 'local-tmux',
+        command: 'claude',
+        prompt: 'Prompt 1',
+      }),
+    });
+    expect(fetch).toHaveBeenNthCalledWith(2, 'http://orchestrator.test/sessions', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: 'tlc',
+        pool: 'local-tmux',
+        command: 'codex',
+        prompt: 'Prompt 2',
+      }),
+    });
+    expect(fetch).toHaveBeenNthCalledWith(3, 'http://orchestrator.test/sessions', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: 'tlc',
+        pool: 'local-tmux',
+        command: 'gemini',
+        prompt: 'Prompt 3',
+      }),
+    });
+    expect(result).toEqual({
+      dispatched: 3,
+      sessions: [
+        { id: 'session-1', taskName: 'Task 1' },
+        { id: 'session-2', taskName: 'Task 2' },
+        { id: 'session-3', taskName: 'Task 3' },
+      ],
+      errors: [],
+    });
+  });
+
+  it('writes session IDs to the active sessions file', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-1' }) })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-2' }) });
+
+    await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test',
+      project: 'tlc',
+      tasks: [
+        makeTask({ name: 'Task 1', prompt: 'Prompt 1' }),
+        makeTask({ name: 'Task 2', prompt: 'Prompt 2' }),
+      ],
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    const written = JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'));
+    expect(written).toHaveLength(2);
+    expect(written[0]).toEqual({
+      sessionId: 'session-1',
+      taskName: 'Task 1',
+      startedAt: expect.any(String),
+    });
+    expect(written[1]).toEqual({
+      sessionId: 'session-2',
+      taskName: 'Task 2',
+      startedAt: expect.any(String),
+    });
+  });
+
+  it('returns fallback when the orchestrator is unreachable', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const fetch = vi.fn().mockRejectedValue(new Error('connect ECONNREFUSED'));
+
+    const result = await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test',
+      project: 'tlc',
+      tasks: [makeTask()],
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    expect(result).toEqual({
+      dispatched: 0,
+      errors: ['orchestrator unreachable'],
+      fallback: true,
+    });
+    expect(fs.existsSync(activeSessionsPath)).toBe(false);
+  });
+
+  it('reports errors for partial failure', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const fetch = vi
+      .fn()
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-1' }) })
+      .mockResolvedValueOnce({ ok: false, status: 500, json: async () => ({}) })
+      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 'session-3' }) });
+
+    const result = await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test',
+      project: 'tlc',
+      tasks: [
+        makeTask({ name: 'Task 1', prompt: 'Prompt 1' }),
+        makeTask({ name: 'Task 2', prompt: 'Prompt 2' }),
+        makeTask({ name: 'Task 3', prompt: 'Prompt 3' }),
+      ],
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    expect(result).toEqual({
+      dispatched: 2,
+      sessions: [
+        { id: 'session-1', taskName: 'Task 1' },
+        { id: 'session-3', taskName: 'Task 3' },
+      ],
+      errors: ['Task 2: 500'],
+    });
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([
+      {
+        sessionId: 'session-1',
+        taskName: 'Task 1',
+        startedAt: expect.any(String),
+      },
+      {
+        sessionId: 'session-3',
+        taskName: 'Task 3',
+        startedAt: expect.any(String),
+      },
+    ]);
+  });
+
+  it('returns dispatched 0 for an empty task list', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const fetch = vi.fn();
+
+    const result = await dispatchToOrchestrator({
+      orchestratorUrl: 'http://orchestrator.test',
+      project: 'tlc',
+      tasks: [],
+      phaseBranch: 'phase/test',
+      activeSessionsPath,
+      fetch,
+    });
+
+    expect(result).toEqual({
+      dispatched: 0,
+      sessions: [],
+      errors: [],
+    });
+    expect(fetch).not.toHaveBeenCalled();
+    expect(fs.existsSync(activeSessionsPath)).toBe(false);
+  });
+});