kritya 0.8.2-beta

package/dist/ui/inline.js

@@ -0,0 +1,241 @@
+import stringWidth from "string-width";
+/**
+ * Inline markdown: bold, italic, code spans, links. Shared by every block type
+ * (headers, bullets, paragraphs, table cells) so emphasis markers never leak
+ * through as literal asterisks, and so column widths can be measured against
+ * what is actually shown rather than the source text.
+ */
+export function parseInline(s) {
+    const out = [];
+    let plain = "";
+    const flush = () => {
+        if (plain) {
+            out.push({ text: decodeEntities(plain) });
+            plain = "";
+        }
+    };
+    const push = (tokens, style) => {
+        flush();
+        for (const t of tokens)
+            out.push({ ...t, ...style });
+    };
+    let i = 0;
+    while (i < s.length) {
+        const rest = s.slice(i);
+        // Code spans win over everything else, so `**` inside one stays literal.
+        if (s[i] === "`") {
+            const end = s.indexOf("`", i + 1);
+            if (end > i + 1) {
+                flush();
+                out.push({ text: s.slice(i + 1, end), code: true });
+                i = end + 1;
+                continue;
+            }
+        }
+        // An emphasis run can't open right after a word or another marker, and
+        // can't be followed by a space — between them that keeps "2 * 3", "a*b",
+        // and glob patterns like **/*.ts from turning into stray italics, while
+        // still emphasising content that happens to be punctuation, like **+ / –**.
+        if (!/[*_\w]/.test(s[i - 1] ?? "")) {
+            const strong = rest.match(/^(\*\*|__)(?=\S)([\s\S]*?\S)\1/);
+            if (strong) {
+                push(parseInline(strong[2]), { bold: true });
+                i += strong[0].length;
+                continue;
+            }
+            const em = rest.match(/^\*(?=\S)([^*]*\S)\*/);
+            if (em) {
+                push(parseInline(em[1]), { italic: true });
+                i += em[0].length;
+                continue;
+            }
+        }
+        // Some providers cite sources as 【3†L1-L4】. Keep the reference, drop the
+        // internal span bookkeeping, which is unreadable and means nothing here.
+        const citation = rest.match(/^【(\d+)[†:][^】]*】/);
+        if (citation) {
+            flush();
+            out.push({ text: `[${citation[1]}]`, dim: true });
+            i += citation[0].length;
+            continue;
+        }
+        // Links keep their URL, dimmed — a terminal can't hide it behind the text.
+        const link = rest.match(/^\[([^\]]*)\]\((\S+?)(?:\s+"[^"]*")?\)/);
+        if (link) {
+            push(parseInline(link[1]), {});
+            out.push({ text: ` (${link[2]})`, dim: true });
+            i += link[0].length;
+            continue;
+        }
+        plain += s[i];
+        i++;
+    }
+    flush();
+    return mergeTokens(out);
+}
+const NAMED_ENTITIES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'",
+    nbsp: " ",
+    hellip: "…",
+    mdash: "—",
+    ndash: "–",
+    lsquo: "‘",
+    rsquo: "’",
+    ldquo: "“",
+    rdquo: "”",
+    times: "×",
+    bull: "•",
+    deg: "°",
+    check: "✓",
+};
+/**
+ * Models escape markdown-significant characters as HTML entities — `&#124;`
+ * for a pipe inside a table cell above all — and a terminal has no HTML layer
+ * to undo that. Decoded after the markup is parsed, so `&#42;` can't turn
+ * itself into emphasis, and never inside a code span.
+ */
+export function decodeEntities(s) {
+    if (!s.includes("&"))
+        return s;
+    return s.replace(/&(#x?[0-9a-f]+|[a-z]+);/gi, (match, body) => {
+        if (body[0] === "#") {
+            const code = Number(body[1] === "x" || body[1] === "X" ? `0x${body.slice(2)}` : body.slice(1));
+            return Number.isInteger(code) && code > 0 && code <= 0x10ffff
+                ? String.fromCodePoint(code)
+                : match;
+        }
+        return NAMED_ENTITIES[body.toLowerCase()] ?? match;
+    });
+}
+function mergeTokens(tokens) {
+    const merged = [];
+    for (const t of tokens) {
+        const last = merged[merged.length - 1];
+        if (last && sameStyle(last, t))
+            last.text += t.text;
+        else
+            merged.push({ ...t });
+    }
+    return merged;
+}
+function sameStyle(a, b) {
+    return (!!a.bold === !!b.bold &&
+        !!a.italic === !!b.italic &&
+        !!a.code === !!b.code &&
+        !!a.dim === !!b.dim);
+}
+export function tokensWidth(tokens) {
+    return tokens.reduce((n, t) => n + stringWidth(t.text), 0);
+}
+/** Cut a line to `width` display columns, marking it when something was lost. */
+export function truncateToWidth(text, width) {
+    if (width <= 0)
+        return "";
+    if (stringWidth(text) <= width)
+        return text;
+    let out = "";
+    let used = 0;
+    for (const ch of text) {
+        const w = stringWidth(ch);
+        if (used + w > width - 1)
+            break;
+        out += ch;
+        used += w;
+    }
+    return `${out}…`;
+}
+/** Display width of one line of markdown, ignoring the markup itself. */
+export function inlineWidth(s) {
+    return Math.max(0, ...s.split("\n").map((line) => tokensWidth(parseInline(line))));
+}
+/**
+ * Wrap to `width` display columns, honouring hard line breaks. Returns one
+ * token list per output line, each guaranteed to fit — table cells wrap
+ * themselves so the row never has to.
+ */
+export function wrapInline(s, width) {
+    const limit = Math.max(1, width);
+    const lines = [];
+    for (const segment of s.split("\n")) {
+        let cur = [];
+        let curWidth = 0;
+        let pendingSpace = false;
+        for (const word of toWords(parseInline(segment))) {
+            if (/^\s+$/.test(word.text)) {
+                if (curWidth)
+                    pendingSpace = true;
+                continue;
+            }
+            const pieces = splitToWidth(word.text, limit);
+            for (let k = 0; k < pieces.length; k++) {
+                const pieceWidth = stringWidth(pieces[k]);
+                if (curWidth && curWidth + (pendingSpace ? 1 : 0) + pieceWidth > limit) {
+                    lines.push(mergeTokens(cur));
+                    cur = [];
+                    curWidth = 0;
+                }
+                else if (pendingSpace) {
+                    // Carry the word's style onto the space so a run of styled words
+                    // merges back into a single token instead of fragmenting.
+                    cur.push({ ...word, text: " " });
+                    curWidth += 1;
+                }
+                pendingSpace = false;
+                cur.push({ ...word, text: pieces[k] });
+                curWidth += pieceWidth;
+                if (k < pieces.length - 1) {
+                    lines.push(mergeTokens(cur));
+                    cur = [];
+                    curWidth = 0;
+                }
+            }
+        }
+        lines.push(mergeTokens(cur));
+    }
+    return lines;
+}
+function toWords(tokens) {
+    const words = [];
+    for (const t of tokens) {
+        for (const piece of t.text.split(/(\s+)/)) {
+            if (piece)
+                words.push({ ...t, text: piece });
+        }
+    }
+    return words;
+}
+/**
+ * Hard-split a word too long to fit (a URL, a path) at a display-width
+ * boundary, preferring a separator near the end of the piece so a long URL
+ * breaks after a "/" instead of mid-segment.
+ */
+function splitToWidth(text, width) {
+    if (stringWidth(text) <= width)
+        return [text];
+    const pieces = [];
+    let cur = "";
+    let curWidth = 0;
+    let lastBreak = -1;
+    for (const ch of text) {
+        const w = stringWidth(ch);
+        if (curWidth + w > width && cur) {
+            // Only rewind to a separator if it doesn't waste much of the line.
+            const cut = lastBreak >= 0 && lastBreak >= Math.floor(cur.length * 0.6) ? lastBreak + 1 : cur.length;
+            pieces.push(cur.slice(0, cut));
+            cur = cur.slice(cut);
+            curWidth = stringWidth(cur);
+            lastBreak = -1;
+        }
+        cur += ch;
+        curWidth += w;
+        if (/[/\\?&=_.-]/.test(ch))
+            lastBreak = cur.length - 1;
+    }
+    if (cur)
+        pieces.push(cur);
+    return pieces;
+}

