@hasna/terminal 2.0.5 → 2.2.0

package/dist/output-processor.js

@@ -1,136 +0,0 @@
-// 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";
-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 {
-        // Pre-parse: if output contains clear pass/fail counts, extract and return directly
-        // No hardcoded test runner list — works for ANY tool that outputs "X pass, Y fail"
-        const passMatch = output.match(/(\d+)\s+pass/i);
-        const failMatch = output.match(/(\d+)\s+fail/i);
-        // Pre-parse fires when output has BOTH pass+fail counts AND the user asked about tests
-        if (passMatch && failMatch && originalPrompt && /test|pass|fail/i.test(originalPrompt)) {
-            const passed = parseInt(passMatch[1]);
-            const failed = parseInt(failMatch[1]);
-            const answer = failed === 0
-                ? `✓ Yes, all ${passed} tests pass.`
-                : `✗ ${failed} of ${passed + failed} tests failed.`;
-            const savedTokens = estimateTokens(output) - estimateTokens(answer);
-            return {
-                summary: answer, full: output, tokensSaved: Math.max(0, savedTokens),
-                aiTokensUsed: 0, aiProcessed: true, aiCostUsd: 0, savingsValueUsd: 0, netSavingsUsd: 0,
-            };
-        }
-        const provider = getProvider();
-        const summary = await provider.complete(`${originalPrompt ? `User asked: ${originalPrompt}\n` : ""}Command: ${command}\nOutput (${lines.length} lines):\n${toSummarize}`, {
-            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

@@ -1,41 +0,0 @@
-// 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/parsers/base.js

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

package/dist/parsers/build.js

@@ -1,64 +0,0 @@
-// 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

@@ -1,101 +0,0 @@
-// 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

@@ -1,78 +0,0 @@
-// 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

@@ -1,99 +0,0 @@
-// 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

@@ -1,48 +0,0 @@
-// 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 };
-}

package/dist/parsers/tests.js

@@ -1,89 +0,0 @@
-// Parser for test runner output (jest, vitest, bun test, pytest, go test)
-export const testParser = {
-    name: "test",
-    detect(command, output) {
-        if (/\b(jest|vitest|bun\s+test|pytest|go\s+test|mocha|ava|tap)\b/.test(command))
-            return true;
-        if (/\b(npm|bun|pnpm|yarn)\s+(run\s+)?test\b/.test(command))
-            return true;
-        // Detect by output patterns
-        return /Tests:\s+\d+/.test(output) || /\d+\s+(passing|passed|failed)/.test(output) || /PASS|FAIL/.test(output);
-    },
-    parse(_command, output) {
-        const failures = [];
-        let passed = 0, failed = 0, skipped = 0, duration;
-        // Jest/Vitest style: Tests: 5 passed, 2 failed, 7 total
-        const jestMatch = output.match(/Tests:\s+(?:(\d+)\s+passed)?[,\s]*(?:(\d+)\s+failed)?[,\s]*(?:(\d+)\s+skipped)?[,\s]*(\d+)\s+total/);
-        if (jestMatch) {
-            passed = parseInt(jestMatch[1] ?? "0");
-            failed = parseInt(jestMatch[2] ?? "0");
-            skipped = parseInt(jestMatch[3] ?? "0");
-        }
-        // Bun test style: 5 pass, 2 fail
-        const bunMatch = output.match(/(\d+)\s+pass.*?(\d+)\s+fail/);
-        if (!jestMatch && bunMatch) {
-            passed = parseInt(bunMatch[1]);
-            failed = parseInt(bunMatch[2]);
-        }
-        // Pytest style: 5 passed, 2 failed
-        const pytestMatch = output.match(/(\d+)\s+passed(?:.*?(\d+)\s+failed)?/);
-        if (!jestMatch && !bunMatch && pytestMatch) {
-            passed = parseInt(pytestMatch[1]);
-            failed = parseInt(pytestMatch[2] ?? "0");
-        }
-        // Go test: ok/FAIL + count
-        const goPassMatch = output.match(/ok\s+\S+\s+([\d.]+s)/);
-        const goFailMatch = output.match(/FAIL\s+\S+/);
-        if (!jestMatch && !bunMatch && !pytestMatch && (goPassMatch || goFailMatch)) {
-            const passLines = (output.match(/--- PASS/g) || []).length;
-            const failLines = (output.match(/--- FAIL/g) || []).length;
-            passed = passLines;
-            failed = failLines;
-            if (goPassMatch)
-                duration = goPassMatch[1];
-        }
-        // Duration
-        const timeMatch = output.match(/Time:\s+([\d.]+\s*(?:s|ms|m))/i) || output.match(/in\s+([\d.]+\s*(?:s|ms|m))/i);
-        if (timeMatch)
-            duration = timeMatch[1];
-        // Extract failure details: lines starting with FAIL or ✗ or ×
-        const lines = output.split("\n");
-        let capturingFailure = false;
-        let currentTest = "";
-        let currentError = [];
-        for (const line of lines) {
-            const failMatch = line.match(/(?:FAIL|✗|×|✕)\s+(.+)/);
-            if (failMatch) {
-                if (capturingFailure && currentTest) {
-                    failures.push({ test: currentTest, error: currentError.join("\n").trim() });
-                }
-                currentTest = failMatch[1].trim();
-                currentError = [];
-                capturingFailure = true;
-                continue;
-            }
-            if (capturingFailure) {
-                if (line.match(/^(PASS|✓|✔|FAIL|✗|×|✕)\s/) || line.match(/^Tests:|^\d+ pass/)) {
-                    failures.push({ test: currentTest, error: currentError.join("\n").trim() });
-                    capturingFailure = false;
-                    currentTest = "";
-                    currentError = [];
-                }
-                else {
-                    currentError.push(line);
-                }
-            }
-        }
-        if (capturingFailure && currentTest) {
-            failures.push({ test: currentTest, error: currentError.join("\n").trim() });
-        }
-        return {
-            passed,
-            failed,
-            skipped,
-            total: passed + failed + skipped,
-            duration,
-            failures,
-        };
-    },
-};