@nxuss/lemma 0.9.2 → 1.0.0

package/README.md

@@ -1,8 +1,8 @@
-# 🧠 Lemma v0.9.2
+# 🧠 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)
-[![MCP Tools](https://img.shields.io/badge/MCP%20tools-36-ff69b4?style=flat-square)](https://github.com/Nxusbets/lemma)
+[![MCP Tools](https://img.shields.io/badge/MCP%20tools-38-ff69b4?style=flat-square)](https://github.com/Nxusbets/lemma)
 [![Security](https://img.shields.io/badge/privacy-firewall%20active-blueviolet?style=flat-square)](https://github.com/Nxusbets/lemma)
 [![Caching](https://img.shields.io/badge/semantic%20memory-enabled-success?style=flat-square)](https://github.com/Nxusbets/lemma)
 
@@ -16,7 +16,7 @@
 
 > **The Intelligent local-first AI Gateway — Privacy, Performance, and Static Code Intelligence for the Agentic Era.**
 
-Lemma is a high-performance orchestration layer that sits between your development environment and LLM providers. It transforms the way you build with AI by providing **Shared Semantic Memory**, **Autonomous Cost Optimization**, **Privacy Guardrails**, and a suite of **36 MCP tools** — including zero-token static code intelligence that runs entirely on your machine with no LLM calls required.
+Lemma is a high-performance orchestration layer that sits between your development environment and LLM providers. It transforms the way you build with AI by providing **Shared Semantic Memory**, **Autonomous Cost Optimization**, **Privacy Guardrails**, and a suite of **38 MCP tools** — including zero-token static code intelligence that runs entirely on your machine with no LLM calls required.
 
 ---
 
@@ -31,21 +31,22 @@ Lemma is a high-performance orchestration layer that sits between your developme
 | **Complexity Router** | ✅ | ✅ |
 | **Dashboard** | Basic stats | ✅ Full time-travel |
 | **Proxy requests/month** | 300 | ✅ Unlimited |
-| **MCP Server (all 32 tools)** | ❌ | ✅ |
+| **MCP Server (all 38 tools)** | ❌ | ✅ |
 | **The Brain — Semantic Memory** | ❌ | ✅ |
 | **Zero-Token Static Analysis** | ❌ | ✅ |
 | **Cross-Project Telepathy** | ❌ | ✅ |
 | **AutoPilot & Auto-Heal** | ❌ | ✅ |
+| **`depgraph` — Dependency Graph** | ❌ | ✅ |
+| **`refactor` — Codemod Engine** | ❌ | ✅ |
 
-> **The MCP is Pro.** All 32 tools — The Brain, PreCrime predictor, AST Hologram, Entropy Score, Coupling Radar, workspace control, and every optimization tool — require a Pro license. Activate with `lemma activate <key>` → [Get Pro](https://lemma.nxus.studio/upgrade)
+> **The MCP is Pro.** All 38 tools — The Brain, PreCrime predictor, AST Hologram, Entropy Score, Coupling Radar, `depgraph`, `refactor`, and every optimization tool — require a Pro license. Activate with `lemma activate <key>` → [Get Pro](https://lemma.nxus.studio/upgrade)
 
 ---
 
 ## ⚡ 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.
@@ -62,6 +63,48 @@ Mathematical chaos score (0-100) per file using the TS Compiler API. Measures cy
 ### 🗺️ AST Hologram — Zero Tokens
 Scans the entire workspace and returns a dense JSON index of all exported symbols (classes, functions, interfaces, types, consts) with file paths and line numbers. Use this instead of reading individual files — saves up to 90% tokens when navigating large codebases.
 
+### 📡 `depgraph` — Real-Time Dependency Graph *(NEW in v0.9.3)*
+**Architecture-aware blast radius analysis.** Builds a real-time, bidirectional dependency graph for any file in the workspace using the TypeScript Compiler API — zero LLM calls, zero tokens. Shows exactly what a file imports, what imports it (reverse dependencies), and what symbols it exports.
+
+```
+📦 src/services/pantry.ts
+├── importa:
+│   ├── src/lib/utils/ingredient-parser.ts  → parseIngredientString, normalizeUnit
+│   └── src/db/prisma.ts                    → PrismaClient
+├── es importado por:
+│   ├── src/app/actions/generate-recipe.ts
+│   └── src/components/PantryWidget.tsx
+└── exporta:
+    ├── applyRecipeDeductions
+    └── getPantryBalance
+```
+
+Supports `--depth` (1-5), `--format text|mermaid|json`, `--reverse`, `--circular` (cycle detection), and `--external` (include node_modules).
+
+### 🔧 `refactor` — Declarative Codemod Engine *(NEW in v0.9.3)*
+**Multi-file refactoring with surgical precision.** Rename any symbol across the entire workspace or move files updating all importers — using the TypeScript Compiler API for accurate AST-based reference detection. Zero LLM calls.
+
+**`rename`** — Finds every reference to a symbol (via AST, not text search) and renames it everywhere:
+```bash
+# Preview first
+lemma refactor --operation rename --from "applyRecipeDeductions" --to "deductPantryIngredients" \
+  --file src/services/pantry.ts --dryRun
+
+# Apply with TypeScript verification
+lemma refactor --operation rename --from "applyRecipeDeductions" --to "deductPantryIngredients" \
+  --file src/services/pantry.ts --tscCheck
+```
+
+**`move`** — Moves a file physically and rewires every import path in the workspace:
+```bash
+lemma refactor --operation move \
+  --from src/lib/validation/recipe.schema.ts \
+  --to src/lib/schemas/recipe.ts \
+  --tscCheck
+```
+
+Supports `--dryRun` (unified diff preview), `--tscCheck` (post-refactor type verification), and `--backup` (`.bak` files).
+
 ### 🚦 Complexity Router
 Intelligently evaluates each prompt and routes it to the most cost-effective model. Reserves premium models for complex reasoning, uses smaller models for simple tasks. Slashes your AI bill without sacrificing quality.
 
@@ -74,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)
@@ -142,11 +200,11 @@ Just run `lemma init`. Lemma automatically registers its MCP server in your `~/.
 }
 ```
 
-Once connected, your IDE gains access to all **32 MCP tools** and Lemma auto-injects the TurboMode system prompt on handshake.
+Once connected, your IDE gains access to all **38 MCP tools** and Lemma auto-injects the TurboMode system prompt on handshake.
 
 ---
 
-## 🛠️ MCP Tools Reference (v0.9.2 — 36 Tools)
+## 🛠️ MCP Tools Reference (v0.9.3 — 38 Tools)
 
 ### 🗂️ Workspace Tools
 
@@ -193,7 +251,7 @@ Once connected, your IDE gains access to all **32 MCP tools** and Lemma auto-inj
 | `auto_heal` | Diagnose and auto-heal the latest crash from Lemma's live context logs. |
 | `batch_tool_calls` | Execute multiple tool calls in parallel via `Promise.all`. High-throughput operations in a single MCP round-trip. |
 
-### 🔮 Zero-Token Static Intelligence Tools (NEW in v0.9.0)
+### 🔮 Zero-Token Static Intelligence Tools
 
 > All tools in this section use **zero LLM tokens, zero Ollama, zero cloud**. Pure local computation via TypeScript Compiler API, git, and math.
 
@@ -207,7 +265,16 @@ Once connected, your IDE gains access to all **32 MCP tools** and Lemma auto-inj
 | `semantic_dedup_guard` | **Brain dedup firewall.** Before calling `store_memory`, pass content through here. If similarity ≥ 92% → rejects as duplicate. If 75–91% → warns and shows the similar entry. Keeps The Brain lean and dense. |
 | `dead_export_necromancer` | **Dead code auditor.** Maps every `export` in the workspace against every `import`. Symbols exported but never imported anywhere = zombie code inflating your context. Reports dead exports by file with estimated token waste. |
 
-### 🔍 PR Review Agent Tools (NEW in v0.9.2)
+### 🏗️ Architecture & Refactoring Tools *(NEW in v0.9.3)*
+
+> Architecture-aware tools that combine dependency analysis with surgical code transformation. **Zero LLM calls.**
+
+| Tool | Description |
+| :--- | :--- |
+| `depgraph` | **Real-time dependency graph.** Builds a bidirectional import/export map for any file. Shows what a file imports, what imports it (reverse deps with `--reverse`), and what symbols it exports. Supports `--depth` 1-5, `--format text\|mermaid\|json`, `--circular` (cycle detection), and `--external` (include node_modules). Use before any refactor to measure blast radius. |
+| `refactor` | **Declarative codemod engine.** `rename` renames a symbol across all files using AST-based reference detection (no false positives from string search). `move` relocates a file and rewires every import path in the workspace. Both support `--dryRun` (unified diff preview), `--tscCheck` (post-apply type verification), and `--backup` (`.bak` files). |
+
+### 🔍 PR Review Agent Tools
 
 | Tool | Description |
 | :--- | :--- |

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);
+});