tlc-claude-code 2.4.1 → 2.4.3

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect, vi, afterEach } from 'vitest';
 import {
   showRouting,
   showProviders,
@@ -8,6 +8,10 @@ import {
 } from './routing-command.js';
 
 describe('routing-command', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   // ── showRouting ───────────────────────────────────────────────────
   describe('showRouting', () => {
     it('returns routing for all routable commands', () => {
@@ -204,6 +208,40 @@ describe('routing-command', () => {
       const parsed = JSON.parse(writtenData);
       expect(parsed.task_routing).toEqual(routing);
     });
+
+    it('warns when existing personal config JSON is invalid', () => {
+      const routing = { build: { models: ['codex'], strategy: 'single' } };
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const fs = {
+        existsSync: vi.fn(() => true),
+        readFileSync: vi.fn(() => '{invalid json'),
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn(),
+      };
+
+      savePersonalRouting({ routing, homeDir: '/home/user', fs });
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        '[TLC WARNING] Failed to parse existing personal routing config; overwriting task_routing'
+      );
+    });
+
+    it('stays silent when personal config file is missing', () => {
+      const routing = { build: { models: ['codex'], strategy: 'single' } };
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const error = new Error('ENOENT');
+      error.code = 'ENOENT';
+      const fs = {
+        existsSync: vi.fn(() => false),
+        readFileSync: vi.fn(() => { throw error; }),
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn(),
+      };
+
+      savePersonalRouting({ routing, homeDir: '/home/user', fs });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
   });
 
   // ── formatRoutingTable ────────────────────────────────────────────

package/server/lib/routing-preamble.integration.test.js

@@ -0,0 +1,319 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import routingPreamble from './routing-preamble.js';
+
+const { generatePreamble } = routingPreamble;
+
+const createdDirs = [];
+
+function makeTempDir(name) {
+  const dir = path.join(os.tmpdir(), `tlc-routing-${name}-${crypto.randomUUID()}`);
+  fs.mkdirSync(dir, { recursive: true });
+  createdDirs.push(dir);
+  return dir;
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2));
+}
+
+function writeFile(filePath, contents) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+}
+
+function runPreamble({
+  commandName,
+  flagModel,
+  personalConfig,
+  personalConfigRaw,
+  projectConfig,
+  projectConfigRaw,
+  projectDirName = 'project',
+} = {}) {
+  const homeDir = makeTempDir('home');
+  const cwd = makeTempDir(projectDirName);
+
+  if (personalConfig !== undefined) {
+    writeJson(path.join(homeDir, '.tlc', 'config.json'), personalConfig);
+  }
+
+  if (personalConfigRaw !== undefined) {
+    writeFile(path.join(homeDir, '.tlc', 'config.json'), personalConfigRaw);
+  }
+
+  if (projectConfig !== undefined) {
+    writeJson(path.join(cwd, '.tlc.json'), projectConfig);
+  }
+
+  if (projectConfigRaw !== undefined) {
+    writeFile(path.join(cwd, '.tlc.json'), projectConfigRaw);
+  }
+
+  const command = flagModel
+    ? `${generatePreamble(commandName)} -- ${JSON.stringify(flagModel)}`
+    : generatePreamble(commandName);
+
+  const completed = spawnSync('bash', ['-lc', command], {
+    cwd,
+    env: {
+      ...process.env,
+      HOME: homeDir,
+    },
+    encoding: 'utf8',
+  });
+
+  if (completed.status !== 0) {
+    throw new Error(completed.stderr || `Preamble command failed with exit code ${completed.status}`);
+  }
+
+  return {
+    result: JSON.parse(completed.stdout),
+    stderr: completed.stderr,
+    homeDir,
+    cwd,
+  };
+}
+
+afterEach(() => {
+  while (createdDirs.length > 0) {
+    const dir = createdDirs.pop();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('routing-preamble integration', () => {
+  it('uses defaults when no config files exist', () => {
+    expect(runPreamble({ commandName: 'build' }).result).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      source: 'shipped-defaults',
+      warnings: [],
+    });
+  });
+
+  it('uses a personal config model override', () => {
+    expect(
+      runPreamble({
+        commandName: 'build',
+        personalConfig: {
+          task_routing: {
+            build: { model: 'codex' },
+          },
+        },
+      }).result,
+    ).toEqual({
+      models: ['codex'],
+      strategy: 'single',
+      source: 'personal-config',
+      warnings: [expect.stringMatching(/models/i)],
+    });
+  });
+
+  it('uses a personal config models array as-is', () => {
+    expect(
+      runPreamble({
+        commandName: 'review',
+        personalConfig: {
+          task_routing: {
+            review: { models: ['codex', 'claude'] },
+          },
+        },
+      }).result,
+    ).toEqual({
+      models: ['codex', 'claude'],
+      strategy: 'single',
+      source: 'personal-config',
+      warnings: [],
+    });
+  });
+
+  it('lets a project override win over personal routing', () => {
+    expect(
+      runPreamble({
+        commandName: 'docs',
+        personalConfig: {
+          task_routing: {
+            docs: { model: 'codex', strategy: 'parallel' },
+          },
+        },
+        projectConfig: {
+          task_routing_override: {
+            docs: { model: 'claude' },
+          },
+        },
+      }).result,
+    ).toEqual({
+      models: ['claude'],
+      strategy: 'parallel',
+      source: 'project-override',
+      warnings: [expect.stringMatching(/models/i), expect.stringMatching(/models/i)],
+    });
+  });
+
+  it('uses the project override when both config files are present', () => {
+    expect(
+      runPreamble({
+        commandName: 'test',
+        personalConfig: {
+          task_routing: {
+            test: { models: ['codex', 'claude'], strategy: 'parallel' },
+          },
+        },
+        projectConfig: {
+          task_routing_override: {
+            test: { models: ['claude'], strategy: 'single' },
+          },
+        },
+      }).result,
+    ).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      source: 'project-override',
+      warnings: [],
+    });
+  });
+
+  it('lets a flag override win over project and personal config', () => {
+    expect(
+      runPreamble({
+        commandName: 'build',
+        flagModel: 'local-model',
+        personalConfig: {
+          task_routing: {
+            build: { model: 'codex', strategy: 'parallel' },
+          },
+        },
+        projectConfig: {
+          task_routing_override: {
+            build: { model: 'claude', strategy: 'parallel' },
+          },
+        },
+      }).result,
+    ).toEqual({
+      models: ['local-model'],
+      strategy: 'single',
+      source: 'flag-override',
+      warnings: [expect.stringMatching(/models/i), expect.stringMatching(/models/i)],
+    });
+  });
+
+  it('passes through model providers from personal config', () => {
+    const providers = {
+      claude: { type: 'cli', command: 'claude' },
+      codex: { type: 'cli', command: 'codex' },
+    };
+
+    expect(
+      runPreamble({
+        commandName: 'build',
+        personalConfig: {
+          task_routing: {
+            build: { model: 'codex' },
+          },
+          model_providers: providers,
+        },
+      }).result,
+    ).toEqual({
+      models: ['codex'],
+      strategy: 'single',
+      source: 'personal-config',
+      providers,
+      warnings: [expect.stringMatching(/models/i)],
+    });
+  });
+
+  it('falls back to defaults for malformed personal config JSON', () => {
+    const { result, stderr, homeDir } = runPreamble({
+      commandName: 'build',
+      personalConfigRaw: '{not-valid-json',
+    });
+
+    expect(result).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      source: 'shipped-defaults',
+      warnings: [expect.stringContaining(path.join(homeDir, '.tlc', 'config.json'))],
+    });
+    expect(stderr).toContain(path.join(homeDir, '.tlc', 'config.json'));
+  });
+
+  it('falls back to defaults for malformed project config JSON', () => {
+    const { result, stderr, cwd } = runPreamble({
+      commandName: 'build',
+      projectConfigRaw: '{broken-json',
+    });
+
+    expect(result).toEqual({
+      models: ['claude'],
+      strategy: 'single',
+      source: 'shipped-defaults',
+      warnings: [expect.stringContaining(path.join(cwd, '.tlc.json'))],
+    });
+    expect(stderr).toContain(path.join(cwd, '.tlc.json'));
+  });
+
+  it('still uses personal config when .tlc.json is missing in cwd', () => {
+    expect(
+      runPreamble({
+        commandName: 'quick',
+        personalConfig: {
+          task_routing: {
+            quick: { model: 'codex' },
+          },
+        },
+        projectDirName: 'cwd-without-project-config',
+      }).result,
+    ).toEqual({
+      models: ['codex'],
+      strategy: 'single',
+      source: 'personal-config',
+      warnings: [expect.stringMatching(/models/i)],
+    });
+  });
+
+  it('preserves a parallel strategy from config', () => {
+    expect(
+      runPreamble({
+        commandName: 'plan',
+        personalConfig: {
+          task_routing: {
+            plan: { model: 'codex', strategy: 'parallel' },
+          },
+        },
+      }).result,
+    ).toEqual({
+      models: ['codex'],
+      strategy: 'parallel',
+      source: 'personal-config',
+      warnings: [expect.stringMatching(/models/i)],
+    });
+  });
+
+  it('prefers models over model in the same entry', () => {
+    expect(
+      runPreamble({
+        commandName: 'build',
+        personalConfig: {
+          task_routing: {
+            build: {
+              model: 'claude',
+              models: ['codex', 'claude'],
+              strategy: 'parallel',
+            },
+          },
+        },
+      }).result,
+    ).toEqual({
+      models: ['codex', 'claude'],
+      strategy: 'parallel',
+      source: 'personal-config',
+      warnings: [],
+    });
+  });
+});

