@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.550

package/dist/senses/cli/tool-render.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolBadge = ToolBadge;
+exports.ToolParams = ToolParams;
+exports.ToolProgress = ToolProgress;
+exports.ToolResultCard = ToolResultCard;
+exports.ToolExecutionBlock = ToolExecutionBlock;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const ink_1 = require("ink");
+const inline_diff_1 = require("./inline-diff");
+/**
+ * Tool execution display components for the CLI TUI.
+ *
+ * Provides: ToolBadge, ToolParams, ToolProgress, ToolResultCard, ToolExecutionBlock.
+ *
+ * Design: Ouroboros-themed. Inline diffs use green/red with +/- markers and line numbers.
+ * No padding -- visual separation via color/bold/dim only.
+ *
+ * Files >50KB get a summary instead of inline diff (scrutiny finding 17).
+ */
+// Ouroboros brand palette
+const OURO_GREEN = "#2ecc40";
+const OURO_RED = "#e74c3c";
+const OURO_TEAL = "#4ec9b0";
+// 50KB threshold for inline diff vs summary
+const LARGE_FILE_THRESHOLD = 50 * 1024;
+// Tool name -> primary parameter key mapping
+const PRIMARY_PARAM = {
+    edit_file: "path",
+    write_file: "path",
+    read_file: "path",
+    glob: "pattern",
+    grep: "pattern",
+    shell: "command",
+    coding_spawn: "task",
+    coding_status: "session_id",
+    coding_tail: "session_id",
+};
+function truncate(s, max) {
+    return s.length > max ? s.slice(0, max - 3) + "..." : s;
+}
+function ToolBadge({ name }) {
+    return (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_TEAL, bold: true, children: name });
+}
+function ToolParams({ name, args, }) {
+    // Find primary parameter to show inline
+    const primaryKey = PRIMARY_PARAM[name];
+    let display = "";
+    if (primaryKey && typeof args[primaryKey] === "string") {
+        display = truncate(args[primaryKey], 80);
+    }
+    else {
+        // Fallback: show first string value
+        for (const val of Object.values(args)) {
+            if (typeof val === "string") {
+                display = truncate(val, 80);
+                break;
+            }
+        }
+    }
+    if (!display)
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" });
+    return (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: [" ", display] });
+}
+function ToolProgress({ name }) {
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_GREEN, children: "\u25CF " }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: [name, " running..."] })] }));
+}
+function ToolResultCard({ name, result, success, expanded, }) {
+    const icon = success ? "\u2713" : "\u2717";
+    const color = success ? OURO_GREEN : OURO_RED;
+    if (expanded) {
+        return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsxs)(ink_1.Text, { color: color, children: [icon, " "] }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_TEAL, bold: true, children: name })] }), (0, jsx_runtime_1.jsx)(ink_1.Text, { children: result })] }));
+    }
+    // Collapsed: one-line summary
+    const summary = truncate(result.replace(/\n/g, " "), 100);
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsxs)(ink_1.Text, { color: color, children: [icon, " "] }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: OURO_TEAL, bold: true, children: name }), (0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: [" ", summary] })] }));
+}
+function ToolExecutionBlock({ name, args, result, success, fileBefore, fileAfter, }) {
+    const filePath = typeof args.path === "string" ? args.path : undefined;
+    const showDiff = name === "edit_file" && fileBefore !== undefined && fileAfter !== undefined;
+    // Check file size threshold
+    const tooLarge = showDiff && ((fileBefore?.length ?? 0) > LARGE_FILE_THRESHOLD ||
+        (fileAfter?.length ?? 0) > LARGE_FILE_THRESHOLD);
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [(0, jsx_runtime_1.jsxs)(ink_1.Box, { children: [(0, jsx_runtime_1.jsx)(ToolBadge, { name: name }), (0, jsx_runtime_1.jsx)(ToolParams, { name: name, args: args })] }), showDiff && !tooLarge ? ((0, jsx_runtime_1.jsx)(inline_diff_1.InlineDiff, { before: fileBefore, after: fileAfter, filePath: filePath ?? "unknown" })) : /* v8 ignore next -- tooLarge branch not exercised in render tests @preserve */ showDiff && tooLarge ? ((0, jsx_runtime_1.jsxs)(ink_1.Text, { dimColor: true, children: ["large file changed (", Math.round((fileAfter?.length ?? 0) / 1024), "KB)"] })) : ((0, jsx_runtime_1.jsx)(ToolResultCard, { name: name, result: result, success: success }))] }));
+}

