tlc-claude-code 2.2.1 → 2.4.0

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

@@ -0,0 +1,142 @@
+/**
+ * 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];
+      }
+      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];
+      }
+      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,
+};

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();
+    });
+  });
+});

package/server/lib/test-selector.js

@@ -0,0 +1,127 @@
+/**
+ * Diff-Based Test Selection
+ * Map test files to their source dependencies and select only affected tests
+ * when source files change.
+ */
+
+/**
+ * Parse `// @depends path/to/file.js` comments from test file content.
+ * Supports multiple @depends lines and comma-separated paths on a single line.
+ *
+ * @param {string} testContent - The raw content of a test file
+ * @returns {string[]} Array of dependency paths extracted from @depends comments
+ */
+function parseDependsComment(testContent) {
+  if (!testContent) return [];
+
+  const results = [];
+  const lines = testContent.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    // Only match lines that start with a comment marker
+    if (!trimmed.startsWith('//')) continue;
+
+    const match = trimmed.match(/^\/\/\s*@depends\s+(.+)$/);
+    if (!match) continue;
+
+    const pathsPart = match[1];
+    const paths = pathsPart.split(',').map((p) => p.trim()).filter(Boolean);
+    results.push(...paths);
+  }
+
+  return results;
+}
+
+/**
+ * Read each test file and extract @depends comments to build a mapping
+ * from test files to their source dependencies.
+ *
+ * @param {string[]} testFiles - Array of test file paths
+ * @param {object} options - Options object
+ * @param {function} options.readFile - Async function to read file contents (path) => string
+ * @returns {Promise<Map<string, string[]>>} Map from test file path to dependency paths
+ */
+async function buildTestMap(testFiles, options = {}) {
+  if (!testFiles || testFiles.length === 0) return new Map();
+
+  const { readFile } = options;
+  if (!readFile) {
+    throw new Error('options.readFile is required');
+  }
+
+  const map = new Map();
+
+  for (const testFile of testFiles) {
+    try {
+      const content = await readFile(testFile);
+      const deps = parseDependsComment(content);
+      map.set(testFile, deps);
+    } catch {
+      // If we can't read the file, treat as no-depends (conservative)
+      map.set(testFile, []);
+    }
+  }
+
+  return map;
+}
+
+/**
+ * Given a list of changed source files and a test map, return the test files
+ * whose dependencies include any changed file. Tests with no @depends
+ * annotation are always included (conservative approach).
+ *
+ * @param {string[]} changedFiles - Array of changed source file paths
+ * @param {Map<string, string[]>} testMap - Map from test file to dependency paths
+ * @returns {string[]} Array of affected test file paths
+ */
+function getAffectedTests(changedFiles, testMap) {
+  if (!testMap || testMap.size === 0) return [];
+  if (!changedFiles || !Array.isArray(changedFiles)) {
+    // Conservative fallback: run ALL tests when diff is unavailable
+    return [...testMap.keys()];
+  }
+
+  const changedSet = new Set(changedFiles);
+  const affected = [];
+
+  for (const [testFile, deps] of testMap) {
+    // Always include test files that were themselves changed in the diff
+    if (changedSet.has(testFile)) {
+      affected.push(testFile);
+      continue;
+    }
+
+    // No @depends means always include (conservative)
+    if (deps.length === 0) {
+      affected.push(testFile);
+      continue;
+    }
+
+    // Include if any dependency is in the changed set
+    const isAffected = deps.some((dep) => changedSet.has(dep));
+    if (isAffected) {
+      affected.push(testFile);
+    }
+  }
+
+  return affected;
+}
+
+/**
+ * Format a human-readable summary of test selection results.
+ *
+ * @param {number} affected - Number of affected (selected) tests
+ * @param {number} total - Total number of tests
+ * @returns {string} Human-readable selection summary
+ */
+function formatSelection(affected, total) {
+  if (affected === total) {
+    return `Running all ${total} tests`;
+  }
+
+  const skipped = total - affected;
+  return `Running ${affected} of ${total} tests (${skipped} skipped — dependencies unchanged)`;
+}
+
+module.exports = { parseDependsComment, buildTestMap, getAffectedTests, formatSelection };