tlc-claude-code 1.4.1 → 1.4.4

package/server/lib/model-router.test.js

@@ -0,0 +1,313 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  createRouter,
+  resolveProvider,
+  resolveCapability,
+  loadConfig,
+  DEFAULT_CONFIG,
+} from './model-router.js';
+
+// Mock dependencies
+vi.mock('./cli-detector.js', () => ({
+  detectAllCLIs: vi.fn(),
+  clearCache: vi.fn(),
+}));
+
+vi.mock('fs/promises', () => ({
+  default: {
+    readFile: vi.fn(),
+  },
+}));
+
+import { detectAllCLIs } from './cli-detector.js';
+import fs from 'fs/promises';
+
+describe('model-router', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createRouter', () => {
+    it('creates router with default config', async () => {
+      detectAllCLIs.mockResolvedValue(new Map());
+
+      const router = await createRouter();
+
+      expect(router).toBeDefined();
+      expect(router.resolveProvider).toBeDefined();
+      expect(router.resolveCapability).toBeDefined();
+    });
+
+    it('creates router with custom config', async () => {
+      detectAllCLIs.mockResolvedValue(new Map());
+
+      const config = {
+        providers: {
+          claude: { type: 'cli', command: 'claude' },
+        },
+        capabilities: {
+          review: { providers: ['claude'] },
+        },
+      };
+
+      const router = await createRouter(config);
+
+      expect(router).toBeDefined();
+    });
+
+    it('detects local CLIs on creation', async () => {
+      detectAllCLIs.mockResolvedValue(new Map([
+        ['claude', { name: 'claude', version: 'v4.0.0' }],
+      ]));
+
+      await createRouter();
+
+      expect(detectAllCLIs).toHaveBeenCalled();
+    });
+  });
+
+  describe('resolveProvider', () => {
+    it('returns local when CLI detected', async () => {
+      detectAllCLIs.mockResolvedValue(new Map([
+        ['claude', { name: 'claude', version: 'v4.0.0', detected: true }],
+      ]));
+
+      const router = await createRouter({
+        providers: {
+          claude: { type: 'cli', command: 'claude', capabilities: ['review'] },
+        },
+      });
+
+      const result = router.resolveProvider('claude');
+
+      expect(result.via).toBe('local');
+      expect(result.provider.name).toBe('claude');
+    });
+
+    it('returns devserver when CLI not detected', async () => {
+      detectAllCLIs.mockResolvedValue(new Map()); // No CLIs detected
+
+      const router = await createRouter({
+        providers: {
+          claude: { type: 'cli', command: 'claude', capabilities: ['review'] },
+        },
+        devserver: { url: 'https://devserver.example.com' },
+      });
+
+      const result = router.resolveProvider('claude');
+
+      expect(result.via).toBe('devserver');
+    });
+
+    it('returns devserver for API type', async () => {
+      detectAllCLIs.mockResolvedValue(new Map());
+
+      const router = await createRouter({
+        providers: {
+          deepseek: {
+            type: 'api',
+            baseUrl: 'https://api.deepseek.com',
+            capabilities: ['review'],
+          },
+        },
+      });
+
+      const result = router.resolveProvider('deepseek');
+
+      expect(result.via).toBe('devserver');
+    });
+
+    it('returns null for unknown provider', async () => {
+      detectAllCLIs.mockResolvedValue(new Map());
+
+      const router = await createRouter();
+
+      const result = router.resolveProvider('unknown');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('resolveCapability', () => {
+    it('returns ordered providers for capability', async () => {
+      detectAllCLIs.mockResolvedValue(new Map([
+        ['claude', { name: 'claude' }],
+      ]));
+
+      const router = await createRouter({
+        providers: {
+          claude: { type: 'cli', command: 'claude', capabilities: ['review'] },
+          deepseek: { type: 'api', baseUrl: 'https://api.deepseek.com', capabilities: ['review'] },
+        },
+        capabilities: {
+          review: { providers: ['claude', 'deepseek'] },
+        },
+      });
+
+      const providers = router.resolveCapability('review');
+
+      expect(providers.length).toBe(2);
+      expect(providers[0].name).toBe('claude');
+      expect(providers[1].name).toBe('deepseek');
+    });
+
+    it('filters by capability', async () => {
+      detectAllCLIs.mockResolvedValue(new Map());
+
+      const router = await createRouter({
+        providers: {
+          claude: { type: 'cli', command: 'claude', capabilities: ['review', 'code-gen'] },
+          gemini: { type: 'cli', command: 'gemini', capabilities: ['design'] },
+        },
+        capabilities: {
+          review: { providers: ['claude'] },
+          design: { providers: ['gemini'] },
+        },
+      });
+
+      const reviewProviders = router.resolveCapability('review');
+      const designProviders = router.resolveCapability('design');
+
+      expect(reviewProviders.length).toBe(1);
+      expect(reviewProviders[0].name).toBe('claude');
+
+      expect(designProviders.length).toBe(1);
+      expect(designProviders[0].name).toBe('gemini');
+    });
+
+    it('returns empty array for unknown capability', async () => {
+      detectAllCLIs.mockResolvedValue(new Map());
+
+      const router = await createRouter();
+
+      const providers = router.resolveCapability('unknown');
+
+      expect(providers).toEqual([]);
+    });
+  });
+
+  describe('cascade behavior', () => {
+    it('tries local first', async () => {
+      detectAllCLIs.mockResolvedValue(new Map([
+        ['claude', { name: 'claude', detected: true }],
+      ]));
+
+      const router = await createRouter({
+        providers: {
+          claude: { type: 'cli', command: 'claude', capabilities: ['review'] },
+        },
+        devserver: { url: 'https://devserver.example.com' },
+      });
+
+      const result = router.resolveProvider('claude');
+
+      expect(result.via).toBe('local');
+    });
+
+    it('falls back to devserver when local unavailable', async () => {
+      detectAllCLIs.mockResolvedValue(new Map()); // No CLIs detected
+
+      const router = await createRouter({
+        providers: {
+          claude: { type: 'cli', command: 'claude', capabilities: ['review'] },
+        },
+        devserver: { url: 'https://devserver.example.com' },
+      });
+
+      const result = router.resolveProvider('claude');
+
+      expect(result.via).toBe('devserver');
+    });
+  });
+
+  describe('loadConfig', () => {
+    it('reads from .tlc.json', async () => {
+      const config = {
+        router: {
+          providers: { claude: { type: 'cli', command: 'claude' } },
+        },
+      };
+
+      fs.readFile.mockResolvedValue(JSON.stringify(config));
+
+      const loaded = await loadConfig('/project');
+
+      expect(fs.readFile).toHaveBeenCalledWith('/project/.tlc.json', 'utf8');
+      expect(loaded.providers.claude).toBeDefined();
+    });
+
+    it('uses defaults when file missing', async () => {
+      fs.readFile.mockRejectedValue(new Error('ENOENT'));
+
+      const loaded = await loadConfig('/project');
+
+      expect(loaded).toEqual(DEFAULT_CONFIG);
+    });
+
+    it('merges with defaults', async () => {
+      const config = {
+        router: {
+          providers: { custom: { type: 'api', baseUrl: 'https://example.com' } },
+        },
+      };
+
+      fs.readFile.mockResolvedValue(JSON.stringify(config));
+
+      const loaded = await loadConfig('/project');
+
+      // Should have custom provider
+      expect(loaded.providers.custom).toBeDefined();
+      // Should still have defaults
+      expect(loaded.providers.claude).toBeDefined();
+    });
+  });
+
+  describe('DEFAULT_CONFIG', () => {
+    it('includes claude provider', () => {
+      expect(DEFAULT_CONFIG.providers.claude).toBeDefined();
+      expect(DEFAULT_CONFIG.providers.claude.type).toBe('cli');
+    });
+
+    it('includes codex provider', () => {
+      expect(DEFAULT_CONFIG.providers.codex).toBeDefined();
+      expect(DEFAULT_CONFIG.providers.codex.type).toBe('cli');
+    });
+
+    it('includes gemini provider', () => {
+      expect(DEFAULT_CONFIG.providers.gemini).toBeDefined();
+      expect(DEFAULT_CONFIG.providers.gemini.type).toBe('cli');
+    });
+
+    it('includes deepseek provider', () => {
+      expect(DEFAULT_CONFIG.providers.deepseek).toBeDefined();
+      expect(DEFAULT_CONFIG.providers.deepseek.type).toBe('api');
+    });
+
+    it('includes review capability', () => {
+      expect(DEFAULT_CONFIG.capabilities.review).toBeDefined();
+      expect(DEFAULT_CONFIG.capabilities.review.providers).toContain('claude');
+    });
+  });
+
+  describe('handleUnavailable', () => {
+    it('skips unavailable providers', async () => {
+      detectAllCLIs.mockResolvedValue(new Map()); // No local CLIs
+
+      const router = await createRouter({
+        providers: {
+          claude: { type: 'cli', command: 'claude', capabilities: ['review'] },
+          deepseek: { type: 'api', baseUrl: 'https://api.deepseek.com', capabilities: ['review'] },
+        },
+        capabilities: {
+          review: { providers: ['claude', 'deepseek'] },
+        },
+        devserver: { url: 'https://devserver.example.com' },
+      });
+
+      const providers = router.resolveCapability('review');
+
+      // Both should be available (claude via devserver, deepseek via api)
+      expect(providers.length).toBe(2);
+    });
+  });
+});

package/server/lib/output-schemas.js

@@ -0,0 +1,269 @@
+/**
+ * Output Schemas - Standard JSON schemas for provider outputs
+ *
+ * Ensures consistent output format across all providers.
+ */
+
+import fs from 'fs/promises';
+
+/**
+ * Built-in schemas for common operations
+ */
+export const BUILTIN_SCHEMAS = {
+  'review-result': {
+    type: 'object',
+    properties: {
+      summary: { type: 'string', description: 'Brief summary of the review' },
+      issues: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            severity: {
+              type: 'string',
+              enum: ['critical', 'moderate', 'suggestion'],
+              description: 'Issue severity level',
+            },
+            file: { type: 'string', description: 'File path' },
+            line: { type: 'integer', description: 'Line number' },
+            title: { type: 'string', description: 'Issue title' },
+            description: { type: 'string', description: 'Detailed description' },
+            suggestion: { type: 'string', description: 'Suggested fix' },
+          },
+          required: ['severity', 'file', 'title', 'description'],
+        },
+      },
+      score: {
+        type: 'integer',
+        minimum: 0,
+        maximum: 100,
+        description: 'Overall code quality score',
+      },
+      approved: { type: 'boolean', description: 'Whether the code is approved' },
+    },
+    required: ['summary', 'issues', 'score', 'approved'],
+  },
+
+  'design-result': {
+    type: 'object',
+    properties: {
+      mockups: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Mockup name' },
+            description: { type: 'string', description: 'Mockup description' },
+            imageUrl: { type: 'string', description: 'Generated image URL' },
+            components: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'UI components used',
+            },
+          },
+          required: ['name', 'description'],
+        },
+      },
+      rationale: { type: 'string', description: 'Design rationale' },
+      alternatives: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            description: { type: 'string' },
+            tradeoffs: { type: 'string' },
+          },
+        },
+        description: 'Alternative design approaches',
+      },
+    },
+    required: ['mockups', 'rationale'],
+  },
+
+  'code-result': {
+    type: 'object',
+    properties: {
+      files: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            path: { type: 'string', description: 'File path' },
+            content: { type: 'string', description: 'File content' },
+            action: {
+              type: 'string',
+              enum: ['create', 'modify', 'delete'],
+              description: 'Action to take',
+            },
+          },
+          required: ['path', 'content', 'action'],
+        },
+      },
+      explanation: { type: 'string', description: 'Explanation of changes' },
+      tests: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            description: { type: 'string' },
+          },
+        },
+        description: 'Suggested tests',
+      },
+    },
+    required: ['files', 'explanation'],
+  },
+};
+
+/**
+ * Load a schema from file
+ * @param {string} filePath - Path to schema file
+ * @returns {Promise<Object>} Parsed schema
+ */
+export async function loadSchema(filePath) {
+  const content = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(content);
+}
+
+/**
+ * Validate output against a schema
+ * @param {any} data - Data to validate
+ * @param {Object} schema - JSON schema
+ * @returns {Object} Validation result { valid, errors }
+ */
+export function validateOutput(data, schema) {
+  const errors = [];
+
+  function validate(value, schemaNode, path = '') {
+    if (!schemaNode) return;
+
+    // Type validation
+    if (schemaNode.type) {
+      const actualType = Array.isArray(value) ? 'array' : typeof value;
+      const expectedType = schemaNode.type;
+
+      // Handle integer as number
+      if (expectedType === 'integer') {
+        if (typeof value !== 'number' || !Number.isInteger(value)) {
+          errors.push(`${path}: expected integer, got ${actualType}`);
+          return;
+        }
+      } else if (expectedType !== actualType) {
+        errors.push(`${path}: expected ${expectedType}, got ${actualType}`);
+        return;
+      }
+    }
+
+    // Enum validation
+    if (schemaNode.enum && !schemaNode.enum.includes(value)) {
+      errors.push(`${path}: value must be one of: ${schemaNode.enum.join(', ')}`);
+    }
+
+    // Number constraints
+    if (typeof value === 'number') {
+      if (schemaNode.minimum !== undefined && value < schemaNode.minimum) {
+        errors.push(`${path}: value must be >= ${schemaNode.minimum}`);
+      }
+      if (schemaNode.maximum !== undefined && value > schemaNode.maximum) {
+        errors.push(`${path}: value must be <= ${schemaNode.maximum}`);
+      }
+    }
+
+    // Object validation
+    if (schemaNode.type === 'object' && typeof value === 'object' && value !== null) {
+      // Required fields
+      if (schemaNode.required) {
+        for (const field of schemaNode.required) {
+          if (!(field in value)) {
+            errors.push(`${path}.${field}: required field missing`);
+          }
+        }
+      }
+
+      // Validate properties
+      if (schemaNode.properties) {
+        for (const [key, propSchema] of Object.entries(schemaNode.properties)) {
+          if (key in value) {
+            validate(value[key], propSchema, `${path}.${key}`);
+          }
+        }
+      }
+    }
+
+    // Array validation
+    if (schemaNode.type === 'array' && Array.isArray(value)) {
+      if (schemaNode.items) {
+        value.forEach((item, index) => {
+          validate(item, schemaNode.items, `${path}[${index}]`);
+        });
+      }
+    }
+  }
+
+  validate(data, schema, 'root');
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Convert schema to human-readable prompt instructions
+ * @param {Object} schema - JSON schema
+ * @returns {string} Text instructions
+ */
+export function schemaToPromptInstructions(schema) {
+  const lines = ['Your response must be valid JSON matching this structure:'];
+
+  function describeSchema(node, indent = 0) {
+    const prefix = '  '.repeat(indent);
+
+    if (node.type === 'object' && node.properties) {
+      lines.push(`${prefix}{`);
+
+      for (const [key, prop] of Object.entries(node.properties)) {
+        const required = node.required?.includes(key) ? ' (required)' : '';
+        const type = prop.type || 'any';
+
+        if (prop.enum) {
+          lines.push(`${prefix}  "${key}": one of [${prop.enum.join(', ')}]${required}`);
+        } else if (type === 'object' && prop.properties) {
+          lines.push(`${prefix}  "${key}": {${required}`);
+          describeSchema(prop, indent + 2);
+          lines.push(`${prefix}  }`);
+        } else if (type === 'array') {
+          lines.push(`${prefix}  "${key}": array of ${prop.items?.type || 'items'}${required}`);
+        } else {
+          lines.push(`${prefix}  "${key}": ${type}${required}`);
+        }
+      }
+
+      lines.push(`${prefix}}`);
+    }
+  }
+
+  describeSchema(schema);
+
+  return lines.join('\n');
+}
+
+/**
+ * Build a prompt that includes schema instructions
+ * @param {string} prompt - Original prompt
+ * @param {Object} schema - JSON schema
+ * @returns {string} Enhanced prompt
+ */
+export function buildPromptWithSchema(prompt, schema) {
+  if (!schema) return prompt;
+
+  const instructions = schemaToPromptInstructions(schema);
+
+  return `${prompt}
+
+${instructions}
+
+Respond ONLY with valid JSON matching the above structure.`;
+}