tlc-claude-code 1.2.26 → 1.2.28

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

@@ -0,0 +1,231 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OpenAIAdapter, OPENAI_PRICING, OPENAI_MODEL, DEFAULT_RATE_LIMITS } from './openai-adapter.js';
+import { BaseAdapter } from './base-adapter.js';
+
+describe('OpenAIAdapter', () => {
+  describe('constructor', () => {
+    it('sets name to openai by default', () => {
+      const adapter = new OpenAIAdapter();
+      expect(adapter.name).toBe('openai');
+    });
+
+    it('initializes rate limit counters', () => {
+      const adapter = new OpenAIAdapter();
+      expect(adapter.requestsThisMinute).toBe(0);
+      expect(adapter.tokensThisMinute).toBe(0);
+    });
+
+    it('accepts custom rate limits', () => {
+      const adapter = new OpenAIAdapter({
+        rateLimits: { requestsPerMinute: 100, tokensPerMinute: 50000 },
+      });
+      expect(adapter.rateLimits.requestsPerMinute).toBe(100);
+      expect(adapter.rateLimits.tokensPerMinute).toBe(50000);
+    });
+  });
+
+  describe('review', () => {
+    it('returns empty response for empty code', async () => {
+      const adapter = new OpenAIAdapter();
+      const result = await adapter.review('');
+
+      expect(result.issues).toEqual([]);
+      expect(result.model).toBe('openai');
+    });
+
+    it('returns standardized response format', async () => {
+      const adapter = new OpenAIAdapter();
+      const result = await adapter.review('const x = 1;');
+
+      expect(BaseAdapter.validateResponse(result)).toBe(true);
+      expect(result.model).toBe('openai');
+    });
+
+    it('throws when budget exceeded', async () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => false),
+        record: vi.fn(),
+        getUsage: vi.fn(() => ({ daily: 10, monthly: 100, requests: 50 })),
+      };
+      const adapter = new OpenAIAdapter({ budgetTracker: mockTracker });
+
+      await expect(adapter.review('const x = 1;')).rejects.toThrow('Budget exceeded');
+    });
+
+    it('throws when rate limit exceeded', async () => {
+      const adapter = new OpenAIAdapter({
+        rateLimits: { requestsPerMinute: 1, tokensPerMinute: 10 },
+      });
+
+      // First request succeeds
+      await adapter.review('const x = 1;');
+
+      // Second request exceeds rate limit
+      await expect(adapter.review('const y = 2;')).rejects.toThrow('Rate limit 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 OpenAIAdapter({ budgetTracker: mockTracker });
+
+      await adapter.review('const x = 1;');
+
+      expect(mockTracker.record).toHaveBeenCalledWith('openai', expect.any(Number));
+    });
+
+    it('increments rate limit counters', async () => {
+      const adapter = new OpenAIAdapter();
+
+      await adapter.review('const x = 1;');
+
+      expect(adapter.requestsThisMinute).toBe(1);
+      expect(adapter.tokensThisMinute).toBeGreaterThan(0);
+    });
+
+    it('handles API errors gracefully', async () => {
+      const adapter = new OpenAIAdapter();
+      adapter.callAPI = vi.fn().mockRejectedValue(new Error('API error'));
+
+      const result = await adapter.review('const x = 1;');
+
+      expect(result.error).toBe('API error');
+      expect(result.issues).toEqual([]);
+    });
+  });
+
+  describe('rate limiting', () => {
+    it('resets counters after minute window', () => {
+      const adapter = new OpenAIAdapter();
+      adapter.requestsThisMinute = 100;
+      adapter.tokensThisMinute = 50000;
+      adapter.lastMinuteReset = Date.now() - 61000; // 61 seconds ago
+
+      adapter.checkRateLimitReset();
+
+      expect(adapter.requestsThisMinute).toBe(0);
+      expect(adapter.tokensThisMinute).toBe(0);
+    });
+
+    it('does not reset within minute window', () => {
+      const adapter = new OpenAIAdapter();
+      adapter.requestsThisMinute = 100;
+      adapter.lastMinuteReset = Date.now() - 30000; // 30 seconds ago
+
+      adapter.checkRateLimitReset();
+
+      expect(adapter.requestsThisMinute).toBe(100);
+    });
+
+    it('withinRateLimits checks both requests and tokens', () => {
+      const adapter = new OpenAIAdapter({
+        rateLimits: { requestsPerMinute: 10, tokensPerMinute: 1000 },
+      });
+
+      // Within limits
+      expect(adapter.withinRateLimits(500)).toBe(true);
+
+      // Exceed token limit
+      expect(adapter.withinRateLimits(1500)).toBe(false);
+
+      // Exceed request limit
+      adapter.requestsThisMinute = 10;
+      expect(adapter.withinRateLimits(100)).toBe(false);
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('calculates cost based on token count', () => {
+      const adapter = new OpenAIAdapter();
+      const cost = adapter.estimateCost(1000);
+
+      // At default pricing (o3): (500 * 10 + 500 * 40) / 1M = 0.025
+      expect(cost).toBeCloseTo(0.025, 4);
+    });
+
+    it('uses custom pricing if provided', () => {
+      const adapter = new OpenAIAdapter({
+        pricing: { inputPerMillion: 5.00, outputPerMillion: 15.00 },
+      });
+      const cost = adapter.estimateCost(1000);
+
+      // (500 * 5 + 500 * 15) / 1M = 0.01
+      expect(cost).toBeCloseTo(0.01, 4);
+    });
+  });
+
+  describe('canAfford', () => {
+    it('returns true without budget tracker', () => {
+      const adapter = new OpenAIAdapter();
+      expect(adapter.canAfford(100)).toBe(true);
+    });
+
+    it('checks budget tracker when available', () => {
+      const mockTracker = {
+        canSpend: vi.fn(() => true),
+      };
+      const adapter = new OpenAIAdapter({
+        budgetTracker: mockTracker,
+        budget: { budgetDaily: 10, budgetMonthly: 100 },
+      });
+
+      adapter.canAfford(0.5);
+
+      expect(mockTracker.canSpend).toHaveBeenCalledWith('openai', 0.5, expect.any(Object));
+    });
+  });
+
+  describe('getUsage', () => {
+    it('returns zero without budget tracker', () => {
+      const adapter = new OpenAIAdapter();
+      expect(adapter.getUsage()).toEqual({ daily: 0, monthly: 0, requests: 0 });
+    });
+
+    it('returns tracker usage when available', () => {
+      const mockTracker = {
+        getUsage: vi.fn(() => ({ daily: 5.00, monthly: 50.00, requests: 25 })),
+      };
+      const adapter = new OpenAIAdapter({ budgetTracker: mockTracker });
+
+      const usage = adapter.getUsage();
+
+      expect(usage.daily).toBe(5.00);
+      expect(usage.requests).toBe(25);
+    });
+  });
+
+  describe('getRateLimitStatus', () => {
+    it('returns current rate limit status', () => {
+      const adapter = new OpenAIAdapter();
+      adapter.requestsThisMinute = 5;
+      adapter.tokensThisMinute = 1000;
+
+      const status = adapter.getRateLimitStatus();
+
+      expect(status.requestsUsed).toBe(5);
+      expect(status.requestsLimit).toBe(DEFAULT_RATE_LIMITS.requestsPerMinute);
+      expect(status.tokensUsed).toBe(1000);
+      expect(status.tokensLimit).toBe(DEFAULT_RATE_LIMITS.tokensPerMinute);
+      expect(typeof status.resetsIn).toBe('number');
+    });
+  });
+
+  describe('exports', () => {
+    it('exports OPENAI_PRICING for o3', () => {
+      expect(OPENAI_PRICING.inputPerMillion).toBe(10.00);
+      expect(OPENAI_PRICING.outputPerMillion).toBe(40.00);
+    });
+
+    it('exports OPENAI_MODEL', () => {
+      expect(OPENAI_MODEL).toBe('o3');
+    });
+
+    it('exports DEFAULT_RATE_LIMITS', () => {
+      expect(DEFAULT_RATE_LIMITS.requestsPerMinute).toBe(500);
+      expect(DEFAULT_RATE_LIMITS.tokensPerMinute).toBe(150000);
+    });
+  });
+});