package/dist/ui/mermaid.js

@@ -0,0 +1,98 @@
+/**
+ * Minimal mermaid flowchart parser, scoped to what an LLM typically emits for
+ * a hierarchy explanation: `graph TD` / `graph LR` / `flowchart TD` with
+ * `id --> id2` or `id[Label] --> id2[Label2]` edges. Anything that isn't a
+ * single-rooted tree (multiple parents, cycles, unparsable lines) returns
+ * null so the caller can fall back to rendering the raw code block.
+ */
+const HEADER_RE = /^\s*(graph|flowchart)\s+(TD|TB|LR|RL|BT)\s*$/i;
+// id, or id[Label] / id(Label) / id{Label} / id((Label)) — brackets are
+// stripped, not matched by shape, since we only render text. Each bracket
+// type is matched separately (rather than a shared character class) so a
+// label containing the other kind of bracket, e.g. `[Cosmos (Universe)]`,
+// isn't cut short at its first inner paren.
+const NODE_RE = /^([A-Za-z0-9_-]+)(?:\[(.*)\]|\((.*)\)|\{(.*)\})?$/;
+const EDGE_RE = /^(.+?)\s*(?:-->|---|-\.->|==>)\s*(.+)$/;
+function parseNode(raw) {
+    const m = NODE_RE.exec(raw.trim());
+    if (!m)
+        return null;
+    const label = m[2] ?? m[3] ?? m[4];
+    return { id: m[1], label: label ?? m[1] };
+}
+/**
+ * Parses the body of a ```mermaid fence. Returns a tree if the graph has
+ * exactly one root and every node has at most one parent; otherwise null.
+ */
+export function parseMermaidTree(lines) {
+    const body = lines.map((l) => l.trim()).filter(Boolean);
+    if (!body.length)
+        return null;
+    if (!HEADER_RE.test(body[0]))
+        return null; // require an explicit graph/flowchart header to opt in
+    const start = 1;
+    const nodes = new Map();
+    const parentOf = new Map();
+    const order = [];
+    const ensure = (id, label) => {
+        let n = nodes.get(id);
+        if (!n) {
+            n = { id, label, children: [] };
+            nodes.set(id, n);
+            order.push(id);
+        }
+        else if (label !== id) {
+            n.label = label;
+        }
+        return n;
+    };
+    for (let i = start; i < body.length; i++) {
+        const line = body[i];
+        const edge = EDGE_RE.exec(line);
+        if (!edge)
+            return null; // not the simple edge-list subset we support
+        const from = parseNode(edge[1]);
+        const to = parseNode(edge[2]);
+        if (!from || !to)
+            return null;
+        const parent = ensure(from.id, from.label);
+        const child = ensure(to.id, to.label);
+        if (parentOf.has(child.id) && parentOf.get(child.id) !== parent.id)
+            return null; // multiple parents
+        if (child.id === parent.id)
+            return null; // self-loop
+        parentOf.set(child.id, parent.id);
+        if (!parent.children.includes(child))
+            parent.children.push(child);
+    }
+    const roots = order.filter((id) => !parentOf.has(id));
+    if (roots.length !== 1)
+        return null;
+    // Cycle check: walking from the root must reach every node exactly once.
+    const root = nodes.get(roots[0]);
+    const visited = new Set();
+    const stack = [root];
+    while (stack.length) {
+        const n = stack.pop();
+        if (visited.has(n.id))
+            return null;
+        visited.add(n.id);
+        stack.push(...n.children);
+    }
+    if (visited.size !== nodes.size)
+        return null;
+    return root;
+}
+/** Renders a tree as `tree`-style box-drawing lines. */
+export function renderMermaidTree(root) {
+    const lines = [root.label];
+    const walk = (node, prefix) => {
+        node.children.forEach((child, i) => {
+            const last = i === node.children.length - 1;
+            lines.push(`${prefix}${last ? "└─ " : "├─ "}${child.label}`);
+            walk(child, `${prefix}${last ? "   " : "│  "}`);
+        });
+    };
+    walk(root, "");
+    return lines;
+}

