tlc-claude-code 2.4.3 → 2.4.5

package/server/lib/health-check.test.js

@@ -0,0 +1,243 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const {
+  ensureMemoryDirs,
+  checkGitignoreTeamMemory,
+  checkSpoolEntries,
+  checkCaptureHookInstalled,
+  checkRoutingConfigReadable,
+  checkProviderAvailable,
+  checkCaptureWarningsLog,
+  runHealthChecks,
+} = require('./health-check.js');
+
+describe('health-check', () => {
+  let projectDir;
+
+  beforeEach(() => {
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-health-check-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('ensureMemoryDirs creates missing memory directories and reports autofixes', async () => {
+    const result = await ensureMemoryDirs(projectDir, { fs });
+
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', 'team', 'decisions'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', 'team', 'gotchas'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', '.local', 'sessions'))).toBe(true);
+    expect(result.passed).toBe('Memory directories ready');
+    expect(result.autoFixed).toHaveLength(3);
+  });
+
+  it('ensureMemoryDirs does not autofix directories that already exist', async () => {
+    fs.mkdirSync(path.join(projectDir, '.tlc', 'memory', 'team', 'decisions'), { recursive: true });
+    fs.mkdirSync(path.join(projectDir, '.tlc', 'memory', 'team', 'gotchas'), { recursive: true });
+    fs.mkdirSync(path.join(projectDir, '.tlc', 'memory', '.local', 'sessions'), { recursive: true });
+
+    const result = await ensureMemoryDirs(projectDir, { fs });
+
+    expect(result.autoFixed).toEqual([]);
+    expect(result.passed).toBe('Memory directories ready');
+  });
+
+  it('ensureMemoryDirs converts fs failures into warnings', async () => {
+    const failingFs = {
+      existsSync: vi.fn(() => false),
+      mkdirSync: vi.fn(() => {
+        throw new Error('mkdir failed');
+      }),
+    };
+
+    const result = await ensureMemoryDirs(projectDir, { fs: failingFs });
+
+    expect(result.passed).toBeNull();
+    expect(result.warning).toContain('[TLC WARNING]');
+    expect(result.warning).toContain('memory directories');
+  });
+
+  it('checkGitignoreTeamMemory warns when team memory path is ignored', async () => {
+    const execSync = vi.fn(() => Buffer.from('.tlc/memory/team/test.md\n'));
+
+    const result = await checkGitignoreTeamMemory(projectDir, { execSync });
+
+    expect(execSync).toHaveBeenCalledWith(
+      'git check-ignore .tlc/memory/team/test.md 2>/dev/null',
+      expect.objectContaining({ cwd: projectDir })
+    );
+    expect(result.warning).toContain('[TLC WARNING]');
+    expect(result.warning).toContain('gitignore');
+    expect(result.passed).toBeNull();
+  });
+
+  it('checkGitignoreTeamMemory passes when git check-ignore does not match', async () => {
+    const execSync = vi.fn(() => Buffer.from(''));
+
+    const result = await checkGitignoreTeamMemory(projectDir, { execSync });
+
+    expect(result.passed).toBe('Team memory is not ignored by git');
+    expect(result.warning).toBeNull();
+  });
+
+  it('checkSpoolEntries warns with byte count when spool file has content', async () => {
+    const spoolPath = path.join(projectDir, '.tlc', 'memory', '.spool.jsonl');
+    fs.mkdirSync(path.dirname(spoolPath), { recursive: true });
+    fs.writeFileSync(spoolPath, '{"event":"queued"}\n');
+
+    const result = await checkSpoolEntries(projectDir, { fs });
+
+    expect(result.warning).toContain('[TLC WARNING]');
+    expect(result.warning).toContain('unprocessed spool entries');
+    expect(result.warning).toContain('19 bytes');
+  });
+
+  it('checkSpoolEntries passes when spool file is missing or empty', async () => {
+    expect((await checkSpoolEntries(projectDir, { fs })).passed).toBe('No unprocessed spool entries');
+
+    const spoolPath = path.join(projectDir, '.tlc', 'memory', '.spool.jsonl');
+    fs.mkdirSync(path.dirname(spoolPath), { recursive: true });
+    fs.writeFileSync(spoolPath, '');
+
+    const result = await checkSpoolEntries(projectDir, { fs });
+    expect(result.passed).toBe('No unprocessed spool entries');
+  });
+
+  it('checkCaptureHookInstalled warns when capture hook is missing', async () => {
+    const result = await checkCaptureHookInstalled(projectDir, { fs });
+
+    expect(result.warning).toContain('[TLC WARNING]');
+    expect(result.warning).toContain('capture hook');
+  });
+
+  it('checkCaptureHookInstalled passes when capture hook exists', async () => {
+    const hookPath = path.join(projectDir, '.claude', 'hooks', 'tlc-capture-exchange.sh');
+    fs.mkdirSync(path.dirname(hookPath), { recursive: true });
+    fs.writeFileSync(hookPath, '#!/bin/sh\n');
+
+    const result = await checkCaptureHookInstalled(projectDir, { fs });
+
+    expect(result.passed).toBe('Capture hook installed');
+    expect(result.warning).toBeNull();
+  });
+
+  it('checkRoutingConfigReadable warns when .tlc.json is invalid JSON', async () => {
+    fs.writeFileSync(path.join(projectDir, '.tlc.json'), '{invalid');
+
+    const result = await checkRoutingConfigReadable(projectDir, { fs });
+
+    expect(result.warning).toContain('[TLC WARNING]');
+    expect(result.warning).toContain('.tlc.json');
+  });
+
+  it('checkRoutingConfigReadable passes when .tlc.json can be parsed', async () => {
+    fs.writeFileSync(path.join(projectDir, '.tlc.json'), JSON.stringify({ ok: true }));
+
+    const result = await checkRoutingConfigReadable(projectDir, { fs });
+
+    expect(result.passed).toBe('Routing config is readable');
+  });
+
+  it('checkProviderAvailable warns when router state has no available providers', async () => {
+    const statePath = path.join(projectDir, '.tlc', '.router-state.json');
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+    fs.writeFileSync(statePath, JSON.stringify({ summary: { available_count: 0 } }));
+
+    const result = await checkProviderAvailable(projectDir, { fs });
+
+    expect(result.warning).toContain('[TLC WARNING]');
+    expect(result.warning).toContain('provider available');
+  });
+
+  it('checkProviderAvailable passes when router state reports available providers', async () => {
+    const statePath = path.join(projectDir, '.tlc', '.router-state.json');
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+    fs.writeFileSync(statePath, JSON.stringify({ summary: { available_count: 2 } }));
+
+    const result = await checkProviderAvailable(projectDir, { fs });
+
+    expect(result.passed).toBe('At least one provider is available');
+  });
+
+  it('checkCaptureWarningsLog warns when recent capture warnings exist', async () => {
+    const warningsPath = path.join(projectDir, '.tlc', 'memory', '.capture-warnings.log');
+    fs.mkdirSync(path.dirname(warningsPath), { recursive: true });
+    fs.writeFileSync(warningsPath, `${new Date().toISOString()} capture lag detected\n`);
+
+    const result = await checkCaptureWarningsLog(projectDir, { fs });
+
+    expect(result.warning).toContain('[TLC WARNING]');
+    expect(result.warning).toContain('capture warnings');
+    expect(result.warning).toContain('last 24h');
+  });
+
+  it('checkCaptureWarningsLog passes when warnings are older than 24 hours', async () => {
+    const warningsPath = path.join(projectDir, '.tlc', 'memory', '.capture-warnings.log');
+    const oldDate = new Date(Date.now() - (25 * 60 * 60 * 1000)).toISOString();
+    fs.mkdirSync(path.dirname(warningsPath), { recursive: true });
+    fs.writeFileSync(warningsPath, `${oldDate} old warning\n`);
+
+    const result = await checkCaptureWarningsLog(projectDir, { fs });
+
+    expect(result.passed).toBe('No recent capture warnings');
+  });
+
+  it('runHealthChecks aggregates passed checks, warnings, and autofixes', async () => {
+    fs.writeFileSync(path.join(projectDir, '.tlc.json'), JSON.stringify({ ok: true }));
+    fs.mkdirSync(path.join(projectDir, '.claude', 'hooks'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, '.claude', 'hooks', 'tlc-capture-exchange.sh'),
+      '#!/bin/sh\n'
+    );
+    fs.mkdirSync(path.join(projectDir, '.tlc'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, '.tlc', '.router-state.json'),
+      JSON.stringify({ summary: { available_count: 1 } })
+    );
+
+    const execSync = vi.fn(() => Buffer.from(''));
+    const result = await runHealthChecks(projectDir, { fs, execSync });
+
+    expect(result.passed).toContain('Memory directories ready');
+    expect(result.passed).toContain('Team memory is not ignored by git');
+    expect(result.passed).toContain('Capture hook installed');
+    expect(result.passed).toContain('Routing config is readable');
+    expect(result.passed).toContain('At least one provider is available');
+    expect(result.warnings).toEqual([]);
+    expect(result.autoFixed).toHaveLength(3);
+  });
+
+  it('runHealthChecks never throws when dependencies fail and returns warnings instead', async () => {
+    const failingFs = {
+      existsSync: vi.fn(() => {
+        throw new Error('exists failed');
+      }),
+      mkdirSync: vi.fn(() => {
+        throw new Error('mkdir failed');
+      }),
+      readFileSync: vi.fn(() => {
+        throw new Error('read failed');
+      }),
+      statSync: vi.fn(() => {
+        throw new Error('stat failed');
+      }),
+    };
+    const execSync = vi.fn(() => {
+      throw new Error('git failed');
+    });
+
+    const result = await runHealthChecks(projectDir, { fs: failingFs, execSync });
+
+    expect(Array.isArray(result.passed)).toBe(true);
+    expect(Array.isArray(result.warnings)).toBe(true);
+    expect(Array.isArray(result.autoFixed)).toBe(true);
+    expect(result.warnings.length).toBeGreaterThan(0);
+    expect(result.warnings.every((warning) => warning.startsWith('[TLC WARNING]'))).toBe(true);
+  });
+});

package/server/lib/orchestration/cli-dispatch.js

@@ -0,0 +1,200 @@
+let parseCodexEvents = null;
+
+try {
+  ({ parseCodexEvents } = require('../capture/codex-event-parser.js'));
+} catch (_) {
+  parseCodexEvents = null;
+}
+
+function fallbackParseCodexEvents(jsonStream) {
+  const lines = typeof jsonStream === 'string' ? jsonStream.split('\n') : [];
+  let threadId = null;
+
+  for (const line of lines) {
+    if (typeof line !== 'string' || line.trim() === '') {
+      continue;
+    }
+
+    try {
+      const event = JSON.parse(line);
+      if (
+        event &&
+        event.type === 'thread.started' &&
+        typeof event.thread_id === 'string' &&
+        event.thread_id.trim() !== ''
+      ) {
+        threadId = event.thread_id;
+      }
+    } catch (_) {
+      // Ignore non-JSON lines in mixed stdout streams.
+    }
+  }
+
+  return { threadId };
+}
+
+function extractCodexThreadId(stdout) {
+  const parsed = parseCodexEvents
+    ? parseCodexEvents(stdout)
+    : fallbackParseCodexEvents(stdout);
+
+  return parsed && typeof parsed.threadId === 'string' ? parsed.threadId : null;
+}
+
+function buildCommand(provider, prompt, worktreePath, flags) {
+  const normalizedProvider = String(provider || '').trim();
+  const baseFlags = Array.isArray(flags) ? [...flags] : [];
+  const spawnOptions = {};
+  let usesStdin = true;
+  let args;
+
+  if (normalizedProvider === 'codex') {
+    args = ['exec', '--json', '--full-auto'];
+    if (worktreePath) {
+      args.push('-C', worktreePath);
+    }
+  } else if (normalizedProvider === 'gemini') {
+    usesStdin = false;
+    args = [...baseFlags, '-p', prompt];
+    if (worktreePath) {
+      spawnOptions.cwd = worktreePath;
+    }
+    return { command: normalizedProvider, args, spawnOptions, usesStdin };
+  } else if (normalizedProvider === 'claude') {
+    usesStdin = false;
+    args = ['--agent', 'builder'];
+    if (worktreePath) {
+      args.push('--worktree', worktreePath);
+      spawnOptions.cwd = worktreePath;
+    }
+    args.push(...baseFlags, '-p', prompt);
+    return { command: normalizedProvider, args, spawnOptions, usesStdin };
+  } else if (normalizedProvider === 'ollama') {
+    args = ['run', ...baseFlags];
+    if (worktreePath) {
+      spawnOptions.cwd = worktreePath;
+    }
+    return { command: normalizedProvider, args, spawnOptions, usesStdin };
+  } else {
+    args = baseFlags;
+    if (worktreePath) {
+      spawnOptions.cwd = worktreePath;
+    }
+    return { command: normalizedProvider, args, spawnOptions, usesStdin };
+  }
+
+  args.push(...baseFlags);
+  return { command: normalizedProvider, args, spawnOptions, usesStdin };
+}
+
+function buildSpawnError(provider, err) {
+  const message = err && err.message ? err.message : `Failed to spawn ${provider}`;
+
+  if (err && err.code === 'ENOENT') {
+    return {
+      code: 'CLI_NOT_FOUND',
+      message: `CLI "${provider}" was not found: ${message}`,
+    };
+  }
+
+  return {
+    code: 'SPAWN_ERROR',
+    message,
+  };
+}
+
+async function dispatch({
+  provider,
+  prompt = '',
+  worktreePath,
+  flags = [],
+  timeout = 120000,
+  spawn = require('child_process').spawn,
+  binaryOverride,
+}) {
+  const start = Date.now();
+  const built = buildCommand(provider, prompt, worktreePath, flags);
+  // Allow standalone to preserve custom/absolute binary paths
+  const command = binaryOverride || built.command;
+  const { args, spawnOptions, usesStdin } = built;
+
+  return new Promise((resolve) => {
+    let proc;
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    let timer = null;
+
+    function finish(exitCode, error) {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+
+      resolve({
+        stdout,
+        stderr,
+        exitCode,
+        duration: Date.now() - start,
+        threadId: command === 'codex' ? extractCodexThreadId(stdout) : null,
+        error: error || null,
+      });
+    }
+
+    try {
+      proc = spawn(command, args, spawnOptions);
+    } catch (err) {
+      finish(-1, buildSpawnError(command, err));
+      return;
+    }
+
+    proc.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    proc.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    proc.on('error', (err) => {
+      finish(-1, buildSpawnError(command, err));
+    });
+
+    proc.on('close', (code) => {
+      finish(typeof code === 'number' ? code : -1, null);
+    });
+
+    timer = setTimeout(() => {
+      if (typeof proc.kill === 'function') {
+        proc.kill();
+      }
+
+      finish(-1, {
+        code: 'TIMEOUT',
+        message: `CLI "${command}" timed out after ${timeout}ms`,
+      });
+    }, timeout);
+
+    if (proc.stdin && typeof proc.stdin.on === 'function') {
+      proc.stdin.on('error', () => {});
+    }
+
+    if (proc.stdin) {
+      if (usesStdin && typeof proc.stdin.write === 'function' && prompt) {
+        proc.stdin.write(prompt);
+      }
+
+      if (typeof proc.stdin.end === 'function') {
+        proc.stdin.end();
+      }
+    }
+  });
+}
+
+module.exports = {
+  dispatch,
+};

package/server/lib/orchestration/cli-dispatch.test.js

@@ -0,0 +1,242 @@
+import { describe, it, expect, vi } from 'vitest';
+import { EventEmitter } from 'events';
+
+const { dispatch } = require('./cli-dispatch.js');
+
+function createMockProcess({ stdout = '', stderr = '', exitCode = 0, delay = 0 } = {}) {
+  const proc = new EventEmitter();
+  proc.stdout = new EventEmitter();
+  proc.stderr = new EventEmitter();
+  proc.stdin = {
+    write: vi.fn(),
+    end: vi.fn(),
+    on: vi.fn(),
+  };
+  proc.kill = vi.fn();
+
+  setTimeout(() => {
+    if (stdout) {
+      proc.stdout.emit('data', Buffer.from(stdout));
+    }
+
+    if (stderr) {
+      proc.stderr.emit('data', Buffer.from(stderr));
+    }
+
+    proc.emit('close', exitCode);
+  }, delay);
+
+  return proc;
+}
+
+describe('cli-dispatch', () => {
+  it('builds codex args with -C, writes prompt to stdin, and extracts threadId', async () => {
+    const stdout = [
+      '{"type":"thread.started","thread_id":"thread-123"}',
+      '{"type":"agent_message","message":{"items":[{"type":"text","text":"done"}]}}',
+    ].join('\n');
+    const proc = createMockProcess({ stdout });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'codex',
+      prompt: 'Review this change',
+      worktreePath: '/tmp/worktree',
+      flags: ['--model', 'gpt-5.4'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'codex',
+      ['exec', '--json', '--full-auto', '-C', '/tmp/worktree', '--model', 'gpt-5.4'],
+      {}
+    );
+    expect(proc.stdin.write).toHaveBeenCalledWith('Review this change');
+    expect(proc.stdin.end).toHaveBeenCalled();
+    expect(result.threadId).toBe('thread-123');
+    expect(result.exitCode).toBe(0);
+    expect(result.error).toBeNull();
+  });
+
+  it('passes gemini prompt as -p argument and sets cwd from worktreePath', async () => {
+    const proc = createMockProcess({ stdout: 'gemini output' });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'gemini',
+      prompt: 'Explain this diff',
+      worktreePath: '/tmp/gemini-worktree',
+      flags: ['--model', 'gemini-2.5-pro'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'gemini',
+      ['--model', 'gemini-2.5-pro', '-p', 'Explain this diff'],
+      { cwd: '/tmp/gemini-worktree' }
+    );
+    expect(proc.stdin.write).not.toHaveBeenCalled();
+    expect(proc.stdin.end).toHaveBeenCalled();
+    expect(result.stdout).toBe('gemini output');
+  });
+
+  it('builds claude args with worktree and prompt flag and sets cwd', async () => {
+    const proc = createMockProcess({ stdout: 'claude output' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'claude',
+      prompt: 'Implement the feature',
+      worktreePath: '/tmp/claude-worktree',
+      flags: ['--permission-mode', 'auto'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'claude',
+      ['--agent', 'builder', '--worktree', '/tmp/claude-worktree', '--permission-mode', 'auto', '-p', 'Implement the feature'],
+      { cwd: '/tmp/claude-worktree' }
+    );
+  });
+
+  it('uses stdin prompt for ollama and sets cwd when worktreePath is provided', async () => {
+    const proc = createMockProcess({ stdout: 'ollama output' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'ollama',
+      prompt: 'Summarize the logs',
+      worktreePath: '/tmp/ollama-worktree',
+      flags: ['llama3.2'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'ollama',
+      ['run', 'llama3.2'],
+      { cwd: '/tmp/ollama-worktree' }
+    );
+    expect(proc.stdin.write).toHaveBeenCalledWith('Summarize the logs');
+  });
+
+  it('uses generic flags and stdin for unknown providers', async () => {
+    const proc = createMockProcess({ stdout: 'custom output' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'custom-cli',
+      prompt: 'Do the custom thing',
+      worktreePath: '/tmp/custom-worktree',
+      flags: ['--mode', 'fast'],
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'custom-cli',
+      ['--mode', 'fast'],
+      { cwd: '/tmp/custom-worktree' }
+    );
+    expect(proc.stdin.write).toHaveBeenCalledWith('Do the custom thing');
+  });
+
+  it('returns CLI_NOT_FOUND when spawn emits ENOENT', async () => {
+    const proc = new EventEmitter();
+    proc.stdout = new EventEmitter();
+    proc.stderr = new EventEmitter();
+    proc.stdin = {
+      write: vi.fn(),
+      end: vi.fn(),
+      on: vi.fn(),
+    };
+    proc.kill = vi.fn();
+
+    const spawn = vi.fn(() => {
+      setTimeout(() => {
+        proc.emit('error', Object.assign(new Error('spawn codex ENOENT'), { code: 'ENOENT' }));
+      }, 0);
+      return proc;
+    });
+
+    const result = await dispatch({
+      provider: 'codex',
+      prompt: 'test',
+      spawn,
+    });
+
+    expect(result.exitCode).toBe(-1);
+    expect(result.error).toEqual(
+      expect.objectContaining({
+        code: 'CLI_NOT_FOUND',
+      })
+    );
+    expect(result.error.message).toContain('codex');
+  });
+
+  it('returns TIMEOUT on hung processes', async () => {
+    const proc = createMockProcess({ stdout: 'late output', delay: 5000 });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'ollama',
+      prompt: 'slow task',
+      timeout: 20,
+      spawn,
+    });
+
+    expect(result.exitCode).toBe(-1);
+    expect(result.error).toEqual(
+      expect.objectContaining({
+        code: 'TIMEOUT',
+      })
+    );
+    expect(proc.kill).toHaveBeenCalled();
+  });
+
+  it('captures non-zero exits without throwing', async () => {
+    const proc = createMockProcess({ stdout: 'partial', stderr: 'failed', exitCode: 2 });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'custom-cli',
+      prompt: 'run',
+      spawn,
+    });
+
+    expect(result.stdout).toBe('partial');
+    expect(result.stderr).toBe('failed');
+    expect(result.exitCode).toBe(2);
+    expect(result.error).toBeNull();
+  });
+
+  it('does not set cwd when codex already uses -C', async () => {
+    const proc = createMockProcess({ stdout: 'ok' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'codex',
+      prompt: 'test',
+      worktreePath: '/tmp/codex-worktree',
+      spawn,
+    });
+
+    expect(spawn).toHaveBeenCalledWith(
+      'codex',
+      ['exec', '--json', '--full-auto', '-C', '/tmp/codex-worktree'],
+      {}
+    );
+  });
+
+  it('returns null threadId when codex output does not contain one', async () => {
+    const proc = createMockProcess({ stdout: '{"type":"agent_message"}' });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'codex',
+      prompt: 'test',
+      spawn,
+    });
+
+    expect(result.threadId).toBeNull();
+    expect(result.exitCode).toBe(0);
+  });
+});