tlc-claude-code 1.7.0 → 1.8.0

package/server/lib/llm/provider-registry.test.js

@@ -0,0 +1,157 @@
+/**
+ * Provider Registry Tests
+ *
+ * Runtime registry of available providers with health status.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const {
+  createRegistry,
+} = require('./provider-registry.js');
+
+describe('Provider Registry', () => {
+  let registry;
+  let mockHealthCheck;
+
+  beforeEach(() => {
+    mockHealthCheck = vi.fn().mockResolvedValue({ available: true, version: '1.0.0' });
+    registry = createRegistry({ healthCheck: mockHealthCheck });
+  });
+
+  describe('register', () => {
+    it('registers CLI provider', () => {
+      registry.register({
+        name: 'codex',
+        type: 'cli',
+        command: 'codex',
+        capabilities: ['review', 'code-gen'],
+      });
+
+      const providers = registry.list();
+      expect(providers).toHaveLength(1);
+      expect(providers[0].name).toBe('codex');
+      expect(providers[0].type).toBe('cli');
+    });
+
+    it('registers API provider', () => {
+      registry.register({
+        name: 'litellm',
+        type: 'api',
+        url: 'http://localhost:4000',
+        capabilities: ['review'],
+      });
+
+      const providers = registry.list();
+      expect(providers).toHaveLength(1);
+      expect(providers[0].type).toBe('api');
+    });
+  });
+
+  describe('health', () => {
+    it('health check passes for available CLI', async () => {
+      mockHealthCheck.mockResolvedValue({ available: true, version: '2.1.0' });
+      registry.register({ name: 'codex', type: 'cli', command: 'codex', capabilities: ['review'] });
+
+      const status = await registry.checkHealth('codex');
+      expect(status.available).toBe(true);
+      expect(status.version).toBe('2.1.0');
+    });
+
+    it('health check fails for missing CLI', async () => {
+      mockHealthCheck.mockResolvedValue({ available: false, error: 'not found' });
+      registry.register({ name: 'codex', type: 'cli', command: 'codex', capabilities: ['review'] });
+
+      const status = await registry.checkHealth('codex');
+      expect(status.available).toBe(false);
+    });
+
+    it('health check passes for reachable API', async () => {
+      mockHealthCheck.mockResolvedValue({ available: true, latency: 50 });
+      registry.register({ name: 'litellm', type: 'api', url: 'http://localhost:4000', capabilities: ['review'] });
+
+      const status = await registry.checkHealth('litellm');
+      expect(status.available).toBe(true);
+    });
+
+    it('health check fails for unreachable API', async () => {
+      mockHealthCheck.mockResolvedValue({ available: false, error: 'connection refused' });
+      registry.register({ name: 'litellm', type: 'api', url: 'http://localhost:4000', capabilities: ['review'] });
+
+      const status = await registry.checkHealth('litellm');
+      expect(status.available).toBe(false);
+    });
+  });
+
+  describe('capability lookup', () => {
+    it('lists providers by capability', () => {
+      registry.register({ name: 'codex', type: 'cli', command: 'codex', capabilities: ['review', 'code-gen'] });
+      registry.register({ name: 'gemini', type: 'cli', command: 'gemini', capabilities: ['design', 'review'] });
+      registry.register({ name: 'litellm', type: 'api', url: 'http://localhost:4000', capabilities: ['review'] });
+
+      const reviewProviders = registry.getByCapability('review');
+      expect(reviewProviders).toHaveLength(3);
+
+      const designProviders = registry.getByCapability('design');
+      expect(designProviders).toHaveLength(1);
+      expect(designProviders[0].name).toBe('gemini');
+    });
+
+    it('returns best available provider (first healthy in priority order)', async () => {
+      mockHealthCheck
+        .mockResolvedValueOnce({ available: false }) // codex unhealthy
+        .mockResolvedValueOnce({ available: true, version: '1.0' }); // gemini healthy
+
+      registry.register({ name: 'codex', type: 'cli', command: 'codex', capabilities: ['review'], priority: 1 });
+      registry.register({ name: 'gemini', type: 'cli', command: 'gemini', capabilities: ['review'], priority: 2 });
+
+      const best = await registry.getBestProvider('review');
+      expect(best.name).toBe('gemini');
+    });
+  });
+
+  describe('health cache', () => {
+    it('caches health status within TTL', async () => {
+      registry = createRegistry({ healthCheck: mockHealthCheck, cacheTTL: 5000 });
+      registry.register({ name: 'codex', type: 'cli', command: 'codex', capabilities: ['review'] });
+
+      await registry.checkHealth('codex');
+      await registry.checkHealth('codex');
+
+      expect(mockHealthCheck).toHaveBeenCalledTimes(1);
+    });
+
+    it('refreshes status after TTL expires', async () => {
+      registry = createRegistry({ healthCheck: mockHealthCheck, cacheTTL: 10 });
+      registry.register({ name: 'codex', type: 'cli', command: 'codex', capabilities: ['review'] });
+
+      await registry.checkHealth('codex');
+      await new Promise(r => setTimeout(r, 20));
+      await registry.checkHealth('codex');
+
+      expect(mockHealthCheck).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('config loading', () => {
+    it('loads providers from config', () => {
+      const config = {
+        providers: {
+          codex: { type: 'cli', command: 'codex', capabilities: ['review'] },
+          gemini: { type: 'cli', command: 'gemini', capabilities: ['design'] },
+        },
+      };
+
+      const reg = createRegistry({ healthCheck: mockHealthCheck });
+      reg.loadFromConfig(config);
+
+      expect(reg.list()).toHaveLength(2);
+    });
+
+    it('handles empty config gracefully', () => {
+      const reg = createRegistry({ healthCheck: mockHealthCheck });
+      reg.loadFromConfig({});
+
+      expect(reg.list()).toHaveLength(0);
+    });
+  });
+});

package/server/lib/llm/review-service.js

@@ -0,0 +1,222 @@
+/**
+ * Unified Review Service
+ *
+ * One service: router → executor → prompt → parse → findings.
+ * Replaces the disconnected pieces with a single coherent flow.
+ *
+ * @module llm/review-service
+ */
+
+const path = require('path');
+
+/** Docs-only extensions that skip LLM review */
+const DOCS_EXTENSIONS = ['.md', '.txt', '.rst', '.adoc'];
+
+/** Severity mapping from LLM levels to gate levels */
+const SEVERITY_MAP = {
+  critical: 'block',
+  high: 'block',
+  medium: 'warn',
+  low: 'info',
+  block: 'block',
+  warn: 'warn',
+  info: 'info',
+};
+
+/**
+ * Check if review should be skipped (docs-only)
+ * @param {string[]} files - Changed file paths
+ * @returns {boolean}
+ */
+function shouldSkip(files) {
+  if (!files || files.length === 0) return false;
+  return files.every(f => {
+    const ext = path.extname(f).toLowerCase();
+    return DOCS_EXTENSIONS.includes(ext);
+  });
+}
+
+/**
+ * Build review prompt
+ * @param {string} diff - Git diff
+ * @param {string} standards - Coding standards content
+ * @returns {string}
+ */
+function buildPrompt(diff, standards) {
+  let prompt = 'You are a strict code reviewer. Review this diff';
+  if (standards) {
+    prompt += ' against these coding standards:\n\n' + standards + '\n\n';
+  }
+  prompt += '\n\nDiff:\n```\n' + diff + '\n```\n\n';
+  prompt += 'Respond with JSON: {"findings": [{"severity": "critical|high|medium|low", "file": "path", "line": 0, "rule": "name", "message": "desc", "fix": "how"}], "summary": "text"}\n';
+  prompt += 'Respond ONLY with JSON.';
+  return prompt;
+}
+
+/**
+ * Parse LLM response to structured findings
+ * @param {string} response - Raw LLM response
+ * @returns {Object} { findings, summary }
+ */
+function parseResponse(response) {
+  const codeBlockMatch = response.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  const jsonStr = codeBlockMatch ? codeBlockMatch[1].trim() : response.trim();
+
+  try {
+    const parsed = JSON.parse(jsonStr);
+    const findings = (parsed.findings || []).map(f => ({
+      ...f,
+      severity: SEVERITY_MAP[f.severity] || 'warn',
+    }));
+    return { findings, summary: parsed.summary || '' };
+  } catch {
+    return { findings: [], summary: response.substring(0, 200) };
+  }
+}
+
+/**
+ * Deduplicate findings by file+line+rule, merge flaggedBy
+ * @param {Array} findings - All findings
+ * @returns {Array} Deduplicated
+ */
+function deduplicateFindings(findings) {
+  const PRIORITY = { block: 3, warn: 2, info: 1 };
+  const map = new Map();
+
+  for (const finding of findings) {
+    const key = finding.file + ':' + finding.line + ':' + finding.rule;
+    if (map.has(key)) {
+      const existing = map.get(key);
+      for (const m of (finding.flaggedBy || [])) {
+        if (!existing.flaggedBy.includes(m)) existing.flaggedBy.push(m);
+      }
+      if ((PRIORITY[finding.severity] || 0) > (PRIORITY[existing.severity] || 0)) {
+        existing.severity = finding.severity;
+        existing.message = finding.message;
+      }
+    } else {
+      map.set(key, { ...finding, flaggedBy: finding.flaggedBy || [] });
+    }
+  }
+
+  return Array.from(map.values());
+}
+
+/**
+ * Create the unified review service
+ * @param {Object} options - Service options
+ * @param {Object} options.registry - Provider registry
+ * @param {Object} options.executor - Provider executor
+ * @param {boolean} options.multiModel - Enable multi-model mode
+ * @param {number} options.timeout - Review timeout
+ * @param {string} options.standards - Coding standards text
+ * @returns {Object} Service with review method
+ */
+function createReviewService(options = {}) {
+  const { registry, executor, multiModel = false, timeout, standards = '' } = options;
+
+  return {
+    /**
+     * Review a diff
+     * @param {string} diff - Git diff content
+     * @param {Object} reviewOptions - Per-review options
+     * @returns {Promise<Object>} { findings, summary, provider, latency }
+     */
+    async review(diff, reviewOptions = {}) {
+      // Skip docs-only
+      if (shouldSkip(reviewOptions.files)) {
+        return { findings: [], summary: 'Skipped (docs-only)', skipped: true };
+      }
+
+      // No registry or executor — return empty
+      if (!registry || !executor) {
+        return { findings: [], summary: 'No providers configured' };
+      }
+
+      const prompt = buildPrompt(diff, standards);
+      const providers = registry.getByCapability('review');
+
+      if (providers.length === 0) {
+        return { findings: [], summary: 'No review providers available — static-only fallback' };
+      }
+
+      // Multi-model: fan out to all providers
+      if (multiModel && providers.length > 1) {
+        return await reviewMultiModel(prompt, providers, executor, timeout);
+      }
+
+      // Single-model: try providers in order until one works
+      return await reviewSingleModel(prompt, providers, executor, timeout);
+    },
+  };
+}
+
+/**
+ * Single-model review: try providers in priority order
+ */
+async function reviewSingleModel(prompt, providers, executor, timeout) {
+  const sorted = [...providers].sort((a, b) => (a.priority || 99) - (b.priority || 99));
+
+  for (const provider of sorted) {
+    try {
+      const result = await executor.execute(prompt, { ...provider, timeout });
+      const parsed = parseResponse(result.response);
+      return {
+        findings: parsed.findings,
+        summary: parsed.summary,
+        provider: provider.name,
+        latency: result.latency,
+      };
+    } catch {
+      // Try next provider
+      continue;
+    }
+  }
+
+  // All failed
+  return { findings: [], summary: 'All providers failed — static-only fallback' };
+}
+
+/**
+ * Multi-model review: fan out to all, aggregate
+ */
+async function reviewMultiModel(prompt, providers, executor, timeout) {
+  const results = await Promise.allSettled(
+    providers.map(async (provider) => {
+      const result = await executor.execute(prompt, { ...provider, timeout });
+      const parsed = parseResponse(result.response);
+      return {
+        model: provider.name,
+        findings: parsed.findings.map(f => ({ ...f, flaggedBy: [provider.name] })),
+        summary: parsed.summary,
+        latency: result.latency,
+      };
+    })
+  );
+
+  const successful = results
+    .filter(r => r.status === 'fulfilled')
+    .map(r => r.value);
+
+  if (successful.length === 0) {
+    return { findings: [], summary: 'All providers failed — static-only fallback' };
+  }
+
+  // Aggregate findings
+  const allFindings = successful.flatMap(r => r.findings);
+  const deduped = deduplicateFindings(allFindings);
+
+  // Merge summaries
+  const summaryParts = successful.map(r => '[' + r.model + ']: ' + r.summary);
+
+  return {
+    findings: deduped,
+    summary: summaryParts.join('\n'),
+    providers: successful.map(r => r.model),
+    latency: Math.max(...successful.map(r => r.latency)),
+  };
+}
+
+module.exports = {
+  createReviewService,
+};

