tlc-claude-code 1.2.27 → 1.2.28

package/server/lib/adapters/claude-adapter.js

@@ -0,0 +1,141 @@
+/**
+ * Claude Adapter - Adapter for Claude API
+ * Note: In TLC context, Claude is subscription-based so no per-request cost
+ */
+
+const { BaseAdapter } = require('./base-adapter.js');
+
+// Latest model: claude-opus-4-5-20251101 (Claude Opus 4.5)
+const CLAUDE_MODEL = 'claude-opus-4-5-20251101';
+
+const CLAUDE_PRICING = {
+  // Pricing per 1M tokens (Claude Opus 4.5)
+  inputPerMillion: 15.00,
+  outputPerMillion: 75.00,
+};
+
+class ClaudeAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({
+      name: 'claude',
+      ...config,
+    });
+    this.budgetTracker = config.budgetTracker || null;
+    this.pricing = config.pricing || CLAUDE_PRICING;
+    this.model = config.model || CLAUDE_MODEL;
+    this.trackCost = config.trackCost !== false;
+  }
+
+  /**
+   * Review code for issues and suggestions
+   * @param {string} code - Code to review
+   * @param {Object} context - Additional context
+   * @returns {Promise<Object>} Standardized review response
+   */
+  async review(code, context = {}) {
+    if (!code || code.trim() === '') {
+      return this.createEmptyResponse();
+    }
+
+    // Check budget if tracking
+    const estimatedTokens = this.estimateTokens(code);
+    const estimatedCost = this.estimateCost(estimatedTokens);
+
+    if (this.trackCost && !this.canAfford(estimatedCost)) {
+      throw new Error('Budget exceeded for Claude');
+    }
+
+    try {
+      // Simulate API call - in real implementation, call Claude API
+      const result = await this.callAPI(code, context);
+
+      // Record cost if tracking
+      if (this.trackCost && this.budgetTracker) {
+        this.budgetTracker.record('claude', result.cost || 0);
+      }
+
+      return result;
+    } catch (error) {
+      // Return empty response on error, don't throw
+      return {
+        ...this.createEmptyResponse(),
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Call Claude API (mock implementation)
+   * @param {string} code - Code to review
+   * @param {Object} context - Additional context
+   * @returns {Promise<Object>} API response
+   */
+  async callAPI(code, context) {
+    // This is a mock - in production, call actual Claude API
+    // For now, simulate a response
+    const tokensUsed = this.estimateTokens(code);
+    const cost = this.estimateCost(tokensUsed);
+
+    return {
+      issues: [],
+      suggestions: [],
+      score: 100,
+      model: this.name,
+      tokensUsed,
+      cost,
+    };
+  }
+
+  /**
+   * Estimate tokens for code
+   * @param {string} code - Code to estimate
+   * @returns {number} Estimated tokens
+   */
+  estimateTokens(code) {
+    // Rough estimate: ~4 chars per token for code
+    return Math.ceil(code.length / 4);
+  }
+
+  /**
+   * Estimate cost for tokens
+   * @param {number} tokens - Number of tokens
+   * @returns {number} Estimated cost in USD
+   */
+  estimateCost(tokens) {
+    // Assume 50% input, 50% output for review
+    const inputCost = (tokens * 0.5 * this.pricing.inputPerMillion) / 1_000_000;
+    const outputCost = (tokens * 0.5 * this.pricing.outputPerMillion) / 1_000_000;
+    return inputCost + outputCost;
+  }
+
+  /**
+   * Check if adapter can afford a request
+   * @param {number} estimatedCost - Estimated cost
+   * @returns {boolean} Whether request is within budget
+   */
+  canAfford(estimatedCost = 0) {
+    if (!this.trackCost || !this.budgetTracker) {
+      return true;
+    }
+
+    const budgetConfig = this.config.budget || { budgetDaily: 10, budgetMonthly: 100 };
+    return this.budgetTracker.canSpend('claude', estimatedCost, budgetConfig);
+  }
+
+  /**
+   * Get current usage stats
+   * @returns {Object} Usage stats
+   */
+  getUsage() {
+    if (!this.budgetTracker) {
+      return { daily: 0, monthly: 0, requests: 0 };
+    }
+    return this.budgetTracker.getUsage('claude');
+  }
+}
+
+module.exports = {
+  ClaudeAdapter,
+  CLAUDE_PRICING,
+  CLAUDE_MODEL,
+};

package/server/lib/adapters/claude-adapter.test.js

@@ -0,0 +1,180 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ClaudeAdapter, CLAUDE_PRICING, CLAUDE_MODEL } from './claude-adapter.js';
+import { BaseAdapter } from './base-adapter.js';
+
+describe('ClaudeAdapter', () => {
+  describe('constructor', () => {
+    it('sets name to claude by default', () => {
+      const adapter = new ClaudeAdapter();
+      expect(adapter.name).toBe('claude');
+    });
+
+    it('accepts custom config', () => {
+      const adapter = new ClaudeAdapter({ apiKey: 'test-key' });
+      expect(adapter.config.apiKey).toBe('test-key');
+    });
+
+    it('accepts budget tracker', () => {
+      const mockTracker = { canSpend: vi.fn() };
+      const adapter = new ClaudeAdapter({ budgetTracker: mockTracker });
+      expect(adapter.budgetTracker).toBe(mockTracker);
+    });
+  });
+
+  describe('review', () => {
+    it('returns empty response for empty code', async () => {
+      const adapter = new ClaudeAdapter();
+      const result = await adapter.review('');
+
+      expect(result.issues).toEqual([]);
+      expect(result.score).toBe(100);
+      expect(result.model).toBe('claude');
+    });
+
+    it('returns empty response for whitespace-only code', async () => {
+      const adapter = new ClaudeAdapter();
+      const result = await adapter.review('   \n\t  ');
+
+      expect(result.issues).toEqual([]);
+    });
+
+    it('returns standardized response format', async () => {
+      const adapter = new ClaudeAdapter();
+      const result = await adapter.review('const x = 1;');
+
+      expect(BaseAdapter.validateResponse(result)).toBe(true);
+      expect(result.model).toBe('claude');
+      expect(typeof result.tokensUsed).toBe('number');
+      expect(typeof result.cost).toBe('number');
+    });
+
+    it('checks budget before review', async () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => false),
+        record: vi.fn(),
+        getUsage: vi.fn(() => ({ daily: 10, monthly: 100, requests: 50 })),
+      };
+      const adapter = new ClaudeAdapter({
+        budgetTracker: mockTracker,
+        budget: { budgetDaily: 5, budgetMonthly: 50 },
+      });
+
+      await expect(adapter.review('const x = 1;')).rejects.toThrow('Budget exceeded');
+    });
+
+    it('records cost after successful review', async () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => true),
+        record: vi.fn(),
+        getUsage: vi.fn(() => ({ daily: 0, monthly: 0, requests: 0 })),
+      };
+      const adapter = new ClaudeAdapter({ budgetTracker: mockTracker });
+
+      await adapter.review('const x = 1;');
+
+      expect(mockTracker.record).toHaveBeenCalledWith('claude', expect.any(Number));
+    });
+
+    it('handles API errors gracefully', async () => {
+      const adapter = new ClaudeAdapter();
+      adapter.callAPI = vi.fn().mockRejectedValue(new Error('API timeout'));
+
+      const result = await adapter.review('const x = 1;');
+
+      expect(result.error).toBe('API timeout');
+      expect(result.issues).toEqual([]);
+    });
+  });
+
+  describe('estimateTokens', () => {
+    it('estimates tokens based on code length', () => {
+      const adapter = new ClaudeAdapter();
+
+      // ~4 chars per token
+      expect(adapter.estimateTokens('abcd')).toBe(1);
+      expect(adapter.estimateTokens('abcdefgh')).toBe(2);
+      expect(adapter.estimateTokens('a'.repeat(100))).toBe(25);
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('calculates cost based on token count', () => {
+      const adapter = new ClaudeAdapter();
+      const cost = adapter.estimateCost(1000);
+
+      // At default pricing (Opus 4.5): (500 * 15 + 500 * 75) / 1M = 0.045
+      expect(cost).toBeCloseTo(0.045, 4);
+    });
+
+    it('uses custom pricing if provided', () => {
+      const adapter = new ClaudeAdapter({
+        pricing: { inputPerMillion: 1.00, outputPerMillion: 2.00 },
+      });
+      const cost = adapter.estimateCost(1000);
+
+      // (500 * 1 + 500 * 2) / 1M = 0.0015
+      expect(cost).toBeCloseTo(0.0015, 5);
+    });
+  });
+
+  describe('canAfford', () => {
+    it('returns true without budget tracker', () => {
+      const adapter = new ClaudeAdapter();
+      expect(adapter.canAfford(100)).toBe(true);
+    });
+
+    it('returns true when tracking disabled', () => {
+      const adapter = new ClaudeAdapter({ trackCost: false });
+      expect(adapter.canAfford(100)).toBe(true);
+    });
+
+    it('checks budget tracker when enabled', () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => true),
+      };
+      const adapter = new ClaudeAdapter({
+        budgetTracker: mockTracker,
+        budget: { budgetDaily: 10, budgetMonthly: 100 },
+      });
+
+      adapter.canAfford(0.5);
+
+      expect(mockTracker.canSpend).toHaveBeenCalledWith('claude', 0.5, expect.any(Object));
+    });
+  });
+
+  describe('getUsage', () => {
+    it('returns zero without budget tracker', () => {
+      const adapter = new ClaudeAdapter();
+      const usage = adapter.getUsage();
+
+      expect(usage).toEqual({ daily: 0, monthly: 0, requests: 0 });
+    });
+
+    it('returns tracker usage when available', () => {
+      const mockTracker = {
+        getUsage: vi.fn(() => ({ daily: 2.50, monthly: 25.00, requests: 10 })),
+      };
+      const adapter = new ClaudeAdapter({ budgetTracker: mockTracker });
+
+      const usage = adapter.getUsage();
+
+      expect(usage.daily).toBe(2.50);
+      expect(usage.monthly).toBe(25.00);
+      expect(usage.requests).toBe(10);
+    });
+  });
+
+  describe('CLAUDE_PRICING', () => {
+    it('exports default pricing for Opus 4.5', () => {
+      expect(CLAUDE_PRICING.inputPerMillion).toBe(15.00);
+      expect(CLAUDE_PRICING.outputPerMillion).toBe(75.00);
+    });
+  });
+
+  describe('CLAUDE_MODEL', () => {
+    it('exports latest model identifier', () => {
+      expect(CLAUDE_MODEL).toBe('claude-opus-4-5-20251101');
+    });
+  });
+});

