tlc-claude-code 2.2.1 → 2.4.0

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/scope-checker.js

@@ -0,0 +1,127 @@
+/**
+ * Scope Checker
+ * Compare diff files against plan task files to detect scope drift
+ */
+
+/**
+ * Extract planned file paths from PLAN.md content.
+ * Parses all `**Files:**` sections and collects listed file paths.
+ * @param {string} planContent - Raw content of a PLAN.md file
+ * @returns {string[]} Deduplicated array of planned file paths
+ */
+function extractPlannedFiles(planContent) {
+  if (!planContent) return [];
+
+  const files = [];
+  const seen = new Set();
+  const lines = planContent.split('\n');
+  let inFilesSection = false;
+
+  for (const line of lines) {
+    if (line.trim().startsWith('**Files:**')) {
+      inFilesSection = true;
+      continue;
+    }
+
+    if (inFilesSection) {
+      const match = line.match(/^- (.+)/);
+      if (match) {
+        // Strip backticks, em-dashes, and parenthetical annotations like (new), (modify)
+        const filePath = match[1]
+          .replace(/`/g, '')
+          .split(' — ')[0]
+          .split(' -- ')[0]
+          .replace(/\s*\((?:new|modify|delete|update|create)\)\s*$/i, '')
+          .trim();
+        if (!seen.has(filePath)) {
+          seen.add(filePath);
+          files.push(filePath);
+        }
+      } else {
+        // Non-list line ends the Files section
+        inFilesSection = false;
+      }
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Check if a file path is a test file.
+ * Matches `.test.`, `_test.`, and `test_` patterns.
+ * @param {string} filePath - File path to check
+ * @returns {boolean} True if the file is a test file
+ */
+function isTestFile(filePath) {
+  const name = filePath.split('/').pop() || filePath;
+  // Check filename patterns
+  const nameMatch = (
+    name.includes('.test.') ||
+    name.includes('.spec.') ||
+    name.includes('_test.') ||
+    name.startsWith('test_')
+  );
+  if (nameMatch) return true;
+
+  // Check directory-based test paths (tests/, __tests__/, test/, spec/)
+  const dirMatch = /(?:^|\/)(?:tests|__tests__|test|spec)\//.test(filePath);
+  return dirMatch;
+}
+
+/**
+ * Detect scope drift between diff files and planned files.
+ * Returns files present in diff but not in plan (drift),
+ * and files in plan but not in diff (missing).
+ * Test files are excluded from drift detection.
+ * @param {string[]} diffFiles - Files changed in the diff
+ * @param {string[]} plannedFiles - Files listed in the plan
+ * @returns {{ drift: string[], missing: string[] }} Drift report
+ */
+function detectDrift(diffFiles, plannedFiles) {
+  if (!diffFiles || !plannedFiles) return { drift: [], missing: [] };
+
+  const plannedSet = new Set(plannedFiles);
+  const diffSet = new Set(diffFiles);
+
+  const drift = diffFiles.filter(
+    (f) => !plannedSet.has(f) && !isTestFile(f)
+  );
+
+  const missing = plannedFiles.filter((f) => !diffSet.has(f));
+
+  return { drift, missing };
+}
+
+/**
+ * Format a drift report as markdown.
+ * Returns "No drift detected" when both arrays are empty.
+ * @param {string[]} drift - Files in diff but not in plan
+ * @param {string[]} missing - Files in plan but not in diff
+ * @returns {string} Formatted markdown report
+ */
+function formatDriftReport(drift, missing) {
+  if ((!drift || drift.length === 0) && (!missing || missing.length === 0)) {
+    return 'No drift detected';
+  }
+
+  const sections = [];
+
+  if (drift && drift.length > 0) {
+    sections.push(
+      '### Scope Drift\n\nFiles changed but not in plan:\n\n' +
+        drift.map((f) => `- \`${f}\``).join('\n')
+    );
+  }
+
+  if (missing && missing.length > 0) {
+    sections.push(
+      '### Missing Work\n\nPlanned files not yet changed:\n\n' +
+        missing.map((f) => `- \`${f}\``).join('\n')
+    );
+  }
+
+  return sections.join('\n\n');
+}
+
+module.exports = { extractPlannedFiles, isTestFile, detectDrift, formatDriftReport };