package/server/lib/llm/review-service.test.js

@@ -0,0 +1,220 @@
+/**
+ * Unified Review Service Tests
+ *
+ * One service: router → executor → prompt → parse → findings.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+const {
+  createReviewService,
+} = require('./review-service.js');
+
+describe('Review Service', () => {
+  const makeMockRegistry = (providers = []) => ({
+    getByCapability: vi.fn().mockReturnValue(providers),
+    getBestProvider: vi.fn().mockResolvedValue(providers[0] || null),
+    checkHealth: vi.fn().mockResolvedValue({ available: true }),
+  });
+
+  const makeMockExecutor = (response = '{"findings": [], "summary": "Clean"}') => ({
+    execute: vi.fn().mockResolvedValue({
+      response,
+      model: 'test-model',
+      latency: 100,
+    }),
+  });
+
+  describe('single-model review', () => {
+    it('routes to configured provider', async () => {
+      const registry = makeMockRegistry([
+        { name: 'codex', type: 'cli', command: 'codex' },
+      ]);
+      const executor = makeMockExecutor();
+
+      const service = createReviewService({ registry, executor });
+      const result = await service.review('diff content');
+
+      expect(result.provider).toBe('codex');
+      expect(result.findings).toBeDefined();
+    });
+
+    it('returns findings from one provider', async () => {
+      const registry = makeMockRegistry([
+        { name: 'codex', type: 'cli', command: 'codex' },
+      ]);
+      const executor = makeMockExecutor(
+        '{"findings": [{"severity": "high", "file": "a.js", "line": 1, "rule": "xss", "message": "XSS risk", "fix": "sanitize"}], "summary": "1 issue"}'
+      );
+
+      const service = createReviewService({ registry, executor });
+      const result = await service.review('diff content');
+
+      expect(result.findings).toHaveLength(1);
+      expect(result.findings[0].severity).toBe('block');
+    });
+
+    it('falls back to next provider on failure', async () => {
+      const providers = [
+        { name: 'codex', type: 'cli', command: 'codex' },
+        { name: 'gemini', type: 'cli', command: 'gemini' },
+      ];
+      const registry = makeMockRegistry(providers);
+      registry.getBestProvider = vi.fn().mockResolvedValue(providers[0]);
+
+      const executor = {
+        execute: vi.fn()
+          .mockRejectedValueOnce(new Error('codex failed'))
+          .mockResolvedValueOnce({
+            response: '{"findings": [], "summary": "OK"}',
+            model: 'gemini',
+            latency: 200,
+          }),
+      };
+
+      const service = createReviewService({ registry, executor });
+      const result = await service.review('diff');
+
+      expect(result.provider).toBe('gemini');
+    });
+
+    it('includes provider name in result', async () => {
+      const registry = makeMockRegistry([
+        { name: 'codex', type: 'cli', command: 'codex' },
+      ]);
+      const executor = makeMockExecutor();
+
+      const service = createReviewService({ registry, executor });
+      const result = await service.review('diff');
+
+      expect(result.provider).toBeDefined();
+    });
+
+    it('includes latency in result', async () => {
+      const registry = makeMockRegistry([
+        { name: 'codex', type: 'cli', command: 'codex' },
+      ]);
+      const executor = makeMockExecutor();
+
+      const service = createReviewService({ registry, executor });
+      const result = await service.review('diff');
+
+      expect(result.latency).toBeDefined();
+      expect(typeof result.latency).toBe('number');
+    });
+  });
+
+  describe('multi-model review', () => {
+    it('fans out to all review providers', async () => {
+      const providers = [
+        { name: 'codex', type: 'cli', command: 'codex' },
+        { name: 'gemini', type: 'cli', command: 'gemini' },
+      ];
+      const registry = makeMockRegistry(providers);
+      const executor = makeMockExecutor();
+
+      const service = createReviewService({ registry, executor, multiModel: true });
+      const result = await service.review('diff');
+
+      expect(executor.execute).toHaveBeenCalledTimes(2);
+    });
+
+    it('aggregates multi-model findings with deduplication', async () => {
+      const providers = [
+        { name: 'codex', type: 'cli', command: 'codex' },
+        { name: 'gemini', type: 'cli', command: 'gemini' },
+      ];
+      const registry = makeMockRegistry(providers);
+
+      const executor = {
+        execute: vi.fn()
+          .mockResolvedValueOnce({
+            response: '{"findings": [{"severity": "warn", "file": "a.js", "line": 1, "rule": "no-console", "message": "console"}], "summary": "A"}',
+            model: 'codex',
+            latency: 100,
+          })
+          .mockResolvedValueOnce({
+            response: '{"findings": [{"severity": "warn", "file": "a.js", "line": 1, "rule": "no-console", "message": "console log"}], "summary": "B"}',
+            model: 'gemini',
+            latency: 150,
+          }),
+      };
+
+      const service = createReviewService({ registry, executor, multiModel: true });
+      const result = await service.review('diff');
+
+      // Same file+line+rule → deduplicated to 1 finding
+      expect(result.findings).toHaveLength(1);
+      expect(result.findings[0].flaggedBy).toContain('codex');
+      expect(result.findings[0].flaggedBy).toContain('gemini');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('skips docs-only changes', async () => {
+      const registry = makeMockRegistry([
+        { name: 'codex', type: 'cli', command: 'codex' },
+      ]);
+      const executor = makeMockExecutor();
+
+      const service = createReviewService({ registry, executor });
+      const result = await service.review('diff --git a/README.md b/README.md', {
+        files: ['README.md', 'docs/guide.md'],
+      });
+
+      expect(result.skipped).toBe(true);
+      expect(executor.execute).not.toHaveBeenCalled();
+    });
+
+    it('handles all providers failing (static-only fallback)', async () => {
+      const registry = makeMockRegistry([
+        { name: 'codex', type: 'cli', command: 'codex' },
+      ]);
+      const executor = {
+        execute: vi.fn().mockRejectedValue(new Error('all fail')),
+      };
+
+      const service = createReviewService({ registry, executor });
+      const result = await service.review('diff');
+
+      expect(result.findings).toEqual([]);
+      expect(result.summary).toContain('static-only');
+    });
+
+    it('works with no config (sensible defaults)', () => {
+      const service = createReviewService({});
+      expect(service).toBeDefined();
+      expect(service.review).toBeDefined();
+    });
+
+    it('provider order from config determines priority', async () => {
+      const providers = [
+        { name: 'codex', type: 'cli', command: 'codex', priority: 1 },
+        { name: 'gemini', type: 'cli', command: 'gemini', priority: 2 },
+      ];
+      const registry = makeMockRegistry(providers);
+      const executor = makeMockExecutor();
+
+      const service = createReviewService({ registry, executor });
+      await service.review('diff');
+
+      // Should try codex first (priority 1)
+      const firstCall = executor.execute.mock.calls[0];
+      expect(firstCall[1].command || firstCall[1].name).toBeDefined();
+    });
+
+    it('respects timeout from config', async () => {
+      const registry = makeMockRegistry([
+        { name: 'codex', type: 'cli', command: 'codex' },
+      ]);
+      const executor = makeMockExecutor();
+
+      const service = createReviewService({ registry, executor, timeout: 30000 });
+      await service.review('diff');
+
+      expect(executor.execute).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({ timeout: 30000 })
+      );
+    });
+  });
+});