package/server/lib/adapters/deepseek-adapter.js

@@ -0,0 +1,153 @@
+/**
+ * DeepSeek Adapter - Adapter for DeepSeek API (budget-friendly model)
+ */
+
+const { BaseAdapter } = require('./base-adapter.js');
+
+// Latest model: deepseek-r1 (January 2025)
+const DEEPSEEK_MODEL = 'deepseek-r1';
+
+const DEEPSEEK_PRICING = {
+  // Pricing per 1M tokens (DeepSeek R1)
+  // Significantly cheaper than OpenAI
+  inputPerMillion: 0.55,
+  outputPerMillion: 2.19,
+};
+
+class DeepSeekAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super({
+      name: 'deepseek',
+      ...config,
+    });
+    this.budgetTracker = config.budgetTracker || null;
+    this.pricing = config.pricing || DEEPSEEK_PRICING;
+    this.model = config.model || DEEPSEEK_MODEL;
+  }
+
+  /**
+   * Review code for issues and suggestions
+   * @param {string} code - Code to review
+   * @param {Object} context - Additional context
+   * @returns {Promise<Object>} Standardized review response
+   */
+  async review(code, context = {}) {
+    if (!code || code.trim() === '') {
+      return this.createEmptyResponse();
+    }
+
+    const estimatedTokens = this.estimateTokens(code);
+    const estimatedCost = this.estimateCost(estimatedTokens);
+
+    if (!this.canAfford(estimatedCost)) {
+      throw new Error('Budget exceeded for DeepSeek');
+    }
+
+    try {
+      const result = await this.callAPI(code, context);
+
+      if (this.budgetTracker) {
+        this.budgetTracker.record('deepseek', result.cost || 0);
+      }
+
+      return result;
+    } catch (error) {
+      // DeepSeek errors return empty response with warning
+      return {
+        ...this.createEmptyResponse(),
+        warning: `DeepSeek unavailable: ${error.message}`,
+      };
+    }
+  }
+
+  /**
+   * Call DeepSeek API (mock implementation)
+   * @param {string} code - Code to review
+   * @param {Object} context - Additional context
+   * @returns {Promise<Object>} API response
+   */
+  async callAPI(code, context) {
+    const tokensUsed = this.estimateTokens(code);
+    const cost = this.estimateCost(tokensUsed);
+
+    return {
+      issues: [],
+      suggestions: [],
+      score: 100,
+      model: this.name,
+      tokensUsed,
+      cost,
+    };
+  }
+
+  /**
+   * Estimate tokens for code
+   * @param {string} code - Code to estimate
+   * @returns {number} Estimated tokens
+   */
+  estimateTokens(code) {
+    return Math.ceil(code.length / 4);
+  }
+
+  /**
+   * Estimate cost for tokens
+   * @param {number} tokens - Number of tokens
+   * @returns {number} Estimated cost in USD
+   */
+  estimateCost(tokens) {
+    const inputCost = (tokens * 0.5 * this.pricing.inputPerMillion) / 1_000_000;
+    const outputCost = (tokens * 0.5 * this.pricing.outputPerMillion) / 1_000_000;
+    return inputCost + outputCost;
+  }
+
+  /**
+   * Check if adapter can afford a request
+   * @param {number} estimatedCost - Estimated cost
+   * @returns {boolean}
+   */
+  canAfford(estimatedCost = 0) {
+    if (!this.budgetTracker) {
+      return true;
+    }
+
+    const budgetConfig = this.config.budget || { budgetDaily: 5, budgetMonthly: 50 };
+    return this.budgetTracker.canSpend('deepseek', estimatedCost, budgetConfig);
+  }
+
+  /**
+   * Get current usage stats
+   * @returns {Object} Usage stats
+   */
+  getUsage() {
+    if (!this.budgetTracker) {
+      return { daily: 0, monthly: 0, requests: 0 };
+    }
+    return this.budgetTracker.getUsage('deepseek');
+  }
+
+  /**
+   * Compare cost with OpenAI equivalent
+   * @param {number} tokens - Token count
+   * @returns {Object} Cost comparison
+   */
+  compareCostWithOpenAI(tokens) {
+    const deepseekCost = this.estimateCost(tokens);
+    // OpenAI GPT-4 Turbo pricing
+    const openaiCost = (tokens * 0.5 * 10.00 + tokens * 0.5 * 30.00) / 1_000_000;
+    const savings = openaiCost - deepseekCost;
+    const savingsPercent = (savings / openaiCost) * 100;
+
+    return {
+      deepseek: deepseekCost,
+      openai: openaiCost,
+      savings,
+      savingsPercent,
+    };
+  }
+}
+
+module.exports = {
+  DeepSeekAdapter,
+  DEEPSEEK_PRICING,
+  DEEPSEEK_MODEL,
+};

