@hasna/terminal 2.3.0 → 2.3.2

package/dist/output-processor.js

@@ -0,0 +1,129 @@
+// AI-powered output processor — uses cheap AI to intelligently summarize any output
+// NOTHING is hardcoded. The AI decides what's important, what's noise, what to keep.
+import { getProvider } from "./providers/index.js";
+import { estimateTokens } from "./parsers/index.js";
+import { recordSaving } from "./economy.js";
+import { discoverOutputHints } from "./context-hints.js";
+import { formatProfileHints } from "./tool-profiles.js";
+const MIN_LINES_TO_PROCESS = 15;
+const MAX_OUTPUT_FOR_AI = 8000; // chars to send to AI (truncate if longer)
+const SUMMARIZE_PROMPT = `You are an intelligent terminal assistant. Given a user's original question and the command output, ANSWER THE QUESTION directly.
+
+RULES:
+- If the user asked a YES/NO question, start with Yes or No, then explain briefly
+- If the user asked "how many", give the number first, then context
+- If the user asked "show me X", show only X, not everything
+- ANSWER the question using the data — don't just summarize the raw output
+- Use symbols: ✓ for success/yes, ✗ for failure/no, ⚠ for warnings
+- Maximum 8 lines
+- Keep errors/failures verbatim
+- Be direct and concise — the user wants an ANSWER, not a data dump
+- For TEST OUTPUT: look for "X pass" and "X fail" lines. These are DEFINITIVE. If you see "42 pass, 0 fail" in the output, the answer is "42 tests pass, 0 fail." NEVER say "no tests found" or "incomplete" when pass/fail counts are visible.
+- For BUILD OUTPUT: if tsc/build exits 0 with no output, it SUCCEEDED. Empty output = success.`;
+/**
+ * Process command output through AI summarization.
+ * Cheap AI call (~100 tokens) saves 1000+ tokens downstream.
+ */
+export async function processOutput(command, output, originalPrompt) {
+    const lines = output.split("\n");
+    // Short output — skip AI UNLESS we have an original prompt (NL mode needs answer framing)
+    if (lines.length <= MIN_LINES_TO_PROCESS && !originalPrompt) {
+        return {
+            summary: output,
+            full: output,
+            tokensSaved: 0,
+            aiTokensUsed: 0,
+            aiProcessed: false,
+            aiCostUsd: 0,
+            savingsValueUsd: 0,
+            netSavingsUsd: 0,
+        };
+    }
+    // Truncate very long output before sending to AI
+    let toSummarize = output;
+    if (toSummarize.length > MAX_OUTPUT_FOR_AI) {
+        const headChars = Math.floor(MAX_OUTPUT_FOR_AI * 0.6);
+        const tailChars = Math.floor(MAX_OUTPUT_FOR_AI * 0.3);
+        toSummarize = output.slice(0, headChars) +
+            `\n\n... (${lines.length} total lines, middle truncated) ...\n\n` +
+            output.slice(-tailChars);
+    }
+    try {
+        // Discover output hints — regex discovers patterns, AI decides what matters
+        const outputHints = discoverOutputHints(output, command);
+        const hintsBlock = outputHints.length > 0
+            ? `\n\nOUTPUT OBSERVATIONS:\n${outputHints.join("\n")}`
+            : "";
+        // Inject tool-specific profile hints
+        const profileBlock = formatProfileHints(command);
+        const profileHints = profileBlock ? `\n\n${profileBlock}` : "";
+        const provider = getProvider();
+        const summary = await provider.complete(`${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}${hintsBlock}${profileHints}`, {
+            system: SUMMARIZE_PROMPT,
+            maxTokens: 300,
+        });
+        const originalTokens = estimateTokens(output);
+        const summaryTokens = estimateTokens(summary);
+        const saved = Math.max(0, originalTokens - summaryTokens);
+        if (saved > 0) {
+            recordSaving("compressed", saved);
+        }
+        // Try to extract structured JSON if the AI returned it
+        let structured;
+        try {
+            const jsonMatch = summary.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                structured = JSON.parse(jsonMatch[0]);
+            }
+        }
+        catch { /* not JSON, that's fine */ }
+        // Cost calculation
+        // AI input: system prompt (~200 tokens) + command + output sent to AI
+        const aiInputTokens = estimateTokens(SUMMARIZE_PROMPT) + estimateTokens(toSummarize) + 20;
+        const aiOutputTokens = summaryTokens;
+        const aiTokensUsed = aiInputTokens + aiOutputTokens;
+        // Cerebras qwen-3-235b pricing: $0.60/M input, $1.20/M output
+        const aiCostUsd = (aiInputTokens * 0.60 + aiOutputTokens * 1.20) / 1_000_000;
+        // Value of tokens saved (at Claude Sonnet $3/M input — what the agent would pay)
+        const savingsValueUsd = (saved * 3.0) / 1_000_000;
+        const netSavingsUsd = savingsValueUsd - aiCostUsd;
+        // Only record savings if net positive (AI cost < token savings value)
+        if (netSavingsUsd > 0 && saved > 0) {
+            recordSaving("compressed", saved);
+        }
+        return {
+            summary,
+            full: output,
+            structured,
+            tokensSaved: saved,
+            aiTokensUsed,
+            aiProcessed: true,
+            aiCostUsd,
+            savingsValueUsd,
+            netSavingsUsd,
+        };
+    }
+    catch {
+        // AI unavailable — fall back to simple truncation
+        const head = lines.slice(0, 5).join("\n");
+        const tail = lines.slice(-5).join("\n");
+        const fallback = `${head}\n  ... (${lines.length - 10} lines hidden) ...\n${tail}`;
+        return {
+            summary: fallback,
+            full: output,
+            tokensSaved: Math.max(0, estimateTokens(output) - estimateTokens(fallback)),
+            aiTokensUsed: 0,
+            aiProcessed: false,
+            aiCostUsd: 0,
+            savingsValueUsd: 0,
+            netSavingsUsd: 0,
+        };
+    }
+}
+/**
+ * Lightweight version — just decides IF output should be processed.
+ * Returns true if the output would benefit from AI summarization.
+ */
+export function shouldProcess(output) {
+    return output.split("\n").length > MIN_LINES_TO_PROCESS;
+}

