@hasna/terminal 2.3.1 → 3.0.1

package/dist/search/filters.js

@@ -0,0 +1,34 @@
+// Smart filters for search results — auto-hide noise, prioritize source files
+export const DEFAULT_EXCLUDE_DIRS = [
+    "node_modules", ".git", "dist", "build", ".next", "__pycache__",
+    "coverage", ".turbo", ".cache", ".output", "vendor", "target",
+];
+export const SOURCE_EXTENSIONS = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".rb",
+    ".sh", ".c", ".cpp", ".h", ".css", ".scss", ".html", ".vue", ".svelte",
+    ".md", ".json", ".yaml", ".yml", ".toml", ".sql", ".graphql",
+]);
+export const CONFIG_EXTENSIONS = new Set([
+    ".json", ".yaml", ".yml", ".toml", ".ini", ".env", ".config.js",
+    ".config.ts", ".config.mjs",
+]);
+export function isSourceFile(path) {
+    const ext = path.match(/\.\w+$/)?.[0] ?? "";
+    return SOURCE_EXTENSIONS.has(ext);
+}
+export function isExcludedDir(path) {
+    return DEFAULT_EXCLUDE_DIRS.some(d => path.includes(`/${d}/`) || path.includes(`/${d}`));
+}
+/** Relevance score: higher = more relevant */
+export function relevanceScore(path) {
+    if (isExcludedDir(path))
+        return 0;
+    const ext = path.match(/\.\w+$/)?.[0] ?? "";
+    if (SOURCE_EXTENSIONS.has(ext))
+        return 10;
+    if (CONFIG_EXTENSIONS.has(ext))
+        return 5;
+    if (path.includes("/test") || path.includes(".test.") || path.includes(".spec."))
+        return 7;
+    return 3;
+}

package/dist/search/index.js

