@cargo-ai/cli 1.0.125 → 1.0.127

package/build/commands/ask/input/prompt.js

@@ -1,5 +1,6 @@
 import * as readline from "node:readline";
-import { colors } from "../../runHandler.js";
+import { cellWidth, textCells } from "../../../utils/textWidth.js";
+import { clipToWidth, colors } from "../../runHandler.js";
 import { applyCompletion, ASK_COMPLETION_MENU_LIMIT, listCompletions, } from "./completer.js";
 /**
  * Ctrl-C on the Ask line.
@@ -37,6 +38,9 @@ initialLine = "") {
         let cursor = initialLine.length;
         let selected = 0;
         let painted = false;
+        // Rows between the ◆ row and the cursor. A line longer than the terminal
+        // wraps, and the next clear has to start from the ◆ row, not the cursor's.
+        let cursorRow = 0;
         let finished = false;
         const wasRaw = isTTYStream(input) ? input.isRaw === true : false;
         if (isTTYStream(input) === true) {
@@ -171,9 +175,13 @@ initialLine = "") {
             if (painted === false || process.stderr.isTTY !== true) {
                 return;
             }
-            // Cursor sits on the ◆ line; wipe from there through the menu below.
+            // Back up to the ◆ row; wipe from there through the menu below.
+            if (cursorRow > 0) {
+                process.stderr.write(`\x1B[${String(cursorRow)}A`);
+            }
             process.stderr.write("\r\x1B[J");
             painted = false;
+            cursorRow = 0;
         }
         function paint() {
             const matches = visibleMatches();
@@ -181,7 +189,16 @@ initialLine = "") {
                 selected = matches.length === 0 ? 0 : matches.length - 1;
             }
             clearFrame();
+            const columns = process.stderr.columns === undefined ? 80 : process.stderr.columns;
+            // The terminal wraps the line itself; this says where it ends up.
+            const end = layoutCells(`◆  ${line}`, columns);
             process.stderr.write(`${colors.cyan("◆")}  ${line}`);
+            // Text ending exactly at the edge leaves the cursor parked on that row
+            // until something is written. Step onto the next row so the count holds.
+            if (line.length > 0 && end.column === columns) {
+                process.stderr.write("\r\n");
+            }
+            let row = end.column === columns ? end.row + 1 : end.row;
             if (matches.length > 0) {
                 process.stderr.write("\n");
                 for (let index = 0; index < matches.length; index += 1) {
@@ -191,18 +208,25 @@ initialLine = "") {
                     }
                     const active = index === selected;
                     const bullet = active === true ? colors.cyan("●") : colors.dim("○");
-                    const label = active === true ? colors.cyan(hit) : colors.dim(hit);
+                    // One row each, or the count of rows to climb back is off.
+                    const text = clipToWidth(hit, columns - 5);
+                    const label = active === true ? colors.cyan(text) : colors.dim(text);
                     process.stderr.write(`${colors.dim("│")}  ${bullet} ${label}`);
                     if (index < matches.length - 1) {
                         process.stderr.write("\n");
                     }
                 }
-                // Return to the ◆ line so the next clearFrame / keystroke is correct.
-                process.stderr.write(`\x1B[${String(matches.length)}A`);
+                row += matches.length;
+            }
+            // Back to the cursor's cell inside the (possibly wrapped) line.
+            const at = layoutCells(`◆  ${line.slice(0, cursor)}`, columns);
+            const targetRow = at.column === columns ? at.row + 1 : at.row;
+            const targetColumn = (at.column === columns ? 0 : at.column) + 1;
+            if (row > targetRow) {
+                process.stderr.write(`\x1B[${String(row - targetRow)}A`);
             }
-            // Column after `◆  ` (3 visible cells) plus the cursor in the line.
-            const column = 3 + cursor + 1;
-            process.stderr.write(`\r\x1B[${String(column)}G`);
+            process.stderr.write(`\r\x1B[${String(targetColumn)}G`);
+            cursorRow = targetRow;
             painted = true;
         }
         function cleanup() {
@@ -232,3 +256,25 @@ initialLine = "") {
         }
     });
 }
+/**
+ * Where the terminal leaves the cursor after writing `text` from the start of
+ * a row: the row it is on, and how many columns of it are filled. A filled
+ * row stays the cursor's row until the next character, which is why `column`
+ * can equal `columns`.
+ *
+ * Walked character by character rather than divided out: an emoji or a CJK
+ * character takes two columns, and one that does not fit in the last column
+ * starts the next row and leaves that column empty.
+ */
+function layoutCells(text, columns) {
+    const position = { row: 0, column: 0 };
+    for (const cell of textCells(text)) {
+        const width = cellWidth(cell);
+        if (position.column + width > columns) {
+            position.row += 1;
+            position.column = 0;
+        }
+        position.column += width;
+    }
+    return position;
+}

