tlc-claude-code 1.4.1 → 1.4.4

package/server/lib/output-schemas.test.js

@@ -0,0 +1,307 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import {
+  loadSchema,
+  validateOutput,
+  buildPromptWithSchema,
+  schemaToPromptInstructions,
+  BUILTIN_SCHEMAS,
+} from './output-schemas.js';
+
+// Mock fs/promises
+vi.mock('fs/promises');
+
+describe('output-schemas', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('loadSchema', () => {
+    it('reads schema from file', async () => {
+      const schema = {
+        type: 'object',
+        properties: { result: { type: 'string' } },
+      };
+
+      fs.readFile.mockResolvedValue(JSON.stringify(schema));
+
+      const loaded = await loadSchema('/.tlc/schemas/test-schema.json');
+
+      expect(loaded).toEqual(schema);
+      expect(fs.readFile).toHaveBeenCalledWith('/.tlc/schemas/test-schema.json', 'utf8');
+    });
+
+    it('returns parsed JSON', async () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          summary: { type: 'string' },
+          score: { type: 'number' },
+        },
+        required: ['summary'],
+      };
+
+      fs.readFile.mockResolvedValue(JSON.stringify(schema));
+
+      const loaded = await loadSchema('/.tlc/schemas/review.json');
+
+      expect(loaded.type).toBe('object');
+      expect(loaded.properties.summary.type).toBe('string');
+      expect(loaded.required).toContain('summary');
+    });
+
+    it('handles missing schema file', async () => {
+      fs.readFile.mockRejectedValue(new Error('ENOENT: no such file'));
+
+      await expect(loadSchema('/.tlc/schemas/missing.json'))
+        .rejects.toThrow(/ENOENT|no such file/i);
+    });
+
+    it('handles invalid JSON', async () => {
+      fs.readFile.mockResolvedValue('not valid json {');
+
+      await expect(loadSchema('/.tlc/schemas/invalid.json'))
+        .rejects.toThrow();
+    });
+  });
+
+  describe('validateOutput', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        summary: { type: 'string' },
+        score: { type: 'integer', minimum: 0, maximum: 100 },
+        approved: { type: 'boolean' },
+      },
+      required: ['summary', 'score', 'approved'],
+    };
+
+    it('passes valid data', () => {
+      const data = {
+        summary: 'Code looks good',
+        score: 85,
+        approved: true,
+      };
+
+      const result = validateOutput(data, schema);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+
+    it('rejects invalid data', () => {
+      const data = {
+        summary: 'Code looks good',
+        score: 'not a number', // Should be integer
+        approved: true,
+      };
+
+      const result = validateOutput(data, schema);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('rejects missing required fields', () => {
+      const data = {
+        summary: 'Code looks good',
+        // Missing score and approved
+      };
+
+      const result = validateOutput(data, schema);
+
+      expect(result.valid).toBe(false);
+    });
+
+    it('validates nested objects', () => {
+      const nestedSchema = {
+        type: 'object',
+        properties: {
+          issue: {
+            type: 'object',
+            properties: {
+              severity: { type: 'string', enum: ['critical', 'moderate', 'suggestion'] },
+              line: { type: 'integer' },
+            },
+            required: ['severity'],
+          },
+        },
+      };
+
+      const validData = {
+        issue: { severity: 'critical', line: 42 },
+      };
+
+      const invalidData = {
+        issue: { severity: 'invalid-severity' },
+      };
+
+      expect(validateOutput(validData, nestedSchema).valid).toBe(true);
+      expect(validateOutput(invalidData, nestedSchema).valid).toBe(false);
+    });
+  });
+
+  describe('BUILTIN_SCHEMAS', () => {
+    it('has review-result schema', () => {
+      const schema = BUILTIN_SCHEMAS['review-result'];
+
+      expect(schema).toBeDefined();
+      expect(schema.properties.summary).toBeDefined();
+      expect(schema.properties.issues).toBeDefined();
+      expect(schema.properties.score).toBeDefined();
+      expect(schema.properties.approved).toBeDefined();
+    });
+
+    it('review-result has required fields', () => {
+      const schema = BUILTIN_SCHEMAS['review-result'];
+
+      expect(schema.required).toContain('summary');
+      expect(schema.required).toContain('issues');
+      expect(schema.required).toContain('score');
+      expect(schema.required).toContain('approved');
+    });
+
+    it('has design-result schema', () => {
+      const schema = BUILTIN_SCHEMAS['design-result'];
+
+      expect(schema).toBeDefined();
+      expect(schema.properties.mockups).toBeDefined();
+      expect(schema.properties.rationale).toBeDefined();
+    });
+
+    it('design-result has required fields', () => {
+      const schema = BUILTIN_SCHEMAS['design-result'];
+
+      expect(schema.required).toContain('mockups');
+      expect(schema.required).toContain('rationale');
+    });
+
+    it('has code-result schema', () => {
+      const schema = BUILTIN_SCHEMAS['code-result'];
+
+      expect(schema).toBeDefined();
+      expect(schema.properties.files).toBeDefined();
+      expect(schema.properties.explanation).toBeDefined();
+    });
+
+    it('code-result has required fields', () => {
+      const schema = BUILTIN_SCHEMAS['code-result'];
+
+      expect(schema.required).toContain('files');
+      expect(schema.required).toContain('explanation');
+    });
+  });
+
+  describe('buildPromptWithSchema', () => {
+    it('injects schema into prompt', () => {
+      const prompt = 'Review this code';
+      const schema = {
+        type: 'object',
+        properties: { result: { type: 'string' } },
+      };
+
+      const result = buildPromptWithSchema(prompt, schema);
+
+      expect(result).toContain('Review this code');
+      expect(result).toContain('JSON');
+    });
+
+    it('includes schema structure', () => {
+      const prompt = 'Analyze';
+      const schema = {
+        type: 'object',
+        properties: {
+          summary: { type: 'string' },
+          score: { type: 'integer' },
+        },
+        required: ['summary'],
+      };
+
+      const result = buildPromptWithSchema(prompt, schema);
+
+      expect(result).toContain('summary');
+      expect(result).toContain('score');
+    });
+
+    it('returns original prompt when no schema', () => {
+      const prompt = 'Just a prompt';
+
+      const result = buildPromptWithSchema(prompt, null);
+
+      expect(result).toBe(prompt);
+    });
+  });
+
+  describe('schemaToPromptInstructions', () => {
+    it('creates text instructions from schema', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          summary: { type: 'string', description: 'A brief summary' },
+          score: { type: 'integer', minimum: 0, maximum: 100 },
+        },
+        required: ['summary', 'score'],
+      };
+
+      const instructions = schemaToPromptInstructions(schema);
+
+      expect(instructions).toContain('summary');
+      expect(instructions).toContain('score');
+      expect(instructions).toContain('required');
+    });
+
+    it('handles nested objects', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          data: {
+            type: 'object',
+            properties: {
+              value: { type: 'string' },
+            },
+          },
+        },
+      };
+
+      const instructions = schemaToPromptInstructions(schema);
+
+      expect(instructions).toContain('data');
+      expect(instructions).toContain('value');
+    });
+
+    it('handles arrays', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          items: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+      };
+
+      const instructions = schemaToPromptInstructions(schema);
+
+      expect(instructions).toContain('items');
+      expect(instructions).toContain('array');
+    });
+
+    it('includes enum values', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          status: {
+            type: 'string',
+            enum: ['pending', 'approved', 'rejected'],
+          },
+        },
+      };
+
+      const instructions = schemaToPromptInstructions(schema);
+
+      expect(instructions).toContain('pending');
+      expect(instructions).toContain('approved');
+      expect(instructions).toContain('rejected');
+    });
+  });
+});

