@hasna/terminal 2.3.0 → 2.3.2

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);
+            // ONLY use JSON if it actually saves tokens (never return larger output)
+            if (savings.saved > 0 && (!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/context-hints.js

@@ -0,0 +1,275 @@
+// 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 rich metadata from package.json
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            if (pkg.name)
+                hints.push(`Package name: ${pkg.name}@${pkg.version ?? "unknown"}`);
+            if (pkg.scripts) {
+                hints.push(`Available scripts: ${Object.entries(pkg.scripts).map(([k, v]) => `${k}: ${v}`).slice(0, 10).join(", ")}`);
+            }
+            if (pkg.dependencies)
+                hints.push(`Dependencies: ${Object.keys(pkg.dependencies).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
+    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 3 -not -path '*/node_modules/*' -not -path '*/dist/*' -not -name '*.test.*' 2>/dev/null | sort | head -60`, { cwd, encoding: "utf8", timeout: 3000 }).trim();
+                if (tree)
+                    hints.push(`Files in ${dir}/:\n${tree}`);
+                break;
+            }
+        }
+        // Top-level files
+        const topLevel = execSync("ls -1", { cwd, encoding: "utf8", timeout: 1000 }).trim();
+        hints.push(`Top-level: ${topLevel.split("\n").join(", ")}`);
+    }
+    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

@@ -0,0 +1,107 @@
+// Diff-aware output caching — when same command runs again, return only what changed
+import { estimateTokens } from "./parsers/index.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();
+}