tlc-claude-code 1.4.1 → 1.4.4

package/server/lib/api-provider.test.js

@@ -0,0 +1,336 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  createAPIProvider,
+  callAPI,
+  parseResponse,
+  calculateCost,
+  API_PRICING,
+} from './api-provider.js';
+
+// Mock fetch
+global.fetch = vi.fn();
+
+describe('api-provider', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createAPIProvider', () => {
+    it('creates provider with API type', () => {
+      const provider = createAPIProvider({
+        name: 'deepseek',
+        baseUrl: 'https://api.deepseek.com',
+        model: 'deepseek-coder',
+        capabilities: ['review'],
+      });
+
+      expect(provider.type).toBe('api');
+      expect(provider.name).toBe('deepseek');
+    });
+
+    it('sets devserverOnly to true by default', () => {
+      const provider = createAPIProvider({
+        name: 'deepseek',
+        baseUrl: 'https://api.deepseek.com',
+      });
+
+      expect(provider.devserverOnly).toBe(true);
+    });
+
+    it('stores baseUrl and model', () => {
+      const provider = createAPIProvider({
+        name: 'deepseek',
+        baseUrl: 'https://api.deepseek.com',
+        model: 'deepseek-coder',
+      });
+
+      expect(provider.baseUrl).toBe('https://api.deepseek.com');
+      expect(provider.model).toBe('deepseek-coder');
+    });
+  });
+
+  describe('callAPI', () => {
+    it('calls baseUrl/v1/chat/completions', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: '{"result": "ok"}' } }],
+          usage: { prompt_tokens: 100, completion_tokens: 50 },
+        }),
+      });
+
+      await callAPI({
+        baseUrl: 'https://api.deepseek.com',
+        model: 'deepseek-coder',
+        prompt: 'test',
+        apiKey: 'sk-test',
+      });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://api.deepseek.com/v1/chat/completions',
+        expect.any(Object)
+      );
+    });
+
+    it('sets Authorization header', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: '{}' } }],
+          usage: { prompt_tokens: 100, completion_tokens: 50 },
+        }),
+      });
+
+      await callAPI({
+        baseUrl: 'https://api.deepseek.com',
+        model: 'deepseek-coder',
+        prompt: 'test',
+        apiKey: 'sk-test-key',
+      });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'Authorization': 'Bearer sk-test-key',
+          }),
+        })
+      );
+    });
+
+    it('sends model in body', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: '{}' } }],
+          usage: { prompt_tokens: 100, completion_tokens: 50 },
+        }),
+      });
+
+      await callAPI({
+        baseUrl: 'https://api.deepseek.com',
+        model: 'deepseek-coder',
+        prompt: 'test',
+        apiKey: 'sk-test',
+      });
+
+      const callArgs = global.fetch.mock.calls[0];
+      const body = JSON.parse(callArgs[1].body);
+
+      expect(body.model).toBe('deepseek-coder');
+    });
+
+    it('includes response_format when schema provided', async () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          result: { type: 'string' },
+        },
+      };
+
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: '{"result": "ok"}' } }],
+          usage: { prompt_tokens: 100, completion_tokens: 50 },
+        }),
+      });
+
+      await callAPI({
+        baseUrl: 'https://api.deepseek.com',
+        model: 'deepseek-coder',
+        prompt: 'test',
+        apiKey: 'sk-test',
+        outputSchema: schema,
+      });
+
+      const callArgs = global.fetch.mock.calls[0];
+      const body = JSON.parse(callArgs[1].body);
+
+      expect(body.response_format).toBeDefined();
+      expect(body.response_format.type).toBe('json_schema');
+    });
+  });
+
+  describe('parseResponse', () => {
+    it('extracts content from response', () => {
+      const response = {
+        choices: [{ message: { content: '{"result": "ok"}' } }],
+        usage: { prompt_tokens: 100, completion_tokens: 50 },
+      };
+
+      const result = parseResponse(response);
+
+      expect(result.raw).toBe('{"result": "ok"}');
+    });
+
+    it('extracts token usage', () => {
+      const response = {
+        choices: [{ message: { content: '{}' } }],
+        usage: { prompt_tokens: 100, completion_tokens: 50 },
+      };
+
+      const result = parseResponse(response);
+
+      expect(result.tokenUsage).toEqual({ input: 100, output: 50 });
+    });
+
+    it('parses JSON content', () => {
+      const response = {
+        choices: [{ message: { content: '{"score": 85}' } }],
+        usage: { prompt_tokens: 100, completion_tokens: 50 },
+      };
+
+      const result = parseResponse(response);
+
+      expect(result.parsed).toEqual({ score: 85 });
+    });
+
+    it('handles non-JSON content', () => {
+      const response = {
+        choices: [{ message: { content: 'Plain text response' } }],
+        usage: { prompt_tokens: 100, completion_tokens: 50 },
+      };
+
+      const result = parseResponse(response);
+
+      expect(result.raw).toBe('Plain text response');
+      expect(result.parsed).toBeNull();
+    });
+  });
+
+  describe('calculateCost', () => {
+    it('uses provider pricing', () => {
+      const cost = calculateCost(
+        { input: 1000, output: 500 },
+        { input: 0.001, output: 0.002 }
+      );
+
+      // (1000 * 0.001 + 500 * 0.002) / 1000 = 0.002
+      expect(cost).toBeCloseTo(0.002);
+    });
+
+    it('handles zero tokens', () => {
+      const cost = calculateCost(
+        { input: 0, output: 0 },
+        { input: 0.001, output: 0.002 }
+      );
+
+      expect(cost).toBe(0);
+    });
+
+    it('returns null when no pricing', () => {
+      const cost = calculateCost({ input: 1000, output: 500 }, null);
+
+      expect(cost).toBeNull();
+    });
+  });
+
+  describe('rate limit handling', () => {
+    it('retries on rate limit', async () => {
+      let attempts = 0;
+      global.fetch.mockImplementation(() => {
+        attempts++;
+        if (attempts === 1) {
+          return Promise.resolve({
+            ok: false,
+            status: 429,
+            headers: { get: () => '1' }, // Retry-After
+          });
+        }
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve({
+            choices: [{ message: { content: '{}' } }],
+            usage: { prompt_tokens: 10, completion_tokens: 5 },
+          }),
+        });
+      });
+
+      const result = await callAPI({
+        baseUrl: 'https://api.example.com',
+        model: 'test',
+        prompt: 'test',
+        apiKey: 'sk-test',
+        retryDelay: 10,
+      });
+
+      expect(attempts).toBe(2);
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('error handling', () => {
+    it('handles network errors gracefully', async () => {
+      global.fetch.mockRejectedValue(new Error('Network error'));
+
+      const result = await callAPI({
+        baseUrl: 'https://api.example.com',
+        model: 'test',
+        prompt: 'test',
+        apiKey: 'sk-test',
+        maxRetries: 1,
+      });
+
+      expect(result.exitCode).not.toBe(0);
+      expect(result.error).toBeDefined();
+    });
+
+    it('handles API errors', async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        json: () => Promise.resolve({ error: { message: 'Server error' } }),
+      });
+
+      const result = await callAPI({
+        baseUrl: 'https://api.example.com',
+        model: 'test',
+        prompt: 'test',
+        apiKey: 'sk-test',
+        maxRetries: 1,
+      });
+
+      expect(result.exitCode).not.toBe(0);
+    });
+  });
+
+  describe('DeepSeek support', () => {
+    it('supports DeepSeek endpoint', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: '{"review": "LGTM"}' } }],
+          usage: { prompt_tokens: 500, completion_tokens: 100 },
+        }),
+      });
+
+      const result = await callAPI({
+        baseUrl: 'https://api.deepseek.com',
+        model: 'deepseek-coder',
+        prompt: 'Review this code',
+        apiKey: 'sk-deepseek-key',
+      });
+
+      expect(result.parsed).toEqual({ review: 'LGTM' });
+      expect(result.tokenUsage).toEqual({ input: 500, output: 100 });
+    });
+  });
+
+  describe('API_PRICING', () => {
+    it('has pricing for deepseek', () => {
+      expect(API_PRICING.deepseek).toBeDefined();
+      expect(API_PRICING.deepseek.input).toBeDefined();
+      expect(API_PRICING.deepseek.output).toBeDefined();
+    });
+
+    it('has pricing for mistral', () => {
+      expect(API_PRICING.mistral).toBeDefined();
+    });
+
+    it('has default pricing', () => {
+      expect(API_PRICING.default).toBeDefined();
+    });
+  });
+});

