tlc-claude-code 2.3.0 → 2.4.1

package/server/lib/routing-command.js

@@ -0,0 +1,159 @@
+/**
+ * Routing Command - Config management for per-command model routing
+ *
+ * Shows effective routing config, installed providers, and saves personal config.
+ * Used by the `/tlc:llm` command.
+ */
+
+const path = require('path');
+
+/**
+ * Show effective routing table after precedence merge.
+ * @param {Object} deps - Injected dependencies
+ * @param {Function} deps.resolveRouting - from task-router-config
+ * @param {string[]} deps.commands - list of routable commands
+ * @returns {Array<{ command: string, models: string[], strategy: string, source: string }>}
+ */
+function showRouting({ resolveRouting, commands, projectDir, homeDir }) {
+  return commands.map((cmd) => {
+    const resolved = resolveRouting({ command: cmd, projectDir, homeDir });
+    return {
+      command: cmd,
+      models: resolved.models,
+      strategy: resolved.strategy,
+      source: resolved.source,
+    };
+  });
+}
+
+/**
+ * Show installed CLI providers with availability.
+ * @param {Object} deps - Injected dependencies
+ * @param {Function} deps.detectCLI - from cli-detector
+ * @param {string[]} deps.providerNames - provider names to check
+ * @returns {Promise<Array<{ name: string, found: boolean, path: string|null, version: string|null }>>}
+ */
+async function showProviders({ detectCLI, providerNames }) {
+  const results = await Promise.all(
+    providerNames.map(async (name) => {
+      const detection = await detectCLI(name);
+      return {
+        name,
+        found: detection.found,
+        path: detection.path,
+        version: detection.version,
+      };
+    }),
+  );
+  return results;
+}
+
+/**
+ * Write task_routing config to personal config file.
+ * @param {Object} opts
+ * @param {Object} opts.routing - The task_routing object to save
+ * @param {string} opts.homeDir - Home directory
+ * @param {Object} opts.fs - Injected fs module
+ * @returns {{ saved: boolean, path: string }}
+ */
+function savePersonalRouting({ routing, homeDir, fs }) {
+  const dirPath = path.join(homeDir, '.tlc');
+  const configPath = path.join(dirPath, 'config.json');
+
+  // Ensure directory exists
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+
+  // Load existing config or start fresh
+  let existing = {};
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    existing = JSON.parse(content);
+  } catch {
+    // No existing config, start fresh
+  }
+
+  // Merge: replace task_routing, keep everything else
+  existing.task_routing = routing;
+
+  fs.writeFileSync(configPath, JSON.stringify(existing, null, 2));
+
+  return { saved: true, path: configPath };
+}
+
+/**
+ * Format routing table for display.
+ * @param {Array} routingTable - Output from showRouting
+ * @returns {string} Formatted text table
+ */
+function formatRoutingTable(routingTable) {
+  if (!routingTable || routingTable.length === 0) {
+    return 'No routing entries configured.';
+  }
+
+  // Calculate column widths
+  const headers = { command: 'Command', models: 'Models', strategy: 'Strategy', source: 'Source' };
+  let cmdW = headers.command.length;
+  let modW = headers.models.length;
+  let strW = headers.strategy.length;
+  let srcW = headers.source.length;
+
+  const rows = routingTable.map((entry) => {
+    const modelsStr = entry.models.join(' + ');
+    cmdW = Math.max(cmdW, entry.command.length);
+    modW = Math.max(modW, modelsStr.length);
+    strW = Math.max(strW, entry.strategy.length);
+    srcW = Math.max(srcW, entry.source.length);
+    return { command: entry.command, models: modelsStr, strategy: entry.strategy, source: entry.source };
+  });
+
+  const pad = (str, len) => str.padEnd(len);
+  const lines = [];
+
+  // Header
+  lines.push(
+    `${pad(headers.command, cmdW)}  ${pad(headers.models, modW)}  ${pad(headers.strategy, strW)}  ${pad(headers.source, srcW)}`,
+  );
+  // Separator
+  lines.push(
+    `${'-'.repeat(cmdW)}  ${'-'.repeat(modW)}  ${'-'.repeat(strW)}  ${'-'.repeat(srcW)}`,
+  );
+  // Rows
+  for (const row of rows) {
+    lines.push(
+      `${pad(row.command, cmdW)}  ${pad(row.models, modW)}  ${pad(row.strategy, strW)}  ${pad(row.source, srcW)}`,
+    );
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format provider list for display.
+ * @param {Array} providers - Output from showProviders
+ * @returns {string} Formatted text list
+ */
+function formatProviderList(providers) {
+  if (!providers || providers.length === 0) {
+    return 'No providers configured.';
+  }
+
+  const lines = providers.map((p) => {
+    const icon = p.found ? '✓' : '✗';
+    const status = p.found ? 'installed' : 'not found';
+    const version = p.version ? ` (${p.version})` : '';
+    const loc = p.path ? ` — ${p.path}` : '';
+    return `  ${icon} ${p.name}: ${status}${version}${loc}`;
+  });
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  showRouting,
+  showProviders,
+  savePersonalRouting,
+  formatRoutingTable,
+  formatProviderList,
+};

package/server/lib/routing-command.test.js

@@ -0,0 +1,290 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  showRouting,
+  showProviders,
+  savePersonalRouting,
+  formatRoutingTable,
+  formatProviderList,
+} from './routing-command.js';
+
+describe('routing-command', () => {
+  // ── showRouting ───────────────────────────────────────────────────
+  describe('showRouting', () => {
+    it('returns routing for all routable commands', () => {
+      const commands = ['build', 'review', 'plan'];
+      const resolveRouting = vi.fn(() => ({
+        models: ['claude'],
+        strategy: 'single',
+        source: 'shipped-defaults',
+      }));
+
+      const result = showRouting({ resolveRouting, commands });
+
+      expect(result).toHaveLength(3);
+      expect(resolveRouting).toHaveBeenCalledTimes(3);
+      // Verify it passes an options object with command field
+      expect(resolveRouting).toHaveBeenCalledWith(expect.objectContaining({ command: 'build' }));
+    });
+
+    it('each entry has command, models, strategy, source', () => {
+      const commands = ['build'];
+      const resolveRouting = vi.fn(() => ({
+        models: ['claude', 'codex'],
+        strategy: 'parallel',
+        source: 'personal-config',
+      }));
+
+      const result = showRouting({ resolveRouting, commands });
+
+      expect(result[0]).toEqual({
+        command: 'build',
+        models: ['claude', 'codex'],
+        strategy: 'parallel',
+        source: 'personal-config',
+      });
+    });
+
+    it('uses resolveRouting for each command', () => {
+      const commands = ['build', 'review'];
+      const resolveRouting = vi.fn((opts) => {
+        if (opts.command === 'build') {
+          return { models: ['codex'], strategy: 'single', source: 'personal-config' };
+        }
+        return { models: ['claude'], strategy: 'single', source: 'shipped-defaults' };
+      });
+
+      const result = showRouting({ resolveRouting, commands });
+
+      expect(result[0]).toEqual({
+        command: 'build',
+        models: ['codex'],
+        strategy: 'single',
+        source: 'personal-config',
+      });
+      expect(result[1]).toEqual({
+        command: 'review',
+        models: ['claude'],
+        strategy: 'single',
+        source: 'shipped-defaults',
+      });
+    });
+  });
+
+  // ── showProviders ─────────────────────────────────────────────────
+  describe('showProviders', () => {
+    it('returns status for each provider name', async () => {
+      const detectCLI = vi.fn(async () => ({
+        found: true,
+        path: '/usr/bin/claude',
+        version: '1.0.0',
+      }));
+
+      const result = await showProviders({
+        detectCLI,
+        providerNames: ['claude', 'codex'],
+      });
+
+      expect(result).toHaveLength(2);
+      expect(detectCLI).toHaveBeenCalledTimes(2);
+    });
+
+    it('includes found, path, version fields', async () => {
+      const detectCLI = vi.fn(async () => ({
+        found: true,
+        path: '/usr/local/bin/claude',
+        version: '2.1.0',
+      }));
+
+      const result = await showProviders({
+        detectCLI,
+        providerNames: ['claude'],
+      });
+
+      expect(result[0]).toEqual({
+        name: 'claude',
+        found: true,
+        path: '/usr/local/bin/claude',
+        version: '2.1.0',
+      });
+    });
+
+    it('handles provider not found', async () => {
+      const detectCLI = vi.fn(async () => ({
+        found: false,
+        path: null,
+        version: null,
+      }));
+
+      const result = await showProviders({
+        detectCLI,
+        providerNames: ['gemini'],
+      });
+
+      expect(result[0]).toEqual({
+        name: 'gemini',
+        found: false,
+        path: null,
+        version: null,
+      });
+    });
+  });
+
+  // ── savePersonalRouting ───────────────────────────────────────────
+  describe('savePersonalRouting', () => {
+    it('writes config to ~/.tlc/config.json', () => {
+      const routing = { build: { models: ['codex'], strategy: 'single' } };
+      const written = {};
+      const fs = {
+        existsSync: vi.fn(() => true),
+        readFileSync: vi.fn(() => '{}'),
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn((path, data) => { written.path = path; written.data = data; }),
+      };
+
+      const result = savePersonalRouting({ routing, homeDir: '/home/user', fs });
+
+      expect(result.saved).toBe(true);
+      expect(result.path).toBe('/home/user/.tlc/config.json');
+      expect(written.path).toBe('/home/user/.tlc/config.json');
+      const parsed = JSON.parse(written.data);
+      expect(parsed.task_routing).toEqual(routing);
+    });
+
+    it('creates directory if missing', () => {
+      const routing = { build: { models: ['claude'], strategy: 'single' } };
+      const fs = {
+        existsSync: vi.fn(() => false),
+        readFileSync: vi.fn(() => { throw new Error('ENOENT'); }),
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn(),
+      };
+
+      savePersonalRouting({ routing, homeDir: '/home/user', fs });
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith(
+        '/home/user/.tlc',
+        { recursive: true },
+      );
+    });
+
+    it('merges with existing config without overwriting other keys', () => {
+      const routing = { build: { models: ['codex'], strategy: 'single' } };
+      const existingConfig = {
+        model_providers: { claude: { type: 'inline' } },
+        task_routing: { review: { models: ['gemini'], strategy: 'single' } },
+      };
+      let writtenData;
+      const fs = {
+        existsSync: vi.fn(() => true),
+        readFileSync: vi.fn(() => JSON.stringify(existingConfig)),
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn((_, data) => { writtenData = data; }),
+      };
+
+      savePersonalRouting({ routing, homeDir: '/home/user', fs });
+
+      const parsed = JSON.parse(writtenData);
+      expect(parsed.model_providers).toEqual({ claude: { type: 'inline' } });
+      expect(parsed.task_routing).toEqual(routing);
+    });
+
+    it('creates new file if none exists', () => {
+      const routing = { plan: { models: ['claude'], strategy: 'single' } };
+      let writtenData;
+      const fs = {
+        existsSync: vi.fn(() => false),
+        readFileSync: vi.fn(() => { throw new Error('ENOENT'); }),
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn((_, data) => { writtenData = data; }),
+      };
+
+      const result = savePersonalRouting({ routing, homeDir: '/home/user', fs });
+
+      expect(result.saved).toBe(true);
+      const parsed = JSON.parse(writtenData);
+      expect(parsed.task_routing).toEqual(routing);
+    });
+  });
+
+  // ── formatRoutingTable ────────────────────────────────────────────
+  describe('formatRoutingTable', () => {
+    it('formats entries as aligned text table', () => {
+      const table = [
+        { command: 'build', models: ['claude'], strategy: 'single', source: 'shipped-defaults' },
+        { command: 'review', models: ['claude', 'codex'], strategy: 'parallel', source: 'personal-config' },
+      ];
+
+      const output = formatRoutingTable(table);
+
+      expect(output).toContain('build');
+      expect(output).toContain('review');
+      expect(output).toContain('single');
+      expect(output).toContain('parallel');
+    });
+
+    it('shows command, models joined with +, strategy, source', () => {
+      const table = [
+        { command: 'review', models: ['claude', 'codex'], strategy: 'parallel', source: 'personal-config' },
+      ];
+
+      const output = formatRoutingTable(table);
+
+      expect(output).toContain('claude + codex');
+      expect(output).toContain('parallel');
+      expect(output).toContain('personal-config');
+    });
+
+    it('handles empty table', () => {
+      const output = formatRoutingTable([]);
+
+      expect(output).toContain('No routing');
+    });
+  });
+
+  // ── formatProviderList ────────────────────────────────────────────
+  describe('formatProviderList', () => {
+    it('shows checkmark for found providers', () => {
+      const providers = [
+        { name: 'claude', found: true, path: '/usr/bin/claude', version: '1.0.0' },
+      ];
+
+      const output = formatProviderList(providers);
+
+      // Use a checkmark symbol
+      expect(output).toMatch(/[✓✔]/);
+      expect(output).toContain('claude');
+    });
+
+    it('shows X for missing providers', () => {
+      const providers = [
+        { name: 'codex', found: false, path: null, version: null },
+      ];
+
+      const output = formatProviderList(providers);
+
+      // Use an X symbol
+      expect(output).toMatch(/[✗✘×]/);
+      expect(output).toContain('codex');
+    });
+
+    it('includes version when available', () => {
+      const providers = [
+        { name: 'claude', found: true, path: '/usr/bin/claude', version: '2.1.0' },
+      ];
+
+      const output = formatProviderList(providers);
+
+      expect(output).toContain('2.1.0');
+    });
+
+    it('shows path', () => {
+      const providers = [
+        { name: 'claude', found: true, path: '/usr/local/bin/claude', version: '1.0.0' },
+      ];
+
+      const output = formatProviderList(providers);
+
+      expect(output).toContain('/usr/local/bin/claude');
+    });
+  });
+});

package/server/lib/task-router-config.js

@@ -0,0 +1,146 @@
+/**
+ * Task Router Config - Unified config loader for per-command model routing
+ *
+ * Merges personal -> project -> flag overrides into a single resolved routing table.
+ *
+ * Precedence (most specific wins):
+ *   1. --model flag (one-off override)
+ *   2. .tlc.json -> task_routing_override (project level)
+ *   3. ~/.tlc/config.json -> task_routing (personal level)
+ *   4. Shipped defaults (all commands -> claude, single strategy)
+ */
+
+const path = require('path');
+
+/**
+ * Commands that support model routing.
+ * @type {string[]}
+ */
+const ROUTABLE_COMMANDS = [
+  'build', 'plan', 'review', 'test', 'coverage',
+  'autofix', 'discuss', 'docs', 'edge-cases', 'quick',
+];
+
+/**
+ * Default routing: every routable command maps to claude with single strategy.
+ * @type {Record<string, {models: string[], strategy: string}>}
+ */
+const SHIPPED_DEFAULTS = {};
+for (const cmd of ROUTABLE_COMMANDS) {
+  SHIPPED_DEFAULTS[cmd] = { models: ['claude'], strategy: 'single' };
+}
+
+/**
+ * Load personal config from ~/.tlc/config.json
+ * @param {object} options
+ * @param {string} options.homeDir - Home directory path
+ * @param {object} options.fs - Filesystem module (must have readFileSync)
+ * @returns {object|null} Parsed config or null on failure
+ */
+function loadPersonalConfig({ homeDir, fs }) {
+  try {
+    const configPath = path.join(homeDir, '.tlc', 'config.json');
+    const content = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load project-level task routing override from .tlc.json
+ * @param {object} options
+ * @param {string} options.projectDir - Project directory path
+ * @param {object} options.fs - Filesystem module (must have readFileSync)
+ * @returns {object|null} The task_routing_override section or null
+ */
+function loadProjectOverride({ projectDir, fs }) {
+  try {
+    const configPath = path.join(projectDir, '.tlc.json');
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const data = JSON.parse(content);
+    return data.task_routing_override || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the routing configuration for a given command.
+ *
+ * @param {object} options
+ * @param {string} options.command - The TLC command name (e.g. 'build', 'review')
+ * @param {string} [options.flagModel] - Model name from --model flag override
+ * @param {string} options.projectDir - Project directory path
+ * @param {string} options.homeDir - Home directory path
+ * @param {object} options.fs - Filesystem module (must have readFileSync)
+ * @returns {{ models: string[], strategy: string, source: string, providers?: object }}
+ */
+function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDir = require('os').homedir(), fs = require('fs') }) {
+  // Start with shipped defaults
+  const defaultEntry = SHIPPED_DEFAULTS[command] || { models: ['claude'], strategy: 'single' };
+  let models = [...defaultEntry.models];
+  let strategy = defaultEntry.strategy;
+  let source = 'shipped-defaults';
+  let providers;
+
+  // Layer 1: personal config (~/.tlc/config.json)
+  const personal = loadPersonalConfig({ homeDir, fs });
+  if (personal) {
+    // Capture model_providers if present
+    if (personal.model_providers) {
+      providers = personal.model_providers;
+    }
+
+    const personalRouting = personal.task_routing?.[command];
+    if (personalRouting) {
+      if (personalRouting.models) {
+        models = [...personalRouting.models];
+      } else if (personalRouting.model) {
+        models = [personalRouting.model];
+      }
+      if (personalRouting.strategy) {
+        strategy = personalRouting.strategy;
+      }
+      source = 'personal-config';
+    }
+  }
+
+  // Layer 2: project override (.tlc.json -> task_routing_override)
+  const projectOverride = loadProjectOverride({ projectDir, fs });
+  if (projectOverride) {
+    const overrideEntry = projectOverride[command];
+    if (overrideEntry) {
+      if (overrideEntry.models) {
+        models = [...overrideEntry.models];
+      } else if (overrideEntry.model) {
+        models = [overrideEntry.model];
+      }
+      if (overrideEntry.strategy) {
+        strategy = overrideEntry.strategy;
+      }
+      source = 'project-override';
+    }
+  }
+
+  // Layer 3: --model flag (highest priority)
+  if (flagModel) {
+    models = [flagModel];
+    strategy = 'single';
+    source = 'flag-override';
+  }
+
+  const result = { models, strategy, source };
+  if (providers) {
+    result.providers = providers;
+  }
+  return result;
+}
+
+module.exports = {
+  resolveRouting,
+  loadPersonalConfig,
+  loadProjectOverride,
+  SHIPPED_DEFAULTS,
+  ROUTABLE_COMMANDS,
+};