@zenera/cli 1.1.19 → 1.1.21

package/dist/tui/wrap.js

@@ -93,8 +93,8 @@ export const CHROME_ROWS = 7;
  */
 export const THINKING_ROWS = 1;
 /** How much of the frame the work in flight may take. A branch is a box now,
- *  not a row, so a fan-out of two costs fourteen of these. */
-export const ACTIVITY_ROWS = 16;
+ *  not a row, so a fan-out of two costs twenty-two of these. */
+export const ACTIVITY_ROWS = 24;
 /** The width of the elapsed-time column every call row is drawn behind. */
 export const TIME_COL = 5;
 /**
@@ -114,8 +114,18 @@ export function budgetOf(rows, activity, thinking) {
     const tail = Math.min(Math.max(0, thinking), THINKING_ROWS, Math.max(0, rest - 1));
     return { activity: shown, thinking: tail, live: rest - tail, total };
 }
-/** The rows a branch box may spend on its own calls and its reasoning. */
-export const BRANCH_ROWS = 5;
+/** The rows a branch box may spend on its own calls, prose and reasoning. */
+export const BRANCH_ROWS = 9;
+/**
+ * The fewest a box is worth drawing at.
+ *
+ * One row per branch fit more of them on screen and said nothing about any of
+ * them: a box holding a single call is a label, and the reason it is a box at
+ * all is that what a branch just did and said is why it is doing this. Below
+ * six rows there is no *what it just did* — so a fork too wide to give every
+ * branch six is cut to the ones that fit and counted, which is `fitActivity`.
+ */
+export const BRANCH_MIN = 6;
 /** Rows a branch box spends on chrome: the title rule and the closing one. */
 export const BOX_CHROME = 2;
 /**
@@ -123,26 +133,51 @@ export const BOX_CHROME = 2;
  * activity region has to divide between them.
  *
  * Every branch gets the same number, because they are the same kind of thing
- * and a fan-out is read across, not down. A wide fork spends its rows on being
- * complete rather than on being detailed: eight branches showing one call each
- * is a picture of the fork, eight rows of one branch is not.
+ * and a fan-out is read across, not down.
  */
 export function branchRows(count, allowance) {
     if (count <= 0) {
         return 0;
     }
     const each = Math.floor(Math.max(0, allowance) / count) - BOX_CHROME;
-    return Math.max(1, Math.min(BRANCH_ROWS, each));
+    return Math.max(BRANCH_MIN, Math.min(BRANCH_ROWS, each));
 }
 /**
- * How wide the answer is drawn. A line of prose spanning a 200-column terminal
- * is measurably harder to read than one that stops, which is why every demo in
+ * How wide *prose* is drawn. A line spanning a 200-column terminal is
+ * measurably harder to read than one that stops, which is why every demo in
  * `examples/sdk/` puts its answer in a box of bounded width — the terminal is the
  * page, not the paragraph.
+ *
+ * `boxWidth` is what a whole answer is drawn at; this is the floor it starts from.
  */
 export function answerWidth(columns) {
     return Math.max(24, Math.min(columns - 4, 96));
 }
+/**
+ * How wide the box holding `text` has to be.
+ *
+ * Prose stops at the comfort width, but a fence and a table cannot be
+ * reflowed — fold a table row and the columns stop lining up, which is the one
+ * thing the table was for — so the box grows to hold the widest of them, as far
+ * as the terminal allows and no further.
+ */
+export function boxWidth(text, columns) {
+    let rigid = 0;
+    for (const block of blocksOf(text)) {
+        // A fence is drawn behind a `│ ` gutter; a table row is not.
+        const lines = block.kind === 'code'
+            ? (block.lines ?? []).map((l) => l.length + 6)
+            : block.kind === 'table'
+                ? textOf(block)
+                    .split('\n')
+                    .map((l) => l.length + 4)
+                : [];
+        for (const width of lines) {
+            rigid = Math.max(rigid, width);
+        }
+    }
+    return Math.max(answerWidth(columns), Math.min(Math.max(24, columns - 4), rigid));
+}
 // ---------------------------------------------------------------------------
 // Reading a payload
 // ---------------------------------------------------------------------------
@@ -349,32 +384,470 @@ export function gistOf(text, width) {
     const last = heads.at(-1)?.[1];
     return clip(last ?? tail, width);
 }
