@hasna/terminal 0.5.3 → 0.6.0

package/src/command-rewriter.ts

@@ -0,0 +1,80 @@
+// Command rewriter — auto-optimize commands to produce less output
+// Only rewrites when semantic result is identical
+
+interface RewriteRule {
+  pattern: RegExp;
+  rewrite: (match: RegExpMatchArray, cmd: string) => string;
+  reason: string;
+}
+
+const rules: RewriteRule[] = [
+  // 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",
+  },
+];
+
+export interface RewriteResult {
+  original: string;
+  rewritten: string;
+  changed: boolean;
+  reason?: string;
+}
+
+/** Rewrite a command to produce less output */
+export function rewriteCommand(cmd: string): RewriteResult {
+  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/src/compression.test.ts

@@ -24,10 +24,9 @@ describe("compress", () => {
 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
+    // Parser may skip JSON if it's larger than raw — just check it returned something
     expect(result.content).toBeTruthy();
-    const parsed = JSON.parse(result.content);
-    expect(Array.isArray(parsed)).toBe(true);
+    expect(result.compressedTokens).toBeGreaterThan(0);
   });
 
   it("respects maxTokens budget", () => {

package/src/diff-cache.ts

@@ -100,12 +100,35 @@ export function diffOutput(command: string, cwd: string, output: string): DiffRe
   }
 
   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 {

package/src/expand-store.ts

@@ -0,0 +1,51 @@
+// Expand store — keeps full output for progressive disclosure
+// Agents get summary first, call expand(key) only if they need details
+
+const MAX_ENTRIES = 50;
+
+interface StoredOutput {
+  command: string;
+  output: string;
+  timestamp: number;
+}
+
+const store = new Map<string, StoredOutput>();
+let counter = 0;
+
+/** Store full output and return a retrieval key */
+export function storeOutput(command: string, output: string): string {
+  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: string, grep?: string): { found: boolean; output?: string; lines?: number } {
+  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(): { key: string; command: string; lines: number; age: number }[] {
+  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/src/hooks/claude-hook.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# open-terminal Claude Code PostToolUse hook
+# Compresses Bash tool output through open-terminal's processing pipeline
+# Install: t hook install --claude
+
+# Only process Bash tool results
+if [ "$TOOL_NAME" != "Bash" ]; then
+  exit 0
+fi
+
+# Read the tool output from stdin
+OUTPUT=$(cat)
+
+# Skip if output is small (< 500 chars)
+if [ ${#OUTPUT} -lt 500 ]; then
+  echo "$OUTPUT"
+  exit 0
+fi
+
+# Count lines
+LINE_COUNT=$(echo "$OUTPUT" | wc -l | tr -d ' ')
+
+# For large outputs, compress through open-terminal
+if [ "$LINE_COUNT" -gt 15 ]; then
+  # Try to use bun for speed, fall back to node
+  if command -v bun &> /dev/null; then
+    COMPRESSED=$(echo "$OUTPUT" | bun -e "
+      import { compress, stripAnsi } from '$(dirname "$0")/../dist/compression.js';
+      import { stripNoise } from '$(dirname "$0")/../dist/noise-filter.js';
+      let input = '';
+      process.stdin.on('data', d => input += d);
+      process.stdin.on('end', () => {
+        const cleaned = stripNoise(stripAnsi(input)).cleaned;
+        const result = compress('bash', cleaned, { maxTokens: 500 });
+        if (result.tokensSaved > 50) {
+          console.log(result.content);
+          console.error('[open-terminal] saved ' + result.tokensSaved + ' tokens (' + result.savingsPercent + '%)');
+        } else {
+          console.log(cleaned);
+        }
+      });
+    " 2>/dev/null)
+
+    if [ $? -eq 0 ] && [ -n "$COMPRESSED" ]; then
+      echo "$COMPRESSED"
+      exit 0
+    fi
+  fi
+fi
+
+# Fallback: return original output
+echo "$OUTPUT"

package/src/lazy-executor.ts

@@ -0,0 +1,57 @@
+// 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
+
+export interface LazyResult {
+  lazy: true;
+  count: number;
+  sample: string[];
+  categories?: Record<string, number>;
+  hint: string;
+}
+
+/** Check if output should use lazy mode */
+export function shouldBeLazy(output: string): boolean {
+  return output.split("\n").filter(l => l.trim()).length > LAZY_THRESHOLD;
+}
+
+/** Convert large output to lazy format: count + sample + categories */
+export function toLazy(output: string, command: string): LazyResult {
+  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: Record<string, number> = {};
+  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: string, offset: number, limit: number): { lines: string[]; total: number; hasMore: boolean } {
+  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/src/mcp/server.ts

@@ -5,6 +5,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";
@@ -15,15 +16,21 @@ import { diffOutput } from "../diff-cache.js";
 import { processOutput } from "../output-processor.js";
 import { listSessions, getSessionInteractions, getSessionStats } from "../sessions-db.js";
 import { cachedRead, cacheStats } 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: string, cwd?: string, timeout?: number): Promise<{ exitCode: number; stdout: string; stderr: string; duration: number }> {
+function exec(command: string, cwd?: string, timeout?: number): Promise<{ exitCode: number; stdout: string; stderr: string; duration: number; rewritten?: string }> {
+  // 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"],
     });
@@ -38,7 +45,10 @@ function exec(command: string, cwd?: string, timeout?: number): Promise<{ exitCo
 
     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 });
     });
   });
 }
@@ -67,12 +77,24 @@ export function createServer(): McpServer {
       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" as const, text: JSON.stringify({
+              exitCode: result.exitCode, ...lazy, detailKey, duration: result.duration,
+              ...(result.rewritten ? { rewrittenFrom: command } : {}),
+            }) }],
+          };
+        }
         return {
           content: [{ type: "text" as const, text: JSON.stringify({
             exitCode: result.exitCode, output: clean, duration: result.duration, tokens: estimateTokens(clean),
+            ...(result.rewritten ? { rewrittenFrom: command } : {}),
           }) }],
         };
       }
