@hasna/terminal 4.3.0 → 4.3.1

package/dist/command-rewriter.js

@@ -1,64 +0,0 @@
-// 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 → sort by memory and head (macOS compatible)
-    {
-        pattern: /^ps\s+aux\s*$/,
-        rewrite: () => "ps aux | sort -k4 -rn | 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/command-validator.js

@@ -1,86 +0,0 @@
-// Command validator — catch invalid commands BEFORE executing
-// Prevents shell errors from hallucinated flags, wrong paths, bad syntax
-import { existsSync } from "fs";
-import { join } from "path";
-/** Extract file paths referenced in a command */
-function extractPaths(command) {
-    const paths = [];
-    // Match quoted paths
-    const quoted = command.match(/["']([^"']+\.\w+)["']/g);
-    if (quoted)
-        paths.push(...quoted.map(q => q.replace(/["']/g, "")));
-    // Match unquoted paths with extensions or directory separators
-    const tokens = command.split(/\s+/);
-    for (const t of tokens) {
-        if (t.includes("/") && !t.startsWith("-") && !t.startsWith("|") && !t.startsWith("&")) {
-            // Clean shell operators from end
-            const clean = t.replace(/[;|&>]+$/, "");
-            if (clean && !clean.startsWith("-"))
-                paths.push(clean);
-        }
-    }
-    return [...new Set(paths)];
-}
-/** Check for obviously broken shell syntax */
-function checkSyntax(command) {
-    const issues = [];
-    // Unmatched quotes
-    const singleQuotes = (command.match(/'/g) || []).length;
-    const doubleQuotes = (command.match(/"/g) || []).length;
-    if (singleQuotes % 2 !== 0)
-        issues.push("unmatched single quote");
-    if (doubleQuotes % 2 !== 0)
-        issues.push("unmatched double quote");
-    // Unmatched parentheses
-    const openParens = (command.match(/\(/g) || []).length;
-    const closeParens = (command.match(/\)/g) || []).length;
-    if (openParens !== closeParens)
-        issues.push("unmatched parentheses");
-    // Empty pipe targets
-    if (/\|\s*$/.test(command))
-        issues.push("pipe with no target");
-    if (/^\s*\|/.test(command))
-        issues.push("pipe with no source");
-    return issues;
-}
-/** Validate a command before execution */
-export function validateCommand(command, cwd) {
-    const issues = [];
-    // Check syntax
-    issues.push(...checkSyntax(command));
-    // Check file paths exist
-    const paths = extractPaths(command);
-    for (const p of paths) {
-        const fullPath = p.startsWith("/") ? p : join(cwd, p);
-        if (p.includes("*") || p.includes("?"))
-            continue; // skip globs
-        if (p.startsWith("-"))
-            continue; // skip flags
-        if ([".", "..", "/", "~"].includes(p))
-            continue; // skip special
-        if (!existsSync(fullPath) && !existsSync(p)) {
-            // Only flag source file paths, not output paths
-            if (/\.(ts|tsx|js|jsx|json|md|yaml|yml|py|go|rs)$/.test(p)) {
-                issues.push(`file not found: ${p}`);
-            }
-        }
-    }
-    // Check for common GNU flags on macOS
-    const gnuFlags = command.match(/--max-depth|--color=|--sort=|--field-type|--no-deps/g);
-    if (gnuFlags) {
-        issues.push(`GNU flag on macOS: ${gnuFlags.join(", ")}`);
-    }
-    // Complexity guard — extreme pipe chains are fragile
-    const pipeCount = (command.match(/\|/g) || []).length;
-    if (pipeCount > 7) {
-        issues.push(`too complex: ${pipeCount} pipes — simplify`);
-    }
-    // grep -P (PCRE) doesn't exist on macOS
-    if (/grep\s+.*-[a-zA-Z]*P/.test(command)) {
-        issues.push("grep -P (PCRE) not available on macOS — use grep -E");
-    }
-    return {
-        valid: issues.length === 0,
-        issues,
-    };
-}

package/dist/compression.js

@@ -1,91 +0,0 @@
-// Token compression engine — reduces CLI output to fit within token budgets
-// No regex parsing — just ANSI stripping, deduplication, and smart truncation.
-// All intelligent output processing goes through AI via processOutput().
-import { estimateTokens } from "./tokens.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];
-        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) {
-                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 60% + last 40% of lines */
-function smartTruncate(text, maxTokens) {
-    const lines = text.split("\n");
-    const currentTokens = estimateTokens(text);
-    if (currentTokens <= maxTokens)
-        return text;
-    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 — ANSI strip, dedup, truncate. No parsing. */
-export function compress(command, output, options = {}) {
-    const { maxTokens, stripAnsi: doStrip = true } = options;
-    const originalTokens = estimateTokens(output);
-    // Short output — no-op, skip all processing
-    if (output.split("\n").length <= 20 && !maxTokens) {
-        const clean = doStrip ? stripAnsi(output) : output;
-        const cleanTokens = estimateTokens(clean);
-        return { content: clean, originalTokens, compressedTokens: cleanTokens, tokensSaved: Math.max(0, originalTokens - cleanTokens), savingsPercent: 0 };
-    }
-    // Step 1: Strip ANSI codes
-    let text = doStrip ? stripAnsi(output) : output;
-    // Step 2: Deduplicate similar lines
-    const lines = text.split("\n");
-    const deduped = deduplicateLines(lines);
-    text = deduped.join("\n");
-    // Step 3: Smart truncation if over budget
-    if (maxTokens) {
-        text = smartTruncate(text, maxTokens);
-    }
-    const compressedTokens = estimateTokens(text);
-    return {
-        content: text,
-        originalTokens,
-        compressedTokens,
-        tokensSaved: Math.max(0, originalTokens - compressedTokens),
-        savingsPercent: originalTokens > 0 ? Math.round(((originalTokens - compressedTokens) / originalTokens) * 100) : 0,
-    };
-}

package/dist/context-hints.js

@@ -1,285 +0,0 @@
-// Context hints — discover context via lightweight checks, inject into AI prompt
-// Regex DISCOVERS, AI DECIDES. No hardcoded logic that makes decisions.
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { join } from "path";
-/** Discover project context from the filesystem */
-export function discoverProjectHints(cwd) {
-    const hints = [];
-    // Package managers and project files
-    const projectFiles = [
-        ["package.json", "Node.js/TypeScript"],
-        ["pyproject.toml", "Python"],
-        ["requirements.txt", "Python"],
-        ["go.mod", "Go"],
-        ["Cargo.toml", "Rust"],
-        ["pom.xml", "Java/Maven"],
-        ["build.gradle", "Java/Gradle"],
-        ["build.gradle.kts", "Java/Gradle (Kotlin DSL)"],
-        ["Makefile", "Has Makefile"],
-        ["Dockerfile", "Has Docker"],
-        ["docker-compose.yml", "Has Docker Compose"],
-        ["docker-compose.yaml", "Has Docker Compose"],
-        [".github/workflows", "Has GitHub Actions CI"],
-        ["Gemfile", "Ruby"],
-        ["composer.json", "PHP"],
-        ["mix.exs", "Elixir"],
-        ["build.zig", "Zig"],
-        ["CMakeLists.txt", "C/C++ (CMake)"],
-    ];
-    for (const [file, lang] of projectFiles) {
-        if (existsSync(join(cwd, file))) {
-            hints.push(`Project type: ${lang} (${file} found)`);
-        }
-    }
-    // Extract metadata from package.json — trimmed to save tokens
-    const pkgPath = join(cwd, "package.json");
-    if (existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-            if (pkg.name)
-                hints.push(`Package: ${pkg.name}@${pkg.version ?? "?"}`);
-            if (pkg.scripts) {
-                // Only top-5 most useful scripts
-                const priority = ["dev", "build", "test", "lint", "start", "typecheck", "check"];
-                const scripts = Object.keys(pkg.scripts);
-                const top = priority.filter(s => scripts.includes(s));
-                const rest = scripts.filter(s => !priority.includes(s)).slice(0, Math.max(0, 5 - top.length));
-                hints.push(`Scripts: ${[...top, ...rest].join(", ")}`);
-            }
-            if (pkg.dependencies) {
-                // Only framework/major deps — skip utility libs
-                const major = ["react", "next", "express", "fastify", "hono", "vue", "angular", "svelte",
-                    "prisma", "drizzle", "mongoose", "typeorm", "zod", "trpc", "graphql", "tailwindcss",
-                    "electron", "bun", "elysia", "nest", "nuxt", "remix", "astro", "vite"];
-                const deps = Object.keys(pkg.dependencies);
-                const found = deps.filter(d => major.some(m => d.includes(m)));
-                if (found.length > 0)
-                    hints.push(`Key deps: ${found.slice(0, 10).join(", ")}`);
-            }
-        }
-        catch { }
-    }
-    // Extract from pyproject.toml
-    const pyPath = join(cwd, "pyproject.toml");
-    if (existsSync(pyPath)) {
-        try {
-            const py = readFileSync(pyPath, "utf8");
-            const name = py.match(/name\s*=\s*"([^"]+)"/)?.[1];
-            if (name)
-                hints.push(`Python package: ${name}`);
-        }
-        catch { }
-    }
-    // Extract from go.mod
-    const goPath = join(cwd, "go.mod");
-    if (existsSync(goPath)) {
-        try {
-            const go = readFileSync(goPath, "utf8");
-            const mod = go.match(/module\s+(\S+)/)?.[1];
-            if (mod)
-                hints.push(`Go module: ${mod}`);
-        }
-        catch { }
-    }
-    // Extract from Cargo.toml
-    const cargoPath = join(cwd, "Cargo.toml");
-    if (existsSync(cargoPath)) {
-        try {
-            const cargo = readFileSync(cargoPath, "utf8");
-            const name = cargo.match(/name\s*=\s*"([^"]+)"/)?.[1];
-            if (name)
-                hints.push(`Rust crate: ${name}`);
-        }
-        catch { }
-    }
-    // Monorepo detection
-    if (existsSync(join(cwd, "packages"))) {
-        try {
-            const pkgs = readdirSync(join(cwd, "packages")).filter(d => !d.startsWith("."));
-            hints.push(`MONOREPO: ${pkgs.length} packages in packages/ — search packages/ not src/`);
-            hints.push(`Packages: ${pkgs.slice(0, 10).join(", ")}`);
-        }
-        catch { }
-    }
-    if (existsSync(join(cwd, "apps"))) {
-        hints.push("MONOREPO: apps/ directory detected");
-    }
-    // Makefile targets
-    if (existsSync(join(cwd, "Makefile"))) {
-        try {
-            const { execSync } = require("child_process");
-            const targets = execSync("grep -E '^[a-zA-Z_-]+:' Makefile | head -10 | cut -d: -f1", { cwd, encoding: "utf8", timeout: 1000 }).trim();
-            if (targets)
-                hints.push(`Makefile targets: ${targets.split("\n").join(", ")}`);
-        }
-        catch { }
-    }
-    // Source directory structure — max 20 files to save tokens
-    try {
-        const { execSync } = require("child_process");
-        const srcDirs = ["src", "lib", "app", "packages"];
-        for (const dir of srcDirs) {
-            if (existsSync(join(cwd, dir))) {
-                const tree = execSync(`find ${dir} -maxdepth 2 -not -path '*/node_modules/*' -not -path '*/dist/*' -not -name '*.test.*' -not -name '*.spec.*' 2>/dev/null | sort | head -20`, { cwd, encoding: "utf8", timeout: 2000 }).trim();
-                if (tree)
-                    hints.push(`Files in ${dir}/:\n${tree}`);
-                break;
-            }
-        }
-    }
-    catch { }
-    return hints;
-}
-/** Discover output-specific hints (observations about command output) */
-export function discoverOutputHints(output, command) {
-    const hints = [];
-    const lines = output.split("\n");
-    hints.push(`Output: ${lines.length} lines, ${output.length} chars`);
-    // Only detect test results from actual test runners (not grep output containing "pass"/"fail" in code)
-    const isGrepOutput = /^\s*(src\/|\.\/|packages\/).*:\d+:/.test(output);
-    if (!isGrepOutput) {
-        const passMatch = output.match(/(\d+)\s+pass(?:ed|ing)?\b/i);
-        const failMatch = output.match(/(\d+)\s+fail(?:ed|ing|ure)?\b/i);
-        if (passMatch)
-            hints.push(`Test results detected: ${passMatch[0]}`);
-        if (failMatch)
-            hints.push(`Test results detected: ${failMatch[0]}`);
-        // Error patterns (only from actual command output, not code search)
-        if (output.match(/error\s*TS\d+/i))
-            hints.push("TypeScript errors detected in output");
-        if (output.match(/ENOENT|EACCES|EADDRINUSE/))
-            hints.push("System error code detected in output");
-    }
-    // Coverage patterns
-    if (output.match(/%\s*Funcs|%\s*Lines|coverage/i))
-        hints.push("Code coverage data detected in output");
-    // Large/repetitive output
-    if (lines.length > 100)
-        hints.push(`Large output (${lines.length} lines) — consider summarizing`);
-    const uniqueLines = new Set(lines.map(l => l.trim())).size;
-    if (uniqueLines < lines.length * 0.5)
-        hints.push("Output has many duplicate/similar lines");
-    // Sensitive data (only env var assignments, not code containing the word KEY/TOKEN)
-    if (output.match(/^[A-Z_]+(KEY|TOKEN|SECRET|PASSWORD)\s*=\s*\S+/m))
-        hints.push("Output may contain sensitive data — redact credentials");
-    // Error block extraction — state machine that captures multi-line errors
-    if (!isGrepOutput) {
-        const errorBlocks = extractErrorBlocks(output);
-        if (errorBlocks.length > 0) {
-            const summary = errorBlocks.slice(0, 3).map(b => b.trim().split("\n").slice(0, 5).join("\n")).join("\n---\n");
-            hints.push(`ERROR BLOCKS FOUND (${errorBlocks.length}):\n${summary}`);
-        }
-    }
-    return hints;
-}
-/** Extract multi-line error blocks using a state machine */
-function extractErrorBlocks(output) {
-    const lines = output.split("\n");
-    const blocks = [];
-    let currentBlock = [];
-    let inErrorBlock = false;
-    let blankCount = 0;
-    // Patterns that START an error block
-    const errorStarters = [
-        /^error/i, /^Error:/i, /^ERROR/,
-        /^Traceback/i, /^panic:/i, /^fatal:/i,
-        /^FAIL/i, /^✗/, /^✘/,
-        /error\s*TS\d+/i, /error\[E\d+\]/,
-        /^SyntaxError/i, /^TypeError/i, /^ReferenceError/i,
-        /^Unhandled/i, /^Exception/i,
-        /ENOENT|EACCES|EADDRINUSE|ECONNREFUSED/,
-    ];
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            blankCount++;
-            if (inErrorBlock) {
-                currentBlock.push(line);
-                // 2+ blank lines = end of error block
-                if (blankCount >= 2) {
-                    blocks.push(currentBlock.join("\n").trim());
-                    currentBlock = [];
-                    inErrorBlock = false;
-                }
-            }
-            continue;
-        }
-        blankCount = 0;
-        // Check if this line starts a new error block
-        if (!inErrorBlock && errorStarters.some(p => p.test(trimmed))) {
-            inErrorBlock = true;
-            currentBlock = [line];
-            continue;
-        }
-        if (inErrorBlock) {
-            // Continuation: indented lines, "at ..." stack frames, "--->" pointers, "File ..." python traces
-            const isContinuation = /^\s+/.test(line) ||
-                /^\s*at\s/.test(trimmed) ||
-                /^\s*-+>/.test(trimmed) ||
-                /^\s*\|/.test(trimmed) ||
-                /^\s*File "/.test(trimmed) ||
-                /^\s*\d+\s*\|/.test(trimmed) || // rust/compiler line numbers
-                /^Caused by:/i.test(trimmed);
-            if (isContinuation) {
-                currentBlock.push(line);
-            }
-            else {
-                // Non-continuation, non-blank = end of error block
-                blocks.push(currentBlock.join("\n").trim());
-                currentBlock = [];
-                inErrorBlock = false;
-                // Check if THIS line starts a new error block
-                if (errorStarters.some(p => p.test(trimmed))) {
-                    inErrorBlock = true;
-                    currentBlock = [line];
-                }
-            }
-        }
-    }
-    // Flush remaining block
-    if (currentBlock.length > 0) {
-        blocks.push(currentBlock.join("\n").trim());
-    }
-    return blocks;
-}
-/** Discover safety hints about a command */
-export function discoverSafetyHints(command) {
-    const hints = [];
-    // Observations about the command (AI decides if it's safe)
-    if (command.match(/\brm\b|\brmdir\b|\btruncate\b/))
-        hints.push("SAFETY: command contains file deletion (rm/rmdir/truncate)");
-    if (command.match(/\bkill\b|\bkillall\b|\bpkill\b/))
-        hints.push("SAFETY: command kills processes");
-    if (command.match(/\bgit\s+push\b|\bgit\s+reset\s+--hard\b/))
-        hints.push("SAFETY: command pushes/resets git");
-    if (command.match(/\bnpx\b|\bnpm\s+install\b|\bpip\s+install\b/))
-        hints.push("SAFETY: command installs packages");
-    if (command.match(/\bsed\s+-i\b|\bcodemod\b/))
-        hints.push("SAFETY: command modifies files in-place");
-    if (command.match(/\btouch\b|\bmkdir\b/))
-        hints.push("SAFETY: command creates files/directories");
-    if (command.match(/>\s*\S+\.\w+/))
-        hints.push("SAFETY: command writes to a file via redirect");
-    if (command.match(/\b(bun|npm|pnpm)\s+run\s+dev\b|\bstart\b/))
-        hints.push("SAFETY: command starts a server/process");
-    // Read-only observations
-    if (command.match(/^\s*git\s+(log|show|diff|status|branch|blame|tag)\b/))
-        hints.push("This is a read-only git command");
-    if (command.match(/^\s*(ls|cat|head|tail|grep|find|wc|du|df|uptime|whoami|pwd)\b/))
-        hints.push("This is a read-only command");
-    return hints;
-}
-/** Format all hints for system prompt injection */
-export function formatHints(project, output, safety) {
-    const sections = [];
-    if (project.length > 0) {
-        sections.push("PROJECT CONTEXT:\n" + project.join("\n"));
-    }
-    if (output && output.length > 0) {
-        sections.push("OUTPUT OBSERVATIONS:\n" + output.join("\n"));
-    }
-    if (safety && safety.length > 0) {
-        sections.push("SAFETY OBSERVATIONS:\n" + safety.join("\n"));
-    }
-    return sections.join("\n\n");
-}

package/dist/diff-cache.js

@@ -1,107 +0,0 @@
-// Diff-aware output caching — when same command runs again, return only what changed
-import { estimateTokens } from "./tokens.js";
-const cache = new Map();
-function cacheKey(command, cwd) {
-    return `${cwd}:${command}`;
-}
-/** Compute a simple line diff between two outputs */
-function lineDiff(prev, curr) {
-    const prevLines = new Set(prev.split("\n"));
-    const currLines = curr.split("\n");
-    const added = [];
-    const removed = [];
-    let unchanged = 0;
-    for (const line of currLines) {
-        if (prevLines.has(line)) {
-            unchanged++;
-            prevLines.delete(line);
-        }
-        else {
-            added.push(line);
-        }
-    }
-    for (const line of prevLines) {
-        removed.push(line);
-    }
-    return { added, removed, unchanged };
-}
-/** Generate a human-readable diff summary */
-function summarizeDiff(diff) {
-    const parts = [];
-    if (diff.added.length > 0)
-        parts.push(`+${diff.added.length} new lines`);
-    if (diff.removed.length > 0)
-        parts.push(`-${diff.removed.length} removed lines`);
-    parts.push(`${diff.unchanged} unchanged`);
-    return parts.join(", ");
-}
-/** Run diffing on command output. Caches the output for next comparison. */
-export function diffOutput(command, cwd, output) {
-    const key = cacheKey(command, cwd);
-    const prev = cache.get(key);
-    // Store current for next time
-    cache.set(key, { command, cwd, output, timestamp: Date.now() });
-    if (!prev) {
-        return {
-            full: output,
-            hasPrevious: false,
-            added: [],
-            removed: [],
-            diffSummary: "first run",
-            unchanged: false,
-            tokensSaved: 0,
-        };
-    }
-    if (prev.output === output) {
-        const fullTokens = estimateTokens(output);
-        return {
-            full: output,
-            hasPrevious: true,
-            added: [],
-            removed: [],
-            diffSummary: "identical to previous run",
-            unchanged: true,
-            tokensSaved: fullTokens - 10, // ~10 tokens for the "unchanged" message
-        };
-    }
-    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 diffTokens = estimateTokens(diffContent);
-    return {
-        full: output,
-        hasPrevious: true,
-        added: diff.added,
-        removed: diff.removed,
-        diffSummary: summarizeDiff(diff),
-        unchanged: false,
-        tokensSaved: Math.max(0, fullTokens - diffTokens),
-    };
-}
-/** Clear the diff cache */
-export function clearDiffCache() {
-    cache.clear();
-}