package/build/commands/ask/input/slash.d.ts

@@ -6,7 +6,13 @@ export type SlashAction = {
     kind: "action";
     action: "exit" | "new" | "clear" | "pick-agent" | "cancel";
 };
-export type SlashResult = SlashCard | SlashAction;
+/** `/tools` or `/reasoning`, with the display asked for if one was given. */
+export type SlashDisplay = {
+    kind: "display";
+    setting: "tools" | "reasoning";
+    value: string | undefined;
+};
+export type SlashResult = SlashCard | SlashAction | SlashDisplay;
 /**
  * Parse a user line that starts with `/`. Anything else is prose for the agent.
  *

package/build/commands/ask/input/slash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slash.d.ts","sourceRoot":"","sources":["../../../../src/commands/ask/input/slash.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,YAAY,GAAG,QAAQ,CAAC;CAC5D,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,WAAW,CAAC;AAmBlD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAqDhE;AAED,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;gBAE3B,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;CAK1C"}
+{"version":3,"file":"slash.d.ts","sourceRoot":"","sources":["../../../../src/commands/ask/input/slash.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,YAAY,GAAG,QAAQ,CAAC;CAC5D,CAAC;AAEF,6EAA6E;AAC7E,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,OAAO,GAAG,WAAW,CAAC;IAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,YAAY,CAAC;AAqBjE;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CA+DhE;AAED,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;gBAE3B,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;CAK1C"}

package/build/commands/ask/input/slash.js

@@ -6,6 +6,8 @@ const HELP_TEXT = [
     "/clear    Start a fresh local session (no agent)",
     "/new      Same as /clear",
     "/agent    Pick a workspace agent, or Local workspace (default). Stays on this machine.",
+    "/tools    How tool calls show: full, collapsed (default), hidden",
+    "/reasoning  How thinking shows: full, auto-collapsed (default), collapsed, hidden",
     "/cancel   Explain how to stop a turn (press Ctrl-C while it runs)",
     "/exit     Leave without asking (same as an empty line)",
     "",
@@ -52,6 +54,14 @@ export function parseSlash(text) {
     if (command === "agent") {
         return { kind: "action", action: "pick-agent" };
     }
+    if (command === "tools" || command === "reasoning") {
+        const value = trimmed.split(/\s+/)[1];
+        return {
+            kind: "display",
+            setting: command,
+            value: value === undefined ? undefined : value.toLowerCase(),
+        };
+    }
     if (command === "cancel") {
         return { kind: "action", action: "cancel" };
     }

package/build/commands/ask/session/index.d.ts

@@ -1,5 +1,6 @@
 export { type ChatTurnClaim, claimChatTurn, proxyTokenDeadlineMs, } from "./claim.js";
+export { renderMarkdown } from "./markdown.js";
 export { type AskSessionOptions, doesChatExist, runAskPrint, runAskSession, } from "./run.js";
 export { ASK_THINKING_WORDS, pickThinkingWord } from "./thinking.js";
-export { displayPath, wrapLine } from "./tree.js";
+export { displayPath, showTurnStats, wrapLine } from "./tree.js";
 //# sourceMappingURL=index.d.ts.map

package/build/commands/ask/session/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/ask/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,aAAa,EACb,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,KAAK,iBAAiB,EACtB,aAAa,EACb,WAAW,EACX,aAAa,GACd,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/ask/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,aAAa,EACb,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EACL,KAAK,iBAAiB,EACtB,aAAa,EACb,WAAW,EACX,aAAa,GACd,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC"}

package/build/commands/ask/session/index.js

@@ -1,4 +1,5 @@
 export { claimChatTurn, proxyTokenDeadlineMs, } from "./claim.js";
+export { renderMarkdown } from "./markdown.js";
 export { doesChatExist, runAskPrint, runAskSession, } from "./run.js";
 export { ASK_THINKING_WORDS, pickThinkingWord } from "./thinking.js";
-export { displayPath, wrapLine } from "./tree.js";
+export { displayPath, showTurnStats, wrapLine } from "./tree.js";

package/build/commands/ask/session/markdown.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The model's markdown, drawn for the tree: headings, lists, quotes, code
+ * fences, rules and tables, with bold, italic, code and links inline.
+ *
+ * The block and table handling follows `@ai-sdk/tui`'s renderer
+ * (`src/tui/markdown.ts`). It is not exported from that package, and its
+ * output assumes it owns the whole width, so it is redone here around the
+ * rail: every line comes back already wrapped to `width`, because a line the
+ * terminal soft-wraps starts its next row at column zero, outside the tree.
+ *
+ * Styles are applied word by word rather than across a span. A colour code
+ * here ends with a full reset, so a bold phrase that wraps would lose its
+ * bold at the rail drawn in between.
+ *
+ * Exported for tests.
+ */
+export declare function renderMarkdown(text: string, width: number, tone?: MarkdownTone): string[];
+/** `dim` is for text that is not the answer, such as the model's reasoning. */
+export type MarkdownTone = "normal" | "dim";
+//# sourceMappingURL=markdown.d.ts.map

