@nxuss/lemma 0.9.2 → 1.0.0

package/cache-proxy.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PORT = parseInt(process.env.LEMMA_PROXY_PORT || '9090', 10);
+const UPSTREAM = process.env.LEMMA_UPSTREAM || 'https://api.openai.com';
+const API_KEY = process.env.LEMMA_API_KEY || process.env.OPENAI_API_KEY || '';
+const BRAIN_FILE = path.join(os.homedir(), '.lemma-cache', 'lemma_brain.json');
+
+function loadBrain() {
+  try {
+    if (!fs.existsSync(BRAIN_FILE)) {
+      fs.mkdirSync(path.dirname(BRAIN_FILE), { recursive: true });
+      fs.writeFileSync(BRAIN_FILE, '[]', 'utf8');
+      return [];
+    }
+    return JSON.parse(fs.readFileSync(BRAIN_FILE, 'utf8'));
+  } catch (e) {
+    console.error('[cache-proxy] Failed to load brain:', e.message);
+    return [];
+  }
+}
+
+function saveBrain(data) {
+  try {
+    fs.mkdirSync(path.dirname(BRAIN_FILE), { recursive: true });
+    fs.writeFileSync(BRAIN_FILE, JSON.stringify(data), 'utf8');
+  } catch (e) {
+    console.error('[cache-proxy] Failed to save brain:', e.message);
+  }
+}
+
+const STOP_WORDS = new Set(['the','a','an','is','are','was','were','be','been','being','have','has','had','do','does','did','will','would','could','should','may','might','shall','can','need','dare','ought','used','to','of','in','for','on','with','at','by','from','as','into','through','during','before','after','above','below','between','out','off','over','under','again','further','then','once','here','there','when','where','why','how','all','each','every','both','few','more','most','other','some','such','no','nor','not','only','own','same','so','than','too','very','just','because','but','and','or','if','while','although','since','until','unless','about','up','it','its','this','that','these','those','i','me','my','myself','we','our','ours','ourselves','you','your','yours','yourself','yourselves','he','him','his','himself','she','her','hers','herself','they','them','their','theirs','themselves','what','which','who','whom','this']);
+
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, '').split(/\s+/).filter(w => w.length > 1 && !STOP_WORDS.has(w));
+}
+
+function idf(corpusTokens) {
+  const df = {}, N = corpusTokens.length;
+  for (const tokens of corpusTokens) {
+    const seen = new Set(tokens);
+    for (const t of seen) df[t] = (df[t] || 0) + 1;
+  }
+  const scores = {};
+  for (const [t, count] of Object.entries(df)) scores[t] = Math.log(1 + (N - count + 0.5) / (count + 0.5));
+  return scores;
+}
+
+function bm25(queryTokens, docTokens, idfScores, avgDocLen) {
+  const k1 = 1.5, b = 0.75;
+  let score = 0;
+  const docLen = docTokens.length;
+  const tf = {};
+  for (const t of docTokens) tf[t] = (tf[t] || 0) + 1;
+  for (const q of queryTokens) {
+    const f = tf[q] || 0;
+    const idfVal = idfScores[q] || 0;
+    if (f === 0) continue;
+    score += idfVal * ((f * (k1 + 1)) / (f + k1 * (1 - b + b * (docLen / avgDocLen))));
+  }
+  return score;
+}
+
+function buildIndex(entries) {
+  if (!entries || entries.length === 0) return { corpusTokens: [], idfScores: {}, avgDocLen: 0 };
+  const corpusTokens = entries.map(e => tokenize(e.prompt || ''));
+  const avgDocLen = corpusTokens.reduce((s, t) => s + t.length, 0) / corpusTokens.length;
+  return { corpusTokens, idfScores: idf(corpusTokens), avgDocLen };
+}
+
+function search(entries, query, threshold) {
+  if (!entries || entries.length === 0) return [];
+  const qt = tokenize(query);
+  if (qt.length === 0) return [];
+  const idx = buildIndex(entries);
+  const maxScore = bm25(qt, qt, idx.idfScores, idx.avgDocLen);
+  return entries.map((e, i) => {
+    const raw = bm25(qt, idx.corpusTokens[i], idx.idfScores, idx.avgDocLen);
+    return { entry: e, similarity: maxScore > 0 ? raw / maxScore : 0, index: i };
+  }).filter(r => r.similarity >= threshold).sort((a, b) => b.similarity - a.similarity);
+}
+
+function extractPrompt(body) {
+  try {
+    if (body.messages) {
+      return body.messages.map(m => `${m.role}: ${m.content}`).join('\n');
+    }
+    if (body.prompt) return body.prompt;
+    if (body.input) return typeof body.input === 'string' ? body.input : JSON.stringify(body.input);
+  } catch {}
+  return JSON.stringify(body).substring(0, 500);
+}
+
+function extractResponse(data) {
+  try {
+    if (data.choices && data.choices[0]) {
+      return data.choices[0].message?.content || data.choices[0].text || JSON.stringify(data);
+    }
+    return JSON.stringify(data);
+  } catch { return JSON.stringify(data); }
+}
+
+function proxyRequest(body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(UPSTREAM + '/v1/chat/completions');
+    const data = JSON.stringify(body);
+    const opts = {
+      hostname: url.hostname, port: url.port || 443, path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Length': Buffer.byteLength(data)
+      }
+    };
+    const mod = url.protocol === 'https:' ? https : http;
+    const req = mod.request(opts, (res) => {
+      let chunks = '';
+      res.on('data', c => chunks += c);
+      res.on('end', () => {
+        try { resolve(JSON.parse(chunks)); }
+        catch { resolve({ choices: [{ message: { content: chunks } }] }); }
+      });
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+const server = http.createServer((req, res) => {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', '*');
+
+  if (req.method === 'OPTIONS') { res.writeHead(200); res.end(); return; }
+
+  let body = '';
+  req.on('data', c => body += c);
+  req.on('end', async () => {
+    try {
+      const parsed = JSON.parse(body);
+      const prompt = extractPrompt(parsed);
+
+      if (req.url === '/v1/chat/completions' && prompt) {
+        const brain = loadBrain();
+        const results = search(brain, prompt, 0.85);
+
+        if (results.length > 0) {
+          const hit = results[0];
+          brain[hit.index].hits = (brain[hit.index].hits || 0) + 1;
+          saveBrain(brain);
+          const cached = JSON.parse(hit.entry.response);
+          console.error(`[cache-proxy] HIT (${(hit.similarity * 100).toFixed(1)}%) — returning cached (${hit.entry.hits} hits)`);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(cached));
+          return;
+        }
+
+        console.error('[cache-proxy] MISS — forwarding to upstream');
+        const upstreamResp = await proxyRequest(parsed);
+        const responseText = extractResponse(upstreamResp);
+
+        brain.push({ prompt, response: responseText, hits: 0, createdAt: Date.now() });
+        saveBrain(brain);
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(upstreamResp));
+      } else {
+        res.writeHead(404); res.end('Not found');
+      }
+    } catch (e) {
+      console.error('[cache-proxy] Error:', e.message);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+  });
+});
+
+server.listen(PORT, () => {
+  console.error(`[cache-proxy] Lemma Cache Proxy on :${PORT}`);
+  console.error(`[cache-proxy] Upstream: ${UPSTREAM}`);
+  console.error(`[cache-proxy] Caching ANY provider via OpenAI-compatible endpoint`);
+  console.error(`[cache-proxy] Point your tool to: http://localhost:${PORT}/v1/chat/completions`);
+});

package/dist/cjs/cli/lemma-proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lemma-proxy.d.ts","sourceRoot":"","sources":["../../../src/cli/lemma-proxy.ts"],"names":[],"mappings":";AA2cA,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA4DvF;AAugED,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA6KhL"}
+{"version":3,"file":"lemma-proxy.d.ts","sourceRoot":"","sources":["../../../src/cli/lemma-proxy.ts"],"names":[],"mappings":";AA2cA,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA4DvF;AAogED,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA6KhL"}

package/dist/cjs/cli/lemma-proxy.js

@@ -2000,14 +2000,12 @@ Adjusted Answer:`;
             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/');
             if (pro) {
-                console.log(`🎯 Semantic Cache        : ${ollamaOk && chromaOk ? '\x1b[32m[ACTIVE]\x1b[0m' : '\x1b[33m[OFFLINE - Check Ollama/Chroma]\x1b[0m'}`);
+                console.log(`🎯 Semantic Cache        : \x1b[32m[ACTIVE - Local TheBrainV2 Okapi BM25 Engine]\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(`🎯 Semantic Cache        : \x1b[32m[ACTIVE - Local TheBrainV2 Okapi BM25 Engine]\x1b[0m`);
                 console.log(`🌐 Hive Mind (Cloud)     : \x1b[90m[PRO ONLY]\x1b[0m -> https://lemma.nxus.studio/upgrade`);
             }
             const hasStackDir = fs_1.default.existsSync(path_1.default.join(process.cwd(), '.lemma'));