tlc-claude-code 2.4.2 → 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

@@ -13,28 +13,40 @@ function buildProgram(commandName) {
     "const fs = require('fs');",
     "const path = require('path');",
     "const os = require('os');",
-    "function readJson(filePath, fileSystem) {",
+    "function readJson(filePath, fileSystem, label) {",
     "  try {",
-    "    return JSON.parse(fileSystem.readFileSync(filePath, 'utf8'));",
-    "  } catch {",
-    "    return null;",
+    "    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');",
-    "  return readJson(configPath, options.fs);",
+    "  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 data = readJson(configPath, options.fs);",
-    "  return data && data.task_routing_override ? data.task_routing_override : null;",
+    "  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 personal = loadPersonalConfig({ homeDir: options.homeDir, fs: options.fs });",
+    "  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;",
@@ -45,6 +57,7 @@ function buildProgram(commandName) {
     "        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;",
@@ -52,7 +65,11 @@ function buildProgram(commandName) {
     "      source = 'personal-config';",
     "    }",
     "  }",
-    "  const projectOverride = loadProjectOverride({ projectDir: options.projectDir, fs: options.fs });",
+    "  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) {",
@@ -60,11 +77,12 @@ function buildProgram(commandName) {
     "        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';",
+      "      source = 'project-override';",
     "    }",
     "  }",
     "  if (options.flagModel) {",
@@ -72,13 +90,18 @@ function buildProgram(commandName) {
     "    strategy = 'single';",
     "    source = 'flag-override';",
     "  }",
-    "  const result = { models, strategy, source };",
+    "  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');
 }

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

@@ -50,6 +50,7 @@ describe('routing-preamble', () => {
       models: ['claude'],
       strategy: 'single',
       source: 'shipped-defaults',
+      warnings: [],
     });
   });
 
@@ -67,6 +68,7 @@ describe('routing-preamble', () => {
       models: ['codex', 'claude'],
       strategy: 'parallel',
       source: 'personal-config',
+      warnings: [],
     });
   });
 
@@ -89,6 +91,7 @@ describe('routing-preamble', () => {
       models: ['gemini'],
       strategy: 'single',
       source: 'project-override',
+      warnings: [],
     });
   });
 
@@ -106,6 +109,7 @@ describe('routing-preamble', () => {
       models: ['codex'],
       strategy: 'single',
       source: 'personal-config',
+      warnings: [expect.stringMatching(/models/i)],
     });
   });
 
@@ -123,6 +127,7 @@ describe('routing-preamble', () => {
       models: ['codex', 'claude'],
       strategy: 'parallel',
       source: 'personal-config',
+      warnings: [],
     });
   });
 
@@ -147,6 +152,7 @@ describe('routing-preamble', () => {
       strategy: 'single',
       source: 'personal-config',
       providers,
+      warnings: [],
     });
   });
 
@@ -170,6 +176,7 @@ describe('routing-preamble', () => {
       models: ['local-model'],
       strategy: 'single',
       source: 'flag-override',
+      warnings: [],
     });
   });
 
@@ -192,6 +199,7 @@ describe('routing-preamble', () => {
       models: ['claude'],
       strategy: 'single',
       source: 'shipped-defaults',
+      warnings: [expect.stringContaining(path.join(homeDir, '.tlc', 'config.json'))],
     });
   });
 
@@ -213,6 +221,7 @@ describe('routing-preamble', () => {
       models: ['claude'],
       strategy: 'single',
       source: 'shipped-defaults',
+      warnings: [expect.stringContaining(path.join(cwd, '.tlc.json'))],
     });
   });
 
@@ -240,6 +249,7 @@ describe('routing-preamble', () => {
       models: ['codex'],
       strategy: 'single',
       source: 'project-override',
+      warnings: [expect.stringMatching(/models/i)],
     });
   });
 