@@ -0,0 +1,5 @@
+// Smart search — unified entry point for file + content search
+export { searchFiles } from "./file-search.js";
+export { searchContent } from "./content-search.js";
+export { DEFAULT_EXCLUDE_DIRS, SOURCE_EXTENSIONS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+export { semanticSearch, findExports, findComponents, findHooks } from "./semantic.js";

package/dist/search/semantic.js

@@ -0,0 +1,320 @@
+// Semantic code search — AST-powered search that understands code structure
+// Instead of raw grep, searches by meaning: "find auth functions" → login(), verifyToken()
+import { spawn } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.stderr?.on("data", (d) => { });
+        proc.on("close", () => resolve(out));
+    });
+}
+/** Extract code symbols from a TypeScript/JavaScript file using regex-based parsing */
+export function extractSymbolsFromFile(filePath) {
+    return extractSymbols(filePath);
+}
+/** Extract the complete code block for a symbol by name */
+export function extractBlock(filePath, symbolName) {
+    if (!existsSync(filePath))
+        return null;
+    const content = readFileSync(filePath, "utf8");
+    const lines = content.split("\n");
+    const symbols = extractSymbols(filePath);
+    const symbol = symbols.find(s => s.name === symbolName && s.kind !== "import");
+    if (!symbol)
+        return null;
+    const startLine = symbol.line - 1; // 0-indexed
+    let braceDepth = 0;
+    let foundOpen = false;
+    let endLine = startLine;
+    for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const ch of line) {
+            if (ch === "{") {
+                braceDepth++;
+                foundOpen = true;
+            }
+            if (ch === "}") {
+                braceDepth--;
+            }
+        }
+        endLine = i;
+        if (foundOpen && braceDepth <= 0)
+            break;
+        // For single-line arrow functions without braces
+        if (i === startLine && !line.includes("{") && line.includes("=>"))
+            break;
+    }
+    return {
+        code: lines.slice(startLine, endLine + 1).join("\n"),
+        startLine: startLine + 1, // 1-indexed
+        endLine: endLine + 1,
+    };
+}
+function extractSymbols(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const content = readFileSync(filePath, "utf8");
+    const lines = content.split("\n");
+    const symbols = [];
+    const file = filePath;
+    const ext = filePath.match(/\.(\w+)$/)?.[1] ?? "";
+    // Python support
+    if (ext === "py") {
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const defMatch = line.match(/^(\s*)(?:async\s+)?def\s+(\w+)\s*\(/);
+            if (defMatch) {
+                symbols.push({ name: defMatch[2], kind: "function", file, line: i + 1, signature: line.trim(), exported: !defMatch[2].startsWith("_") });
+            }
+            const classMatch = line.match(/^class\s+(\w+)/);
+            if (classMatch) {
+                symbols.push({ name: classMatch[1], kind: "class", file, line: i + 1, signature: line.trim(), exported: true });
+            }
+        }
+        return symbols;
+    }
+    // Go support
+    if (ext === "go") {
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const funcMatch = line.match(/^func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(/);
+            if (funcMatch) {
+                symbols.push({ name: funcMatch[1], kind: "function", file, line: i + 1, signature: line.trim(), exported: /^[A-Z]/.test(funcMatch[1]) });
+            }
+            const typeMatch = line.match(/^type\s+(\w+)\s+(struct|interface)/);
+            if (typeMatch) {
+                symbols.push({ name: typeMatch[1], kind: typeMatch[2] === "interface" ? "interface" : "class", file, line: i + 1, signature: line.trim(), exported: /^[A-Z]/.test(typeMatch[1]) });
+            }
+        }
+        return symbols;
+    }
+    // Rust support
+    if (ext === "rs") {
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const fnMatch = line.match(/^\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+            if (fnMatch) {
+                symbols.push({ name: fnMatch[1], kind: "function", file, line: i + 1, signature: line.trim(), exported: line.includes("pub") });
+            }
+            const structMatch = line.match(/^\s*(?:pub\s+)?struct\s+(\w+)/);
+            if (structMatch) {
+                symbols.push({ name: structMatch[1], kind: "class", file, line: i + 1, signature: line.trim(), exported: line.includes("pub") });
+            }
+            const enumMatch = line.match(/^\s*(?:pub\s+)?enum\s+(\w+)/);
+            if (enumMatch) {
+                symbols.push({ name: enumMatch[1], kind: "type", file, line: i + 1, signature: line.trim(), exported: line.includes("pub") });
+            }
+            const traitMatch = line.match(/^\s*(?:pub\s+)?trait\s+(\w+)/);
+            if (traitMatch) {
+                symbols.push({ name: traitMatch[1], kind: "interface", file, line: i + 1, signature: line.trim(), exported: line.includes("pub") });
+            }
+        }
+        return symbols;
+    }
+    // TypeScript/JavaScript (default)
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const isExported = line.trimStart().startsWith("export");
+        // Functions: export function X(...) or export const X = (...) =>
+        const funcMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/);
+        if (funcMatch) {
+            const prevLine = i > 0 ? lines[i - 1] : "";
+            const doc = prevLine.trim().startsWith("/**") || prevLine.trim().startsWith("//")
+                ? prevLine.trim().replace(/^\/\*\*\s*|\s*\*\/$/g, "").replace(/^\/\/\s*/, "")
+                : undefined;
+            symbols.push({
+                name: funcMatch[1], kind: "function", file, line: lineNum,
+                signature: line.trim().replace(/\{.*$/, "").trim(),
+                exported: isExported, doc,
+            });
+            continue;
+        }
+        // Arrow functions: export const X = (...) =>
+        const arrowMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*\w[^=]*)?\s*=>/);
+        if (arrowMatch) {
+            // Detect React hooks
+            const isHook = arrowMatch[1].startsWith("use");
+            const isComponent = /^[A-Z]/.test(arrowMatch[1]);
+            symbols.push({
+                name: arrowMatch[1],
+                kind: isHook ? "hook" : isComponent ? "component" : "function",
+                file, line: lineNum,
+                signature: line.trim().replace(/\{.*$/, "").replace(/=>.*$/, "=>").trim(),
+                exported: isExported,
+            });
+            continue;
+        }
+        // Classes
+        const classMatch = line.match(/(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+        if (classMatch) {
+            symbols.push({
+                name: classMatch[1], kind: "class", file, line: lineNum,
+                signature: line.trim().replace(/\{.*$/, "").trim(),
+                exported: isExported,
+            });
+            continue;
+        }
+        // Interfaces
+        const ifaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+        if (ifaceMatch) {
+            symbols.push({
+                name: ifaceMatch[1], kind: "interface", file, line: lineNum,
+                signature: line.trim().replace(/\{.*$/, "").trim(),
+                exported: isExported,
+            });
+            continue;
+        }
+        // Type aliases
+        const typeMatch = line.match(/(?:export\s+)?type\s+(\w+)\s*=/);
+        if (typeMatch) {
+            symbols.push({
+                name: typeMatch[1], kind: "type", file, line: lineNum,
+                signature: line.trim(),
+                exported: isExported,
+            });
+            continue;
+        }
+        // Imports (for dependency tracking)
+        const importMatch = line.match(/import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/);
+        if (importMatch) {
+            const names = importMatch[1]
+                ? importMatch[1].split(",").map(s => s.trim().split(" as ")[0].trim())
+                : [importMatch[2]];
+            for (const name of names) {
+                if (name) {
+                    symbols.push({
+                        name, kind: "import", file, line: lineNum,
+                        signature: `from '${importMatch[3]}'`,
+                        exported: false,
+                    });
+                }
+            }
+            continue;
+        }
+        // Exported constants/variables
+        const constMatch = line.match(/export\s+const\s+(\w+)\s*[=:]/);
+        if (constMatch && !arrowMatch) {
+            symbols.push({
+                name: constMatch[1], kind: "variable", file, line: lineNum,
+                signature: line.trim().slice(0, 80),
+                exported: true,
+            });
+        }
+    }
+    return symbols;
+}
+/** Find all source files in a directory */
+async function findSourceFiles(cwd, maxFiles = 200) {
+    const excludes = ["node_modules", ".git", "dist", "build", ".next", "coverage", "__pycache__"];
+    const excludeArgs = excludes.map(d => `-not -path '*/${d}/*'`).join(" ");
+    const extensions = "\\( -name '*.ts' -o -name '*.tsx' -o -name '*.js' -o -name '*.jsx' \\)";
+    const cmd = `find . ${extensions} ${excludeArgs} -type f 2>/dev/null | head -${maxFiles}`;
+    const output = await exec(cmd, cwd);
+    return output.split("\n").filter(l => l.trim()).map(l => join(cwd, l.trim()));
+}
+/** Semantic search: find symbols matching a natural language query */
+export async function semanticSearch(query, cwd, options = {}) {
+    const { kinds, exportedOnly = false, maxResults = 30 } = options;
+    // Find all source files
+    const files = await findSourceFiles(cwd);
+    // Extract symbols from all files
+    let allSymbols = [];
+    for (const file of files) {
+        try {
+            allSymbols.push(...extractSymbols(file));
+        }
+        catch { /* skip unreadable files */ }
+    }
+    // Filter by kind
+    if (kinds) {
+        allSymbols = allSymbols.filter(s => kinds.includes(s.kind));
+    }
+    // Filter by exported
+    if (exportedOnly) {
+        allSymbols = allSymbols.filter(s => s.exported);
+    }
+    // Score each symbol against the query
+    const queryLower = query.toLowerCase();
+    const queryWords = queryLower.split(/\s+/).filter(w => w.length > 2);
+    const scored = allSymbols.map(symbol => {
+        let score = 0;
+        const nameLower = symbol.name.toLowerCase();
+        const sigLower = (symbol.signature ?? "").toLowerCase();
+        const fileLower = symbol.file.toLowerCase();
+        // Exact name match
+        if (queryWords.some(w => nameLower === w))
+            score += 10;
+        // Name contains query word
+        if (queryWords.some(w => nameLower.includes(w)))
+            score += 5;
+        // Signature contains query word
+        if (queryWords.some(w => sigLower.includes(w)))
+            score += 3;
+        // File path contains query word
+        if (queryWords.some(w => fileLower.includes(w)))
+            score += 2;
+        // Doc contains query word
+        if (symbol.doc && queryWords.some(w => symbol.doc.toLowerCase().includes(w)))
+            score += 4;
+        // Boost exported symbols
+        if (symbol.exported)
+            score += 1;
+        // Boost functions/classes over imports
+        if (symbol.kind === "function" || symbol.kind === "class")
+            score += 1;
+        // Semantic matching for common patterns
+        if (queryLower.includes("component") && symbol.kind === "component")
+            score += 5;
+        if (queryLower.includes("hook") && symbol.kind === "hook")
+            score += 5;
+        if (queryLower.includes("type") && (symbol.kind === "type" || symbol.kind === "interface"))
+            score += 5;
+        if (queryLower.includes("import") && symbol.kind === "import")
+            score += 5;
+        if (queryLower.includes("class") && symbol.kind === "class")
+            score += 5;
+        return { symbol, score };
+    });
+    // Sort by score, filter zero scores
+    const results = scored
+        .filter(s => s.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxResults)
+        .map(s => s.symbol);
+    // Make file paths relative
+    for (const r of results) {
+        if (r.file.startsWith(cwd)) {
+            r.file = "." + r.file.slice(cwd.length);
+        }
+    }
+    // Estimate token savings
+    const rawGrep = await exec(`grep -rn '${queryWords[0] ?? query}' . --include='*.ts' --include='*.tsx' 2>/dev/null | head -100`, cwd);
+    const rawTokens = Math.ceil(rawGrep.length / 4);
+    const resultTokens = Math.ceil(JSON.stringify(results).length / 4);
+    return {
+        query,
+        symbols: results,
+        totalFiles: files.length,
+        tokensSaved: Math.max(0, rawTokens - resultTokens),
+    };
+}
+/** Quick helper: find all exported functions */
+export async function findExports(cwd) {
+    const result = await semanticSearch("export", cwd, { exportedOnly: true, maxResults: 100 });
+    return result.symbols;
+}
+/** Quick helper: find all React components */
+export async function findComponents(cwd) {
+    const result = await semanticSearch("component", cwd, { kinds: ["component"], maxResults: 50 });
+    return result.symbols;
+}
+/** Quick helper: find all hooks */
+export async function findHooks(cwd) {
+    const result = await semanticSearch("hook", cwd, { kinds: ["hook"], maxResults: 50 });
+    return result.symbols;
+}

package/dist/session-boot.js

@@ -0,0 +1,59 @@
+// Session boot cache — precompute common data on first MCP call
+// Agents always start with git status + file tree + package.json — do it once
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+let bootCache = null;
+let bootCwd = "";
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.on("close", () => resolve(out.trim()));
+    });
+}
+/** Get or build session boot context */
+export async function getBootContext(cwd) {
+    if (bootCache && bootCwd === cwd)
+        return bootCache;
+    const [branch, status, log, srcLs] = await Promise.all([
+        exec("git branch --show-current 2>/dev/null", cwd),
+        exec("git status --porcelain 2>/dev/null", cwd),
+        exec("git log --oneline -8 2>/dev/null", cwd),
+        exec("ls -1 src/ 2>/dev/null || ls -1 lib/ 2>/dev/null || echo ''", cwd),
+    ]);
+    let pkg = null;
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        }
+        catch { }
+    }
+    bootCache = {
+        cwd,
+        git: {
+            branch: branch || null,
+            dirty: status.length > 0,
+            changedFiles: status.split("\n").filter(l => l.trim()).length,
+            recentCommits: log.split("\n").filter(l => l.trim()).slice(0, 5).map(l => {
+                const m = l.match(/^([a-f0-9]+)\s+(.+)$/);
+                return m ? { hash: m[1], message: m[2] } : null;
+            }).filter(Boolean),
+        },
+        project: pkg ? {
+            name: pkg.name,
+            version: pkg.version,
+            scripts: pkg.scripts ? Object.keys(pkg.scripts) : [],
+            deps: pkg.dependencies ? Object.keys(pkg.dependencies).length : 0,
+        } : null,
+        sourceFiles: srcLs.split("\n").filter(l => l.trim()),
+    };
+    bootCwd = cwd;
+    return bootCache;
+}
+/** Invalidate boot cache (call after git operations or file changes) */
+export function invalidateBootCache() {
+    bootCache = null;
+}

