tlc-claude-code 1.7.0 → 1.8.0

package/server/lib/llm/adapters/api-adapter.js

@@ -0,0 +1,95 @@
+/**
+ * API Adapter
+ *
+ * HTTP adapter for OpenAI-compatible APIs (LiteLLM, direct).
+ *
+ * @module llm/adapters/api-adapter
+ */
+
+const DEFAULT_TIMEOUT = 60000;
+
+/**
+ * Build HTTP request for OpenAI-compatible API
+ * @param {string} prompt - Prompt text
+ * @param {Object} options - Adapter options
+ * @returns {Object} Request specification
+ */
+function buildRequest(prompt, options = {}) {
+  const headers = { 'Content-Type': 'application/json' };
+
+  if (options.apiKey) {
+    headers['Authorization'] = 'Bearer ' + options.apiKey;
+  }
+
+  return {
+    url: options.url,
+    method: 'POST',
+    headers,
+    body: {
+      model: options.model,
+      messages: [{ role: 'user', content: prompt }],
+    },
+    timeout: options.timeout || DEFAULT_TIMEOUT,
+  };
+}
+
+/**
+ * Parse OpenAI-format API response
+ * @param {Object|null} data - Response JSON body
+ * @param {Object} httpResponse - HTTP response metadata
+ * @returns {Object} Parsed response
+ */
+function parseApiResponse(data, httpResponse = {}) {
+  if (httpResponse.status === 429) {
+    return {
+      error: 'Rate limited (429)',
+      retryable: true,
+      response: '',
+    };
+  }
+
+  if (!data || !data.choices) {
+    return {
+      error: 'Invalid API response',
+      retryable: false,
+      response: '',
+    };
+  }
+
+  const content = data.choices[0]?.message?.content || '';
+
+  return {
+    response: content,
+    model: data.model || 'unknown',
+    tokens: data.usage?.total_tokens || 0,
+  };
+}
+
+/**
+ * Create an API adapter instance
+ * @param {Object} config - Adapter config
+ * @returns {Object} Adapter with execute interface
+ */
+function createAdapter(config = {}) {
+  return {
+    name: 'api',
+    execute: async (prompt, deps = {}) => {
+      const req = buildRequest(prompt, config);
+      const { executeApiProvider } = deps;
+      if (!executeApiProvider) {
+        throw new Error('executeApiProvider dependency required');
+      }
+      const result = await executeApiProvider(prompt, {
+        ...config,
+        fetch: deps.fetch,
+      });
+      return result;
+    },
+  };
+}
+
+module.exports = {
+  buildRequest,
+  parseApiResponse,
+  createAdapter,
+};

package/server/lib/llm/adapters/api-adapter.test.js

