@hasna/terminal 0.1.5 → 0.2.0

package/.claude/scheduled_tasks.lock

@@ -1 +1 @@
-{"sessionId":"501c27b4-5243-40d6-8fb5-04ebdb3c8df8","pid":90841,"acquiredAt":1773556984409}
+{"sessionId":"c1e414c7-f1a5-4b9e-bcc4-64c451584cb8","pid":54679,"acquiredAt":1773566918526}

package/README.md

@@ -0,0 +1,186 @@
+# open-terminal
+
+Smart terminal wrapper for AI agents and humans. Speak plain English or let agents execute commands with structured output, token compression, and massive context savings.
+
+## Why?
+
+AI agents waste tokens on terminal interaction. Every `npm test` dumps hundreds of lines into context. Every `find` returns noise. `open-terminal` sits between callers and the shell, making every interaction dramatically more efficient.
+
+**For agents:** MCP server with structured output, token compression, diff-aware caching, smart search, process supervision. Cut token usage 50-90% on verbose commands.
+
+**For humans:** Natural language terminal powered by Cerebras (free, open-source) or Anthropic. Type "count typescript files" instead of `find . -name '*.ts' | wc -l`.
+
+## Install
+
+```bash
+npm install -g @hasna/terminal
+```
+
+## Quick Start
+
+### For Humans (TUI Mode)
+
+```bash
+# Set your API key (pick one)
+export CEREBRAS_API_KEY=your_key  # free, open-source (default)
+export ANTHROPIC_API_KEY=your_key # Claude
+
+# Launch
+t
+```
+
+Type in plain English. The terminal translates, shows you the command, and runs it.
+
+### For AI Agents (MCP Server)
+
+```bash
+# Install for your agent
+t mcp install --claude   # Claude Code
+t mcp install --codex    # OpenAI Codex
+t mcp install --gemini   # Gemini CLI
+t mcp install --all      # All agents
+
+# Or start manually
+t mcp serve
+```
+
+## MCP Tools
+
+| Tool | Description | Token Savings |
+|------|-------------|---------------|
+| `execute` | Run command with structured output, compression, or AI summary | 50-90% |
+| `execute_diff` | Run command, return only what changed since last run | 80-95% |
+| `browse` | List files as structured JSON, auto-filter node_modules | 60-80% |
+| `search_files` | Find files by pattern, categorized (source/config/other) | 70-90% |
+| `search_content` | Grep with grouping by file and relevance ranking | 60-80% |
+| `explain_error` | Structured error diagnosis with fix suggestions | N/A |
+| `bg_start` | Start background process with port auto-detection | N/A |
+| `bg_status` | List managed processes with health info | N/A |
+| `bg_wait_port` | Wait for a port to be ready | N/A |
+| `bg_stop` / `bg_logs` | Stop process / get recent output | N/A |
+| `list_recipes` / `run_recipe` / `save_recipe` | Reusable command templates | N/A |
+| `snapshot` | Capture terminal state for agent handoff | N/A |
+| `token_stats` | Token economy dashboard | N/A |
+
+### Example: Structured Output
+
+```
+Agent: execute("npm test", {format: "json"})
+
+→ {"passed": 142, "failed": 2, "failures": [{"test": "auth.test.ts:45", "error": "expected 200 got 401"}]}
+  (saved 847 tokens vs raw output)
+```
+
+### Example: Diff Mode
+
+```
+Agent: execute_diff("npm test")  # first run → full output
+Agent: execute_diff("npm test")  # second run → only changes
+
+→ {"diffSummary": "+1 new line, -1 removed", "added": ["PASS auth.test.ts:45"], "removed": ["FAIL auth.test.ts:45"], "tokensSaved": 892}
+```
+
+### Example: Smart Search
+
+```
+Agent: search_files("*hooks*")
+
+→ {"source": ["src/lib/webhooks.ts", "src/hooks/useAuth.ts"], "filtered": [{"count": 47, "reason": "node_modules"}], "tokensSaved": 312}
+```
+
+## Recipes
+
+Reusable command templates with variable substitution:
+
+```bash
+# Save a recipe
+t recipe add kill-port "lsof -i :{port} -t | xargs kill"
+
+# Run it
+t recipe run kill-port --port=3000
+
+# List recipes
+t recipe list
+
+# Project-scoped recipes
+t project init
+t recipe add dev-start "npm run dev" --project
+
+# Collections
+t collection create docker "Docker commands"
+t recipe add docker-build "docker build -t {tag} ." --collection=docker
+```
+
+## Token Economy
+
+Track how many tokens you've saved:
+
+```bash
+t stats
+```
+
+```
+Token Economy:
+  Total saved:  124.5K
+  By feature:
+    Structured: 45.2K
+    Compressed: 32.1K
+    Diff cache: 28.7K
+    Search:     18.5K
+```
+
+## TUI Keyboard Shortcuts
+
+| Key | Action |
+|-----|--------|
+| `ctrl+t` | New tab |
+| `tab` | Switch tabs |
+| `ctrl+w` | Close tab |
+| `ctrl+b` | Browse mode (file navigator) |
+| `ctrl+r` | Fuzzy history search |
+| `ctrl+l` | Clear scrollback |
+| `ctrl+c` | Cancel / exit |
+| `?` | Explain command before running |
+| `e` | Edit translated command |
+| `→` | Accept ghost text suggestion |
+
+## Configuration
+
+Config stored at `~/.terminal/config.json`:
+
+```json
+{
+  "provider": "cerebras",
+  "permissions": {
+    "destructive": true,
+    "network": true,
+    "sudo": false,
+    "install": true,
+    "write_outside_cwd": false
+  }
+}
+```
+
+## Architecture
+
+```
+┌──────────────────────────────────────────┐
+│            open-terminal                  │
+│  ┌──────────┐  ┌──────────┐  ┌────────┐ │
+│  │ Human    │  │ MCP      │  │ CLI    │ │
+│  │ TUI      │  │ Server   │  │ Tools  │ │
+│  └────┬─────┘  └────┬─────┘  └───┬────┘ │
+│       └──────────┬───┘────────────┘      │
+│   ┌──────────────────────────────────┐   │
+│   │  Output Intelligence Router      │   │
+│   │  Parsers → Compression → Diff    │   │
+│   └──────────────┬───────────────────┘   │
+│   ┌──────────────────────────────────┐   │
+│   │  Shell (zsh/bash)                │   │
+│   └──────────────────────────────────┘   │
+└──────────────────────────────────────────┘
+```
+
+## License
+
+MIT