package/dist/ui/table.js

@@ -0,0 +1,148 @@
+// Render and format GitHub-flavored markdown tables in the terminal.
+import { inlineWidth } from "./inline.js";
+/** Gap between columns, in spaces. */
+export const COLUMN_GAP = 2;
+/** A column squeezed below this is unreadable — stack the table instead. */
+export const MIN_READABLE_COLUMN = 14;
+/** More columns than this and a grid is unreadable at any sane terminal width. */
+export const MAX_GRID_COLUMNS = 5;
+const DELIMITER_CELL = /^:?-+:?$/;
+/** Cells may carry their own line breaks: models emit <br> inside them constantly. */
+function normalizeCell(cell) {
+    return cell
+        .replace(/<br\s*\/?>/gi, "\n")
+        .split("\n")
+        .map((s) => s.trim())
+        .join("\n")
+        .trim();
+}
+export function splitRow(line) {
+    let s = line.trim();
+    if (s.startsWith("|"))
+        s = s.slice(1);
+    if (s.endsWith("|") && !s.endsWith("\\|"))
+        s = s.slice(0, -1);
+    const cells = [];
+    let cur = "";
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === "\\" && s[i + 1] === "|") {
+            cur += "|";
+            i++;
+            continue;
+        }
+        if (s[i] === "|") {
+            cells.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += s[i];
+    }
+    cells.push(cur);
+    return cells.map(normalizeCell);
+}
+export function isTableRow(line) {
+    return line.includes("|") && splitRow(line).length >= 2;
+}
+function isDelimiterRow(line) {
+    if (!line.includes("|"))
+        return false;
+    const cells = splitRow(line);
+    return cells.length >= 2 && cells.every((c) => DELIMITER_CELL.test(c));
+}
+function alignOf(cell) {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    if (left && right)
+        return "center";
+    if (right)
+        return "right";
+    return "left";
+}
+/**
+ * Recognise a GFM table starting at `lines[start]`. A delimiter row is
+ * required, so ordinary prose containing a pipe is never mistaken for one.
+ * Returns the index to resume parsing from.
+ */
+export function detectTable(lines, start) {
+    if (start + 1 >= lines.length)
+        return null;
+    if (!isTableRow(lines[start]) || !isDelimiterRow(lines[start + 1]))
+        return null;
+    const header = splitRow(lines[start]);
+    const delimiter = splitRow(lines[start + 1]);
+    if (delimiter.length !== header.length)
+        return null;
+    // Once the header and delimiter have committed, any following line with a
+    // pipe belongs to the table — including ragged ones with too few cells.
+    const rows = [];
+    let i = start + 2;
+    while (i < lines.length && lines[i].includes("|")) {
+        rows.push(fit(splitRow(lines[i]), header.length));
+        i++;
+    }
+    return { table: { header, rows, align: delimiter.map(alignOf) }, next: i };
+}
+function fit(cells, n) {
+    if (cells.length === n)
+        return cells;
+    if (cells.length > n) {
+        // Keep overflow visible rather than dropping it on the floor.
+        return [...cells.slice(0, n - 1), cells.slice(n - 1).join(" | ")];
+    }
+    return [...cells, ...Array(n - cells.length).fill("")];
+}
+/** What each column would take if nothing had to give. */
+function naturalWidths(table) {
+    return table.header.map((cell, c) => Math.max(inlineWidth(cell), ...table.rows.map((r) => inlineWidth(r[c] ?? "")), 1));
+}
+/**
+ * Column widths that fit `maxWidth` display columns. Over budget, the widest
+ * columns give ground first; their cells then wrap internally, which is what
+ * keeps the row itself from wrapping and destroying the alignment.
+ */
+export function columnWidths(table, maxWidth) {
+    const n = table.header.length;
+    const widths = naturalWidths(table);
+    const gaps = COLUMN_GAP * (n - 1);
+    const budget = Math.max(n, maxWidth - gaps);
+    const shrinkTo = (floor) => {
+        let total = widths.reduce((a, b) => a + b, 0);
+        while (total > budget) {
+            let idx = 0;
+            for (let i = 1; i < n; i++)
+                if (widths[i] > widths[idx])
+                    idx = i;
+            if (widths[idx] <= floor)
+                return;
+            widths[idx]--;
+            total--;
+        }
+    };
+    shrinkTo(8);
+    shrinkTo(1);
+    return widths;
+}
+/**
+ * Whether a grid is hopeless at this width. Judged against what the table
+ * actually needs, not a fixed terminal width — a two-column table of short
+ * cells reads fine in a narrow terminal, and a six-column one never does.
+ */
+export function shouldStack(table, maxWidth) {
+    if (table.header.length > MAX_GRID_COLUMNS)
+        return true;
+    const needed = naturalWidths(table).reduce((total, w) => total + Math.min(w, MIN_READABLE_COLUMN), COLUMN_GAP * (table.header.length - 1));
+    return needed > maxWidth;
+}
+/**
+ * While a response is still streaming, hold back a trailing run of table-ish
+ * lines that has not yet produced a delimiter row — otherwise it renders as
+ * raw pipes for a moment and then snaps into a grid.
+ */
+export function dropPartialTrailingTable(lines) {
+    let start = lines.length;
+    while (start > 0 && isTableRow(lines[start - 1]))
+        start--;
+    if (start === lines.length)
+        return lines;
+    return detectTable(lines, start) ? lines : lines.slice(0, start);
+}