package/server/lib/provider-interface.js

@@ -0,0 +1,153 @@
+/**
+ * Provider Interface - Unified interface for CLI and API providers
+ *
+ * Supports two provider types:
+ * - CLI: Wraps AI coding CLI tools (claude, codex, gemini)
+ * - API: Direct REST calls to OpenAI-compatible endpoints
+ */
+
+/**
+ * Provider types enum
+ */
+export const PROVIDER_TYPES = {
+  CLI: 'cli',
+  API: 'api',
+};
+
+/**
+ * Validate provider configuration
+ * @param {Object} config - Provider configuration
+ * @throws {Error} If configuration is invalid
+ */
+export function validateConfig(config) {
+  if (!config.name) {
+    throw new Error('name is required');
+  }
+
+  if (!config.type) {
+    throw new Error('type is required');
+  }
+
+  if (config.type !== PROVIDER_TYPES.CLI && config.type !== PROVIDER_TYPES.API) {
+    throw new Error(`Invalid provider type: ${config.type}. Must be 'cli' or 'api'`);
+  }
+
+  if (config.type === PROVIDER_TYPES.CLI && !config.command) {
+    throw new Error('command is required for CLI providers');
+  }
+
+  if (config.type === PROVIDER_TYPES.API && !config.baseUrl) {
+    throw new Error('baseUrl is required for API providers');
+  }
+}
+
+/**
+ * Create a ProviderResult object
+ * @param {Object} data - Result data
+ * @param {string} data.raw - Raw output string
+ * @param {any} data.parsed - Parsed output (typically JSON)
+ * @param {number} data.exitCode - Exit code (0 for success)
+ * @param {Object} [data.tokenUsage] - Token usage statistics
+ * @param {number} [data.cost] - Cost in USD
+ * @returns {Object} ProviderResult
+ */
+export function createProviderResult({ raw, parsed, exitCode, tokenUsage = null, cost = null }) {
+  return {
+    raw,
+    parsed,
+    exitCode,
+    tokenUsage,
+    cost,
+  };
+}
+
+/**
+ * Calculate cost from token usage
+ * @param {Object} tokenUsage - Token usage { input, output }
+ * @param {Object} pricing - Pricing { input, output } per 1K tokens
+ * @returns {number} Cost in USD
+ */
+function calculateCost(tokenUsage, pricing) {
+  if (!tokenUsage || !pricing) return null;
+
+  const inputCost = (tokenUsage.input * pricing.input) / 1000;
+  const outputCost = (tokenUsage.output * pricing.output) / 1000;
+
+  return inputCost + outputCost;
+}
+
+/**
+ * Create a provider instance
+ * @param {Object} config - Provider configuration
+ * @param {string} config.name - Provider name
+ * @param {string} config.type - Provider type ('cli' or 'api')
+ * @param {string} [config.command] - CLI command (required for CLI type)
+ * @param {string} [config.baseUrl] - API base URL (required for API type)
+ * @param {string} [config.model] - Model identifier
+ * @param {string[]} [config.capabilities] - List of capabilities
+ * @param {string[]} [config.headlessArgs] - Headless mode arguments
+ * @param {Object} [config.pricing] - Token pricing { input, output }
+ * @param {Function} [config.runner] - Custom runner function (for testing)
+ * @returns {Object} Provider instance
+ */
+export function createProvider(config) {
+  // Validate
+  if (!config.name) {
+    throw new Error('name is required');
+  }
+
+  if (config.type !== PROVIDER_TYPES.CLI && config.type !== PROVIDER_TYPES.API) {
+    throw new Error(`Invalid provider type: ${config.type}. Must be 'cli' or 'api'`);
+  }
+
+  // Freeze capabilities to make them immutable
+  const capabilities = Object.freeze([...(config.capabilities || [])]);
+
+  // Default runner that throws (should be overridden)
+  const defaultRunner = async () => {
+    throw new Error('Provider runner not implemented');
+  };
+
+  const runner = config.runner || defaultRunner;
+
+  /**
+   * Run a prompt through the provider
+   * @param {string} prompt - The prompt to send
+   * @param {Object} opts - Run options
+   * @param {string} [opts.outputFormat] - Output format ('json' or 'text')
+   * @param {string} [opts.sandbox] - Sandbox mode
+   * @param {Object} [opts.outputSchema] - JSON schema for output
+   * @param {string} [opts.cwd] - Working directory
+   * @returns {Promise<Object>} ProviderResult
+   */
+  async function run(prompt, opts = {}) {
+    const result = await runner(prompt, opts);
+
+    // Calculate cost if we have token usage and pricing
+    if (result.tokenUsage && config.pricing) {
+      result.cost = calculateCost(result.tokenUsage, config.pricing);
+    }
+
+    return createProviderResult({
+      raw: result.raw,
+      parsed: result.parsed,
+      exitCode: result.exitCode,
+      tokenUsage: result.tokenUsage || null,
+      cost: result.cost || null,
+    });
+  }
+
+  return {
+    name: config.name,
+    type: config.type,
+    command: config.command,
+    baseUrl: config.baseUrl,
+    model: config.model,
+    headlessArgs: config.headlessArgs,
+    pricing: config.pricing,
+    detected: config.detected || false,
+    devserverOnly: config.devserverOnly,
+    capabilities,
+    run,
+  };
+}