package/dist/output-router.js

@@ -0,0 +1,41 @@
+// Output intelligence router — auto-detect command type and optimize output
+import { parseOutput, estimateTokens } from "./parsers/index.js";
+import { compress, stripAnsi } from "./compression.js";
+import { recordSaving } from "./economy.js";
+/** Route command output through the best optimization path */
+export function routeOutput(command, output, maxTokens) {
+    const clean = stripAnsi(output);
+    const rawTokens = estimateTokens(clean);
+    // Try structured parsing first
+    const parsed = parseOutput(command, clean);
+    if (parsed) {
+        const json = JSON.stringify(parsed.data);
+        const jsonTokens = estimateTokens(json);
+        const saved = rawTokens - jsonTokens;
+        if (saved > 0) {
+            recordSaving("structured", saved);
+            return {
+                raw: clean,
+                structured: parsed.data,
+                parser: parsed.parser,
+                tokensSaved: saved,
+                format: "json",
+            };
+        }
+    }
+    // Try compression if structured didn't save enough
+    if (maxTokens || rawTokens > 200) {
+        const compressed = compress(command, clean, { maxTokens, format: "text" });
+        if (compressed.tokensSaved > 0) {
+            recordSaving("compressed", compressed.tokensSaved);
+            return {
+                raw: clean,
+                compressed: compressed.content,
+                tokensSaved: compressed.tokensSaved,
+                format: "compressed",
+            };
+        }
+    }
+    // Return raw if no optimization helps
+    return { raw: clean, tokensSaved: 0, format: "raw" };
+}

package/dist/output-store.js