package/server/lib/budget-tracker.js

@@ -0,0 +1,169 @@
+/**
+ * Budget Tracker - Track and limit API spending across models
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class BudgetTracker {
+  constructor(configPath = '.tlc/usage.json') {
+    this.configPath = configPath;
+    this.usage = {};
+    this.load();
+  }
+
+  /**
+   * Load usage from file
+   */
+  load() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const data = fs.readFileSync(this.configPath, 'utf-8');
+        this.usage = JSON.parse(data);
+      }
+    } catch (err) {
+      console.error('Failed to load usage:', err.message);
+      this.usage = {};
+    }
+
+    // Initialize missing models
+    this.initializeModel('openai');
+    this.initializeModel('deepseek');
+
+    this.checkResets();
+    this.save();
+  }
+
+  /**
+   * Initialize model with default values
+   */
+  initializeModel(model) {
+    if (!this.usage[model]) {
+      this.usage[model] = {
+        daily: 0,
+        monthly: 0,
+        requests: 0,
+        lastDailyReset: new Date().toISOString(),
+        lastMonthlyReset: new Date().toISOString(),
+      };
+    }
+  }
+
+  /**
+   * Save usage to file
+   */
+  save() {
+    try {
+      const dir = path.dirname(this.configPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(this.configPath, JSON.stringify(this.usage, null, 2), 'utf-8');
+    } catch (err) {
+      console.error('Failed to save usage:', err.message);
+    }
+  }
+
+  /**
+   * Check and perform resets if needed
+   */
+  checkResets() {
+    const now = new Date();
+
+    for (const model of Object.keys(this.usage)) {
+      const usage = this.usage[model];
+
+      // Daily reset
+      const lastDaily = new Date(usage.lastDailyReset);
+      if (lastDaily.toDateString() !== now.toDateString()) {
+        usage.daily = 0;
+        usage.lastDailyReset = now.toISOString();
+      }
+
+      // Monthly reset
+      const lastMonthly = new Date(usage.lastMonthlyReset);
+      if (lastMonthly.getMonth() !== now.getMonth() || lastMonthly.getFullYear() !== now.getFullYear()) {
+        usage.monthly = 0;
+        usage.lastMonthlyReset = now.toISOString();
+      }
+    }
+  }
+
+  /**
+   * Check if can spend amount
+   * @param {string} model - Model name
+   * @param {number} amount - Amount in USD
+   * @param {Object} config - Budget config { budgetDaily, budgetMonthly }
+   * @returns {boolean}
+   */
+  canSpend(model, amount, config) {
+    this.initializeModel(model);
+    const usage = this.usage[model];
+
+    const withinDaily = (usage.daily + amount) <= config.budgetDaily;
+    const withinMonthly = (usage.monthly + amount) <= config.budgetMonthly;
+
+    return withinDaily && withinMonthly;
+  }
+
+  /**
+   * Record spending
+   * @param {string} model - Model name
+   * @param {number} amount - Amount in USD
+   */
+  record(model, amount) {
+    this.initializeModel(model);
+    this.usage[model].daily += amount;
+    this.usage[model].monthly += amount;
+    this.usage[model].requests = (this.usage[model].requests || 0) + 1;
+    this.save();
+  }
+
+  /**
+   * Check if should alert about budget
+   * @param {string} model - Model name
+   * @param {Object} config - Budget config { budgetDaily, alertThreshold }
+   * @returns {boolean}
+   */
+  shouldAlert(model, config) {
+    this.initializeModel(model);
+    const usage = this.usage[model];
+    const percentUsed = usage.daily / config.budgetDaily;
+    return percentUsed >= (config.alertThreshold || 0.8);
+  }
+
+  /**
+   * Get usage for model
+   * @param {string} model - Model name
+   * @returns {Object} Usage { daily, monthly, requests }
+   */
+  getUsage(model) {
+    if (!this.usage[model]) {
+      return { daily: 0, monthly: 0, requests: 0 };
+    }
+    return {
+      daily: this.usage[model].daily || 0,
+      monthly: this.usage[model].monthly || 0,
+      requests: this.usage[model].requests || 0,
+    };
+  }
+
+  /**
+   * Reset usage for model (admin)
+   * @param {string} model - Model name
+   */
+  reset(model) {
+    this.usage[model] = {
+      daily: 0,
+      monthly: 0,
+      requests: 0,
+      lastDailyReset: new Date().toISOString(),
+      lastMonthlyReset: new Date().toISOString(),
+    };
+    this.save();
+  }
+}
+
+module.exports = {
+  BudgetTracker,
+};

