@nxuss/lemma 0.3.0 → 0.3.1

package/lemma-proxy.js

@@ -1,810 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * Lemma Proxy v0.3.0 — Universal AI Cache CLI
- * Commands: start, stop, stats, status, activate <key>
- */
-
-const { program } = require('commander');
-const express = require('express');
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const { ChromaClient } = require('chromadb');
-const chroma = new ChromaClient({ host: 'localhost', port: 8000 });
-const dummyEmbeddingFunction = { generate: (texts) => Promise.resolve([]) };
-const https = require('https');
-const http = require('http');
-const axios = require('axios');
-const WebSocket = require('ws');
-
-// ── Paths ──────────────────────────────────────────────────────────────────────
-const HOME = process.env.HOME || process.env.USERPROFILE || '~';
-const CACHE_DIR = path.join(HOME, '.lemma-cache');
-const PID_FILE  = path.join(CACHE_DIR, 'proxy.pid');
-const PORT_FILE = path.join(CACHE_DIR, 'proxy.port');
-const STATS_FILE = path.join(CACHE_DIR, 'stats.json');
-const USAGE_FILE = path.join(CACHE_DIR, 'usage.json');
-const LICENSE_FILE = path.join(CACHE_DIR, 'license.json');
-const LEGACY_LICENSE_FILE = path.join(CACHE_DIR, 'license.key');
-
-const EVENT_LOG = [];
-const MAX_EVENTS = 100;
-
-function logEvent(event) {
-  const ev = { id: Math.random().toString(36).slice(2, 11), timestamp: Date.now(), ...event };
-  EVENT_LOG.push(ev);
-  if (EVENT_LOG.length > MAX_EVENTS) EVENT_LOG.shift();
-}
-
-const FREE_LIMIT = 300;
-const WARN_PCT   = 0.8;
-const VALIDATE_URL = 'https://lemma.nxus.studio/api/v1/validate';
-
-if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR, { recursive: true });
-
-// ── Helpers ────────────────────────────────────────────────────────────────────
-function readJson(file, fallback) {
-  try { if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf8')); } catch {}
-  return fallback;
-}
-function writeJson(file, data) {
-  try { fs.writeFileSync(file, JSON.stringify(data, null, 2)); } catch {}
-}
-function projectHash(name) {
-  return crypto.createHash('sha1').update(name).digest('hex').slice(0, 12);
-}
-function detectProject() {
-  const pkg = path.join(process.cwd(), 'package.json');
-  if (fs.existsSync(pkg)) {
-    try { const p = JSON.parse(fs.readFileSync(pkg, 'utf8')); if (p.name) return p.name; } catch {}
-  }
-  return path.basename(process.cwd());
-}
-function ensureProjectDir(name) {
-  const dir = path.join(CACHE_DIR, projectHash(name));
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const marker = path.join(dir, 'project-name.txt');
-  if (!fs.existsSync(marker)) fs.writeFileSync(marker, name);
-  return dir;
-}
-
-// ── License helpers ────────────────────────────────────────────────────────────
-function loadLicense() {
-  let lic = readJson(LICENSE_FILE, null);
-  if (lic && lic.isPro) return lic;
-  // migrate legacy
-  const leg = readJson(LEGACY_LICENSE_FILE, null);
-  if (leg && (leg.isPro || leg.tier === 'pro')) {
-    const m = { key: leg.key, tier: 'pro', isPro: true, activatedAt: leg.activatedAt || new Date().toISOString(), validatedRemotely: false };
-    writeJson(LICENSE_FILE, m);
-    try { fs.unlinkSync(LEGACY_LICENSE_FILE); } catch {}
-    return m;
-  }
-  return { isPro: false };
-}
-function isPro() { const l = loadLicense(); return !!(l && l.isPro); }
-
-async function validateKeyRemote(key) {
-  return new Promise((resolve, reject) => {
-    const body = JSON.stringify({ key });
-    const u = new URL(VALIDATE_URL);
-    const req = https.request({ hostname: u.hostname, port: 443, path: u.pathname, method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body), 'User-Agent': 'lemma-proxy/0.3.0' }
-    }, res => {
-      let d = '';
-      res.on('data', c => d += c);
-      res.on('end', () => { try { resolve(JSON.parse(d)); } catch { reject(new Error('bad json')); } });
-    });
-    req.on('error', reject);
-    const t = setTimeout(() => { req.destroy(); reject(new Error('timeout')); }, 5000);
-    req.on('close', () => clearTimeout(t));
-    req.write(body); req.end();
-  });
-}
-
-// ── Usage helpers ──────────────────────────────────────────────────────────────
-function loadUsage() {
-  const u = readJson(USAGE_FILE, { count: 0, lastReset: new Date().toISOString(), history: [] });
-  const now = new Date(), last = new Date(u.lastReset || 0);
-  if (now.getMonth() !== last.getMonth() || now.getFullYear() !== last.getFullYear()) {
-    const fresh = { count: 0, lastReset: now.toISOString(), history: [...(u.history||[]), { month: last.toISOString().slice(0,7), count: u.count }] };
-    writeJson(USAGE_FILE, fresh); return fresh;
-  }
-  return u;
-}
-
-// ── Stats helpers ──────────────────────────────────────────────────────────────
-function loadStats() { return readJson(STATS_FILE, {}); }
-function recordStat(stats, project, fromCache, latencyMs, provider, tokensSaved) {
-  if (!stats[project]) stats[project] = { total:0, hits:0, misses:0, totalLatency:0, totalTokensSaved:0, providers:{} };
-  const s = stats[project];
-  s.total++; s.totalLatency += latencyMs;
-  fromCache ? s.hits++ : s.misses++;
-  s.totalTokensSaved += (fromCache ? (tokensSaved||2000) : 0);
-  if (!s.providers[provider]) s.providers[provider] = { hits:0, misses:0 };
-  fromCache ? s.providers[provider].hits++ : s.providers[provider].misses++;
-  
-  logEvent({ 
-    type: fromCache ? 'cache:hit' : 'cache:miss', 
-    project, 
-    latency: latencyMs, 
-    provider,
-    tokens: fromCache ? (tokensSaved||2000) : 0
-  });
-
-  writeJson(STATS_FILE, stats);
-}
-
-// ── Cache (in-process) ─────────────────────────────────────────────────────────
-// Simple in-memory map used by the proxy process itself
-const CACHE = new Map(); // key → {input, data, createdAt, ttl}
-const TTL_MS = 86400000 * 7;
-
-function cacheKey(prompt) {
-  return crypto.createHash('sha256').update(prompt.toLowerCase().trim()).digest('hex');
-}
-
-// ── Semantic Search (Pro) ──────────────────────────────────────────────────────
-async function getEmbedding(text) {
-  try {
-    const resp = await axios.post('http://localhost:11434/api/embeddings', {
-      model: 'nomic-embed-text',
-      prompt: text
-    }, { timeout: 5000 });
-    return resp.data.embedding;
-  } catch (e) {
-    return null;
-  }
-}
-
-async function semanticGet(prompt) {
-  if (!isPro()) return null;
-  const emb = await getEmbedding(prompt);
-  if (!emb) return null;
-
-    try {
-      const collection = await chroma.getOrCreateCollection({ 
-        name: 'lemma-cache',
-        embeddingFunction: dummyEmbeddingFunction,
-        metadata: { "hnsw:space": "cosine" }
-      });
-      const res = await collection.query({
-        queryEmbeddings: [emb],
-        nResults: 1
-      });
-    
-    if (!res.ids[0] || res.ids[0].length === 0) return null;
-    
-    const distance = res.distances[0][0];
-    const similarity = Math.max(0, 1 - distance); // Chroma Cosine distance is 0 to 2
-    const THRESHOLD = 0.7;
-
-    console.log(`🔍 Semantic Search: Dist=${distance.toFixed(3)}, Sim=${similarity.toFixed(3)} (Threshold=${THRESHOLD})`);
-
-    if (similarity >= THRESHOLD) {
-      console.log(`🎯 Semantic HIT!`);
-      const metadata = res.metadatas[0][0];
-      return { 
-        data: JSON.parse(metadata.response), 
-        similarity,
-        id: res.ids[0][0]
-      };
-    }
-  } catch (e) {
-    console.error(`❌ Semantic search error: ${e.message}`);
-  }
-  return null;
-}
-
-async function semanticSet(prompt, data) {
-  if (!isPro()) return;
-  const emb = await getEmbedding(prompt);
-  if (!emb) return;
-
-    try {
-      const collection = await chroma.getOrCreateCollection({ 
-        name: 'lemma-cache',
-        embeddingFunction: dummyEmbeddingFunction,
-        metadata: { "hnsw:space": "cosine" }
-      });
-
-    await collection.add({
-      ids: [crypto.randomUUID?.() || Math.random().toString(36).substring(7)],
-      embeddings: [emb],
-      metadatas: [{ 
-        prompt, 
-        response: JSON.stringify(data),
-        timestamp: Date.now() 
-      }],
-      documents: [prompt]
-    });
-    console.log(`💾 Stored semantic entry: "${prompt.substring(0, 30)}..."`);
-  } catch (e) {
-    console.error(`❌ Semantic storage failed: ${e.message}`);
-  }
-}
-
-function cacheGet(prompt) {
-  const k = cacheKey(prompt);
-  const e = CACHE.get(k);
-  if (!e) return null;
-  if (e.ttl > 0 && Date.now() - e.createdAt > e.ttl) { CACHE.delete(k); return null; }
-  return e;
-}
-function cacheSet(prompt, data) {
-  CACHE.set(cacheKey(prompt), { input: prompt, data, createdAt: Date.now(), ttl: TTL_MS });
-}
-
-// ── Prompt extraction ──────────────────────────────────────────────────────────
-function extractPrompt(body, provider) {
-  const msgs = body.messages || [];
-  if (provider === 'openai') return msgs.map(m => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content))).join('\n');
-  if (provider === 'anthropic') return msgs.map(m => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content))).join('\n');
-  if (provider === 'gemini') {
-    const contents = body.contents || [];
-    return contents.map(c => c.parts.map(p => p.text).join(' ')).join('\n');
-  }
-  return null;
-}
-
-// ── SSE helpers ────────────────────────────────────────────────────────────────
-function setSseHeaders(res, fromCache, similarity, tier) {
-  res.setHeader('Content-Type', 'text/event-stream');
-  res.setHeader('Cache-Control', 'no-cache');
-  res.setHeader('Connection', 'keep-alive');
-  res.setHeader('X-Accel-Buffering', 'no');
-  res.setHeader('X-Lemma-Cache', fromCache ? 'HIT' : 'MISS');
-  res.setHeader('X-Lemma-Similarity', (similarity || 1.0).toFixed(3));
-  res.setHeader('X-Lemma-Tier', tier);
-}
-
-function buildOaiChunk(id, model, text, stop) {
-  return { id, object:'chat.completion.chunk', created: Math.floor(Date.now()/1000), model,
-    choices:[{ index:0, delta: stop ? {} : { content: text }, finish_reason: stop ? 'stop' : null }] };
-}
-function buildAntChunk(text, stop) {
-  if (stop) return { type:'message_stop' };
-  return { type:'content_block_delta', index:0, delta:{ type:'text_delta', text } };
-}
-function buildGemChunk(text, stop) {
-  return { candidates: [{ content: { parts: [{ text }] }, finishReason: stop ? 'STOP' : undefined }] };
-}
-
-async function simulateHitStream(res, cachedData, provider, model, tier, similarity) {
-  setSseHeaders(res, true, similarity, tier);
-  const id = `lemma-${Date.now()}`;
-  let text = '';
-  try {
-    if (provider === 'openai') text = cachedData?.choices?.[0]?.message?.content || '';
-    else if (provider === 'anthropic') { const c = cachedData?.content; text = Array.isArray(c) ? c.map(x=>x.text||'').join('') : String(c||''); }
-    else if (provider === 'gemini') { text = cachedData?.candidates?.[0]?.content?.parts?.[0]?.text || ''; }
-  } catch {}
-  const words = text.split(' ');
-  for (let i = 0; i < words.length; i += 5) {
-    const chunk = words.slice(i, i+5).join(' ');
-    let evt;
-    if (provider === 'openai') evt = buildOaiChunk(id, model, chunk, false);
-    else if (provider === 'anthropic') evt = buildAntChunk(chunk, false);
-    else if (provider === 'gemini') evt = buildGemChunk(chunk, false);
-    
-    res.write(provider === 'gemini' ? `${JSON.stringify(evt)}\n` : `data: ${JSON.stringify(evt)}\n\n`);
-    await new Promise(r => setTimeout(r, 15));
-  }
-  const stopEvt = provider === 'openai' ? buildOaiChunk(id, model, '', true) : (provider === 'anthropic' ? buildAntChunk('', true) : buildGemChunk('', true));
-  res.write(provider === 'gemini' ? `${JSON.stringify(stopEvt)}\n` : `data: ${JSON.stringify(stopEvt)}\n\n`);
-  if (provider !== 'gemini') res.write('data: [DONE]\n\n');
-  res.end();
-}
-
-async function relayMissStream(res, body, provider, tier) {
-  setSseHeaders(res, false, 1.0, tier);
-  const apiKey = provider === 'openai' ? process.env.OPENAI_API_KEY : process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) { res.write(`data: ${JSON.stringify({error:`${provider.toUpperCase()}_API_KEY not set`})}\n\ndata: [DONE]\n\n`); res.end(); return; }
-  const hostname = provider === 'openai' ? 'api.openai.com' : 'api.anthropic.com';
-  const upPath   = provider === 'openai' ? '/v1/chat/completions' : '/v1/messages';
-  const headers  = provider === 'openai'
-    ? { Authorization: `Bearer ${apiKey}`, 'Content-Type':'application/json' }
-    : { 'x-api-key': apiKey, 'anthropic-version':'2023-06-01', 'Content-Type':'application/json' };
-  const payload = JSON.stringify({ ...body, stream: true });
-  await new Promise(resolve => {
-    const req = https.request({ hostname, port:443, path:upPath, method:'POST',
-      headers: { ...headers, 'Content-Length': Buffer.byteLength(payload) }
-    }, upstream => {
-      upstream.on('data', chunk => res.write(chunk));
-      upstream.on('end', () => { res.write('data: [DONE]\n\n'); res.end(); resolve(); });
-      upstream.on('error', err => { res.write(`data: ${JSON.stringify({error:err.message})}\n\ndata: [DONE]\n\n`); res.end(); resolve(); });
-    });
-    req.on('error', err => { res.write(`data: ${JSON.stringify({error:err.message})}\n\ndata: [DONE]\n\n`); res.end(); resolve(); });
-    req.write(payload); req.end();
-  });
-}
-
-// ── Proxy Server class ─────────────────────────────────────────────────────────
-class LemmaServer {
-  constructor(port, projectName) {
-    this.port = port;
-    this.projectName = projectName || detectProject();
-    this.projectDir = ensureProjectDir(this.projectName);
-    this.stats = loadStats();
-    this.app = express();
-    this.setupMiddleware();
-    this.setupRoutes();
-    this.setupWebSockets();
-  }
-
-  setupMiddleware() {
-    this.app.use(express.json({ limit: '10mb' }));
-    this.app.use((req, res, next) => {
-      res.header('Access-Control-Allow-Origin', '*');
-      res.header('Access-Control-Allow-Headers', '*');
-      res.header('Access-Control-Allow-Methods', '*');
-      if (req.method === 'OPTIONS') return res.sendStatus(200);
-      next();
-    });
-  }
-
-  setupRoutes() {
-    // Health
-    this.app.get('/health', (req, res) => {
-      const pro = isPro();
-      res.json({ status:'ok', project: this.projectName, mode: pro?'pro':'standard',
-        tier: pro?'pro':'free', cacheSize: CACHE.size, port: this.port });
-    });
-
-    // Stats endpoint
-    this.app.get('/stats', (req, res) => {
-      res.json({ project: this.projectName, stats: this.stats[this.projectName] || {} });
-    });
-
-    // Mock /v1/models (required by Cursor to accept Lemma as a valid base URL)
-    this.app.get('/v1/models', (req, res) => {
-      res.json({ object:'list', data:[
-        { id:'gpt-4o', object:'model', created:1706745938, owned_by:'lemma-proxy' },
-        { id:'gpt-4', object:'model', created:1687882411, owned_by:'lemma-proxy' },
-        { id:'gpt-4-turbo', object:'model', created:1712361441, owned_by:'lemma-proxy' },
-        { id:'gpt-3.5-turbo', object:'model', created:1677610602, owned_by:'lemma-proxy' },
-        { id:'claude-3-5-sonnet-20241022', object:'model', created:1706745938, owned_by:'lemma-proxy' },
-        { id:'claude-3-opus-20240229', object:'model', created:1706745938, owned_by:'lemma-proxy' },
-      ]});
-    });
-
-    // OpenAI completions
-    this.app.post('/v1/chat/completions', (req, res) => this.handleCompletion(req, res, 'openai'));
-
-    // Anthropic messages
-    this.app.post('/v1/messages', (req, res) => this.handleCompletion(req, res, 'anthropic'));
-
-    // Gemini completions
-    this.app.post('/v1beta/models/:modelId:generateContent', (req, res) => this.handleCompletion(req, res, 'gemini'));
-    this.app.post('/v1beta/models/:modelId:streamGenerateContent', (req, res) => this.handleCompletion(req, res, 'gemini'));
-
-    // Pass-through all other /v1/* calls
-    this.app.all('/v1/*', async (req, res) => this.passThrough(req, res));
-
-    // ── Dashboard APIs ──────────────────────────────────────────────────────────
-    
-    // Serve Dashboard Static UI
-    const dashboardPath = path.join(__dirname, 'dashboard', 'dist');
-    if (fs.existsSync(dashboardPath)) {
-      // Redirect /dashboard to /dashboard/ to ensure relative assets load correctly
-      this.app.get('/dashboard', (req, res, next) => {
-        if (!req.path.endsWith('/')) return res.redirect(301, '/dashboard/');
-        next();
-      });
-
-      this.app.use('/dashboard/', express.static(dashboardPath));
-      // API endpoints expected by the dashboard
-      this.app.get('/api/metrics', (req, res) => {
-        const stats = this.stats[this.projectName] || { total:0, hits:0, misses:0, totalLatency:0, totalTokensSaved:0 };
-        const pro = isPro();
-        res.json({
-          timestamp: new Date().toISOString(),
-          totalRequests: stats.total,
-          cacheHits: stats.hits,
-          cacheMisses: stats.misses,
-          hitRate: stats.total > 0 ? (stats.hits / stats.total) : 0,
-          averageLatency: stats.total > 0 ? (stats.totalLatency / stats.total) : 0,
-          tokensSaved: stats.totalTokensSaved,
-          costSaved: stats.hits * 0.003,
-          activeAgents: 1,
-          totalAgents: 1,
-          uptime: process.uptime(),
-          tier: pro ? 'pro' : 'free',
-          mode: pro ? 'Semantic' : 'Standard'
-        });
-      });
-
-      this.app.get('/api/agents', (req, res) => {
-        res.json({ agents: [{ 
-          id: this.projectName, 
-          name: this.projectName, 
-          status: 'active', 
-          capabilities: ['Semantic Cache', 'IDE Proxy'], 
-          tasksCompleted: this.stats[this.projectName]?.total || 0,
-          cacheHits: this.stats[this.projectName]?.hits || 0,
-          lastSeen: new Date().toISOString() 
-        }]});
-      });
-
-      this.app.get('/api/events', (req, res) => {
-        const page = parseInt(req.query.page) || 1;
-        const limit = parseInt(req.query.limit) || 50;
-        const reversed = [...EVENT_LOG].reverse();
-        res.json({ 
-          events: reversed.slice((page-1)*limit, page*limit),
-          pagination: { total: EVENT_LOG.length, page, limit }
-        });
-      });
-
-      this.app.get('/api/cache-stats', (req, res) => {
-        res.json({ topQueries: [], latencyPercentiles: { p50: 20, p95: 50, p99: 100 }, totalCached: CACHE.size });
-      });
-
-      // Handle dashboard client-side routing (must be last)
-      this.app.get('/dashboard/*', (req, res) => {
-        res.sendFile(path.join(dashboardPath, 'index.html'));
-      });
-    }
-  }
-
-  async handleCompletion(req, res, provider) {
-    const t0 = Date.now();
-    const pro = isPro();
-    const tier = pro ? 'pro' : 'standard';
-    const isStream = !!req.body.stream;
-
-    // Free tier gate
-    if (!pro) {
-      const usage = loadUsage();
-      const remaining = FREE_LIMIT - usage.count;
-      if (remaining <= 0) {
-        const errBody = { error:{ message:`Free tier limit (${FREE_LIMIT}/mo). Upgrade: https://lemma.nxus.studio/upgrade`, type:'rate_limit_exceeded', code:'free_tier_limit' }};
-        if (isStream) { res.setHeader('Content-Type','text/event-stream'); res.write(`data: ${JSON.stringify(errBody)}\n\ndata: [DONE]\n\n`); return res.end(); }
-        return res.status(429).json(errBody);
-      }
-      if (remaining <= FREE_LIMIT * (1 - WARN_PCT)) res.setHeader('X-Lemma-Warning', `${remaining} queries remaining this month`);
-    }
-
-    const prompt = extractPrompt(req.body, provider);
-    if (!prompt) return res.status(400).json({ error:'Invalid request format' });
-
-    const model = req.body.model || (provider==='openai'?'gpt-4o':'claude-3-5-sonnet-20241022');
-
-    // 1. Exact Match Cache
-    const hit = cacheGet(prompt);
-    if (hit) {
-      const latencyMs = Date.now() - t0;
-      recordStat(this.stats, this.projectName, true, latencyMs, provider, 2000);
-      if (isStream) return simulateHitStream(res, hit.data, provider, model, tier, 1.0);
-      res.setHeader('X-Lemma-Cache', 'HIT');
-      res.setHeader('X-Lemma-Similarity', '1.000');
-      res.setHeader('X-Lemma-Tier', tier);
-      res.setHeader('X-Lemma-Latency', `${latencyMs}ms`);
-      return res.json(hit.data);
-    }
-
-    // 2. Semantic Match Cache (Pro Only)
-    if (pro) {
-      const semHit = await semanticGet(prompt);
-      if (semHit) {
-        const latencyMs = Date.now() - t0;
-        recordStat(this.stats, this.projectName, true, latencyMs, provider, 2000);
-        if (isStream) return simulateHitStream(res, semHit.data, provider, model, tier, semHit.similarity);
-        res.setHeader('X-Lemma-Cache', 'HIT');
-        res.setHeader('X-Lemma-Similarity', semHit.similarity.toFixed(3));
-        res.setHeader('X-Lemma-Tier', tier);
-        res.setHeader('X-Lemma-Latency', `${latencyMs}ms`);
-        return res.json(semHit.data);
-      }
-    }
-
-    // Cache miss — stream relay or regular call
-    if (isStream) {
-      // Relay then cache the assembled response (best-effort)
-      recordStat(this.stats, this.projectName, false, Date.now()-t0, provider, 0);
-      if (!pro) { const u = loadUsage(); u.count++; writeJson(USAGE_FILE, u); }
-      return relayMissStream(res, req.body, provider, tier);
-    }
-
-    // Non-stream upstream call
-    try {
-      const data = await this.callUpstream(req.body, provider);
-      cacheSet(prompt, data);
-      if (pro) semanticSet(prompt, data); // Store semantically
-      if (!pro) { const u = loadUsage(); u.count++; writeJson(USAGE_FILE, u); }
-      const latencyMs = Date.now() - t0;
-      recordStat(this.stats, this.projectName, false, latencyMs, provider, 0);
-      res.setHeader('X-Lemma-Cache', 'MISS');
-      res.setHeader('X-Lemma-Similarity', '0.000');
-      res.setHeader('X-Lemma-Tier', tier);
-      res.setHeader('X-Lemma-Latency', `${latencyMs}ms`);
-      return res.json(data);
-    } catch (err) {
-      return res.status(500).json({ error: err.message });
-    }
-  }
-
-  async callUpstream(body, provider) {
-    if (provider === 'gemini') {
-      const apiKey = process.env.GEMINI_API_KEY;
-      if (!apiKey) throw new Error('GEMINI_API_KEY not set');
-      const model = body.model || 'gemini-1.5-pro';
-      const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
-      const resp = await axios.post(url, body, { headers: { 'Content-Type': 'application/json' } });
-      return resp.data;
-    }
-    const apiKey = provider === 'openai' ? process.env.OPENAI_API_KEY : process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) throw new Error(`${provider.toUpperCase()}_API_KEY not set`);
-    const baseURL = provider === 'openai' ? 'https://api.openai.com' : 'https://api.anthropic.com';
-    const endpoint = provider === 'openai' ? '/v1/chat/completions' : '/v1/messages';
-    const headers = provider === 'openai'
-      ? { Authorization:`Bearer ${apiKey}`, 'Content-Type':'application/json' }
-      : { 'x-api-key':apiKey, 'anthropic-version':'2023-06-01', 'Content-Type':'application/json' };
-    const resp = await axios.post(`${baseURL}${endpoint}`, body, { headers });
-    return resp.data;
-  }
-
-  async passThrough(req, res) {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) return res.status(401).json({ error:'OPENAI_API_KEY not set' });
-    try {
-      const resp = await axios({ method:req.method, url:`https://api.openai.com${req.path}`, data:req.body,
-        headers:{ Authorization:`Bearer ${apiKey}` } });
-      res.json(resp.data);
-    } catch (err) { res.status(err.response?.status||500).json(err.response?.data||{error:err.message}); }
-  }
-
-  setupWebSockets() {
-    this.wss = new WebSocket.Server({ noServer: true });
-
-    this.wss.on('connection', (ws) => {
-      let agentId = 'unknown';
-      console.log(`🔌 New agent connection attempt...`);
-
-      ws.on('message', async (message) => {
-        try {
-          const data = JSON.parse(message);
-          
-          // 1. Handle Handshake
-          if (data.type === 'handshake') {
-            agentId = data.payload?.agentId || `agent-${Date.now()}`;
-            console.log(`✅ Agent authenticated: ${agentId}`);
-            ws.send(JSON.stringify({ 
-              type: 'handshake_ack', 
-              timestamp: Date.now(),
-              payload: { status: 'connected', agentId }
-            }));
-          } 
-          
-          // 2. Handle Task Request (The core of Lemma intercepting agents)
-          else if (data.type === 'task_request') {
-            const taskId = data.payload?.taskId;
-            const prompt = data.payload?.description;
-            console.log(`🤖 [${agentId}] Task received: "${prompt.substring(0, 40)}..."`);
-
-            const t0 = Date.now();
-            const pro = isPro();
-
-            // Free tier gate
-            if (!pro) {
-              const usage = loadUsage();
-              if (usage.count >= FREE_LIMIT) {
-                console.log(`⚠️  [${agentId}] Blocked: Free tier limit reached`);
-                ws.send(JSON.stringify({
-                  type: 'task_response',
-                  payload: {
-                    taskId,
-                    success: false,
-                    error: `Free tier limit (${FREE_LIMIT}/mo). Upgrade: https://lemma.nxus.studio/upgrade`,
-                    code: 'free_tier_limit'
-                  }
-                }));
-                return;
-              }
-            }
-            
-            // Check Cache (Exact + Semantic if Pro)
-            const hit = cacheGet(prompt);
-            let responseData = null;
-            let fromCache = false;
-            let similarity = 1.0;
-
-            if (hit) {
-              responseData = hit.data;
-              fromCache = true;
-            } else if (isPro()) {
-              const semHit = await semanticGet(prompt);
-              if (semHit) {
-                responseData = semHit.data;
-                fromCache = true;
-                similarity = semHit.similarity;
-              }
-            }
-
-            if (fromCache) {
-              const latencyMs = Date.now() - t0;
-              recordStat(this.stats, this.projectName, true, latencyMs, 'agent-swarm', 500);
-              console.log(`⚡ [${agentId}] Cache HIT! (${latencyMs}ms)`);
-              
-              ws.send(JSON.stringify({
-                type: 'task_response',
-                payload: {
-                  taskId,
-                  success: true,
-                  result: responseData,
-                  fromCache: true,
-                  latencyMs
-                }
-              }));
-            } else {
-              // Simular una respuesta del modelo para el ejemplo de los agentes
-              // En un entorno real, aquí se llamaría a callUpstream
-              const mockResult = `Processed by Lemma Engine: ${prompt.toUpperCase()}`;
-              const latencyMs = 800 + Math.random() * 500; // Simular latencia de red
-              
-              setTimeout(() => {
-                cacheSet(prompt, mockResult);
-                if (isPro()) semanticSet(prompt, mockResult);
-                recordStat(this.stats, this.projectName, false, latencyMs, 'agent-swarm', 0);
-                
-                ws.send(JSON.stringify({
-                  type: 'task_response',
-                  payload: {
-                    taskId,
-                    success: true,
-                    result: mockResult,
-                    fromCache: false,
-                    latencyMs
-                  }
-                }));
-              }, 500);
-            }
-          }
-        } catch (e) {
-          console.error('WebSocket message error:', e);
-        }
-      });
-    });
-  }
-
-  start() {
-    const server = this.app.listen(this.port, () => {
-      writeJson(PID_FILE.replace('.pid', '.pid'), { pid: process.pid });
-      fs.writeFileSync(PID_FILE, String(process.pid));
-      fs.writeFileSync(PORT_FILE, String(this.port));
-      const pro = isPro();
-      console.log(`\n🚀 Lemma Proxy v0.3.0 — ${pro?'✨ Pro (Semantic)':'📦 Standard (Free)'}`);
-      console.log(`📁 Project : ${this.projectName}`);
-      console.log(`🔌 Port    : ${this.port}`);
-      console.log(`💾 Cache   : ${this.projectDir}`);
-      console.log(`\n📝 Configure your IDE:`);
-      console.log(`   OpenAI Base URL  → http://localhost:${this.port}/v1`);
-      console.log(`   Anthropic Base   → http://localhost:${this.port}/v1`);
-      console.log(`\n📊 Commands: lemma-proxy stats | lemma-proxy stop`);
-      console.log(`🌐 Dashboard: http://localhost:${this.port}/dashboard\n`);
-    });
-
-    server.on('upgrade', (request, socket, head) => {
-      this.wss.handleUpgrade(request, socket, head, (ws) => {
-        this.wss.emit('connection', ws, request);
-      });
-    });
-
-    process.on('SIGTERM', () => this.stop(server));
-    process.on('SIGINT',  () => this.stop(server));
-  }
-
-  stop(server) {
-    console.log('\n🛑 Stopping Lemma Proxy...');
-    if (server) server.close();
-    try { if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE); } catch {}
-    try { if (fs.existsSync(PORT_FILE)) fs.unlinkSync(PORT_FILE); } catch {}
-    console.log('✅ Stopped');
-    process.exit(0);
-  }
-}
-
-// ── CLI ────────────────────────────────────────────────────────────────────────
-program.name('lemma-proxy').description('Lemma Proxy — Universal AI Cache for IDEs').version('0.3.0');
-
-program.command('start')
-  .description('Start the proxy server')
-  .option('-p, --port <number>', 'Port to listen on', '8080')
-  .option('--project <name>', 'Override project name')
-  .action(async (opts) => {
-    const port = parseInt(opts.port, 10);
-    const server = new LemmaServer(port, opts.project || null);
-    server.start();
-  });
-
-program.command('stop')
-  .description('Stop the running proxy')
-  .action(() => {
-    if (!fs.existsSync(PID_FILE)) return console.log('⚠️  Proxy not running');
-    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8'));
-    try { process.kill(pid, 'SIGTERM'); console.log('✅ Proxy stopped'); }
-    catch { console.log('⚠️  Process not found — clearing PID'); try { fs.unlinkSync(PID_FILE); } catch {} }
-  });
-
-program.command('status')
-  .description('Show proxy status')
-  .action(() => {
-    const running = fs.existsSync(PID_FILE);
-    const port = fs.existsSync(PORT_FILE) ? fs.readFileSync(PORT_FILE,'utf8').trim() : '?';
-    const lic = loadLicense();
-    console.log(`\n📊 Lemma Proxy Status`);
-    console.log(`   Running : ${running ? '✅ Yes (PID '+fs.readFileSync(PID_FILE,'utf8').trim()+')' : '❌ No'}`);
-    if (running) console.log(`   Port    : ${port}`);
-    console.log(`   Tier    : ${lic.isPro ? '✨ Pro' : '📦 Standard (Free)'}`);
-    console.log(`   URL     : http://localhost:${port}/v1\n`);
-  });
-
-program.command('stats')
-  .description('Print the Savings Audit')
-  .option('--avg-tokens <n>', 'Avg tokens per request', '2000')
-  .action((opts) => {
-    const avgTokens = parseInt(opts.avgTokens || '2000', 10);
-    const stats = loadStats();
-    const usage  = loadUsage();
-    const lic    = loadLicense();
-    const border = '═'.repeat(54);
-    console.log(`\n╔${border}╗`);
-    console.log(`║   🧠  Lemma Proxy — Savings Audit${' '.repeat(20)}║`);
-    console.log(`╠${border}╣`);
-    if (Object.keys(stats).length === 0) {
-      console.log(`║  No data yet. Start making AI calls through the proxy.${' '.repeat(0)}║`);
-    }
-    for (const [proj, s] of Object.entries(stats)) {
-      const hitRate = s.total > 0 ? (s.hits / s.total * 100).toFixed(1) : '0.0';
-      const tokSaved = (s.hits * avgTokens).toLocaleString();
-      const usd = (s.hits * 0.003).toFixed(4);
-      console.log(`║  Project     │ ${proj.slice(0,36).padEnd(36)} ║`);
-      console.log(`║  Cache Hits  │ ${String(s.hits).padEnd(36)} ║`);
-      console.log(`║  Misses      │ ${String(s.misses).padEnd(36)} ║`);
-      console.log(`║  Hit Rate    │ ${(hitRate+'%').padEnd(36)} ║`);
-      console.log(`║  Tokens Saved│ ~${tokSaved.padEnd(35)} ║`);
-      console.log(`║  USD Saved   │ ~$${String(usd).padEnd(34)} ║`);
-      console.log(`╠${border}╣`);
-    }
-    console.log(`║  Mode        │ ${(lic.isPro?'✨ Pro (Semantic)':'📦 Standard (Free)').padEnd(36)} ║`);
-    console.log(`║  Queries     │ ${(usage.count+'/'+FREE_LIMIT+' this month').padEnd(36)} ║`);
-    console.log(`╚${border}╝\n`);
-    if (!lic.isPro && usage.count >= FREE_LIMIT * WARN_PCT) {
-      console.log(`⚠️  Approaching free tier limit. Upgrade: https://lemma.nxus.studio/upgrade\n`);
-    }
-  });
-
-program.command('activate <key>')
-  .description('Activate a Lemma Pro license key')
-  .action(async (key) => {
-    if (!/^LEMMA-PRO-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/.test(key.trim())) {
-      console.log('❌ Invalid format. Keys look like: LEMMA-PRO-XXXX-XXXX-XXXX');
-      process.exit(1);
-    }
-    process.stdout.write('🔍 Validating key...');
-    let validatedRemotely = false;
-    let remoteData = null;
-    try {
-      remoteData = await validateKeyRemote(key.trim());
-      validatedRemotely = true;
-      if (!remoteData.valid) {
-        console.log(`\n❌ ${remoteData.reason || 'Invalid key'}`);
-        process.exit(1);
-      }
-    } catch (err) {
-      console.log(` (server offline — using local validation)`);
-    }
-    const lic = { key: key.trim(), tier:'pro', isPro:true, activatedAt: new Date().toISOString(),
-      validatedRemotely, expiresAt: remoteData?.expiresAt, email: remoteData?.email };
-    writeJson(LICENSE_FILE, lic);
-    console.log(`\n✅ Lemma Pro activated!${validatedRemotely?' (server-verified)':' (format-validated)'}`);
-    console.log('\n✨ Unlocked:');
-    console.log('   • Unlimited queries');
-    console.log('   • Semantic Mode (embeddings)');
-    console.log('   • All projects\n');
-    console.log('🚀 Restart the proxy to apply: lemma-proxy stop && lemma-proxy start\n');
-  });
-
-program.parse(process.argv);
-module.exports = { LemmaServer };