tlc-claude-code 2.3.0 → 2.4.1

package/server/lib/cli-dispatcher.test.js

@@ -0,0 +1,249 @@
+import { describe, it, expect, vi } from 'vitest';
+import { dispatch, buildProviderCommand } from './cli-dispatcher.js';
+
+/**
+ * Create a mock spawn function that simulates child_process.spawn.
+ * @param {Object} opts - Mock behavior
+ * @param {string} [opts.stdout=''] - Data to emit on stdout
+ * @param {string} [opts.stderr=''] - Data to emit on stderr
+ * @param {number} [opts.exitCode=0] - Exit code to emit on close
+ * @param {number} [opts.delay=0] - Delay in ms before emitting close
+ * @returns {Function} Mock spawn function
+ */
+function createMockSpawn({ stdout = '', stderr = '', exitCode = 0, delay = 0 } = {}) {
+  return vi.fn(() => {
+    const listeners = {};
+    const stdinChunks = [];
+    const proc = {
+      stdin: {
+        write(data) { stdinChunks.push(data); },
+        end() { stdinChunks.push(null); },
+        on() {},
+      },
+      stdout: { on(event, cb) { listeners[`stdout:${event}`] = cb; } },
+      stderr: { on(event, cb) { listeners[`stderr:${event}`] = cb; } },
+      on(event, cb) { listeners[event] = cb; },
+      kill() { listeners._killed = true; },
+      _stdinChunks: stdinChunks,
+    };
+
+    // Emit data and close asynchronously
+    setTimeout(() => {
+      if (stdout) listeners['stdout:data']?.(Buffer.from(stdout));
+      if (stderr) listeners['stderr:data']?.(Buffer.from(stderr));
+      if (!listeners._killed) {
+        listeners.close?.(exitCode);
+      }
+    }, delay);
+
+    return proc;
+  });
+}
+
+describe('cli-dispatcher', () => {
+  describe('dispatch', () => {
+    it('dispatches command and captures stdout', async () => {
+      const mockSpawn = createMockSpawn({ stdout: 'hello world' });
+
+      const result = await dispatch({
+        command: 'echo',
+        args: ['hello'],
+        prompt: '',
+        spawn: mockSpawn,
+      });
+
+      expect(result.stdout).toBe('hello world');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('captures stderr separately', async () => {
+      const mockSpawn = createMockSpawn({ stdout: 'out', stderr: 'err' });
+
+      const result = await dispatch({
+        command: 'test-cmd',
+        args: [],
+        prompt: '',
+        spawn: mockSpawn,
+      });
+
+      expect(result.stdout).toBe('out');
+      expect(result.stderr).toBe('err');
+    });
+
+    it('pipes prompt to stdin', async () => {
+      const mockSpawn = createMockSpawn({ stdout: 'response' });
+
+      await dispatch({
+        command: 'codex',
+        args: ['--quiet'],
+        prompt: 'Review this code',
+        spawn: mockSpawn,
+      });
+
+      const proc = mockSpawn.mock.results[0].value;
+      expect(proc._stdinChunks).toContain('Review this code');
+      // stdin should be ended (null sentinel)
+      expect(proc._stdinChunks).toContain(null);
+    });
+
+    it('returns exit code from process', async () => {
+      const mockSpawn = createMockSpawn({ exitCode: 42 });
+
+      const result = await dispatch({
+        command: 'failing-cmd',
+        args: [],
+        prompt: '',
+        spawn: mockSpawn,
+      });
+
+      expect(result.exitCode).toBe(42);
+    });
+
+    it('timeout kills process and returns error result', async () => {
+      const mockSpawn = createMockSpawn({ stdout: 'slow', delay: 5000 });
+
+      const result = await dispatch({
+        command: 'slow-cmd',
+        args: [],
+        prompt: '',
+        timeout: 50,
+        spawn: mockSpawn,
+      });
+
+      expect(result.exitCode).toBe(-1);
+      expect(result.stderr).toBe('Process timed out');
+    });
+
+    it('duration measured in milliseconds', async () => {
+      const mockSpawn = createMockSpawn({ stdout: 'fast', delay: 10 });
+
+      const result = await dispatch({
+        command: 'fast-cmd',
+        args: [],
+        prompt: '',
+        spawn: mockSpawn,
+      });
+
+      expect(result.duration).toBeTypeOf('number');
+      expect(result.duration).toBeGreaterThanOrEqual(0);
+    });
+
+    it('non-zero exit code captured not thrown', async () => {
+      const mockSpawn = createMockSpawn({ exitCode: 1, stderr: 'command failed' });
+
+      const result = await dispatch({
+        command: 'bad-cmd',
+        args: [],
+        prompt: '',
+        spawn: mockSpawn,
+      });
+
+      // Should NOT throw
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toBe('command failed');
+      expect(result.stdout).toBe('');
+    });
+
+    it('empty prompt still works and closes stdin immediately', async () => {
+      const mockSpawn = createMockSpawn({ stdout: 'ok' });
+
+      const result = await dispatch({
+        command: 'cmd',
+        args: [],
+        prompt: '',
+        spawn: mockSpawn,
+      });
+
+      expect(result.stdout).toBe('ok');
+      expect(result.exitCode).toBe(0);
+
+      // stdin.end should have been called (null sentinel present)
+      const proc = mockSpawn.mock.results[0].value;
+      expect(proc._stdinChunks).toContain(null);
+    });
+
+    it('handles spawn error event (e.g., ENOENT) without hanging', async () => {
+      const mockSpawn = vi.fn(() => {
+        const listeners = {};
+        const proc = {
+          stdin: { write() {}, end() {}, on() {} },
+          stdout: { on(event, cb) { listeners[`stdout:${event}`] = cb; } },
+          stderr: { on(event, cb) { listeners[`stderr:${event}`] = cb; } },
+          on(event, cb) { listeners[event] = cb; },
+          kill() {},
+        };
+        // Emit error asynchronously (simulates ENOENT)
+        setTimeout(() => {
+          listeners.error?.(new Error('spawn codex ENOENT'));
+        }, 1);
+        return proc;
+      });
+
+      const result = await dispatch({
+        command: 'codex',
+        args: [],
+        prompt: 'test',
+        timeout: 5000,
+        spawn: mockSpawn,
+      });
+
+      expect(result.exitCode).toBe(-1);
+      expect(result.stderr).toContain('ENOENT');
+      expect(result.duration).toBeLessThan(1000);
+    });
+
+    it('passes cwd to spawn options', async () => {
+      const mockSpawn = createMockSpawn({ stdout: 'ok' });
+
+      await dispatch({
+        command: 'cmd',
+        args: ['--flag'],
+        prompt: 'hello',
+        cwd: '/tmp/test',
+        spawn: mockSpawn,
+      });
+
+      expect(mockSpawn).toHaveBeenCalledWith(
+        'cmd',
+        ['--flag'],
+        expect.objectContaining({ cwd: '/tmp/test' })
+      );
+    });
+  });
+
+  describe('buildProviderCommand', () => {
+    it('extracts command and flags', () => {
+      const result = buildProviderCommand({
+        type: 'cli',
+        command: 'codex',
+        flags: ['--dangerously-skip-permissions'],
+      });
+
+      expect(result).toEqual({
+        command: 'codex',
+        args: ['--dangerously-skip-permissions'],
+      });
+    });
+
+    it('handles provider with no flags', () => {
+      const result = buildProviderCommand({
+        type: 'cli',
+        command: 'gemini',
+      });
+
+      expect(result).toEqual({
+        command: 'gemini',
+        args: [],
+      });
+    });
+
+    it('handles inline type and returns null', () => {
+      const result = buildProviderCommand({
+        type: 'inline',
+        command: 'claude',
+      });
+
+      expect(result).toBeNull();
+    });
+  });
+});

package/server/lib/command-router.js

@@ -0,0 +1,171 @@
+/**
+ * Command Router
+ *
+ * Integration point for TLC command routing. Given a command name,
+ * resolves routing config, checks provider availability, packages
+ * prompts, and dispatches to the appropriate execution path.
+ *
+ * @module command-router
+ */
+
+const { buildProviderCommand } = require('./cli-dispatcher.js');
+
+/**
+ * Check whether a model is available in the router state.
+ * @param {string} model - Model name to check
+ * @param {Object} routerState - Parsed .tlc/.router-state.json
+ * @returns {boolean} True if the model's provider is available
+ */
+function isModelAvailable(model, routerState, providerConfig) {
+  if (model === 'claude') return true;
+  // Check router state (probed CLIs) first
+  const probed = routerState?.providers?.[model];
+  if (probed?.available === true) return true;
+  // Also accept user-defined provider aliases from model_providers config
+  if (providerConfig?.[model]?.type === 'cli') return true;
+  return false;
+}
+
+/**
+ * Route a single model to its result.
+ * @param {string} model - Model name
+ * @param {Object} opts - Routing options
+ * @param {string} opts.agentPrompt - Command instruction text
+ * @param {Object} opts.context - Project context
+ * @param {Object|undefined} opts.providerConfig - Provider config for CLI models
+ * @param {Object} opts.routerState - Router state from .router-state.json
+ * @param {Object} deps - Injected dependencies
+ * @returns {Promise<Object>} Result for this model
+ */
+async function routeModel(model, { agentPrompt, context, providerConfig, routerState }, deps) {
+  // Claude is always inline
+  if (model === 'claude') {
+    return { model: 'claude', type: 'inline' };
+  }
+
+  // Check availability — return skipped (not duplicate Claude) so parallel doesn't double-run
+  if (!isModelAvailable(model, routerState, providerConfig)) {
+    return {
+      type: 'skipped',
+      model,
+      warning: `${model} is unavailable`,
+    };
+  }
+
+  // Get provider command config
+  const provider = providerConfig?.[model];
+  if (!provider) {
+    return {
+      type: 'skipped',
+      model,
+      warning: `${model} has no provider config`,
+    };
+  }
+
+  const cmdSpec = buildProviderCommand(provider);
+  if (!cmdSpec) {
+    return {
+      type: 'skipped',
+      model,
+      warning: `${model} is not a CLI provider`,
+    };
+  }
+
+  // Package prompt with full context
+  const prompt = deps.packagePrompt({
+    agentPrompt,
+    projectDoc: context.projectDoc || null,
+    planDoc: context.planDoc || null,
+    codingStandards: context.codingStandards || null,
+    files: context.files || null,
+  });
+
+  // Dispatch to CLI
+  const dispatchResult = await deps.dispatch({
+    command: cmdSpec.command,
+    args: cmdSpec.args,
+    prompt,
+  });
+
+  return {
+    type: 'cli',
+    model,
+    output: dispatchResult.stdout,
+    stderr: dispatchResult.stderr,
+    exitCode: dispatchResult.exitCode,
+    duration: dispatchResult.duration,
+  };
+}
+
+/**
+ * Route a TLC command to the appropriate execution path.
+ * @param {Object} options
+ * @param {string} options.command - TLC command name (e.g., 'build', 'review')
+ * @param {string} options.agentPrompt - The command's instruction text
+ * @param {string|null} options.flagModel - --model flag override
+ * @param {Object} options.context - Project context for prompt packaging
+ * @param {string|null} options.context.projectDoc - PROJECT.md contents
+ * @param {string|null} options.context.planDoc - Current phase PLAN.md
+ * @param {string|null} options.context.codingStandards - CODING-STANDARDS.md
+ * @param {Array|null} options.context.files - [{path, content}]
+ * @param {Object} deps - Injected dependencies for testability
+ * @param {string} [options.projectDir] - Project directory for config loading
+ * @param {string} [options.homeDir] - Home directory for personal config
+ * @param {Object} deps - Injected dependencies for testability
+ * @param {Function} deps.resolveRouting - from task-router-config
+ * @param {Function} deps.packagePrompt - from prompt-packager
+ * @param {Function} deps.dispatch - from cli-dispatcher
+ * @param {Function} deps.readRouterState - reads .tlc/.router-state.json
+ * @returns {Promise<Object>} Result
+ */
+async function routeCommand({ command, agentPrompt, flagModel, context, projectDir, homeDir }, deps) {
+  // Resolve routing config — pass full context so personal + project configs are loaded
+  const routing = deps.resolveRouting({ command, flagModel, projectDir, homeDir });
+
+  // Read router state for provider availability
+  const routerState = deps.readRouterState();
+
+  const { models, strategy, providers: providerConfig } = routing;
+
+  // Single strategy — fall back to Claude if target is unavailable
+  if (strategy === 'single') {
+    const model = models[0];
+    const result = await routeModel(model, {
+      agentPrompt,
+      context,
+      providerConfig,
+      routerState,
+    }, deps);
+
+    // For single strategy, skipped means fall back to inline
+    if (result.type === 'skipped') {
+      return { type: 'inline', model: 'claude', warning: result.warning + ', falling back to inline (claude)' };
+    }
+
+    return result;
+  }
+
+  // Parallel strategy
+  if (strategy === 'parallel') {
+    const promises = models.map((model) =>
+      routeModel(model, {
+        agentPrompt,
+        context,
+        providerConfig,
+        routerState,
+      }, deps)
+    );
+
+    const results = await Promise.all(promises);
+
+    return {
+      type: 'parallel',
+      results,
+    };
+  }
+
+  // Unknown strategy — fall back to inline
+  return { type: 'inline', model: 'claude' };
+}
+
+module.exports = { routeCommand };