@nxuss/lemma 0.4.6 → 0.4.8

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

@@ -0,0 +1,1268 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performAutoHeal = performAutoHeal;
+const commander_1 = require("commander");
+const express_1 = __importDefault(require("express"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const chromadb_1 = require("chromadb");
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const axios_1 = __importDefault(require("axios"));
+function getVersion() {
+    const paths = [
+        path_1.default.join(__dirname, '../../package.json'),
+        path_1.default.join(__dirname, '../../../package.json'),
+        path_1.default.join(__dirname, '../../../../package.json')
+    ];
+    for (const p of paths) {
+        if (fs_1.default.existsSync(p)) {
+            try {
+                const pkg = JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+                if (pkg.version)
+                    return pkg.version;
+            }
+            catch { }
+        }
+    }
+    return '0.4.6';
+}
+const VERSION = getVersion();
+const ComplexityRouter_1 = __importDefault(require("../proxy/ComplexityRouter"));
+const SemanticScrubber_1 = __importDefault(require("../security/SemanticScrubber"));
+const CloudSyncClient_1 = __importDefault(require("../cloud/CloudSyncClient"));
+const ContextSqueezer_1 = require("../utils/ContextSqueezer");
+const AgentMultiplexer_1 = require("../proxy/AgentMultiplexer");
+const chroma = new chromadb_1.ChromaClient({ host: 'localhost', port: 8000 });
+const dummyEmbeddingFunction = { generate: (texts) => Promise.resolve([]) };
+const complexityRouter = new ComplexityRouter_1.default();
+const semanticScrubber = new SemanticScrubber_1.default();
+const cloudSync = new CloudSyncClient_1.default();
+const agentMultiplexer = new AgentMultiplexer_1.AgentMultiplexer();
+// ── Paths ──────────────────────────────────────────────────────────────────────
+const HOME = process.env.HOME || process.env.USERPROFILE || '~';
+const CACHE_DIR = path_1.default.join(HOME, '.lemma-cache');
+const PID_FILE = path_1.default.join(CACHE_DIR, 'proxy.pid');
+const PORT_FILE = path_1.default.join(CACHE_DIR, 'proxy.port');
+const STATS_FILE = path_1.default.join(CACHE_DIR, 'stats.json');
+const USAGE_FILE = path_1.default.join(CACHE_DIR, 'usage.json');
+const LICENSE_FILE = path_1.default.join(CACHE_DIR, 'license.json');
+const EVENT_LOG = [];
+const MAX_EVENTS = 100;
+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();
+}
+const FREE_LIMIT = 500;
+const WARN_PCT = 0.8;
+const VALIDATE_URL = 'https://lemma.nxus.studio/api/v1/validate';
+if (!fs_1.default.existsSync(CACHE_DIR))
+    fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
+// ── Helpers ────────────────────────────────────────────────────────────────────
+async function readJson(file, fallback) {
+    try {
+        if (await fs_1.default.promises.access(file).then(() => true).catch(() => false)) {
+            const content = await fs_1.default.promises.readFile(file, 'utf8');
+            return JSON.parse(content);
+        }
+    }
+    catch { }
+    return fallback;
+}
+async function writeJson(file, data) {
+    try {
+        const tempFile = file + '.tmp';
+        await fs_1.default.promises.writeFile(tempFile, JSON.stringify(data, null, 2));
+        await fs_1.default.promises.rename(tempFile, file);
+    }
+    catch { }
+}
+function projectHash(name) {
+    return crypto_1.default.createHash('sha1').update(name).digest('hex').slice(0, 12);
+}
+function detectProject() {
+    const pkgPath = path_1.default.join(process.cwd(), 'package.json');
+    if (fs_1.default.existsSync(pkgPath)) {
+        try {
+            const p = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+            if (p.name)
+                return p.name;
+        }
+        catch { }
+    }
+    return path_1.default.basename(process.cwd());
+}
+function ensureProjectDir(name) {
+    const dir = path_1.default.join(CACHE_DIR, projectHash(name));
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    const marker = path_1.default.join(dir, 'project-name.txt');
+    if (!fs_1.default.existsSync(marker))
+        fs_1.default.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_1.default.get(url, { timeout: 1000, validateStatus: () => true });
+        return res.status >= 200 && res.status < 500;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureGitIgnore() {
+    const gi = path_1.default.join(process.cwd(), '.gitignore');
+    const line = '.lemma/';
+    try {
+        if (fs_1.default.existsSync(gi)) {
+            const content = fs_1.default.readFileSync(gi, 'utf8');
+            if (!content.includes(line)) {
+                fs_1.default.appendFileSync(gi, `\n# Lemma Context Logs\n${line}\n`);
+                return true;
+            }
+        }
+        else {
+            fs_1.default.writeFileSync(gi, `# Lemma Context Logs\n${line}\n`);
+            return true;
+        }
+    }
+    catch { }
+    return false;
+}
+// ── License helpers ────────────────────────────────────────────────────────────
+async function loadLicense() {
+    return readJson(LICENSE_FILE, { isPro: false });
+}
+async function isPro() {
+    const l = await loadLicense();
+    return !!(l && l.isPro);
+}
+async function validateKeyRemote(key) {
+    return new Promise((resolve, reject) => {
+        const body = JSON.stringify({ key });
+        const u = new URL(VALIDATE_URL);
+        const req = https_1.default.request({
+            hostname: u.hostname,
+            port: 443,
+            path: u.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+                'User-Agent': `lemma-proxy/${VERSION}`
+            }
+        }, res => {
+            let d = '';
+            res.on('data', c => d += c);
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(d));
+                }
+                catch {
+                    reject(new Error('bad json'));
+                }
+            });
+        });
+        req.on('error', reject);
+        const t = setTimeout(() => { req.destroy(); reject(new Error('timeout')); }, 5000);
+        req.on('close', () => clearTimeout(t));
+        req.write(body);
+        req.end();
+    });
+}
+// ── Usage helpers ──────────────────────────────────────────────────────────────
+async function loadUsage() {
+    const u = await readJson(USAGE_FILE, { count: 0, lastReset: new Date().toISOString(), history: [] });
+    const now = new Date();
+    const last = new Date(u.lastReset || 0);
+    if (now.getMonth() !== last.getMonth() || now.getFullYear() !== last.getFullYear()) {
+        const fresh = {
+            count: 0,
+            lastReset: now.toISOString(),
+            history: [...(u.history || []), { month: last.toISOString().slice(0, 7), count: u.count }]
+        };
+        await writeJson(USAGE_FILE, fresh);
+        return fresh;
+    }
+    return u;
+}
+// ── Stats helpers ──────────────────────────────────────────────────────────────
+async function loadStats() {
+    return readJson(STATS_FILE, {});
+}
+async function recordStat(stats, project, fromCache, latencyMs, provider, tokensSaved) {
+    if (!stats[project]) {
+        stats[project] = { total: 0, hits: 0, misses: 0, totalLatency: 0, totalTokensSaved: 0, providers: {} };
+    }
+    const s = stats[project];
+    s.total++;
+    s.totalLatency += latencyMs;
+    fromCache ? s.hits++ : s.misses++;
+    s.totalTokensSaved += (fromCache ? (tokensSaved || 2000) : (tokensSaved || 0));
+    if (!s.providers[provider])
+        s.providers[provider] = { hits: 0, misses: 0 };
+    fromCache ? s.providers[provider].hits++ : s.providers[provider].misses++;
+    logEvent({
+        type: fromCache ? 'cache:hit' : 'cache:miss',
+        project,
+        latency: latencyMs,
+        provider,
+        tokens: fromCache ? (tokensSaved || 2000) : (tokensSaved || 0)
+    });
+    await writeJson(STATS_FILE, stats);
+}
+const CACHE = new Map();
+const TTL_MS = 86400000 * 7;
+function cacheKey(prompt) {
+    return crypto_1.default.createHash('sha256').update(prompt).digest('hex');
+}
+function cacheGet(prompt) {
+    const k = cacheKey(prompt);
+    const e = CACHE.get(k);
+    if (!e)
+        return null;
+    if (e.ttl > 0 && Date.now() - e.createdAt > e.ttl) {
+        CACHE.delete(k);
+        return null;
+    }
+    return e;
+}
+function cacheSet(prompt, data) {
+    CACHE.set(cacheKey(prompt), { input: prompt, data, createdAt: Date.now(), ttl: TTL_MS });
+}
+// ── Semantic Search (Pro) ──────────────────────────────────────────────────────
+async function getEmbedding(text) {
+    try {
+        const resp = await axios_1.default.post('http://127.0.0.1:11434/api/embeddings', {
+            model: 'nomic-embed-text',
+            prompt: text
+        }, { timeout: 15000 });
+        return resp.data.embedding;
+    }
+    catch (e) {
+        console.warn(`\n\x1b[33m⚠️  [Semantic Cache] Failed to generate embedding from Ollama: ${e.message}\x1b[0m`);
+        console.warn(`\x1b[33m👉  Verify that Ollama is running ('ollama run nomic-embed-text'). Bypassing semantic cache for this request.\x1b[0m\n`);
+        return null;
+    }
+}
+async function semanticGet(prompt) {
+    if (!await isPro())
+        return null;
+    const emb = await getEmbedding(prompt);
+    if (!emb)
+        return null;
+    try {
+        const collection = await chroma.getOrCreateCollection({
+            name: 'lemma-cache',
+            embeddingFunction: dummyEmbeddingFunction,
+            metadata: { "hnsw:space": "cosine" }
+        });
+        const res = await collection.query({
+            queryEmbeddings: [emb],
+            nResults: 1
+        });
+        if (!res.ids[0] || res.ids[0].length === 0)
+            return null;
+        const distances = res.distances;
+        const distance = (distances && distances[0] && distances[0][0] !== null && distances[0][0] !== undefined) ? distances[0][0] : 1.0;
+        const similarity = Math.max(0, 1 - distance);
+        const THRESHOLD = 0.7;
+        if (similarity >= THRESHOLD) {
+            const metadata = res.metadatas[0][0];
+            return {
+                data: JSON.parse(metadata.response),
+                similarity,
+                id: res.ids[0][0],
+                prompt: metadata.prompt
+            };
+        }
+    }
+    catch (e) { }
+    return null;
+}
+async function semanticSet(prompt, data) {
+    if (!await isPro())
+        return;
+    const emb = await getEmbedding(prompt);
+    if (!emb)
+        return;
+    try {
+        const collection = await chroma.getOrCreateCollection({
+            name: 'lemma-cache',
+            embeddingFunction: dummyEmbeddingFunction,
+            metadata: { "hnsw:space": "cosine" }
+        });
+        await collection.add({
+            ids: [crypto_1.default.randomUUID?.() || Math.random().toString(36).substring(7)],
+            embeddings: [emb],
+            metadatas: [{
+                    prompt,
+                    response: JSON.stringify(data),
+                    timestamp: Date.now()
+                }],
+            documents: [prompt]
+        });
+    }
+    catch (e) { }
+}
+// ── Prompt extraction ──────────────────────────────────────────────────────────
+function extractPrompt(body, provider) {
+    const msgs = body.messages || [];
+    if (provider === 'openai' || provider === 'anthropic') {
+        return msgs.map((m) => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content))).join('\n');
+    }
+    if (provider === 'gemini') {
+        const contents = body.contents || [];
+        return contents.map((c) => c.parts.map((p) => p.text).join(' ')).join('\n');
+    }
+    return null;
+}
+// ── SSE helpers ────────────────────────────────────────────────────────────────
+function setSseHeaders(res, fromCache, similarity, tier) {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.setHeader('X-Lemma-Cache', fromCache ? 'HIT' : 'MISS');
+    res.setHeader('X-Lemma-Similarity', (similarity || 1.0).toFixed(3));
+    res.setHeader('X-Lemma-Tier', tier);
+}
+function buildOaiChunk(id, model, text, stop) {
+    return { id, object: 'chat.completion.chunk', created: Math.floor(Date.now() / 1000), model,
+        choices: [{ index: 0, delta: stop ? {} : { content: text }, finish_reason: stop ? 'stop' : null }] };
+}
+function buildAntChunk(text, stop) {
+    if (stop)
+        return { type: 'message_stop' };
+    return { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text } };
+}
+function buildGemChunk(text, stop) {
+    return { candidates: [{ content: { parts: [{ text }] }, finishReason: stop ? 'STOP' : undefined }] };
+}
+async function simulateHitStream(res, cachedData, provider, model, tier, similarity) {
+    setSseHeaders(res, true, similarity, tier);
+    const id = `lemma-${Date.now()}`;
+    let text = '';
+    try {
+        if (provider === 'openai')
+            text = cachedData?.choices?.[0]?.message?.content || '';
+        else if (provider === 'anthropic') {
+            const c = cachedData?.content;
+            text = Array.isArray(c) ? c.map((x) => x.text || '').join('') : String(c || '');
+        }
+        else if (provider === 'gemini') {
+            text = cachedData?.candidates?.[0]?.content?.parts?.[0]?.text || '';
+        }
+    }
+    catch { }
+    const words = text.split(' ');
+    for (let i = 0; i < words.length; i += 5) {
+        const chunk = words.slice(i, i + 5).join(' ');
+        let evt;
+        if (provider === 'openai')
+            evt = buildOaiChunk(id, model, chunk, false);
+        else if (provider === 'anthropic')
+            evt = buildAntChunk(chunk, false);
+        else if (provider === 'gemini')
+            evt = buildGemChunk(chunk, false);
+        res.write(provider === 'gemini' ? `${JSON.stringify(evt)}\n` : `data: ${JSON.stringify(evt)}\n\n`);
+        await new Promise(r => setTimeout(r, 15));
+    }
+    const stopEvt = provider === 'openai' ? buildOaiChunk(id, model, '', true) : (provider === 'anthropic' ? buildAntChunk('', true) : buildGemChunk('', true));
+    res.write(provider === 'gemini' ? `${JSON.stringify(stopEvt)}\n` : `data: ${JSON.stringify(stopEvt)}\n\n`);
+    if (provider !== 'gemini')
+        res.write('data: [DONE]\n\n');
+    res.end();
+}
+async function relayMissStream(res, body, provider, tier) {
+    setSseHeaders(res, false, 1.0, tier);
+    const apiKey = provider === 'openai' ? process.env.OPENAI_API_KEY : process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        res.write(`data: ${JSON.stringify({ error: `${provider.toUpperCase()}_API_KEY not set` })}\n\ndata: [DONE]\n\n`);
+        res.end();
+        return;
+    }
+    const hostname = provider === 'openai' ? 'api.openai.com' : 'api.anthropic.com';
+    const upPath = provider === 'openai' ? '/v1/chat/completions' : '/v1/messages';
+    const headers = provider === 'openai'
+        ? { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' }
+        : { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json' };
+    const payload = JSON.stringify({ ...body, stream: true });
+    await new Promise(resolve => {
+        const req = https_1.default.request({ hostname, port: 443, path: upPath, method: 'POST',
+            headers: { ...headers, 'Content-Length': Buffer.byteLength(payload) }
+        }, upstream => {
+            upstream.on('data', chunk => res.write(chunk));
+            upstream.on('end', () => { res.write('data: [DONE]\n\n'); res.end(); resolve(); });
+            upstream.on('error', err => { res.write(`data: ${JSON.stringify({ error: err.message })}\n\ndata: [DONE]\n\n`); res.end(); resolve(); });
+        });
+        req.on('error', err => { res.write(`data: ${JSON.stringify({ error: err.message })}\n\ndata: [DONE]\n\n`); res.end(); resolve(); });
+        req.write(payload);
+        req.end();
+    });
+}
+// ── Proxy Server class ─────────────────────────────────────────────────────────
+class LemmaServer {
+    constructor(port, projectName) {
+        this.stats = {};
+        this.port = port;
+        this.projectName = projectName || detectProject();
+        this.projectDir = ensureProjectDir(this.projectName);
+        this.app = (0, express_1.default)();
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        this.app.use(express_1.default.json({ limit: '10mb' }));
+        this.app.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.header('Access-Control-Allow-Headers', '*');
+            res.header('Access-Control-Allow-Methods', '*');
+            if (req.method === 'OPTIONS')
+                return res.sendStatus(200);
+            next();
+        });
+    }
+    setupRoutes() {
+        this.app.get('/health', async (req, res) => {
+            const pro = await isPro();
+            res.json({ status: 'ok', project: this.projectName, mode: pro ? 'pro' : 'standard', tier: pro ? 'pro' : 'free', port: this.port });
+        });
+        this.app.get('/v1/models', (req, res) => {
+            res.json({ object: 'list', data: [
+                    { id: 'gpt-4o', object: 'model', owned_by: 'lemma-proxy' },
+                    { id: 'claude-3-5-sonnet-20241022', object: 'model', owned_by: 'lemma-proxy' }
+                ] });
+        });
+        this.app.post('/v1/chat/completions', (req, res) => this.handleCompletion(req, res, 'openai'));
+        this.app.post('/v1/messages', (req, res) => this.handleCompletion(req, res, 'anthropic'));
+        this.app.post('/v1beta/models/:modelId:generateContent', (req, res) => this.handleCompletion(req, res, 'gemini'));
+        // Dashboard APIs
+        const dashboardPath = path_1.default.join(__dirname, 'dashboard', 'dist');
+        if (fs_1.default.existsSync(dashboardPath)) {
+            this.app.use('/dashboard/', express_1.default.static(dashboardPath));
+            this.app.get('/api/metrics', async (req, res) => {
+                const stats = this.stats[this.projectName] || { total: 0, hits: 0, misses: 0, totalLatency: 0, totalTokensSaved: 0 };
+                const hitRate = stats.total > 0 ? stats.hits / stats.total : 0;
+                const avgLat = stats.total > 0 ? stats.totalLatency / stats.total : 0;
+                const secretsMasked = EVENT_LOG.filter(e => e.type === 'privacy:mask').length;
+                res.json({
+                    timestamp: new Date().toISOString(),
+                    totalRequests: stats.total,
+                    cacheHits: stats.hits,
+                    cacheMisses: stats.misses,
+                    hitRate,
+                    averageLatency: avgLat,
+                    tokensSaved: stats.totalTokensSaved,
+                    costSaved: (stats.totalTokensSaved / 1000) * 0.02,
+                    secretsMasked: secretsMasked,
+                    activeAgents: 1,
+                    totalAgents: 1,
+                    uptime: process.uptime(),
+                    tier: (await isPro()) ? 'pro' : 'free'
+                });
+            });
+            this.app.get('/api/agents', async (req, res) => {
+                const stats = await loadStats();
+                res.json({ agents: [
+                        { id: 'lemma-gateway', name: 'Lemma Gateway', status: 'active', capabilities: ['Privacy Firewall', 'Semantic Cache', 'Complexity Router'], tasksCompleted: stats[this.projectName]?.total || 0, lastSeen: new Date().toISOString(), errorCount: 0, cacheHitRate: 0.85 }
+                    ] });
+            });
+            this.app.get('/api/events', (req, res) => {
+                const page = parseInt(req.query.page) || 1;
+                const limit = parseInt(req.query.limit) || 50;
+                const start = (page - 1) * limit;
+                const events = EVENT_LOG.slice().reverse().slice(start, start + limit);
+                res.json({ events, pagination: { total: EVENT_LOG.length, page, limit } });
+            });
+            this.app.get('/api/cache-stats', (req, res) => {
+                res.json({ topQueries: [] });
+            });
+            this.app.get('/api/search', async (req, res) => {
+                const query = req.query.q;
+                if (!query)
+                    return res.status(400).json({ error: 'Query required' });
+                try {
+                    const emb = await getEmbedding(query);
+                    if (!emb)
+                        throw new Error('Failed to generate embedding');
+                    const collection = await chroma.getOrCreateCollection({
+                        name: 'lemma-cache',
+                        embeddingFunction: dummyEmbeddingFunction,
+                        metadata: { "hnsw:space": "cosine" }
+                    });
+                    const results = await collection.query({
+                        queryEmbeddings: [emb],
+                        nResults: 10
+                    });
+                    const formatted = (results.ids[0] || []).map((id, i) => {
+                        const meta = results.metadatas[0][i];
+                        const dists = results.distances;
+                        const dist = (dists && dists[0] && dists[0][i] !== null && dists[0][i] !== undefined) ? dists[0][i] : 1.0;
+                        return {
+                            id,
+                            prompt: meta.prompt,
+                            response: JSON.parse(meta.response),
+                            timestamp: meta.timestamp,
+                            similarity: 1 - dist
+                        };
+                    });
+                    res.json({ results: formatted });
+                }
+                catch (e) {
+                    res.status(500).json({ error: e.message });
+                }
+            });
+            this.app.post('/api/cache/clear', (req, res) => {
+                const count = CACHE.size;
+                CACHE.clear();
+                res.json({ success: true, clearedEntries: count });
+            });
+            this.app.get('/dashboard/*', (req, res) => res.sendFile(path_1.default.join(dashboardPath, 'index.html')));
+        }
+    }
+    async handleCompletion(req, res, provider) {
+        const t0 = Date.now();
+        const pro = await isPro();
+        const tier = pro ? 'pro' : 'standard';
+        const isStream = !!req.body.stream;
+        let historyTokensSaved = 0;
+        if (!pro) {
+            const usage = await loadUsage();
+            if (usage.count >= FREE_LIMIT) {
+                return res.status(429).json({ error: { message: `Free tier limit (${FREE_LIMIT}/mo). Upgrade: https://lemma.nxus.studio/upgrade` } });
+            }
+        }
+        const rawPrompt = extractPrompt(req.body, provider);
+        if (!rawPrompt)
+            return res.status(400).json({ error: 'Invalid request format' });
+        const { maskedPrompt: prompt, tokenMap } = semanticScrubber.mask(rawPrompt);
+        if (Object.keys(tokenMap).length > 0) {
+            logEvent({ type: 'privacy:mask', count: Object.keys(tokenMap).length, project: this.projectName });
+        }
+        const originalModel = req.body.model || 'gpt-4o';
+        const routingDecision = complexityRouter.evaluate(prompt, originalModel);
+        const model = routingDecision.model;
+        if (req.body.model)
+            req.body.model = model;
+        // Apply the Agent Multiplexer to local-verify the prompt in parallel
+        const enrichedPrompt = await agentMultiplexer.multiplexPrompt(prompt, model);
+        // Compress long TS/JS codebase file blocks in the enriched prompt using the Context Squeezer AST Tree-Shaker!
+        // The query context is the user's primary prompt to ensure we keep relevant methods!
+        const squeezeResult = (0, ContextSqueezer_1.squeezePrompt)(enrichedPrompt, prompt);
+        const squeezedPrompt = squeezeResult.squeezed;
+        const compressionSavings = squeezeResult.originalSize - squeezeResult.squeezedSize;
+        if (compressionSavings > 0) {
+            console.log(`⚡ [Squeezer] Compressed prompt from ${squeezeResult.originalSize} to ${squeezeResult.squeezedSize} chars (Saved ${(squeezeResult.compressionRatio * 100).toFixed(1)}% context tokens!)`);
+        }
+        if (provider === 'openai' || provider === 'anthropic') {
+            if (req.body.messages && req.body.messages.length > 0) {
+                req.body.messages[req.body.messages.length - 1].content = squeezedPrompt;
+                // Apply conversational history pruning to save tokens on historical messages!
+                const pruneResult = (0, ContextSqueezer_1.pruneHistoryMessages)(req.body.messages);
+                req.body.messages = pruneResult.messages;
+                historyTokensSaved = pruneResult.tokensSavedEstimate + Math.floor(compressionSavings / 4);
+            }
+        }
+        else if (provider === 'gemini') {
+            if (req.body.contents && req.body.contents.length > 0) {
+                const lastContent = req.body.contents[req.body.contents.length - 1];
+                if (lastContent.parts && lastContent.parts.length > 0) {
+                    lastContent.parts[lastContent.parts.length - 1].text = squeezedPrompt;
+                }
+            }
+        }
+        const hit = cacheGet(prompt);
+        if (hit) {
+            await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, 2000 + historyTokensSaved);
+            const unmaskedData = semanticScrubber.unmask(hit.data, tokenMap);
+            if (isStream)
+                return simulateHitStream(res, unmaskedData, provider, model, tier, 1.0);
+            res.setHeader('X-Lemma-Cache', 'HIT');
+            res.setHeader('X-Lemma-Similarity', '1.000');
+            res.setHeader('X-Lemma-Tier', tier);
+            return res.json(unmaskedData);
+        }
+        if (pro) {
+            const semHit = await semanticGet(prompt);
+            if (semHit) {
+                if (semHit.similarity >= 0.90) {
+                    await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, 2000 + historyTokensSaved);
+                    const unmaskedData = semanticScrubber.unmask(semHit.data, tokenMap);
+                    if (isStream)
+                        return simulateHitStream(res, unmaskedData, provider, model, tier, semHit.similarity);
+                    res.setHeader('X-Lemma-Cache', 'HIT');
+                    res.setHeader('X-Lemma-Similarity', semHit.similarity.toFixed(3));
+                    res.setHeader('X-Lemma-Tier', tier);
+                    return res.json(unmaskedData);
+                }
+                else if (semHit.similarity >= 0.70) {
+                    console.log(`💡 [CARS] Near Cache Hit (Similarity: ${(semHit.similarity * 100).toFixed(1)}%). Synthesizing answer locally via Ollama...`);
+                    let cachedContent = '';
+                    if (provider === 'openai') {
+                        cachedContent = semHit.data.choices?.[0]?.message?.content || '';
+                    }
+                    else if (provider === 'anthropic') {
+                        cachedContent = semHit.data.content?.[0]?.text || '';
+                    }
+                    if (cachedContent) {
+                        const synthesisPrompt = `You are a local helper AI. You have an exact previous query and its professional answer from a cloud LLM.
+Your task is to adjust/synthesize the previous answer slightly so that it perfectly matches the new query. Do not perform any unnecessary changes. Keep the exact premium style of the answer.
+
+Previous Query:
+${semHit.prompt}
+
+Previous Answer:
+${cachedContent}
+
+New Query:
+${prompt}
+
+Adjusted Answer:`;
+                        try {
+                            const carsResponse = await axios_1.default.post('http://127.0.0.1:11434/api/generate', {
+                                model: 'llama3',
+                                prompt: synthesisPrompt,
+                                stream: false
+                            }, { timeout: 15000 });
+                            const adjustedText = carsResponse.data.response || '';
+                            if (adjustedText && adjustedText.length > 20) {
+                                const synthesizedData = JSON.parse(JSON.stringify(semHit.data));
+                                if (provider === 'openai') {
+                                    synthesizedData.choices[0].message.content = adjustedText;
+                                }
+                                else if (provider === 'anthropic') {
+                                    synthesizedData.content[0].text = adjustedText;
+                                }
+                                await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, 2000 + historyTokensSaved);
+                                const unmaskedData = semanticScrubber.unmask(synthesizedData, tokenMap);
+                                if (isStream) {
+                                    return simulateHitStream(res, unmaskedData, provider, model, tier, semHit.similarity);
+                                }
+                                res.setHeader('X-Lemma-Cache', 'HIT-CARS');
+                                res.setHeader('X-Lemma-Similarity', semHit.similarity.toFixed(3));
+                                res.setHeader('X-Lemma-Tier', tier);
+                                return res.json(unmaskedData);
+                            }
+                        }
+                        catch (carsErr) {
+                            console.log(`⚠️ [CARS] Local synthesis failed or Ollama offline (${carsErr.message}). Falling back to cloud.`);
+                        }
+                    }
+                }
+            }
+            const cloudHit = await cloudSync.get(prompt);
+            if (cloudHit) {
+                cacheSet(prompt, cloudHit.data);
+                await recordStat(this.stats, this.projectName, true, Date.now() - t0, provider, 2000 + historyTokensSaved);
+                const unmaskedData = semanticScrubber.unmask(cloudHit.data, tokenMap);
+                if (isStream)
+                    return simulateHitStream(res, unmaskedData, provider, model, tier, cloudHit.similarity || 0.95);
+                res.setHeader('X-Lemma-Cache', 'HIT');
+                res.setHeader('X-Lemma-Similarity', (cloudHit.similarity || 0.95).toFixed(3));
+                res.setHeader('X-Lemma-Tier', tier);
+                return res.json(unmaskedData);
+            }
+        }
+        if (isStream) {
+            await recordStat(this.stats, this.projectName, false, Date.now() - t0, provider, historyTokensSaved);
+            if (!pro) {
+                const u = await loadUsage();
+                u.count++;
+                await writeJson(USAGE_FILE, u);
+            }
+            return relayMissStream(res, req.body, provider, tier);
+        }
+        try {
+            const data = await this.callUpstream(req.body, provider);
+            cacheSet(prompt, data);
+            if (pro) {
+                await semanticSet(prompt, data);
+                await cloudSync.set(prompt, data);
+            }
+            if (!pro) {
+                const u = await loadUsage();
+                u.count++;
+                await writeJson(USAGE_FILE, u);
+            }
+            await recordStat(this.stats, this.projectName, false, Date.now() - t0, provider, historyTokensSaved);
+            return res.json(semanticScrubber.unmask(data, tokenMap));
+        }
+        catch (err) {
+            return res.status(500).json({ error: err.message });
+        }
+    }
+    async callUpstream(body, provider) {
+        let apiKey = provider === 'openai' ? process.env.OPENAI_API_KEY : (provider === 'anthropic' ? process.env.ANTHROPIC_API_KEY : process.env.GEMINI_API_KEY);
+        if (!apiKey) {
+            console.log(`\n\x1b[33m⚠️  No API Key found for ${provider.toUpperCase()}. Falling back to local Ollama (Zero-Cost Mode)!\x1b[0m`);
+            const model = body.model || 'llama3';
+            const baseURL = 'http://127.0.0.1:11434/v1/chat/completions';
+            try {
+                const resp = await axios_1.default.post(baseURL, {
+                    ...body,
+                    model: model
+                }, { timeout: 30000 });
+                return resp.data;
+            }
+            catch (e) {
+                throw new Error(`No API Key found and Ollama is offline. Please set ${provider.toUpperCase()}_API_KEY or start Ollama.`);
+            }
+        }
+        const baseURL = provider === 'openai' ? 'https://api.openai.com/v1/chat/completions' : (provider === 'anthropic' ? 'https://api.anthropic.com/v1/messages' : `https://generativelanguage.googleapis.com/v1beta/models/${body.model || 'gemini-1.5-pro'}:generateContent?key=${apiKey}`);
+        const headers = provider === 'openai' ? { Authorization: `Bearer ${apiKey}` } : (provider === 'anthropic' ? { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' } : {});
+        const resp = await axios_1.default.post(baseURL, body, { headers: { ...headers, 'Content-Type': 'application/json' } });
+        return resp.data;
+    }
+    async start() {
+        this.stats = await loadStats();
+        const server = http_1.default.createServer(this.app);
+        server.on('error', (e) => {
+            if (e.code === 'EADDRINUSE') {
+                console.error(`\n❌ Error: Port ${this.port} is already in use.`);
+                console.error(`💡 Try stopping the existing process with 'lemma stop' or use a different port with '--port <number>'.\n`);
+                process.exit(1);
+            }
+            throw e;
+        });
+        server.listen(this.port, async () => {
+            fs_1.default.writeFileSync(PID_FILE, String(process.pid));
+            fs_1.default.writeFileSync(PORT_FILE, String(this.port));
+            const pro = await isPro();
+            console.log(`\x1b[1m\x1b[35m┌──────────────────────────────────────────────────────────┐\x1b[0m`);
+            console.log(`\x1b[1m\x1b[35m│   🚀 LEMMA PROXY v${VERSION} — THE UNIVERSAL AI GATEWAY      │\x1b[0m`);
+            console.log(`\x1b[1m\x1b[35m└──────────────────────────────────────────────────────────┘\x1b[0m`);
+            console.log(`\n📁 Project : ${this.projectName}\n🔌 Port    : ${this.port}`);
+            console.log('\n🧠 Intelligence Report');
+            console.log('────────────────────────────────────────────────');
+            console.log(`🔒 Privacy Firewall      : \x1b[32m[ACTIVE]\x1b[0m`);
+            console.log(`🔀 Complexity Router     : \x1b[32m[ACTIVE]\x1b[0m`);
+            console.log(`💾 Exact Cache           : \x1b[32m[ACTIVE]\x1b[0m`);
+            const ollamaOk = await checkDependency('http://localhost:11434/api/tags');
+            const chromaOk = await checkDependency('http://localhost:8000/');
+            if (pro) {
+                console.log(`🎯 Semantic Cache        : ${ollamaOk && chromaOk ? '\x1b[32m[ACTIVE]\x1b[0m' : '\x1b[33m[OFFLINE - Check Ollama/Chroma]\x1b[0m'}`);
+                console.log(`🌐 Hive Mind (Cloud)     : \x1b[32m[ACTIVE]\x1b[0m`);
+            }
+            else {
+                console.log(`🎯 Semantic Cache        : \x1b[90m[PRO ONLY]\x1b[0m -> https://lemma.nxus.studio/upgrade`);
+                console.log(`🌐 Hive Mind (Cloud)     : \x1b[90m[PRO ONLY]\x1b[0m -> https://lemma.nxus.studio/upgrade`);
+            }
+            const hasStackDir = fs_1.default.existsSync(path_1.default.join(process.cwd(), '.lemma'));
+            console.log(`📡 Telepathic Sync       : ${hasStackDir ? '\x1b[32m[READY]\x1b[0m' : '\x1b[90m[DISABLED - Run "lemma init"]\x1b[0m'}`);
+            console.log('────────────────────────────────────────────────\n');
+            if (!pro) {
+                console.log('\x1b[36m💡 Unlock Semantic Search & Team Caching at https://lemma.nxus.studio/upgrade\x1b[0m\n');
+            }
+            console.log('\x1b[35m✨ Zero-Config IDE Integration (MCP)\x1b[0m');
+            console.log('────────────────────────────────────────────────');
+            console.log('To use Lemma as a Tool in Cursor or Claude Desktop,');
+            console.log('simply copy-paste this command into your MCP settings:');
+            console.log(`\n   \x1b[1m\x1b[33mlemma mcp\x1b[0m\n`);
+            console.log('────────────────────────────────────────────────\n');
+        });
+        process.on('SIGTERM', () => server.close());
+    }
+}
+// ── CLI ────────────────────────────────────────────────────────────────────────
+commander_1.program.name('lemma').description('Lemma Proxy CLI — Intelligent AI Gateway').version(VERSION);
+commander_1.program.command('mcp')
+    .description('Start the Lemma MCP Server (Model Context Protocol)')
+    .action(() => {
+    const { spawn } = require('child_process');
+    const mcpPath = path_1.default.join(__dirname, 'src', 'mcp', 'index.ts');
+    const mcpDistPath = path_1.default.join(__dirname, 'dist', 'cjs', 'mcp', 'index.js');
+    let target = mcpPath;
+    let cmd = 'npx';
+    let args = ['tsx', mcpPath];
+    if (!fs_1.default.existsSync(mcpPath) && fs_1.default.existsSync(mcpDistPath)) {
+        target = mcpDistPath;
+        cmd = 'node';
+        args = [mcpDistPath];
+    }
+    const mcp = spawn(cmd, args, { stdio: 'inherit' });
+    mcp.on('exit', (code) => process.exit(code || 0));
+});
+commander_1.program.command('start')
+    .description('Start the proxy server')
+    .option('-p, --port <number>', 'Port to listen on', '8081')
+    .option('--project <name>', 'Override project name')
+    .option('--stack', 'Launch full development stack (Chroma + Router + Dashboard + Autopilot)')
+    .option('--autopilot', 'Launch background compiler watcher & healer', false)
+    .action(async (opts) => {
+    const port = parseInt(opts.port, 10);
+    try {
+        const resp = await axios_1.default.get(`http://localhost:${port}/health`, { timeout: 500 });
+        if (resp.data && resp.data.status === 'ok') {
+            console.log(`\n⚠️  Lemma Proxy is already running on port ${port} (Project: ${resp.data.project})`);
+            console.log(`💡 Use 'lemma status' for details or 'lemma stop' to restart.\n`);
+            process.exit(0);
+        }
+    }
+    catch { }
+    // Automatically enable autopilot if stack is enabled and user is Pro
+    const runAutopilot = opts.autopilot || opts.stack;
+    if (runAutopilot) {
+        try {
+            const pro = await isPro();
+            if (!pro) {
+                if (opts.autopilot) {
+                    console.log(`\n🛸 \x1b[35m[Autopilot]\x1b[0m Active background auto-healing watcher is a Lemma Pro feature.`);
+                    console.log(`💡 Upgrade to Pro in your Dashboard or visit: \x1b[4mhttps://lemma.nxus.studio/upgrade\x1b[0m\n`);
+                }
+                else {
+                    console.log(`\n🛸 \x1b[35m[Autopilot]\x1b[0m Skipping Autopilot background watcher launch (exclusive to Lemma Pro).`);
+                }
+            }
+            else {
+                const { AutopilotWatcher } = require('../autopilot/AutopilotWatcher');
+                const watcher = new AutopilotWatcher('src');
+                watcher.start();
+            }
+        }
+        catch (err) {
+            console.log(`⚠️ Could not initialize Autopilot: ${err.message}`);
+        }
+    }
+    if (opts.stack) {
+        const { spawn } = require('child_process');
+        console.log('🚀 Launching Lemma Full Stack...');
+        const chromaProcess = spawn('chroma', ['run', '--path', './chroma_data'], { stdio: 'ignore', detached: true });
+        chromaProcess.unref();
+        console.log('   ✅ ChromaDB requested');
+        const dash = spawn('npm', ['run', 'dev', '--prefix', 'dashboard', '--', '--port', '8082'], { stdio: 'ignore', detached: true });
+        dash.unref();
+        console.log('   ✅ Dashboard requested (http://localhost:8082)');
+        console.log('   🚀 Starting Router & Proxy...\n');
+        const stackScript = fs_1.default.existsSync(path_1.default.join(__dirname, 'dist', 'cjs', 'cli', 'stack.js'))
+            ? path_1.default.join(__dirname, 'dist', 'cjs', 'cli', 'stack.js')
+            : (fs_1.default.existsSync(path_1.default.join(__dirname, 'src', 'cli', 'stack.ts')) ? 'src/cli/stack.ts' : null);
+        if (!stackScript) {
+            console.error('❌ Error: Could not find Lemma Stack script. Reinstall the package.');
+            process.exit(1);
+        }
+        const routerCmd = stackScript.endsWith('.ts') ? ['npx', 'tsx', stackScript] : ['node', stackScript];
+        const router = spawn(routerCmd[0], routerCmd.slice(1), {
+            stdio: 'inherit',
+            env: { ...process.env, WS_PORT: '8080', DASHBOARD_API_PORT: '8083' }
+        });
+        const server = new LemmaServer(port, opts.project || null);
+        await server.start();
+        router.on('exit', (code) => {
+            console.log(`\n🛑 Router exited with code ${code}`);
+            process.exit(code || 0);
+        });
+    }
+    else {
+        const server = new LemmaServer(port, opts.project || null);
+        await server.start();
+    }
+});
+commander_1.program.command('stop')
+    .description('Stop the proxy server')
+    .option('-p, --port <number>', 'Port to check', '8081')
+    .action(async (opts) => {
+    const port = parseInt(opts.port, 10);
+    let stopped = false;
+    try {
+        if (fs_1.default.existsSync(PID_FILE)) {
+            const pid = fs_1.default.readFileSync(PID_FILE, 'utf8');
+            try {
+                process.kill(parseInt(pid), 'SIGTERM');
+                stopped = true;
+            }
+            catch { }
+        }
+        if (!stopped) {
+            const pidByPort = getPidByPort(port);
+            if (pidByPort) {
+                process.kill(parseInt(pidByPort), 'SIGTERM');
+                console.log(`✅ Stopped process ${pidByPort} on port ${port}`);
+                stopped = true;
+            }
+        }
+        if (stopped) {
+            console.log('✅ Stopped');
+        }
+        else {
+            console.log('⚠️  No running process found.');
+        }
+    }
+    catch {
+        console.log('⚠️  Could not stop process.');
+    }
+    if (fs_1.default.existsSync(PID_FILE))
+        fs_1.default.unlinkSync(PID_FILE);
+});
+commander_1.program.command('status')
+    .description('Check proxy status')
+    .action(async () => {
+    const port = fs_1.default.existsSync(PORT_FILE) ? fs_1.default.readFileSync(PORT_FILE, 'utf8') : '8081';
+    try {
+        const resp = await axios_1.default.get(`http://localhost:${port}/health`, { timeout: 1000 });
+        if (resp.data && resp.data.status === 'ok') {
+            console.log(`✅ Running (Project: ${resp.data.project}, Port: ${port})`);
+        }
+        else {
+            console.log('❌ Stopped (Health check failed)');
+        }
+    }
+    catch {
+        console.log('❌ Stopped');
+        if (fs_1.default.existsSync(PID_FILE))
+            fs_1.default.unlinkSync(PID_FILE);
+    }
+});
+commander_1.program.command('stats')
+    .description('Show usage statistics')
+    .action(async () => {
+    const stats = await loadStats();
+    const usage = await loadUsage();
+    const project = detectProject();
+    const s = stats[project] || { total: 0, hits: 0, misses: 0, totalLatency: 0, totalTokensSaved: 0 };
+    console.log(`\n📊 Lemma Stats for [${project}]`);
+    console.log(`──────────────────────────────────`);
+    console.log(`Total Requests : ${s.total}`);
+    console.log(`Cache Hits     : ${s.hits} (${((s.hits / s.total || 0) * 100).toFixed(1)}%)`);
+    console.log(`Tokens Saved   : ${s.totalTokensSaved.toLocaleString()}`);
+    console.log(`Avg Latency    : ${(s.totalLatency / (s.total || 1)).toFixed(2)}ms`);
+    console.log(`Tier           : ${(await isPro()) ? 'PRO' : 'FREE'}`);
+    if (!await isPro())
+        console.log(`Free Usage     : ${usage.count}/${FREE_LIMIT} requests`);
+    console.log(`──────────────────────────────────\n`);
+});
+commander_1.program.command('activate <key>')
+    .description('Activate Pro features with a license key')
+    .action(async (key) => {
+    console.log('🔑 Validating license key...');
+    try {
+        const res = await validateKeyRemote(key);
+        if (res.valid) {
+            await writeJson(LICENSE_FILE, { key, isPro: true, activatedAt: new Date().toISOString() });
+            console.log('✅ License activated! Enjoy Pro features.');
+        }
+        else {
+            console.log('❌ Invalid license key.');
+        }
+    }
+    catch (e) {
+        console.error('❌ Error validating key:', e.message);
+    }
+});
+commander_1.program.command('init')
+    .description('Initialize Lemma in the current project (auto-discovery)')
+    .action(() => {
+    const project = detectProject();
+    console.log(`\n🛠️  Initializing Lemma for [${project}]...`);
+    const lemmaDir = path_1.default.join(process.cwd(), '.lemma');
+    if (!fs_1.default.existsSync(lemmaDir)) {
+        fs_1.default.mkdirSync(lemmaDir, { recursive: true });
+        console.log('✅ Created .lemma directory (Telepathic Sync enabled)');
+    }
+    if (ensureGitIgnore()) {
+        console.log('✅ Added .lemma/ to .gitignore');
+    }
+    const envFile = path_1.default.join(process.cwd(), '.env');
+    const lemmaConfig = `\n# Lemma AI Gateway Configuration\nOPENAI_BASE_URL=http://localhost:8081/v1\nLEMMA_PROJECT=${project}\n`;
+    if (fs_1.default.existsSync(envFile)) {
+        const content = fs_1.default.readFileSync(envFile, 'utf8');
+        if (content.includes('OPENAI_BASE_URL')) {
+            console.log('⚠️  OPENAI_BASE_URL already exists in .env. Update it to: http://localhost:8081/v1');
+        }
+        else {
+            fs_1.default.appendFileSync(envFile, lemmaConfig);
+            console.log('✅ Added Lemma configuration to .env');
+        }
+    }
+    else {
+        fs_1.default.writeFileSync(envFile, lemmaConfig);
+        console.log('✅ Created .env with Lemma configuration');
+    }
+    console.log('\n🧠 \x1b[35mAuto-Setup MCP for AI IDEs?\x1b[0m');
+    console.log('   Lemma can automatically configure Claude Desktop and open settings for Cursor/Windsurf.');
+    const { exec } = require('child_process');
+    const isWin = process.platform === 'win32';
+    const claudePath = isWin
+        ? path_1.default.join(process.env.APPDATA || '', 'Claude/claude_desktop_config.json')
+        : path_1.default.join(process.env.HOME || '~', 'Library/Application Support/Claude/claude_desktop_config.json');
+    if (fs_1.default.existsSync(path_1.default.dirname(claudePath))) {
+        try {
+            let config = { mcpServers: {} };
+            if (fs_1.default.existsSync(claudePath)) {
+                config = JSON.parse(fs_1.default.readFileSync(claudePath, 'utf8'));
+            }
+            if (!config.mcpServers)
+                config.mcpServers = {};
+            config.mcpServers.lemma = {
+                command: 'npx',
+                args: ['-y', '@nxuss/lemma', 'mcp'],
+                env: { LEMMA_PROJECT: project }
+            };
+            fs_1.default.writeFileSync(claudePath, JSON.stringify(config, null, 2));
+            console.log(`✅ \x1b[32mClaude Desktop configured automatically!\x1b[0m (Restart Claude to activate)`);
+        }
+        catch (e) {
+            console.log('⚠️  Could not auto-configure Claude Desktop. No worries, you can do it manually.');
+        }
+    }
+    console.log('🚀 Opening IDE configuration pages...');
+    const urls = [
+        'https://docs.anthropic.com/en/docs/agents-and-tools/mcp#using-mcp-in-claude-desktop',
+        'https://cursor.com',
+        'https://codeium.com/windsurf'
+    ];
+    const opener = process.platform === 'darwin' ? 'open' : (process.platform === 'win32' ? 'start' : 'xdg-open');
+    urls.forEach(url => exec(`${opener} ${url}`));
+    console.log('\n✨ Project initialized for the Agentic Era!');
+    console.log('🚀 Run "lemma start" to begin.\n');
+});
+// ── Auto-Healing Diagnostics (Zero-Cost Suite) ───────────────────────────────
+async function performAutoHeal(apply) {
+    const contextPath = path_1.default.join(process.cwd(), '.lemma', 'live-context.md');
+    if (!fs_1.default.existsSync(contextPath)) {
+        return { success: false, message: 'No crash report found in .lemma/live-context.md. Run "lemma init" or make sure your server has crashed first.' };
+    }
+    const md = fs_1.default.readFileSync(contextPath, 'utf8');
+    // Extract file path and error from markdown
+    const fileRegex = /((?:\/[a-zA-Z0-9._-]+)+):(\d+):(\d+)/;
+    const match = md.match(fileRegex) || md.match(/in\s+([^\s:]+\.[a-zA-Z0-9]+):(\d+)/);
+    let targetFile = '';
+    let lineNum = 0;
+    if (match) {
+        targetFile = match[1];
+        lineNum = parseInt(match[2], 10);
+    }
+    // Clean target file path to make it absolute or relative to project
+    if (targetFile && !path_1.default.isAbsolute(targetFile)) {
+        targetFile = path_1.default.resolve(process.cwd(), targetFile);
+    }
+    else if (!targetFile) {
+        // If not found in stack trace format, parse by search
+        const fileSearch = md.match(/Message:\s+.*\s+in\s+([^\n]+)/);
+        if (fileSearch) {
+            targetFile = path_1.default.resolve(process.cwd(), fileSearch[1].trim());
+        }
+    }
+    if (!targetFile || !fs_1.default.existsSync(targetFile)) {
+        return { success: false, message: `Could not reliably locate the crashed file in the stack trace. Extracted file path: ${targetFile || 'None'}` };
+    }
+    const fileContent = fs_1.default.readFileSync(targetFile, 'utf8');
+    const errorMsg = md.match(/Message:\s+([^\n]+)/)?.[1] || 'Unknown Runtime Error';
+    console.log(`\n🩺 \x1b[36mDiagnosing crash in:\x1b[0m ${path_1.default.basename(targetFile)}:line ${lineNum}`);
+    console.log(`❌ \x1b[31mError message:\x1b[0m ${errorMsg}`);
+    // Generate prompt for the LLM
+    const prompt = `You are Lemma's Auto-Healing Diagnostics Agent.
+We detected a runtime crash in the local codebase.
+File: ${targetFile}
+Line of failure: ${lineNum}
+Error: ${errorMsg}
+
+Here is the context of the crash log:
+\`\`\`markdown
+${md}
+\`\`\`
+
+Here is the source code of the file causing the crash:
+\`\`\`typescript
+${fileContent}
+\`\`\`
+
+Please analyze the crash and provide:
+1. A brief 1-2 sentence explanation of why it crashed.
+2. A drop-in replacement or patch for the file.
+Return your response in a clear JSON format with two keys:
+{
+  "explanation": "Why it crashed",
+  "fixedContent": "Complete fixed code of the file"
+}
+Ensure you return strictly JSON. Do not return any other text outside the JSON block.`;
+    // Call local Ollama or the premium model
+    console.log('🧠 Running AI Diagnostics...');
+    let apiKey = process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.GEMINI_API_KEY;
+    let fixedJson = null;
+    try {
+        if (!apiKey) {
+            // Attempt local Ollama first
+            try {
+                const resp = await axios_1.default.post('http://127.0.0.1:11434/api/generate', {
+                    model: 'llama3',
+                    prompt,
+                    stream: false,
+                    format: 'json'
+                }, { timeout: 3000 });
+                fixedJson = JSON.parse(resp.data.response);
+            }
+            catch (ollamaErr) {
+                // Local Ollama is offline! Fall back to expert static heuristic fixer!
+                console.log('💡 Ollama offline. Activating Offline Heuristic Auto-Healer Fallback...');
+                // Let's deduce the fix based on the file content and crash details
+                let healedCode = fileContent;
+                let healedExplanation = "Offline Heuristic Auto-Heal";
+                if (errorMsg.includes('assignable to type')) {
+                    // e.g. "Type 'string' is not assignable to type 'number'."
+                    const lines = fileContent.split('\n');
+                    const buggyLineIdx = lineNum - 1;
+                    if (buggyLineIdx >= 0 && buggyLineIdx < lines.length) {
+                        const buggyLine = lines[buggyLineIdx];
+                        if (buggyLine.includes(': number') && buggyLine.includes('"')) {
+                            lines[buggyLineIdx] = buggyLine.replace(': number', ': string');
+                            healedCode = lines.join('\n');
+                            healedExplanation = "Fixed TypeScript type mismatch: changed number to string annotation.";
+                        }
+                        else if (buggyLine.includes(': string')) {
+                            lines[buggyLineIdx] = buggyLine.replace(': string', ': any');
+                            healedCode = lines.join('\n');
+                            healedExplanation = "Fixed TypeScript type mismatch: changed string to any annotation.";
+                        }
+                        else {
+                            lines[buggyLineIdx] = buggyLine.replace(': number', ': any');
+                            healedCode = lines.join('\n');
+                            healedExplanation = "Fixed TypeScript type mismatch: changed number to any annotation.";
+                        }
+                    }
+                }
+                else if (errorMsg.includes('unbalanced') || errorMsg.includes('curly braces')) {
+                    // Add missing brace at end of file
+                    healedCode = fileContent.trim() + '\n}\n';
+                    healedExplanation = "Balanced unclosed curly brace syntax at end of file.";
+                }
+                else {
+                    healedCode = fileContent;
+                    healedExplanation = "Offline check completed. Please activate Ollama or add an API key for deep analysis.";
+                }
+                fixedJson = {
+                    explanation: healedExplanation,
+                    fixedContent: healedCode
+                };
+            }
+        }
+        else {
+            // Use OpenAI/Anthropic
+            const resp = await axios_1.default.post('https://api.openai.com/v1/chat/completions', {
+                model: 'gpt-4o',
+                messages: [{ role: 'user', content: prompt }],
+                response_format: { type: 'json_object' }
+            }, {
+                headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+                timeout: 45000
+            });
+            fixedJson = JSON.parse(resp.data.choices[0].message.content);
+        }
+    }
+    catch (e) {
+        return { success: false, message: `AI Diagnostics failed: ${e.message}. Ensure Ollama is running or API key is set.` };
+    }
+    if (!fixedJson || !fixedJson.fixedContent) {
+        return { success: false, message: 'AI returned an invalid JSON response structure.' };
+    }
+    const fixedContent = fixedJson.fixedContent;
+    const explanation = fixedJson.explanation;
+    console.log(`\n💡 \x1b[32mDiagnostics:\x1b[0m ${explanation}\n`);
+    if (apply) {
+        fs_1.default.writeFileSync(targetFile, fixedContent, 'utf8');
+        console.log(`\x1b[32m✔ Successfully applied fix to:\x1b[0m ${targetFile}`);
+        return { success: true, message: `Successfully healed file: ${explanation}`, filePath: targetFile };
+    }
+    else {
+        // Generate a simple diff
+        const tempFile = targetFile + '.fixed';
+        fs_1.default.writeFileSync(tempFile, fixedContent, 'utf8');
+        try {
+            const { execSync } = require('child_process');
+            const diff = execSync(`diff -u "${targetFile}" "${tempFile}"`).toString();
+            fs_1.default.unlinkSync(tempFile);
+            return { success: true, message: explanation, patch: diff, filePath: targetFile, fileBefore: fileContent, fileAfter: fixedContent };
+        }
+        catch (e) {
+            if (e.stdout) {
+                fs_1.default.unlinkSync(tempFile);
+                return { success: true, message: explanation, patch: e.stdout.toString(), filePath: targetFile, fileBefore: fileContent, fileAfter: fixedContent };
+            }
+            fs_1.default.unlinkSync(tempFile);
+            return { success: true, message: explanation, filePath: targetFile, fileBefore: fileContent, fileAfter: fixedContent };
+        }
+    }
+}
+commander_1.program.command('heal')
+    .description('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 {
+        const pro = await isPro();
+        if (!pro) {
+            console.log(`\n🩺 \x1b[35m[Heal]\x1b[0m Guided code diagnostics and auto-healing is a Lemma Pro feature.`);
+            console.log(`💡 Upgrade to Pro in your Dashboard or visit: \x1b[4mhttps://lemma.nxus.studio/upgrade\x1b[0m\n`);
+            process.exit(0);
+        }
+        const res = await performAutoHeal(opts.apply);
+        if (!res.success) {
+            console.error(`\n❌ Error: ${res.message}\n`);
+            process.exit(1);
+        }
+        if (!opts.apply && res.patch) {
+            console.log('📝 \x1b[35mProposed Code Fix Patch:\x1b[0m');
+            console.log('────────────────────────────────────────────────');
+            console.log(res.patch);
+            console.log('────────────────────────────────────────────────');
+            console.log('💡 Run \x1b[1m\x1b[33mlemma heal --apply\x1b[0m to apply this fix automatically.\n');
+        }
+    }
+    catch (err) {
+        console.error('❌ Exception during healing:', err.message);
+        process.exit(1);
+    }
+});
+commander_1.program.command('autopilot')
+    .description('Start the autonomous background compiler watcher & active healer')
+    .option('--dir <directory>', 'Directory to monitor for changes', 'src')
+    .action(async (opts) => {
+    try {
+        const pro = await isPro();
+        if (!pro) {
+            console.log(`\n🛸 \x1b[35m[Autopilot]\x1b[0m Active background auto-healing watcher is a Lemma Pro feature.`);
+            console.log(`💡 Upgrade to Pro in your Dashboard or visit: \x1b[4mhttps://lemma.nxus.studio/upgrade\x1b[0m\n`);
+            process.exit(0);
+        }
+        const { AutopilotWatcher } = require('../autopilot/AutopilotWatcher');
+        const watcher = new AutopilotWatcher(opts.dir);
+        watcher.start();
+        // Keep process alive
+        process.stdin.resume();
+        process.on('SIGINT', () => {
+            watcher.stop();
+            process.exit(0);
+        });
+    }
+    catch (err) {
+        console.error('❌ Exception starting Autopilot:', err.message);
+        process.exit(1);
+    }
+});
+if (process.argv[1] && (process.argv[1].includes('lemma') || process.argv[1].endsWith('.cjs') || process.argv[1].endsWith('.js'))) {
+    commander_1.program.parse(process.argv);
+}
+//# sourceMappingURL=lemma-proxy.js.map