@nxuss/lemma 1.2.2 → 1.2.4

package/mcp-server.js

@@ -3,218 +3,149 @@
 
 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;
+/**
+ * Lemma MCP Server Entry Point
+ * 
+ * This file routes to the full MCP server implementation.
+ * The full server with 70+ tools is in dist/cjs/mcp/index.js
+ */
 
-function loadBrain() {
-  try {
-    if (!fs.existsSync(BRAIN_FILE)) {
-      fs.mkdirSync(path.dirname(BRAIN_FILE), { recursive: true });
-      fs.writeFileSync(BRAIN_FILE, '[]', 'utf8');
+const fullMcpPath = path.join(__dirname, 'dist', 'cjs', 'mcp', 'index.js');
+
+if (fs.existsSync(fullMcpPath)) {
+  // Load the full MCP server with all tools
+  require(fullMcpPath);
+} else {
+  console.error('[lemma-mcp] ERROR: Full MCP server not found at:', fullMcpPath);
+  console.error('[lemma-mcp] Please run "npm run build" to compile the project.');
+  console.error('[lemma-mcp] Falling back to legacy minimal server (only 2 tools)...');
+  
+  // Legacy fallback - minimal BM25 cache server
+  const os = require('os');
+  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) {
       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));
+  function saveBrain(data) {
+    try {
+      fs.mkdirSync(path.dirname(BRAIN_FILE), { recursive: true });
+      fs.writeFileSync(BRAIN_FILE, JSON.stringify(data), 'utf8');
+    } catch (e) {}
   }
-  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))));
+  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));
   }
-  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']
+  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;
+      if (f === 0) continue;
+      score += (idfScores[q] || 0) * ((f * (k1 + 1)) / (f + k1 * (1 - b + b * (docLen / avgDocLen))));
     }
+    return score;
   }
-];
 
-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
-        }) }]
-      };
+  const tools = [
+    {
+      name: 'get_cached_solution',
+      description: 'Search the semantic cache (BM25) for a similar prompt.',
+      inputSchema: { type: 'object', properties: { prompt: { type: 'string' }, threshold: { type: 'number', default: 0.85 } }, required: ['prompt'] }
+    },
+    {
+      name: 'store_cached_solution',
+      description: 'Store a prompt-response pair in the semantic cache.',
+      inputSchema: { type: 'object', properties: { prompt: { type: 'string' }, response: { type: 'string' } }, required: ['prompt', 'response'] }
     }
-    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;
+  const handlers = {
+    get_cached_solution: async (args) => {
+      const brain = loadBrain();
+      const qt = tokenize(args.prompt);
+      if (qt.length === 0) return { content: [{ type: 'text', text: JSON.stringify({ hit: false }) }] };
+      
+      let bestMatch = null;
+      let bestScore = 0;
+      
+      for (let i = 0; i < brain.length; i++) {
+        const docTokens = tokenize(brain[i].prompt || '');
+        const corpusTokens = brain.map(e => tokenize(e.prompt || ''));
+        const df = {};
+        for (const tokens of corpusTokens) {
+          const seen = new Set(tokens);
+          for (const t of seen) df[t] = (df[t] || 0) + 1;
         }
-        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 }
-          }));
+        const idfScores = {};
+        for (const [t, count] of Object.entries(df)) {
+          idfScores[t] = Math.log(1 + (corpusTokens.length - count + 0.5) / (count + 0.5));
+        }
+        const avgDocLen = corpusTokens.reduce((s, t) => s + t.length, 0) / corpusTokens.length;
+        const score = bm25(qt, docTokens, idfScores, avgDocLen);
+        const maxScore = bm25(qt, qt, idfScores, avgDocLen);
+        const similarity = maxScore > 0 ? score / maxScore : 0;
+        
+        if (similarity >= (args.threshold || 0.85) && similarity > bestScore) {
+          bestScore = similarity;
+          bestMatch = { entry: brain[i], similarity, index: i };
         }
-      } 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);
+      
+      if (bestMatch) {
+        brain[bestMatch.index].hits = (brain[bestMatch.index].hits || 0) + 1;
+        saveBrain(brain);
+        return { content: [{ type: 'text', text: JSON.stringify({ hit: true, similarity: bestMatch.similarity, response: bestMatch.entry.response }) }] };
+      }
+      return { content: [{ type: 'text', text: JSON.stringify({ hit: false }) }] };
+    },
+    store_cached_solution: async (args) => {
+      const brain = loadBrain();
+      brain.push({ prompt: args.prompt, response: args.response, hits: 0, createdAt: Date.now() });
+      saveBrain(brain);
+      return { content: [{ type: 'text', text: JSON.stringify({ success: true, total: brain.length }) }] };
     }
-  }
-});
+  };
 
-process.on('SIGINT', () => process.exit(0));
-process.on('SIGTERM', () => process.exit(0));
+  process.stdin.on('data', async (chunk) => {
+    for (const line of chunk.toString().split('\n').filter(l => l.trim())) {
+      try {
+        const msg = JSON.parse(line);
+        if (msg.method === 'initialize') {
+          console.log(JSON.stringify({ jsonrpc: '2.0', id: msg.id, result: { protocolVersion: '2024-11-05', serverInfo: { name: 'lemma-mcp-server', version: '1.0.0' }, capabilities: { tools: {} } } }));
+        } else if (msg.method === 'tools/list') {
+          console.log(JSON.stringify({ jsonrpc: '2.0', id: msg.id, result: { tools } }));
+        } else if (msg.method === 'tools/call') {
+          const handler = handlers[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}` } }));
+          } else {
+            const result = await handler(msg.params.arguments || {});
+            console.log(JSON.stringify({ jsonrpc: '2.0', id: msg.id, result }));
+          }
+        }
+      } catch (e) {}
+    }
+  });
 
-console.error('[lemma-mcp] BM25 cache server ready on stdio');
+  process.on('SIGINT', () => process.exit(0));
+  process.on('SIGTERM', () => process.exit(0));
+  console.error('[lemma-mcp] Legacy fallback server ready (2 tools only)');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxuss/lemma",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Intelligent AI Gateway for IDEs & Agents — Semantic cache, Privacy Firewall, Infrastructure Command Center, and Autonomous Cost-Optimization.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -170,7 +170,6 @@
   "dependencies": {
     "@chroma-core/default-embed": "^0.1.9",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@nxuss/lemma": "^1.1.1",
     "axios": "^1.6.0",
     "commander": "^14.0.3",
     "cors": "^2.8.6",