@nxuss/lemma 0.3.0 → 0.3.1

package/lemma-proxy.cjs

@@ -0,0 +1,477 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Lemma Proxy v0.3.1 — 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 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() {
+  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/0.3.1' }
+    }, 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) ─────────────────────────────────────────────────────────
+const CACHE = new Map();
+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);
+    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 prompt = extractPrompt(req.body, provider);
+    if (!prompt) return res.status(400).json({ error:'Invalid request format' });
+
+    const model = req.body.model || 'gpt-4o';
+    const hit = cacheGet(prompt);
+    if (hit) {
+      recordStat(this.stats, this.projectName, true, Date.now()-t0, provider, 2000);
+      if (isStream) return simulateHitStream(res, hit.data, provider, model, tier, 1.0);
+      return res.json(hit.data);
+    }
+
+    if (pro) {
+      const semHit = await semanticGet(prompt);
+      if (semHit) {
+        recordStat(this.stats, this.projectName, true, Date.now()-t0, provider, 2000);
+        if (isStream) return simulateHitStream(res, semHit.data, provider, model, tier, semHit.similarity);
+        return res.json(semHit.data);
+      }
+    }
+
+    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);
+      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(data);
+    } 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.listen(this.port, () => {
+      fs.writeFileSync(PID_FILE, String(process.pid));
+      fs.writeFileSync(PORT_FILE, String(this.port));
+      console.log(`\n🚀 Lemma Proxy v0.3.1\n📁 Project : ${this.projectName}\n🔌 Port    : ${this.port}\n`);
+    });
+    process.on('SIGTERM', () => server.close());
+  }
+}
+
+// ── CLI ────────────────────────────────────────────────────────────────────────
+program.name('lemma').description('Lemma Proxy CLI').version('0.3.1');
+
+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);
+    
+    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
+      const dash = spawn('npm', ['run', 'dev', '--prefix', 'dashboard', '--', '--port', '3000'], { stdio: 'ignore', detached: true });
+      dash.unref();
+      console.log('   ✅ Dashboard requested (http://localhost:3000)');
+
+      // 3. Start Router (in the same process to see logs)
+      console.log('   🚀 Starting Router & Proxy...\n');
+      const router = spawn('npx', ['tsx', 'start-dev.ts'], { 
+        stdio: 'inherit',
+        env: { ...process.env, PORT: '8080' } 
+      });
+
+      // 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').action(() => {
+  try {
+    const pid = fs.readFileSync(PID_FILE, 'utf8');
+    process.kill(parseInt(pid), 'SIGTERM');
+    console.log('✅ Stopped');
+  } catch { console.log('⚠️  Not running'); }
+});
+program.command('status').action(() => console.log(fs.existsSync(PID_FILE) ? '✅ Running' : '❌ Stopped'));
+
+program.parse(process.argv);

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@nxuss/lemma",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Semantic cache for AI apps — stop paying for the same LLM call twice",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
   "bin": {
-    "lemma-proxy": "./lemma-proxy.js"
+    "lemma": "./lemma-proxy.cjs"
   },
   "exports": {
     ".": {
@@ -78,17 +78,17 @@
     "LICENSE"
   ],
   "scripts": {
-    "proxy:start": "node lemma-proxy.js start",
-    "proxy:stop": "node lemma-proxy.js stop",
-    "proxy:stats": "node lemma-proxy.js stats",
-    "proxy:status": "node lemma-proxy.js status",
+    "proxy:start": "node lemma-proxy.cjs start",
+    "proxy:stop": "node lemma-proxy.cjs stop",
+    "proxy:stats": "node lemma-proxy.cjs stats",
+    "proxy:status": "node lemma-proxy.cjs status",
     "build": "npm run build:esm && npm run build:cjs && npm run postbuild",
     "build:full": "npm run build && npm run build:sdks",
     "build:esm": "tsc --outDir ./dist/esm",
     "build:cjs": "tsc --project tsconfig.cjs.json",
     "build:sdks": "npm run sdk:build",
     "postbuild": "node scripts/post-build.js",
-    "dev": "ts-node start-dev.ts",
+    "dev": "npx tsx start-dev.ts",
     "start": "node dist/cjs/index.js",
     "test": "jest",
     "lint": "eslint src/**/*.ts",
@@ -150,6 +150,8 @@
   },
   "homepage": "https://github.com/Nxusbets/lemma#readme",
   "dependencies": {
+    "@chroma-core/default-embed": "^1.1.4",
+    "@nxuss/lemma": "^0.3.1",
     "@types/cors": "^2.8.19",
     "axios": "^1.6.0",
     "commander": "^14.0.3",