@@ -250,6 +260,7 @@ describe('routing-preamble', () => {
       models: ['claude'],
       strategy: 'single',
       source: 'shipped-defaults',
+      warnings: [],
     });
   });
 });

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

@@ -35,15 +35,21 @@ for (const cmd of ROUTABLE_COMMANDS) {
  * @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
+ * @returns {{ config: object|null, warning: string|null }} Parsed config and optional warning
  */
 function loadPersonalConfig({ homeDir, fs }) {
+  const configPath = path.join(homeDir, '.tlc', 'config.json');
   try {
-    const configPath = path.join(homeDir, '.tlc', 'config.json');
     const content = fs.readFileSync(configPath, 'utf-8');
-    return JSON.parse(content);
-  } catch {
-    return null;
+    return { config: JSON.parse(content), warning: null };
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return { config: null, warning: null };
+    }
+    return {
+      config: null,
+      warning: `Failed to parse personal routing config at ${configPath}: ${error.message}`,
+    };
   }
 }
 
@@ -52,16 +58,22 @@ function loadPersonalConfig({ homeDir, fs }) {
  * @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
+ * @returns {{ override: object|null, warning: string|null }} The task_routing_override section and optional warning
  */
 function loadProjectOverride({ projectDir, fs }) {
+  const configPath = path.join(projectDir, '.tlc.json');
   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;
+    return { override: data.task_routing_override || null, warning: null };
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return { override: null, warning: null };
+    }
+    return {
+      override: null,
+      warning: `Failed to parse project routing config at ${configPath}: ${error.message}`,
+    };
   }
 }
 
@@ -74,7 +86,7 @@ function loadProjectOverride({ projectDir, fs }) {
  * @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 }}
+ * @returns {{ models: string[], strategy: string, source: string, providers?: object, warnings: string[] }}
  */
 function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDir = require('os').homedir(), fs = require('fs') }) {
   // Start with shipped defaults
@@ -83,9 +95,13 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
   let strategy = defaultEntry.strategy;
   let source = 'shipped-defaults';
   let providers;
+  const warnings = [];
 
   // Layer 1: personal config (~/.tlc/config.json)
-  const personal = loadPersonalConfig({ homeDir, fs });
+  const { config: personal, warning: personalWarning } = loadPersonalConfig({ homeDir, fs });
+  if (personalWarning) {
+    warnings.push(personalWarning);
+  }
   if (personal) {
     // Capture model_providers if present
     if (personal.model_providers) {
@@ -98,6 +114,7 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
         models = [...personalRouting.models];
       } else if (personalRouting.model) {
         models = [personalRouting.model];
+        warnings.push(`Deprecated routing config for command "${command}" in personal config: use "models" (array) instead of "model" (string).`);
       }
       if (personalRouting.strategy) {
         strategy = personalRouting.strategy;
@@ -107,7 +124,10 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
   }
 
   // Layer 2: project override (.tlc.json -> task_routing_override)
-  const projectOverride = loadProjectOverride({ projectDir, fs });
+  const { override: projectOverride, warning: projectWarning } = loadProjectOverride({ projectDir, fs });
+  if (projectWarning) {
+    warnings.push(projectWarning);
+  }
   if (projectOverride) {
     const overrideEntry = projectOverride[command];
     if (overrideEntry) {
@@ -115,6 +135,7 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
         models = [...overrideEntry.models];
       } else if (overrideEntry.model) {
         models = [overrideEntry.model];
+        warnings.push(`Deprecated routing config for command "${command}" in project override: use "models" (array) instead of "model" (string).`);
       }
       if (overrideEntry.strategy) {
         strategy = overrideEntry.strategy;
@@ -130,7 +151,7 @@ function resolveRouting({ command, flagModel, projectDir = process.cwd(), homeDi
     source = 'flag-override';
   }
 
-  const result = { models, strategy, source };
+  const result = { models, strategy, source, warnings };
   if (providers) {
     result.providers = providers;
   }