package/build/commands/ask/session/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../../src/commands/ask/session/markdown.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,YAAuB,GAC5B,MAAM,EAAE,CA6CV;AAED,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,KAAK,CAAC"}

package/build/commands/ask/session/markdown.js

@@ -0,0 +1,451 @@
+import { clipToCells, sliceToWidth, textCells, textWidth, } from "../../../utils/textWidth.js";
+import { colorize } from "../../runHandler.js";
+/**
+ * The model's markdown, drawn for the tree: headings, lists, quotes, code
+ * fences, rules and tables, with bold, italic, code and links inline.
+ *
+ * The block and table handling follows `@ai-sdk/tui`'s renderer
+ * (`src/tui/markdown.ts`). It is not exported from that package, and its
+ * output assumes it owns the whole width, so it is redone here around the
+ * rail: every line comes back already wrapped to `width`, because a line the
+ * terminal soft-wraps starts its next row at column zero, outside the tree.
+ *
+ * Styles are applied word by word rather than across a span. A colour code
+ * here ends with a full reset, so a bold phrase that wraps would lose its
+ * bold at the rail drawn in between.
+ *
+ * Exported for tests.
+ */
+export function renderMarkdown(text, width, tone = "normal") {
+    const lines = text.split("\n");
+    const output = [];
+    const cursor = { index: 0, inFence: false };
+    while (cursor.index < lines.length) {
+        const line = lines[cursor.index];
+        if (line === undefined) {
+            break;
+        }
+        if (FENCE.test(line) === true) {
+            cursor.inFence = cursor.inFence === false;
+            cursor.index += 1;
+            continue;
+        }
+        if (cursor.inFence === true) {
+            // Code keeps its shape: clipped, never re-flowed, behind a bar that
+            // sets it apart from the prose around it.
+            output.push(`${paint(CODE_BAR, "url", tone)}${paint(clipToCells(line.replace(/\t/g, "  "), width - CODE_BAR.length), "code", tone)}`);
+            cursor.index += 1;
+            continue;
+        }
+        const table = parseTable(lines, cursor.index);
+        if (table !== undefined) {
+            output.push(...renderTable(table, width, tone));
+            cursor.index = table.endIndex;
+            continue;
+        }
+        output.push(...renderBlockLine(line, width, tone));
+        cursor.index += 1;
+    }
+    return output;
+}
+const STYLE_CODES = {
+    plain: [],
+    bold: ["1"],
+    italic: ["3"],
+    code: ["36"],
+    link: ["4"],
+    url: ["2"],
+};
+const FENCE = /^\s*(```|~~~)/;
+const HEADING = /^#{1,6}\s+(.*)$/;
+const RULE = /^\s*([-*_])(\s*\1){2,}\s*$/;
+const LIST_ITEM = /^(\s*)([-+*]|\d+[.)])\s+(.*)$/;
+const QUOTE = /^\s*>\s?(.*)$/;
+/**
+ * Code, bold, italic and links. `_` only opens italics at a word boundary, so
+ * `snake_case_names` stay as written.
+ */
+const INLINE = /`([^`]+)`|\*\*(.+?)\*\*|__(.+?)__|(?<![\w*])\*(?![\s*])(.+?)(?<![\s*])\*(?![\w*])|(?<!\w)_(?![\s_])(.+?)(?<![\s_])_(?!\w)|\[([^\]]+)\]\(([^)\s]+)\)/g;
+const TABLE_COLUMN_GAP = "  ";
+const CODE_BAR = "▎ ";
+const STACKED_INDENT = "  ";
+/** How narrow a table column may be squeezed before it is left to overflow. */
+const MIN_TABLE_COLUMN_WIDTH = 6;
+function renderBlockLine(line, width, tone) {
+    if (line.trim() === "") {
+        return [""];
+    }
+    const heading = line.match(HEADING);
+    if (heading !== null) {
+        const words = parseInline(heading[1] === undefined ? "" : heading[1]);
+        return wrapWords(emphasize(words), width).map((row) => renderWords(row, tone));
+    }
+    if (RULE.test(line) === true) {
+        return [paint("─".repeat(Math.min(width, 40)), "url", tone)];
+    }
+    const item = line.match(LIST_ITEM);
+    if (item !== null) {
+        const indent = item[1] === undefined ? "" : item[1];
+        const marker = item[2] === undefined ? "-" : item[2];
+        const body = item[3] === undefined ? "" : item[3];
+        const bullet = /\d/.test(marker) === true ? marker : "•";
+        return renderHanging(`${indent}${bullet} `, parseInline(body), width, tone);
+    }
+    const quote = line.match(QUOTE);
+    if (quote !== null) {
+        const body = quote[1] === undefined ? "" : quote[1];
+        return wrapWords(parseInline(body), Math.max(1, width - 2)).map((row) => `${paint("│", "url", tone)} ${renderWords(row, tone)}`);
+    }
+    return wrapWords(parseInline(line), width).map((row) => renderWords(row, tone));
+}
+/** A list item: the marker on the first row, its width of indent after. */
+function renderHanging(prefix, words, width, tone) {
+    const rows = wrapWords(words, Math.max(1, width - textWidth(prefix)));
+    if (rows.length === 0) {
+        return [prefix.trimEnd()];
+    }
+    const pad = " ".repeat(prefix.length);
+    return rows.map((row, index) => `${index === 0 ? prefix : pad}${renderWords(row, tone)}`);
+}
+function parseInline(text) {
+    const pieces = [];
+    const cursor = { at: 0 };
+    for (const match of text.matchAll(INLINE)) {
+        const start = match.index === undefined ? cursor.at : match.index;
+        if (start > cursor.at) {
+            pieces.push({ text: text.slice(cursor.at, start), style: "plain" });
+        }
+        pieces.push(...inlineMatchPieces(match));
+        cursor.at = start + match[0].length;
+    }
+    if (cursor.at < text.length) {
+        pieces.push({ text: text.slice(cursor.at), style: "plain" });
+    }
+    return toWords(pieces);
+}
+function inlineMatchPieces(match) {
+    const [, code, bold, boldUnderscore, italic, italicUnderscore, label, url] = match;
+    if (code !== undefined) {
+        return [{ text: code, style: "code" }];
+    }
+    if (bold !== undefined) {
+        return [{ text: bold, style: "bold" }];
+    }
+    if (boldUnderscore !== undefined) {
+        return [{ text: boldUnderscore, style: "bold" }];
+    }
+    if (italic !== undefined) {
+        return [{ text: italic, style: "italic" }];
+    }
+    if (italicUnderscore !== undefined) {
+        return [{ text: italicUnderscore, style: "italic" }];
+    }
+    if (label !== undefined && url !== undefined) {
+        // A bare link is written `[url](url)`; saying it twice adds nothing.
+        if (label === url) {
+            return [{ text: label, style: "link", href: url }];
+        }
+        return [
+            { text: label, style: "link", href: url },
+            { text: ` (${url})`, style: "url" },
+        ];
+    }
+    return [{ text: match[0], style: "plain" }];
+}
+/** Split styled runs on whitespace, gluing runs that touch into one word. */
+function toWords(pieces) {
+    const words = [];
+    const state = { glued: false };
+    for (const piece of pieces) {
+        for (const part of piece.text.split(/(\s+)/)) {
+            if (part === "") {
+                continue;
+            }
+            if (/^\s+$/.test(part) === true) {
+                state.glued = false;
+                continue;
+            }
+            const last = words[words.length - 1];
+            if (state.glued === true && last !== undefined) {
+                last.push({ ...piece, text: part });
+            }
+            else {
+                words.push([{ ...piece, text: part }]);
+            }
+            state.glued = true;
+        }
+    }
+    return words;
+}
+/** Headings and table headers: everything plain becomes bold. */
+function emphasize(words) {
+    return words.map((word) => word.map((piece) => piece.style === "plain" ? { ...piece, style: "bold" } : piece));
+}
+function wordWidth(word) {
+    return word.reduce((total, piece) => total + textWidth(piece.text), 0);
+}
+function rowWidth(row) {
+    if (row.length === 0) {
+        return 0;
+    }
+    return (row.reduce((total, word) => total + wordWidth(word), 0) + row.length - 1);
+}
+/**
+ * Greedy wrap on spaces. A word wider than the line is cut, unlike the plain
+ * wrap in `tree.ts`: a table cell or a long URL left whole would overflow,
+ * and the terminal would wrap it off the rail.
+ */
+function wrapWords(words, width) {
+    const rows = [];
+    for (const word of words.flatMap((entry) => splitWord(entry, width))) {
+        const current = rows[rows.length - 1];
+        if (current === undefined ||
+            rowWidth(current) + 1 + wordWidth(word) > width) {
+            rows.push([word]);
+            continue;
+        }
+        current.push(word);
+    }
+    return rows;
+}
+function splitWord(word, width) {
+    if (wordWidth(word) <= width) {
+        return [word];
+    }
+    const chunks = [[]];
+    for (const piece of word) {
+        const remaining = { text: piece.text };
+        while (remaining.text.length > 0) {
+            const chunk = chunks[chunks.length - 1];
+            if (chunk === undefined) {
+                break;
+            }
+            const room = width - wordWidth(chunk);
+            if (room <= 0 && chunk.length > 0) {
+                chunks.push([]);
+                continue;
+            }
+            const fits = sliceToWidth(remaining.text, room);
+            // A two-column character with one column left: start the next row,
+            // unless this row is empty and the line is narrower than the character.
+            if (fits === "" && chunk.length > 0) {
+                chunks.push([]);
+                continue;
+            }
+            const taken = fits === "" ? textCells(remaining.text)[0] : fits;
+            if (taken === undefined) {
+                break;
+            }
+            chunk.push({ ...piece, text: taken });
+            remaining.text = remaining.text.slice(taken.length);
+        }
+    }
+    return chunks.filter((chunk) => chunk.length > 0);
+}
+function renderWords(row, tone) {
+    return row
+        .map((word) => word
+        .map((piece) => hyperlink(paint(piece.text, piece.style, tone), piece))
+        .join(""))
+        .join(" ");
+}
+/**
+ * OSC 8: the terminal shows `text` and opens `href` when it is clicked. Each
+ * word of a link is wrapped on its own, like its colour, so a link that wraps
+ * onto the next row stays clickable on both. Terminals without OSC 8 ignore
+ * the sequence, and the URL printed after the label still shows where it
+ * goes. Left out when stderr is not a terminal, along with the colours.
+ */
+function hyperlink(text, piece) {
+    if (piece.href === undefined || process.stderr.isTTY !== true) {
+        return text;
+    }
+    return `\x1B]8;;${piece.href}\x1B\\${text}\x1B]8;;\x1B\\`;
+}
+function paint(text, style, tone) {
+    const codes = tone === "dim" ? ["2", ...STYLE_CODES[style]] : STYLE_CODES[style];
+    if (codes.length === 0) {
+        return text;
+    }
+    return colorize(text, codes.join(";"));
+}
+function parseTable(lines, startIndex) {
+    const headerLine = lines[startIndex];
+    const separatorLine = lines[startIndex + 1];
+    if (headerLine === undefined || separatorLine === undefined) {
+        return undefined;
+    }
+    const header = parseTableCells(headerLine);
+    if (header === undefined || header.length < 2) {
+        return undefined;
+    }
+    const separator = parseTableCells(separatorLine);
+    if (separator === undefined || separator.length !== header.length) {
+        return undefined;
+    }
+    const alignments = parseTableAlignments(separator);
+    if (alignments === undefined) {
+        return undefined;
+    }
+    const rows = [];
+    const cursor = { index: startIndex + 2 };
+    while (cursor.index < lines.length) {
+        const line = lines[cursor.index];
+        const row = line === undefined ? undefined : parseTableCells(line);
+        if (row === undefined) {
+            break;
+        }
+        rows.push(Array.from({ length: header.length }, (_, index) => {
+            const cell = row[index];
+            return cell === undefined ? "" : cell;
+        }));
+        cursor.index += 1;
+    }
+    return { alignments, endIndex: cursor.index, header, rows };
+}
+function parseTableCells(line) {
+    const trimmed = line.trim();
+    if (trimmed.includes("|") === false) {
+        return undefined;
+    }
+    const inner = trimmed.replace(/^\|/, "").replace(/(?<!\\)\|$/, "");
+    const cells = [""];
+    for (let index = 0; index < inner.length; index += 1) {
+        const character = inner[index];
+        if (character === "\\" && inner[index + 1] === "|") {
+            cells[cells.length - 1] += "|";
+            index += 1;
+            continue;
+        }
+        if (character === "|") {
+            cells.push("");
+            continue;
+        }
+        cells[cells.length - 1] += character === undefined ? "" : character;
+    }
+    return cells.map((cell) => cell.trim());
+}
+function parseTableAlignments(cells) {
+    const alignments = [];
+    for (const cell of cells) {
+        const match = cell.match(/^(:)?-{3,}(:)?$/);
+        if (match === null) {
+            return undefined;
+        }
+        const [, left, right] = match;
+        if (left !== undefined && right !== undefined) {
+            alignments.push("center");
+        }
+        else if (right !== undefined) {
+            alignments.push("right");
+        }
+        else {
+            alignments.push("left");
+        }
+    }
+    return alignments;
+}
+/**
+ * Columns sized to their content, then the widest squeezed until the table
+ * fits beside the rail; a cell that no longer fits wraps inside its column.
+ */
+function renderTable(table, width, tone) {
+    const header = table.header.map((cell) => emphasize(parseInline(cell)));
+    const rows = table.rows.map((row) => row.map((cell) => parseInline(cell)));
+    const widths = fitColumns(table.alignments.map((_, column) => Math.max(3, ...[header, ...rows].map((row) => {
+        const cell = row[column];
+        return cell === undefined ? 0 : rowWidth(cell);
+    }))), width);
+    const tableWidth = widths.reduce((total, columnWidth) => total + columnWidth, 0) +
+        TABLE_COLUMN_GAP.length * (widths.length - 1);
+    // Too many columns to fit even squeezed: the terminal would wrap every row
+    // off the rail. One record per row reads better than six-column slivers.
+    if (tableWidth > width) {
+        return renderStackedTable(header, rows, width, tone);
+    }
+    return [
+        ...renderTableRow(header, widths, table.alignments, tone),
+        paint(widths
+            .map((columnWidth) => "─".repeat(columnWidth))
+            .join(TABLE_COLUMN_GAP), "url", tone),
+        ...rows.flatMap((row) => renderTableRow(row, widths, table.alignments, tone)),
+    ];
+}
+/**
+ * A table too wide for the screen, as one block per row:
+ *
+ *   Name: Acme
+ *   Industry: Software
+ *
+ *   Name: Globex
+ *   …
+ *
+ * Each field wraps with its continuation indented under the header.
+ */
+function renderStackedTable(header, rows, width, tone) {
+    // Only the header so far, mid-stream or for good: show the field names
+    // rather than nothing.
+    if (rows.length === 0) {
+        return wrapWords(header.flatMap((label, column) => column < header.length - 1 ? appendText(label, ",") : label), width).map((line) => renderWords(line, tone));
+    }
+    return rows.flatMap((row, index) => {
+        const fields = header.flatMap((label, column) => {
+            const cell = row[column];
+            if (cell === undefined || cell.length === 0) {
+                return [];
+            }
+            return wrapWords([...appendText(label, ":"), ...cell], Math.max(1, width - STACKED_INDENT.length)).map((line, at) => at === 0
+                ? renderWords(line, tone)
+                : `${STACKED_INDENT}${renderWords(line, tone)}`);
+        });
+        return index === 0 ? fields : ["", ...fields];
+    });
+}
+/** `Name` → `Name:`, the mark glued to the header's last word. */
+function appendText(label, mark) {
+    const last = label[label.length - 1];
+    if (last === undefined) {
+        return [];
+    }
+    return [...label.slice(0, -1), [...last, { text: mark, style: "bold" }]];
+}
+function fitColumns(natural, width) {
+    const widths = [...natural];
+    const available = width - TABLE_COLUMN_GAP.length * (widths.length - 1);
+    while (widths.reduce((total, columnWidth) => total + columnWidth, 0) > available) {
+        const widest = Math.max(...widths);
+        if (widest <= MIN_TABLE_COLUMN_WIDTH) {
+            break;
+        }
+        widths[widths.indexOf(widest)] = widest - 1;
+    }
+    return widths;
+}
+function renderTableRow(cells, widths, alignments, tone) {
+    const wrapped = widths.map((columnWidth, column) => {
+        const cell = cells[column];
+        return wrapWords(cell === undefined ? [] : cell, columnWidth);
+    });
+    const height = Math.max(1, ...wrapped.map((lines) => lines.length));
+    return Array.from({ length: height }, (_, line) => widths
+        .map((columnWidth, column) => {
+        const columnLines = wrapped[column];
+        const row = columnLines === undefined ? undefined : columnLines[line];
+        const alignment = alignments[column];
+        return alignCell(row === undefined ? [] : row, columnWidth, alignment === undefined ? "left" : alignment, tone);
+    })
+        .join(TABLE_COLUMN_GAP)
+        .trimEnd());
+}
+function alignCell(row, width, alignment, tone) {
+    const text = renderWords(row, tone);
+    const padding = Math.max(0, width - rowWidth(row));
+    if (alignment === "right") {
+        return `${" ".repeat(padding)}${text}`;
+    }
+    if (alignment === "center") {
+        const left = Math.floor(padding / 2);
+        return `${" ".repeat(left)}${text}${" ".repeat(padding - left)}`;
+    }
+    return `${text}${" ".repeat(padding)}`;
+}

package/build/commands/ask/session/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../../src/commands/ask/session/run.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAoD3C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAkHF;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAqBlB;AAyND;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC,CAsmB7B;AAED,wBAAsB,WAAW,CAAC,KAAK,EAAE;IACvC,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,IAAI,CAAC,CAqGhB"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../../src/commands/ask/session/run.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAkE3C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAwHF;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAqBlB;AAyND;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC,CA0zB7B;AAED,wBAAsB,WAAW,CAAC,KAAK,EAAE;IACvC,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,IAAI,CAAC,CAqGhB"}