@@ -0,0 +1,81 @@
+/**
+ * API Adapter Tests
+ *
+ * HTTP adapter for OpenAI-compatible APIs (LiteLLM, direct).
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+const {
+  buildRequest,
+  parseApiResponse,
+  createAdapter,
+} = require('./api-adapter.js');
+
+describe('API Adapter', () => {
+  describe('buildRequest', () => {
+    it('sends correct HTTP request body', () => {
+      const req = buildRequest('Review code', {
+        url: 'http://localhost:4000/v1/chat/completions',
+        model: 'gpt-4o',
+      });
+
+      expect(req.url).toBe('http://localhost:4000/v1/chat/completions');
+      expect(req.body.model).toBe('gpt-4o');
+      expect(req.body.messages).toBeDefined();
+      expect(req.body.messages[0].content).toContain('Review code');
+    });
+
+    it('includes auth header from config', () => {
+      const req = buildRequest('prompt', {
+        url: 'http://api.example.com/v1/chat/completions',
+        model: 'gpt-4o',
+        apiKey: 'sk-test-key',
+      });
+
+      expect(req.headers['Authorization']).toBe('Bearer sk-test-key');
+    });
+
+    it('respects timeout', () => {
+      const req = buildRequest('prompt', {
+        url: 'http://localhost:4000/v1/chat/completions',
+        model: 'gpt-4o',
+        timeout: 30000,
+      });
+
+      expect(req.timeout).toBe(30000);
+    });
+  });
+
+  describe('parseApiResponse', () => {
+    it('parses OpenAI-format response', () => {
+      const apiResp = {
+        choices: [{ message: { content: '{"findings": [], "summary": "Clean"}' } }],
+        model: 'gpt-4o',
+        usage: { total_tokens: 500 },
+      };
+
+      const result = parseApiResponse(apiResp);
+      expect(result.response).toContain('Clean');
+      expect(result.model).toBe('gpt-4o');
+      expect(result.tokens).toBe(500);
+    });
+
+    it('handles rate limiting (429)', () => {
+      const result = parseApiResponse(null, { status: 429 });
+      expect(result.error).toBeDefined();
+      expect(result.retryable).toBe(true);
+    });
+  });
+
+  describe('createAdapter', () => {
+    it('implements execute interface', () => {
+      const adapter = createAdapter({
+        url: 'http://localhost:4000/v1/chat/completions',
+        model: 'gpt-4o',
+      });
+
+      expect(adapter.name).toBe('api');
+      expect(adapter.execute).toBeDefined();
+    });
+  });
+});

package/server/lib/llm/adapters/codex-adapter.js

@@ -0,0 +1,85 @@
+/**
+ * Codex CLI Adapter
+ *
+ * Format prompts for Codex CLI and parse its output.
+ *
+ * @module llm/adapters/codex-adapter
+ */
+
+const DEFAULT_TIMEOUT = 60000;
+
+/**
+ * Build Codex CLI command
+ * @param {string} prompt - Prompt text
+ * @param {Object} options - Adapter options
+ * @returns {Object} Command specification
+ */
+function buildCommand(prompt, options = {}) {
+  const args = ['--quiet'];
+
+  if (options.model) {
+    args.push('--model', options.model);
+  }
+
+  return {
+    command: 'codex',
+    args,
+    prompt,
+    timeout: options.timeout || DEFAULT_TIMEOUT,
+  };
+}
+
+/**
+ * Parse Codex response
+ * @param {string} output - Raw CLI output
+ * @returns {Object} Parsed response
+ */
+function parseResponse(output) {
+  const trimmed = output.trim();
+
+  // Try JSON parse first
+  try {
+    const parsed = JSON.parse(trimmed);
+    return {
+      findings: parsed.findings || [],
+      summary: parsed.summary || '',
+      raw: trimmed,
+    };
+  } catch {
+    // Not JSON — return raw
+    return {
+      raw: trimmed,
+      findings: [],
+      summary: trimmed,
+    };
+  }
+}
+
+/**
+ * Create a Codex adapter instance
+ * @param {Object} config - Adapter config
+ * @returns {Object} Adapter with execute interface
+ */
+function createAdapter(config = {}) {
+  return {
+    name: 'codex',
+    execute: async (prompt, deps = {}) => {
+      const cmd = buildCommand(prompt, config);
+      const { executeCliProvider } = deps;
+      if (!executeCliProvider) {
+        throw new Error('executeCliProvider dependency required');
+      }
+      const result = await executeCliProvider(prompt, {
+        ...cmd,
+        spawn: deps.spawn,
+      });
+      return parseResponse(result.response);
+    },
+  };
+}
+
+module.exports = {
+  buildCommand,
+  parseResponse,
+  createAdapter,
+};

package/server/lib/llm/adapters/codex-adapter.test.js