package/server/lib/routing-preamble.js

@@ -0,0 +1,116 @@
+function escapeForDoubleQuotedShell(value) {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\$/g, '\\$')
+    .replace(/`/g, '\\`');
+}
+
+function buildProgram(commandName) {
+  const serializedCommand = JSON.stringify(commandName);
+
+  return [
+    "const fs = require('fs');",
+    "const path = require('path');",
+    "const os = require('os');",
+    "function readJson(filePath, fileSystem, label) {",
+    "  try {",
+    "    return { data: JSON.parse(fileSystem.readFileSync(filePath, 'utf8')), warning: null };",
+    "  } catch (error) {",
+    "    if (error && error.code === 'ENOENT') {",
+    "      return { data: null, warning: null };",
+    "    }",
+    "    return { data: null, warning: 'Failed to parse ' + label + ' routing config at ' + filePath + ': ' + error.message };",
+    "  }",
+    "}",
+    "function loadPersonalConfig(options) {",
+    "  const configPath = path.join(options.homeDir, '.tlc', 'config.json');",
+    "  const result = readJson(configPath, options.fs, 'personal');",
+    "  return { config: result.data, warning: result.warning };",
+    "}",
+    "function loadProjectOverride(options) {",
+    "  const configPath = path.join(options.projectDir, '.tlc.json');",
+    "  const result = readJson(configPath, options.fs, 'project');",
+    "  return {",
+    "    override: result.data && result.data.task_routing_override ? result.data.task_routing_override : null,",
+    "    warning: result.warning,",
+    "  };",
+    "}",
+    "function resolveRouting(options) {",
+    "  let models = ['claude'];",
+    "  let strategy = 'single';",
+    "  let source = 'shipped-defaults';",
+    "  let providers;",
+    "  const warnings = [];",
+    "  const personalResult = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });",
+    "  const personal = personalResult.config;",
+    "  if (personalResult.warning) {",
+    "    warnings.push(personalResult.warning);",
+    "  }",
+    "  if (personal) {",
+    "    if (personal.model_providers) {",
+    "      providers = personal.model_providers;",
+    "    }",
+    "    const personalRouting = personal.task_routing && personal.task_routing[options.command];",
+    "    if (personalRouting) {",
+    "      if (Array.isArray(personalRouting.models)) {",
+    "        models = personalRouting.models.slice();",
+    "      } else if (typeof personalRouting.model === 'string') {",
+    "        models = [personalRouting.model];",
+    "        warnings.push('Deprecated routing config for command \"' + options.command + '\" in personal config: use \"models\" (array) instead of \"model\" (string).');",
+    "      }",
+    "      if (personalRouting.strategy) {",
+    "        strategy = personalRouting.strategy;",
+    "      }",
+    "      source = 'personal-config';",
+    "    }",
+    "  }",
+    "  const projectResult = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });",
+    "  const projectOverride = projectResult.override;",
+    "  if (projectResult.warning) {",
+    "    warnings.push(projectResult.warning);",
+    "  }",
+    "  if (projectOverride) {",
+    "    const overrideEntry = projectOverride[options.command];",
+    "    if (overrideEntry) {",
+    "      if (Array.isArray(overrideEntry.models)) {",
+    "        models = overrideEntry.models.slice();",
+    "      } else if (typeof overrideEntry.model === 'string') {",
+    "        models = [overrideEntry.model];",
+    "        warnings.push('Deprecated routing config for command \"' + options.command + '\" in project override: use \"models\" (array) instead of \"model\" (string).');",
+    "      }",
+    "      if (overrideEntry.strategy) {",
+    "        strategy = overrideEntry.strategy;",
+    "      }",
+      "      source = 'project-override';",
+    "    }",
+    "  }",
+    "  if (options.flagModel) {",
+    "    models = [options.flagModel];",
+    "    strategy = 'single';",
+    "    source = 'flag-override';",
+    "  }",
+    "  const result = { models, strategy, source, warnings };",
+    "  if (providers) {",
+    "    result.providers = providers;",
+    "  }",
+    "  return result;",
+    "}",
+    `const result = resolveRouting({ command: ${serializedCommand}, flagModel: process.argv[1], projectDir: process.cwd(), homeDir: process.env.HOME || os.homedir(), fs });`,
+    "if (Array.isArray(result.warnings) && result.warnings.length > 0) {",
+    "  for (const warning of result.warnings) {",
+    "    process.stderr.write(warning + '\\n');",
+    "  }",
+    "}",
+    'process.stdout.write(JSON.stringify(result));',
+  ].join('\n');
+}
+
+function generatePreamble(commandName) {
+  const program = buildProgram(commandName);
+  return `node -e "${escapeForDoubleQuotedShell(program)}"`;
+}
+
+module.exports = {
+  generatePreamble,
+};