micro-models-agent 0.61.0 → 0.62.0

package/dist/ui/line-math.js

@@ -0,0 +1,73 @@
+import stringWidth from "string-width";
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+export function stripAnsi(s) {
+    return s.replace(ANSI_RE, "");
+}
+export function charLen(s) {
+    return Array.from(s).length;
+}
+export function wrapLine(line, width, firstRowWidth) {
+    const w = width > 0 ? width : 80;
+    // Only the FIRST visual row shares its screen line with something else
+    // (e.g. the prompt); every continuation row uses the full width.
+    let limit = firstRowWidth !== undefined && firstRowWidth > 0 ? firstRowWidth : w;
+    const chars = Array.from(line);
+    const rows = [];
+    let start = 0;
+    let cells = 0;
+    for (let i = 0; i < chars.length; i++) {
+        const ch = chars[i];
+        if (ch === "\n") {
+            rows.push({ text: chars.slice(start, i).join(""), charStart: start });
+            start = i + 1;
+            cells = 0;
+            continue;
+        }
+        const cw = stringWidth(ch);
+        if (cells + cw > limit && cells > 0) {
+            rows.push({ text: chars.slice(start, i).join(""), charStart: start });
+            start = i;
+            cells = cw;
+            limit = w;
+        }
+        else {
+            cells += cw;
+        }
+    }
+    rows.push({ text: chars.slice(start).join(""), charStart: start });
+    return rows;
+}
+export function buildLayout(lines, width, firstRowWidth) {
+    const rows = [];
+    for (let b = 0; b < lines.length; b++) {
+        for (const r of wrapLine(lines[b], width, b === 0 ? firstRowWidth : undefined)) {
+            rows.push({ bufRow: b, charStart: r.charStart, text: r.text });
+        }
+    }
+    return rows;
+}
+export function layoutIndexFor(rows, bufRow, col) {
+    let idx = 0;
+    for (let i = 0; i < rows.length; i++) {
+        if (rows[i].bufRow === bufRow && rows[i].charStart <= col)
+            idx = i;
+    }
+    return idx;
+}
+export function visualColAt(rows, idx, col) {
+    const r = rows[idx];
+    const upTo = col - r.charStart;
+    return stringWidth(Array.from(r.text).slice(0, upTo).join(""));
+}
+export function charOffsetFor(rows, idx, visualCol) {
+    const r = rows[idx];
+    const chars = Array.from(r.text);
+    let cells = 0;
+    for (let i = 0; i < chars.length; i++) {
+        const cw = stringWidth(chars[i]);
+        if (cells + cw > visualCol)
+            return r.charStart + i;
+        cells += cw;
+    }
+    return r.charStart + chars.length;
+}

package/dist/ui/md-formatter.js

