tlc-claude-code 1.4.4 → 1.4.5

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

@@ -1,307 +1,106 @@
-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');
-    });
-  });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  loadSchema,
+  validateOutput,
+  reviewResultSchema,
+  designResultSchema,
+  codeResultSchema,
+  buildPromptWithSchema,
+  schemaToPromptInstructions,
+} from './output-schemas.js';
+
+describe('Output Schemas', () => {
+  describe('loadSchema', () => {
+    it('reads from file', async () => {
+      const schema = await loadSchema('review-result');
+      expect(schema).toBeDefined();
+    });
+
+    it('returns parsed JSON', async () => {
+      const schema = await loadSchema('review-result');
+      expect(schema).toHaveProperty('type');
+    });
+
+    it('handles missing schema file', async () => {
+      await expect(loadSchema('nonexistent')).rejects.toThrow();
+    });
+  });
+
+  describe('validateOutput', () => {
+    it('passes valid data', () => {
+      const schema = {
+        type: 'object',
+        required: ['summary'],
+        properties: {
+          summary: { type: 'string' },
+        },
+      };
+
+      const result = validateOutput({ summary: 'Test' }, schema);
+      expect(result.valid).toBe(true);
+    });
+
+    it('rejects invalid data', () => {
+      const schema = {
+        type: 'object',
+        required: ['summary'],
+        properties: {
+          summary: { type: 'string' },
+        },
+      };
+
+      const result = validateOutput({ other: 'field' }, schema);
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('Built-in Schemas', () => {
+    it('reviewResultSchema has required fields', () => {
+      expect(reviewResultSchema.properties).toHaveProperty('summary');
+      expect(reviewResultSchema.properties).toHaveProperty('issues');
+      expect(reviewResultSchema.properties).toHaveProperty('score');
+      expect(reviewResultSchema.properties).toHaveProperty('approved');
+    });
+
+    it('designResultSchema has required fields', () => {
+      expect(designResultSchema.properties).toHaveProperty('mockups');
+      expect(designResultSchema.properties).toHaveProperty('rationale');
+      expect(designResultSchema.properties).toHaveProperty('alternatives');
+    });
+
+    it('codeResultSchema has required fields', () => {
+      expect(codeResultSchema.properties).toHaveProperty('files');
+      expect(codeResultSchema.properties).toHaveProperty('explanation');
+      expect(codeResultSchema.properties).toHaveProperty('tests');
+    });
+  });
+
+  describe('buildPromptWithSchema', () => {
+    it('injects schema into prompt', () => {
+      const prompt = 'Review this code';
+      const schema = { type: 'object', properties: { summary: { type: 'string' } } };
+
+      const enhanced = buildPromptWithSchema(prompt, schema);
+
+      expect(enhanced).toContain('Review this code');
+      expect(enhanced).toContain('JSON');
+    });
+  });
+
+  describe('schemaToPromptInstructions', () => {
+    it('creates text instructions', () => {
+      const schema = {
+        type: 'object',
+        properties: {
+          summary: { type: 'string', description: 'Brief summary' },
+          score: { type: 'number', description: 'Quality score 0-100' },
+        },
+      };
+
+      const instructions = schemaToPromptInstructions(schema);
+
+      expect(instructions).toContain('summary');
+      expect(instructions).toContain('score');
+    });
+  });
+});

package/server/lib/provider-interface.js

@@ -1,153 +1,99 @@
-/**
- * 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,
-  };
-}
+/**
+ * Provider Interface - Unified interface for CLI and API providers
+ * Phase 33, Task 1
+ */
+
+export const ProviderType = {
+  CLI: 'cli',
+  API: 'api',
+};
+
+/**
+ * Validate provider configuration
+ */
+export function validateProviderConfig(config) {
+  const errors = [];
+
+  if (!config.name) {
+    errors.push('name is required');
+  }
+
+  if (!config.type) {
+    errors.push('type is required');
+  } else if (config.type !== ProviderType.CLI && config.type !== ProviderType.API) {
+    errors.push('invalid type: ' + config.type);
+  }
+
+  if (config.type === ProviderType.CLI && !config.command) {
+    errors.push('command is required for CLI providers');
+  }
+
+  if (config.type === ProviderType.API && !config.baseUrl) {
+    errors.push('baseUrl is required for API providers');
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Create a provider instance
+ */
+export function createProvider(config) {
+  const validation = validateProviderConfig(config);
+  if (!validation.valid) {
+    throw new Error('Invalid provider config: ' + validation.errors.join(', '));
+  }
+
+  const provider = {
+    name: config.name,
+    type: config.type,
+    capabilities: config.capabilities || [],
+    config,
+    _execute: null,
+
+    async run(prompt, options = {}) {
+      if (this._execute) {
+        return this._execute(prompt, options);
+      }
+      if (this.type === ProviderType.CLI) {
+        return this._runCLI(prompt, options);
+      } else {
+        return this._runAPI(prompt, options);
+      }
+    },
+
+    async _runCLI(prompt, options) {
+      return {
+        raw: '',
+        parsed: null,
+        exitCode: 0,
+        tokenUsage: { input: 0, output: 0 },
+        cost: 0,
+      };
+    },
+
+    async _runAPI(prompt, options) {
+      return {
+        raw: '',
+        parsed: null,
+        exitCode: 0,
+        tokenUsage: { input: 0, output: 0 },
+        cost: 0,
+      };
+    },
+
+    calculateCost(tokenUsage) {
+      const pricing = config.pricing || { inputPer1k: 0, outputPer1k: 0 };
+      const inputCost = (tokenUsage.input / 1000) * pricing.inputPer1k;
+      const outputCost = (tokenUsage.output / 1000) * pricing.outputPer1k;
+      return inputCost + outputCost;
+    },
+  };
+
+  return provider;
+}
+
+export default { createProvider, validateProviderConfig, ProviderType };