s-app-scoder-agent 0.9.3 → 0.9.7

package/dist/tui/hooks/use-submit.js

@@ -0,0 +1,106 @@
+/**
+ * Shared entry point for every task submission (steer vs. new-run, slash
+ * commands). Extracted verbatim from app.tsx.
+ */
+import { useCallback } from "react";
+import { dispatchCommand } from "../../commands/registry.js";
+import { parseSlashCommand } from "../../commands/definitions.js";
+import { applyEvent } from "../state.js";
+import { THEMES, useNamedTheme } from "../theme.js";
+export function useSubmit(deps) {
+    const { cfg, pushNotice, writeInput, exit, update, queueEvent, skills, skillNames, permMode, tuiHost, agentRef, runningRef, stateRef, historyRef, setScrollOffset, createAgent, bumpFrame } = deps;
+    // Close any lingering streaming messages when the user sends a new query —
+    // prevents green/dim text from the previous response appearing stale.
+    const closeStreamingItems = useCallback(() => {
+        update((s) => {
+            let changed = false;
+            for (const it of s.items) {
+                if (it.kind === "assistant" && it.streaming) {
+                    it.streaming = false;
+                    changed = true;
+                }
+            }
+            return changed ? { ...s, items: [...s.items] } : s;
+        });
+    }, [update]);
+    /**
+     * Shared entry point for every task submission:
+     *   1. Close any still-streaming assistant message from the previous response.
+     *   2. Record the query in history.
+     *   3. Clear the input field.
+     * Then the caller handles steer vs. new-run separately.
+     */
+    const preSubmit = useCallback((task) => {
+        closeStreamingItems();
+        historyRef.current = [...historyRef.current, task].slice(-100);
+        writeInput("");
+    }, [closeStreamingItems, writeInput]);
+    const submit = useCallback(async (text) => {
+        let task = text.trim();
+        if (!task)
+            return;
+        // "exit"/"quit" always works — aborts a running agent first.
+        if (task === "exit" || task === "quit") {
+            agentRef.current?.abort();
+            exit();
+            return;
+        }
+        // Slash commands — TUI-specific first (/theme), then the shared
+        // registry (T1) for the rest.
+        const slash = parseSlashCommand(task);
+        if (slash) {
+            writeInput("");
+            if (slash.cmd === "/theme") {
+                // T-09: palette hot-swap.
+                if (!slash.arg) {
+                    pushNotice(`themes: ${Object.keys(THEMES).join(", ")} — /theme <name>; project default qua .scoder/theme.json`);
+                    return;
+                }
+                pushNotice(useNamedTheme(slash.arg.trim()), "info");
+                bumpFrame();
+                return;
+            }
+            // T1: phần còn lại qua registry dùng chung với REPL.
+            const { handled, outcome } = await dispatchCommand(task, tuiHost(), pushNotice);
+            if (handled && outcome?.task) {
+                task = outcome.task;
+            }
+            else {
+                return;
+            }
+        }
+        if (runningRef.current) {
+            // Steer: user input while the agent runs — deliver at next step
+            // boundary (H-08, "steer by default" — pattern from opencode).
+            preSubmit(task);
+            agentRef.current?.steer(task);
+            // Steer = user message mới → plan cũ reset (cùng ngữ nghĩa latestPlan).
+            update((s) => ({ ...s, plan: null, items: [...s.items, { kind: "user", text: `${task}  (steered)` }] }));
+            return;
+        }
+        preSubmit(task);
+        runningRef.current = true;
+        setScrollOffset(0);
+        // isFirst must be computed BEFORE pushing the user item below.
+        const isFirst = stateRef.current.items.every((i) => i.kind !== "user");
+        // runTurn() doesn't emit run_start, so the TUI shows the user's message
+        // itself; applyEvent's run_start dedupe keeps turn 1 from doubling.
+        // runTurn cũng không reset plan — reset ở đây (user message mới).
+        update((s) => ({ ...s, plan: null, items: [...s.items, { kind: "user", text: task }], status: "running", summary: null }));
+        const agent = createAgent();
+        try {
+            // First submission runs the full closed loop; later ones continue the session.
+            const result = isFirst ? await agent.run(task) : await agent.runTurn(task);
+            void result;
+            runningRef.current = false;
+        }
+        catch (err) {
+            runningRef.current = false;
+            // Surface the failure through the reducer (not just a notice) so the
+            // status leaves "running" and the error is visible as the final line.
+            update((s) => applyEvent({ ...s, items: [...s.items] }, { type: "finish", success: false, steps: s.step, summary: `Run failed: ${err.message}` }));
+            update((s) => ({ ...s, items: [...s.items, { kind: "notice", text: err.message, level: "error" }] }));
+        }
+    }, [cfg, pushNotice, writeInput, exit, update, queueEvent, skills, skillNames, permMode, tuiHost, preSubmit]);
+    return { submit };
+}

