@hasna/terminal 0.5.2 → 0.6.0

package/.claude/scheduled_tasks.lock

@@ -1 +1 @@
-{"sessionId":"c1e414c7-f1a5-4b9e-bcc4-64c451584cb8","pid":54679,"acquiredAt":1773566918526}
+{"sessionId":"c1e414c7-f1a5-4b9e-bcc4-64c451584cb8","pid":1236,"acquiredAt":1773584959902}

package/dist/cli.js

@@ -19,6 +19,89 @@ if (args[0] === "mcp") {
         console.log("Usage: t mcp [serve|install]");
     }
 }
+// ── Hook commands ────────────────────────────────────────────────────────────
+else if (args[0] === "hook") {
+    const { existsSync, mkdirSync, writeFileSync, readFileSync } = await import("fs");
+    const { join, dirname } = await import("path");
+    const { execSync } = await import("child_process");
+    const sub = args[1];
+    const target = args[2]; // --claude, --codex
+    if (sub === "install" && (target === "--claude" || target === "claude")) {
+        // Find the hook script
+        const hookSrc = join(dirname(new URL(import.meta.url).pathname), "hooks", "claude-hook.sh");
+        const hookDest = join(process.env.HOME ?? "~", ".claude", "hooks", "PostToolUse-open-terminal.sh");
+        // Copy hook script
+        const destDir = dirname(hookDest);
+        if (!existsSync(destDir))
+            mkdirSync(destDir, { recursive: true });
+        // Generate hook with resolved paths
+        const terminalBin = execSync("which terminal", { encoding: "utf8" }).trim();
+        const hookScript = `#!/usr/bin/env bash
+# open-terminal PostToolUse hook — compresses Bash output
+# Installed by: t hook install --claude
+
+if [ "$TOOL_NAME" != "Bash" ]; then exit 0; fi
+OUTPUT=$(cat)
+if [ \${#OUTPUT} -lt 500 ]; then echo "$OUTPUT"; exit 0; fi
+
+LINE_COUNT=$(echo "$OUTPUT" | wc -l | tr -d ' ')
+if [ "$LINE_COUNT" -gt 15 ]; then
+  COMPRESSED=$(echo "$OUTPUT" | bun -e "
+    import{compress,stripAnsi}from'${dirname(terminalBin)}/../lib/node_modules/@hasna/terminal/dist/compression.js';
+    import{stripNoise}from'${dirname(terminalBin)}/../lib/node_modules/@hasna/terminal/dist/noise-filter.js';
+    let i='';process.stdin.on('data',d=>i+=d);process.stdin.on('end',()=>{
+      const c=stripNoise(stripAnsi(i)).cleaned;
+      const r=compress('bash',c,{maxTokens:500});
+      console.log(r.tokensSaved>50?r.content:c);
+    });
+  " 2>/dev/null)
+  if [ $? -eq 0 ] && [ -n "$COMPRESSED" ]; then echo "$COMPRESSED"; exit 0; fi
+fi
+echo "$OUTPUT"
+`;
+        writeFileSync(hookDest, hookScript, { mode: 0o755 });
+        // Register in Claude settings
+        const settingsPath = join(process.env.HOME ?? "~", ".claude", "settings.json");
+        let settings = {};
+        if (existsSync(settingsPath)) {
+            try {
+                settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+            }
+            catch { }
+        }
+        if (!settings.hooks)
+            settings.hooks = {};
+        if (!settings.hooks.PostToolUse)
+            settings.hooks.PostToolUse = [];
+        const hookEntry = { command: hookDest, event: "PostToolUse", tools: ["Bash"] };
+        const exists = settings.hooks.PostToolUse.some((h) => h.command?.includes("open-terminal"));
+        if (!exists) {
+            settings.hooks.PostToolUse.push(hookEntry);
+            writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        }
+        console.log("✓ Installed open-terminal PostToolUse hook for Claude Code");
+        console.log("  Hook: " + hookDest);
+        console.log("  Bash output >15 lines will be auto-compressed");
+    }
+    else if (sub === "uninstall") {
+        const settingsPath = join(process.env.HOME ?? "~", ".claude", "settings.json");
+        if (existsSync(settingsPath)) {
+            try {
+                const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+                if (settings.hooks?.PostToolUse) {
+                    settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter((h) => !h.command?.includes("open-terminal"));
+                    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+                }
+            }
+            catch { }
+        }
+        console.log("✓ Uninstalled open-terminal hook");
+    }
+    else {
+        console.log("Usage: t hook install --claude");
+        console.log("       t hook uninstall");
+    }
+}
 // ── Recipe commands ──────────────────────────────────────────────────────────
 else if (args[0] === "recipe") {
     const { listRecipes, getRecipe, createRecipe, deleteRecipe, listCollections, createCollection } = await import("./recipes/storage.js");

package/dist/command-rewriter.js

@@ -0,0 +1,64 @@
+// Command rewriter — auto-optimize commands to produce less output
+// Only rewrites when semantic result is identical
+const rules = [
+    // find | grep -v node_modules → find -not -path
+    {
+        pattern: /find\s+(\S+)\s+(.*?)\|\s*grep\s+-v\s+node_modules/,
+        rewrite: (m, cmd) => cmd.replace(m[0], `find ${m[1]} ${m[2]}-not -path '*/node_modules/*'`),
+        reason: "avoid pipe, filter in-kernel",
+    },
+    // cat file | grep X → grep X file
+    {
+        pattern: /cat\s+(\S+)\s*\|\s*grep\s+(.*)/,
+        rewrite: (m) => `grep ${m[2]} ${m[1]}`,
+        reason: "useless cat",
+    },
+    // find without node_modules exclusion → add it
+    {
+        pattern: /^find\s+\.\s+(.*)(?!.*node_modules)/,
+        rewrite: (m, cmd) => {
+            if (cmd.includes("node_modules") || cmd.includes("-not -path"))
+                return cmd;
+            return cmd.replace(/^find\s+\.\s+/, "find . -not -path '*/node_modules/*' -not -path '*/.git/*' ");
+        },
+        reason: "auto-exclude node_modules and .git",
+    },
+    // git log without limit → add --oneline -20
+    {
+        pattern: /^git\s+log\s*$/,
+        rewrite: () => "git log --oneline -20",
+        reason: "prevent unbounded log output",
+    },
+    // git diff without stat → add --stat for overview
+    {
+        pattern: /^git\s+diff\s*$/,
+        rewrite: () => "git diff --stat",
+        reason: "stat overview is usually sufficient",
+    },
+    // npm ls without depth → add --depth=0
+    {
+        pattern: /^npm\s+ls\s*$/,
+        rewrite: () => "npm ls --depth=0",
+        reason: "full tree is massive, top-level usually enough",
+    },
+    // ps aux without filter → add sort and head
+    {
+        pattern: /^ps\s+aux\s*$/,
+        rewrite: () => "ps aux --sort=-%mem | head -20",
+        reason: "full process list is noise, show top consumers",
+    },
+];
+/** Rewrite a command to produce less output */
+export function rewriteCommand(cmd) {
+    const trimmed = cmd.trim();
+    for (const rule of rules) {
+        const match = trimmed.match(rule.pattern);
+        if (match) {
+            const rewritten = rule.rewrite(match, trimmed);
+            if (rewritten !== trimmed) {
+                return { original: trimmed, rewritten, changed: true, reason: rule.reason };
+            }
+        }
+    }
+    return { original: trimmed, rewritten: trimmed, changed: false };
+}

package/dist/compression.js

@@ -74,8 +74,8 @@ export function compress(command, output, options = {}) {
             const json = JSON.stringify(parsed.data, null, format === "summary" ? 0 : 2);
             const savings = tokenSavings(output, parsed.data);
             const compressedTokens = estimateTokens(json);
-            // If within budget or no budget, return structured
-            if (!maxTokens || compressedTokens <= maxTokens) {
+            // ONLY use JSON if it actually saves tokens (never return larger output)
+            if (savings.saved > 0 && (!maxTokens || compressedTokens <= maxTokens)) {
                 return {
                     content: json,
                     format: "json",

package/dist/diff-cache.js

@@ -65,11 +65,31 @@ export function diffOutput(command, cwd, output) {
         };
     }
     const diff = lineDiff(prev.output, output);
+    const total = diff.added.length + diff.removed.length + diff.unchanged;
+    const similarity = total > 0 ? diff.unchanged / total : 0;
+    // Fuzzy threshold: if >80% similar, return diff-only (massive token savings)
+    const fullTokens = estimateTokens(output);
+    if (similarity > 0.8 && diff.added.length + diff.removed.length > 0) {
+        const diffContent = [
+            ...diff.added.map(l => `+ ${l}`),
+            ...diff.removed.map(l => `- ${l}`),
+        ].join("\n");
+        const diffTokens = estimateTokens(diffContent);
+        return {
+            full: output,
+            hasPrevious: true,
+            added: diff.added,
+            removed: diff.removed,
+            diffSummary: `${Math.round(similarity * 100)}% similar — ${summarizeDiff(diff)}`,
+            unchanged: false,
+            tokensSaved: Math.max(0, fullTokens - diffTokens),
+        };
+    }
+    // Less than 80% similar — return full output with diff info
     const diffContent = [
         ...diff.added.map(l => `+ ${l}`),
         ...diff.removed.map(l => `- ${l}`),
     ].join("\n");
-    const fullTokens = estimateTokens(output);
     const diffTokens = estimateTokens(diffContent);
     return {
         full: output,

package/dist/expand-store.js

@@ -0,0 +1,38 @@
+// Expand store — keeps full output for progressive disclosure
+// Agents get summary first, call expand(key) only if they need details
+const MAX_ENTRIES = 50;
+const store = new Map();
+let counter = 0;
+/** Store full output and return a retrieval key */
+export function storeOutput(command, output) {
+    const key = `out_${++counter}`;
+    // Evict oldest if over limit
+    if (store.size >= MAX_ENTRIES) {
+        const oldest = store.keys().next().value;
+        if (oldest)
+            store.delete(oldest);
+    }
+    store.set(key, { command, output, timestamp: Date.now() });
+    return key;
+}
+/** Retrieve full output by key, optionally filtered */
+export function expandOutput(key, grep) {
+    const entry = store.get(key);
+    if (!entry)
+        return { found: false };
+    let output = entry.output;
+    if (grep) {
+        const pattern = new RegExp(grep, "i");
+        output = output.split("\n").filter(l => pattern.test(l)).join("\n");
+    }
+    return { found: true, output, lines: output.split("\n").length };
+}
+/** List available stored outputs */
+export function listStored() {
+    return [...store.entries()].map(([key, entry]) => ({
+        key,
+        command: entry.command.slice(0, 60),
+        lines: entry.output.split("\n").length,
+        age: Date.now() - entry.timestamp,
+    }));
+}

package/dist/lazy-executor.js

@@ -0,0 +1,41 @@
+// Lazy execution — for large result sets, return count + sample + categories
+// instead of full output. Agent requests slices on demand.
+import { dirname } from "path";
+const LAZY_THRESHOLD = 100; // lines before switching to lazy mode
+/** Check if output should use lazy mode */
+export function shouldBeLazy(output) {
+    return output.split("\n").filter(l => l.trim()).length > LAZY_THRESHOLD;
+}
+/** Convert large output to lazy format: count + sample + categories */
+export function toLazy(output, command) {
+    const lines = output.split("\n").filter(l => l.trim());
+    const sample = lines.slice(0, 20);
+    // Try to categorize by directory (for file-like output)
+    const categories = {};
+    const isFilePaths = lines.filter(l => l.includes("/")).length > lines.length * 0.5;
+    if (isFilePaths) {
+        for (const line of lines) {
+            const dir = dirname(line.trim()) || ".";
+            // Group by top-level dir
+            const topDir = dir.split("/").slice(0, 2).join("/");
+            categories[topDir] = (categories[topDir] ?? 0) + 1;
+        }
+    }
+    return {
+        lazy: true,
+        count: lines.length,
+        sample,
+        categories: Object.keys(categories).length > 1 ? categories : undefined,
+        hint: `${lines.length} results. Showing first 20. Use offset/limit to paginate, or narrow your search.`,
+    };
+}
+/** Get a slice of output */
+export function getSlice(output, offset, limit) {
+    const allLines = output.split("\n").filter(l => l.trim());
+    const slice = allLines.slice(offset, offset + limit);
+    return {
+        lines: slice,
+        total: allLines.length,
+        hasMore: offset + limit < allLines.length,
+    };
+}

package/dist/mcp/server.js

@@ -4,6 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { spawn } from "child_process";
 import { compress, stripAnsi } from "../compression.js";
+import { stripNoise } from "../noise-filter.js";
 import { parseOutput, tokenSavings, estimateTokens } from "../parsers/index.js";
 import { summarizeOutput } from "../ai.js";
 import { searchFiles, searchContent, semanticSearch } from "../search/index.js";
@@ -14,13 +15,19 @@ import { diffOutput } from "../diff-cache.js";
 import { processOutput } from "../output-processor.js";
 import { listSessions, getSessionInteractions, getSessionStats } from "../sessions-db.js";
 import { cachedRead } from "../file-cache.js";
+import { storeOutput, expandOutput } from "../expand-store.js";
+import { rewriteCommand } from "../command-rewriter.js";
+import { shouldBeLazy, toLazy } from "../lazy-executor.js";
 import { getEconomyStats, recordSaving } from "../economy.js";
 import { captureSnapshot } from "../snapshots.js";
 // ── helpers ──────────────────────────────────────────────────────────────────
 function exec(command, cwd, timeout) {
+    // Auto-optimize command before execution
+    const rw = rewriteCommand(command);
+    const actualCommand = rw.changed ? rw.rewritten : command;
     return new Promise((resolve) => {
         const start = Date.now();
-        const proc = spawn("/bin/zsh", ["-c", command], {
+        const proc = spawn("/bin/zsh", ["-c", actualCommand], {
             cwd: cwd ?? process.cwd(),
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -35,7 +42,10 @@ function exec(command, cwd, timeout) {
         proc.on("close", (code) => {
             if (timer)
                 clearTimeout(timer);
-            resolve({ exitCode: code ?? 0, stdout, stderr, duration: Date.now() - start });
+            // Strip noise before returning (npm fund, progress bars, etc.)
+            const cleanStdout = stripNoise(stdout).cleaned;
+            const cleanStderr = stripNoise(stderr).cleaned;
+            resolve({ exitCode: code ?? 0, stdout: cleanStdout, stderr: cleanStderr, duration: Date.now() - start, rewritten: rw.changed ? rw.rewritten : undefined });
         });
     });
 }
@@ -55,26 +65,41 @@ export function createServer() {
     }, async ({ command, cwd, timeout, format, maxTokens }) => {
         const result = await exec(command, cwd, timeout ?? 30000);
         const output = (result.stdout + result.stderr).trim();
-        // Raw mode
+        // Raw mode — with lazy execution for large results
         if (!format || format === "raw") {
             const clean = stripAnsi(output);
+            // Lazy mode: if >100 lines, return count + sample instead of full output
+            if (shouldBeLazy(clean)) {
+                const lazy = toLazy(clean, command);
+                const detailKey = storeOutput(command, clean);
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                exitCode: result.exitCode, ...lazy, detailKey, duration: result.duration,
+                                ...(result.rewritten ? { rewrittenFrom: command } : {}),
+                            }) }],
+                };
+            }
             return {
                 content: [{ type: "text", text: JSON.stringify({
                             exitCode: result.exitCode, output: clean, duration: result.duration, tokens: estimateTokens(clean),
+                            ...(result.rewritten ? { rewrittenFrom: command } : {}),
                         }) }],
             };
         }
-        // JSON mode — structured parsing
+        // JSON mode — structured parsing (only if it actually saves tokens)
         if (format === "json") {
             const parsed = parseOutput(command, output);
             if (parsed) {
                 const savings = tokenSavings(output, parsed.data);
-                return {
-                    content: [{ type: "text", text: JSON.stringify({
-                                exitCode: result.exitCode, parsed: parsed.data, parser: parsed.parser,
-                                duration: result.duration, tokensSaved: savings.saved, savingsPercent: savings.percent,
-                            }) }],
-                };
+                if (savings.saved > 0) {
+                    return {
+                        content: [{ type: "text", text: JSON.stringify({
+                                    exitCode: result.exitCode, parsed: parsed.data, parser: parsed.parser,
+                                    duration: result.duration, tokensSaved: savings.saved, savingsPercent: savings.percent,
+                                }) }],
+                    };
+                }
+                // JSON was larger — fall through to compression
             }
         }
         // Compressed mode (also fallback for json when no parser matches)
@@ -121,6 +146,8 @@ export function createServer() {
         const result = await exec(command, cwd, timeout ?? 30000);
         const output = (result.stdout + result.stderr).trim();
         const processed = await processOutput(command, output);
+        // Progressive disclosure: store full output, return summary + expand key
+        const detailKey = output.split("\n").length > 15 ? storeOutput(command, output) : undefined;
         return {
             content: [{ type: "text", text: JSON.stringify({
                         exitCode: result.exitCode,
@@ -130,9 +157,21 @@ export function createServer() {
                         totalLines: output.split("\n").length,
                         tokensSaved: processed.tokensSaved,
                         aiProcessed: processed.aiProcessed,
+                        ...(detailKey ? { detailKey, expandable: true } : {}),
                     }) }],
         };
     });
+    // ── expand: retrieve full output on demand ────────────────────────────────
+    server.tool("expand", "Retrieve full output from a previous execute_smart call. Only call this when you need details (e.g., to see failing test errors). Use the detailKey from execute_smart response.", {
+        key: z.string().describe("The detailKey from a previous execute_smart response"),
+        grep: z.string().optional().describe("Filter output lines by pattern (e.g., 'FAIL', 'error')"),
+    }, async ({ key, grep }) => {
+        const result = expandOutput(key, grep);
+        if (!result.found) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: "Output expired or not found" }) }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ output: result.output, lines: result.lines }) }] };
+    });
     // ── browse: list files/dirs as structured JSON ────────────────────────────
     server.tool("browse", "List files and directories as structured JSON. Auto-filters node_modules, .git, dist by default.", {
         path: z.string().optional().describe("Directory path (default: cwd)"),
@@ -444,6 +483,27 @@ export function createServer() {
             content: [{ type: "text", text: JSON.stringify(fileSymbols) }],
         };
     });