@@ -0,0 +1,212 @@
+import { pc } from "./colors";
+import { t } from "../i18n/index";
+import { formatTable, getTerminalWidth } from "./table";
+const KW = /\b(import|export|from|const|let|var|function|return|if|else|for|while|do|switch|case|break|continue|new|class|extends|implements|interface|type|enum|namespace|module|declare|abstract|async|await|yield|throw|try|catch|finally|typeof|instanceof|in|of|as|is|keyof|readonly|static|private|public|protected|get|set|constructor|this|super|void|never|any|unknown|boolean|string|number|symbol|object|true|false|null|undefined|default)\b/g;
+const STRING = /('[^']*'|"[^"]*"|`[^`]*`)/g;
+const COMMENT = /(\/\/[^\n]*|\/\*[\s\S]*?\*\/|#[^\n]*)/g;
+const NUMBER = /\b(\d+\.?\d*)\b/g;
+const TAG = /<\/?([A-Z][a-zA-Z0-9]*|[a-z][a-zA-Z0-9-]*)/g;
+const ATTR = /\b([a-zA-Z-]+=)"([^"]*)"/g;
+function highlight(code, lang) {
+    if (lang === "html" || lang === "xml" || lang === "svg") {
+        code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
+        code = code.replace(ATTR, (_m, attr, val) => pc.yellow(attr) + "=" + pc.green('"' + val + '"'));
+        code = code.replace(TAG, (_m, tag) => "<" + pc.cyan(tag));
+    }
+    else if (lang === "css" || lang === "scss" || lang === "less") {
+        code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
+        code = code.replace(STRING, (m) => pc.green(m));
+        code = code.replace(NUMBER, (m) => pc.yellow(m));
+    }
+    else if (lang === "bash" || lang === "sh" || lang === "shell" || lang === "zsh") {
+        code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
+        code = code.replace(STRING, (m) => pc.green(m));
+    }
+    else if (lang === "json") {
+        code = code.replace(STRING, (m) => pc.green(m));
+        code = code.replace(NUMBER, (m) => pc.yellow(m));
+    }
+    else {
+        // js, ts, jsx, tsx, and fallback
+        code = code.replace(COMMENT, (m) => pc.dim(pc.green(m)));
+        code = code.replace(STRING, (m) => pc.green(m));
+        code = code.replace(KW, (m) => pc.magenta(m));
+        code = code.replace(NUMBER, (m) => pc.yellow(m));
+    }
+    return code;
+}
+function isTableRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|"))
+        return false;
+    const pipes = trimmed.match(/\|/g);
+    return (pipes?.length ?? 0) >= 2;
+}
+function isHorizontalRule(line) {
+    return /^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trim());
+}
+export class FormattingStream {
+    buffer = "";
+    inCodeBlock = false;
+    codeLang = "";
+    codeLines = [];
+    tableBuffer = [];
+    onWrite;
+    width;
+    constructor(onWrite, width) {
+        this.onWrite = onWrite;
+        this.width = width ?? getTerminalWidth();
+    }
+    write(chunk) {
+        this.buffer += chunk;
+        let idx;
+        while ((idx = this.buffer.indexOf("\n")) !== -1) {
+            const line = this.buffer.slice(0, idx);
+            this.buffer = this.buffer.slice(idx + 1);
+            this.processLine(line);
+        }
+    }
+    flush() {
+        if (this.inCodeBlock && this.codeLines.length > 0) {
+            this.emitCodeBlock();
+        }
+        if (this.tableBuffer.length > 0) {
+            this.flushTable();
+        }
+        if (this.buffer.length > 0) {
+            const line = this.buffer;
+            this.buffer = "";
+            if (line.trim() === "```" || line.trim().startsWith("```")) {
+                if (this.codeLines.length > 0) {
+                    this.emitCodeBlock();
+                }
+                return;
+            }
+            this.onWrite(this.formatLine(line));
+        }
+    }
+    processLine(line) {
+        if (line.trim() === "```" || line.trim().startsWith("```")) {
+            if (this.inCodeBlock) {
+                this.emitCodeBlock();
+            }
+            else {
+                this.inCodeBlock = true;
+                this.codeLang = line.trim().slice(3).trim();
+                this.codeLines = [];
+            }
+            return;
+        }
+        if (this.inCodeBlock) {
+            this.codeLines.push(line);
+            return;
+        }
+        if (isTableRow(line)) {
+            this.tableBuffer.push(line);
+            return;
+        }
+        if (this.tableBuffer.length > 0) {
+            this.flushTable();
+        }
+        this.onWrite(this.formatLine(line));
+    }
+    flushTable() {
+        const lines = this.tableBuffer;
+        this.tableBuffer = [];
+        const hasSeparator = lines.length >= 2 && /^\s*\|?[\s:|-]+\|?\s*$/.test(lines[1].trim());
+        if (hasSeparator) {
+            for (const l of formatTable(lines, { maxWidth: this.width })) {
+                this.onWrite(l);
+            }
+        }
+        else {
+            for (const l of lines) {
+                this.onWrite(this.formatLine(l));
+            }
+        }
+    }
+    emitCodeBlock() {
+        this.inCodeBlock = false;
+        if (this.codeLines.length > 0) {
+            const code = this.codeLines.join("\n");
+            const highlighted = highlight(code, this.codeLang);
+            const lang = this.codeLang ? ` ${this.codeLang} ` : " ";
+            const top = pc.dim(`┌─${lang}${"─".repeat(Math.max(0, this.width - 3 - lang.length))}┐`);
+            this.onWrite(top);
+            for (const l of highlighted.split("\n")) {
+                this.onWrite(pc.dim("│ ") + l);
+            }
+            this.onWrite(pc.dim(`└${"─".repeat(Math.max(0, this.width - 1))}┘`));
+        }
+        this.codeLines = [];
+        this.codeLang = "";
+    }
+    formatLine(line) {
+        let result = line;
+        const heading = result.match(/^(#{1,6})\s+(.+)$/);
+        if (heading) {
+            const level = heading[1].length;
+            const content = this.formatInline(heading[2]);
+            if (level === 1)
+                return pc.cyan(pc.bold(pc.underline(content)));
+            return pc.cyan(pc.bold(content));
+        }
+        if (isHorizontalRule(result)) {
+            return pc.dim("─".repeat(Math.max(0, Math.min(this.width, 60))));
+        }
+        const quote = result.match(/^(>+)\s?(.*)$/);
+        if (quote) {
+            const depth = Math.min(quote[1].length, 4);
+            const marker = pc.dim("▍".repeat(depth));
+            return `${marker} ${this.formatInline(quote[2])}`;
+        }
+        const checkbox = result.match(/^[-*]\s+\[([ xX])\]\s+(.+)$/);
+        if (checkbox) {
+            const checked = checkbox[1].toLowerCase() === "x";
+            const mark = checked ? pc.green("✓") : pc.dim("☐");
+            return `  ${mark} ${this.formatInline(checkbox[2])}`;
+        }
+        const ordered = result.match(/^(\d+)[.)]\s+(.+)$/);
+        if (ordered) {
+            return ` ${pc.yellow(ordered[1])}. ${this.formatInline(ordered[2])}`;
+        }
+        const bullet = result.match(/^[-*]\s+(.+)$/);
+        if (bullet) {
+            return ` ${pc.dim("•")} ${this.formatInline(bullet[1])}`;
+        }
+        return this.formatInline(result);
+    }
+    formatInline(text) {
+        const codeSpans = [];
+        let result = text.replace(/`([^`]+)`/g, (_m, c) => {
+            codeSpans.push(pc.yellow(c));
+            return `\u0000${codeSpans.length - 1}\u0000`;
+        });
+        result = result.replace(/\*\*(.+?)\*\*/g, (_, s) => pc.bold(s));
+        result = result.replace(/~~(.+?)~~/g, (_, s) => pc.strikethrough(s));
+        result = result.replace(/\*([^*]+)\*/g, (_, s) => pc.italic(s));
+        result = result.replace(/(^|\s)_([^_\n]+)_(?=\s|$)/g, (_m, pre, s) => pre + pc.italic(s));
+        result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => {
+            const short = url.length > 80 ? url.slice(0, 77) + "…" : url;
+            return `${pc.cyan(label)} ${pc.dim(`(${short})`)}`;
+        });
+        result = result.replace(/\u0000(\d+)\u0000/g, (_m, i) => codeSpans[Number(i)]);
+        return result;
+    }
+}
+export function formatMarkdown(text) {
+    const lines = [];
+    const stream = new FormattingStream((l) => lines.push(l));
+    stream.write(text);
+    stream.flush();
+    return lines.join("\n");
+}
+export function formatError(text) {
+    return pc.red(pc.bold(t("ui.error_prefix")) + text);
+}
+export function formatSuccess(text) {
+    return pc.green(pc.bold(t("ui.success_prefix")) + text);
+}
+export function formatWarning(text) {
+    return pc.yellow(pc.bold(t("ui.warning_prefix")) + text);
+}

package/dist/ui/output.js

@@ -0,0 +1,13 @@
+import { formatMarkdown, formatError, formatSuccess, formatWarning } from "./md-formatter";
+export function writeOutput(text) {
+    process.stdout.write(formatMarkdown(text) + "\n");
+}
+export function writeError(text) {
+    process.stderr.write(formatError(text) + "\n");
+}
+export function writeSuccess(text) {
+    process.stdout.write(formatSuccess(text) + "\n");
+}
+export function writeWarning(text) {
+    process.stdout.write(formatWarning(text) + "\n");
+}

package/dist/ui/plan-view.js

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { pc } from "./colors";
+import { extractFileLikeTokens, stripUrls } from "../modules/hallucination/js-identifiers";
+import { t } from "../i18n/index";
+export function readActivePlan(baseDir) {
+    const p = join(baseDir, ".mma", "plans", "active.json");
+    if (!existsSync(p))
+        return null;
+    try {
+        const raw = readFileSync(p, "utf-8");
+        if (!raw.trim())
+            return null;
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.steps))
+            return null;
+        return {
+            id: parsed.id || "plan",
+            title: parsed.title || "Plan",
+            steps: parsed.steps,
+            createdAt: parsed.createdAt || new Date().toISOString(),
+            baseDir: parsed.baseDir || baseDir,
+            name: parsed.name,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function currentStepIndex(plan) {
+    const idx = plan.steps.findIndex((s) => s.status !== "done" && s.status !== "skipped");
+    return idx === -1 ? 0 : idx;
+}
+function stepMark(step) {
+    switch (step.status) {
+        case "done":
+            return pc.green("[x]");
+        case "in_progress":
+            return pc.yellow("[*]");
+        case "failed":
+            return pc.red("[!]");
+        case "skipped":
+            return pc.dim("[-]");
+        default:
+            return pc.dim("[ ]");
+    }
+}
+export function formatPlanChecklist(plan) {
+    const done = plan.steps.filter((s) => s.status === "done" || s.status === "skipped").length;
+    const total = plan.steps.length;
+    const pct = total === 0 ? 0 : Math.round((done / total) * 100);
+    const cur = currentStepIndex(plan);
+    const barLen = 15;
+    const filled = Math.round((pct / 100) * barLen);
+    const bar = pc.green("█".repeat(filled)) + pc.dim("░".repeat(barLen - filled));
+    const title = plan.title.replace(/^\[\d+[^]]*\]\s*/, "");
+    const lines = [
+        `${pc.cyan(`[${plan.id}]`)} ${pc.bold(title)}  ${bar} ${pc.dim(`${done}/${total} ${pct}%`)}`,
+    ];
+    for (let i = 0; i < plan.steps.length; i++) {
+        const step = plan.steps[i];
+        const active = i === cur;
+        const desc = active ? pc.yellow(step.description) : pc.dim(step.description);
+        lines.push(`  ${stepMark(step)} ${step.id}. ${desc}`);
+        for (const sub of step.subtasks ?? []) {
+            lines.push(`      ${sub.done ? pc.green("[x]") : pc.dim("[ ]")} ${sub.text}`);
+        }
+    }
+    return lines;
+}
+const STRUCTURAL_TOOLS = new Set([
+    "plan",
+    "todo",
+    "verify",
+    "project_map",
+    "lsp_check",
+    "enable_tools",
+]);
+function truncate(s, max = 48) {
+    return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+export function stepContextForTool(plan, tool, args) {
+    if (!plan || STRUCTURAL_TOOLS.has(tool))
+        return null;
+    const argStr = JSON.stringify(args);
+    const callPaths = extractFileLikeTokens(stripUrls(argStr)).map((p) => p.toLowerCase());
+    if (callPaths.length > 0) {
+        for (const step of plan.steps) {
+            if (step.status === "done" || step.status === "skipped")
+                continue;
+            const stepPaths = extractFileLikeTokens(stripUrls(step.description)).map((p) => p.toLowerCase());
+            if (stepPaths.length > 0 &&
+                stepPaths.some((s) => callPaths.some((c) => c.includes(s) || s.includes(c)))) {
+                return t("ui.step_context", { id: step.id, desc: truncate(step.description) });
+            }
+        }
+    }
+    const cur = currentStepIndex(plan);
+    const step = plan.steps[cur];
+    if (!step)
+        return null;
+    return t("ui.step_context", { id: step.id, desc: truncate(step.description) });
+}

package/dist/ui/renderer.js

@@ -0,0 +1,259 @@
+import { pc } from "./colors";
+import { FormattingStream } from "./md-formatter";
+import { Spinner } from "./spinner";
+import { box, divider } from "./box";
+import { getTerminalWidth } from "./table";
+import { t } from "../i18n/index";
+import { formatCost } from "../modules/pricing/prices";
+import { isAbsolute, relative, sep } from "path";
+function formatUsd(cost) {
+    return formatCost(cost);
+}
+/** Tools whose `path` argument is shown in the header. */
+const PATH_TOOLS = new Set([
+    "read_file",
+    "write_file",
+    "edit_file",
+    "delete_file",
+    "create_dir",
+    "move_file",
+    "list_dir",
+    "file_info",
+]);
+function toDisplayPath(baseDir, p) {
+    if (!baseDir || !isAbsolute(p))
+        return p;
+    const rel = relative(baseDir, p);
+    // Outside baseDir (../ prefix) or another drive (absolute result) → keep as-is.
+    if (!rel || rel.startsWith("..") || isAbsolute(rel))
+        return p;
+    return rel.split(sep).join("/");
+}
+const GUTTER = "  ";
+/** Tools that show a busy spinner while running (inline mode). */
+const BUSY_TOOLS = new Set(["lsp_check"]);
+/** opencode-like leading marker per tool category. */
+export function toolMarker(tool) {
+    switch (tool) {
+        case "write_file":
+        case "edit_file":
+        case "create_dir":
+        case "move_file":
+        case "delete_file":
+            return "←";
+        case "read_file":
+        case "list_dir":
+        case "file_info":
+            return "→";
+        case "glob":
+        case "grep":
+            return "✱";
+        case "bash":
+            return "$";
+        default:
+            return "⚙";
+    }
+}
+export function isRichTerminal() {
+    return Boolean(process.stdout.isTTY) && !process.env.CI;
+}
+/** Short human-friendly summary of tool arguments. */
+export function summarizeArgs(args) {
+    const preferred = ["path", "file", "query", "url", "command", "name"];
+    for (const key of preferred) {
+        const value = args[key];
+        if (typeof value === "string" && value) {
+            return value.length > 60 ? `${value.slice(0, 57)}…` : value;
+        }
+    }
+    const serialized = JSON.stringify(args);
+    if (!serialized || serialized === "{}")
+        return "";
+    return serialized.length > 60 ? `${serialized.slice(0, 57)}…` : serialized;
+}
+function friendlyTool(tool) {
+    const key = `tool.friendly.${tool}`;
+    const value = t(key);
+    return value !== key ? value : tool;
+}
+/**
+ * Streams agent events to the terminal. Rich mode (TTY) adds a spinner
+ * and boxed tool cards; plain mode falls back to simple prefixed lines.
+ * Colors come from `colors.ts`, disabled outside a TTY, in CI, or on NO_COLOR.
+ */
+export class Renderer {
+    rich;
+    spinner;
+    fmt;
+    out;
+    err;
+    width;
+    toolStyle;
+    baseDir;
+    card = null;
+    constructor(opts = {}) {
+        this.rich = opts.rich ?? isRichTerminal();
+        this.out = opts.out ?? process.stdout;
+        this.err = opts.err ?? process.stderr;
+        this.width = opts.width ?? getTerminalWidth();
+        this.toolStyle = opts.toolStyle ?? "inline";
+        this.baseDir = opts.baseDir;
+        this.spinner = new Spinner({
+            enabled: this.rich && (opts.spinner ?? true),
+            stream: this.err,
+            width: this.width,
+        });
+        this.fmt = new FormattingStream((line) => this.out.write(`${line}\n`), this.width);
+    }
+    /** Final answer streamed from the model (markdown-formatted). */
+    text(chunk) {
+        this.endCard();
+        this.spinner.stop();
+        this.fmt.write(chunk);
+    }
+    /** Arbitrary status/meta text (tool output, reasoning, MoE status). */
+    meta(chunk) {
+        this.spinner.stop();
+        if (this.card) {
+            if (this.toolStyle === "inline") {
+                this.writeInlineBody(chunk);
+            }
+            else {
+                this.card.body.push(chunk);
+            }
+        }
+        else {
+            this.out.write(chunk);
+        }
+    }
+    /** Stream tool body lines with the gutter prefix, skipping blank lines. */
+    writeInlineBody(chunk) {
+        for (const line of chunk.split("\n")) {
+            if (line.trim() === "")
+                continue;
+            this.out.write(`${GUTTER}${line}\n`);
+        }
+    }
+    /** Dimmed reasoning stream (already colored by the agent). */
+    reasoning(chunk) {
+        this.spinner.stop();
+        this.out.write(pc.dim(chunk));
+    }
+    /** Model is loading / generating — show the thinking spinner. */
+    thinkingStart() {
+        this.spinner.start(t("ui.thinking"));
+    }
+    /** LLM call finished; clear the thinking spinner. */
+    thinkingEnd() {
+        this.spinner.stop();
+    }
+    toolStart(tool, args, stepContext, icon) {
+        this.endCard();
+        this.spinner.stop();
+        const displayArgs = PATH_TOOLS.has(tool) && typeof args.path === "string"
+            ? { ...args, path: toDisplayPath(this.baseDir, args.path) }
+            : args;
+        const summary = summarizeArgs(displayArgs);
+        const step = stepContext ? ` ${pc.cyan(`← ${stepContext}`)}` : "";
+        const marker = icon || toolMarker(tool);
+        if (!this.rich) {
+            this.out.write(`\n${pc.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}\n`);
+            return;
+        }
+        this.card = { tool, args, body: [], start: Date.now() };
+        if (this.toolStyle === "inline") {
+            this.out.write(`\n${pc.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}\n`);
+            if (BUSY_TOOLS.has(tool)) {
+                this.spinner.start(t("ui.tool_running", { tool: friendlyTool(tool) }));
+            }
+            return;
+        }
+        this.spinner.start(`${pc.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc.dim(summary)}` : ""}${step}`);
+    }
+    /** Live plan checklist — prints the plan block as-is (already colored). */
+    planBlock(lines) {
+        this.endCard();
+        this.spinner.stop();
+        for (const line of lines) {
+            this.out.write(`${line}\n`);
+        }
+    }
+    toolEnd(_tool, duration, error, ctxDelta, costUsd, provider, model) {
+        this.spinner.stop();
+        const prov = provider && model ? `${pc.dim(`${provider}·${model}`)}` : undefined;
+        if (!this.rich) {
+            const parts = [];
+            if (ctxDelta !== undefined && ctxDelta !== 0) {
+                const deltaStr = ctxDelta > 0 ? pc.green(`+${ctxDelta}`) : pc.yellow(`${ctxDelta} ↓`);
+                parts.push(`${pc.dim("ctx")} ${deltaStr}`);
+            }
+            if (costUsd !== undefined && costUsd > 0) {
+                parts.push(`${pc.dim("cost")} ${pc.yellow(formatUsd(costUsd))}`);
+            }
+            if (prov)
+                parts.push(prov);
+            if (parts.length > 0)
+                this.out.write(`${parts.join("  ")}\n`);
+            return;
+        }
+        if (!this.card)
+            return;
+        const { tool, args, body } = this.card;
+        const marker = error ? pc.red("✗") : pc.green("✓");
+        let footer = `${marker} ${pc.dim(`${duration}ms`)}`;
+        if (ctxDelta !== undefined && ctxDelta !== 0) {
+            const deltaStr = ctxDelta > 0 ? pc.green(`+${ctxDelta}`) : pc.yellow(`${ctxDelta} ↓`);
+            footer += `  ${pc.dim("ctx")} ${deltaStr}`;
+        }
+        if (costUsd !== undefined && costUsd > 0) {
+            footer += `  ${pc.dim("cost")} ${pc.yellow(formatUsd(costUsd))}`;
+        }
+        if (prov) {
+            footer += `  ${pc.dim("via")} ${prov}`;
+        }
+        if (this.toolStyle === "inline") {
+            this.out.write(`${GUTTER}${footer}\n`);
+            this.out.write(`${divider(this.width)}\n`);
+            this.card = null;
+            return;
+        }
+        const lines = [];
+        const summary = summarizeArgs(args);
+        if (summary)
+            lines.push(pc.dim(summary));
+        for (const chunk of body) {
+            for (const line of chunk.split("\n")) {
+                if (line.trim() !== "")
+                    lines.push(line);
+            }
+        }
+        lines.push(footer);
+        const title = `${marker} ${friendlyTool(tool)}`;
+        for (const line of box(lines, { title, width: this.width })) {
+            this.out.write(`${line}\n`);
+        }
+        this.card = null;
+    }
+    /** Raw pre-formatted text (diff blocks, warnings). */
+    raw(text) {
+        this.endCard();
+        this.spinner.stop();
+        this.out.write(text);
+    }
+    error(text) {
+        this.endCard();
+        this.spinner.stop();
+        this.err.write(`${pc.red(text)}\n`);
+    }
+    flush() {
+        this.endCard();
+        this.spinner.stop();
+        this.fmt.flush();
+    }
+    endCard() {
+        if (!this.card)
+            return;
+        const { tool, start } = this.card;
+        this.toolEnd(tool, Date.now() - start);
+    }
+}