package/dist/tui/image.js

@@ -1,149 +1,2 @@
-/**
- * T7: image render trong chat — detect terminal protocol + halfblock preview.
- * Không thêm dependency: halfblock qua unicode upper-half ▀ với truecolor
- * (iTerm2/kitty hỗ trợ COLORTERM=truecolor). Terminal không hỗ trợ → fallback
- * link text. ponytail: 40px width cố định, không đo cell size thật — nâng
- * cấp khi cần aspect ratio chuẩn.
- */
-import { inflateSync } from "node:zlib";
-export function detectImageCaps(env = process.env) {
-    const truecolor = env.COLORTERM === "truecolor" || env.COLORTERM === "24bit";
-    const iterm = env.TERM_PROGRAM === "iTerm.app";
-    const kitty = env.TERM === "xterm-kitty" || env.KITTY_WINDOW_ID !== undefined;
-    return { truecolor, iterm, kitty };
-}
-const IMG_MAGIC = [
-    { ext: "png", test: (b) => b.length > 8 && b[0] === 0x89 && b[1] === 0x50 },
-    { ext: "jpg", test: (b) => b.length > 3 && b[0] === 0xff && b[1] === 0xd8 },
-    { ext: "gif", test: (b) => b.length > 6 && b.toString("ascii", 0, 3) === "GIF" },
-    { ext: "bmp", test: (b) => b.length > 2 && b[0] === 0x42 && b[1] === 0x4d },
-];
-/** Detect image từ magic bytes (đuôi file không đáng tin). */
-export function detectImageBytes(buf) {
-    return IMG_MAGIC.find((m) => m.test(buf))?.ext ?? null;
-}
-/** Decode PNG/JPG size (width/height) — chỉ PNG (IHDR) và JPEG (SOF markers). */
-export function imageSize(buf) {
-    if (detectImageBytes(buf) === "png" && buf.length > 24) {
-        return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
-    }
-    if (detectImageBytes(buf) === "jpg") {
-        let i = 2;
-        while (i + 9 < buf.length) {
-            if (buf[i] !== 0xff)
-                break;
-            const marker = buf[i + 1];
-            const len = buf.readUInt16BE(i + 2);
-            if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
-                return { height: buf.readUInt16BE(i + 5), width: buf.readUInt16BE(i + 7) };
-            }
-            i += 2 + len;
-        }
-    }
-    return null;
-}
-/**
- * Render buffer ảnh thành mảng dòng "▀" (2 pixel ảnh / 1 dòng terminal).
- * Trả về null khi terminal không truecolor (caller fallback link).
- */
-export function halfblockRows(buf, maxCols = 40) {
-    const png = detectImageBytes(buf) === "png";
-    if (!png)
-        return null; // ponytail: chỉ decode PNG thuần (zlib builtin); JPG → null
-    const size = imageSize(buf);
-    if (!size || size.width === 0 || size.height === 0)
-        return null;
-    // Decode IDAT: zlib inflate + unfilter scanlines.
-    let rows;
-    try {
-        rows = decodePngPixels(buf, size.width, size.height);
-    }
-    catch {
-        return null;
-    }
-    const w = size.width;
-    const cols = Math.min(maxCols, w);
-    const step = w / cols; // downsample theo cột
-    const out = [];
-    for (let py = 0; py < size.height; py += 2) {
-        let line = "";
-        for (let cx = 0; cx < cols; cx++) {
-            const px = Math.min(w - 1, Math.floor(cx * step));
-            const top = pixelAt(rows, w, px, py);
-            const bot = py + 1 < size.height ? pixelAt(rows, w, px, py + 1) : [0, 0, 0];
-            line += `\x1b[38;2;${top[0]};${top[1]};${top[2]};48;2;${bot[0]};${bot[1]};${bot[2]}m▀`;
-        }
-        out.push({ text: line + "\x1b[0m" });
-    }
-    return out;
-}
-function pixelAt(rows, w, x, y) {
-    const o = (y * w + x) * 3;
-    return [rows[o], rows[o + 1], rows[o + 2]];
-}
-/** PNG IDAT decode (zlib builtin) + unfilter — RGB/RGBA 8-bit không interlace. */
-function decodePngPixels(buf, w, h) {
-    // Scan chunks: gather IDAT data.
-    let off = 8;
-    const idat = [];
-    let bitDepth = 8;
-    let colorType = 2;
-    while (off + 8 <= buf.length) {
-        const len = buf.readUInt32BE(off);
-        const type = buf.toString("ascii", off + 4, off + 8);
-        if (type === "IHDR") {
-            bitDepth = buf[off + 16];
-            colorType = buf[off + 17];
-        }
-        if (type === "IDAT")
-            idat.push(buf.subarray(off + 8, off + 8 + len));
-        if (type === "IEND")
-            break;
-        off += 12 + len;
-    }
-    if (bitDepth !== 8 || (colorType !== 2 && colorType !== 6))
-        throw new Error("unsupported png");
-    const bpp = colorType === 6 ? 4 : 3;
-    const raw = inflateSync(Buffer.concat(idat));
-    const stride = w * bpp;
-    const px = new Uint8Array(w * h * 3);
-    let prev = new Uint8Array(stride);
-    for (let y = 0; y < h; y++) {
-        const f = raw[y * (stride + 1)];
-        const line = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
-        const cur = new Uint8Array(stride);
-        for (let x = 0; x < stride; x++) {
-            const a = x >= bpp ? cur[x - bpp] : 0;
-            const b = prev[x];
-            const c = x >= bpp ? prev[x - bpp] : 0;
-            let v = line[x];
-            switch (f) {
-                case 1:
-                    v += a;
-                    break;
-                case 2:
-                    v += b;
-                    break;
-                case 3:
-                    v += (a + b) >> 1;
-                    break;
-                case 4: {
-                    const p = a + b - c;
-                    const pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
-                    v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
-                    break;
-                }
-            }
-            cur[x] = v & 0xff;
-        }
-        for (let x = 0; x < w; x++) {
-            const so = x * bpp;
-            const do_ = (y * w + x) * 3;
-            px[do_] = cur[so];
-            px[do_ + 1] = cur[so + 1];
-            px[do_ + 2] = cur[so + 2];
-        }
-        prev = cur;
-    }
-    return px;
-}
+/** Legacy compatibility facade; implementation lives in src/media/image.ts. */
+export * from "../media/image.js";

