tlc-claude-code 2.3.0 → 2.4.0

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

@@ -0,0 +1,428 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  resolveRouting,
+  loadPersonalConfig,
+  loadProjectOverride,
+  SHIPPED_DEFAULTS,
+  ROUTABLE_COMMANDS,
+} from './task-router-config.js';
+
+/**
+ * Helper: build a mock fs with readFileSync that serves different
+ * content per path. Paths not in the map throw ENOENT.
+ */
+function mockFs(fileMap = {}) {
+  return {
+    readFileSync(path, _encoding) {
+      if (fileMap[path] !== undefined) {
+        return fileMap[path];
+      }
+      const err = new Error(`ENOENT: no such file or directory, open '${path}'`);
+      err.code = 'ENOENT';
+      throw err;
+    },
+  };
+}
+
+describe('task-router-config', () => {
+  // ── SHIPPED_DEFAULTS ──────────────────────────────────────────────
+  describe('SHIPPED_DEFAULTS', () => {
+    it('maps every routable command to claude/single', () => {
+      for (const cmd of ROUTABLE_COMMANDS) {
+        expect(SHIPPED_DEFAULTS[cmd]).toEqual({
+          models: ['claude'],
+          strategy: 'single',
+        });
+      }
+    });
+  });
+
+  // ── ROUTABLE_COMMANDS ─────────────────────────────────────────────
+  describe('ROUTABLE_COMMANDS', () => {
+    it('contains the expected commands', () => {
+      const expected = [
+        'build', 'plan', 'review', 'test', 'coverage',
+        'autofix', 'discuss', 'docs', 'edge-cases', 'quick',
+      ];
+      for (const cmd of expected) {
+        expect(ROUTABLE_COMMANDS).toContain(cmd);
+      }
+    });
+  });
+
+  // ── loadPersonalConfig ────────────────────────────────────────────
+  describe('loadPersonalConfig', () => {
+    it('returns parsed config when file exists', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'single' },
+        },
+        model_providers: {
+          codex: { type: 'cli', command: 'codex' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+      });
+
+      const result = loadPersonalConfig({ homeDir: '/home/user', fs });
+      expect(result).toEqual(personalConfig);
+    });
+
+    it('returns null when file does not exist', () => {
+      const fs = mockFs({});
+      const result = loadPersonalConfig({ homeDir: '/home/user', fs });
+      expect(result).toBeNull();
+    });
+
+    it('returns null for malformed JSON', () => {
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': '{ not valid json',
+      });
+      const result = loadPersonalConfig({ homeDir: '/home/user', fs });
+      expect(result).toBeNull();
+    });
+  });
+
+  // ── loadProjectOverride ───────────────────────────────────────────
+  describe('loadProjectOverride', () => {
+    it('returns task_routing_override section when present', () => {
+      const tlcJson = {
+        task_routing_override: {
+          build: { models: ['local'], strategy: 'single' },
+        },
+      };
+      const fs = mockFs({
+        '/project/.tlc.json': JSON.stringify(tlcJson),
+      });
+
+      const result = loadProjectOverride({ projectDir: '/project', fs });
+      expect(result).toEqual(tlcJson.task_routing_override);
+    });
+
+    it('returns null when .tlc.json has no task_routing_override', () => {
+      const fs = mockFs({
+        '/project/.tlc.json': JSON.stringify({ router: {} }),
+      });
+
+      const result = loadProjectOverride({ projectDir: '/project', fs });
+      expect(result).toBeNull();
+    });
+
+    it('returns null when .tlc.json does not exist', () => {
+      const fs = mockFs({});
+      const result = loadProjectOverride({ projectDir: '/project', fs });
+      expect(result).toBeNull();
+    });
+
+    it('returns null for malformed JSON', () => {
+      const fs = mockFs({
+        '/project/.tlc.json': 'broken!!!',
+      });
+      const result = loadProjectOverride({ projectDir: '/project', fs });
+      expect(result).toBeNull();
+    });
+  });
+
+  // ── resolveRouting ────────────────────────────────────────────────
+  describe('resolveRouting', () => {
+    it('returns shipped defaults when no config exists', () => {
+      const fs = mockFs({});
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result).toEqual({
+        models: ['claude'],
+        strategy: 'single',
+        source: 'shipped-defaults',
+      });
+    });
+
+    it('personal config overrides defaults', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'single' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result).toEqual({
+        models: ['codex'],
+        strategy: 'single',
+        source: 'personal-config',
+      });
+    });
+
+    it('project override overrides personal config', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'single' },
+        },
+      };
+      const tlcJson = {
+        task_routing_override: {
+          build: { models: ['local'], strategy: 'single' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+        '/project/.tlc.json': JSON.stringify(tlcJson),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result).toEqual({
+        models: ['local'],
+        strategy: 'single',
+        source: 'project-override',
+      });
+    });
+
+    it('flag override overrides everything', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'single' },
+        },
+      };
+      const tlcJson = {
+        task_routing_override: {
+          build: { models: ['local'], strategy: 'single' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+        '/project/.tlc.json': JSON.stringify(tlcJson),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        flagModel: 'gemini',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result).toEqual({
+        models: ['gemini'],
+        strategy: 'single',
+        source: 'flag-override',
+      });
+    });
+
+    it('unknown command returns defaults (claude, single)', () => {
+      const fs = mockFs({});
+      const result = resolveRouting({
+        command: 'nonexistent-command',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result).toEqual({
+        models: ['claude'],
+        strategy: 'single',
+        source: 'shipped-defaults',
+      });
+    });
+
+    it('personal config for one command does not affect another', () => {
+      const personalConfig = {
+        task_routing: {
+          review: { models: ['claude', 'codex'], strategy: 'parallel' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+      });
+
+      // 'review' should use personal config
+      const reviewResult = resolveRouting({
+        command: 'review',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+      expect(reviewResult).toEqual({
+        models: ['claude', 'codex'],
+        strategy: 'parallel',
+        source: 'personal-config',
+      });
+
+      // 'build' should still use defaults
+      const buildResult = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+      expect(buildResult).toEqual({
+        models: ['claude'],
+        strategy: 'single',
+        source: 'shipped-defaults',
+      });
+    });
+
+    it('partial personal config merges correctly (only strategy)', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { strategy: 'parallel' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      // Should keep default models but use personal strategy
+      expect(result.strategy).toBe('parallel');
+      expect(result.models).toEqual(['claude']);
+      expect(result.source).toBe('personal-config');
+    });
+
+    it('partial personal config merges correctly (only models)', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { models: ['codex'] },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result.models).toEqual(['codex']);
+      expect(result.strategy).toBe('single');
+      expect(result.source).toBe('personal-config');
+    });
+
+    it('missing personal config file handled gracefully', () => {
+      const fs = mockFs({
+        '/project/.tlc.json': JSON.stringify({
+          task_routing_override: {
+            build: { models: ['local'], strategy: 'single' },
+          },
+        }),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result).toEqual({
+        models: ['local'],
+        strategy: 'single',
+        source: 'project-override',
+      });
+    });
+
+    it('malformed personal JSON handled gracefully', () => {
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': '{{{{not json!',
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result).toEqual({
+        models: ['claude'],
+        strategy: 'single',
+        source: 'shipped-defaults',
+      });
+    });
+
+    it('malformed project JSON handled gracefully', () => {
+      const fs = mockFs({
+        '/project/.tlc.json': 'not json either!',
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result).toEqual({
+        models: ['claude'],
+        strategy: 'single',
+        source: 'shipped-defaults',
+      });
+    });
+
+    it('model_providers loaded from personal config', () => {
+      const personalConfig = {
+        task_routing: {
+          build: { models: ['codex'], strategy: 'single' },
+        },
+        model_providers: {
+          claude: { type: 'inline' },
+          codex: { type: 'cli', command: 'codex' },
+          gemini: { type: 'cli', command: 'gemini' },
+        },
+      };
+      const fs = mockFs({
+        '/home/user/.tlc/config.json': JSON.stringify(personalConfig),
+      });
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result.models).toEqual(['codex']);
+      expect(result.providers).toEqual(personalConfig.model_providers);
+    });
+
+    it('returns no providers when personal config has none', () => {
+      const fs = mockFs({});
+
+      const result = resolveRouting({
+        command: 'build',
+        projectDir: '/project',
+        homeDir: '/home/user',
+        fs,
+      });
+
+      expect(result.providers).toBeUndefined();
+    });
+  });
+});