package/server/lib/cli-detector.js

@@ -0,0 +1,166 @@
+/**
+ * CLI Detector - Detects locally installed AI CLI tools
+ *
+ * Supports detection of:
+ * - claude (Claude Code)
+ * - codex (Codex CLI)
+ * - gemini (Gemini CLI)
+ */
+
+import { execSync } from 'child_process';
+
+/**
+ * CLI tool configurations
+ */
+export const CLI_TOOLS = {
+  claude: {
+    command: 'claude',
+    headlessArgs: ['-p', '--output-format', 'json'],
+    capabilities: ['review', 'code-gen', 'refactor', 'explain', 'test-gen'],
+    versionFlag: '--version',
+    versionParser: (output) => {
+      const match = output.match(/v?(\d+\.\d+\.\d+)/);
+      return match ? match[0] : output.trim();
+    },
+  },
+  codex: {
+    command: 'codex',
+    headlessArgs: ['exec', '--json', '--sandbox', 'read-only'],
+    capabilities: ['review', 'code-gen', 'refactor', 'explain'],
+    versionFlag: '--version',
+    versionParser: (output) => {
+      const match = output.match(/(\d+\.\d+\.\d+)/);
+      return match ? match[0] : output.trim();
+    },
+  },
+  gemini: {
+    command: 'gemini',
+    headlessArgs: ['-p', '--output-format', 'json'],
+    capabilities: ['design', 'image-gen', 'vision', 'review', 'explain'],
+    versionFlag: '--version',
+    versionParser: (output) => {
+      const match = output.match(/(\d+\.\d+\.\d+)/);
+      return match ? match[0] : output.trim();
+    },
+  },
+};
+
+// Detection cache
+let detectionCache = null;
+let cacheTimestamp = 0;
+const CACHE_TTL = 60000; // 1 minute
+
+/**
+ * Get the 'which' command based on platform
+ * @returns {string} Command to find executables
+ */
+function getWhichCommand() {
+  return process.platform === 'win32' ? 'where' : 'which';
+}
+
+/**
+ * Execute a command with timeout
+ * @param {string} command - Command to execute
+ * @param {number} timeout - Timeout in ms
+ * @returns {string|null} Output or null on failure
+ */
+function execWithTimeout(command, timeout = 5000) {
+  try {
+    const result = execSync(command, {
+      timeout,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return result.toString().trim();
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Detect a single CLI tool
+ * @param {string} name - CLI tool name (claude, codex, gemini)
+ * @returns {Promise<Object|null>} Detection result or null if not found
+ */
+export async function detectCLI(name) {
+  const tool = CLI_TOOLS[name];
+  if (!tool) {
+    return null;
+  }
+
+  const whichCmd = getWhichCommand();
+
+  // Check if command exists
+  const path = execWithTimeout(`${whichCmd} ${tool.command}`);
+  if (!path) {
+    return null;
+  }
+
+  // Get version
+  let version = 'unknown';
+  try {
+    const versionOutput = execWithTimeout(`${tool.command} ${tool.versionFlag}`);
+    if (versionOutput) {
+      version = tool.versionParser(versionOutput);
+    }
+  } catch (err) {
+    // Version detection failed, but CLI exists
+  }
+
+  return {
+    name,
+    command: tool.command,
+    path: path.split('\n')[0].trim(),
+    version,
+    capabilities: tool.capabilities,
+    headlessArgs: tool.headlessArgs,
+  };
+}
+
+/**
+ * Detect all CLI tools
+ * @param {boolean} [useCache=true] - Whether to use cached results
+ * @returns {Promise<Map<string, Object>>} Map of detected CLIs
+ */
+export async function detectAllCLIs(useCache = true) {
+  const now = Date.now();
+
+  // Return cached results if valid
+  if (useCache && detectionCache && (now - cacheTimestamp) < CACHE_TTL) {
+    return detectionCache;
+  }
+
+  const detected = new Map();
+
+  // Detect each CLI tool
+  for (const name of Object.keys(CLI_TOOLS)) {
+    const result = await detectCLI(name);
+    if (result) {
+      detected.set(name, result);
+    }
+  }
+
+  // Update cache
+  detectionCache = detected;
+  cacheTimestamp = now;
+
+  return detected;
+}
+
+/**
+ * Clear the detection cache
+ */
+export function clearCache() {
+  detectionCache = null;
+  cacheTimestamp = 0;
+}
+
+/**
+ * Get capabilities for a CLI tool
+ * @param {string} name - CLI tool name
+ * @returns {string[]} List of capabilities
+ */
+export function getCapabilities(name) {
+  const tool = CLI_TOOLS[name];
+  return tool ? [...tool.capabilities] : [];
+}