@@ -0,0 +1,111 @@
+// Output store — saves full raw output to disk when AI compresses it
+// Agents can read the file for full detail. Tiered retention strategy.
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+const OUTPUTS_DIR = join(process.env.HOME ?? "~", ".terminal", "outputs");
+/** Ensure outputs directory exists */
+function ensureDir() {
+    if (!existsSync(OUTPUTS_DIR))
+        mkdirSync(OUTPUTS_DIR, { recursive: true });
+}
+/** Generate a short hash for an output */
+function hashOutput(command, output) {
+    return createHash("md5").update(command + output.slice(0, 1000)).digest("hex").slice(0, 12);
+}
+/** Tiered retention: recent = keep all, older = keep only high-value */
+function rotate() {
+    try {
+        const now = Date.now();
+        const ONE_HOUR = 60 * 60 * 1000;
+        const ONE_DAY = 24 * ONE_HOUR;
+        const files = readdirSync(OUTPUTS_DIR)
+            .filter(f => f.endsWith(".txt"))
+            .map(f => {
+            const path = join(OUTPUTS_DIR, f);
+            const stat = statSync(path);
+            return { name: f, path, mtime: stat.mtimeMs, size: stat.size };
+        })
+            .sort((a, b) => b.mtime - a.mtime); // newest first
+        for (const file of files) {
+            const age = now - file.mtime;
+            // Last 1 hour: keep everything
+            if (age < ONE_HOUR)
+                continue;
+            // Last 24 hours: keep outputs >2KB (meaningful compression)
+            if (age < ONE_DAY) {
+                if (file.size < 2000) {
+                    try {
+                        unlinkSync(file.path);
+                    }
+                    catch { }
+                }
+                continue;
+            }
+            // Older than 24h: keep only >10KB (high-value saves)
+            if (file.size < 10000) {
+                try {
+                    unlinkSync(file.path);
+                }
+                catch { }
+                continue;
+            }
+            // Older than 7 days: remove everything
+            if (age > 7 * ONE_DAY) {
+                try {
+                    unlinkSync(file.path);
+                }
+                catch { }
+            }
+        }
+        // Hard cap: never exceed 100 files or 10MB total
+        const remaining = readdirSync(OUTPUTS_DIR)
+            .filter(f => f.endsWith(".txt"))
+            .map(f => ({ path: join(OUTPUTS_DIR, f), mtime: statSync(join(OUTPUTS_DIR, f)).mtimeMs, size: statSync(join(OUTPUTS_DIR, f)).size }))
+            .sort((a, b) => b.mtime - a.mtime);
+        let totalSize = 0;
+        for (let i = 0; i < remaining.length; i++) {
+            totalSize += remaining[i].size;
+            if (i >= 100 || totalSize > 10 * 1024 * 1024) {
+                try {
+                    unlinkSync(remaining[i].path);
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+}
+/** Save full output to disk, return the file path */
+export function saveOutput(command, rawOutput) {
+    ensureDir();
+    const hash = hashOutput(command, rawOutput);
+    const filename = `${hash}.txt`;
+    const filepath = join(OUTPUTS_DIR, filename);
+    const content = `$ ${command}\n${"─".repeat(60)}\n${rawOutput}`;
+    writeFileSync(filepath, content, "utf8");
+    rotate();
+    return filepath;
+}
+/** Format the hint line that tells agents where to find full output */
+export function formatOutputHint(filepath) {
+    return `[full output: ${filepath}]`;
+}
+/** Get the outputs directory path */
+export function getOutputsDir() {
+    return OUTPUTS_DIR;
+}
+/** Manually purge all outputs */
+export function purgeOutputs() {
+    if (!existsSync(OUTPUTS_DIR))
+        return 0;
+    let count = 0;
+    for (const f of readdirSync(OUTPUTS_DIR)) {
+        try {
+            unlinkSync(join(OUTPUTS_DIR, f));
+            count++;
+        }
+        catch { }
+    }
+    return count;
+}

package/dist/parsers/base.js

@@ -0,0 +1,2 @@
+// Base types for output parsers
+export {};

package/dist/parsers/build.js

@@ -0,0 +1,64 @@
+// Parser for build output (npm/bun/pnpm build, tsc, webpack, vite, etc.)
+export const buildParser = {
+    name: "build",
+    detect(command, output) {
+        if (/\b(npm|bun|pnpm|yarn)\s+(run\s+)?build\b/.test(command))
+            return true;
+        if (/\btsc\b/.test(command))
+            return true;
+        if (/\b(webpack|vite|esbuild|rollup|turbo)\b/.test(command))
+            return true;
+        return /\b(compiled|bundled|built)\b/i.test(output) && /\b(success|error|warning)\b/i.test(output);
+    },
+    parse(_command, output) {
+        const lines = output.split("\n");
+        let warnings = 0, errors = 0, duration;
+        // Count warnings and errors
+        for (const line of lines) {
+            if (/\bwarning\b/i.test(line))
+                warnings++;
+            if (/\berror\b/i.test(line) && !/0 errors/.test(line))
+                errors++;
+        }
+        // Specific patterns
+        const tscErrors = output.match(/Found (\d+) error/);
+        if (tscErrors)
+            errors = parseInt(tscErrors[1]);
+        const warningCount = output.match(/(\d+)\s+warning/);
+        if (warningCount)
+            warnings = parseInt(warningCount[1]);
+        // Duration
+        const timeMatch = output.match(/(?:in|took)\s+([\d.]+\s*(?:s|ms|m))/i) ||
+            output.match(/Done in ([\d.]+s)/);
+        if (timeMatch)
+            duration = timeMatch[1];
+        const status = errors > 0 ? "failure" : "success";
+        return { status, warnings, errors, duration };
+    },
+};
+export const npmInstallParser = {
+    name: "npm-install",
+    detect(command, _output) {
+        return /\b(npm|bun|pnpm|yarn)\s+(install|add|i)\b/.test(command);
+    },
+    parse(_command, output) {
+        let installed = 0, vulnerabilities = 0, duration;
+        // npm: added 47 packages in 3.2s
+        const npmMatch = output.match(/added\s+(\d+)\s+packages?\s+in\s+([\d.]+s)/);
+        if (npmMatch) {
+            installed = parseInt(npmMatch[1]);
+            duration = npmMatch[2];
+        }
+        // bun: 47 packages installed [1.2s]
+        const bunMatch = output.match(/(\d+)\s+packages?\s+installed.*?\[([\d.]+[ms]*s)\]/);
+        if (!npmMatch && bunMatch) {
+            installed = parseInt(bunMatch[1]);
+            duration = bunMatch[2];
+        }
+        // Vulnerabilities
+        const vulnMatch = output.match(/(\d+)\s+vulnerabilit/);
+        if (vulnMatch)
+            vulnerabilities = parseInt(vulnMatch[1]);
+        return { installed, vulnerabilities, duration };
+    },
+};

package/dist/parsers/errors.js

@@ -0,0 +1,101 @@
+// Parser for common error patterns
+const ERROR_PATTERNS = [
+    {
+        type: "port_in_use",
+        pattern: /EADDRINUSE.*?(?::(\d+))|port\s+(\d+)\s+(?:is\s+)?(?:already\s+)?in\s+use/i,
+        extract: (m) => ({
+            type: "port_in_use",
+            message: m[0],
+            suggestion: `Kill the process: lsof -i :${m[1] ?? m[2]} -t | xargs kill`,
+        }),
+    },
+    {
+        type: "file_not_found",
+        pattern: /ENOENT.*?'([^']+)'|No such file or directory:\s*(.+)/,
+        extract: (m) => ({
+            type: "file_not_found",
+            message: m[0],
+            file: m[1] ?? m[2]?.trim(),
+            suggestion: "Check the file path exists",
+        }),
+    },
+    {
+        type: "permission_denied",
+        pattern: /EACCES.*?'([^']+)'|Permission denied:\s*(.+)/,
+        extract: (m) => ({
+            type: "permission_denied",
+            message: m[0],
+            file: m[1] ?? m[2]?.trim(),
+            suggestion: "Check file permissions or run with sudo",
+        }),
+    },
+    {
+        type: "command_not_found",
+        pattern: /command not found:\s*(\S+)|(\S+):\s*not found/,
+        extract: (m) => ({
+            type: "command_not_found",
+            message: m[0],
+            suggestion: `Install ${m[1] ?? m[2]} or check your PATH`,
+        }),
+    },
+    {
+        type: "dependency_missing",
+        pattern: /Cannot find module\s+'([^']+)'|Module not found.*?'([^']+)'/,
+        extract: (m) => ({
+            type: "dependency_missing",
+            message: m[0],
+            suggestion: `Install: npm install ${m[1] ?? m[2]}`,
+        }),
+    },
+    {
+        type: "syntax_error",
+        pattern: /SyntaxError:\s*(.+)|error TS\d+:\s*(.+)/,
+        extract: (m, output) => {
+            const fileMatch = output.match(/(\S+\.\w+):(\d+)/);
+            return {
+                type: "syntax_error",
+                message: m[1] ?? m[2] ?? m[0],
+                file: fileMatch?.[1],
+                line: fileMatch ? parseInt(fileMatch[2]) : undefined,
+                suggestion: "Fix the syntax error in the referenced file",
+            };
+        },
+    },
+    {
+        type: "out_of_memory",
+        pattern: /ENOMEM|JavaScript heap out of memory|Killed/,
+        extract: (m) => ({
+            type: "out_of_memory",
+            message: m[0],
+            suggestion: "Increase memory: NODE_OPTIONS=--max-old-space-size=4096",
+        }),
+    },
+    {
+        type: "network_error",
+        pattern: /ECONNREFUSED|ENOTFOUND|ETIMEDOUT|fetch failed/,
+        extract: (m) => ({
+            type: "network_error",
+            message: m[0],
+            suggestion: "Check network connection and target URL/host",
+        }),
+    },
+];
+export const errorParser = {
+    name: "error",
+    detect(_command, output) {
+        return ERROR_PATTERNS.some(({ pattern }) => pattern.test(output));
+    },
+    parse(_command, output) {
+        for (const { pattern, extract } of ERROR_PATTERNS) {
+            const match = output.match(pattern);
+            if (match)
+                return extract(match, output);
+        }
+        // Generic error fallback
+        const errorLine = output.split("\n").find(l => /error/i.test(l));
+        return {
+            type: "unknown",
+            message: errorLine?.trim() ?? "Unknown error",
+        };
+    },
+};