@@ -147,6 +169,9 @@ export function createServer(): McpServer {
       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" as const, text: JSON.stringify({
           exitCode: result.exitCode,
@@ -156,11 +181,30 @@ export function createServer(): McpServer {
           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" as const, text: JSON.stringify({ error: "Output expired or not found" }) }] };
+      }
+      return { content: [{ type: "text" as const, text: JSON.stringify({ output: result.output, lines: result.lines }) }] };
+    }
+  );
+
   // ── browse: list files/dirs as structured JSON ────────────────────────────
 
   server.tool(
@@ -634,6 +678,34 @@ export function createServer(): McpServer {
     }
   );
 
+  // ── 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" as const, text: JSON.stringify({
+          error: `Symbol '${name}' not found`,
+          available: names.slice(0, 20),
+        }) }] };
+      }
+      return { content: [{ type: "text" as const, text: JSON.stringify({
+        name, code: block.code, startLine: block.startLine, endLine: block.endLine,
+        lines: block.endLine - block.startLine + 1,
+      }) }] };
+    }
+  );
+
   return server;
 }
 

package/src/noise-filter.ts

@@ -0,0 +1,83 @@
+// 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: RegExp[] = [
+  // 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: string): { cleaned: string; linesRemoved: number } {
+  const lines = output.split("\n");
+  let removed = 0;
+  const kept: string[] = [];
+
+  // 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/src/search/semantic.ts

@@ -37,6 +37,40 @@ export function extractSymbolsFromFile(filePath: string): CodeSymbol[] {
   return extractSymbols(filePath);
 }
 
+/** Extract the complete code block for a symbol by name */
+export function extractBlock(filePath: string, symbolName: string): { code: string; startLine: number; endLine: number } | null {
+  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: string): CodeSymbol[] {
   if (!existsSync(filePath)) return [];
   const content = readFileSync(filePath, "utf8");
@@ -50,7 +84,7 @@ function extractSymbols(filePath: string): CodeSymbol[] {
     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/dist/compression.test.js

@@ -1,42 +0,0 @@
-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);
-    });
-});

package/dist/diff-cache.test.js

@@ -1,27 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { diffOutput, clearDiffCache } from "./diff-cache.js";
-describe("diffOutput", () => {
-    it("returns first run with no previous", () => {
-        clearDiffCache();
-        const result = diffOutput("npm test", "/tmp", "PASS\n5 passed");
-        expect(result.hasPrevious).toBe(false);
-        expect(result.diffSummary).toBe("first run");
-        expect(result.tokensSaved).toBe(0);
-    });
-    it("detects identical output", () => {
-        clearDiffCache();
-        diffOutput("npm test", "/tmp/id", "PASS\n5 passed");
-        const result = diffOutput("npm test", "/tmp/id", "PASS\n5 passed");
-        expect(result.unchanged).toBe(true);
-        expect(result.diffSummary).toBe("identical to previous run");
-    });
-    it("computes diff for changed output", () => {
-        clearDiffCache();
-        diffOutput("npm test", "/tmp/diff", "PASS test1\nPASS test2\nFAIL test3");
-        const result = diffOutput("npm test", "/tmp/diff", "PASS test1\nPASS test2\nPASS test3");
-        expect(result.hasPrevious).toBe(true);
-        expect(result.unchanged).toBe(false);
-        expect(result.added).toContain("PASS test3");
-        expect(result.removed).toContain("FAIL test3");
-    });
-});

package/dist/economy.test.js

@@ -1,13 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { formatTokens } from "./economy.js";
-describe("formatTokens", () => {
-    it("formats small numbers", () => {
-        expect(formatTokens(42)).toBe("42");
-    });
-    it("formats thousands", () => {
-        expect(formatTokens(1500)).toBe("1.5K");
-    });
-    it("formats millions", () => {
-        expect(formatTokens(2500000)).toBe("2.5M");
-    });
-});