package/dist/senses/cli/tui-store.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TuiStore = void 0;
+exports.createTuiCallbacks = createTuiCallbacks;
+/**
+ * TUI Store — mutable external state for the OuroTui component.
+ *
+ * Tracks two buckets:
+ *   1. completedMessages — fed to Ink's <Static>, rendered once
+ *   2. live — current turn state, re-renders on change
+ *
+ * ZERO business logic. Just state + notify.
+ */
+const phrases_1 = require("../../mind/phrases");
+const format_1 = require("../../mind/format");
+const runtime_1 = require("../../nerves/runtime");
+class TuiStore {
+    _completed = [];
+    _live = {
+        streamingText: "",
+        loading: false,
+        spinnerPhrase: "",
+        spinnerPhrasePool: [],
+        activeTool: null,
+        errorMessage: null,
+        kickMessage: null,
+        inputSuppressed: false,
+    };
+    _spinnerStart = 0;
+    _hadTool = false;
+    _turnId = 0;
+    _listeners = new Set();
+    _headerShown = false;
+    _inputHistory = [];
+    _queuedInputs = [];
+    get completedMessages() { return this._completed; }
+    get live() { return this._live; }
+    get headerShown() { return this._headerShown; }
+    get inputHistory() { return this._inputHistory; }
+    get queuedInputs() { return this._queuedInputs; }
+    /** Elapsed seconds since spinner started — computed on demand, not stored */
+    getElapsed() {
+        if (this._live.loading && this._spinnerStart > 0) {
+            return Math.floor((Date.now() - this._spinnerStart) / 1000);
+        }
+        return 0;
+    }
+    subscribe(fn) {
+        this._listeners.add(fn);
+        return () => { this._listeners.delete(fn); };
+    }
+    notify() {
+        for (const fn of this._listeners)
+            fn();
+    }
+    // ─── Called by business logic (via callbacks) ───
+    modelStart() {
+        const phrases = (0, phrases_1.getPhrases)();
+        const pool = this._hadTool ? phrases.followup : phrases.thinking;
+        this._live = {
+            ...this._live,
+            loading: true,
+            spinnerPhrase: (0, phrases_1.pickPhrase)(pool),
+            spinnerPhrasePool: pool,
+            streamingText: "",
+            activeTool: null,
+            errorMessage: null,
+            kickMessage: null,
+        };
+        this._spinnerStart = Date.now();
+        this._turnId++;
+        this.notify();
+    }
+    appendText(text) {
+        this._live = {
+            ...this._live,
+            loading: false,
+            streamingText: this._live.streamingText + text,
+        };
+        this.notify();
+    }
+    clearText() {
+        this._live = { ...this._live, streamingText: "" };
+        this.notify();
+    }
+    toolStart(name, args) {
+        this._hadTool = true;
+        // Before showing tool in-progress, commit any buffered streaming text
+        // so it doesn't disappear when the live area switches to tool display
+        if (this._live.streamingText.trim()) {
+            this._completed = [...this._completed, {
+                    id: `asst-${this._turnId}-${Date.now()}`,
+                    role: "assistant",
+                    content: this._live.streamingText.trim(),
+                }];
+        }
+        this._live = {
+            ...this._live,
+            loading: true,
+            streamingText: "",
+            activeTool: { name, args },
+            spinnerPhrase: (0, phrases_1.pickPhrase)((0, phrases_1.getPhrases)().tool),
+            spinnerPhrasePool: (0, phrases_1.getPhrases)().tool,
+        };
+        this._spinnerStart = Date.now();
+        this.notify();
+    }
+    toolEnd(name, argSummary, success) {
+        // Move tool result to completed messages (so it renders via Static)
+        this._completed = [...this._completed, {
+                id: `tool-${this._turnId}-${Date.now()}`,
+                role: "tool",
+                content: "",
+                toolCalls: [{ name, argSummary, success }],
+            }];
+        this._live = {
+            ...this._live,
+            loading: false,
+            activeTool: null,
+        };
+        this.notify();
+    }
+    setError(msg) {
+        this._live = { ...this._live, loading: false, errorMessage: msg };
+        this.notify();
+    }
+    setKick() {
+        this._live = { ...this._live, loading: false, kickMessage: (0, format_1.formatKick)() };
+        this.notify();
+    }
+    suppressInput() {
+        this._live = { ...this._live, inputSuppressed: true };
+        this.notify();
+    }
+    restoreInput() {
+        this._live = { ...this._live, inputSuppressed: false };
+        this.notify();
+    }
+    /** Commit current streaming text as a completed assistant message */
+    commitAssistantMessage() {
+        if (this._live.streamingText.trim()) {
+            this._completed = [...this._completed, {
+                    id: `asst-${this._turnId}-${Date.now()}`,
+                    role: "assistant",
+                    content: this._live.streamingText.trim(),
+                }];
+        }
+        // Clear streaming text immediately — prevents double display
+        this._live = {
+            ...this._live,
+            loading: false,
+            streamingText: "",
+            activeTool: null,
+            errorMessage: null,
+            kickMessage: null,
+        };
+        this.notify();
+    }
+    /** Add a user message to completed (for display) AND input history */
+    addUserMessage(text) {
+        if (this._completed.length === 0) {
+            this._headerShown = false;
+        }
+        this._completed = [...this._completed, {
+                id: `user-${Date.now()}`,
+                role: "user",
+                content: text,
+            }];
+        this._inputHistory.push(text);
+        this.notify();
+    }
+    /** Add text to input history only (no completed message, no notify). Used by ESC-to-clear. */
+    addToHistoryOnly(text) {
+        this._inputHistory.push(text);
+    }
+    /** Seed input history from previous session messages (display only, no rendering) */
+    seedHistory(texts) {
+        this._inputHistory.push(...texts);
+    }
+    /** Push previous session exchanges as normal user/assistant messages (for resume display) */
+    addResumeMessages(exchanges) {
+        if (exchanges.length === 0) {
+            this.notify();
+            return;
+        }
+        const msgs = exchanges.map((ex, i) => ({
+            id: `resume-${i}`,
+            role: ex.role,
+            content: ex.content,
+        }));
+        this._completed = [...msgs, ...this._completed];
+        this.notify();
+    }
+    // ─── Queued input display ────────────────────────────────────────
+    enqueueInput(text) {
+        this._queuedInputs.push(text);
+        this.notify();
+    }
+    dequeueInput(text) {
+        const idx = this._queuedInputs.indexOf(text);
+        if (idx !== -1) {
+            this._queuedInputs.splice(idx, 1);
+        }
+        this.notify();
+    }
+    popAllQueuedForEditing() {
+        const copy = [...this._queuedInputs];
+        this._queuedInputs = [];
+        this.notify();
+        return copy;
+    }
+    clearQueue() {
+        this._queuedInputs = [];
+        this.notify();
+    }
+}
+exports.TuiStore = TuiStore;
+// ─── Callbacks factory ──────────────────────────────────────────────
+function createTuiCallbacks(store) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.tui_callbacks_created",
+        message: "TUI callbacks created",
+        meta: {},
+    });
+    return {
+        onModelStart: () => { store.modelStart(); },
+        onModelStreamStart: () => { },
+        onClearText: () => { store.clearText(); },
+        onTextChunk: (text) => { store.appendText(text); },
+        onReasoningChunk: () => { },
+        onToolStart: (name, args) => { store.toolStart(name, args); },
+        onToolEnd: (name, argSummary, success) => { store.toolEnd(name, argSummary, success); },
+        onError: (error, severity) => {
+            store.setError(severity === "terminal" ? (0, format_1.formatError)(error) : error.message);
+        },
+        onKick: () => { store.setKick(); },
+        flushMarkdown: () => { store.commitAssistantMessage(); },
+    };
+}