package/dist/session-context.js

@@ -0,0 +1,55 @@
+// Session context — stores last N command+output pairs for follow-up queries
+// Enables: terminal "show auth code" → terminal "explain that function"
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const DIR = join(homedir(), ".terminal");
+const CTX_FILE = join(DIR, "session-context.json");
+const MAX_ENTRIES = 5;
+function ensureDir() {
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+}
+/** Load session context */
+export function loadContext() {
+    ensureDir();
+    if (!existsSync(CTX_FILE))
+        return [];
+    try {
+        const entries = JSON.parse(readFileSync(CTX_FILE, "utf8"));
+        // Only return entries from last 30 minutes (session freshness)
+        const cutoff = Date.now() - 30 * 60 * 1000;
+        return entries.filter(e => e.timestamp > cutoff).slice(-MAX_ENTRIES);
+    }
+    catch {
+        return [];
+    }
+}
+/** Save a command to session context */
+export function saveContext(prompt, command, output) {
+    ensureDir();
+    const entries = loadContext();
+    entries.push({
+        prompt,
+        command,
+        output: output.slice(0, 500),
+        timestamp: Date.now(),
+    });
+    // Keep only last N
+    const trimmed = entries.slice(-MAX_ENTRIES);
+    writeFileSync(CTX_FILE, JSON.stringify(trimmed, null, 2));
+}
+/** Format context for AI prompt injection */
+export function formatContext() {
+    const entries = loadContext();
+    if (entries.length === 0)
+        return "";
+    const lines = ["\nRECENT SESSION CONTEXT (for follow-up references like 'that', 'it', 'the same'):"];
+    for (const e of entries.slice(-3)) {
+        lines.push(`> ${e.prompt}`);
+        lines.push(`$ ${e.command}`);
+        if (e.output)
+            lines.push(e.output.slice(0, 200));
+    }
+    return lines.join("\n");
+}

