@nxuss/lemma 0.7.1 → 0.7.3

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

@@ -32,6 +32,8 @@ import SemanticScrubber from '../security/SemanticScrubber';
 import CloudSyncClient from '../cloud/CloudSyncClient';
 import { pruneHistoryMessages, squeezePrompt } from '../utils/ContextSqueezer';
 import { AgentMultiplexer } from '../proxy/AgentMultiplexer';
+import { ProjectRegistry } from '../proxy/ProjectRegistry';
+import { shouldInject, buildMinimalContext, buildDeepContext, sniffProjectFromMessages } from '../proxy/ContextInjector';
 import { savingsLedger } from '../utils/SavingsLedger';
 const chroma = new ChromaClient({ host: 'localhost', port: 8000 });
 const dummyEmbeddingFunction = { generate: (texts) => Promise.resolve([]) };
@@ -49,11 +51,23 @@ const USAGE_FILE = path.join(CACHE_DIR, 'usage.json');
 const LICENSE_FILE = path.join(CACHE_DIR, 'license.json');
 const EVENT_LOG = [];
 const MAX_EVENTS = 100;
+// MCP Status tracking
+const MCP_STATUS = {
+    lastActivity: Date.now(),
+    toolCallCount: 0,
+    status: 'idle'
+};
 function logEvent(event) {
     const ev = { id: Math.random().toString(36).slice(2, 11), timestamp: Date.now(), ...event };
     EVENT_LOG.push(ev);
     if (EVENT_LOG.length > MAX_EVENTS)
         EVENT_LOG.shift();
+    // Track MCP activity
+    if (event.type === 'mcp_tool_call') {
+        MCP_STATUS.lastActivity = Date.now();
+        MCP_STATUS.toolCallCount++;
+        MCP_STATUS.status = 'active';
+    }
     // Print a terminal savings summary every 10 events
     if (EVENT_LOG.length > 0 && EVENT_LOG.length % 10 === 0) {
         const snap = savingsLedger.getSnapshot();
@@ -62,354 +76,49 @@ function logEvent(event) {
         }
     }
 }