@@ -0,0 +1,54 @@
+/**
+ * Codex CLI Adapter Tests
+ *
+ * Format prompts for Codex CLI, parse its output.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+const {
+  buildCommand,
+  parseResponse,
+  createAdapter,
+} = require('./codex-adapter.js');
+
+describe('Codex Adapter', () => {
+  describe('buildCommand', () => {
+    it('builds correct CLI command', () => {
+      const cmd = buildCommand('Review this code', { model: 'gpt-4o' });
+      expect(cmd.command).toBe('codex');
+      expect(cmd.args).toContain('--quiet');
+    });
+
+    it('passes model flag from config', () => {
+      const cmd = buildCommand('prompt', { model: 'o3-mini' });
+      expect(cmd.args).toContain('--model');
+      expect(cmd.args).toContain('o3-mini');
+    });
+
+    it('respects timeout', () => {
+      const cmd = buildCommand('prompt', { timeout: 30000 });
+      expect(cmd.timeout).toBe(30000);
+    });
+  });
+
+  describe('parseResponse', () => {
+    it('parses JSON response', () => {
+      const json = JSON.stringify({ findings: [{ severity: 'high', message: 'XSS' }], summary: 'Issues found' });
+      const result = parseResponse(json);
+      expect(result.findings).toHaveLength(1);
+    });
+
+    it('handles non-JSON output gracefully', () => {
+      const result = parseResponse('This is a plain text review response with some issues noted.');
+      expect(result.raw).toBeDefined();
+    });
+  });
+
+  describe('createAdapter', () => {
+    it('implements execute interface', () => {
+      const adapter = createAdapter({ model: 'gpt-4o' });
+      expect(adapter.name).toBe('codex');
+      expect(adapter.execute).toBeDefined();
+    });
+  });
+});

package/server/lib/llm/adapters/gemini-adapter.js

@@ -0,0 +1,100 @@
+/**
+ * Gemini CLI Adapter
+ *
+ * Format prompts for Gemini CLI and parse its output.
+ *
+ * @module llm/adapters/gemini-adapter
+ */
+
+const DEFAULT_TIMEOUT = 60000;
+
+/**
+ * Build Gemini CLI command
+ * @param {string} prompt - Prompt text
+ * @param {Object} options - Adapter options
+ * @returns {Object} Command specification
+ */
+function buildCommand(prompt, options = {}) {
+  const args = [];
+
+  if (options.model) {
+    args.push('--model', options.model);
+  }
+
+  return {
+    command: 'gemini',
+    args,
+    prompt,
+    timeout: options.timeout || DEFAULT_TIMEOUT,
+  };
+}
+
+/**
+ * Parse Gemini response (may be markdown or JSON in code block)
+ * @param {string} output - Raw CLI output
+ * @returns {Object} Parsed response
+ */
+function parseResponse(output) {
+  const trimmed = output.trim();
+
+  // Try to extract JSON from markdown code block
+  const codeBlockMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (codeBlockMatch) {
+    try {
+      const parsed = JSON.parse(codeBlockMatch[1].trim());
+      return {
+        findings: parsed.findings || [],
+        summary: parsed.summary || '',
+        raw: trimmed,
+      };
+    } catch {
+      // JSON in code block but invalid — fall through
+    }
+  }
+
+  // Try direct JSON parse
+  try {
+    const parsed = JSON.parse(trimmed);
+    return {
+      findings: parsed.findings || [],
+      summary: parsed.summary || '',
+      raw: trimmed,
+    };
+  } catch {
+    // Markdown/text response
+    return {
+      raw: trimmed,
+      findings: [],
+      summary: trimmed,
+    };
+  }
+}
+
+/**
+ * Create a Gemini adapter instance
+ * @param {Object} config - Adapter config
+ * @returns {Object} Adapter with execute interface
+ */
+function createAdapter(config = {}) {
+  return {
+    name: 'gemini',
+    execute: async (prompt, deps = {}) => {
+      const cmd = buildCommand(prompt, config);
+      const { executeCliProvider } = deps;
+      if (!executeCliProvider) {
+        throw new Error('executeCliProvider dependency required');
+      }
+      const result = await executeCliProvider(prompt, {
+        ...cmd,
+        spawn: deps.spawn,
+      });
+      return parseResponse(result.response);
+    },
+  };
+}
+
+module.exports = {
+  buildCommand,
+  parseResponse,
+  createAdapter,
+};

package/server/lib/llm/adapters/gemini-adapter.test.js