package/dist/parsers/files.js

@@ -0,0 +1,78 @@
+// Parser for file listing output (ls -la, find, etc.)
+const NODE_MODULES_RE = /node_modules/;
+const DIST_RE = /\b(dist|build|\.next|__pycache__|coverage|\.git)\b/;
+const SOURCE_EXTS = /\.(ts|tsx|js|jsx|py|go|rs|java|rb|sh|c|cpp|h|css|scss|html|vue|svelte|md|json|yaml|yml|toml)$/;
+export const lsParser = {
+    name: "ls",
+    detect(command, output) {
+        return /^\s*(ls|ll|la)\b/.test(command) && output.includes(" ");
+    },
+    parse(_command, output) {
+        const lines = output.split("\n").filter(l => l.trim());
+        const entries = [];
+        for (const line of lines) {
+            // ls -la format: drwxr-xr-x  5 user group 160 Mar 10 09:00 dirname
+            const match = line.match(/^([dlcbps-])([rwxsStT-]{9})\s+\d+\s+\S+\s+\S+\s+(\d+)\s+(\w+\s+\d+\s+[\d:]+)\s+(.+)$/);
+            if (match) {
+                const typeChar = match[1];
+                entries.push({
+                    name: match[5],
+                    type: typeChar === "d" ? "dir" : typeChar === "l" ? "symlink" : "file",
+                    size: parseInt(match[3]),
+                    modified: match[4],
+                    permissions: match[1] + match[2],
+                });
+            }
+            else if (line.trim() && !line.startsWith("total ")) {
+                // Simple ls output — just filenames
+                entries.push({ name: line.trim(), type: "file" });
+            }
+        }
+        return entries;
+    },
+};
+export const findParser = {
+    name: "find",
+    detect(command, _output) {
+        return /^\s*(find|fd)\b/.test(command);
+    },
+    parse(_command, output) {
+        const lines = output.split("\n").filter(l => l.trim());
+        const source = [];
+        const other = [];
+        let nodeModulesCount = 0;
+        let distCount = 0;
+        for (const line of lines) {
+            const path = line.trim();
+            if (!path)
+                continue;
+            if (NODE_MODULES_RE.test(path)) {
+                nodeModulesCount++;
+                continue;
+            }
+            if (DIST_RE.test(path)) {
+                distCount++;
+                continue;
+            }
+            const name = path.split("/").pop() ?? path;
+            const entry = { name: path, type: SOURCE_EXTS.test(name) ? "file" : "other" };
+            if (SOURCE_EXTS.test(name)) {
+                source.push(entry);
+            }
+            else {
+                other.push(entry);
+            }
+        }
+        const filtered = [];
+        if (nodeModulesCount > 0)
+            filtered.push({ count: nodeModulesCount, reason: "node_modules" });
+        if (distCount > 0)
+            filtered.push({ count: distCount, reason: "dist/build" });
+        return {
+            total: lines.length,
+            source,
+            other,
+            filtered,
+        };
+    },
+};