package/dist/senses/cli/virtual-list.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualList = VirtualList;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const ink_1 = require("ink");
+function VirtualList({ items, viewportHeight, scrollOffset, renderItem, }) {
+    const { startIndex, visibleItems } = (0, react_1.useMemo)(() => {
+        if (items.length === 0) {
+            return { startIndex: 0, visibleItems: [] };
+        }
+        // Determine the start index for the visible window
+        let start;
+        if (scrollOffset !== undefined) {
+            // Scroll-locked: show items starting at the given offset
+            start = Math.max(0, Math.min(scrollOffset, items.length - 1));
+        }
+        else {
+            // Auto-scroll: pin to bottom, show last viewportHeight items
+            start = Math.max(0, items.length - viewportHeight);
+        }
+        const end = Math.min(start + viewportHeight, items.length);
+        return {
+            startIndex: start,
+            visibleItems: items.slice(start, end),
+        };
+    }, [items, viewportHeight, scrollOffset]);
+    if (visibleItems.length === 0) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Box, { children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }) });
+    }
+    return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: visibleItems.map((item, i) => {
+            const globalIndex = startIndex + i;
+            return ((0, jsx_runtime_1.jsx)(ink_1.Box, { children: (0, jsx_runtime_1.jsx)(ink_1.Text, { children: renderItem(item, globalIndex) }) }, globalIndex));
+        }) }));
+}

