@nxuss/lemma 1.16.1 → 1.18.0

package/bin/init.js

@@ -10,8 +10,13 @@ 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, '..', 'dist', 'cjs', 'mcp', 'index.js');
-const PROXY_PATH = path.join(__dirname, '..', 'cache-proxy.js');
+const PROXY_PATH = path.join(__dirname, '..', 'dist', 'cjs', 'cli', 'lemma-proxy.js');
 const PORT = '8081';
+// Static local placeholder — the proxy never validates the client's bearer token (it
+// always signs upstream requests with its OWN server-side ANTHROPIC_API_KEY / OPENAI_API_KEY),
+// and only binds to 127.0.0.1 by default. This just satisfies Claude Code's "auth token
+// must be present" check; it is not a real credential.
+const LEMMA_GATEWAY_TOKEN = 'sk-lemma-local-gateway';
 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 {} }
@@ -270,13 +275,18 @@ tokens sale más cara que los tokens que ahorra.
 | Tarea | Tool de Lemma | Por qué |
 |---|---|---|
 | Leer/listar/buscar en el workspace | \`mcp__lemma__read_workspace_file\`, \`list_workspace_dir\`, \`search_workspace\` | Auto-scrubbing de secretos y compresión de contexto sin perder el archivo real |
-| Pregunta que depende de archivos específicos | \`mcp__lemma__state_hash_cache\` (action="lookup" antes de razonar, "store" después) | Hit solo si el hash del archivo no cambió — invalidación exacta, no una adivinanza por similitud |
-| Pregunta general, sin dependencia de archivos | \`mcp__lemma__search_memory\` / \`smarter_cache\` | Cache semántico; si hay hit, dilo explícitamente ("esto viene de una respuesta cacheada") en vez de presentarlo como recién razonado |
+| Pregunta puntual, de una sola sesión, atada a archivos concretos | \`mcp__lemma__state_hash_cache\` (action="lookup" antes de razonar, "store" después) | Hit solo si el hash exacto de esos archivos no cambió — invalidación exacta, no una adivinanza por similitud. Match de texto exacto en la query: no sirve para "¿algo así ya se resolvió?", solo para "esta misma pregunta, ¿estos archivos siguen igual?" |
+| Conocimiento que debe sobrevivir sesiones, con seguimiento por símbolo (no todo el archivo) | \`mcp__lemma__search_memory\` / \`store_memory\` | Motor con más garantías: invalida por símbolo específico (no por archivo completo), distingue cambio de código real vs. cambio de branch, y sigue cadenas de memorias derivadas — no solo "sin dependencia de archivos", también rastrea archivos con más precisión que state_hash_cache |
+| Pregunta general, sin dependencia de archivos ni necesidad de sobrevivir sesiones | \`mcp__lemma__smarter_cache\` | Cache semántico difuso; si hay hit, dilo explícitamente ("esto viene de una respuesta cacheada") en vez de presentarlo como recién razonado |
 | Tarea mecánica/trivial y quieres saber si conviene un modelo más barato | \`mcp__lemma__get_routing_advice\` | Evita gastar presupuesto de modelo grande en algo mecánico |
 | Agregar un método/función a un archivo existente | \`mcp__lemma__surgical_ast_insert\` | Patch quirúrgico en vez de reescribir el archivo completo |
 | Antes de aplicar un patch generado | \`mcp__lemma__validate_patch_sandbox\` | Valídalo antes de escribirlo, no después |
 | "¿Cuánto ahorramos de verdad?" | \`mcp__lemma__token_receipt\` | Bitácora auditable real, no una cifra inventada |
 | Guardar una solución para el futuro | \`mcp__lemma__store_memory\` | Solo después de verificarla (tests pasaron, el usuario confirmó) — una solución mala guardada se vuelve un cache hit falso más adelante |
+| Una memoria salió STALE pero la verificaste y sigue siendo correcta | \`mcp__lemma__refresh_memory\` | Re-ancla la evidencia conservando id, hits y las aristas \`derivedFrom\`; guardar un casi-duplicado pierde las tres (y el dedup suele rechazarlo) |
+| Una memoria está simplemente mal, no solo mal encajada | \`mcp__lemma__forget_memory\` | Borrado real. Para "no era lo que buscaba en esta consulta" usa \`downvote_memory\`: esa memoria puede ser la correcta para otra pregunta |
+
+Ambas están en el toolbox (\`action="call"\`), no en la lista anunciada.
 
 ## No todas las tools de Lemma están en tu lista
 
@@ -372,6 +382,49 @@ function configureClaudeCode() {
   return true;
 }
 
+// ─── Claude Code gateway (routes real LLM traffic, not just MCP tools) ────────────
+//
+// Claude Code (CLI + VS Code/JetBrains extension) never picks up the OPENAI_*/CODEX_*
+// vars other tools use — it isn't OpenAI-compatible. It respects ANTHROPIC_BASE_URL /
+// ANTHROPIC_AUTH_TOKEN instead, and critically: the IDE extensions only read those from
+// the user's GLOBAL ~/.claude/settings.json ("env" block) or managed settings — never
+// from a project-local settings file. Without this, Lemma's MCP tools work but the
+// actual model traffic (the thing that produces cache hits / real $ savings) never
+// touches the proxy.
+//
+// This intentionally does NOT reuse KeyManager/Gatekeeper — those govern the Lemma Pro
+// license tier (semantic cache vs. exact-match cache), which has nothing to do with
+// gateway credentials. The proxy (lemma-proxy.ts) never validates whatever token the
+// client sends anyway: it always signs upstream requests with its OWN server-side
+// ANTHROPIC_API_KEY (see installProxyDaemon). So ANTHROPIC_AUTH_TOKEN here is just a
+// fixed local placeholder to satisfy Claude Code's "a token is present" check.
+function configureClaudeCodeGateway(anthropicApiKey) {
+  if (!anthropicApiKey) {
+    // Setting ANTHROPIC_BASE_URL alone would still redirect traffic away from
+    // api.anthropic.com, but a subscription (OAuth `claude login`) session's credentials
+    // would keep going out over that redirected connection with no server-side key to
+    // answer them — the proxy has nothing to sign upstream requests with and silently
+    // falls back to local Ollama. Refuse to flip this on until there's a real key.
+    return { activated: false, reason: 'no-anthropic-api-key' };
+  }
+
+  const claudeSettingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+  ensureDir(path.dirname(claudeSettingsPath));
+  let settings = {};
+  try {
+    if (fs.existsSync(claudeSettingsPath)) {
+      settings = JSON.parse(fs.readFileSync(claudeSettingsPath, 'utf8'));
+    }
+  } catch {}
+
+  if (!settings.env || typeof settings.env !== 'object') settings.env = {};
+  settings.env.ANTHROPIC_BASE_URL = `http://localhost:${PORT}`;
+  settings.env.ANTHROPIC_AUTH_TOKEN = LEMMA_GATEWAY_TOKEN;
+
+  fs.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  return { activated: true, settingsPath: claudeSettingsPath };
+}
+
 const LEMMA_RULES_CONTENT = `# Lemma MCP — Autonomous Behaviors
 
 > ⚠️ MANDATORY RULES — Follow without exception.
@@ -528,10 +581,26 @@ function installProxyDaemon() {
   const isMac = process.platform === 'darwin';
   const isLinux = process.platform === 'linux';
 
+  // The full proxy server (lemma-proxy.ts) needs its own server-side credentials to sign
+  // upstream requests — it never trusts whatever token the calling client sends. A launchd/
+  // systemd service does not inherit the shell's exported env, so these must be baked into
+  // the unit definition at install time or the daemon silently falls back to local Ollama.
+  const anthropicApiKey = process.env.ANTHROPIC_API_KEY || '';
+  const openaiApiKey = process.env.OPENAI_API_KEY || '';
+  const proxyArgs = ['start', '--port', PORT, '--no-configure', '--no-clipboard'];
+
   if (isMac) {
     const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
     ensureDir(plistDir);
     const plistPath = path.join(plistDir, 'com.lemma.cache-proxy.plist');
+    const argEntries = proxyArgs.map((a) => `    <string>${a}</string>`).join('\n');
+    const envEntries = [
+      `    <key>LEMMA_PROXY_PORT</key><string>${PORT}</string>`,
+      `    <key>LEMMA_CACHE_DIR</key><string>${LEMMA_CACHE}</string>`,
+      `    <key>LEMMA_DISABLE_CLIPBOARD</key><string>true</string>`,
+      anthropicApiKey ? `    <key>ANTHROPIC_API_KEY</key><string>${anthropicApiKey}</string>` : '',
+      openaiApiKey ? `    <key>OPENAI_API_KEY</key><string>${openaiApiKey}</string>` : '',
+    ].filter(Boolean).join('\n');
     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">
@@ -541,6 +610,7 @@ function installProxyDaemon() {
   <array>
     <string>${process.execPath}</string>
     <string>${PROXY_PATH}</string>
+${argEntries}
   </array>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
@@ -549,12 +619,12 @@ function installProxyDaemon() {
   <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>
+${envEntries}
   </dict>
 </dict>
 </plist>`;
     fs.writeFileSync(plistPath, plist, 'utf8');