package/server/lib/adapters/deepseek-adapter.test.js

@@ -0,0 +1,193 @@
+import { describe, it, expect, vi } from 'vitest';
+import { DeepSeekAdapter, DEEPSEEK_PRICING, DEEPSEEK_MODEL } from './deepseek-adapter.js';
+import { BaseAdapter } from './base-adapter.js';
+
+describe('DeepSeekAdapter', () => {
+  describe('constructor', () => {
+    it('sets name to deepseek by default', () => {
+      const adapter = new DeepSeekAdapter();
+      expect(adapter.name).toBe('deepseek');
+    });
+
+    it('uses default pricing', () => {
+      const adapter = new DeepSeekAdapter();
+      expect(adapter.pricing).toBe(DEEPSEEK_PRICING);
+    });
+
+    it('accepts custom pricing', () => {
+      const customPricing = { inputPerMillion: 0.20, outputPerMillion: 0.40 };
+      const adapter = new DeepSeekAdapter({ pricing: customPricing });
+      expect(adapter.pricing).toBe(customPricing);
+    });
+  });
+
+  describe('review', () => {
+    it('returns empty response for empty code', async () => {
+      const adapter = new DeepSeekAdapter();
+      const result = await adapter.review('');
+
+      expect(result.issues).toEqual([]);
+      expect(result.model).toBe('deepseek');
+    });
+
+    it('returns standardized response format', async () => {
+      const adapter = new DeepSeekAdapter();
+      const result = await adapter.review('const x = 1;');
+
+      expect(BaseAdapter.validateResponse(result)).toBe(true);
+      expect(result.model).toBe('deepseek');
+    });
+
+    it('throws when budget exceeded', async () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => false),
+        record: vi.fn(),
+        getUsage: vi.fn(() => ({ daily: 5, monthly: 50, requests: 100 })),
+      };
+      const adapter = new DeepSeekAdapter({ budgetTracker: mockTracker });
+
+      await expect(adapter.review('const x = 1;')).rejects.toThrow('Budget exceeded');
+    });
+
+    it('records cost after successful review', async () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => true),
+        record: vi.fn(),
+        getUsage: vi.fn(() => ({ daily: 0, monthly: 0, requests: 0 })),
+      };
+      const adapter = new DeepSeekAdapter({ budgetTracker: mockTracker });
+
+      await adapter.review('const x = 1;');
+
+      expect(mockTracker.record).toHaveBeenCalledWith('deepseek', expect.any(Number));
+    });
+
+    it('handles API errors with warning instead of error', async () => {
+      const adapter = new DeepSeekAdapter();
+      adapter.callAPI = vi.fn().mockRejectedValue(new Error('Connection failed'));
+
+      const result = await adapter.review('const x = 1;');
+
+      expect(result.warning).toBe('DeepSeek unavailable: Connection failed');
+      expect(result.issues).toEqual([]);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('calculates cost based on token count', () => {
+      const adapter = new DeepSeekAdapter();
+      const cost = adapter.estimateCost(1000);
+
+      // At default pricing (R1): (500 * 0.55 + 500 * 2.19) / 1M = 0.00137
+      expect(cost).toBeCloseTo(0.00137, 5);
+    });
+
+    it('is much cheaper than OpenAI', () => {
+      const adapter = new DeepSeekAdapter();
+      const comparison = adapter.compareCostWithOpenAI(1000);
+
+      expect(comparison.deepseek).toBeLessThan(comparison.openai);
+      expect(comparison.savingsPercent).toBeGreaterThan(90); // >90% savings
+    });
+  });
+
+  describe('compareCostWithOpenAI', () => {
+    it('returns detailed cost comparison', () => {
+      const adapter = new DeepSeekAdapter();
+      const comparison = adapter.compareCostWithOpenAI(10000);
+
+      expect(comparison).toHaveProperty('deepseek');
+      expect(comparison).toHaveProperty('openai');
+      expect(comparison).toHaveProperty('savings');
+      expect(comparison).toHaveProperty('savingsPercent');
+    });
+
+    it('calculates savings correctly', () => {
+      const adapter = new DeepSeekAdapter();
+      const comparison = adapter.compareCostWithOpenAI(1000000);
+
+      // For 1M tokens:
+      // DeepSeek R1: (500k * 0.55 + 500k * 2.19) / 1M = 1.37
+      // OpenAI (comparison uses hardcoded $10/$30): (500k * 10 + 500k * 30) / 1M = 20
+      expect(comparison.deepseek).toBeCloseTo(1.37, 2);
+      expect(comparison.openai).toBeCloseTo(20, 2);
+      expect(comparison.savings).toBeCloseTo(18.63, 2);
+    });
+  });
+
+  describe('canAfford', () => {
+    it('returns true without budget tracker', () => {
+      const adapter = new DeepSeekAdapter();
+      expect(adapter.canAfford(100)).toBe(true);
+    });
+
+    it('checks budget tracker when available', () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => true),
+      };
+      const adapter = new DeepSeekAdapter({
+        budgetTracker: mockTracker,
+        budget: { budgetDaily: 5, budgetMonthly: 50 },
+      });
+
+      adapter.canAfford(0.01);
+
+      expect(mockTracker.canSpend).toHaveBeenCalledWith('deepseek', 0.01, expect.any(Object));
+    });
+
+    it('uses lower default budget than OpenAI', () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => true),
+      };
+      const adapter = new DeepSeekAdapter({ budgetTracker: mockTracker });
+
+      adapter.canAfford(0.01);
+
+      // Default budget is 5 daily, 50 monthly (lower than typical OpenAI)
+      expect(mockTracker.canSpend).toHaveBeenCalledWith(
+        'deepseek',
+        0.01,
+        expect.objectContaining({ budgetDaily: 5, budgetMonthly: 50 })
+      );
+    });
+  });
+
+  describe('getUsage', () => {
+    it('returns zero without budget tracker', () => {
+      const adapter = new DeepSeekAdapter();
+      expect(adapter.getUsage()).toEqual({ daily: 0, monthly: 0, requests: 0 });
+    });
+
+    it('returns tracker usage when available', () => {
+      const mockTracker = {
+        getUsage: vi.fn(() => ({ daily: 0.50, monthly: 5.00, requests: 100 })),
+      };
+      const adapter = new DeepSeekAdapter({ budgetTracker: mockTracker });
+
+      const usage = adapter.getUsage();
+
+      expect(usage.daily).toBe(0.50);
+      expect(usage.requests).toBe(100);
+    });
+  });
+
+  describe('DEEPSEEK_PRICING', () => {
+    it('exports pricing constants for R1', () => {
+      expect(DEEPSEEK_PRICING.inputPerMillion).toBe(0.55);
+      expect(DEEPSEEK_PRICING.outputPerMillion).toBe(2.19);
+    });
+
+    it('is significantly cheaper than OpenAI', () => {
+      // OpenAI o3: $10/1M input, $40/1M output
+      expect(DEEPSEEK_PRICING.inputPerMillion).toBeLessThan(10);
+      expect(DEEPSEEK_PRICING.outputPerMillion).toBeLessThan(40);
+    });
+  });
+
+  describe('DEEPSEEK_MODEL', () => {
+    it('exports latest model identifier', () => {
+      expect(DEEPSEEK_MODEL).toBe('deepseek-r1');
+    });
+  });
+});