@@ -0,0 +1,54 @@
+/**
+ * Gemini CLI Adapter Tests
+ *
+ * Format prompts for Gemini CLI, parse its output.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+const {
+  buildCommand,
+  parseResponse,
+  createAdapter,
+} = require('./gemini-adapter.js');
+
+describe('Gemini Adapter', () => {
+  describe('buildCommand', () => {
+    it('builds correct CLI command', () => {
+      const cmd = buildCommand('Review this code', {});
+      expect(cmd.command).toBe('gemini');
+    });
+
+    it('passes model flag from config', () => {
+      const cmd = buildCommand('prompt', { model: 'gemini-2.5-pro' });
+      expect(cmd.args).toContain('--model');
+      expect(cmd.args).toContain('gemini-2.5-pro');
+    });
+
+    it('respects timeout', () => {
+      const cmd = buildCommand('prompt', { timeout: 45000 });
+      expect(cmd.timeout).toBe(45000);
+    });
+  });
+
+  describe('parseResponse', () => {
+    it('parses markdown response', () => {
+      const markdown = '## Issues\n- Line 5: XSS vulnerability\n- Line 12: Missing validation';
+      const result = parseResponse(markdown);
+      expect(result.raw).toContain('XSS');
+    });
+
+    it('handles structured output mode', () => {
+      const json = '```json\n{"findings": [{"severity": "high", "message": "SQL injection"}]}\n```';
+      const result = parseResponse(json);
+      expect(result.findings).toHaveLength(1);
+    });
+  });
+
+  describe('createAdapter', () => {
+    it('implements execute interface', () => {
+      const adapter = createAdapter({ model: 'gemini-2.5-pro' });
+      expect(adapter.name).toBe('gemini');
+      expect(adapter.execute).toBeDefined();
+    });
+  });
+});

package/server/lib/llm/index.js

@@ -0,0 +1,109 @@
+/**
+ * LLM Service - Unified API
+ *
+ * createLLMService(config) → { review(diff), execute(prompt), health() }
+ *
+ * @module llm
+ */
+
+const { createExecutor } = require('./provider-executor.js');
+const { createRegistry } = require('./provider-registry.js');
+const { createReviewService } = require('./review-service.js');
+
+/**
+ * Create the unified LLM service
+ * @param {Object} config - Service configuration
+ * @param {Object} config.providers - Provider configs { name: { type, command, capabilities } }
+ * @param {boolean} config.multiModel - Enable multi-model review
+ * @param {number} config.timeout - Default timeout
+ * @param {Object} deps - Injectable dependencies
+ * @param {Function} deps.healthCheck - Health check function
+ * @param {Function} deps.spawn - Process spawn function
+ * @param {Function} deps.fetch - HTTP fetch function
+ * @returns {Object} Service with review, execute, health methods
+ */
+function createLLMService(config = {}, deps = {}) {
+  const { providers = {}, multiModel = false, timeout } = config;
+
+  // Build health check from deps
+  const healthCheck = deps.healthCheck || (() => Promise.resolve({ available: false }));
+
+  // Create registry and load providers
+  const registry = createRegistry({ healthCheck, cacheTTL: config.cacheTTL });
+  registry.loadFromConfig({ providers });
+
+  // Create executor with real spawn/fetch
+  const executor = createExecutor({
+    spawn: deps.spawn,
+    fetch: deps.fetch,
+  });
+
+  // Create review service
+  const reviewService = createReviewService({
+    registry,
+    executor,
+    multiModel,
+    timeout,
+    standards: config.standards || '',
+  });
+
+  return {
+    /**
+     * Review a diff using configured providers
+     * @param {string} diff - Git diff content
+     * @param {Object} options - Review options
+     * @returns {Promise<Object>} { findings, summary, provider, latency }
+     */
+    review: (diff, options) => reviewService.review(diff, options),
+
+    /**
+     * Execute a generic prompt against best available provider
+     * @param {string} prompt - Prompt text
+     * @param {Object} options - Execution options
+     * @returns {Promise<Object>} { response, model, latency }
+     */
+    execute: async (prompt, options = {}) => {
+      const capability = options.capability || 'code-gen';
+      const provider = await registry.getBestProvider(capability);
+
+      if (!provider) {
+        // Fall back to first available provider
+        const allProviders = registry.list();
+        if (allProviders.length === 0) {
+          return { response: '', error: 'No providers configured' };
+        }
+
+        try {
+          return await executor.execute(prompt, { ...allProviders[0], timeout });
+        } catch (err) {
+          return { response: '', error: err.message };
+        }
+      }
+
+      try {
+        return await executor.execute(prompt, { ...provider, timeout });
+      } catch (err) {
+        return { response: '', error: err.message };
+      }
+    },
+
+    /**
+     * Get health status of all providers
+     * @returns {Promise<Object>} { providers: { name: status } }
+     */
+    health: async () => {
+      const allProviders = registry.list();
+      const statuses = {};
+
+      for (const provider of allProviders) {
+        statuses[provider.name] = await registry.checkHealth(provider.name);
+      }
+
+      return { providers: statuses };
+    },
+  };
+}
+
+module.exports = {
+  createLLMService,
+};