+// ---------------------------------------------------------------------------
+// Inline
+// ---------------------------------------------------------------------------
+/** What a backslash may turn back into ordinary text. */
+const ESCAPABLE = /[\\`*_~[\]()#+\-.!>|]/;
+/** Emphasis has to hug its own text, or `2 * 3 * 4` reads as arithmetic in italics. */
+const spacey = (ch) => ch === undefined || /\s/.test(ch);
+/** An underscore between word characters is part of the word: `snake_case_name`. */
+const wordy = (ch) => ch !== undefined && /[\p{L}\p{N}]/u.test(ch);
+/** Far past anything a model writes, and the thing that stops a pathological nest. */
+const NESTING = 4;
 /**
- * Splits an answer on ``` fences. Prose is left exactly as it was — the common
- * answer has no fence in it and comes back in one piece — but a fenced block is
- * the one thing a terminal must not reflow: its indentation is its meaning, and
- * wrapping it as prose destroys it.
+ * The inline markup of one block, resolved.
+ *
+ * Order is the correctness argument. Code is settled first and never entered
+ * again, which is why this is a scanner and not a chain of replaces: in
+ * "use `[a](b)` syntax" the brackets are prose, and no regex over the whole
+ * string can know that. Everything else recurses on the text between its own
+ * markers, so `**bold with `code` in it**` keeps both.
  */
-export function segmentsOf(text) {
+export function inlineOf(text, style = {}, depth = 0) {
     const out = [];
-    let current = { code: false, lines: [] };
-    const flush = () => {
-        if (current.lines.length) {
-            out.push(current);
+    let buffer = '';
+    const keep = () => {
+        if (buffer) {
+            out.push({ text: buffer, ...style });
+            buffer = '';
+        }
+    };
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === '\\' && ESCAPABLE.test(text[i + 1] ?? '')) {
+            buffer += text[i + 1];
+            i += 2;
+            continue;
+        }
+        if (ch === '`') {
+            const span = codeAt(text, i);
+            if (span) {
+                keep();
+                out.push({ text: span.text, ...style, code: true });
+                i = span.end;
+                continue;
+            }
+        }
+        if (depth < NESTING && (ch === '[' || (ch === '!' && text[i + 1] === '['))) {
+            const link = linkAt(text, i);
+            if (link) {
+                keep();
+                const inner = { ...style, ...(link.href ? { href: link.href } : {}) };
+                out.push(...inlineOf(link.label, inner, depth + 1));
+                i = link.end;
+                continue;
+            }
+        }
+        if (depth < NESTING && (ch === '*' || ch === '_' || ch === '~')) {
+            const marks = ch === '~' ? 2 : Math.min(runOf(text, i, ch), 2);
+            const close = marks === 2 || ch !== '~' ? closingAt(text, i, ch, marks) : undefined;
+            if (close !== undefined) {
+                keep();
+                // Strikethrough has no weight of its own here, so it resolves
+                // to its text: the markers were never meant to be read.
+                const added = ch === '~' ? {} : marks === 2 ? { bold: true } : { italic: true };
+                out.push(...inlineOf(text.slice(i + marks, close), { ...style, ...added }, depth + 1));
+                i = close + marks;
+                continue;
+            }
+        }
+        buffer += ch;
+        i += 1;
+    }
+    keep();
+    return out;
+}
+/** How many of `ch` run on from `at`. */
+function runOf(text, at, ch) {
+    let n = 0;
+    while (text[at + n] === ch) {
+        n += 1;
+    }
+    return n;
+}
+/**
+ * The code span opening at `at`, or nothing when its backticks never close.
+ *
+ * A run of n backticks closes on a run of exactly n, which is what lets a code
+ * span contain a backtick. One space either side of the content is padding for
+ * that case rather than text, so it comes off.
+ */
+function codeAt(text, at) {
+    const run = runOf(text, at, '`');
+    const fence = '`'.repeat(run);
+    let from = at + run;
+    for (;;) {
+        const found = text.indexOf(fence, from);
+        if (found < 0) {
+            return undefined;
         }
+        if (text[found + run] === '`') {
+            from = found + runOf(text, found, '`');
+            continue;
+        }
+        const body = text.slice(at + run, found);
+        const padded = body.length > 2 && body.startsWith(' ') && body.endsWith(' ');
+        return { text: padded ? body.slice(1, -1) : body, end: found + run };
+    }
+}
+/**
+ * Where the emphasis opened at `at` closes, or nothing.
+ *
+ * Two of CommonMark's flanking rules earn their keep and the rest do not: a
+ * marker that opens is followed by something other than a space, one that
+ * closes is preceded by something other than a space. Without them `a * b * c`
+ * is italic and every second multiplication in an answer goes missing.
+ */
+function closingAt(text, at, ch, marks) {
+    if (spacey(text[at + marks]) || (ch === '_' && wordy(text[at - 1]))) {
+        return undefined;
+    }
+    const mark = ch.repeat(marks);
+    let from = at + marks + 1;
+    while (from < text.length) {
+        const found = text.indexOf(mark, from);
+        if (found < 0) {
+            return undefined;
+        }
+        if (!spacey(text[found - 1]) && !(ch === '_' && wordy(text[found + marks]))) {
+            return found;
+        }
+        from = found + 1;
+    }
+    return undefined;
+}
+/** `[label](href)` or `![alt](href)` at `at`, or nothing when it is only a bracket. */
+function linkAt(text, at) {
+    const open = text[at] === '!' ? at + 1 : at;
+    let depth = 0;
+    let close = -1;
+    for (let i = open; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '\\') {
+            i += 1;
+        }
+        else if (ch === '[') {
+            depth += 1;
+        }
+        else if (ch === ']') {
+            depth -= 1;
+            if (depth === 0) {
+                close = i;
+                break;
+            }
+        }
+    }
+    if (close < 0 || text[close + 1] !== '(') {
+        return undefined;
+    }
+    const end = text.indexOf(')', close + 2);
+    if (end < 0) {
+        return undefined;
+    }
+    // `[label](url "title")` — the title is for a tooltip nothing here has.
+    const target = text
+        .slice(close + 2, end)
+        .trim()
+        .split(/\s+/)[0] ?? '';
+    return {
+        label: text.slice(open + 1, close),
+        href: target.replace(/^<|>$/g, ''),
+        end: end + 1,
+    };
+}
+// ---------------------------------------------------------------------------
+// Blocks
+// ---------------------------------------------------------------------------
+const FENCE = /^(\s*)(```+|~~~+)\s*(\S*)/;
+const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+const RULE = /^ {0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const QUOTE = /^ {0,3}>\s?(.*)$/;
+const ITEM = /^(\s*)(?:([-*+])|(\d{1,9})[.)])\s+(.*)$/;
+/** A markdown table row. Both pipes, so a sentence with one in it is still prose. */
+const TABLE_ROW = /^\s*\|.*\|\s*$/;
+/** A cell of the rule row under a header: dashes, and where the column is set. */
+const RULE_CELL = /^:?-+:?$/;
+/** What a bullet is drawn as, by how deep it is nested. */
+const BULLETS = ['\u2022', '\u25e6', '\u25aa'];
+/** Splits a row on the pipes that divide it, dropping the two that bound it. */
+function cellsOf(row) {
+    const out = [];
+    let cell = '';
+    for (let i = 0; i < row.length; i += 1) {
+        const ch = row[i];
+        // An escaped pipe is text, and stays escaped for the inline scan.
+        if (ch === '\\' && row[i + 1] === '|') {
+            cell += '\\|';
+            i += 1;
+        }
+        else if (ch === '|') {
+            out.push(cell);
+            cell = '';
+        }
+        else {
+            cell += ch;
+        }
+    }
+    out.push(cell);
+    return out.slice(1, -1).map((c) => c.trim());
+}
+/**
+ * The rows a table was written as, read into a grid.
+ *
+ * The rule row is not kept: what it said about alignment is kept instead, and
+ * `gridOf` draws a rule of the width the columns turn out to be. A table
+ * without one is still a table — models write them — it just has no header.
+ */
+function gatherTable(rows) {
+    const grid = rows.map(cellsOf);
+    const rule = grid[1];
+    const ruled = rule !== undefined && rule.length > 0 && rule.every((c) => RULE_CELL.test(c));
+    const body = ruled ? [grid[0], ...grid.slice(2)] : grid;
+    const columns = Math.max(0, ...body.map((row) => row.length));
+    return {
+        kind: 'table',
+        cells: body.map((row) => Array.from({ length: columns }, (_, i) => inlineOf(row[i] ?? ''))),
+        ...(ruled
+            ? {
+                align: Array.from({ length: columns }, (_, i) => (rule[i] ?? '').endsWith(':')
+                    ? rule[i].startsWith(':')
+                        ? 'center'
+                        : 'right'
+                    : 'left'),
+            }
+            : {}),
+    };
+}
+/** Takes back up to `by` columns of indent, and no more than the line has. */
+function dedent(line, by) {
+    let n = 0;
+    while (n < by && (line[n] === ' ' || line[n] === '\t')) {
+        n += 1;
+    }
+    return line.slice(n);
+}
+/**
+ * An answer, as the blocks it is made of.
+ *
+ * Read top down, one line at a time, because that is the order the text
+ * arrives in and a stream must be readable before it is finished. The two
+ * verbatim kinds win over everything: a pipe inside a fence is whatever the
+ * code says it is, and a `#` inside one is a comment, not a heading.
+ */
+export function blocksOf(text) {
+    const out = [];
+    let prose;
+    let fence;
+    let table;
+    const closeProse = () => {
+        if (prose) {
+            out.push({
+                kind: prose.kind,
+                ...(prose.level === undefined ? {} : { level: prose.level }),
+                ...(prose.marker === undefined ? {} : { marker: prose.marker }),
+                spans: inlineOf(prose.lines.join('\n').trim()),
+            });
+            prose = undefined;
+        }
+    };
+    const closeTable = () => {
+        if (table) {
+            out.push(gatherTable(table));
+            table = undefined;
+        }
+    };
+    const closeFence = () => {
+        if (fence) {
+            out.push({
+                kind: 'code',
+                ...(fence.title ? { title: fence.title } : {}),
+                lines: fence.lines,
+            });
+            fence = undefined;
+        }
+    };
+    const settle = () => {
+        closeProse();
+        closeTable();
     };
     for (const raw of text.split('\n')) {
-        const fence = /^\s*```+\s*(\S*)/.exec(raw);
-        if (!fence) {
-            current.lines.push(raw);
+        if (fence) {
+            if (raw.trimStart().startsWith(fence.marker)) {
+                closeFence();
+            }
+            else {
+                fence.lines.push(dedent(raw, fence.indent));
+            }
+            continue;
+        }
+        const opening = FENCE.exec(raw);
+        if (opening) {
+            settle();
+            fence = {
+                marker: opening[2].slice(0, 3),
+                indent: opening[1].length,
+                ...(opening[3] ? { title: opening[3] } : {}),
+                lines: [],
+            };
             continue;
         }
-        flush();
-        current = current.code
-            ? { code: false, lines: [] }
-            : { code: true, title: fence[1] || undefined, lines: [] };
+        // A blank line ends whatever was being gathered and is not itself a block.
+        if (!raw.trim()) {
+            settle();
+            continue;
+        }
+        if (TABLE_ROW.test(raw)) {
+            closeProse();
+            (table ??= []).push(raw.trim());
+            continue;
+        }
+        closeTable();
+        const heading = HEADING.exec(raw);
+        if (heading) {
+            closeProse();
+            out.push({
+                kind: 'heading',
+                level: heading[1].length,
+                spans: inlineOf(heading[2]),
+            });
+            continue;
+        }
+        // Before the item check, so `* * *` is a rule and not a list of one star.
+        if (RULE.test(raw)) {
+            closeProse();
+            out.push({ kind: 'rule' });
+            continue;
+        }
+        const quote = QUOTE.exec(raw);
+        if (quote) {
+            if (prose?.kind !== 'quote') {
+                closeProse();
+                prose = { kind: 'quote', lines: [] };
+            }
+            prose.lines.push(quote[1]);
+            continue;
+        }
+        const item = ITEM.exec(raw);
+        if (item) {
+            closeProse();
+            const level = Math.min(BULLETS.length - 1, Math.floor(item[1].length / 2));
+            const number = item[3];
+            prose = {
+                kind: 'item',
+                level,
+                marker: number ? `${number}.` : BULLETS[level],
+                lines: [item[4]],
+            };
+            continue;
+        }
+        // A line under an item belongs to it; a line under nothing starts a paragraph.
+        if (prose) {
+            prose.lines.push(raw.trim());
+        }
+        else {
+            prose = { kind: 'paragraph', lines: [raw] };
+        }
     }
-    flush();
+    settle();
+    closeFence();
     return out;
 }
+// ---------------------------------------------------------------------------
+// Back to text
+// ---------------------------------------------------------------------------
+/** What a run of spans measures, which is the text and never the styling. */
+const lengthOf = (spans) => spans.reduce((n, s) => n + s.text.length, 0);
+/** A cell in its column, set where the rule row asked for it. */
+function padOf(spans, width, align) {
+    const slack = Math.max(0, width - lengthOf(spans));
+    const lead = align === 'right' ? slack : align === 'center' ? Math.floor(slack / 2) : 0;
+    return [
+        ...(lead > 0 ? [{ text: ' '.repeat(lead) }] : []),
+        ...spans,
+        ...(slack > lead ? [{ text: ' '.repeat(slack - lead) }] : []),
+    ];
+}
+/**
+ * A table as its rows, each one a single run of spans.
+ *
+ * Columns are laid out here and nowhere else, so the drawn table and the plain
+ * one are the same table: a cell's width is the length of its text, which is
+ * what a `Span` measures whatever styling rides beside it. Nothing a model
+ * writes in a cell can move the cell after it.
+ */
+export function gridOf(block) {
+    const cells = block.cells ?? [];
+    const count = Math.max(0, ...cells.map((row) => row.length));
+    if (count === 0) {
+        return [];
+    }
+    const widths = Array.from({ length: count }, (_, i) => Math.max(3, ...cells.map((row) => lengthOf(row[i] ?? []))));
+    const rows = cells.map((row) => {
+        const out = [];
+        widths.forEach((width, i) => {
+            out.push({ text: i === 0 ? '| ' : ' | ' });
+            out.push(...padOf(row[i] ?? [], width, block.align?.[i] ?? 'left'));
+        });
+        out.push({ text: ' |' });
+        return out;
+    });
+    if (block.align && rows.length > 0) {
+        rows.splice(1, 0, [{ text: `|${widths.map((w) => '-'.repeat(w + 2)).join('|')}|` }]);
+    }
+    return rows;
+}
+/**
+ * A block as the row or rows it reads as, with its markers resolved rather
+ * than shown, and nothing styled.
+ *
+ * This is what a sink that cannot style gets — the pre-answer stream, and the
+ * plain box `zen meta` draws — so that the text does not visibly change shape
+ * at the moment it settles.
+ */
+export function textOf(block, width = 0) {
+    if (block.kind === 'code') {
+        // The same chrome the settled answer draws, so a fence that is still
+        // arriving is already the shape it will end up as.
+        return [
+            `\u250c\u2500${block.title ? ` ${block.title}` : ''}`,
+            ...(block.lines ?? []).map((l) => `\u2502 ${l}`),
+            '\u2514\u2500',
+        ].join('\n');
+    }
+    if (block.lines) {
+        return block.lines.join('\n');
+    }
+    if (block.kind === 'table') {
+        return gridOf(block)
+            .map((row) => row.map((s) => s.text).join(''))
+            .join('\n');
+    }
+    if (block.kind === 'rule') {
+        return '\u2500'.repeat(Math.max(3, width));
+    }
+    const body = (block.spans ?? []).map((s) => s.text).join('');
+    if (block.kind === 'item') {
+        return `${'  '.repeat(block.level ?? 0)}${block.marker ?? BULLETS[0]} ${body}`;
+    }
+    if (block.kind === 'quote') {
+        return `\u2502 ${body}`;
+    }
+    return body;
+}
+/** A whole answer with its markup resolved instead of shown. Still plain text. */
+export function unmarked(text, width = 0) {
+    const rows = [];
+    let previous;
+    for (const block of blocksOf(text)) {
+        // Items of one list are one thing; a blank row between them is two lists.
+        if (previous && !(block.kind === 'item' && previous.kind === 'item')) {
+            rows.push('');
+        }
+        rows.push(textOf(block, width));
+        previous = block;
+    }
+    return rows.join('\n');
+}
 //# sourceMappingURL=wrap.js.map