+    // ── read_symbol: read a function/class by name ─────────────────────────────
+    server.tool("read_symbol", "Read a specific function, class, or interface by name from a source file. Returns only the code block — not the entire file. Saves 70-85% tokens vs reading the whole file.", {
+        path: z.string().describe("Source file path"),
+        name: z.string().describe("Symbol name (function, class, interface)"),
+    }, async ({ path: filePath, name }) => {
+        const { extractBlock, extractSymbolsFromFile } = await import("../search/semantic.js");
+        const block = extractBlock(filePath, name);
+        if (!block) {
+            // Return available symbols so the agent can pick the right one
+            const symbols = extractSymbolsFromFile(filePath);
+            const names = symbols.filter(s => s.kind !== "import").map(s => `${s.kind}: ${s.name} (L${s.line})`);
+            return { content: [{ type: "text", text: JSON.stringify({
+                            error: `Symbol '${name}' not found`,
+                            available: names.slice(0, 20),
+                        }) }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify({
+                        name, code: block.code, startLine: block.startLine, endLine: block.endLine,
+                        lines: block.endLine - block.startLine + 1,
+                    }) }] };
+    });
     return server;
 }
 // ── main: start MCP server via stdio ─────────────────────────────────────────

package/dist/noise-filter.js

@@ -0,0 +1,70 @@
+// Noise filter — strips output that is NEVER useful for AI agents or humans
+// Applied before any parsing/compression so ALL features benefit
+const NOISE_PATTERNS = [
+    // npm noise
+    /^\d+ packages? are looking for funding/,
+    /^\s*run [`']?npm fund[`']? for details/,
+    /^found 0 vulnerabilities/,
+    /^npm warn deprecated\b/,
+    /^npm warn ERESOLVE\b/,
+    /^npm warn old lockfile/,
+    /^npm notice\b/,
+    // Progress bars and spinners
+    /[█▓▒░⣾⣽⣻⢿⡿⣟⣯⣷]{3,}/,
+    /\[\s*[=>#-]{5,}\s*\]\s*\d+%/, // [=====>    ] 45%
+    /^\s*[\\/|/-]{1}\s*$/, // spinner chars alone on a line
+    /Downloading\s.*\d+%/,
+    /Progress:\s*\d+%/i,
+    // Build noise
+    /^gyp info\b/,
+    /^gyp warn\b/,
+    /^TSFILE:/,
+    /^\s*hmr update\s/i,
+    // Python noise
+    /^Requirement already satisfied:/,
+    // Docker noise
+    /^Pulling fs layer/,
+    /^Waiting$/,
+    /^Downloading\s+\[/,
+    /^Extracting\s+\[/,
+    // Git LFS
+    /^Filtering content:/,
+    /^Git LFS:/,
+    // Generic download/upload progress
+    /^\s*\d+(\.\d+)?\s*[KMG]?B\s*\/\s*\d+(\.\d+)?\s*[KMG]?B\b/,
+];
+/** Strip noise lines from output. Returns cleaned output + count of lines removed. */
+export function stripNoise(output) {
+    const lines = output.split("\n");
+    let removed = 0;
+    const kept = [];
+    // Track consecutive blank lines
+    let blankRun = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Collapse 3+ blank lines to 1
+        if (!trimmed) {
+            blankRun++;
+            if (blankRun <= 1)
+                kept.push(line);
+            else
+                removed++;
+            continue;
+        }
+        blankRun = 0;
+        // Check noise patterns
+        if (NOISE_PATTERNS.some(p => p.test(trimmed))) {
+            removed++;
+            continue;
+        }
+        // Carriage return overwrites (spinner animations)
+        if (line.includes("\r") && !line.endsWith("\r")) {
+            // Keep only the last part after \r
+            const parts = line.split("\r");
+            kept.push(parts[parts.length - 1]);
+            continue;
+        }
+        kept.push(line);
+    }
+    return { cleaned: kept.join("\n"), linesRemoved: removed };
+}

package/dist/output-processor.js

@@ -32,7 +32,11 @@ export async function processOutput(command, output) {
             summary: output,
             full: output,
             tokensSaved: 0,
+            aiTokensUsed: 0,
             aiProcessed: false,
+            aiCostUsd: 0,
+            savingsValueUsd: 0,
+            netSavingsUsd: 0,
         };
     }
     // Truncate very long output before sending to AI
@@ -65,12 +69,30 @@ export async function processOutput(command, output) {
             }
         }
         catch { /* not JSON, that's fine */ }
+        // Cost calculation
+        // AI input: system prompt (~200 tokens) + command + output sent to AI
+        const aiInputTokens = estimateTokens(SUMMARIZE_PROMPT) + estimateTokens(toSummarize) + 20;
+        const aiOutputTokens = summaryTokens;
+        const aiTokensUsed = aiInputTokens + aiOutputTokens;
+        // Cerebras qwen-3-235b pricing: $0.60/M input, $1.20/M output
+        const aiCostUsd = (aiInputTokens * 0.60 + aiOutputTokens * 1.20) / 1_000_000;
+        // Value of tokens saved (at Claude Sonnet $3/M input — what the agent would pay)
+        const savingsValueUsd = (saved * 3.0) / 1_000_000;
+        const netSavingsUsd = savingsValueUsd - aiCostUsd;
+        // Only record savings if net positive (AI cost < token savings value)
+        if (netSavingsUsd > 0 && saved > 0) {
+            recordSaving("compressed", saved);
+        }
         return {
             summary,
             full: output,
             structured,
             tokensSaved: saved,
+            aiTokensUsed,
             aiProcessed: true,
+            aiCostUsd,
+            savingsValueUsd,
+            netSavingsUsd,
         };
     }
     catch {
@@ -82,7 +104,11 @@ export async function processOutput(command, output) {
             summary: fallback,
             full: output,
             tokensSaved: Math.max(0, estimateTokens(output) - estimateTokens(fallback)),
+            aiTokensUsed: 0,
             aiProcessed: false,
+            aiCostUsd: 0,
+            savingsValueUsd: 0,
+            netSavingsUsd: 0,
         };
     }
 }

package/dist/search/semantic.js

@@ -16,6 +16,44 @@ function exec(command, cwd) {
 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 [];
@@ -28,7 +66,7 @@ function extractSymbols(filePath) {
         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*\(([^)]*)\)/);
+        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("//")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/terminal",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Smart terminal wrapper for AI agents and humans — structured output, token compression, MCP server, natural language",
   "type": "module",
   "bin": {