whale-code 6.4.0

package/dist/cli/shared/markdown.js

@@ -0,0 +1,756 @@
+/**
+ * Markdown rendering — Apple-polished terminal output
+ *
+ * Syntax theme: purples, blues, pinks — no yellow.
+ * Financials: green for gains, red for losses/deductions.
+ * Uses marked + marked-terminal + cli-highlight.
+ */
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import chalk from "chalk";
+import { createRequire } from "module";
+import { colors } from "./Theme.js";
+import { diffWords } from "diff";
+// Note: chalk.level is auto-detected by supports-color.
+// Apple_Terminal → level 2 (256-color), iTerm.app v3+ → level 3 (24-bit).
+// Do NOT force level 3 — Terminal.app can't render 24-bit codes (shows gray).
+const require = createRequire(import.meta.url);
+const { highlight } = require("cli-highlight");
+// ============================================================================
+// Apple Dark palette — derived from Theme.tsx (respects ~/.swagmanager/theme.json)
+// ============================================================================
+const systemBlue = chalk.hex(colors.brand);
+const systemCyan = chalk.hex(colors.info);
+const systemPink = chalk.hex(colors.pink);
+const systemPurple = chalk.hex(colors.purple);
+const systemIndigo = chalk.hex(colors.indigo);
+const systemGreen = chalk.hex(colors.success);
+const systemMint = chalk.hex(colors.mint);
+const systemRed = chalk.hex(colors.error);
+const systemOrange = chalk.hex(colors.warning);
+const text = chalk.hex(colors.text);
+const secondary = chalk.hex(colors.secondary);
+const tertiary = chalk.hex(colors.tertiary);
+const separator = chalk.hex(colors.separator);
+const lavender = chalk.hex(colors.lavender);
+const roseGold = chalk.hex(colors.roseGold);
+// ============================================================================
+// Terminal width helpers — single source of truth for layout widths
+// ============================================================================
+function termWidth() {
+    return process.stdout.columns || 80;
+}
+/** Width for top-level assistant text (accounts for MessageList marginLeft=2) */
+export function contentWidth() {
+    return termWidth() - 2;
+}
+/** Width for content nested inside tool results (MessageList=2 + ToolIndicator=2 + safety=2) */
+export function toolContentWidth() {
+    return termWidth() - 6;
+}
+// ============================================================================
+// console.warn suppression — safe in single-threaded Node.js
+// ============================================================================
+/** Suppress console.warn during a synchronous function call. */
+function withSuppressedWarnings(fn) {
+    const orig = console.warn;
+    console.warn = () => { };
+    try {
+        return fn();
+    }
+    finally {
+        console.warn = orig;
+    }
+}
+// ============================================================================
+// OSC 8 hyperlinks — only in terminals that support them
+// ============================================================================
+/** Detect if terminal supports OSC 8 clickable hyperlinks */
+const supportsOsc8 = (() => {
+    const tp = process.env.TERM_PROGRAM || "";
+    if (/iterm|wezterm|kitty|hyper|warp|foot|alacritty/i.test(tp))
+        return true;
+    if (process.env.VTE_VERSION)
+        return true; // GNOME Terminal, Tilix
+    if (process.env.WT_SESSION)
+        return true; // Windows Terminal
+    if (process.env.KONSOLE_VERSION)
+        return true; // Konsole
+    // Apple Terminal.app does NOT support OSC 8
+    return false;
+})();
+function hyperlink(url, text) {
+    // mailto: → clean email address, no protocol prefix, no OSC 8
+    if (url.startsWith("mailto:")) {
+        const email = text || url.slice(7);
+        return systemCyan(email);
+    }
+    // tel: → clean phone number
+    if (url.startsWith("tel:")) {
+        return systemCyan(text || url.slice(4));
+    }
+    const display = text || url;
+    // OSC 8 clickable links — only where terminal supports them
+    if (supportsOsc8) {
+        return `\x1B]8;;${url}\x07${systemCyan.underline(display)}\x1B]8;;\x07`;
+    }
+    // Fallback: colored underlined text (no escape sequences)
+    return systemCyan.underline(display);
+}
+// ============================================================================
+// Path helpers
+// ============================================================================
+/** Shorten a file path for code block headers */
+function shortenPathForHeader(fullPath, maxLen = 40) {
+    let p = fullPath;
+    const cwd = process.cwd();
+    const home = process.env.HOME || "";
+    if (p.startsWith(cwd + "/"))
+        p = p.slice(cwd.length + 1);
+    else if (p.startsWith(cwd))
+        p = p.slice(cwd.length);
+    else if (home && p.startsWith(home))
+        p = "~" + p.slice(home.length);
+    if (p.length <= maxLen)
+        return p;
+    const parts = p.split("/");
+    const file = parts.pop();
+    if (file.length >= maxLen - 4)
+        return "…/" + file.slice(-(maxLen - 4));
+    const parent = parts.pop();
+    return parent ? "…/" + parent + "/" + file : "…/" + file;
+}
+// ============================================================================
+// Syntax highlighting — purples / blues / pinks
+// ============================================================================
+const appleTheme = {
+    // Keywords — pink bold
+    keyword: systemPink.bold,
+    built_in: systemPurple,
+    type: systemCyan,
+    literal: systemIndigo,
+    number: systemMint,
+    regexp: systemPink,
+    // Strings — lavender
+    string: lavender,
+    subst: systemCyan,
+    symbol: systemPurple,
+    // Functions & classes — blue
+    class: systemCyan.bold,
+    function: systemBlue,
+    title: systemBlue.bold,
+    params: roseGold,
+    // Comments — tertiary italic
+    comment: tertiary.italic,
+    doctag: secondary.italic,
+    meta: systemIndigo,
+    "meta-keyword": systemPink,
+    "meta-string": lavender,
+    // Tags (HTML/JSX)
+    tag: systemPink,
+    name: systemCyan,
+    attr: systemPurple,
+    attribute: systemPurple,
+    // Variables & properties
+    variable: systemCyan,
+    property: systemBlue,
+    // Diff
+    addition: systemGreen,
+    deletion: systemRed,
+    // Lists & markup
+    bullet: systemPurple,
+    code: systemPink,
+    emphasis: chalk.italic,
+    strong: chalk.bold,
+    link: systemCyan.underline,
+    quote: secondary.italic,
+    // Selectors (CSS)
+    "selector-tag": systemPink,
+    "selector-id": systemBlue,
+    "selector-class": systemPurple,
+    "selector-pseudo": systemCyan,
+    "selector-attr": lavender,
+    // Template
+    "template-tag": systemPink,
+    "template-variable": systemCyan,
+    // JSON property names — purple
+    section: systemPurple,
+    // Fallback
+    default: (s) => s,
+};
+// ============================================================================
+// Financial coloring
+// ============================================================================
+function colorizeFinancials(str) {
+    return str
+        // NOTE: URL hyperlinking is handled by marked's GFM autolink + link/href handlers.
+        // Do NOT add URL patterns here — it causes links to render 3-5x.
+        // Negative dollar amounts → red  (-$1,234.56) — require digit after $
+        .replace(/(-\$\d[\d,]*\.?\d*)/g, (m) => systemRed(m))
+        // Positive dollar amounts → green  ($1,234.56) — require digit after $
+        .replace(/((?:^|[^-])\$\d[\d,]*\.?\d*)/g, (m) => systemGreen(m))
+        // Negative percentages → red
+        .replace(/(-\d+\.?\d*%)/g, (m) => systemRed(m))
+        // Positive percentages → cyan
+        .replace(/((?:^|[^-])\d+\.?\d*%)/g, (m) => systemCyan(m))
+        // Explicit positive → green
+        .replace(/(\+\$?[\d,]+\.?\d*)/g, (m) => systemGreen(m))
+        // Financial-specific words → green (no generic words like running/ready/started)
+        .replace(/\b(profit|revenue|gain|in stock|available)\b/gi, (m) => systemGreen(m))
+        // Financial/status negatives → red
+        .replace(/\b(loss|deduction|deficit|expense|out of stock|low stock|overdue|expired|cancelled|failed|error|crashed|EADDRINUSE|ENOENT)\b/gi, (m) => systemRed(m));
+}
+// ============================================================================
+// Markdown renderer
+// ============================================================================
+// ── Isolated marked instance (no global side effects) ──
+const md = new Marked();
+md.use(markedTerminal({
+    // Headings — bold blue
+    firstHeading: systemBlue.bold,
+    heading: systemBlue.bold,
+    // Inline
+    codespan: systemPink,
+    strong: text.bold,
+    em: lavender.italic,
+    // Blocks
+    blockquote: secondary.italic,
+    paragraph: (body) => colorizeFinancials(body),
+    hr: () => separator("─".repeat(50)),
+    // Links — OSC 8 clickable (single source of truth for URL rendering)
+    // NOTE: Only use `link` handler, NOT `href` — having both causes double-hyperlinking
+    link: (href, _title, text) => hyperlink(href, text !== href ? text : undefined),
+    // Lists — purple bullets, financial-aware
+    list: (body, ordered) => {
+        if (ordered) {
+            let n = 0;
+            return body.replace(/^\* /gm, () => {
+                n++;
+                return `${systemIndigo(String(n) + ".")} `;
+            });
+        }
+        return body.replace(/^\* /gm, `${systemPurple("●")} `);
+    },
+    listitem: (itemText) => {
+        return colorizeFinancials(itemText);
+    },
+    // Layout — adapt to terminal width
+    reflowText: false,
+    showSectionPrefix: false,
+    width: Math.min(120, contentWidth()),
+    tab: 2,
+}, {
+    // cli-highlight — purple/blue/pink syntax theme
+    theme: appleTheme,
+    ignoreIllegals: true,
+}));
+// ============================================================================
+// Diff renderer — background colors + word-level diff (Claude Code parity)
+// ============================================================================
+// Background colors for diff lines — derived from Theme (256-color safe cube values)
+const diffAddedBg = chalk.bgHex(colors.diffAddedBg).white;
+const diffRemovedBg = chalk.bgHex(colors.diffRemovedBg).white;
+const diffWordAdded = chalk.bgHex(colors.diffWordAdded).whiteBright.bold;
+const diffWordRemoved = chalk.bgHex(colors.diffWordRemoved).whiteBright.bold;
+/** Compute word-level diff between two lines using the `diff` library. */
+function wordDiff(oldLine, newLine) {
+    const changes = diffWords(oldLine, newLine);
+    const oldSegs = [];
+    const newSegs = [];
+    for (const change of changes) {
+        if (change.added) {
+            newSegs.push({ text: change.value, changed: true });
+        }
+        else if (change.removed) {
+            oldSegs.push({ text: change.value, changed: true });
+        }
+        else {
+            oldSegs.push({ text: change.value, changed: false });
+            newSegs.push({ text: change.value, changed: false });
+        }
+    }
+    // If >60% of either line changed, fall back to full-line highlight
+    const oldChanged = oldSegs.filter(s => s.changed).reduce((n, s) => n + s.text.length, 0);
+    const newChanged = newSegs.filter(s => s.changed).reduce((n, s) => n + s.text.length, 0);
+    if ((oldLine.length > 0 && oldChanged / oldLine.length > 0.6) ||
+        (newLine.length > 0 && newChanged / newLine.length > 0.6)) {
+        return { old: [{ text: oldLine, changed: true }], new: [{ text: newLine, changed: true }] };
+    }
+    return { old: oldSegs, new: newSegs };
+}
+/** Render segments with word-level highlighting */
+function renderSegments(segs, wordStyle, lineStyle) {
+    return segs.map(s => s.changed ? wordStyle(s.text) : lineStyle(s.text)).join("");
+}
+function renderDiff(code) {
+    const lines = code.split("\n");
+    const tw = toolContentWidth();
+    const segments = [];
+    let oldLineNo = 1, newLineNo = 1;
+    let seenDiff = false;
+    for (const line of lines) {
+        // Skip file headers (--- a/file, +++ b/file)
+        if (line.startsWith("---") || line.startsWith("+++"))
+            continue;
+        // Hunk header — extract line numbers
+        const hunkMatch = line.match(/^@@\s*-(\d+)(?:,\d+)?\s*\+(\d+)(?:,\d+)?\s*@@/);
+        if (hunkMatch) {
+            oldLineNo = parseInt(hunkMatch[1]);
+            newLineNo = parseInt(hunkMatch[2]);
+            seenDiff = true;
+            continue;
+        }
+        // Skip non-diff header lines (e.g., "File edited:", "Applied N edits")
+        if (!seenDiff && !line.startsWith("-") && !line.startsWith("+") && !line.startsWith(" ")) {
+            continue;
+        }
+        seenDiff = true;
+        if (line.startsWith("-")) {
+            segments.push({ type: "remove", content: line.slice(1), lineNo: oldLineNo });
+            oldLineNo++;
+        }
+        else if (line.startsWith("+")) {
+            segments.push({ type: "add", content: line.slice(1), lineNo: newLineNo });
+            newLineNo++;
+        }
+        else {
+            const content = line.startsWith(" ") ? line.slice(1) : line;
+            segments.push({ type: "context", content, lineNo: newLineNo });
+            oldLineNo++;
+            newLineNo++;
+        }
+    }
+    if (segments.length === 0)
+        return code; // fallback
+    // Gutter width from max line number
+    const maxLineNo = segments.reduce((max, s) => Math.max(max, s.lineNo), 0);
+    const gutterW = Math.max(3, String(maxLineNo).length);
+    const out = [];
+    let i = 0;
+    while (i < segments.length) {
+        const seg = segments[i];
+        if (seg.type === "remove") {
+            // Collect consecutive removes
+            const removes = [];
+            while (i < segments.length && segments[i].type === "remove") {
+                removes.push(segments[i]);
+                i++;
+            }
+            // Collect consecutive adds
+            const adds = [];
+            while (i < segments.length && segments[i].type === "add") {
+                adds.push(segments[i]);
+                i++;
+            }
+            // Pair for word-level diff
+            const pairCount = Math.min(removes.length, adds.length);
+            for (let j = 0; j < removes.length; j++) {
+                const r = removes[j];
+                const rPrefix = `${String(r.lineNo).padStart(gutterW)} - `;
+                if (j < pairCount) {
+                    const a = adds[j];
+                    const aPrefix = `${String(a.lineNo).padStart(gutterW)} + `;
+                    const wd = wordDiff(r.content, a.content);
+                    // Removed line with word highlights
+                    const rPad = Math.max(0, tw - rPrefix.length - r.content.length);
+                    out.push(diffRemovedBg(rPrefix) + renderSegments(wd.old, diffWordRemoved, diffRemovedBg) + diffRemovedBg(" ".repeat(rPad)));
+                    // Added line with word highlights
+                    const aPad = Math.max(0, tw - aPrefix.length - a.content.length);
+                    out.push(diffAddedBg(aPrefix) + renderSegments(wd.new, diffWordAdded, diffAddedBg) + diffAddedBg(" ".repeat(aPad)));
+                }
+                else {
+                    // Unpaired remove
+                    const raw = rPrefix + r.content;
+                    const pad = Math.max(0, tw - raw.length);
+                    out.push(diffRemovedBg(raw + " ".repeat(pad)));
+                }
+            }
+            // Unpaired adds
+            for (let j = pairCount; j < adds.length; j++) {
+                const a = adds[j];
+                const prefix = `${String(a.lineNo).padStart(gutterW)} + `;
+                const raw = prefix + a.content;
+                const pad = Math.max(0, tw - raw.length);
+                out.push(diffAddedBg(raw + " ".repeat(pad)));
+            }
+            continue;
+        }
+        if (seg.type === "add") {
+            // Standalone add (no preceding remove)
+            const prefix = `${String(seg.lineNo).padStart(gutterW)} + `;
+            const raw = prefix + seg.content;
+            const pad = Math.max(0, tw - raw.length);
+            out.push(diffAddedBg(raw + " ".repeat(pad)));
+            i++;
+            continue;
+        }
+        // Context line — dim line number, plain content, no background
+        const prefix = tertiary(`${String(seg.lineNo).padStart(gutterW)}   `);
+        out.push(prefix + seg.content);
+        i++;
+    }
+    return out.join("\n") + "\n";
+}
+// ============================================================================
+// Bar chart renderer — ```chart code blocks
+// ============================================================================
+const barGradient = [
+    chalk.hex("#BF5AF2"), // purple
+    chalk.hex("#5E5CE6"), // indigo
+    chalk.hex("#0A84FF"), // blue
+    chalk.hex("#64D2FF"), // cyan
+    chalk.hex("#6AC4DC"), // teal
+    chalk.hex("#30D158"), // green
+    chalk.hex("#FF9F0A"), // orange
+    chalk.hex("#FF375F"), // pink
+];
+function renderBarChart(code) {
+    const lines = code.trim().split("\n").filter(l => l.trim());
+    // Optional title — first line without "label: number" pattern
+    let title = "";
+    let dataLines = lines;
+    if (lines.length > 1 && !/:\s*[$\-+]?[\d,]+/.test(lines[0])) {
+        title = lines[0].trim();
+        dataLines = lines.slice(1);
+    }
+    // Parse "Label: $1,234.56" or "Label: 42%" or "Label: 1000"
+    const entries = [];
+    for (const line of dataLines) {
+        const m = line.match(/^(.+?):\s*([+\-]?\$?[\d,]+\.?\d*%?)\s*$/);
+        if (!m)
+            continue;
+        const label = m[1].trim();
+        const raw = m[2].trim();
+        const value = Math.abs(parseFloat(raw.replace(/[$,%]/g, "")));
+        if (!isNaN(value))
+            entries.push({ label, value, raw });
+    }
+    if (entries.length === 0)
+        return code;
+    const maxVal = Math.max(...entries.map(e => e.value));
+    const maxLabel = Math.max(...entries.map(e => e.label.length));
+    const maxRaw = Math.max(...entries.map(e => e.raw.length));
+    const cw = contentWidth();
+    const barWidth = Math.min(36, Math.max(12, cw - 8 - maxLabel - maxRaw));
+    const out = [];
+    if (title) {
+        out.push(`  ${systemBlue.bold(title)}`);
+        out.push("");
+    }
+    for (let i = 0; i < entries.length; i++) {
+        const e = entries[i];
+        const ratio = maxVal > 0 ? e.value / maxVal : 0;
+        const filled = Math.round(ratio * barWidth);
+        const color = barGradient[i % barGradient.length];
+        const label = secondary(e.label.padStart(maxLabel));
+        const bar = color("█".repeat(filled)) + chalk.hex("#2C2C2E")("░".repeat(barWidth - filled));
+        const val = e.raw.includes("$")
+            ? systemGreen(e.raw.padStart(maxRaw))
+            : e.raw.includes("%")
+                ? systemCyan(e.raw.padStart(maxRaw))
+                : systemMint(e.raw.padStart(maxRaw));
+        out.push(`  ${label}  ${bar}  ${val}`);
+    }
+    return "\n" + out.join("\n") + "\n";
+}
+function getRowTone(cells) {
+    for (const cell of cells) {
+        const t = cell.trim();
+        // Negative financial → red row
+        if (/^-\$[\d,]+/.test(t) || /^-\d+\.?\d*%/.test(t))
+            return "negative";
+        // Explicit positive delta → green row
+        if (/^\+\d/.test(t) || /^\+\$/.test(t))
+            return "positive";
+        // Status badges
+        if (/^`?[✕✗]/.test(t) || /cancelled|failed|rejected|error|out of stock|low stock/i.test(t))
+            return "negative";
+        if (/^`?[✓●]/.test(t) || /completed|received|approved|active|success|paid|published/i.test(t))
+            return "positive";
+    }
+    return "neutral";
+}
+// Background tints for row-level coloring
+const rowBgPositive = chalk.bgHex("#0d1f14"); // subtle green tint
+const rowBgNegative = chalk.bgHex("#1f0d10"); // subtle red tint
+function colorizeCell(val, isHeader, rowTone = "neutral") {
+    const trimmed = val.trim();
+    if (!trimmed)
+        return text("");
+    if (isHeader)
+        return systemIndigo.bold(trimmed);
+    // Badge format: `✓ status` or `◆ status` or `○ status` or `✕ status`
+    const badgeMatch = trimmed.match(/^`([✓●◆○✕◦])\s+(.+)`$/);
+    if (badgeMatch) {
+        const [, icon, label] = badgeMatch;
+        if (icon === "✓" || icon === "●")
+            return systemGreen(`${icon} ${label}`);
+        if (icon === "◆")
+            return systemCyan(`${icon} ${label}`);
+        if (icon === "○")
+            return systemOrange(`${icon} ${label}`);
+        if (icon === "✕")
+            return systemRed(`${icon} ${label}`);
+        return secondary(`${icon} ${label}`);
+    }
+    // Inline code (UUID, SKU, transfer number) — subtle style
+    if (trimmed.startsWith("`") && trimmed.endsWith("`")) {
+        return systemPurple(trimmed.slice(1, -1));
+    }
+    // Bold text
+    if (trimmed.startsWith("**") && trimmed.endsWith("**")) {
+        return text.bold(trimmed.slice(2, -2));
+    }
+    // Negative values → red
+    if (/^-\$?[\d,]+\.?\d*$/.test(trimmed) || /^-\d+\.?\d*%$/.test(trimmed)) {
+        return systemRed(trimmed);
+    }
+    // Positive financial → green
+    if (/^\+?\$[\d,]+\.?\d*$/.test(trimmed) || /^\$[\d,]+\.?\d*$/.test(trimmed)) {
+        return systemGreen(trimmed);
+    }
+    // Percentages → cyan
+    if (/^\d+\.?\d*%$/.test(trimmed)) {
+        return systemCyan(trimmed);
+    }
+    // Plain numbers → mint
+    if (/^[\d,]+\.?\d*$/.test(trimmed)) {
+        return systemMint(trimmed);
+    }
+    // Status words
+    if (/^(active|success|complete|approved|in stock|available)/i.test(trimmed)) {
+        return systemGreen(trimmed);
+    }
+    if (/^(inactive|error|failed|cancelled|out of stock|low|overdue|expired)/i.test(trimmed)) {
+        return systemRed(trimmed);
+    }
+    if (/^(pending|draft|processing)/i.test(trimmed)) {
+        return systemOrange(trimmed);
+    }
+    // Apply row tone tint to text cells
+    if (rowTone === "positive")
+        return rowBgPositive(text(trimmed));
+    if (rowTone === "negative")
+        return rowBgNegative(text(trimmed));
+    return text(trimmed);
+}
+function renderTable(token) {
+    // Extract cell text from token — handles both inline tokens and plain text
+    function getCellText(cell) {
+        if (!cell)
+            return "";
+        if (typeof cell === "string")
+            return cell;
+        if (cell.text !== undefined)
+            return String(cell.text);
+        if (cell.tokens) {
+            return cell.tokens.map((t) => t.raw || t.text || "").join("");
+        }
+        return String(cell);
+    }
+    const headers = (token.header || []).map((h) => getCellText(h));
+    const rows = (token.rows || []).map((row) => row.map((cell) => getCellText(cell)));
+    if (headers.length === 0)
+        return "";
+    // Responsive column widths based on terminal width
+    const cw = contentWidth();
+    const N = headers.length;
+    // Overhead: "  ╭" (3) + N+1 border chars + N*2 cell padding + "╮"
+    const overhead = 3 + (N + 1) + (N * 2);
+    const availableForContent = cw - overhead;
+    // Scale minimum column width down for narrow terminals
+    const minCol = cw < 70 ? 3 : cw < 90 ? 4 : 6;
+    const maxPerCol = Math.max(minCol, Math.floor(availableForContent / N));
+    const colWidths = headers.map((h, i) => {
+        const dataMax = rows.reduce((max, row) => Math.max(max, (row[i] || "").length), 0);
+        return Math.min(maxPerCol, Math.max(minCol, h.length, dataMax) + 2);
+    });
+    const border = chalk.hex("#48484A");
+    const out = [];
+    // Top border: ╭──────┬──────╮
+    out.push(border("  ╭" + colWidths.map((w) => "─".repeat(w + 2)).join("┬") + "╮"));
+    // Header row (truncate headers to fit)
+    const hdrLine = headers.map((h, i) => {
+        const display = h.length > colWidths[i] ? h.slice(0, colWidths[i] - 1) + "…" : h;
+        return " " + systemIndigo.bold(display.padEnd(colWidths[i])) + " ";
+    }).join(border("│"));
+    out.push(border("  │") + hdrLine + border("│"));
+    // Header/body divider: ├──────┼──────┤
+    out.push(border("  ├" + colWidths.map((w) => "─".repeat(w + 2)).join("┼") + "┤"));
+    // Data rows (truncate values to fit, with row-level background tinting)
+    for (const row of rows) {
+        const tone = getRowTone(row);
+        const cells = headers.map((_, i) => {
+            const raw = row[i] || "";
+            const display = raw.length > colWidths[i] ? raw.slice(0, colWidths[i] - 1) + "…" : raw;
+            const colored = colorizeCell(display, false, tone);
+            const extraPad = Math.max(0, colWidths[i] - display.length);
+            const cellContent = " " + colored + " ".repeat(extraPad) + " ";
+            // Apply subtle background tint to the entire cell for positive/negative rows
+            if (tone === "positive")
+                return rowBgPositive(cellContent);
+            if (tone === "negative")
+                return rowBgNegative(cellContent);
+            return cellContent;
+        }).join(border("│"));
+        out.push(border("  │") + cells + border("│"));
+    }
+    // Bottom border: ╰──────┴──────╯
+    out.push(border("  ╰" + colWidths.map((w) => "─".repeat(w + 2)).join("┴") + "╯"));
+    return "\n" + out.join("\n") + "\n";
+}
+// Register chart + table extensions — intercepts before markedTerminal
+md.use({
+    renderer: {
+        code(token) {
+            const rawLang = token.lang || "";
+            const code = token.text;
+            // Parse lang:subtitle (e.g. "typescript:src/foo.ts")
+            const colonIdx = rawLang.indexOf(":");
+            const lang = colonIdx > 0 ? rawLang.slice(0, colonIdx) : rawLang;
+            const subtitle = colonIdx > 0 ? rawLang.slice(colonIdx + 1) : "";
+            if (lang === "chart" || lang === "bar") {
+                return renderBarChart(code);
+            }
+            if (lang === "diff") {
+                return renderDiff(code);
+            }
+            {
+                // Command output mode: bash without subtitle = run_command output
+                // → no line numbers, wider content area, clean indent
+                const isCommandOutput = (lang === "bash" || lang === "terminal") && !subtitle;
+                const highlightLang = lang === "terminal" ? "bash" : lang;
+                // Build header: ── lang ── subtitle ──────
+                const cw = contentWidth();
+                const headerWidth = Math.max(20, cw - 6);
+                const displayLang = isCommandOutput ? "bash" : lang;
+                let header;
+                if (displayLang && subtitle) {
+                    const shortSub = shortenPathForHeader(subtitle, headerWidth - displayLang.length - 10);
+                    const pad = Math.max(2, headerWidth - displayLang.length - shortSub.length - 6);
+                    header = separator("  ── ") + tertiary(displayLang) + separator(" ── ") + secondary(shortSub) + separator(` ${"─".repeat(pad)}`);
+                }
+                else if (displayLang) {
+                    const pad = Math.max(2, headerWidth - displayLang.length - 3);
+                    header = separator("  ── ") + tertiary(displayLang) + separator(` ${"─".repeat(pad)}`);
+                }
+                else {
+                    header = separator("  ──" + "─".repeat(headerWidth - 2));
+                }
+                // Calculate max line width to prevent wrapping
+                const lineCount = code.split("\n").length;
+                const gutterW = isCommandOutput ? 0 : String(lineCount).length;
+                const gutterOverhead = isCommandOutput ? 4 : (2 + gutterW + 3); // "    " or "  123 │ "
+                const maxLineWidth = Math.max(20, cw - gutterOverhead - 2);
+                // Pre-truncate lines BEFORE highlighting (avoids cutting ANSI codes)
+                const truncatedCode = code.split("\n").map((line) => {
+                    if (line.length > maxLineWidth) {
+                        return line.slice(0, maxLineWidth - 1) + "…";
+                    }
+                    return line;
+                }).join("\n");
+                let highlighted;
+                if (highlightLang) {
+                    try {
+                        highlighted = withSuppressedWarnings(() => highlight(truncatedCode, { language: highlightLang, ignoreIllegals: true, theme: appleTheme }));
+                    }
+                    catch {
+                        highlighted = truncatedCode;
+                    }
+                }
+                else {
+                    highlighted = truncatedCode;
+                }
+                const hLines = highlighted.split("\n");
+                if (isCommandOutput) {
+                    // Command output: no line numbers, 4-space indent
+                    const body = hLines.map(l => "    " + l).join("\n");
+                    return "\n" + header + "\n" + body + "\n";
+                }
+                else {
+                    // Code with line numbers + gutter
+                    const numbered = hLines.map((l, i) => {
+                        const num = tertiary(String(i + 1).padStart(gutterW));
+                        return "  " + num + separator(" │ ") + l;
+                    }).join("\n");
+                    return "\n" + header + "\n" + numbered + "\n";
+                }
+            }
+        },
+        table(token) {
+            return renderTable(token);
+        },
+    },
+});
+// ============================================================================
+// Streaming fence closure — state-tracking approach
+// ============================================================================
+/** Extract text outside fenced code blocks */
+function getNonFencedText(input) {
+    const lines = input.split("\n");
+    const parts = [];
+    let inFence = false;
+    for (const line of lines) {
+        if (line.trimStart().startsWith("```")) {
+            inFence = !inFence;
+            continue;
+        }
+        if (!inFence)
+            parts.push(line);
+    }
+    return parts.join("\n");
+}
+/** Strip complete inline code spans from text */
+function getNonCodeText(t) {
+    return t.replace(/``[^`]*``/g, "").replace(/`[^`\n]*`/g, "");
+}
+/**
+ * Close incomplete markdown fences for safe streaming rendering.
+ * State-tracking approach: handles nested fences, escaped markers, double-backtick spans.
+ */
+export function closeIncompleteFences(input) {
+    let result = input;
+    // 1. Code fences — walk lines, track open/close state
+    let inFence = false;
+    for (const line of result.split("\n")) {
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith("```")) {
+            inFence = !inFence;
+        }
+    }
+    if (inFence) {
+        result += "\n```";
+    }
+    // 2. For inline markers, only examine text OUTSIDE fenced code blocks
+    const outside = getNonFencedText(result);
+    // 3. Inline backticks — remove escaped, remove complete spans, count remainder
+    let forBacktick = outside.replace(/\\`/g, "");
+    forBacktick = forBacktick.replace(/``[^`]*``/g, ""); // double-backtick spans
+    forBacktick = forBacktick.replace(/`[^`\n]*`/g, ""); // single-backtick spans
+    const unmatched = (forBacktick.match(/`/g) || []).length;
+    if (unmatched % 2 !== 0) {
+        result += "`";
+    }
+    // 4. Bold — count ** in non-code text
+    const forBold = getNonCodeText(outside);
+    const boldCount = (forBold.match(/\*\*/g) || []).length;
+    if (boldCount % 2 !== 0) {
+        result += "**";
+    }
+    // 5. Italic — count standalone * (not part of **) with escape awareness
+    const forItalic = forBold.replace(/\*\*/g, "");
+    const italicCount = (forItalic.match(/(?<!\\)\*/g) || []).length;
+    if (italicCount % 2 !== 0) {
+        result += "*";
+    }
+    return result;
+}
+/**
+ * Render markdown to ANSI-styled terminal string.
+ * Optionally applies streaming-safe fence closing.
+ */
+export function renderMarkdown(input, streaming = false) {
+    const safe = streaming ? closeIncompleteFences(input) : input;
+    const result = md.parse(safe);
+    return result.replace(/\n+$/, "");
+}