package/server/lib/budget-tracker.test.js

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { BudgetTracker } from './budget-tracker.js';
+
+describe('BudgetTracker', () => {
+  let testDir;
+  let tracker;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-budget-test-'));
+    tracker = new BudgetTracker(path.join(testDir, '.tlc', 'usage.json'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('initialization', () => {
+    it('creates usage file if not exists', () => {
+      expect(fs.existsSync(tracker.configPath)).toBe(true);
+    });
+
+    it('loads existing usage', () => {
+      const initialData = {
+        openai: { daily: 2.50, monthly: 25.00, lastDailyReset: new Date().toISOString() },
+      };
+      fs.mkdirSync(path.dirname(tracker.configPath), { recursive: true });
+      fs.writeFileSync(tracker.configPath, JSON.stringify(initialData));
+
+      const newTracker = new BudgetTracker(tracker.configPath);
+      expect(newTracker.usage.openai.daily).toBe(2.50);
+    });
+  });
+
+  describe('canSpend', () => {
+    it('allows spending within daily budget', () => {
+      const config = { budgetDaily: 5.00, budgetMonthly: 50.00 };
+      tracker.usage.openai = { daily: 2.00, monthly: 10.00 };
+
+      expect(tracker.canSpend('openai', 1.00, config)).toBe(true);
+    });
+
+    it('blocks spending over daily budget', () => {
+      const config = { budgetDaily: 5.00, budgetMonthly: 50.00 };
+      tracker.usage.openai = { daily: 4.50, monthly: 10.00 };
+
+      expect(tracker.canSpend('openai', 1.00, config)).toBe(false);
+    });
+
+    it('blocks spending over monthly budget', () => {
+      const config = { budgetDaily: 5.00, budgetMonthly: 50.00 };
+      tracker.usage.openai = { daily: 0.00, monthly: 49.50 };
+
+      expect(tracker.canSpend('openai', 1.00, config)).toBe(false);
+    });
+  });
+
+  describe('record', () => {
+    it('records spending', () => {
+      tracker.record('openai', 1.50);
+
+      expect(tracker.usage.openai.daily).toBe(1.50);
+      expect(tracker.usage.openai.monthly).toBe(1.50);
+    });
+
+    it('accumulates spending', () => {
+      tracker.record('openai', 1.00);
+      tracker.record('openai', 0.50);
+
+      expect(tracker.usage.openai.daily).toBe(1.50);
+    });
+
+    it('persists to file', () => {
+      tracker.record('openai', 2.00);
+
+      const loaded = JSON.parse(fs.readFileSync(tracker.configPath, 'utf-8'));
+      expect(loaded.openai.daily).toBe(2.00);
+    });
+  });
+
+  describe('daily reset', () => {
+    it('resets daily at midnight', () => {
+      tracker.usage.openai = {
+        daily: 5.00,
+        monthly: 20.00,
+        lastDailyReset: new Date('2026-01-30').toISOString(),
+        lastMonthlyReset: new Date('2026-01-01').toISOString(), // Same month
+      };
+
+      // Simulate new day (same month)
+      vi.setSystemTime(new Date('2026-01-31T10:00:00'));
+      tracker.checkResets();
+
+      expect(tracker.usage.openai.daily).toBe(0);
+      expect(tracker.usage.openai.monthly).toBe(20.00); // Monthly preserved
+    });
+
+    it('does not reset if same day', () => {
+      const now = new Date('2026-01-31T10:00:00');
+      vi.setSystemTime(now);
+
+      tracker.usage.openai = {
+        daily: 3.00,
+        monthly: 15.00,
+        lastDailyReset: now.toISOString(),
+      };
+
+      tracker.checkResets();
+
+      expect(tracker.usage.openai.daily).toBe(3.00);
+    });
+  });
+
+  describe('monthly reset', () => {
+    it('resets monthly at month start', () => {
+      tracker.usage.openai = {
+        daily: 5.00,
+        monthly: 45.00,
+        lastMonthlyReset: new Date('2025-12-15').toISOString(),
+      };
+
+      // Simulate new month
+      vi.setSystemTime(new Date('2026-01-15'));
+      tracker.checkResets();
+
+      expect(tracker.usage.openai.monthly).toBe(0);
+    });
+  });
+
+  describe('shouldAlert', () => {
+    it('returns true at threshold', () => {
+      tracker.usage.openai = { daily: 4.00, monthly: 0 };
+      const config = { budgetDaily: 5.00, alertThreshold: 0.8 };
+
+      expect(tracker.shouldAlert('openai', config)).toBe(true);
+    });
+
+    it('returns false below threshold', () => {
+      tracker.usage.openai = { daily: 2.00, monthly: 0 };
+      const config = { budgetDaily: 5.00, alertThreshold: 0.8 };
+
+      expect(tracker.shouldAlert('openai', config)).toBe(false);
+    });
+  });
+
+  describe('getUsage', () => {
+    it('returns usage for model', () => {
+      tracker.usage.openai = { daily: 2.50, monthly: 25.00, requests: 10 };
+
+      const usage = tracker.getUsage('openai');
+
+      expect(usage.daily).toBe(2.50);
+      expect(usage.monthly).toBe(25.00);
+    });
+
+    it('returns zero for unknown model', () => {
+      const usage = tracker.getUsage('unknown');
+
+      expect(usage.daily).toBe(0);
+      expect(usage.monthly).toBe(0);
+    });
+  });
+});

package/server/lib/claude-injector.js

@@ -0,0 +1,85 @@
+/**
+ * CLAUDE.md Injector - Inject memory context into CLAUDE.md
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Markers for the auto-generated memory section
+ */
+const MEMORY_SECTION_MARKERS = {
+  START: '<!-- TLC-MEMORY-START -->',
+  END: '<!-- TLC-MEMORY-END -->',
+};
+
+/**
+ * Extract memory section content from CLAUDE.md
+ * @param {string} content - CLAUDE.md content
+ * @returns {string|null} Extracted memory content or null if not found
+ */
+function extractMemorySection(content) {
+  if (!content) return null;
+
+  const startIdx = content.indexOf(MEMORY_SECTION_MARKERS.START);
+  const endIdx = content.indexOf(MEMORY_SECTION_MARKERS.END);
+
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    return null;
+  }
+
+  const start = startIdx + MEMORY_SECTION_MARKERS.START.length;
+  return content.slice(start, endIdx).trim();
+}
+
+/**
+ * Inject memory context into CLAUDE.md
+ * @param {string} projectRoot - Project root directory
+ * @param {string} memoryContext - Memory context to inject
+ * @returns {Promise<void>}
+ */
+async function injectMemoryContext(projectRoot, memoryContext) {
+  const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+
+  let existingContent = '';
+  try {
+    existingContent = await fs.readFile(claudeMdPath, 'utf-8');
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+    // File doesn't exist, will create new
+  }
+
+  // Build the new memory section
+  const memorySection = `${MEMORY_SECTION_MARKERS.START}
+${memoryContext}
+${MEMORY_SECTION_MARKERS.END}`;
+
+  let newContent;
+
+  // Check if memory section already exists
+  const startIdx = existingContent.indexOf(MEMORY_SECTION_MARKERS.START);
+  const endIdx = existingContent.indexOf(MEMORY_SECTION_MARKERS.END);
+
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    // Replace existing section
+    const before = existingContent.slice(0, startIdx);
+    const after = existingContent.slice(endIdx + MEMORY_SECTION_MARKERS.END.length);
+    newContent = before + memorySection + after;
+  } else {
+    // Append new section
+    const trimmed = existingContent.trim();
+    if (trimmed) {
+      newContent = trimmed + '\n\n' + memorySection + '\n';
+    } else {
+      newContent = memorySection + '\n';
+    }
+  }
+
+  await fs.writeFile(claudeMdPath, newContent, 'utf-8');
+}
+
+module.exports = {
+  injectMemoryContext,
+  extractMemorySection,
+  MEMORY_SECTION_MARKERS,
+};