+    try { execSync('launchctl unload ' + plistPath, { stdio: 'ignore' }); } catch {}
     try { execSync('launchctl load ' + plistPath, { stdio: 'ignore' }); } catch {}
     return true;
   }
@@ -562,23 +632,29 @@ function installProxyDaemon() {
   if (isLinux) {
     const svcDir = path.join(os.homedir(), '.config', 'systemd', 'user');
     ensureDir(svcDir);
+    const envLines = [
+      `Environment=LEMMA_PROXY_PORT=${PORT}`,
+      `Environment=LEMMA_CACHE_DIR=${LEMMA_CACHE}`,
+      `Environment=LEMMA_DISABLE_CLIPBOARD=true`,
+      anthropicApiKey ? `Environment=ANTHROPIC_API_KEY=${anthropicApiKey}` : '',
+      openaiApiKey ? `Environment=OPENAI_API_KEY=${openaiApiKey}` : '',
+    ].filter(Boolean).join('\n');
     const svc = `[Unit]
 Description=Lemma Cache Proxy
 After=network.target
 
 [Service]
-ExecStart=${process.execPath} ${PROXY_PATH}
+ExecStart=${process.execPath} ${PROXY_PATH} ${proxyArgs.join(' ')}
 Restart=always
 RestartSec=3
-Environment=LEMMA_PROXY_PORT=${PORT}
-Environment=LEMMA_CACHE_DIR=${LEMMA_CACHE}
+${envLines}
 
 [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 {}
+    try { execSync('systemctl --user daemon-reload && systemctl --user enable lemma-cache-proxy && systemctl --user restart lemma-cache-proxy', { stdio: 'ignore' }); } catch {}
     return true;
   }
 
@@ -667,6 +743,19 @@ async function main() {
   configureClaudeCode();
   ok('Claude Code / CLI configured (CLAUDE.md + .claude/settings.local.json)');
 
+  const anthropicApiKey = process.env.ANTHROPIC_API_KEY || '';
+  const gatewayResult = configureClaudeCodeGateway(anthropicApiKey);
+  if (gatewayResult.activated) {
+    ok(`Claude Code gateway activated (~/.claude/settings.json → ANTHROPIC_BASE_URL=http://localhost:${PORT})`);
+  } else {
+    warn('Claude Code gateway NOT activated — no ANTHROPIC_API_KEY in this environment.');
+    warn(`  Model traffic keeps going directly to Anthropic (subscription/OAuth or your own key, unchanged).`);
+    warn(`  Only Lemma's MCP tools are active for Claude Code — no cache savings on the model traffic itself.`);
+    warn(`  To enable it: export ANTHROPIC_API_KEY=sk-ant-... and re-run \`lemma init\`.`);
+    warn(`  This SWITCHES Claude Code off your subscription/OAuth session for LLM calls — they'll be`);
+    warn(`  signed by the proxy's own ANTHROPIC_API_KEY instead, and billed/rate-limited as API usage.`);
+  }
+
   updateAgentsMd();
   ok('AGENTS.md configured (Codex CLI, Gemini CLI, OpenAI Agents, any AGENTS.md-aware tool)');
 
@@ -712,8 +801,8 @@ async function main() {
   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');
+  if (daemonOk) ok('Cache proxy daemon installed & started (OpenAI + Anthropic /v1/messages, streaming)');
+  else warn('Could not install daemon — run `lemma proxy start` manually');
 
   const envFile = createEnvFile();
   ok(`Env file created: ${envFile}`);
@@ -729,6 +818,7 @@ async function main() {
   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(`  ${gatewayResult.activated ? GREEN + '●' : YELLOW + '○'}${RESET} Claude Code gateway: ${gatewayResult.activated ? 'ACTIVE (model traffic cached)' : 'inactive (MCP tools only)'}\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`);

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":";AA4cA,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA4DvF;AA+mED,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,CA8KhL"}
+{"version":3,"file":"lemma-proxy.d.ts","sourceRoot":"","sources":["../../../src/cli/lemma-proxy.ts"],"names":[],"mappings":";AA0cA,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA4DvF;AA4nED,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,CA8KhL"}

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

@@ -50,6 +50,7 @@ const AgentMultiplexer_1 = require("../proxy/AgentMultiplexer");
 const SseRelay_1 = require("../proxy/SseRelay");
 const KeyManager_1 = require("../proxy/KeyManager");
 const Gatekeeper_1 = require("../proxy/Gatekeeper");
+const ProjectIdentity_1 = require("../utils/ProjectIdentity");
 const ProjectRegistry_1 = require("../proxy/ProjectRegistry");
 const ContextInjector_1 = require("../proxy/ContextInjector");
 const SavingsLedger_1 = require("../utils/SavingsLedger");
@@ -100,18 +101,13 @@ function writeJson(filePath, data) {
 function getCollectionName(projectName) {
     return `lemma-cache-${projectName}`;
 }
+// detectProject/isProjectMismatch live in ../utils/ProjectIdentity — a side-effect-free
+// module shared with src/mcp/tools.ts, so the client and this daemon can never define
+// "project name" two different ways again, and so a test can import the comparison logic
+// without pulling in this whole CLI (which parses process.argv on import — see bottom of
+// this file).
 function detectProject() {
-    const cwd = process.cwd();
-    const pkgPath = path_1.default.join(cwd, 'package.json');
-    if (fs_1.default.existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
-            if (pkg.name)
-                return pkg.name;
-        }
-        catch { }
-    }
-    return path_1.default.basename(cwd);
+    return (0, ProjectIdentity_1.detectProjectName)(process.cwd());
 }
 function ensureProjectDir(projectName) {
     const hash = crypto_1.default.createHash('sha1').update(projectName).digest('hex').slice(0, 12);
@@ -1351,6 +1347,18 @@ class LemmaServer {
             // Dynamic Zero-Shot Onboarding mental model builder
             this.app.get('/api/project/onboarding', async (req, res) => {
                 try {
+                    // This daemon is one shared process per machine — its project identity was fixed
+                    // at `lemma start` time to whatever cwd it was launched from, not to whichever
+                    // project's MCP client happens to be asking. A caller from a DIFFERENT project
+                    // still resolves the same global proxy.port and would otherwise get served this
+                    // daemon's stack/files/architecture memories as if they were its own. When the
+                    // caller tells us what project it expects (see detectExpectedProjectName in
+                    // src/mcp/tools.ts) and it doesn't match, decline rather than answer wrong —
+                    // the caller falls back to its own local (correctly-scoped) generator.
+                    const expectedProject = typeof req.query.expectedProject === 'string' ? req.query.expectedProject : null;
+                    if ((0, ProjectIdentity_1.isProjectMismatch)(expectedProject, this.projectName)) {
+                        return res.json({ success: false, mismatch: true, servingProject: this.projectName });
+                    }
                     const cwd = process.cwd();
                     // 1. Parse package.json
                     let pkg = {};