@hasna/terminal 0.5.2 → 0.6.0

package/src/cli.tsx

@@ -21,6 +21,90 @@ if (args[0] === "mcp") {
   }
 }
 
+// ── 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: any = {};
+    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: any) => 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: any) => !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") {

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/compression.ts

@@ -104,8 +104,8 @@ export function compress(command: string, output: string, options: CompressOptio
       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/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,27 +77,42 @@ 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 } : {}),
           }) }],
         };
       }
 
-      // 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" as const, 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" as const, 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
         }
       }
 
@@ -144,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,
@@ -153,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(
@@ -631,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 };
+}