@hasna/terminal 2.3.0 → 2.3.2

package/dist/search/content-search.js

@@ -0,0 +1,68 @@
+// Smart content search — structured grep/ripgrep with grouping and dedup
+import { spawn } from "child_process";
+import { DEFAULT_EXCLUDE_DIRS, relevanceScore } from "./filters.js";
+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));
+    });
+}
+export async function searchContent(pattern, cwd, options = {}) {
+    const { fileType, maxResults = 30, contextLines = 0 } = options;
+    // Prefer ripgrep, fall back to grep
+    const excludeArgs = DEFAULT_EXCLUDE_DIRS.map(d => `--glob '!${d}'`).join(" ");
+    const typeArg = fileType ? `--type ${fileType}` : "";
+    const contextArg = contextLines > 0 ? `-C ${contextLines}` : "";
+    // Try rg first, fall back to grep
+    const rgCmd = `rg --line-number --no-heading ${contextArg} ${typeArg} ${excludeArgs} '${pattern.replace(/'/g, "'\\''")}' 2>/dev/null | head -500`;
+    const grepCmd = `grep -rn ${contextArg} '${pattern.replace(/'/g, "'\\''")}' . --include='*.ts' --include='*.js' --include='*.py' --include='*.go' --include='*.rs' --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=dist 2>/dev/null | head -500`;
+    let raw = await exec(rgCmd, cwd);
+    if (!raw.trim()) {
+        raw = await exec(grepCmd, cwd);
+    }
+    const lines = raw.split("\n").filter(l => l.trim());
+    const fileMap = new Map();
+    let filteredCount = 0;
+    for (const line of lines) {
+        // Format: path:line:content
+        const match = line.match(/^([^:]+):(\d+):(.*)$/);
+        if (!match)
+            continue;
+        const [, path, lineNum, content] = match;
+        if (DEFAULT_EXCLUDE_DIRS.some(d => path.includes(`/${d}/`))) {
+            filteredCount++;
+            continue;
+        }
+        if (!fileMap.has(path))
+            fileMap.set(path, []);
+        fileMap.get(path).push({
+            line: parseInt(lineNum),
+            content: content.trim(),
+        });
+    }
+    // Sort files by relevance
+    const files = [...fileMap.entries()]
+        .map(([path, matches]) => ({
+        path,
+        matches: matches.slice(0, 5), // max 5 matches per file
+        relevance: relevanceScore(path),
+    }))
+        .sort((a, b) => b.relevance - a.relevance)
+        .slice(0, maxResults);
+    const totalMatches = [...fileMap.values()].reduce((sum, m) => sum + m.length, 0);
+    const filtered = filteredCount > 0 ? [{ count: filteredCount, reason: "excluded directories" }] : [];
+    const rawTokens = Math.ceil(raw.length / 4);
+    const result = { query: pattern, totalMatches, files, filtered };
+    const resultTokens = Math.ceil(JSON.stringify(result).length / 4);
+    result.tokensSaved = Math.max(0, rawTokens - resultTokens);
+    // Overflow guard — warn when results are truncated
+    if (totalMatches > maxResults * 3) {
+        result.overflow = {
+            warning: `${totalMatches} total matches across ${fileMap.size} files — showing top ${files.length}`,
+            suggestion: "Try a more specific pattern, add fileType filter, or use -l to list files only",
+        };
+    }
+    return result;
+}

package/dist/search/file-search.js

@@ -0,0 +1,61 @@
+// Smart file search — structured, filtered, token-efficient results
+import { spawn } from "child_process";
+import { DEFAULT_EXCLUDE_DIRS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+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) => { out += d.toString(); });
+        proc.on("close", () => resolve(out));
+    });
+}
+export async function searchFiles(pattern, cwd, options = {}) {
+    const { includeNodeModules = false, maxResults = 50 } = options;
+    // Build find command
+    const excludes = includeNodeModules
+        ? DEFAULT_EXCLUDE_DIRS.filter(d => d !== "node_modules")
+        : DEFAULT_EXCLUDE_DIRS;
+    const excludeArgs = excludes.map(d => `-not -path '*/${d}/*'`).join(" ");
+    const command = `find . -name '${pattern}' -type f ${excludeArgs} 2>/dev/null | head -${maxResults * 3}`;
+    const raw = await exec(command, cwd);
+    const allPaths = raw.split("\n").filter(l => l.trim());
+    // Categorize
+    const source = [];
+    const config = [];
+    const other = [];
+    const filteredCounts = {};
+    for (const path of allPaths) {
+        if (isExcludedDir(path)) {
+            const dir = DEFAULT_EXCLUDE_DIRS.find(d => path.includes(`/${d}/`)) ?? "other";
+            filteredCounts[dir] = (filteredCounts[dir] ?? 0) + 1;
+            continue;
+        }
+        if (isSourceFile(path)) {
+            source.push(path);
+        }
+        else if (path.match(/\.(json|yaml|yml|toml|ini|env)/)) {
+            config.push(path);
+        }
+        else {
+            other.push(path);
+        }
+    }
+    // Sort by relevance
+    source.sort((a, b) => relevanceScore(b) - relevanceScore(a));
+    // Limit results
+    const filtered = Object.entries(filteredCounts).map(([reason, count]) => ({ reason, count }));
+    // Estimate token savings
+    const rawTokens = Math.ceil(raw.length / 4);
+    const result = {
+        query: pattern,
+        total: allPaths.length,
+        source: source.slice(0, maxResults),
+        config: config.slice(0, 10),
+        other: other.slice(0, 10),
+        filtered,
+    };
+    const resultTokens = Math.ceil(JSON.stringify(result).length / 4);
+    result.tokensSaved = Math.max(0, rawTokens - resultTokens);
+    return result;
+}

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