package/dist/parsers/git.js

@@ -0,0 +1,99 @@
+// Parsers for git output (log, status, diff)
+export const gitLogParser = {
+    name: "git-log",
+    detect(command, _output) {
+        return /\bgit\s+log\b/.test(command);
+    },
+    parse(_command, output) {
+        const entries = [];
+        const lines = output.split("\n");
+        // Detect oneline format: "abc1234 commit message"
+        const firstLine = lines[0]?.trim() ?? "";
+        const isOneline = /^[a-f0-9]{7,12}\s+/.test(firstLine) && !firstLine.startsWith("commit ");
+        if (isOneline) {
+            for (const line of lines) {
+                const match = line.trim().match(/^([a-f0-9]{7,12})\s+(.+)$/);
+                if (match) {
+                    entries.push({ hash: match[1], author: "", date: "", message: match[2] });
+                }
+            }
+            return entries;
+        }
+        // Verbose format
+        let hash = "", author = "", date = "", message = [];
+        for (const line of lines) {
+            const commitMatch = line.match(/^commit\s+([a-f0-9]+)/);
+            if (commitMatch) {
+                if (hash) {
+                    entries.push({ hash: hash.slice(0, 8), author, date, message: message.join(" ").trim() });
+                }
+                hash = commitMatch[1];
+                author = "";
+                date = "";
+                message = [];
+                continue;
+            }
+            const authorMatch = line.match(/^Author:\s+(.+)/);
+            if (authorMatch) {
+                author = authorMatch[1];
+                continue;
+            }
+            const dateMatch = line.match(/^Date:\s+(.+)/);
+            if (dateMatch) {
+                date = dateMatch[1].trim();
+                continue;
+            }
+            if (line.startsWith("    ")) {
+                message.push(line.trim());
+            }
+        }
+        if (hash) {
+            entries.push({ hash: hash.slice(0, 8), author, date, message: message.join(" ").trim() });
+        }
+        return entries;
+    },
+};
+export const gitStatusParser = {
+    name: "git-status",
+    detect(command, _output) {
+        return /\bgit\s+status\b/.test(command);
+    },
+    parse(_command, output) {
+        const lines = output.split("\n");
+        let branch = "";
+        const staged = [];
+        const unstaged = [];
+        const untracked = [];
+        const branchMatch = output.match(/On branch\s+(\S+)/);
+        if (branchMatch)
+            branch = branchMatch[1];
+        let section = "";
+        for (const line of lines) {
+            if (line.includes("Changes to be committed")) {
+                section = "staged";
+                continue;
+            }
+            if (line.includes("Changes not staged")) {
+                section = "unstaged";
+                continue;
+            }
+            if (line.includes("Untracked files")) {
+                section = "untracked";
+                continue;
+            }
+            const fileMatch = line.match(/^\s+(?:new file|modified|deleted|renamed):\s+(.+)/);
+            if (fileMatch) {
+                if (section === "staged")
+                    staged.push(fileMatch[1].trim());
+                else if (section === "unstaged")
+                    unstaged.push(fileMatch[1].trim());
+                continue;
+            }
+            // Untracked files are just indented filenames
+            if (section === "untracked" && line.match(/^\s+\S/) && !line.includes("(use ")) {
+                untracked.push(line.trim());
+            }
+        }
+        return { branch, staged, unstaged, untracked };
+    },
+};

