@nxuss/lemma 0.4.6 → 0.4.8

package/lemma-proxy.cjs

@@ -1,748 +1,48 @@
 #!/usr/bin/env node
 'use strict';
-/**
- * Lemma Proxy — Universal AI Cache CLI
- * Commands: start, stop, stats, status, activate <key>
- */
-const pkg = require('./package.json');
-const VERSION = pkg.version;
 
-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');
 
-// --- Killer Features ---
-const ComplexityRouter = require('./src/proxy/ComplexityRouter.js');
-const SemanticScrubber = require('./src/security/SemanticScrubber.js');
-const CloudSyncClient = require('./src/cloud/CloudSyncClient.js');
-
-const complexityRouter = new ComplexityRouter();
-const semanticScrubber = new SemanticScrubber();
-const cloudSync = new CloudSyncClient();
-// ── 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 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;
-}
-
-function getPidByPort(port) {
-  const { execSync } = require('child_process');
-  try {
-    if (process.platform === 'win32') {
-      const out = execSync(`netstat -ano | findstr :${port}`).toString();
-      const lines = out.split('\n').filter(l => l.includes('LISTENING'));
-      if (lines.length > 0) return lines[0].trim().split(/\s+/).pop();
-    } else {
-      const out = execSync(`lsof -t -i :${port}`).toString().trim();
-      return out.split('\n')[0]; // Take first if multiple
-    }
-  } catch { return null; }
-  return null;
-}
-
-async function checkDependency(url) {
-  try {
-    const res = await axios.get(url, { timeout: 1000, validateStatus: () => true });
-    return res.status >= 200 && res.status < 500;
-  } catch { return false; }
-}
-
-function ensureGitIgnore() {
-  const gi = path.join(process.cwd(), '.gitignore');
-  const line = '.lemma/';
-  try {
-    if (fs.existsSync(gi)) {
-      const content = fs.readFileSync(gi, 'utf8');
-      if (!content.includes(line)) {
-        fs.appendFileSync(gi, `\n# Lemma Context Logs\n${line}\n`);
-        return true;
+// Automatically load environment variables from the user's workspace using a zero-dependency parser
+function loadEnvFile(filePath) {
+  if (fs.existsSync(filePath)) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      for (const line of lines) {
+        const cleanLine = line.trim();
+        if (!cleanLine || cleanLine.startsWith('#')) continue;
+        const idx = cleanLine.indexOf('=');
+        if (idx === -1) continue;
+        const key = cleanLine.substring(0, idx).trim();
+        let val = cleanLine.substring(idx + 1).trim();
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+          val = val.substring(1, val.length - 1);
+        }
+        process.env[key] = val;
       }
-    } else {
-      fs.writeFileSync(gi, `# Lemma Context Logs\n${line}\n`);
-      return true;
-    }
-  } catch {}
-  return false;
-}
-
-// ── License helpers ────────────────────────────────────────────────────────────
-function loadLicense() {
-  return readJson(LICENSE_FILE, { 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/${VERSION}` }
-    }, 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;
+    } catch (e) {}
   }
-  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);
-}
+loadEnvFile(path.join(process.cwd(), '.env'));
+loadEnvFile(path.join(process.cwd(), '.env.local'));
 
-// ── Cache (in-process) ─────────────────────────────────────────────────────────
-const CACHE = new Map();
-const TTL_MS = 86400000 * 7;
 
-function cacheKey(prompt) {
-  return crypto.createHash('sha256').update(prompt.toLowerCase().trim()).digest('hex');
-}
+// Target path in the compiled CommonJS distribution
+const distPath = path.join(__dirname, 'dist', 'cjs', 'cli', 'lemma-proxy.js');
 
-// ── Semantic Search (Pro) ──────────────────────────────────────────────────────
-async function getEmbedding(text) {
+if (fs.existsSync(distPath)) {
+  // Production mode: run the compiled CJS JavaScript binary
+  require(distPath);
+} else {
+  // Development mode: run via ts-node directly from src/
   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;
+    require('ts-node/register');
+    require('./src/cli/lemma-proxy.ts');
+  } catch (err) {
+    console.error('❌ Error: Could not launch Lemma. Please run "npm run build" to compile the package.');
+    process.exit(1);
   }
 }
-
-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);
-    const THRESHOLD = 0.7;
-
-    if (similarity >= THRESHOLD) {
-      const metadata = res.metadatas[0][0];
-      return { 
-        data: JSON.parse(metadata.response), 
-        similarity,
-        id: res.ids[0][0]
-      };
-    }
-  } catch (e) {}
-  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]
-    });
-  } catch (e) {}
-}
-
-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' || 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();
-  }
-
-  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() {
-    this.app.get('/health', (req, res) => {
-      const pro = isPro();
-      res.json({ status:'ok', project: this.projectName, mode: pro?'pro':'standard', tier: pro?'pro':'free', port: this.port });
-    });
-
-    this.app.get('/v1/models', (req, res) => {
-      res.json({ object:'list', data:[
-        { id:'gpt-4o', object:'model', owned_by:'lemma-proxy' },
-        { id:'claude-3-5-sonnet-20241022', object:'model', owned_by:'lemma-proxy' }
-      ]});
-    });
-
-    this.app.post('/v1/chat/completions', (req, res) => this.handleCompletion(req, res, 'openai'));
-    this.app.post('/v1/messages', (req, res) => this.handleCompletion(req, res, 'anthropic'));
-    this.app.post('/v1beta/models/:modelId:generateContent', (req, res) => this.handleCompletion(req, res, 'gemini'));
-
-    // Dashboard APIs
-    const dashboardPath = path.join(__dirname, 'dashboard', 'dist');
-    if (fs.existsSync(dashboardPath)) {
-      this.app.use('/dashboard/', express.static(dashboardPath));
-      this.app.get('/api/metrics', (req, res) => {
-        const stats = this.stats[this.projectName] || { total:0, hits:0, misses:0, totalLatency:0, totalTokensSaved:0 };
-        res.json({ timestamp: new Date().toISOString(), totalRequests: stats.total, cacheHits: stats.hits, tokensSaved: stats.totalTokensSaved, tier: isPro()?'pro':'free' });
-      });
-      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;
-
-    if (!pro) {
-      const usage = loadUsage();
-      if (usage.count >= FREE_LIMIT) return res.status(429).json({ error:{ message:`Free tier limit (${FREE_LIMIT}/mo). Upgrade: https://lemma.nxus.studio/upgrade` }});
-    }
-
-    const rawPrompt = extractPrompt(req.body, provider);
-    if (!rawPrompt) return res.status(400).json({ error:'Invalid request format' });
-
-    const { maskedPrompt: prompt, tokenMap } = semanticScrubber.mask(rawPrompt);
-    
-    const originalModel = req.body.model || 'gpt-4o';
-    const routingDecision = complexityRouter.evaluate(prompt, originalModel);
-    const model = routingDecision.model;
-    
-    if (req.body.model) req.body.model = model;
-    
-    if (provider === 'openai' || provider === 'anthropic') {
-      if (req.body.messages && req.body.messages.length > 0) {
-        req.body.messages[req.body.messages.length - 1].content = prompt;
-      }
-    } else if (provider === 'gemini') {
-      if (req.body.contents && req.body.contents.length > 0) {
-        const lastContent = req.body.contents[req.body.contents.length - 1];
-        if (lastContent.parts && lastContent.parts.length > 0) {
-          lastContent.parts[lastContent.parts.length - 1].text = prompt;
-        }
-      }
-    }
-
-    const hit = cacheGet(prompt);
-    if (hit) {
-      recordStat(this.stats, this.projectName, true, Date.now()-t0, provider, 2000);
-      const unmaskedData = semanticScrubber.unmask(hit.data, tokenMap);
-      if (isStream) return simulateHitStream(res, unmaskedData, provider, model, tier, 1.0);
-      
-      res.setHeader('X-Lemma-Cache', 'HIT');
-      res.setHeader('X-Lemma-Similarity', '1.000');
-      res.setHeader('X-Lemma-Tier', tier);
-      return res.json(unmaskedData);
-    }
-
-    if (pro) {
-      const semHit = await semanticGet(prompt);
-      if (semHit) {
-        recordStat(this.stats, this.projectName, true, Date.now()-t0, provider, 2000);
-        const unmaskedData = semanticScrubber.unmask(semHit.data, tokenMap);
-        if (isStream) return simulateHitStream(res, unmaskedData, 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);
-        return res.json(unmaskedData);
-      }
-      
-      const cloudHit = await cloudSync.get(prompt);
-      if (cloudHit) {
-        cacheSet(prompt, cloudHit.data);
-        recordStat(this.stats, this.projectName, true, Date.now()-t0, provider, 2000);
-        const unmaskedData = semanticScrubber.unmask(cloudHit.data, tokenMap);
-        if (isStream) return simulateHitStream(res, unmaskedData, provider, model, tier, cloudHit.similarity || 0.95);
-        
-        res.setHeader('X-Lemma-Cache', 'HIT');
-        res.setHeader('X-Lemma-Similarity', (cloudHit.similarity || 0.95).toFixed(3));
-        res.setHeader('X-Lemma-Tier', tier);
-        return res.json(unmaskedData);
-      }
-    }
-
-    if (isStream) {
-      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);
-    }
-
-    try {
-      const data = await this.callUpstream(req.body, provider);
-      cacheSet(prompt, data);
-      if (pro) {
-        semanticSet(prompt, data);
-        cloudSync.set(prompt, data);
-      }
-      if (!pro) { const u = loadUsage(); u.count++; writeJson(USAGE_FILE, u); }
-      recordStat(this.stats, this.projectName, false, Date.now()-t0, provider, 0);
-      return res.json(semanticScrubber.unmask(data, tokenMap));
-    } catch (err) {
-      return res.status(500).json({ error: err.message });
-    }
-  }
-
-  async callUpstream(body, provider) {
-    const apiKey = provider === 'openai' ? process.env.OPENAI_API_KEY : (provider === 'anthropic' ? process.env.ANTHROPIC_API_KEY : process.env.GEMINI_API_KEY);
-    const baseURL = provider === 'openai' ? 'https://api.openai.com/v1/chat/completions' : (provider === 'anthropic' ? 'https://api.anthropic.com/v1/messages' : `https://generativelanguage.googleapis.com/v1beta/models/${body.model || 'gemini-1.5-pro'}:generateContent?key=${apiKey}`);
-    const headers = provider === 'openai' ? { Authorization:`Bearer ${apiKey}` } : (provider === 'anthropic' ? { 'x-api-key':apiKey, 'anthropic-version':'2023-06-01' } : {});
-    const resp = await axios.post(baseURL, body, { headers: { ...headers, 'Content-Type':'application/json' } });
-    return resp.data;
-  }
-
-  start() {
-    const server = http.createServer(this.app);
-    server.on('error', (e) => {
-      if (e.code === 'EADDRINUSE') {
-        console.error(`\n❌ Error: Port ${this.port} is already in use.`);
-        console.error(`💡 Try stopping the existing process with 'lemma stop' or use a different port with '--port <number>'.\n`);
-        process.exit(1);
-      }
-      throw e;
-    });
-    server.listen(this.port, async () => {
-      fs.writeFileSync(PID_FILE, String(process.pid));
-      fs.writeFileSync(PORT_FILE, String(this.port));
-      
-      const pro = isPro();
-      console.log(`\n🚀 Lemma Proxy v${VERSION} — ${pro ? 'PRO' : 'STANDARD'}`);
-      console.log(`📁 Project : ${this.projectName}\n🔌 Port    : ${this.port}`);
-      
-      console.log('\n🧠 Intelligence Report');
-      console.log('────────────────────────────────────────────────');
-      console.log(`🔒 Privacy Firewall      : \x1b[32m[ACTIVE]\x1b[0m`);
-      console.log(`🔀 Complexity Router     : \x1b[32m[ACTIVE]\x1b[0m`);
-      console.log(`💾 Exact Cache           : \x1b[32m[ACTIVE]\x1b[0m`);
-      
-      const ollamaOk = await checkDependency('http://localhost:11434/api/tags');
-      const chromaOk = await checkDependency('http://localhost:8000/'); // Basic check for Chroma
-      
-      if (pro) {
-        console.log(`🎯 Semantic Cache        : ${ollamaOk && chromaOk ? '\x1b[32m[ACTIVE]\x1b[0m' : '\x1b[33m[OFFLINE - Check Ollama/Chroma]\x1b[0m'}`);
-        console.log(`🌐 Hive Mind (Cloud)     : \x1b[32m[ACTIVE]\x1b[0m`);
-      } else {
-        console.log(`🎯 Semantic Cache        : \x1b[90m[PRO ONLY]\x1b[0m -> https://lemma.nxus.studio/upgrade`);
-        console.log(`🌐 Hive Mind (Cloud)     : \x1b[90m[PRO ONLY]\x1b[0m -> https://lemma.nxus.studio/upgrade`);
-      }
-      
-      const hasStackDir = fs.existsSync(path.join(process.cwd(), '.lemma'));
-      console.log(`📡 Telepathic Sync       : ${hasStackDir ? '\x1b[32m[READY]\x1b[0m' : '\x1b[90m[DISABLED - Run "lemma init"]\x1b[0m'}`);
-      console.log('────────────────────────────────────────────────\n');
-      
-      if (!pro) {
-        console.log('\x1b[36m💡 Unlock Semantic Search & Team Caching at https://lemma.nxus.studio/upgrade\x1b[0m\n');
-      }
-    });
-    process.on('SIGTERM', () => server.close());
-  }
-}
-
-// ── CLI ────────────────────────────────────────────────────────────────────────
-program.name('lemma').description('Lemma Proxy CLI — Intelligent AI Gateway').version(VERSION);
-
-program.command('start')
-  .description('Start the proxy server')
-  .option('-p, --port <number>', 'Port to listen on', '8081')
-  .option('--project <name>', 'Override project name')
-  .option('--stack', 'Launch full development stack (Chroma + Router + Dashboard)')
-  .action(async (opts) => {
-    const port = parseInt(opts.port, 10);
-    
-    // Check if already running
-    try {
-      const resp = await axios.get(`http://localhost:${port}/health`, { timeout: 500 });
-      if (resp.data && resp.data.status === 'ok') {
-        console.log(`\n⚠️  Lemma Proxy is already running on port ${port} (Project: ${resp.data.project})`);
-        console.log(`💡 Use 'lemma status' for details or 'lemma stop' to restart.\n`);
-        process.exit(0);
-      }
-    } catch {}
-
-    if (opts.stack) {
-      const { spawn } = require('child_process');
-      console.log('🚀 Launching Lemma Full Stack...');
-
-      // 1. Start Chroma
-      const chroma = spawn('chroma', ['run', '--path', './chroma_data'], { stdio: 'ignore', detached: true });
-      chroma.unref();
-      console.log('   ✅ ChromaDB requested');
-
-      // 2. Start Dashboard
-      // Use port 8082 to avoid conflicts
-      const dash = spawn('npm', ['run', 'dev', '--prefix', 'dashboard', '--', '--port', '8082'], { stdio: 'ignore', detached: true });
-      dash.unref();
-      console.log('   ✅ Dashboard requested (http://localhost:8082)');
-
-      // 3. Start Router (using internal script)
-      console.log('   🚀 Starting Router & Proxy...\n');
-      
-      // Fallback for dev/package mode
-      const stackScript = fs.existsSync(path.join(__dirname, 'dist', 'cjs', 'cli', 'stack.js'))
-        ? path.join(__dirname, 'dist', 'cjs', 'cli', 'stack.js')
-        : (fs.existsSync(path.join(__dirname, 'src', 'cli', 'stack.ts')) ? 'src/cli/stack.ts' : null);
-
-      if (!stackScript) {
-        console.error('❌ Error: Could not find Lemma Stack script. Reinstall the package.');
-        process.exit(1);
-      }
-
-      const routerCmd = stackScript.endsWith('.ts') ? ['npx', 'tsx', stackScript] : ['node', stackScript];
-      const router = spawn(routerCmd[0], routerCmd.slice(1), { 
-        stdio: 'inherit',
-        env: { ...process.env, WS_PORT: '8080', DASHBOARD_API_PORT: '8083' } 
-      });
-
-      // Start Proxy Server alongside
-      const server = new LemmaServer(port, opts.project || null);
-      server.start();
-
-      router.on('exit', (code) => {
-        console.log(`\n🛑 Router exited with code ${code}`);
-        process.exit(code || 0);
-      });
-    } else {
-      const server = new LemmaServer(port, opts.project || null);
-      server.start();
-    }
-  });
-
-program.command('stop')
-  .description('Stop the proxy server')
-  .option('-p, --port <number>', 'Port to check', '8081')
-  .action((opts) => {
-    const port = parseInt(opts.port, 10);
-    let stopped = false;
-    try {
-      if (fs.existsSync(PID_FILE)) {
-        const pid = fs.readFileSync(PID_FILE, 'utf8');
-        try {
-          process.kill(parseInt(pid), 'SIGTERM');
-          stopped = true;
-        } catch {}
-      }
-      
-      if (!stopped) {
-        const pidByPort = getPidByPort(port);
-        if (pidByPort) {
-          process.kill(parseInt(pidByPort), 'SIGTERM');
-          console.log(`✅ Stopped process ${pidByPort} on port ${port}`);
-          stopped = true;
-        }
-      }
-
-      if (stopped) {
-        console.log('✅ Stopped');
-      } else {
-        console.log('⚠️  No running process found.');
-      }
-    } catch { console.log('⚠️  Could not stop process.'); }
-    if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
-  });
-
-program.command('status')
-  .description('Check proxy status')
-  .action(async () => {
-    const port = fs.existsSync(PORT_FILE) ? fs.readFileSync(PORT_FILE, 'utf8') : '8081';
-    try {
-      const resp = await axios.get(`http://localhost:${port}/health`, { timeout: 1000 });
-      if (resp.data && resp.data.status === 'ok') {
-        console.log(`✅ Running (Project: ${resp.data.project}, Port: ${port})`);
-      } else {
-        console.log('❌ Stopped (Health check failed)');
-      }
-    } catch {
-      console.log('❌ Stopped');
-      if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
-    }
-  });
-
-program.command('stats')
-  .description('Show usage statistics')
-  .action(() => {
-    const stats = loadStats();
-    const usage = loadUsage();
-    const project = detectProject();
-    const s = stats[project] || { total:0, hits:0, misses:0, totalLatency:0, totalTokensSaved:0 };
-    
-    console.log(`\n📊 Lemma Stats for [${project}]`);
-    console.log(`──────────────────────────────────`);
-    console.log(`Total Requests : ${s.total}`);
-    console.log(`Cache Hits     : ${s.hits} (${((s.hits/s.total||0)*100).toFixed(1)}%)`);
-    console.log(`Tokens Saved   : ${s.totalTokensSaved.toLocaleString()}`);
-    console.log(`Avg Latency    : ${(s.totalLatency/(s.total||1)).toFixed(2)}ms`);
-    console.log(`Tier           : ${isPro() ? 'PRO' : 'FREE'}`);
-    if (!isPro()) console.log(`Free Usage     : ${usage.count}/${FREE_LIMIT} requests`);
-    console.log(`──────────────────────────────────\n`);
-  });
-
-program.command('activate <key>')
-  .description('Activate Pro features with a license key')
-  .action(async (key) => {
-    console.log('🔑 Validating license key...');
-    try {
-      const res = await validateKeyRemote(key);
-      if (res.valid) {
-        writeJson(LICENSE_FILE, { key, isPro: true, activatedAt: new Date().toISOString() });
-        console.log('✅ License activated! Enjoy Pro features.');
-      } else {
-        console.log('❌ Invalid license key.');
-      }
-    } catch (e) {
-      console.error('❌ Error validating key:', e.message);
-    }
-  });
-
-program.command('init')
-  .description('Initialize Lemma in the current project (auto-discovery)')
-  .action(() => {
-    const project = detectProject();
-    console.log(`\n🛠️  Initializing Lemma for [${project}]...`);
-    
-    // 1. Create .lemma directory
-    const lemmaDir = path.join(process.cwd(), '.lemma');
-    if (!fs.existsSync(lemmaDir)) {
-      fs.mkdirSync(lemmaDir, { recursive: true });
-      console.log('✅ Created .lemma directory (Telepathic Sync enabled)');
-    }
-
-    // 2. Update .gitignore
-    if (ensureGitIgnore()) {
-      console.log('✅ Added .lemma/ to .gitignore');
-    }
-
-    // 3. Update .env
-    const envFile = path.join(process.cwd(), '.env');
-    const lemmaConfig = `\n# Lemma AI Gateway Configuration\nOPENAI_BASE_URL=http://localhost:8081/v1\nLEMMA_PROJECT=${project}\n`;
-    
-    if (fs.existsSync(envFile)) {
-      const content = fs.readFileSync(envFile, 'utf8');
-      if (content.includes('OPENAI_BASE_URL')) {
-        console.log('⚠️  OPENAI_BASE_URL already exists in .env. Update it to: http://localhost:8081/v1');
-      } else {
-        fs.appendFileSync(envFile, lemmaConfig);
-        console.log('✅ Added Lemma configuration to .env');
-      }
-    } else {
-      fs.writeFileSync(envFile, lemmaConfig);
-      console.log('✅ Created .env with Lemma configuration');
-    }
-    
-    console.log('\n✨ Project initialized for the Agentic Era!');
-    console.log('🚀 Run "lemma start" to begin.\n');
-  });
-
-program.parse(process.argv);