package/dist/senses/cli-entry.js

@@ -1,15 +1,67 @@
 "use strict";
-// Thin entrypoint for `npm run dev` / `node dist/senses/cli-entry.js --agent <name>`.
-// Separated from cli.ts so the CLI adapter is pure library code with clean
-// 100% test coverage -- entrypoints can't be covered by vitest since
-// require.main !== module in the test runner.
-// All config comes from the conventional ~/.agentsecrets/<agent>/secrets.json path.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("../nerves/runtime");
 // Fail fast if --agent is missing (before any src/ code tries getAgentName())
-if (!process.argv.includes("--agent")) {
+const agentArgIndex = process.argv.indexOf("--agent");
+const agentName = agentArgIndex >= 0 ? process.argv[agentArgIndex + 1] : undefined;
+if (!agentName) {
     // eslint-disable-next-line no-console -- pre-boot guard: --agent check before imports
     console.error("Missing required --agent <name> argument.\nUsage: node dist/senses/cli-entry.js --agent ouroboros");
     process.exit(1);
 }
-const cli_1 = require("./cli");
-(0, cli_1.main)();
+(0, runtime_1.emitNervesEvent)({
+    component: "senses",
+    event: "senses.entry_boot",
+    message: "booting CLI entrypoint",
+    meta: { entry: "cli", agentName },
+});
+Promise.resolve().then(() => __importStar(require("../heart/runtime-credentials"))).then(async ({ refreshRuntimeCredentialConfig }) => {
+    void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    const { main } = await Promise.resolve().then(() => __importStar(require("./cli")));
+    main();
+})
+    .catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "senses.entry_error",
+        message: "CLI entrypoint failed",
+        meta: { entry: "cli", agentName, error: error instanceof Error ? error.message : String(error) },
+    });
+    // eslint-disable-next-line no-console -- fatal startup guard for sense process
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/senses/cli-layout.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingWordWrapper = void 0;
+exports.wrapCliText = wrapCliText;
+exports.formatEchoedInputSummary = formatEchoedInputSummary;
+const runtime_1 = require("../nerves/runtime");
+// Strip ANSI escape sequences to measure visible text width.
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+function visibleLength(text) {
+    return text.replace(ANSI_RE, "").length;
+}
+/**
+ * Streaming word wrapper for terminal output.
+ *
+ * Text arrives in small chunks (sometimes single characters). This class
+ * buffers a partial line and emits complete wrapped lines at word boundaries
+ * when the visible width approaches the terminal column limit.
+ *
+ * ANSI escape sequences are treated as zero-width so colours and styles
+ * pass through without affecting line-break decisions.
+ */
+class StreamingWordWrapper {
+    col = 0; // visible columns consumed on the current line
+    buf = ""; // buffered text for the current line (not yet emitted)
+    width; // terminal column count
+    constructor(cols) {
+        this.width = Math.max(cols ?? (process.stdout.columns || 80), 1);
+    }
+    /** Accept a chunk of already-rendered text and return text ready for stdout. */
+    push(text) {
+        let out = "";
+        for (let i = 0; i < text.length; i++) {
+            const ch = text[i];
+            // Pass through ANSI escape sequences without counting width
+            /* v8 ignore start -- ANSI handling: tested via StreamingWordWrapper ANSI test @preserve */
+            if (ch === "\x1b") {
+                const rest = text.slice(i);
+                const m = rest.match(/^\x1b\[[0-9;]*[A-Za-z]/);
+                if (m) {
+                    this.buf += m[0];
+                    i += m[0].length - 1;
+                    continue;
+                }
+            }
+            /* v8 ignore stop */
+            // Explicit newline: flush current line and reset
+            if (ch === "\n") {
+                out += this.buf + "\n";
+                this.buf = "";
+                this.col = 0;
+                continue;
+            }
+            // Space: if the current line is already at or past width, wrap now.
+            // Otherwise just append.
+            if (ch === " ") {
+                /* v8 ignore start -- wrap-at-space: tested via StreamingWordWrapper unit tests @preserve */
+                if (this.col >= this.width) {
+                    out += this.buf + "\n";
+                    this.buf = "";
+                    this.col = 0;
+                    // Drop the space at the wrap point
+                    continue;
+                    /* v8 ignore stop */
+                }
+                this.buf += ch;
+                this.col++;
+                continue;
+            }
+            // Non-space character
+            this.col++;
+            if (this.col > this.width) {
+                // We've exceeded the width. Try to break at the last space.
+                const lastSpace = this.buf.lastIndexOf(" ");
+                if (lastSpace !== -1) {
+                    out += this.buf.slice(0, lastSpace) + "\n";
+                    // Keep the remainder (after space) plus current char
+                    this.buf = this.buf.slice(lastSpace + 1) + ch;
+                    this.col = visibleLength(this.buf);
+                }
+                else {
+                    // No space to break at — hard wrap
+                    out += this.buf + "\n";
+                    this.buf = ch;
+                    this.col = 1;
+                }
+                continue;
+            }
+            this.buf += ch;
+        }
+        return out;
+    }
+    /** Flush any remaining buffered text (call at end of response). */
+    flush() {
+        const remainder = this.buf;
+        this.buf = "";
+        this.col = 0;
+        return remainder;
+    }
+    /** Reset wrapper state (call at start of new model turn). */
+    reset() {
+        this.buf = "";
+        this.col = 0;
+    }
+}
+exports.StreamingWordWrapper = StreamingWordWrapper;
+function splitLongWord(word, width) {
+    const chunks = [];
+    for (let index = 0; index < word.length; index += width) {
+        chunks.push(word.slice(index, index + width));
+    }
+    return chunks;
+}
+function wrapCliText(text, cols) {
+    const width = Math.max(cols, 1);
+    const wrapped = [];
+    for (const rawLine of text.split("\n")) {
+        if (rawLine.trim().length === 0) {
+            wrapped.push("");
+            continue;
+        }
+        const words = rawLine.trim().split(/\s+/);
+        let current = "";
+        for (const word of words) {
+            if (!current) {
+                if (word.length <= width) {
+                    current = word;
+                    continue;
+                }
+                const chunks = splitLongWord(word, width);
+                wrapped.push(...chunks.slice(0, -1));
+                current = chunks[chunks.length - 1];
+                continue;
+            }
+            const candidate = `${current} ${word}`;
+            if (candidate.length <= width) {
+                current = candidate;
+                continue;
+            }
+            wrapped.push(current);
+            if (word.length <= width) {
+                current = word;
+                continue;
+            }
+            const chunks = splitLongWord(word, width);
+            wrapped.push(...chunks.slice(0, -1));
+            current = chunks[chunks.length - 1];
+        }
+        wrapped.push(current);
+    }
+    return wrapped;
+}
+function countEchoedInputRows(input, cols) {
+    const width = Math.max(cols, 1);
+    return input.split("\n").reduce((sum, line, index) => {
+        const promptWidth = index === 0 ? 2 : 0;
+        return sum + Math.max(1, Math.ceil((promptWidth + line.length) / width));
+    }, 0);
+}
+function formatEchoedInputSummary(input, cols) {
+    const inputLines = input.split("\n");
+    const summary = `> ${inputLines[0]}${inputLines.length > 1 ? ` (+${inputLines.length - 1} lines)` : ""}`;
+    const wrappedSummary = wrapCliText(summary, cols);
+    const echoRows = countEchoedInputRows(input, cols);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.cli_echo_summary_formatted",
+        message: "formatted echoed cli input summary",
+        meta: {
+            cols,
+            echo_rows: echoRows,
+            input_line_count: inputLines.length,
+            wrapped_line_count: wrappedSummary.length,
+        },
+    });
+    let output = `\x1b[${echoRows}A`;
+    for (let i = 0; i < echoRows; i += 1) {
+        output += "\r\x1b[K";
+        if (i < echoRows - 1) {
+            output += "\x1b[1B";
+        }
+    }
+    if (echoRows > 1) {
+        output += `\x1b[${echoRows - 1}A`;
+    }
+    output += `\x1b[1m${wrappedSummary.join("\n")}\x1b[0m\n\n`;
+    return output;
+}