package/dist/tui/input.js

@@ -6,7 +6,7 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
 import { useCallback, useMemo, useRef, useState } from "react";
 import { Box, Text, useInput } from "ink";
 import { applySuggestion, atQuery, fileIndex, suggest } from "./at-complete.js";
-import { completeSlashCommand, completionProviders, ghostText, completeMcpArg } from "./commands.js";
+import { completeSlashCommand, completionProviders, ghostText, completeMcpArg } from "../commands/definitions.js";
 import { applyNormalKey } from "./vim.js"; // T5
 import { theme } from "./theme.js";
 export function Input({ valueRef, value, onChange, onSubmit, historyRef, skillNames, agentRef, config, atSources, modalRef }) {

package/dist/tui/markdown/ast.js

@@ -0,0 +1,5 @@
+/**
+ * Markdown block AST — output of parse.ts, input of render.tsx.
+ * Pure data, zero Ink dependency, fully unit-testable.
+ */
+export {};

package/dist/tui/markdown/diagram.js

@@ -0,0 +1,239 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { theme } from "../theme.js";
+import { charset } from "../charset.js";
+import { clipCells, measure, padEndCells } from "../text-width.js";
+// ── Chart / timeline specs (unchanged data formats) ─────────────────────────
+function scalar(value) {
+    if (value == null)
+        return "";
+    return typeof value === "string" ? value.trim() : String(value);
+}
+/** Parse JSON or the intentionally small line format accepted by chart fences. */
+export function parseChartSpec(source, language = "chart") {
+    const raw = source.trim();
+    if (!raw)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        parsed = null;
+    }
+    const object = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed
+        : {};
+    const typeRaw = scalar(object.type) || language.split(/[:\s]+/)[1] || "bar";
+    const type = typeRaw.toLowerCase();
+    const rows = Array.isArray(parsed)
+        ? parsed
+        : Array.isArray(object.data) ? object.data : [];
+    const data = rows.flatMap((row, index) => {
+        if (Array.isArray(row)) {
+            const value = Number(row[1]);
+            return Number.isFinite(value) ? [{ label: scalar(row[0]) || String(index + 1), value }] : [];
+        }
+        if (row && typeof row === "object") {
+            const r = row;
+            const value = Number(r.value ?? r.y ?? r.amount);
+            return Number.isFinite(value) ? [{ label: scalar(r.label ?? r.name ?? r.x) || String(index + 1), value }] : [];
+        }
+        return [];
+    });
+    // Friendly fallback: `label | value` or `label, value` per line.
+    if (data.length === 0) {
+        for (const [index, line] of raw.split("\n").entries()) {
+            if (!line.trim() || /^(type|title|data)\s*:/i.test(line))
+                continue;
+            const parts = line.split(/\s*[|,]\s*/);
+            const value = Number(parts.at(-1));
+            if (parts.length >= 2 && Number.isFinite(value))
+                data.push({ label: parts.slice(0, -1).join(" ").trim() || String(index + 1), value });
+        }
+    }
+    if (data.length === 0 || !["bar", "line", "pie"].includes(type))
+        return null;
+    const title = scalar(object.title);
+    return {
+        type: type,
+        ...(title ? { title } : {}),
+        data: data.slice(0, 40),
+    };
+}
+/** Parse JSON or `time | title | detail | status` timeline rows. */
+export function parseTimelineSpec(source) {
+    const raw = source.trim();
+    if (!raw)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        parsed = null;
+    }
+    const rows = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === "object" && Array.isArray(parsed.events)
+            ? parsed.events
+            : [];
+    const events = rows.flatMap((row) => {
+        if (!row || typeof row !== "object")
+            return [];
+        const r = row;
+        const title = scalar(r.title ?? r.name ?? r.event);
+        if (!title)
+            return [];
+        const status = scalar(r.status).toLowerCase();
+        return [{
+                time: scalar(r.time ?? r.date ?? r.timestamp),
+                title,
+                detail: scalar(r.detail ?? r.description ?? r.body) || undefined,
+                status: ["done", "active", "pending", "error"].includes(status) ? status : undefined,
+            }];
+    });
+    if (events.length > 0)
+        return events.slice(0, 40);
+    return raw.split("\n").flatMap((line) => {
+        const trimmed = line.replace(/^[-*]\s*/, "").trim();
+        if (!trimmed)
+            return [];
+        const parts = trimmed.split(/\s*\|\s*/);
+        if (parts.length < 2)
+            return [];
+        const status = parts[3]?.toLowerCase();
+        return [{ time: parts[0], title: parts[1], detail: parts[2] || undefined,
+                status: ["done", "active", "pending", "error"].includes(status) ? status : undefined }];
+    }).slice(0, 40);
+}
+// ── Bordered content box (cell-measured) ────────────────────────────────────
+/** Render content lines inside a properly aligned box sized to `width` cells. */
+export function ContentBox({ title, lines, width, color }) {
+    const inner = Math.max(10, width - 2); // 2 border cells
+    const titleText = ` ${title} `;
+    const topFill = Math.max(0, inner - measure(titleText) - 1);
+    const borderColor = color ?? theme.table;
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: theme.table, bold: true, children: [charset.tl, charset.h, clipCells(titleText, inner - 1), charset.h.repeat(topFill), charset.tr] }), lines.map((line, i) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.table, children: charset.v }), _jsxs(Text, { color: borderColor, children: [" ", padEndCells(clipCells(line, inner - 1), inner - 1)] }), _jsx(Text, { color: theme.table, children: charset.v })] }, i))), _jsxs(Text, { color: theme.table, bold: true, children: [charset.bl, charset.h.repeat(inner), charset.br] })] }));
+}
+/** Node id: any word char + unicode letters, optionally quoted label. */
+const MERMAID_NODE_RX = /([\p{L}\p{N}_]+)\s*(\[\s*(?:[^\]]*)\s*\]|\(\s*(?:[^)]*)\s*\)|\{\s*(?:[^}]*)\s*\}|\(\(\s*(?:[^)]*)\s*\)\))/gu;
+/** Node id with optional shape, so `A[Start] --> B{Valid?}` still parses. */
+const NODE_WITH_SHAPE = String.raw `([\p{L}\p{N}_]+)(?:\(\([^)]*\)\)|\[[^\]]*\]|\([^)]*\)|\{[^}]*\})?`;
+const MERMAID_EDGE_RX = new RegExp(NODE_WITH_SHAPE + String.raw `\s*(--?>?|-.->|==>|<--?>|x--?x|o--?o|---)\s*(?:\|([^|]*)\|)?\s*` + NODE_WITH_SHAPE, "gu");
+/** Strip surrounding shape brackets to get the label: "[Start]" → "Start". */
+function nodeLabel(shape) {
+    return shape.replace(/^[[({]+|[)\]}]+$/g, "").trim().replace(/^"|"$/g, "");
+}
+export function summarizeMermaid(source) {
+    const text = source.join("\n");
+    const typeMatch = /^\s*(\w+)/.exec(text);
+    const type = typeMatch?.[1] ?? "unknown";
+    if (/^(graph|flowchart)$/.test(type)) {
+        const nodeMap = new Map();
+        for (const m of text.matchAll(MERMAID_NODE_RX)) {
+            const label = nodeLabel(m[2] ?? "");
+            if (label)
+                nodeMap.set(m[1], label);
+        }
+        const edges = [];
+        for (const m of text.matchAll(MERMAID_EDGE_RX)) {
+            edges.push({ from: m[1], to: m[4], ...(m[3]?.trim() ? { label: m[3].trim() } : {}) });
+        }
+        const lines = [`flowchart · ${nodeMap.size} nodes · ${edges.length} edges`, ""];
+        for (const [id, label] of [...nodeMap.entries()].slice(0, 6)) {
+            lines.push(`◦ ${label}  (${id})`);
+        }
+        if (nodeMap.size > 6)
+            lines.push(`… ${nodeMap.size - 6} more nodes`);
+        const nameOf = (id) => nodeMap.get(id) ?? id;
+        for (const e of edges.slice(0, 8)) {
+            lines.push(`${nameOf(e.from)} → ${nameOf(e.to)}${e.label ? `  : ${e.label}` : ""}`);
+        }
+        if (edges.length > 8)
+            lines.push(`… ${edges.length - 8} more edges`);
+        return { type: "flowchart", supported: true, lines };
+    }
+    if (type === "sequenceDiagram") {
+        const aliases = new Map();
+        for (const m of text.matchAll(/(?:participant|actor)\s+([\p{L}\p{N}_]+)(?:\s+as\s+(.+))?/giu)) {
+            aliases.set(m[1], m[2]?.trim() ?? m[1]);
+        }
+        const messages = [];
+        for (const m of text.matchAll(/([\p{L}\p{N}_]+)\s*(?:->>|-->>|->|-->|-\)|--\))\s*([\p{L}\p{N}_]+)\s*:\s*(.+)/gu)) {
+            messages.push({ from: m[1], to: m[2], text: m[3].trim() });
+        }
+        const nameOf = (id) => aliases.get(id) ?? id;
+        const lines = [
+            `sequence · ${aliases.size} participants · ${messages.length} messages`,
+            "",
+        ];
+        if (aliases.size > 0)
+            lines.push(`participants: ${[...aliases.values()].slice(0, 6).join(", ")}`);
+        for (const msg of messages.slice(0, 8)) {
+            lines.push(`${nameOf(msg.from)} → ${nameOf(msg.to)}: ${msg.text}`);
+        }
+        if (messages.length > 8)
+            lines.push(`… ${messages.length - 8} more messages`);
+        return { type: "sequence", supported: true, lines };
+    }
+    const KNOWN_UNSUPPORTED = /^(stateDiagram|stateDiagram-v2|erDiagram|classDiagram|gitGraph|gantt|pie|journey|mindmap|timeline|quadrantChart|sankey|xychart-beta|block-beta|packet-beta|architecture-beta|requirementDiagram|C4Context)$/;
+    if (KNOWN_UNSUPPORTED.test(type)) {
+        return {
+            type,
+            supported: false,
+            lines: [`${type} — preview not supported for this diagram type`],
+        };
+    }
+    return {
+        type,
+        supported: false,
+        lines: [`${type || "unknown"} — unknown diagram type`],
+    };
+}
+const MERMAID_EXPORT_HINT = "export: npx @mermaid-js/mermaid-cli -i <file> -o out.svg";
+const MAX_SOURCE_LINES = 12;
+/** Mermaid block: structured summary box; unsupported types → source + note. */
+export function MermaidPreview({ source, width }) {
+    const summary = summarizeMermaid(source);
+    if (summary.supported) {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "  \u25C9 mermaid diagram" }), _jsx(ContentBox, { title: "\u25C8 diagram preview", lines: [...summary.lines, "", MERMAID_EXPORT_HINT], width: Math.min(width, 72), color: theme.mermaid })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { dimColor: true, children: ["  \u25C9 mermaid diagram \u2014 ", summary.lines[0]] }), source.slice(0, MAX_SOURCE_LINES).map((l, i) => (_jsxs(Text, { color: theme.mermaid, children: ["  ", clipCells(l, Math.max(8, width - 2))] }, i))), source.length > MAX_SOURCE_LINES && (_jsxs(Text, { dimColor: true, children: ["  \u2026 +", source.length - MAX_SOURCE_LINES, " more lines"] })), _jsxs(Text, { dimColor: true, children: ["  ", MERMAID_EXPORT_HINT] })] }));
+}
+// ── Chart fence ─────────────────────────────────────────────────────────────
+export function ChartPreview({ spec, width }) {
+    const chartWidth = Math.max(24, Math.min(72, width - 8));
+    const max = Math.max(...spec.data.map((p) => Math.abs(p.value)), 1);
+    const min = Math.min(...spec.data.map((p) => p.value), 0);
+    const range = Math.max(1, max - min);
+    const labelWidth = Math.min(14, Math.max(4, ...spec.data.map((p) => measure(p.label))));
+    const valueWidth = Math.max(1, ...spec.data.map((p) => String(p.value).length));
+    // Row = label + " " + marker + bar + " " + value ≤ chartWidth-3 (ContentBox
+    // padding) → plot budget = chartWidth - labelWidth - valueWidth - 6.
+    const plotWidth = Math.max(12, chartWidth - labelWidth - valueWidth - 6);
+    if (spec.type === "pie") {
+        const total = spec.data.reduce((sum, p) => sum + Math.max(0, p.value), 0) || 1;
+        const lines = spec.data.map((p) => {
+            const pct = Math.round((Math.max(0, p.value) / total) * 100);
+            // Row = label + " " + "NN%" + " " + bar ≤ chartWidth-3 → -9.
+            const barWidth = Math.max(1, chartWidth - labelWidth - 9);
+            const bar = charset.blockFull.repeat(Math.min(barWidth, Math.max(1, Math.round((pct / 100) * barWidth))));
+            return `${padEndCells(clipCells(p.label, labelWidth), labelWidth)} ${String(pct).padStart(3)}% ${bar}`;
+        });
+        return _jsx(ContentBox, { title: spec.title ?? "pie chart", lines: lines, width: chartWidth, color: theme.code });
+    }
+    const rows = spec.data.map((point) => {
+        const ratio = (point.value - min) / range;
+        const filled = Math.max(0, Math.min(plotWidth, Math.round(ratio * plotWidth)));
+        const bar = charset.blockFull.repeat(filled) + charset.blockEmpty.repeat(plotWidth - filled);
+        return `${padEndCells(clipCells(point.label, labelWidth), labelWidth)} ▌${bar} ${String(point.value).padStart(valueWidth)}`;
+    });
+    return _jsx(ContentBox, { title: spec.title ?? `${spec.type} chart`, lines: rows, width: chartWidth, color: theme.code });
+}
+// ── Timeline fence ──────────────────────────────────────────────────────────
+export function TimelinePreview({ events, width }) {
+    const detailWidth = Math.max(16, width - 18);
+    const icon = (status) => status === "done" ? charset.ok : status === "error" ? charset.fail : status === "active" ? charset.active : charset.pending;
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: theme.table, bold: true, children: [" timeline \u00B7 ", events.length, " event", events.length === 1 ? "" : "s"] }), events.map((event, i) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { color: event.status === "error" ? theme.error : event.status === "done" ? theme.success : theme.accent, bold: true, children: icon(event.status) }), _jsxs(Text, { dimColor: true, children: [" ", padEndCells(clipCells(event.time || "—", 16), 16), " "] }), _jsx(Text, { bold: true, children: clipCells(event.title, detailWidth) })] }), event.detail && _jsxs(Text, { dimColor: true, children: ["  ", i === events.length - 1 ? " " : charset.v, " ", clipCells(event.detail, detailWidth)] }), i < events.length - 1 && _jsxs(Text, { dimColor: true, children: ["  ", charset.v] })] }, i)))] }));
+}