package/dist/parsers/index.js

@@ -0,0 +1,48 @@
+// Output parser registry — auto-detect command output type and parse to structured JSON
+import { lsParser, findParser } from "./files.js";
+import { testParser } from "./tests.js";
+import { gitLogParser, gitStatusParser } from "./git.js";
+import { buildParser, npmInstallParser } from "./build.js";
+import { errorParser } from "./errors.js";
+// Ordered by specificity — more specific parsers first
+const parsers = [
+    npmInstallParser,
+    testParser,
+    gitLogParser,
+    gitStatusParser,
+    buildParser,
+    findParser,
+    lsParser,
+    errorParser, // fallback for error detection
+];
+/** Try to parse command output with the best matching parser */
+export function parseOutput(command, output) {
+    for (const parser of parsers) {
+        if (parser.detect(command, output)) {
+            try {
+                const data = parser.parse(command, output);
+                return { parser: parser.name, data, raw: output };
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+/** Get all parsers that match (for debugging/info) */
+export function detectParsers(command, output) {
+    return parsers.filter(p => p.detect(command, output)).map(p => p.name);
+}
+/** Estimate token count for a string (rough: ~4 chars per token) */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/** Calculate token savings between raw output and parsed JSON */
+export function tokenSavings(raw, parsed) {
+    const rawTokens = estimateTokens(raw);
+    const parsedTokens = estimateTokens(JSON.stringify(parsed));
+    const saved = Math.max(0, rawTokens - parsedTokens);
+    const percent = rawTokens > 0 ? Math.round((saved / rawTokens) * 100) : 0;
+    return { rawTokens, parsedTokens, saved, percent };
+}