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

package/dist/senses/cli/streaming-markdown.js

@@ -0,0 +1,526 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingMarkdown = StreamingMarkdown;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = __importDefault(require("react"));
+const ink_1 = require("ink");
+// ─── Block Parser ──────────────────────────────────────────────────
+const HR_PATTERN = /^(\s*[-*_]){3,}\s*$/;
+/** Detect if a line is a diff header or hunk marker. */
+function isDiffLine(line) {
+    return (line.startsWith("diff --git") ||
+        line.startsWith("index ") ||
+        line.startsWith("--- ") ||
+        line.startsWith("+++ ") ||
+        line.startsWith("@@") ||
+        line.startsWith("+") ||
+        line.startsWith("-"));
+}
+/** Check if a block of consecutive lines looks like a unified diff. */
+function looksLikeDiff(lines) {
+    return lines.some(l => l.startsWith("diff --git") ||
+        l.startsWith("@@") ||
+        l.startsWith("--- a/") ||
+        l.startsWith("+++ b/"));
+}
+/** Check if a line is a table row (starts and ends with pipe, has inner pipes). */
+function isTableRow(line) {
+    const trimmed = line.trim();
+    return trimmed.startsWith("|") && trimmed.endsWith("|") && trimmed.length > 2;
+}
+/** Check if a line is a table separator (e.g., |---|---|). */
+function isTableSeparator(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || !trimmed.endsWith("|"))
+        return false;
+    // Between outer pipes, each cell must be only dashes, colons, and spaces
+    const inner = trimmed.slice(1, -1);
+    return inner.split("|").every(cell => /^\s*:?-+:?\s*$/.test(cell));
+}
+function parseBlocks(input) {
+    const rawLines = input.split("\n");
+    const blocks = [];
+    let i = 0;
+    while (i < rawLines.length) {
+        const line = rawLines[i];
+        // Fenced code block (``` with optional language)
+        if (line.trimStart().startsWith("```")) {
+            const langMatch = line.trimStart().match(/^```(\S*)/);
+            const language = langMatch?.[1] ?? "";
+            // Special case: ```diff -> render as diff block
+            if (language === "diff") {
+                const codeLines = [];
+                i++;
+                while (i < rawLines.length && !rawLines[i].trimStart().startsWith("```")) {
+                    codeLines.push(rawLines[i]);
+                    i++;
+                }
+                if (i < rawLines.length)
+                    i++;
+                blocks.push({ type: "diff", lines: codeLines });
+                continue;
+            }
+            const codeLines = [];
+            i++;
+            while (i < rawLines.length && !rawLines[i].trimStart().startsWith("```")) {
+                codeLines.push(rawLines[i]);
+                i++;
+            }
+            // Skip closing fence if present (if not, it's a streaming partial)
+            if (i < rawLines.length)
+                i++;
+            blocks.push({ type: "codeblock", language, lines: codeLines });
+            continue;
+        }
+        // Horizontal rule (---, ***, ___) -- must come before heading check
+        // to avoid "---" being treated differently
+        if (HR_PATTERN.test(line)) {
+            blocks.push({ type: "hr", lines: [line] });
+            i++;
+            continue;
+        }
+        // Heading (# through ######)
+        const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
+        if (headingMatch) {
+            blocks.push({ type: "heading", level: headingMatch[1].length, lines: [headingMatch[2]] });
+            i++;
+            continue;
+        }
+        // Blockquote (> text) -- handle nested levels
+        if (/^>/.test(line)) {
+            const quoteLines = [];
+            // Determine nesting depth from first line
+            const depthMatch = line.match(/^(>+)\s?/);
+            const depth = depthMatch ? depthMatch[1].length : 1;
+            while (i < rawLines.length && /^>/.test(rawLines[i])) {
+                // Strip the leading > markers (up to depth levels)
+                let stripped = rawLines[i];
+                for (let d = 0; d < depth; d++) {
+                    stripped = stripped.replace(/^>\s?/, "");
+                }
+                quoteLines.push(stripped);
+                i++;
+            }
+            blocks.push({ type: "blockquote", level: depth, lines: quoteLines });
+            continue;
+        }
+        // Table detection: line is a table row, and next line (or line after) is a separator
+        if (isTableRow(line)) {
+            const tableLines = [];
+            const startI = i;
+            // Collect consecutive table-like rows
+            while (i < rawLines.length && isTableRow(rawLines[i])) {
+                tableLines.push(rawLines[i]);
+                i++;
+            }
+            // Validate: must have at least a header, separator, and one data row
+            if (tableLines.length >= 2 && tableLines.some(l => isTableSeparator(l))) {
+                blocks.push({ type: "table", lines: tableLines });
+                continue;
+            }
+            // Not a valid table, backtrack
+            i = startI;
+        }
+        // Diff block detection: consecutive diff-like lines with a strong signal
+        if (isDiffLine(line)) {
+            const diffLines = [];
+            const startI = i;
+            while (i < rawLines.length && isDiffLine(rawLines[i])) {
+                diffLines.push(rawLines[i]);
+                i++;
+            }
+            if (looksLikeDiff(diffLines)) {
+                blocks.push({ type: "diff", lines: diffLines });
+                continue;
+            }
+            // Not actually a diff -- backtrack and treat as paragraph
+            i = startI;
+        }
+        // Blank line
+        if (line.trim() === "") {
+            blocks.push({ type: "blank", lines: [""] });
+            i++;
+            continue;
+        }
+        // Regular paragraph (collect consecutive non-special lines)
+        const paraLines = [];
+        while (i < rawLines.length &&
+            rawLines[i].trim() !== "" &&
+            !rawLines[i].trimStart().startsWith("```") &&
+            !rawLines[i].match(/^#{1,6}\s/) &&
+            !/^>/.test(rawLines[i]) &&
+            !HR_PATTERN.test(rawLines[i])) {
+            paraLines.push(rawLines[i]);
+            i++;
+        }
+        if (paraLines.length > 0) {
+            blocks.push({ type: "paragraph", lines: paraLines });
+        }
+    }
+    return blocks;
+}
+// ─── HTML Entity Decoding ─────────────────────────────────────────
+const HTML_ENTITIES = {
+    "&lt;": "<",
+    "&gt;": ">",
+    "&amp;": "&",
+    "&quot;": "\"",
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " ",
+};
+function decodeHtmlEntities(text) {
+    return text.replace(/&(?:#39|lt|gt|amp|quot|apos|nbsp);/g, match => HTML_ENTITIES[match] ?? match);
+}
+// ─── Escape Handling ──────────────────────────────────────────────
+/** Sentinel character for protected escapes. */
+const ESC_SENTINEL = "\x01";
+/** Replace \*, \_, \`, \\ with sentinels before inline parsing. */
+function protectEscapes(text) {
+    const escapes = [];
+    const processed = text.replace(/\\([*_`\\[\]()~<>])/g, (_m, char) => {
+        const idx = escapes.length;
+        escapes.push(char);
+        return `${ESC_SENTINEL}ESC${idx}${ESC_SENTINEL}`;
+    });
+    return { text: processed, escapes };
+}
+/** Restore escape sentinels to their literal characters. */
+function restoreEscapes(text, escapes) {
+    return text.replace(new RegExp(`${ESC_SENTINEL}ESC(\\d+)${ESC_SENTINEL}`, "g"), (_m, idx) => {
+        return escapes[parseInt(idx)] ?? "";
+    });
+}
+// ─── Inline Parser ─────────────────────────────────────────────────
+/**
+ * Parse inline markdown (bold, italic, bold-italic, code, links,
+ * autolinks, strikethrough, escapes, HTML entities) from a single line.
+ */
+function parseInline(text) {
+    // Step 0: decode HTML entities
+    let processed = decodeHtmlEntities(text);
+    // Step 1: protect escape sequences
+    const { text: escaped, escapes } = protectEscapes(processed);
+    processed = escaped;
+    const segments = [];
+    const placeholders = [];
+    // Step 2: extract inline code
+    processed = processed.replace(/`([^`\n]+)`/g, (_m, code) => {
+        const idx = placeholders.length;
+        placeholders.push({ idx, segment: { text: restoreEscapes(code, escapes), code: true } });
+        return `\x00PH${idx}\x00`;
+    });
+    // Step 3a: extract image references ![alt](url) -> placeholder
+    processed = processed.replace(/!\[([^\]]*)\]\(([^)]*)\)/g, (_m, alt, _url) => {
+        const idx = placeholders.length;
+        const label = alt ? `\ud83d\uddbc ${restoreEscapes(alt, escapes)}` : "\ud83d\uddbc image";
+        placeholders.push({ idx, segment: { text: label, image: true } });
+        return `\x00PH${idx}\x00`;
+    });
+    // Step 3b: extract [Image: ...] references
+    processed = processed.replace(/\[Image:\s*([^\]]*)\]/gi, (_m, desc) => {
+        const idx = placeholders.length;
+        const label = desc.trim() ? `\ud83d\uddbc ${restoreEscapes(desc.trim(), escapes)}` : "\ud83d\uddbc image";
+        placeholders.push({ idx, segment: { text: label, image: true } });
+        return `\x00PH${idx}\x00`;
+    });
+    // Step 3c: extract links [text](url)
+    processed = processed.replace(/\[([^\]]*)\]\(([^)]*)\)/g, (_m, linkText, url) => {
+        const idx = placeholders.length;
+        const restoredText = restoreEscapes(linkText, escapes);
+        const restoredUrl = restoreEscapes(url, escapes);
+        placeholders.push({ idx, segment: { text: restoredText, link: { text: restoredText, url: restoredUrl } } });
+        return `\x00PH${idx}\x00`;
+    });
+    // Step 4: extract autolinks <https://...>
+    processed = processed.replace(/<(https?:\/\/[^>]+)>/g, (_m, url) => {
+        const idx = placeholders.length;
+        const restoredUrl = restoreEscapes(url, escapes);
+        placeholders.push({ idx, segment: { text: restoredUrl, autolink: true } });
+        return `\x00PH${idx}\x00`;
+    });
+    // Step 5: extract strikethrough ~~text~~
+    processed = processed.replace(/~~(.+?)~~/g, (_m, content) => {
+        const idx = placeholders.length;
+        placeholders.push({ idx, segment: { text: restoreEscapes(content, escapes), strikethrough: true } });
+        return `\x00PH${idx}\x00`;
+    });
+    // Step 6: parse bold-italic, bold, and italic from remaining text
+    const parts = processed.split(/(\x00PH\d+\x00)/);
+    for (const part of parts) {
+        const phMatch = part.match(/^\x00PH(\d+)\x00$/);
+        if (phMatch) {
+            segments.push(placeholders[parseInt(phMatch[1])].segment);
+            continue;
+        }
+        // Parse ***bold italic***, **bold**, *italic*, _italic_
+        parseInlineStyles(part, segments, escapes);
+    }
+    return segments;
+}
+function parseInlineStyles(text, segments, escapes) {
+    // Match ***bold italic***, **_bold italic_**, **bold**, *italic*, _italic_
+    // Order matters: triple-star before double-star before single-star
+    const pattern = /(\*\*\*(.+?)\*\*\*)|(\*\*_(.+?)_\*\*)|(\*\*(.+?)\*\*)|(\*(.+?)\*)|(_(.+?)_)/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        if (match.index > lastIndex) {
+            const plain = restoreEscapes(text.slice(lastIndex, match.index), escapes);
+            if (plain)
+                segments.push({ text: plain });
+        }
+        if (match[2]) {
+            // ***bold italic***
+            segments.push({ text: restoreEscapes(match[2], escapes), bold: true, italic: true });
+        }
+        else if (match[4]) {
+            // **_bold italic_**
+            segments.push({ text: restoreEscapes(match[4], escapes), bold: true, italic: true });
+        }
+        else if (match[6]) {
+            // **bold**
+            segments.push({ text: restoreEscapes(match[6], escapes), bold: true });
+        }
+        else if (match[8]) {
+            // *italic*
+            segments.push({ text: restoreEscapes(match[8], escapes), italic: true });
+        }
+        else if (match[10]) {
+            // _italic_
+            segments.push({ text: restoreEscapes(match[10], escapes), italic: true });
+        }
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        const plain = restoreEscapes(text.slice(lastIndex), escapes);
+        if (plain)
+            segments.push({ text: plain });
+    }
+}
+function parseTaskListItem(line) {
+    const match = line.match(/^(\s*)-\s+\[([ xX])\]\s(.*)$/);
+    if (!match)
+        return null;
+    return {
+        indent: match[1],
+        checked: match[2].toLowerCase() === "x",
+        text: match[3],
+    };
+}
+function parseTable(lines) {
+    if (lines.length < 2)
+        return null;
+    // Find the separator row
+    let sepIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (isTableSeparator(lines[i])) {
+            sepIdx = i;
+            break;
+        }
+    }
+    if (sepIdx < 1)
+        return null; // separator must not be the first line
+    const parseCells = (line) => {
+        const trimmed = line.trim();
+        // Remove leading and trailing pipes, split by pipe
+        const inner = trimmed.slice(1, -1);
+        return inner.split("|").map(c => c.trim());
+    };
+    const headers = parseCells(lines[sepIdx - 1]);
+    const rows = [];
+    for (let i = sepIdx + 1; i < lines.length; i++) {
+        if (!isTableSeparator(lines[i])) {
+            rows.push(parseCells(lines[i]));
+        }
+    }
+    // Calculate column widths
+    const columnWidths = headers.map((h, ci) => {
+        let max = h.length;
+        for (const row of rows) {
+            const cell = row[ci] ?? "";
+            if (cell.length > max)
+                max = cell.length;
+        }
+        return Math.max(max, 3); // minimum width of 3
+    });
+    return { headers, rows, columnWidths };
+}
+// ─── Word Wrap ─────────────────────────────────────────────────────
+function wrapText(text, maxWidth) {
+    /* v8 ignore next -- defensive guard for non-positive width @preserve */
+    if (maxWidth <= 0)
+        return text;
+    const lines = text.split("\n");
+    const result = [];
+    for (const line of lines) {
+        if (line.length <= maxWidth) {
+            result.push(line);
+        }
+        else {
+            let remaining = line;
+            while (remaining.length > maxWidth) {
+                let breakAt = remaining.lastIndexOf(" ", maxWidth);
+                if (breakAt <= 0)
+                    breakAt = maxWidth;
+                result.push(remaining.slice(0, breakAt));
+                remaining = remaining.slice(breakAt).replace(/^ /, "");
+            }
+            /* v8 ignore next -- defensive guard for empty remaining after word-wrap @preserve */
+            if (remaining)
+                result.push(remaining);
+        }
+    }
+    return result.join("\n");
+}
+// ─── Segment Renderer ──────────────────────────────────────────────
+function SegmentRenderer({ segment }) {
+    if (segment.image) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: segment.text });
+    }
+    if (segment.codeBlock) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: segment.text });
+    }
+    if (segment.code) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { color: "cyan", children: segment.text });
+    }
+    if (segment.autolink) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { color: "cyan", children: segment.text });
+    }
+    if (segment.link) {
+        return ((0, jsx_runtime_1.jsxs)(ink_1.Text, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { children: segment.link.text }), (0, jsx_runtime_1.jsx)(ink_1.Text, { color: "cyan", dimColor: true, children: ` (${segment.link.url})` })] }));
+    }
+    if (segment.strikethrough) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, strikethrough: true, children: segment.text });
+    }
+    if (segment.bold && segment.italic) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { bold: true, italic: true, children: segment.text });
+    }
+    if (segment.bold) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { bold: true, children: segment.text });
+    }
+    if (segment.italic) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { italic: true, children: segment.text });
+    }
+    return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: segment.text });
+}
+// ─── Inline Line Renderer ──────────────────────────────────────────
+function InlineLine({ text: lineText }) {
+    const segs = parseInline(lineText);
+    return ((0, jsx_runtime_1.jsx)(ink_1.Text, { children: segs.map((seg, i) => ((0, jsx_runtime_1.jsx)(SegmentRenderer, { segment: seg }, i))) }));
+}
+// ─── Diff Line Renderer ───────────────────────────────────────────
+function DiffLine({ line }) {
+    if (line.startsWith("@@")) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { color: "cyan", children: line });
+    }
+    if (line.startsWith("diff --git") ||
+        line.startsWith("index ") ||
+        line.startsWith("--- ") ||
+        line.startsWith("+++ ")) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { bold: true, children: line });
+    }
+    if (line.startsWith("+")) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { color: "green", children: line });
+    }
+    if (line.startsWith("-")) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { color: "red", children: line });
+    }
+    return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: line });
+}
+// ─── Table Renderer ───────────────────────────────────────────────
+function TableRenderer({ lines }) {
+    const table = parseTable(lines);
+    if (!table) {
+        // Fallback: render raw lines
+        return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: lines.map((line, i) => ((0, jsx_runtime_1.jsx)(ink_1.Text, { children: line }, i))) }));
+    }
+    const { headers, rows, columnWidths } = table;
+    const padCell = (text, width) => {
+        return text + " ".repeat(Math.max(0, width - text.length));
+    };
+    const renderRow = (cells, bold) => {
+        const cellTexts = columnWidths.map((w, ci) => padCell(cells[ci] ?? "", w));
+        const rowText = "| " + cellTexts.join(" | ") + " |";
+        if (bold)
+            return (0, jsx_runtime_1.jsx)(ink_1.Text, { bold: true, children: rowText });
+        return (0, jsx_runtime_1.jsx)(InlineLine, { text: rowText });
+    };
+    const separatorRow = "| " + columnWidths.map(w => "-".repeat(w)).join(" | ") + " |";
+    return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [renderRow(headers, true), (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: separatorRow }), rows.map((row, i) => ((0, jsx_runtime_1.jsx)(react_1.default.Fragment, { children: renderRow(row, false) }, i)))] }));
+}
+// ─── Block Renderer ────────────────────────────────────────────────
+function BlockRenderer({ block, isFirst, isLast, maxWidth }) {
+    switch (block.type) {
+        case "blank":
+            return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" });
+        case "hr":
+            return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [!isFirst && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }), (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: "\u2500".repeat(40) }), !isLast && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" })] }));
+        case "heading": {
+            const text = block.lines.join(" ");
+            return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [!isFirst && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }), (block.level ?? 1) === 1
+                        ? (0, jsx_runtime_1.jsx)(ink_1.Text, { bold: true, underline: true, children: text })
+                        : (0, jsx_runtime_1.jsx)(ink_1.Text, { bold: true, children: text }), !isLast && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" })] }));
+        }
+        case "codeblock": {
+            const langLabel = block.language || undefined;
+            return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [!isFirst && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }), langLabel && (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: langLabel }), block.lines.map((line, i) => ((0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: line }, i))), !isLast && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" })] }));
+        }
+        case "diff":
+            return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [!isFirst && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }), (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: "\u2500".repeat(40) }), block.lines.map((line, i) => ((0, jsx_runtime_1.jsx)(DiffLine, { line: line }, i))), (0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: "\u2500".repeat(40) }), !isLast && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" })] }));
+        case "table":
+            return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [!isFirst && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }), (0, jsx_runtime_1.jsx)(TableRenderer, { lines: block.lines }), !isLast && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" })] }));
+        case "blockquote": {
+            const depth = block.level ?? 1;
+            const barPrefix = "\u2502 ".repeat(depth);
+            const barLen = barPrefix.length;
+            const effectiveMax = maxWidth || 80;
+            const wrapWidth = Math.max(effectiveMax - barLen, 10);
+            // Pre-wrap each line so continuation lines also get the bar prefix
+            const wrappedLines = [];
+            for (const line of block.lines) {
+                if (line.length <= wrapWidth) {
+                    wrappedLines.push(line);
+                }
+                else {
+                    // Simple word wrap
+                    let remaining = line;
+                    while (remaining.length > wrapWidth) {
+                        let breakAt = remaining.lastIndexOf(" ", wrapWidth);
+                        if (breakAt <= 0)
+                            breakAt = wrapWidth;
+                        wrappedLines.push(remaining.slice(0, breakAt));
+                        remaining = remaining.slice(breakAt).trimStart();
+                    }
+                    if (remaining)
+                        wrappedLines.push(remaining);
+                }
+            }
+            return ((0, jsx_runtime_1.jsxs)(ink_1.Box, { flexDirection: "column", children: [!isFirst && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" }), wrappedLines.map((line, i) => ((0, jsx_runtime_1.jsxs)(ink_1.Text, { children: [(0, jsx_runtime_1.jsx)(ink_1.Text, { dimColor: true, children: barPrefix }), (0, jsx_runtime_1.jsx)(ink_1.Text, { italic: true, children: (0, jsx_runtime_1.jsx)(InlineLine, { text: line }) })] }, i))), !isLast && (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" })] }));
+        }
+        case "paragraph": {
+            // Check for task list items and render them specially
+            const renderedLines = block.lines.map((line, i) => {
+                const task = parseTaskListItem(line);
+                if (task) {
+                    const checkbox = task.checked ? "\u2611" : "\u2610";
+                    return ((0, jsx_runtime_1.jsxs)(ink_1.Text, { children: [(0, jsx_runtime_1.jsxs)(ink_1.Text, { children: [task.indent, checkbox, " "] }), (0, jsx_runtime_1.jsx)(InlineLine, { text: task.text })] }, i));
+                }
+                return (0, jsx_runtime_1.jsx)(InlineLine, { text: line }, i);
+            });
+            return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: renderedLines }));
+        }
+    }
+}
+// ─── Main Component ────────────────────────────────────────────────
+function StreamingMarkdown({ text, maxWidth }) {
+    const processed = maxWidth ? wrapText(text, maxWidth) : text;
+    const blocks = parseBlocks(processed);
+    if (blocks.length === 0) {
+        return (0, jsx_runtime_1.jsx)(ink_1.Text, { children: "" });
+    }
+    return ((0, jsx_runtime_1.jsx)(ink_1.Box, { flexDirection: "column", children: blocks.map((block, i) => ((0, jsx_runtime_1.jsx)(BlockRenderer, { block: block, isFirst: i === 0, isLast: i === blocks.length - 1, maxWidth: maxWidth }, i))) }));
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Imperative tool result rendering for the CLI.
+ *
+ * Writes colored one-liners to stderr — no React, no Ink.
+ * Features:
+ * - Green check / red cross prefix
+ * - Tool name in ouroboros teal
+ * - Parsed first argument (file path, command, query) dimmed
+ * - For edit_file: compact inline diff summary (+N/-M lines)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeToolStart = writeToolStart;
+exports.writeToolEnd = writeToolEnd;
+const runtime_1 = require("../../nerves/runtime");
+// Flow control tools are invisible to the user — internal agent mechanics.
+// `speak` is included because its visible output is the message itself (delivered
+// via onTextChunk/flushNow), not a "running speak..." spinner or tool-end status line.
+const FLOW_CONTROL_TOOLS = new Set(["settle", "ponder", "observe", "rest", "speak"]);
+// Ouroboros teal: #4ec9b0 -> RGB escape
+const OURO_TEAL = "\x1b[38;2;78;201;176m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+// 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;
+}
+/**
+ * Extract the primary display parameter from tool args.
+ */
+function getPrimaryArg(name, args) {
+    const primaryKey = PRIMARY_PARAM[name];
+    if (primaryKey && typeof args[primaryKey] === "string") {
+        return truncate(args[primaryKey], 80);
+    }
+    // Fallback: show first string value
+    for (const val of Object.values(args)) {
+        if (typeof val === "string") {
+            return truncate(val, 80);
+        }
+    }
+    return "";
+}
+/**
+ * Format and write a tool start line to stderr.
+ * Shows: [teal tool name] [dim primary arg]
+ */
+function writeToolStart(name, args) {
+    if (FLOW_CONTROL_TOOLS.has(name))
+        return;
+    const primary = getPrimaryArg(name, args);
+    const argDisplay = primary ? ` ${DIM}${primary}${RESET}` : "";
+    process.stderr.write(`\r\x1b[K${OURO_TEAL}${BOLD}${name}${RESET}${argDisplay}\n`);
+}
+/**
+ * Format and write a tool result line to stderr.
+ * Shows: [green check / red cross] [teal tool name] [dim summary]
+ */
+function writeToolEnd(name, argSummary, success) {
+    if (FLOW_CONTROL_TOOLS.has(name))
+        return;
+    const icon = success ? `${GREEN}\u2713` : `${RED}\u2717`;
+    const summary = argSummary ? ` ${DIM}${truncate(argSummary, 100)}${RESET}` : "";
+    process.stderr.write(`${icon}${RESET} ${OURO_TEAL}${name}${RESET}${summary}\n`);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.tool_display",
+        message: "tool result displayed",
+        meta: { name, success },
+    });
+}