package/dist/ai.js

@@ -1,8 +1,7 @@
-import Anthropic from "@anthropic-ai/sdk";
 import { cacheGet, cacheSet } from "./cache.js";
-const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+import { getProvider } from "./providers/index.js";
 // ── model routing ─────────────────────────────────────────────────────────────
-// Simple queries → haiku (fast). Complex/ambiguous → sonnet.
+// Simple queries → fast model. Complex/ambiguous → smart model.
 const COMPLEX_SIGNALS = [
     /\b(undo|revert|rollback|previous|last)\b/i,
     /\b(all files?|recursively|bulk|batch)\b/i,
@@ -10,9 +9,23 @@ const COMPLEX_SIGNALS = [
     /\b(if|when|unless|only if)\b/i,
     /[|&;]{2}/, // pipes / &&  in NL (unusual = complex intent)
 ];
+/** Model routing per provider */
 function pickModel(nl) {
     const isComplex = COMPLEX_SIGNALS.some((r) => r.test(nl)) || nl.split(" ").length > 10;
-    return isComplex ? "claude-sonnet-4-6" : "claude-haiku-4-5-20251001";
+    const provider = getProvider();
+    if (provider.name === "anthropic") {
+        return {
+            fast: "claude-haiku-4-5-20251001",
+            smart: "claude-sonnet-4-6",
+            pick: isComplex ? "smart" : "fast",
+        };
+    }
+    // Cerebras — single fast model (Llama is already fast)
+    return {
+        fast: "llama-4-scout-17b-16e",
+        smart: "llama-4-scout-17b-16e",
+        pick: isComplex ? "smart" : "fast",
+    };
 }
 // ── irreversibility ───────────────────────────────────────────────────────────
 const IRREVERSIBLE_PATTERNS = [
@@ -73,78 +86,60 @@ export async function translateToCommand(nl, perms, sessionCmds, onToken) {
         onToken?.(cached);
         return cached;
     }
-    const model = pickModel(nl);
-    let result = "";
+    const provider = getProvider();
+    const routing = pickModel(nl);
+    const model = routing.pick === "smart" ? routing.smart : routing.fast;
+    const system = buildSystemPrompt(perms, sessionCmds);
+    let text;
     if (onToken) {
-        // streaming path
-        const stream = await client.messages.stream({
-            model,
-            max_tokens: 256,
-            system: buildSystemPrompt(perms, sessionCmds),
-            messages: [{ role: "user", content: nl }],
+        text = await provider.stream(nl, { model, maxTokens: 256, system }, {
+            onToken: (partial) => onToken(partial),
         });
-        for await (const chunk of stream) {
-            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-                result += chunk.delta.text;
-                onToken(result.trim());
-            }
-        }
     }
     else {
-        const message = await client.messages.create({
-            model,
-            max_tokens: 256,
-            system: buildSystemPrompt(perms, sessionCmds),
-            messages: [{ role: "user", content: nl }],
-        });
-        const block = message.content[0];
-        if (block.type !== "text")
-            throw new Error("Unexpected response type");
-        result = block.text;
+        text = await provider.complete(nl, { model, maxTokens: 256, system });
     }
-    const text = result.trim();
     if (text.startsWith("BLOCKED:"))
         throw new Error(text);
     cacheSet(nl, text);
     return text;
 }
 // ── prefetch ──────────────────────────────────────────────────────────────────
-// Silently warm the cache after a command runs — no await, fire and forget
 export function prefetchNext(lastNl, perms, sessionCmds) {
-    // Only prefetch if we don't have it cached already
     if (cacheGet(lastNl))
         return;
     translateToCommand(lastNl, perms, sessionCmds).catch(() => { });
 }
 // ── explain ───────────────────────────────────────────────────────────────────
 export async function explainCommand(command) {
-    const message = await client.messages.create({
-        model: "claude-haiku-4-5-20251001",
-        max_tokens: 128,
+    const provider = getProvider();
+    const routing = pickModel("explain"); // simple = fast model
+    return provider.complete(command, {
+        model: routing.fast,
+        maxTokens: 128,
         system: "Explain what this shell command does in one plain English sentence. No markdown, no code blocks.",
-        messages: [{ role: "user", content: command }],
     });
-    const block = message.content[0];
-    if (block.type !== "text")
-        return "";
-    return block.text.trim();
 }
 // ── auto-fix ──────────────────────────────────────────────────────────────────
 export async function fixCommand(originalNl, failedCommand, errorOutput, perms, sessionCmds) {
-    const message = await client.messages.create({
-        model: "claude-sonnet-4-6",
-        max_tokens: 256,
+    const provider = getProvider();
+    const routing = pickModel(originalNl);
+    const text = await provider.complete(`I wanted to: ${originalNl}\nI ran: ${failedCommand}\nError:\n${errorOutput}\n\nGive me the corrected command only.`, {
+        model: routing.smart, // always use smart model for fixes
+        maxTokens: 256,
         system: buildSystemPrompt(perms, sessionCmds),
-        messages: [{
-                role: "user",
-                content: `I wanted to: ${originalNl}\nI ran: ${failedCommand}\nError:\n${errorOutput}\n\nGive me the corrected command only.`,
-            }],
     });
-    const block = message.content[0];
-    if (block.type !== "text")
-        throw new Error("Unexpected response type");
-    const text = block.text.trim();
     if (text.startsWith("BLOCKED:"))
         throw new Error(text);
     return text;
 }
+// ── summarize output (for MCP/agent use) ──────────────────────────────────────
+export async function summarizeOutput(command, output, maxTokens = 200) {
+    const provider = getProvider();
+    const routing = pickModel("summarize");
+    return provider.complete(`Command: ${command}\nOutput:\n${output}\n\nSummarize this output concisely for an AI agent. Focus on: status, key results, errors. Be terse.`, {
+        model: routing.fast,
+        maxTokens,
+        system: "You summarize command output for AI agents. Be extremely concise. Return structured info. No prose.",
+    });
+}

package/dist/cli.js

@@ -1,10 +1,142 @@
 #!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from "ink";
-import App from "./App.js";
-if (!process.env.ANTHROPIC_API_KEY) {
-    console.error("terminal: ANTHROPIC_API_KEY is not set.");
-    console.error("Add it to your shell: export ANTHROPIC_API_KEY=your_key");
-    process.exit(1);
+const args = process.argv.slice(2);
+// ── MCP commands ─────────────────────────────────────────────────────────────
+if (args[0] === "mcp") {
+    if (args[1] === "serve" || args.length === 1) {
+        const { startMcpServer } = await import("./mcp/server.js");
+        startMcpServer().catch((err) => {
+            console.error("MCP server error:", err);
+            process.exit(1);
+        });
+    }
+    else if (args[1] === "install") {
+        const { handleMcpInstall } = await import("./mcp/install.js");
+        handleMcpInstall(args.slice(2));
+    }
+    else {
+        console.log("Usage: t mcp [serve|install]");
+    }
+}
+// ── Recipe commands ──────────────────────────────────────────────────────────
+else if (args[0] === "recipe") {
+    const { listRecipes, getRecipe, createRecipe, deleteRecipe, listCollections, createCollection } = await import("./recipes/storage.js");
+    const { substituteVariables } = await import("./recipes/model.js");
+    const sub = args[1];
+    if (sub === "list") {
+        const collection = args.find(a => a.startsWith("--collection="))?.split("=")[1];
+        let recipes = listRecipes(process.cwd());
+        if (collection)
+            recipes = recipes.filter(r => r.collection === collection);
+        if (recipes.length === 0) {
+            console.log("No recipes found.");
+        }
+        else {
+            for (const r of recipes) {
+                const scope = r.project ? "(project)" : "(global)";
+                const col = r.collection ? ` [${r.collection}]` : "";
+                console.log(`  ${r.name}${col} ${scope} → ${r.command}`);
+            }
+        }
+    }
+    else if (sub === "add" && args[2] && args[3]) {
+        const name = args[2];
+        const command = args[3];
+        const collection = args.find(a => a.startsWith("--collection="))?.split("=")[1];
+        const project = args.includes("--project") ? process.cwd() : undefined;
+        const recipe = createRecipe({ name, command, collection, project });
+        console.log(`✓ Saved recipe '${recipe.name}' → ${recipe.command}`);
+    }
+    else if (sub === "run" && args[2]) {
+        const recipe = getRecipe(args[2], process.cwd());
+        if (!recipe) {
+            console.error(`Recipe '${args[2]}' not found.`);
+            process.exit(1);
+        }
+        // Parse --var=value arguments
+        const vars = {};
+        for (const arg of args.slice(3)) {
+            const match = arg.match(/^--(\w+)=(.+)$/);
+            if (match)
+                vars[match[1]] = match[2];
+        }
+        const cmd = substituteVariables(recipe.command, vars);
+        console.log(`$ ${cmd}`);
+        const { execSync } = await import("child_process");
+        try {
+            execSync(cmd, { stdio: "inherit", cwd: process.cwd() });
+        }
+        catch (e) {
+            process.exit(e.status ?? 1);
+        }
+    }
+    else if (sub === "delete" && args[2]) {
+        const ok = deleteRecipe(args[2], process.cwd());
+        console.log(ok ? `✓ Deleted recipe '${args[2]}'` : `Recipe '${args[2]}' not found.`);
+    }
+    else {
+        console.log("Usage: t recipe [add|list|run|delete]");
+        console.log("  t recipe add <name> <command> [--collection=X] [--project]");
+        console.log("  t recipe list [--collection=X]");
+        console.log("  t recipe run <name> [--var=value]");
+        console.log("  t recipe delete <name>");
+    }
+}
+// ── Collection commands ──────────────────────────────────────────────────────
+else if (args[0] === "collection") {
+    const { listCollections, createCollection } = await import("./recipes/storage.js");
+    const sub = args[1];
+    if (sub === "create" && args[2]) {
+        const col = createCollection({ name: args[2], description: args[3], project: args.includes("--project") ? process.cwd() : undefined });
+        console.log(`✓ Created collection '${col.name}'`);
+    }
+    else if (sub === "list") {
+        const cols = listCollections(process.cwd());
+        if (cols.length === 0)
+            console.log("No collections.");
+        else
+            for (const c of cols)
+                console.log(`  ${c.name}${c.description ? ` — ${c.description}` : ""}`);
+    }
+    else {
+        console.log("Usage: t collection [create|list]");
+    }
+}
+// ── Stats command ────────────────────────────────────────────────────────────
+else if (args[0] === "stats") {
+    const { getEconomyStats, formatTokens } = await import("./economy.js");
+    const s = getEconomyStats();
+    console.log("Token Economy:");
+    console.log(`  Total saved:  ${formatTokens(s.totalTokensSaved)}`);
+    console.log(`  Total used:   ${formatTokens(s.totalTokensUsed)}`);
+    console.log(`  By feature:`);
+    console.log(`    Structured: ${formatTokens(s.savingsByFeature.structured)}`);
+    console.log(`    Compressed: ${formatTokens(s.savingsByFeature.compressed)}`);
+    console.log(`    Diff cache: ${formatTokens(s.savingsByFeature.diff)}`);
+    console.log(`    NL cache:   ${formatTokens(s.savingsByFeature.cache)}`);
+    console.log(`    Search:     ${formatTokens(s.savingsByFeature.search)}`);
+}
+// ── Snapshot command ─────────────────────────────────────────────────────────
+else if (args[0] === "snapshot") {
+    const { captureSnapshot } = await import("./snapshots.js");
+    console.log(JSON.stringify(captureSnapshot(), null, 2));
+}
+// ── Project init ─────────────────────────────────────────────────────────────
+else if (args[0] === "project" && args[1] === "init") {
+    const { initProject } = await import("./recipes/storage.js");
+    initProject(process.cwd());
+    console.log("✓ Initialized .terminal/recipes.json");
+}
+// ── TUI mode (default) ──────────────────────────────────────────────────────
+else {
+    if (!process.env.ANTHROPIC_API_KEY && !process.env.CEREBRAS_API_KEY) {
+        console.error("terminal: No API key found.");
+        console.error("Set one of:");
+        console.error("  export CEREBRAS_API_KEY=your_key  (free, open-source)");
+        console.error("  export ANTHROPIC_API_KEY=your_key  (Claude)");
+        process.exit(1);
+    }
+    const App = (await import("./App.js")).default;
+    render(_jsx(App, {}));
 }
-render(_jsx(App, {}));

package/dist/compression.js

@@ -0,0 +1,107 @@
+// Token compression engine — reduces CLI output to fit within token budgets
+import { parseOutput, estimateTokens, tokenSavings } from "./parsers/index.js";
+/** Strip ANSI escape codes from text */
+export function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "");
+}
+/** Deduplicate consecutive similar lines (e.g., "Compiling X... Compiling Y...") */
+function deduplicateLines(lines) {
+    if (lines.length <= 3)
+        return lines;
+    const result = [];
+    let repeatCount = 0;
+    let repeatPattern = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Extract a "pattern" — the line without numbers, paths, specific identifiers
+        const pattern = line.replace(/[0-9]+/g, "N").replace(/\/\S+/g, "/PATH").replace(/\s+/g, " ").trim();
+        if (pattern === repeatPattern) {
+            repeatCount++;
+        }
+        else {
+            if (repeatCount > 2) {
+                result.push(`  ... (${repeatCount} similar lines)`);
+            }
+            else if (repeatCount > 0) {
+                // Push the skipped lines back
+                for (let j = i - repeatCount; j < i; j++) {
+                    result.push(lines[j]);
+                }
+            }
+            result.push(line);
+            repeatPattern = pattern;
+            repeatCount = 0;
+        }
+    }
+    if (repeatCount > 2) {
+        result.push(`  ... (${repeatCount} similar lines)`);
+    }
+    else {
+        for (let j = lines.length - repeatCount; j < lines.length; j++) {
+            result.push(lines[j]);
+        }
+    }
+    return result;
+}
+/** Smart truncation: keep first N + last M lines */
+function smartTruncate(text, maxTokens) {
+    const lines = text.split("\n");
+    const currentTokens = estimateTokens(text);
+    if (currentTokens <= maxTokens)
+        return text;
+    // Keep proportional first/last, with first getting more
+    const targetLines = Math.floor((maxTokens * lines.length) / currentTokens);
+    const firstCount = Math.ceil(targetLines * 0.6);
+    const lastCount = Math.floor(targetLines * 0.4);
+    if (firstCount + lastCount >= lines.length)
+        return text;
+    const first = lines.slice(0, firstCount);
+    const last = lines.slice(-lastCount);
+    const hiddenCount = lines.length - firstCount - lastCount;
+    return [...first, `\n--- ${hiddenCount} lines hidden ---\n`, ...last].join("\n");
+}
+/** Compress command output to fit within a token budget */
+export function compress(command, output, options = {}) {
+    const { maxTokens, format = "text", stripAnsi: doStrip = true } = options;
+    const originalTokens = estimateTokens(output);
+    // Step 1: Strip ANSI codes
+    let text = doStrip ? stripAnsi(output) : output;
+    // Step 2: Try structured parsing (format=json or when it saves tokens)
+    if (format === "json" || format === "summary") {
+        const parsed = parseOutput(command, text);
+        if (parsed) {
+            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) {
+                return {
+                    content: json,
+                    format: "json",
+                    originalTokens,
+                    compressedTokens,
+                    tokensSaved: savings.saved,
+                    savingsPercent: savings.percent,
+                };
+            }
+        }
+    }
+    // Step 3: Deduplicate similar lines
+    const lines = text.split("\n");
+    const deduped = deduplicateLines(lines);
+    text = deduped.join("\n");
+    // Step 4: Smart truncation if over budget
+    if (maxTokens) {
+        text = smartTruncate(text, maxTokens);
+    }
+    const compressedTokens = estimateTokens(text);
+    return {
+        content: text,
+        format: "text",
+        originalTokens,
+        compressedTokens,
+        tokensSaved: Math.max(0, originalTokens - compressedTokens),
+        savingsPercent: originalTokens > 0 ? Math.round(((originalTokens - compressedTokens) / originalTokens) * 100) : 0,
+    };
+}

package/dist/compression.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "bun:test";
+import { compress, stripAnsi } from "./compression.js";
+describe("stripAnsi", () => {
+    it("removes ANSI escape codes", () => {
+        expect(stripAnsi("\x1b[31mred\x1b[0m")).toBe("red");
+        expect(stripAnsi("\x1b[1;32mbold green\x1b[0m")).toBe("bold green");
+    });
+    it("leaves clean text unchanged", () => {
+        expect(stripAnsi("hello world")).toBe("hello world");
+    });
+});
+describe("compress", () => {
+    it("strips ANSI by default", () => {
+        const result = compress("ls", "\x1b[32mfile.ts\x1b[0m");
+        expect(result.content).not.toContain("\x1b");
+    });
+    it("uses structured parser when format=json", () => {
+        const output = `total 16
+-rw-r--r--  1 user staff  450 Mar 10 09:00 package.json
+drwxr-xr-x  5 user staff  160 Mar 10 09:00 src`;
+        const result = compress("ls -la", output, { format: "json" });
+        // Parser may or may not save tokens on small input, just check it parsed
+        expect(result.content).toBeTruthy();
+        const parsed = JSON.parse(result.content);
+        expect(Array.isArray(parsed)).toBe(true);
+    });
+    it("respects maxTokens budget", () => {
+        const longOutput = Array.from({ length: 100 }, (_, i) => `Line ${i}: some output text here`).join("\n");
+        const result = compress("some-command", longOutput, { maxTokens: 50 });
+        expect(result.compressedTokens).toBeLessThanOrEqual(60); // allow some slack
+    });
+    it("deduplicates similar lines", () => {
+        const output = Array.from({ length: 20 }, (_, i) => `Compiling module ${i}...`).join("\n");
+        const result = compress("build", output);
+        expect(result.compressedTokens).toBeLessThan(result.originalTokens);
+    });
+    it("tracks savings on large output", () => {
+        const output = Array.from({ length: 100 }, (_, i) => `Line ${i}: some long output text here that takes tokens`).join("\n");
+        const result = compress("cmd", output, { maxTokens: 50 });
+        expect(result.compressedTokens).toBeLessThan(result.originalTokens);
+    });
+});