package/dist/ui/toolOutputPreview.js

@@ -0,0 +1,34 @@
+import { truncateToWidth } from "./inline.js";
+/**
+ * Preview of tool output: a few lines by default, everything when verbose.
+ * Tabs are expanded first — `read` emits a padded line number and a tab, which
+ * the terminal takes to the next 8-column stop, leaving a ragged gap that made
+ * previews look broken. Lines are clipped rather than wrapped, so a preview
+ * stays the size it claims to be.
+ */
+export function toolOutputPreview(output, verbose, width, isError = false) {
+    const lines = output
+        .replace(/\s+$/, "")
+        .split("\n")
+        // The untrusted-content fence is an instruction to the model about how to
+        // treat what follows. It says nothing to the person reading the screen.
+        .filter((l) => !/^<<<(end_)?external_untrusted_content/i.test(l.trim()))
+        .map((l) => l.replace(/^(\s*\d+)\t/, "$1 ").replace(/\t/g, "  "));
+    while (lines.length && !lines[0].trim())
+        lines.shift();
+    // Drop indentation every line shares — `read` pads its line numbers to five
+    // columns, which is dead space in a preview that is already indented.
+    const common = Math.min(...lines.filter((l) => l.trim()).map((l) => /^ */.exec(l)[0].length), Infinity);
+    if (common > 0 && common < Infinity) {
+        for (let i = 0; i < lines.length; i++)
+            lines[i] = lines[i].slice(common);
+    }
+    if (verbose)
+        return lines.join("\n");
+    // A failure is exactly when the detail is worth the rows.
+    const keep = isError ? 8 : 3;
+    const head = lines.slice(0, keep).map((l) => truncateToWidth(l, width));
+    return lines.length > keep
+        ? `${head.join("\n")}\n… (+${lines.length - keep} lines · Ctrl+O)`
+        : head.join("\n");
+}