@nxuss/lemma 0.9.3 → 1.0.0

package/README.md

@@ -1,4 +1,4 @@
-# 🧠 Lemma v0.9.3
+# 🧠 Lemma v1.0.0
 
 [![npm version](https://img.shields.io/npm/v/@nxuss/lemma.svg?color=orange&style=flat-square)](https://www.npmjs.com/package/@nxuss/lemma)
 [![License](https://img.shields.io/npm/l/@nxuss/lemma.svg?color=blue&style=flat-square)](https://github.com/Nxusbets/lemma/blob/main/LICENSE)
@@ -45,8 +45,8 @@ Lemma is a high-performance orchestration layer that sits between your developme
 
 ## ⚡ What's in the Pro MCP
 
-### 🧠 Shared Semantic Memory — The Brain
-Lemma maintains a persistent vector database (ChromaDB) that accumulates knowledge across all your projects. Every solution, bug fix, and architecture decision you work through gets stored and semantically indexed. Future sessions can retrieve this knowledge in milliseconds — no cloud, no tokens, no re-explaining.
+### 🧠 Shared Semantic Memory — The Brain (Zero-Dependency)
+Lemma maintains a persistent semantic cache index (`TheBrainV2`) using Okapi BM25 + Jaccard re-ranking and Bloom Filters that runs entirely on your local machine with NO external ML dependencies (no ChromaDB, no Ollama required). Every solution, bug fix, and architecture decision you work through gets stored and semantically indexed globally across all your projects. Future sessions can retrieve this knowledge in milliseconds (<10ms) — saving you thousands of tokens.
 
 ### 🛡️ Privacy Firewall (Semantic Scrubber)
 **Enterprise-Grade Privacy.** Prevents API keys, credentials, and PII from ever leaving your machine. Applied automatically to every file read and workspace search via MCP.
@@ -117,6 +117,21 @@ Exposes `write_workspace_file`, smart `apply_workspace_patch` (collision-safe se
 ### 🩺 AutoPilot & Auto-Heal
 Lemma's background file watcher detects TypeScript compilation errors on every save, parses the error, and calls the auto-heal agent to apply a fix — automatically. When Autopilot succeeds, the fix is stored in The Brain for future sessions.
 
+### 🧬 `get_symbol_surgical_context` — Surgical Symbol Context *(NEW in v1.0.0)*
+**Saves up to 90% input tokens.** Instead of reading complete dependency source files, this tool parses your workspace via TS Compiler AST and extracts ONLY the targeted symbol implementation along with the precise function/class signatures of all its direct workspace imports. 
+
+### ⚙️ `surgical_ast_insert` — AST Surgical Code Injector *(NEW in v1.0.0)*
+**Saves up to 95% output tokens.** Removes the need for the LLM to output massive file diffs or rewrite entire files. The LLM only outputs the exact function snippet, and Lemma compiles it surgically into the class/scope AST at the specified anchor point.
+
+### 🩹 `local_semantic_autofix` — Offline Self-Healing *(NEW in v1.0.0)*
+**Resolves compilation/runtime crashes in <15ms with 0 tokens.** When your tests or compilers crash, Lemma queries the global error index in `TheBrainV2`. If a matching traceback fix is found in memory (solved in this or any other repo on your machine), it applies the resolution instantly.
+
+### 💰 `generate_executive_roi_report` — Corporate ROI Ledger *(NEW in v1.0.0)*
+Generates a complete executive Markdown/PDF-ready report of total direct API dollars saved, developer hours reclaimed from caching, security masking events, and scalability financial projections for engineering managers.
+
+### 🌀 `wormhole_squeeze` — Reversible Code Compression *(NEW in v1.0.0)*
+Compresses your source code using non-colliding mathematical unicode symbols (like `⨃`, `⨂`, `⨁`) and temporary aliases to shrink file sizes by up to 70% while keeping it 100% reversible.
+
 ---
 
 ## 🚀 Quick Start (Zero Config)

package/bin/cli.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const LEMMA_CACHE = path.join(os.homedir(), '.lemma-cache');
+const BRAIN_FILE = path.join(LEMMA_CACHE, 'lemma_brain.json');
+const PORT = process.env.LEMMA_PROXY_PORT || '9090';
+
+const INPUT_COST = 3.00 / 1000000;
+const OUTPUT_COST = 15.00 / 1000000;
+const C = '\x1b[36m', G = '\x1b[32m', Y = '\x1b[33m', D = '\x1b[2m', R = '\x1b[0m', B = '\x1b[1m';
+
+function loadBrain() {
+  try {
+    if (fs.existsSync(BRAIN_FILE)) return JSON.parse(fs.readFileSync(BRAIN_FILE, 'utf8'));
+  } catch {}
+  return null;
+}
+
+function daemonStatus() {
+  try {
+    const isMac = process.platform === 'darwin';
+    if (isMac) {
+      execSync('launchctl list com.lemma.cache-proxy 2>/dev/null || true', { stdio: 'pipe' });
+      return 'running';
+    }
+    if (process.platform === 'linux') {
+      execSync('systemctl --user is-active lemma-cache-proxy 2>/dev/null || true', { stdio: 'pipe' });
+      return 'running';
+    }
+  } catch {}
+  try {
+    const port = PORT;
+    const http = require('http');
+    return new Promise(resolve => {
+      const req = http.get(`http://localhost:${port}/v1/models`, res => resolve('running'));
+      req.on('error', () => resolve('stopped'));
+      req.setTimeout(1000, () => { req.destroy(); resolve('stopped'); });
+    });
+  } catch { return 'unknown'; }
+}
+
+async function main() {
+  const brain = loadBrain();
+  const daemon = await daemonStatus();
+
+  process.stderr.write(`\n  ${B}${C}═══ Lemma Cache Dashboard ═══${R}\n\n`);
+
+  const statusColor = daemon === 'running' ? G : Y;
+  process.stderr.write(`  ${C}Proxy:${R}       :${PORT} ${statusColor}${daemon === 'running' ? '● running' : '○ stopped'}${R}\n`);
+  process.stderr.write(`  ${C}MCP Server:${R}   lemma mcp\n`);
+  process.stderr.write(`  ${C}Env File:${R}     ${D}${LEMMA_CACHE}/env${R}\n\n`);
+
+  if (!brain || brain.length === 0) {
+    process.stderr.write(`  ${Y}The Brain is empty.${R} Start using your tools with the cache proxy.\n`);
+    process.stderr.write(`  ${D}Every cached response saves tokens and money.${R}\n\n`);
+    return;
+  }
+
+  let totalHits = 0, totalInputTokens = 0, totalOutputTokens = 0;
+  for (const e of brain) {
+    const hits = e.hits || 0;
+    totalHits += hits;
+    totalInputTokens += Math.ceil((e.prompt || '').length / 4) * (hits + 1);
+    totalOutputTokens += Math.ceil((e.response || '').length / 4) * (hits + 1);
+  }
+
+  const firstInput = Math.ceil(brain.reduce((s, e) => s + (e.prompt || '').length, 0) / 4);
+  const firstOutput = Math.ceil(brain.reduce((s, e) => s + (e.response || '').length, 0) / 4);
+  const avoidedInput = totalInputTokens - firstInput;
+  const avoidedOutput = totalOutputTokens - firstOutput;
+  const totalTokens = avoidedInput + avoidedOutput;
+  const moneySaved = avoidedInput * INPUT_COST + avoidedOutput * OUTPUT_COST;
+
+  process.stderr.write(`  ${C}Entries:${R}       ${brain.length}\n`);
+  process.stderr.write(`  ${C}Cache Hits:${R}    ${totalHits}\n`);
+
+  const fmt = (n) => n >= 1000000 ? (n/1000000).toFixed(2) + 'M' : n >= 1000 ? (n/1000).toFixed(1) + 'K' : n;
+  process.stderr.write(`  ${C}Tokens Saved:${R}  ${fmt(totalTokens)} (in:${fmt(avoidedInput)} out:${fmt(avoidedOutput)})\n`);
+  process.stderr.write(`  ${G}Money Saved:${R}   $${moneySaved.toFixed(4)}\n\n`);
+
+  const top = [...brain].sort((a, b) => (b.hits||0) - (a.hits||0)).slice(0, 5);
+  if (top.length > 0 && top[0].hits > 0) {
+    process.stderr.write(`  ${Y}Top Hits:${R}\n`);
+    for (let i = 0; i < top.length; i++) {
+      const preview = (top[i].prompt || '').replace(/\n/g, ' ').substring(0, 55);
+      process.stderr.write(`  ${D}${i+1}.${R} ${top[i].hits}x  ${preview}${preview.length >= 55 ? '...' : ''}\n`);
+    }
+  }
+  process.stderr.write(`\n  ${D}Pricing: Claude 3.5 Sonnet — Input $3/M, Output $15/M${R}\n\n`);
+}
+
+main().catch(() => {});

package/bin/init.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync, spawn } = require('child_process');
+
+const LEMMA_CACHE = path.join(os.homedir(), '.lemma-cache');
+const BRAIN_FILE = path.join(LEMMA_CACHE, 'lemma_brain.json');
+const ENV_FILE = path.join(LEMMA_CACHE, 'env');
+const MCP_SERVER_PATH = path.join(__dirname, '..', 'mcp-server.js');
+const PROXY_PATH = path.join(__dirname, '..', 'cache-proxy.js');
+const PORT = '9090';
+const CYAN = '\x1b[36m', GREEN = '\x1b[32m', YELLOW = '\x1b[33m', DIM = '\x1b[2m', RESET = '\x1b[0m', BOLD = '\x1b[1m';
+
+function ensureDir(p) { try { fs.mkdirSync(p, { recursive: true }); } catch {} }
+
+function step(msg) { process.stderr.write(`  ${CYAN}✦${RESET} ${msg}\n`); }
+
+function ok(msg) { process.stderr.write(`  ${GREEN}✓${RESET} ${msg}\n`); }
+
+function skip(msg) { process.stderr.write(`  ${DIM}−${RESET} ${DIM}${msg}${RESET}\n`); }
+
+function warn(msg) { process.stderr.write(`  ${YELLOW}⚠${RESET} ${msg}\n`); }
+
+function detectTool(name, checkFn) {
+  try {
+    const result = checkFn();
+    return result || !!result;
+  } catch { return false; }
+}
+
+function configureContinueDotDev() {
+  const configDir = path.join(os.homedir(), '.continue');
+  const configFile = path.join(configDir, 'config.json');
+  if (!fs.existsSync(configFile)) return false;
+
+  try {
+    let config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    if (!config.models) config.models = [];
+    const already = config.models.some(m => m.apiBase === `http://localhost:${PORT}`);
+    if (!already) {
+      config.models.push({
+        title: 'Lemma Cache Proxy',
+        provider: 'openai',
+        model: 'ANY',
+        apiBase: `http://localhost:${PORT}`,
+        apiKey: 'sk-lemma-cache-proxy',
+        description: 'Automatic BM25 semantic cache — local, zero-cost on hits'
+      });
+      fs.writeFileSync(configFile, JSON.stringify(config, null, 2), 'utf8');
+    }
+    return true;
+  } catch { return false; }
+}
+
+function configureCursor() {
+  const cursorDir = path.join(os.homedir(), '.cursor');
+  const settingsFile = path.join(cursorDir, 'settings.json');
+  try {
+    let settings = {};
+    if (fs.existsSync(settingsFile)) {
+      settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+    }
+    settings['openai.apiBase'] = `http://localhost:${PORT}`;
+    fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2), 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function configureOpenCodeMcp() {
+  const configDir = path.join(os.homedir(), '.opencode');
+  const configFile = path.join(configDir, 'mcp.json');
+  ensureDir(configDir);
+  let config = {};
+  try {
+    if (fs.existsSync(configFile)) config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+  } catch {}
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers['lemma-mcp-server'] = {
+    command: 'node', args: [MCP_SERVER_PATH], type: 'local', enabled: true
+  };
+  fs.writeFileSync(configFile, JSON.stringify(config, null, 2), 'utf8');
+
+  const localOpenCode = path.join(process.cwd(), 'opencode.json');
+  if (fs.existsSync(localOpenCode)) {
+    try {
+      const lc = JSON.parse(fs.readFileSync(localOpenCode, 'utf8'));
+      if (!lc.mcp) lc.mcp = {};
+      if (!lc.mcp['lemma-mcp-server']) {
+        lc.mcp['lemma-mcp-server'] = {
+          type: 'local', command: ['node', MCP_SERVER_PATH], enabled: true
+        };
+        fs.writeFileSync(localOpenCode, JSON.stringify(lc, null, 2), 'utf8');
+      }
+    } catch {}
+  }
+  return true;
+}
+
+function configureClaudeDesktop() {
+  const configDir = path.join(os.homedir(), '.lemma-cache');
+  const configFile = path.join(configDir, 'claude_mcp.json');
+  let config = {};
+  try {
+    if (fs.existsSync(configFile)) config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+  } catch {}
+  if (!config.mcpServers) config.mcpServers = {};
+  config.mcpServers['lemma-mcp-server'] = {
+    command: 'node', args: [MCP_SERVER_PATH]
+  };
+  fs.writeFileSync(configFile, JSON.stringify(config, null, 2), 'utf8');
+  return true;
+}
+
+function installProxyDaemon() {
+  const isMac = process.platform === 'darwin';
+  const isLinux = process.platform === 'linux';
+
+  if (isMac) {
+    const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    ensureDir(plistDir);
+    const plistPath = path.join(plistDir, 'com.lemma.cache-proxy.plist');
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.lemma.cache-proxy</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${PROXY_PATH}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>WorkingDirectory</key><string>${os.homedir()}</string>
+  <key>StandardOutPath</key><string>${LEMMA_CACHE}/proxy-daemon.log</string>
+  <key>StandardErrorPath</key><string>${LEMMA_CACHE}/proxy-daemon.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>LEMMA_PROXY_PORT</key><string>${PORT}</string>
+    <key>LEMMA_CACHE_DIR</key><string>${LEMMA_CACHE}</string>
+  </dict>
+</dict>
+</plist>`;
+    fs.writeFileSync(plistPath, plist, 'utf8');
+    try { execSync('launchctl load ' + plistPath, { stdio: 'ignore' }); } catch {}
+    return true;
+  }
+
+  if (isLinux) {
+    const svcDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+    ensureDir(svcDir);
+    const svc = `[Unit]
+Description=Lemma Cache Proxy
+After=network.target
+
+[Service]
+ExecStart=${process.execPath} ${PROXY_PATH}
+Restart=always
+RestartSec=3
+Environment=LEMMA_PROXY_PORT=${PORT}
+Environment=LEMMA_CACHE_DIR=${LEMMA_CACHE}
+
+[Install]
+WantedBy=default.target
+`;
+    const svcPath = path.join(svcDir, 'lemma-cache-proxy.service');
+    fs.writeFileSync(svcPath, svc, 'utf8');
+    try { execSync('systemctl --user daemon-reload && systemctl --user enable lemma-cache-proxy && systemctl --user start lemma-cache-proxy', { stdio: 'ignore' }); } catch {}
+    return true;
+  }
+
+  return false;
+}
+
+function applyEnvToCurrentProcess() {
+  const proxyUrl = `http://localhost:${PORT}`;
+  process.env.LEMMA_PROXY_PORT = PORT;
+  process.env.LEMMA_CACHE_DIR = LEMMA_CACHE;
+  process.env.OPENAI_BASE_URL = proxyUrl;
+  process.env.OPENAI_API_BASE = proxyUrl;
+  process.env.CODEX_BASE_URL = proxyUrl;
+  process.env.LITELLM_PROXY_BASE_URL = proxyUrl;
+}
+
+function createEnvFile() {
+  const proxyUrl = `http://localhost:${PORT}`;
+  const envContent = `# Lemma Cache Proxy — Auto-generated by \`lemma init\`
+# Source this file in your shell to route LLM traffic through the cache:
+#   source ${ENV_FILE}
+export LEMMA_PROXY_PORT=${PORT}
+export LEMMA_CACHE_DIR=${LEMMA_CACHE}
+export OPENAI_BASE_URL=${proxyUrl}
+export OPENAI_API_BASE=${proxyUrl}
+export CODEX_BASE_URL=${proxyUrl}
+export LITELLM_PROXY_BASE_URL=${proxyUrl}
+`;
+  fs.writeFileSync(ENV_FILE, envContent, 'utf8');
+  applyEnvToCurrentProcess();
+  return ENV_FILE;
+}
+
+function setupShellIntegration() {
+  const rcFiles = [
+    { file: path.join(os.homedir(), '.zshrc'), name: 'zsh' },
+    { file: path.join(os.homedir(), '.bashrc'), name: 'bash' },
+    { file: path.join(os.homedir(), '.config', 'fish', 'config.fish'), name: 'fish' }
+  ];
+
+  const sourceLine = `\n# Lemma Cache Proxy — auto-configured by \`lemma init\`\n[ -f "${ENV_FILE}" ] && . "${ENV_FILE}"\n`;
+
+  let configured = false;
+  for (const rc of rcFiles) {
+    if (fs.existsSync(rc.file)) {
+      const content = fs.readFileSync(rc.file, 'utf8');
+      if (content.includes('lemma-cache/env')) { configured = true; continue; }
+      fs.appendFileSync(rc.file, sourceLine, 'utf8');
+      configured = true;
+    }
+  }
+
+  const fallback = path.join(os.homedir(), '.zshrc');
+  if (!fs.existsSync(fallback)) {
+    ensureDir(path.dirname(fallback));
+    fs.writeFileSync(fallback, sourceLine, 'utf8');
+    configured = true;
+  }
+
+  try {
+    if (process.platform === 'darwin') {
+      execSync(`launchctl setenv OPENAI_BASE_URL http://localhost:${PORT}`, { stdio: 'ignore' });
+      execSync(`launchctl setenv CODEX_BASE_URL http://localhost:${PORT}`, { stdio: 'ignore' });
+    }
+  } catch {}
+
+  return configured;
+}
+
+async function main() {
+  process.stderr.write(`\n  ${BOLD}${CYAN}Lemma Init — Magic Setup${RESET}\n\n`);
+
+  ensureDir(LEMMA_CACHE);
+  if (!fs.existsSync(BRAIN_FILE)) {
+    fs.writeFileSync(BRAIN_FILE, '[]', 'utf8');
+  }
+  ok(`Cache directory: ~/.lemma-cache`);
+  ok(`Brain file: ~/.lemma-cache/lemma_brain.json`);
+
+  configureOpenCodeMcp();
+  ok('OpenCode MCP configured');
+
+  configureClaudeDesktop();
+  ok('Claude MCP configured');
+
+  const hasContinue = detectTool('Continue.dev', () => configureContinueDotDev());
+  if (hasContinue) ok('Continue.dev configured');
+  else skip('Continue.dev not detected');
+
+  const hasCursor = detectTool('Cursor', () => fs.existsSync(path.join(os.homedir(), '.cursor')));
+  if (hasCursor) {
+    const configured = configureCursor();
+    if (configured) ok('Cursor configured');
+    else warn('Cursor detected but config could not be auto-updated');
+  } else skip('Cursor not detected');
+
+  const hasCodex = detectTool('Codex CLI', () => {
+    try { execSync('which codex', { stdio: 'ignore' }); return true; } catch { return false; }
+  });
+  if (hasCodex) ok('Codex CLI detected — set OPENAI_BASE_URL env (auto-configured below)');
+  else skip('Codex CLI not detected');
+
+  const hasWindsurf = detectTool('Windsurf', () => fs.existsSync(path.join(os.homedir(), '.windsurfrules')));
+  if (hasWindsurf) ok('Windsurf detected — env auto-configured');
+  else skip('Windsurf not detected');
+
+  const daemonOk = installProxyDaemon();
+  if (daemonOk) ok('Cache proxy daemon installed & started');
+  else warn('Could not install daemon — run `lemma proxy` manually');
+
+  const envFile = createEnvFile();
+  ok(`Env file created: ${envFile}`);
+
+  const shellOk = setupShellIntegration();
+  if (shellOk) ok('Shell rc files updated (source ~/.lemma-cache/env)');
+  else warn('Could not update shell rc — source manually: source ~/.lemma-cache/env');
+
+  process.stderr.write(`\n  ${BOLD}${GREEN}✓ Lemma init complete${RESET}\n`);
+  process.stderr.write(`  ${DIM}──────────────────────────────────────${RESET}\n`);
+  process.stderr.write(`  ${GREEN}●${RESET} Cache proxy running on http://localhost:${PORT}\n`);
+  process.stderr.write(`  ${GREEN}●${RESET} MCP server ready  ${DIM}(lemma mcp)${RESET}\n`);
+  process.stderr.write(`  ${GREEN}●${RESET} Dashboard active  ${DIM}(lemma stats)${RESET}\n`);
+  process.stderr.write(`  ${GREEN}●${RESET} New terminals: env vars auto-loaded\n`);
+  process.stderr.write(`  ${GREEN}●${RESET} Todos los IDE/CLI nuevos ya apuntan al proxy\n`);
+  process.stderr.write(`  ${DIM}──────────────────────────────────────${RESET}\n`);
+  process.stderr.write(`  ${YELLOW}Para activar en ESTA terminal:${RESET}\n`);
+  process.stderr.write(`  ${BOLD}source ${ENV_FILE}${RESET}\n`);
+  process.stderr.write(`  ${DIM}Logs: ${LEMMA_CACHE}/proxy-daemon.log${RESET}\n\n`);
+}
+
+main().catch(e => {
+  console.error('init failed:', e.message);
+  process.exit(1);
+});

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'));