-const FREE_LIMIT = 500;
-const WARN_PCT = 0.8;
-const VALIDATE_URL = 'https://lemma.nxus.studio/api/v1/validate';
-if (!fs.existsSync(CACHE_DIR))
-    fs.mkdirSync(CACHE_DIR, { recursive: true });
-// ── Helpers ────────────────────────────────────────────────────────────────────
-async function readJson(file, fallback) {
-    try {
-        if (await fs.promises.access(file).then(() => true).catch(() => false)) {
-            const content = await fs.promises.readFile(file, 'utf8');
-            return JSON.parse(content);
-        }
-    }
-    catch { }
-    return fallback;
-}
-const writeQueues = new Map();
-async function writeJson(file, data) {
-    const chain = writeQueues.get(file) || Promise.resolve();
-    const writeOperation = async () => {
-        try {
-            const tempFile = `${file}.${crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).substring(2, 15)}.tmp`;
-            await fs.promises.writeFile(tempFile, JSON.stringify(data, null, 2));
-            await fs.promises.rename(tempFile, file);
-        }
-        catch { }
-    };
-    const nextChain = chain.then(writeOperation).catch(() => { });
-    writeQueues.set(file, nextChain);
-    return nextChain;
-}
-function projectHash(name) {
-    return crypto.createHash('sha1').update(name).digest('hex').slice(0, 12);
-}
-function getCollectionName(projectName) {
-    let cleanName = projectName.replace(/[^a-zA-Z0-9._-]/g, '_');
-    cleanName = cleanName.replace(/^[^a-zA-Z0-9]+/, '');
-    cleanName = cleanName.replace(/[^a-zA-Z0-9]+$/, '');
-    if (cleanName.length < 3) {
-        cleanName = 'lemma_proj_' + cleanName;
-    }
-    return `lemma-cache-${cleanName}`;
-}
-function detectProject() {
-    const pkgPath = path.join(process.cwd(), 'package.json');
-    if (fs.existsSync(pkgPath)) {
-        try {
-            const p = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-            if (p.name)
-                return p.name;
-        }
-        catch { }
-    }
-    return path.basename(process.cwd());
-}
-function ensureProjectDir(name) {
-    const dir = path.join(CACHE_DIR, projectHash(name));
-    if (!fs.existsSync(dir))
-        fs.mkdirSync(dir, { recursive: true });
-    const marker = path.join(dir, 'project-name.txt');
-    if (!fs.existsSync(marker))
-        fs.writeFileSync(marker, name);
-    return dir;
-}
-function getPidByPort(port) {
-    const { execSync } = require('child_process');
-    try {
-        if (process.platform === 'win32') {
-            const out = execSync(`netstat -ano | findstr :${port}`).toString();
-            const match = out.match(/LISTENING\s+(\d+)/);
-            return match ? match[1] : null;
-        }
-        else {
-            const out = execSync(`lsof -t -i :${port}`).toString().trim();
-            return out.split('\n')[0]; // Take first if multiple
-        }
-    }
-    catch {
-        return null;
-    }
-}
-async function checkDependency(url) {
-    try {
-        const res = await axios.get(url, { timeout: 1000, validateStatus: () => true });
-        return res.status >= 200 && res.status < 500;
-    }
-    catch {
-        return false;
-    }
-}
-async function ensureChromaRunning() {
-    const chromaPort = process.env.CHROMA_PORT || '8000';
-    const chromaHost = process.env.CHROMA_HOST || 'http://localhost';
-    const chromaUrl = `${chromaHost}:${chromaPort}`;
-    const isChromaUp = await checkDependency(`${chromaUrl}/api/v1/heartbeat`);
-    if (isChromaUp) {
-        console.log(`✅ \x1b[32m[ChromaDB]\x1b[0m ChromaDB is already running on port ${chromaPort}`);
-        return true;
-    }
-    console.log(`\n📦 \x1b[35m[ChromaDB]\x1b[0m ChromaDB is not running on port ${chromaPort}.`);
-    console.log(`🔄 Starting ChromaDB in background...`);
-    const chromaDataPath = path.join(CACHE_DIR, 'chroma_data');
-    try {
-        const { spawn } = require('child_process');
-        if (!fs.existsSync(chromaDataPath)) {
-            fs.mkdirSync(chromaDataPath, { recursive: true });
-        }
-        const chromaProcess = spawn('chroma', ['run', '--path', chromaDataPath, '--port', chromaPort], {
-            stdio: 'ignore',
-            detached: true
-        });
-        chromaProcess.unref();
-        // Wait up to 5 seconds for ChromaDB to start
-        for (let i = 0; i < 5; i++) {
-            await new Promise(r => setTimeout(r, 1000));
-            const up = await checkDependency(`${chromaUrl}/api/v1/heartbeat`);
-            if (up) {
-                console.log(`✅ \x1b[32m[ChromaDB]\x1b[0m ChromaDB has been started and is ready!`);
-                return true;
-            }
-        }
-        console.log(`⚠️  \x1b[33m[ChromaDB]\x1b[0m ChromaDB was started but is taking longer to respond. It will continue starting in the background.`);
-        return true;
-    }
-    catch (err) {
-        console.error(`❌ Failed to automatically start ChromaDB: ${err.message}`);
-        console.error(`👉 Please start it manually: chroma run --path ${chromaDataPath} --port ${chromaPort}`);
-        return false;
-    }
-}
-function ensureGitIgnore() {
-    const gi = path.join(process.cwd(), '.gitignore');
-    let added = false;
-    try {
-        let content = '';
-        if (fs.existsSync(gi)) {
-            content = fs.readFileSync(gi, 'utf8');
-        }
-        const appendLines = [];
-        if (!content.includes('.lemma/')) {
-            appendLines.push('# Lemma Context Logs', '.lemma/');
-            added = true;
-        }
-        if (!content.includes('chroma_data/')) {
-            appendLines.push('# Lemma Local Vector Database', 'chroma_data/');
-            added = true;
-        }
-        if (appendLines.length > 0) {
-            const prefix = content.endsWith('\n') || content === '' ? '' : '\n';
-            fs.appendFileSync(gi, prefix + appendLines.join('\n') + '\n');
-        }
-    }
-    catch { }
-    return added;
-}
-const CLIPBOARD_PID_FILE = path.join(CACHE_DIR, 'clipboard.pid');
-export function autoConfigureAll(projectName, cliOpts) {
-    const project = projectName || detectProject();
-    const HOME = process.env.HOME || process.env.USERPROFILE || '~';
-    // Load configuration if it exists
-    let configDisabled = false;
-    let configEditor = true;
-    let configShell = true;
-    let configClaude = true;
-    try {
-        const configPath = path.join(process.cwd(), 'lemma.config.json');
-        if (fs.existsSync(configPath)) {
-            const rawConfig = fs.readFileSync(configPath, 'utf8');
-            const config = JSON.parse(rawConfig);
-            const systemConfig = config.system || {};
-            const autoConfig = systemConfig.autoConfigure || {};
-            if (autoConfig.disabled === true)
-                configDisabled = true;
-            if (autoConfig.editor === false)
-                configEditor = false;
-            if (autoConfig.shell === false)
-                configShell = false;
-            if (autoConfig.claude === false)
-                configClaude = false;
-        }
-    }
-    catch { }
-    // Merge CLI overrides and config
-    const shouldConfigure = cliOpts?.configure !== false && !configDisabled;
-    if (!shouldConfigure) {
-        console.log(`⏭️  [Auto-Configure] Skipped auto-configuration (disabled via options or config).`);
-        return;
-    }
-    const runEditor = cliOpts?.editor !== false && configEditor;
-    const runShell = cliOpts?.shell !== false && configShell;
-    const runClaude = cliOpts?.claude !== false && configClaude;
-    // 1. Claude Desktop Config
-    if (runClaude) {
-        try {
-            const isWin = process.platform === 'win32';
-            const claudePath = isWin
-                ? path.join(process.env.APPDATA || '', 'Claude/claude_desktop_config.json')
-                : path.join(HOME, 'Library/Application Support/Claude/claude_desktop_config.json');
-            if (fs.existsSync(path.dirname(claudePath))) {
-                let config = { mcpServers: {} };
-                if (fs.existsSync(claudePath)) {
-                    try {
-                        config = JSON.parse(fs.readFileSync(claudePath, 'utf8'));
-                    }
-                    catch { }
-                }
-                if (!config.mcpServers)
-                    config.mcpServers = {};
-                config.mcpServers.lemma = {
-                    command: 'npx',
-                    args: ['-y', '@nxuss/lemma', 'mcp'],
-                    env: { LEMMA_PROJECT: project }
-                };
-                fs.writeFileSync(claudePath, JSON.stringify(config, null, 2));
-                console.log(`✅ [Claude Desktop] Configured automatically in: ${claudePath} (Restart Claude to activate)`);
-            }
-        }
-        catch (e) {
-            console.log(`⚠️  Could not auto-configure Claude Desktop: ${e.message}`);
-        }
-    }
-    else {
-        console.log(`⏭️  [Claude Desktop] Skip auto-configuration.`);
-    }
-    // 2. Shell Profiles Environment Override
-    if (runShell) {
+const LEMMA_RULES_BLOCK = `
+🧠 Lemma MCP — Autonomous Behaviors
+
+I have Lemma MCP tools connected. I MUST use them proactively:
+
+1. When starting work on a project, call \`get_project_onboarding\` or read \`lemma://project/context\` to understand the architecture.
+2. Before answering technical questions, call \`search_memory\` for relevant past solutions.
+3. When examining a file, call \`get_telepathic_hints\` for relevant context.
+4. After solving a problem, call \`store_memory\` to persist the solution for future sessions.
+5. Use \`read_workspace_file\`, \`list_workspace_dir\`, \`search_workspace\` instead of asking the user to read or navigate files.
+6. Always call \`validate_patch_sandbox\` before writing patches.
+7. Read \`lemma://runtime/context\` first when the user reports a bug.
+`;
+function injectIdeRules(projectName) {
+    const content = `\n# ${projectName} — ${LEMMA_RULES_BLOCK.trim()}\n`;
+    const rulesTargets = [
+        { name: 'Cursor', path: path.join(process.cwd(), '.cursorrules') },
+        { name: 'Cursor (v2)', path: path.join(process.cwd(), '.cursor/rules/lemma.mdc') },
+        { name: 'Windsurf', path: path.join(process.cwd(), '.windsurfrules') },
+        { name: 'Cline', path: path.join(process.cwd(), '.clinerules') },
+    ];
+    for (const target of rulesTargets) {
         try {
-            const profiles = [
-                path.join(HOME, '.zshrc'),
-                path.join(HOME, '.bashrc'),
-                path.join(HOME, '.bash_profile'),
-                path.join(HOME, '.profile')
-            ];
-            const lines = [
-                '',
-                '# Lemma AI Gateway Overrides',
-                'export OPENAI_BASE_URL="http://localhost:8081/v1"',
-                'export ANTHROPIC_BASE_URL="http://localhost:8081"',
-                'export LEMMA_PROJECT="' + project + '"',
-                ''
-            ].join('\n');
-            for (const profile of profiles) {
-                if (fs.existsSync(profile)) {
-                    try {
-                        const content = fs.readFileSync(profile, 'utf8');
-                        if (!content.includes('OPENAI_BASE_URL') && !content.includes('LEMMA_PROJECT')) {
-                            fs.appendFileSync(profile, lines);
-                            console.log(`✅ [Shell Profile] Configured ${path.basename(profile)} with local redirect variables!`);
-                        }
-                    }
-                    catch { }
-                }
+            const dir = path.dirname(target.path);
+            if (target.name === 'Cursor (v2)') {
+                if (!fs.existsSync(dir))
+                    fs.mkdirSync(dir, { recursive: true });
             }
-        }
-        catch (e) {
-            console.log(`⚠️  Could not auto-configure shell profiles: ${e.message}`);
-        }
-    }
-    else {
-        console.log(`⏭️  [Shell Profile] Skip auto-configuration.`);
-    }
-    // 3. Cursor, Windsurf & VS Code settings.json updates
-    if (runEditor) {
-        try {
-            const isWin = process.platform === 'win32';
-            const isMac = process.platform === 'darwin';
-            const candidates = [];
-            if (isMac) {
-                candidates.push({
-                    name: 'Cursor',
-                    path: path.join(HOME, 'Library/Application Support/Cursor/User/settings.json')
-                });
-                candidates.push({
-                    name: 'Windsurf',
-                    path: path.join(HOME, 'Library/Application Support/Windsurf/User/settings.json')
-                });
-                candidates.push({
-                    name: 'VS Code',
-                    path: path.join(HOME, 'Library/Application Support/Code/User/settings.json')
-                });
-            }
-            else if (isWin) {
-                const appData = process.env.APPDATA || '';
-                candidates.push({
-                    name: 'Cursor',
-                    path: path.join(appData, 'Cursor/User/settings.json')
-                });
-                candidates.push({
-                    name: 'Windsurf',
-                    path: path.join(appData, 'Windsurf/User/settings.json')
-                });
-                candidates.push({
-                    name: 'VS Code',
-                    path: path.join(appData, 'Code/User/settings.json')
-                });
-            }
-            else {
-                candidates.push({
-                    name: 'Cursor',
-                    path: path.join(HOME, '.config/Cursor/User/settings.json')
-                });
-                candidates.push({
-                    name: 'Windsurf',
-                    path: path.join(HOME, '.config/Windsurf/User/settings.json')
-                });
-                candidates.push({
-                    name: 'VS Code',
-                    path: path.join(HOME, '.config/Code/User/settings.json')
-                });
+            else if (!fs.existsSync(dir)) {
+                continue;
             }
-            for (const cand of candidates) {
-                const dir = path.dirname(cand.path);
-                if (fs.existsSync(dir)) {
-                    let settings = {};
-                    if (fs.existsSync(cand.path)) {
-                        try {
-                            settings = JSON.parse(fs.readFileSync(cand.path, 'utf8'));
-                        }
-                        catch { }
-                    }
-                    let updated = false;
-                    // Settings configuration to route custom openai/anthropic models through the proxy
-                    const updates = {
-                        "openai.baseURL": "http://localhost:8081/v1",
-                        "openai.apiKey": "dummy-key-for-lemma",
-                        "anthropic.baseURL": "http://localhost:8081",
-                        "anthropic.apiKey": "dummy-key-for-lemma"
-                    };
-                    for (const [key, value] of Object.entries(updates)) {
-                        if (settings[key] !== value) {
-                            settings[key] = value;
-                            updated = true;
-                        }
-                    }
-                    if (updated) {
-                        fs.writeFileSync(cand.path, JSON.stringify(settings, null, 2));
-                        console.log(`✅ [${cand.name}] Configured editor settings in ${cand.path} to route via local gateway!`);
-                    }
-                }
+            if (fs.existsSync(target.path)) {
+                const existing = fs.readFileSync(target.path, 'utf8');
+                if (existing.includes('Lemma MCP'))
+                    continue;
             }
+            fs.writeFileSync(target.path, content, { flag: 'a' });
+            console.log(`✅ [${target.name}] Injected Lemma rules: ${target.path}`);
         }
-        catch (e) {
-            console.log(`⚠️  Could not auto-configure editor settings: ${e.message}`);
+        catch {
+            console.log(`⚠️  Could not inject rules for ${target.name}`);
         }
     }
-    else {
-        console.log(`⏭️  [Editor Settings] Skip auto-configuration.`);
-    }
 }
 export function startBackgroundClipboardWatcher(cliOpts) {
     // Load configuration if it exists
@@ -938,6 +647,8 @@ class LemmaServer {
         this.sessions = new Map();
         this.timeline = [];
         this.lastFileContents = new Map();
+        this.registry = new ProjectRegistry();
+        this.projectSessions = new Map();
         this.port = port;
         this.projectName = projectName || detectProject();
         this.projectDir = ensureProjectDir(this.projectName);
@@ -963,6 +674,38 @@ class LemmaServer {
             const pro = await isPro();
             res.json({ status: 'ok', project: this.projectName, mode: pro ? 'pro' : 'standard', tier: pro ? 'pro' : 'free', port: this.port });
         });
+        // MCP Status endpoint
+        this.app.get('/api/mcp-status', (req, res) => {
+            // Update status based on inactivity (60 seconds = idle, 300 seconds = offline)
+            const now = Date.now();
+            const secondsSinceActive = (now - MCP_STATUS.lastActivity) / 1000;
+            let status = 'offline';
+            if (secondsSinceActive < 60) {
+                status = 'active';
+            }
+            else if (secondsSinceActive < 300) {
+                status = 'idle';
+            }
+            res.json({
+                status,
+                lastActivity: new Date(MCP_STATUS.lastActivity).toISOString(),
+                toolCallCount: MCP_STATUS.toolCallCount,
+                secondsSinceActive: Math.floor(secondsSinceActive),
+                uptime: Math.floor(process.uptime())
+            });
+        });
+        // Project registration from MCP handshake
+        this.app.post('/api/handshake', (req, res) => {
+            const { projectPath, projectName, stack } = req.body;
+            if (projectPath && projectName) {
+                this.registry.register(projectPath, projectName, stack || '');
+                console.log(`📋 [Handshake] Project registered: "${projectName}" (${projectPath})`);
+                res.json({ ok: true });
+            }
+            else {
+                res.status(400).json({ error: 'projectPath and projectName required' });
+            }
+        });
         this.app.get('/v1/models', (req, res) => {
             res.json({ object: 'list', data: [
                     { id: 'gpt-4o', object: 'model', owned_by: 'lemma-proxy' },
@@ -1056,18 +799,28 @@ class LemmaServer {
                 const limit = parseInt(req.query.limit) || 50;
                 const start = (page - 1) * limit;
                 // Get local proxy events (normalized schema matching what dashboard expects)
-                const localEvents = EVENT_LOG.map(e => ({
-                    id: e.id,
-                    timestamp: new Date(e.timestamp).toISOString(),
-                    type: e.type, // e.g., 'cache:hit' or 'cache:miss' which client normalizes to 'cache_hit' or 'cache_miss'
-                    latency: e.latency,
-                    tokensSaved: e.tokens,
-                    costSaved: e.tokens ? (e.tokens / 1000) * 0.002 : 0,
-                    metadata: {
-                        provider: e.provider,
-                        project: e.project
+                const localEvents = EVENT_LOG.map(e => {
+                    const eventData = {
+                        id: e.id,
+                        timestamp: new Date(e.timestamp).toISOString(),
+                        type: e.type, // e.g., 'cache:hit' or 'cache:miss' which client normalizes to 'cache_hit' or 'cache_miss'
+                        latency: e.latency,
+                        tokensSaved: e.tokens || e.tokensImpact || 0,
+                        costSaved: (e.tokens || e.tokensImpact || 0) ? ((e.tokens || e.tokensImpact || 0) / 1000) * 0.002 : 0,
+                        metadata: {
+                            provider: e.provider,
+                            project: e.project
+                        }
+                    };
+                    // Include MCP-specific fields if this is an MCP event
+                    if (e.type === 'mcp_tool_call') {
+                        eventData.tool = e.tool;
+                        eventData.args = e.args;
+                        eventData.result = e.result;
+                        eventData.tokensImpact = e.tokensImpact;
                     }
-                }));
+                    return eventData;
+                });
                 let mergedEvents = [...localEvents];
                 // Query the stack orchestration API if running to merge stack events
                 try {
@@ -1457,6 +1210,33 @@ class LemmaServer {
                 }
                 res.json({ ok: true, snapshot: savingsLedger.getSnapshot().total });
             });
+            // MCP Tool Event Endpoint — called by MCP server when tools execute
+            this.app.post('/api/mcp-event', (req, res) => {
+                try {
+                    const event = req.body;
+                    if (!event.type || !event.tool) {
+                        return res.status(400).json({ error: 'Missing type or tool' });
+                    }
+                    // Create normalized event
+                    const mcpEvent = {
+                        id: Math.random().toString(36).slice(2, 11),
+                        type: event.type || 'mcp_tool_call',
+                        tool: event.tool,
+                        args: event.args || {},
+                        result: event.result || 'UNKNOWN',
+                        latency: event.latency || 0,
+                        tokensImpact: event.tokensImpact || 0,
+                        error: event.error || null,
+                        timestamp: event.timestamp || new Date().toISOString(),
+                    };
+                    // Add to EVENT_LOG
+                    logEvent(mcpEvent);
+                    res.json({ success: true, eventId: mcpEvent.id });
+                }
+                catch (error) {
+                    res.status(500).json({ error: 'Internal server error' });
+                }
+            });
             this.app.get('/dashboard/*', (req, res) => res.sendFile(path.join(this.dashboardPath, 'index.html')));
         }
     }
@@ -1559,6 +1339,15 @@ class LemmaServer {
         }
         console.log(`🌌 \x1b[35m[Multiverse]\x1b[0m Captured micro-snapshot ${snapshot.id} (${changedFiles.length} file edits mapped).`);
     }
+    detectActiveProject(req) {
+        const mcpActive = this.registry.getActive();
+        if (mcpActive)
+            return mcpActive;
+        const sniffed = sniffProjectFromMessages(req.body.messages || [], this.registry);
+        if (sniffed)
+            return sniffed;
+        return null;
+    }
     async handleCompletion(req, res, provider) {
         const t0 = Date.now();
         const pro = await isPro();
@@ -1679,6 +1468,24 @@ Adjusted Answer:`;
                 return res.json(unmaskedData);
             }
         }
+        // ── 3. Context Injection (for cache misses) ──
+        const activeProject = this.detectActiveProject(req);
+        if (activeProject) {
+            const psKey = activeProject.path;
+            if (!this.projectSessions.has(psKey)) {
+                this.projectSessions.set(psKey, { alreadyInjected: false });
+            }
+            const session = this.projectSessions.get(psKey);
+            const injectionLevel = shouldInject(activeProject, req.body.messages, session);
+            if (injectionLevel !== 'none') {
+                const context = injectionLevel === 'deep'
+                    ? await buildDeepContext(activeProject, this.port)
+                    : buildMinimalContext(activeProject);
+                req.body.messages.unshift({ role: 'system', content: context });
+                session.alreadyInjected = true;
+                console.log(`🧠 [Context] Injected ${injectionLevel} context for "${activeProject.name}"`);
+            }
+        }
         // ── 2. Cache Miss Path ──
         const routingDecision = complexityRouter.evaluate(prompt, originalModel);
         const model = routingDecision.model;
@@ -1919,9 +1726,46 @@ Adjusted Answer:`;
     }
 }
 // ── CLI ────────────────────────────────────────────────────────────────────────
-program.name('lemma').description('Lemma Proxy CLI — Intelligent AI Gateway').version(VERSION);
+function showWelcomeScreen() {
+    console.log(`
+\x1b[1m\x1b[35m   _                         \x1b[0m
+\x1b[1m\x1b[35m  | |    ___ _ __ ___   __ _ \x1b[0m  \x1b[1mLEMMA\x1b[0m  \x1b[35mv${VERSION}\x1b[0m
+\x1b[1m\x1b[35m  | |   / _ \\ '_ \` _ \\ / _\` |\x1b[0m
+\x1b[1m\x1b[35m  | |__|  __/ | | | | | (_| |\x1b[0m  Intelligent AI Gateway
+\x1b[1m\x1b[35m  |_____\\___|_| |_| |_|\\__,_|\x1b[0m
+
+\x1b[1mQuick Start\x1b[0m
+  \x1b[33mlemma init\x1b[0m          Initialize Lemma in this project
+  \x1b[33mlemma start\x1b[0m         Start the proxy server
+  \x1b[33mlemma mcp\x1b[0m           Start MCP Server for Cursor/Claude
+
+\x1b[1mFree Features\x1b[0m (all included)
+  🔒  Privacy Firewall       💾  Exact-match Cache
+  🔀  Complexity Router      📡  Telepathic Clipboard
+  📊  Basic Usage Stats      🧠  MCP Tools & Resources
+
+\x1b[1mPro Features\x1b[0m (\x1b[35mlemma activate <key>\x1b[0m  or  \x1b[36mhttps://lemma.nxus.studio/upgrade\x1b[0m)
+  🎯  Semantic Vector Cache  🌐  Hive Mind Cloud Sync
+  🛸  Autopilot Healer       🩺  Auto-Diagnose & Heal
+  🌌  Codebase Multiverse    🏗️  Architecture Onboarding
+
+\x1b[90mRun \`lemma --help\` for all commands.\x1b[0m
+`);
+}
+program
+    .name('lemma')
+    .description('Intelligent AI Gateway — cache, route, and optimize AI requests')
+    .version(VERSION)
+    .addHelpText('after', `
+\x1b[1mPlan Comparison\x1b[0m
+  \x1b[32mFree\x1b[0m    500 req/mo · Exact cache · Privacy firewall · MCP tools
+  \x1b[35mPro\x1b[0m     Unlimited  · Semantic cache · Cloud sync · Autopilot · Heal
+         \x1b[36mhttps://lemma.nxus.studio/upgrade\x1b[0m
+
+\x1b[90mActivate Pro: lemma activate <key>\x1b[0m
+`);
 program.command('mcp')
-    .description('Start the Lemma MCP Server (Model Context Protocol)')
+    .description('Start the MCP Server for Cursor / Claude Desktop integration')
     .action(() => {
     const { spawn } = require('child_process');
     // Robust search candidates for both development (TS source) and compiled (JS production) environments.
@@ -1976,6 +1820,7 @@ program.command('start')
             // Keep configurations up to date even if server was already started
             const runningProject = resp.data.project || detectProject();
             autoConfigureAll(runningProject, { configure: opts.configure });
+            injectIdeRules(runningProject);
             startBackgroundClipboardWatcher({ clipboard: opts.clipboard });
             process.exit(0);
         }
@@ -1983,6 +1828,7 @@ program.command('start')
     catch { }
     const startProject = opts.project || detectProject();
     autoConfigureAll(startProject, { configure: opts.configure });
+    injectIdeRules(startProject);
     startBackgroundClipboardWatcher({ clipboard: opts.clipboard });
     // Automatically enable autopilot if stack is enabled and user is Pro
     const runAutopilot = opts.autopilot || opts.stack;
@@ -2195,8 +2041,12 @@ program.command('init')
     }
     console.log('\n🧠 \x1b[35mAuto-Setup MCP and redirection overrides for AI IDEs...\x1b[0m');
     autoConfigureAll(project, { configure: opts.configure });
-    console.log('\n✨ Project initialized for the Agentic Era!');
-    console.log('🚀 Run "lemma start" to begin.\n');
+    injectIdeRules(project);
+    console.log('\n✨ Project initialized for the Agentic Era!\n');
+    console.log('\x1b[1mNext steps:\x1b[0m');
+    console.log('  \x1b[33mlemma start\x1b[0m     Start the proxy & unlock AI savings');
+    console.log('  \x1b[33mlemma upgrade\x1b[0m   See Pro features & get a key');
+    console.log('  \x1b[33mlemma --help\x1b[0m    All available commands\n');
 });
 // ── Auto-Healing Diagnostics (Zero-Cost Suite) ───────────────────────────────
 export async function performAutoHeal(apply) {
@@ -2366,7 +2216,7 @@ Ensure you return strictly JSON. Do not return any other text outside the JSON b
     }
 }
 program.command('heal')
-    .description('Diagnose and auto-heal the latest local server crash from .lemma/live-context.md')
+    .description('[Pro] Diagnose and auto-heal the latest local server crash from .lemma/live-context.md')
     .option('--apply', 'Apply the auto-generated code fix automatically', false)
     .action(async (opts) => {
     try {
@@ -2395,7 +2245,7 @@ program.command('heal')
     }
 });
 program.command('autopilot')
-    .description('Start the autonomous background compiler watcher & active healer')
+    .description('[Pro] Start the autonomous background compiler watcher & active healer')
     .option('--dir <directory>', 'Directory to monitor for changes', 'src')
     .action(async (opts) => {
     try {
@@ -2420,6 +2270,26 @@ program.command('autopilot')
         process.exit(1);
     }
 });
+program.command('upgrade')
+    .description('Learn about Pro features and get an activation key')
+    .action(() => {
+    console.log(`
+\x1b[1m\x1b[35mLemma Pro\x1b[0m — Unlimited AI Gateway power
+
+\x1b[1mPro features:\x1b[0m
+  🎯  \x1b[1mSemantic Vector Cache\x1b[0m   — Smarter cache hits via vector similarity
+  🌐  \x1b[1mHive Mind Cloud Sync\x1b[0m    — Cross-project cache & bug telepathy
+  🛸  \x1b[1mAutopilot Healer\x1b[0m        — Autonomous background compiler watcher
+  🩺  \x1b[1mAuto-Diagnose & Heal\x1b[0m    — AI-driven crash analysis & patch
+  🌌  \x1b[1mCodebase Multiverse\x1b[0m     — AST time-travel & snapshots
+  🏗️  \x1b[1mArchitecture Onboarding\x1b[0m — Zero-shot project understanding
+  🔓  \x1b[1mUnlimited requests\x1b[0m       — No monthly caps
+
+\x1b[36m  https://lemma.nxus.studio/upgrade\x1b[0m
+
+Already have a key? Run:  \x1b[33mlemma activate <key>\x1b[0m
+`);
+});
 program.command('clipboard')
     .description('Start the Lemma Local Clipboard Telepathic Optimizer (auto-squeezes copied code blocks)')
     .option('--interval <ms>', 'Polling interval in milliseconds', '1000')
@@ -2437,6 +2307,11 @@ program.command('clipboard')
     }
 });
 if (process.argv[1] && (process.argv[1].includes('lemma') || process.argv[1].endsWith('.cjs') || process.argv[1].endsWith('.js'))) {
+    // Bare `lemma` with no args → show welcome screen
+    if (process.argv.length <= 2) {
+        showWelcomeScreen();
+        process.exit(0);
+    }
     program.parse(process.argv);
 }
 //# sourceMappingURL=lemma-proxy.js.map