package/dist/sessions-db.js

@@ -0,0 +1,173 @@
+// SQLite session database — tracks every terminal interaction
+// @ts-ignore — bun:sqlite is a bun built-in
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { randomUUID } from "crypto";
+const DIR = join(homedir(), ".terminal");
+const DB_PATH = join(DIR, "sessions.db");
+let db = null;
+function getDb() {
+    if (db)
+        return db;
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+    db = new Database(DB_PATH);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER,
+      cwd TEXT NOT NULL,
+      provider TEXT,
+      model TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS interactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id),
+      nl TEXT NOT NULL,
+      command TEXT,
+      output TEXT,
+      exit_code INTEGER,
+      tokens_used INTEGER DEFAULT 0,
+      tokens_saved INTEGER DEFAULT 0,
+      duration_ms INTEGER,
+      model TEXT,
+      cached INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_interactions_session ON interactions(session_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+
+    CREATE TABLE IF NOT EXISTS corrections (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      prompt TEXT NOT NULL,
+      failed_command TEXT NOT NULL,
+      error_output TEXT,
+      corrected_command TEXT NOT NULL,
+      worked INTEGER DEFAULT 1,
+      error_type TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS outputs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      command TEXT NOT NULL,
+      raw_output_path TEXT,
+      compressed_summary TEXT,
+      tokens_raw INTEGER DEFAULT 0,
+      tokens_compressed INTEGER DEFAULT 0,
+      provider TEXT,
+      model TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_corrections_prompt ON corrections(prompt);
+  `);
+    return db;
+}
+// ── Sessions ─────────────────────────────────────────────────────────────────
+export function createSession(cwd, provider, model) {
+    const id = randomUUID();
+    getDb().prepare("INSERT INTO sessions (id, started_at, cwd, provider, model) VALUES (?, ?, ?, ?, ?)").run(id, Date.now(), cwd, provider ?? null, model ?? null);
+    return id;
+}
+export function endSession(sessionId) {
+    getDb().prepare("UPDATE sessions SET ended_at = ? WHERE id = ?").run(Date.now(), sessionId);
+}
+export function listSessions(limit = 20) {
+    return getDb().prepare("SELECT * FROM sessions ORDER BY started_at DESC LIMIT ?").all(limit);
+}
+export function getSession(id) {
+    return getDb().prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+}
+export function logInteraction(sessionId, data) {
+    const result = getDb().prepare(`INSERT INTO interactions (session_id, nl, command, output, exit_code, tokens_used, tokens_saved, duration_ms, model, cached, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, data.nl, data.command ?? null, data.output ? data.output.slice(0, 500) : null, data.exitCode ?? null, data.tokensUsed ?? 0, data.tokensSaved ?? 0, data.durationMs ?? null, data.model ?? null, data.cached ? 1 : 0, Date.now());
+    // bun:sqlite — lastInsertRowid is a property on the statement after run()
+    const lastId = getDb().prepare("SELECT last_insert_rowid() as id").get();
+    return lastId?.id ?? 0;
+}
+export function updateInteraction(id, data) {
+    const sets = [];
+    const vals = [];
+    if (data.command !== undefined) {
+        sets.push("command = ?");
+        vals.push(data.command);
+    }
+    if (data.output !== undefined) {
+        sets.push("output = ?");
+        vals.push(data.output.slice(0, 500));
+    }
+    if (data.exitCode !== undefined) {
+        sets.push("exit_code = ?");
+        vals.push(data.exitCode);
+    }
+    if (data.tokensSaved !== undefined) {
+        sets.push("tokens_saved = ?");
+        vals.push(data.tokensSaved);
+    }
+    if (sets.length === 0)
+        return;
+    vals.push(id);
+    getDb().prepare(`UPDATE interactions SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+}
+export function getSessionInteractions(sessionId) {
+    return getDb().prepare("SELECT * FROM interactions WHERE session_id = ? ORDER BY created_at ASC").all(sessionId);
+}
+export function getSessionStats() {
+    const d = getDb();
+    const sessions = d.prepare("SELECT COUNT(*) as c FROM sessions").get();
+    const interactions = d.prepare("SELECT COUNT(*) as c, SUM(tokens_saved) as saved, SUM(tokens_used) as used FROM interactions").get();
+    const cached = d.prepare("SELECT COUNT(*) as c FROM interactions WHERE cached = 1").get();
+    const errors = d.prepare("SELECT COUNT(*) as c FROM interactions WHERE exit_code IS NOT NULL AND exit_code != 0").get();
+    const totalInteractions = interactions.c ?? 0;
+    return {
+        totalSessions: sessions.c ?? 0,
+        totalInteractions,
+        totalTokensSaved: interactions.saved ?? 0,
+        totalTokensUsed: interactions.used ?? 0,
+        cacheHitRate: totalInteractions > 0 ? (cached.c ?? 0) / totalInteractions : 0,
+        avgInteractionsPerSession: sessions.c > 0 ? totalInteractions / sessions.c : 0,
+        errorRate: totalInteractions > 0 ? (errors.c ?? 0) / totalInteractions : 0,
+    };
+}
+// ── Corrections ─────────────────────────────────────────────────────────────
+/** Record a correction: command failed, then AI retried with a better one */
+export function recordCorrection(prompt, failedCommand, errorOutput, correctedCommand, worked, errorType) {
+    getDb().prepare("INSERT INTO corrections (prompt, failed_command, error_output, corrected_command, worked, error_type, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(prompt, failedCommand, errorOutput?.slice(0, 2000) ?? "", correctedCommand, worked ? 1 : 0, errorType ?? null, Date.now());
+}
+/** Find similar corrections for a prompt — used to inject as negative examples */
+export function findSimilarCorrections(prompt, limit = 5) {
+    // Simple keyword matching — extract significant words from prompt
+    const words = prompt.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+    if (words.length === 0)
+        return [];
+    // Search corrections where the prompt shares keywords
+    const all = getDb().prepare("SELECT prompt, failed_command, corrected_command, error_type FROM corrections WHERE worked = 1 ORDER BY created_at DESC LIMIT 100").all();
+    return all
+        .filter(c => {
+        const cWords = c.prompt.toLowerCase().split(/\s+/);
+        const overlap = words.filter((w) => cWords.some((cw) => cw.includes(w) || w.includes(cw)));
+        return overlap.length >= Math.min(2, words.length);
+    })
+        .slice(0, limit)
+        .map(c => ({ failed_command: c.failed_command, corrected_command: c.corrected_command, error_type: c.error_type ?? "unknown" }));
+}
+// ── Output tracking ─────────────────────────────────────────────────────────
+/** Record a compressed output for audit trail */
+export function recordOutput(command, rawOutputPath, compressedSummary, tokensRaw, tokensCompressed, provider, model, sessionId) {
+    getDb().prepare("INSERT INTO outputs (session_id, command, raw_output_path, compressed_summary, tokens_raw, tokens_compressed, provider, model, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(sessionId ?? null, command, rawOutputPath ?? null, compressedSummary?.slice(0, 5000) ?? "", tokensRaw, tokensCompressed, provider ?? null, model ?? null, Date.now());
+}
+/** Close the database connection */
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}