package/dist/tui/markdown/inline-render.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from "ink";
+import { theme } from "../theme.js";
+import { tokenizeInline } from "./inline.js";
+/** Render inline markdown as nested Ink <Text> elements. */
+export function renderInline(text, keyPrefix) {
+    return tokenizeInline(text).map((token, i) => {
+        const key = `${keyPrefix}-${i}`;
+        switch (token.type) {
+            case "code":
+                return _jsx(Text, { color: theme.code, children: token.text }, key);
+            case "bold":
+                return _jsx(Text, { bold: true, children: token.text }, key);
+            case "italic":
+                return _jsx(Text, { italic: true, children: token.text }, key);
+            case "strike":
+                return _jsx(Text, { strikethrough: true, dimColor: true, children: token.text }, key);
+            case "link":
+                return (_jsxs(Text, { children: [_jsx(Text, { color: "blue", underline: true, children: token.text }), _jsxs(Text, { dimColor: true, children: [" (", token.url, ")"] })] }, key));
+            default:
+                return token.text;
+        }
+    });
+}

package/dist/tui/markdown/inline.js

@@ -0,0 +1,93 @@
+/** Placeholder chars (private use area) for escaped punctuation. */
+const ESCAPES = {
+    "\\*": "\uE000", "\\_": "\uE001", "\\`": "\uE002", "\\~": "\uE003",
+    "\\[": "\uE004", "\\]": "\uE005", "\\(": "\uE006", "\\)": "\uE007",
+    "\\\\": "\uE008", "\\|": "\uE009",
+};
+const UNESCAPE = new Map(Object.entries(UNESCAPE_MAP()));
+function UNESCAPE_MAP() {
+    const out = {};
+    for (const [k, v] of Object.entries({
+        "\uE000": "*", "\uE001": "_", "\uE002": "`", "\uE003": "~",
+        "\uE004": "[", "\uE005": "]", "\uE006": "(", "\uE007": ")",
+        "\uE008": "\\", "\uE009": "|",
+    }))
+        out[k] = v;
+    return out;
+}
+/** Escape `\X` sequences so tokenizers don't see the marker chars. */
+export function protectEscapes(text) {
+    let out = text;
+    for (const [esc, placeholder] of Object.entries(ESCAPES)) {
+        // replaceAll on literal backslash sequences
+        out = out.split(esc).join(placeholder);
+    }
+    return out;
+}
+/** Restore placeholder chars to their literal punctuation. */
+export function unprotect(text) {
+    let out = text;
+    for (const [placeholder, literal] of UNESCAPE) {
+        out = out.split(placeholder).join(literal);
+    }
+    return out;
+}
+/** Split text keeping code spans intact — returns raw segments for tables etc. */
+export function splitOutsideCodeSpans(text, delimiter) {
+    const protected_ = protectEscapes(text);
+    const out = [];
+    let current = "";
+    let inCode = false;
+    for (const ch of protected_) {
+        if (ch === "`")
+            inCode = !inCode;
+        if (ch === delimiter && !inCode) {
+            out.push(current);
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    out.push(current);
+    return out.map(unprotect);
+}
+/** Tokenize one line of inline markdown. */
+export function tokenizeInline(text) {
+    const src = protectEscapes(text);
+    const tokens = [];
+    // Order matters: code spans → links → bold → strike → italic.
+    const rx = /(`[^`\n]+`)|(\[[^\]\n]*\]\((?:[^()\n]|\([^()\n]*\))+\))|(\*\*[^*\n]+\*\*|__[^_\n]+__)|(~~[^~\n]+~~)|(\*[^*\n]+\*|_[^_\n]+_)/g;
+    let last = 0;
+    for (const m of src.matchAll(rx)) {
+        if (m.index > last)
+            tokens.push({ type: "text", text: unprotect(src.slice(last, m.index)) });
+        const tok = m[0];
+        if (m[1]) {
+            tokens.push({ type: "code", text: unprotect(tok.slice(1, -1)) });
+        }
+        else if (m[2]) {
+            const lm = /^\[([^\]\n]*)\]\(((?:[^()\n]|\([^()\n]*\))+)\)$/.exec(tok);
+            tokens.push({ type: "link", text: unprotect(lm?.[1] ?? ""), url: unprotect(lm?.[2] ?? "") });
+        }
+        else if (m[3]) {
+            tokens.push({ type: "bold", text: unprotect(tok.slice(2, -2)) });
+        }
+        else if (m[4]) {
+            tokens.push({ type: "strike", text: unprotect(tok.slice(2, -2)) });
+        }
+        else if (m[5]) {
+            tokens.push({ type: "italic", text: unprotect(tok.slice(1, -1)) });
+        }
+        last = m.index + tok.length;
+    }
+    if (last < src.length)
+        tokens.push({ type: "text", text: unprotect(src.slice(last)) });
+    return tokens.filter((t) => t.text !== "" || t.type === "link");
+}
+/** Plain-text content of inline markdown (markers stripped) — for measuring. */
+export function inlineToPlain(text) {
+    return tokenizeInline(text)
+        .map((t) => (t.type === "link" ? `${t.text} (${t.url})` : t.text))
+        .join("");
+}