@nxuss/lemma 0.9.3 → 1.0.1

package/mcp-server.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BRAIN_FILE = path.join(os.homedir(), '.lemma-cache', 'lemma_brain.json');
+const INPUT_COST = 3.00 / 1000000;
+const OUTPUT_COST = 15.00 / 1000000;
+
+function loadBrain() {
+  try {
+    if (!fs.existsSync(BRAIN_FILE)) {
+      fs.mkdirSync(path.dirname(BRAIN_FILE), { recursive: true });
+      fs.writeFileSync(BRAIN_FILE, '[]', 'utf8');
+      return [];
+    }
+    const raw = fs.readFileSync(BRAIN_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch (e) {
+    console.error('[lemma-mcp] Failed to load brain, initializing empty:', 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('[lemma-mcp] Failed to save brain:', e.message);
+  }
+}
+
+function tokenize(text) {
+  const stopWords = 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']);
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, '').split(/\s+/).filter(w => w.length > 1 && !stopWords.has(w));
+}
+
+function idf(corpusTokens) {
+  const df = {};
+  const 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;
+  const 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;
+  const idfScores = idf(corpusTokens);
+  return { corpusTokens, idfScores, 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);
+  const results = entries.map((entry, i) => {
+    const raw = bm25(qt, idx.corpusTokens[i], idx.idfScores, idx.avgDocLen);
+    const similarity = maxScore > 0 ? raw / maxScore : 0;
+    return { entry, similarity, index: i };
+  }).filter(r => r.similarity >= threshold).sort((a, b) => b.similarity - a.similarity);
+  return results;
+}
+
+const tools = [
+  {
+    name: 'get_cached_solution',
+    description: 'Search the semantic cache (BM25) for a similar prompt. Hit >= 85% returns cached response.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'The prompt to search for' },
+        threshold: { type: 'number', description: 'Similarity threshold 0-1', default: 0.85 }
+      },
+      required: ['prompt']
+    }
+  },
+  {
+    name: 'store_cached_solution',
+    description: 'Store a prompt-response pair in the semantic cache for future lookups.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        prompt: { type: 'string', description: 'The prompt' },
+        response: { type: 'string', description: 'The response' }
+      },
+      required: ['prompt', 'response']
+    }
+  }
+];
+
+const toolHandlers = {
+  get_cached_solution: async (args) => {
+    const prompt = args.prompt;
+    const threshold = args.threshold || 0.85;
+    if (!prompt) throw new Error('prompt is required');
+    const brain = loadBrain();
+    const results = search(brain, prompt, threshold);
+    if (results.length > 0) {
+      const hit = results[0];
+      brain[hit.index].hits = (brain[hit.index].hits || 0) + 1;
+      saveBrain(brain);
+      return {
+        content: [{ type: 'text', text: JSON.stringify({
+          hit: true,
+          similarity: hit.similarity,
+          response: hit.entry.response,
+          hits: brain[hit.index].hits
+        }) }]
+      };
+    }
+    return { content: [{ type: 'text', text: JSON.stringify({ hit: false }) }] };
+  },
+  store_cached_solution: async (args) => {
+    const prompt = args.prompt;
+    const response = args.response;
+    if (!prompt || !response) throw new Error('prompt and response are required');
+    const brain = loadBrain();
+    brain.push({ prompt, response, hits: 0, createdAt: Date.now() });
+    saveBrain(brain);
+    return { content: [{ type: 'text', text: JSON.stringify({ success: true, total: brain.length }) }] };
+  }
+};
+
+const server = {
+  name: 'lemma-mcp-server',
+  version: '1.0.0',
+  tools,
+  toolHandlers
+};
+
+process.stdin.on('data', async (chunk) => {
+  const lines = chunk.toString().split('\n').filter(l => l.trim());
+  for (const line of lines) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.method === 'initialize') {
+        const resp = {
+          jsonrpc: '2.0',
+          id: msg.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            serverInfo: { name: server.name, version: server.version },
+            capabilities: { tools: {} }
+          }
+        };
+        console.log(JSON.stringify(resp));
+      } else if (msg.method === 'tools/list') {
+        const resp = {
+          jsonrpc: '2.0',
+          id: msg.id,
+          result: { tools: server.tools }
+        };
+        console.log(JSON.stringify(resp));
+      } else if (msg.method === 'tools/call') {
+        const handler = server.toolHandlers[msg.params.name];
+        if (!handler) {
+          console.log(JSON.stringify({
+            jsonrpc: '2.0',
+            id: msg.id,
+            error: { code: -32601, message: `Tool not found: ${msg.params.name}` }
+          }));
+          continue;
+        }
+        try {
+          const result = await handler(msg.params.arguments || {});
+          console.log(JSON.stringify({ jsonrpc: '2.0', id: msg.id, result }));
+        } catch (e) {
+          console.log(JSON.stringify({
+            jsonrpc: '2.0',
+            id: msg.id,
+            error: { code: -32000, message: e.message }
+          }));
+        }
+      } else if (msg.method === 'notifications/initialized') {
+      } else if (msg.id) {
+        console.log(JSON.stringify({
+          jsonrpc: '2.0',
+          id: msg.id,
+          error: { code: -32601, message: `Method not found: ${msg.method}` }
+        }));
+      }
+    } catch (e) {
+      console.error('[lemma-mcp] Parse error:', e.message);
+    }
+  }
+});
+
+process.on('SIGINT', () => process.exit(0));
+process.on('SIGTERM', () => process.exit(0));
+
+console.error('[lemma-mcp] BM25 cache server ready on stdio');

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@nxuss/lemma",
-  "version": "0.9.3",
+  "version": "1.0.1",
   "description": "Intelligent AI Gateway for IDEs & Agents — Semantic cache, Privacy Firewall, and Autonomous Cost-Optimization.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
   "bin": {
-    "lemma": "./lemma-proxy.cjs"
+    "lemma": "./lemma-proxy.cjs",
+    "lemma-mcp-server": "./mcp-server.js"
   },
   "exports": {
     ".": {
@@ -83,6 +84,10 @@
     "dist/cjs/**/*",
     "src/**/*.js",
     "lemma-proxy.cjs",
+    "mcp-server.js",
+    "cache-proxy.js",
+    "bin/init.js",
+    "bin/cli.js",
     "dashboard/dist/**/*",
     "!dist/examples/**",
     "README.md",