@vincemakes/kiso-tui-cells 0.10.0 → 0.12.0

package/dist/components.d.ts

@@ -18,6 +18,8 @@
  * tint, fold wording).
  */
 import { foldThinking, foldResult, renderToolSummary, type ResumeMeta } from "./render.js";
+import { type MdBlock } from "./md.js";
+export { MdStream, renderBlock, renderMarkdown, type MdBlock, type MdKind } from "./md.js";
 /** The spinner glyphs, cycled by the compositor's on-demand tick. */
 export declare const SPINNER: string[];
 /** The frame context the compositor passes down — the pieces of time
@@ -43,8 +45,12 @@ export type RenderLine = string;
  */
 export declare function foldLine(line: string, W: number): string[];
 /** The visible width of a rendered line (SGR stripped — the invariant
- *  the compositor enforces on every emitted line). */
-export declare function visibleWidth(line: string): number;
+ *  the compositor enforces on every emitted line). TUI2-MD ⑤: the body
+ *  moved to width.ts (the width authority's own home) so the markdown
+ *  renderer can measure without importing this module back — the
+ *  re-export is verbatim, so every existing importer and the barrel see
+ *  exactly what they saw. */
+export { visibleWidth } from "./width.js";
 /** A component: render the display lines for one piece of state. */
 export interface Component {
     render(width: number, ctx: FrameCtx): string[];
@@ -145,6 +151,18 @@ export type BodyCell = {
     kind: "text";
     text: string;
     done: boolean;
+}
+/** TUI2-MD ⑤ — ONE markdown block of assistant body text. The cell is
+ *  the commit unit the compositor already had, so block-freeze needs
+ *  no new commit machinery: a CLOSED block is a DONE cell and the
+ *  natural loop freezes it; the OPEN tail block is the one cell left
+ *  live. `block` carries the block's SOURCE (never rendered rows), so
+ *  a resize re-renders it at the new width exactly as every other
+ *  cell does. */
+ | {
+    kind: "md";
+    block: MdBlock;
+    done: boolean;
 } | {
     kind: "notice";
     text: string;
@@ -332,6 +350,34 @@ export declare function statusLine(status: string, tail: string, W: number, hint
 /** The display-width prefix of a plain (SGR-free) text. W21: exported
  *  for the approval panel's option-2 rule-name cut. */
 export declare function widthCut(text: string, max: number): string;
+/**
+ * TUI2-R3v2 ① — THE selection bar. One engine, every selection surface.
+ *
+ * The R1.5 ⑧ ruling settled the shape (a full-row reverse bar, not a
+ * two-cell marker you have to hunt for in eighty columns) and the @
+ * picker, the user chip and the R2 session picker each grew their own
+ * copy of the composition. The approval panel would have been the
+ * fourth, so the composition moves HERE and the surfaces call it.
+ *
+ * Two details are the whole reason this is a function and not four
+ * inlined string templates:
+ *
+ *  - the inner `reset`s are rewritten to reset-then-reverse. A plain SGR
+ *    0 inside the bar punches a hole in it: the row goes back to normal
+ *    video mid-span and the bar reads as two bars with a gap. The close
+ *    is SGR 27 (rvEnd), never SGR 0, for the same reason — the bar
+ *    composes INSIDE whatever span surrounds it.
+ *  - the pad is computed from the caller's measured VISIBLE width, never
+ *    from the styled string's length. A bar that stops short is not a
+ *    bar, and one that runs past W crashes the compositor's invariant ①
+ *    rather than truncating quietly — so the arithmetic is stated once,
+ *    here, and proven once, in the sweep gates.
+ *
+ * The bar spends one cell of frame at each end, so callers build their
+ * spans against W−2 whether the row is selected or not — which is what
+ * keeps the columns from moving as the bar walks the list.
+ */
+export declare function selectionBar(styled: string, visible: number, W: number): string;
 /** W6 — the box: the chrome's top rail. The two ╌ dotted rows become
  *  a rounded box (the box already says "input lives here"); the rails
  *  stay dim, the width is still the full W (the box is a rail with

package/dist/components.js

@@ -17,12 +17,18 @@
  * (untouched); render.ts supplies the original text (palette, escape,
  * tint, fold wording).
  */
-import { displayWidth } from "./width.js";
+import { displayWidth, visibleWidth } from "./width.js";
 // TUI2-R2pre ④: the ONE display-verb table (strings.ts, beside
 // KEY_BINDINGS). strings.js imports only render/width here, so this edge
 // adds no cycle.
 import { displayVerb } from "./strings.js";
 import { bannerLines, escapeTerminal, foldThinking, foldResult, colorInlineCode, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, } from "./render.js";
+// TUI2-MD: the markdown renderer's surface reaches the tui through this
+// module (the tui's components shim re-exports it) — one import edge,
+// and it points one way: md.ts measures with the width authority, never
+// back through here.
+import { renderBlock } from "./md.js";
+export { MdStream, renderBlock, renderMarkdown } from "./md.js";
 /** The spinner glyphs, cycled by the compositor's on-demand tick. */
 export const SPINNER = ["▖", "▘", "▝", "▗"];
 /**
@@ -94,24 +100,12 @@ export function foldLine(line, W) {
     return out;
 }
 /** The visible width of a rendered line (SGR stripped — the invariant
- *  the compositor enforces on every emitted line). */
-export function visibleWidth(line) {
-    let w = 0;
-    for (let i = 0; i < line.length;) {
-        if (line[i] === "\x1b") {
-            const m = /^\x1b\[[0-9;?]*[A-Za-z]/.exec(line.slice(i));
-            if (m !== null) {
-                i += m[0].length;
-                continue;
-            }
-            i += 1;
-            continue;
-        }
-        w += displayWidth(line[i]);
-        i += 1;
-    }
-    return w;
-}
+ *  the compositor enforces on every emitted line). TUI2-MD ⑤: the body
+ *  moved to width.ts (the width authority's own home) so the markdown
+ *  renderer can measure without importing this module back — the
+ *  re-export is verbatim, so every existing importer and the barrel see
+ *  exactly what they saw. */
+export { visibleWidth } from "./width.js";
 /** The W11 spacing formula — "a row gets one blank line above it when
  *  the row is itself a block, or when the previous sibling was taller
  *  than one row". One-row siblings pack tight; anything multi-row
@@ -160,6 +154,8 @@ export function cellComponent(cell) {
             return new ToolExecution(cell);
         case "text":
             return new AssistantMessage(cell);
+        case "md":
+            return new MarkdownBlock(cell);
         case "notice":
             return new ErrorLine(cell);
         case "banner":
@@ -1190,6 +1186,20 @@ class AssistantMessage {
         return wrapped.length > 0 ? wrapped.map((l) => colorInlineCode(l)) : [""];
     }
 }
+/** TUI2-MD ⑤ — one markdown block. Pure in (block, W): the same source
+ *  and the same width give the same bytes, which is the freeze property
+ *  the commit path relies on. The block carries its own leading blank
+ *  (the style table's rhythm), so the compositor's W11 join formula
+ *  steps aside between two of these. */
+class MarkdownBlock {
+    cell;
+    constructor(cell) {
+        this.cell = cell;
+    }
+    render(W, _ctx) {
+        return renderBlock(this.cell.block, W);
+    }
+}
 /** The ⚠ / notice lines — the error surface. */
 class ErrorLine {
     cell;
@@ -1401,6 +1411,38 @@ export function widthCut(text, max) {
     }
     return text.slice(0, i);
 }
+/**
+ * TUI2-R3v2 ① — THE selection bar. One engine, every selection surface.
+ *
+ * The R1.5 ⑧ ruling settled the shape (a full-row reverse bar, not a
+ * two-cell marker you have to hunt for in eighty columns) and the @
+ * picker, the user chip and the R2 session picker each grew their own
+ * copy of the composition. The approval panel would have been the
+ * fourth, so the composition moves HERE and the surfaces call it.
+ *
+ * Two details are the whole reason this is a function and not four
+ * inlined string templates:
+ *
+ *  - the inner `reset`s are rewritten to reset-then-reverse. A plain SGR
+ *    0 inside the bar punches a hole in it: the row goes back to normal
+ *    video mid-span and the bar reads as two bars with a gap. The close
+ *    is SGR 27 (rvEnd), never SGR 0, for the same reason — the bar
+ *    composes INSIDE whatever span surrounds it.
+ *  - the pad is computed from the caller's measured VISIBLE width, never
+ *    from the styled string's length. A bar that stops short is not a
+ *    bar, and one that runs past W crashes the compositor's invariant ①
+ *    rather than truncating quietly — so the arithmetic is stated once,
+ *    here, and proven once, in the sweep gates.
+ *
+ * The bar spends one cell of frame at each end, so callers build their
+ * spans against W−2 whether the row is selected or not — which is what
+ * keeps the columns from moving as the bar walks the list.
+ */
+export function selectionBar(styled, visible, W) {
+    const p = palette();
+    const inner = styled.replaceAll(p.reset, `${p.reset}${p.rv}`);
+    return `${p.rv} ${inner}${" ".repeat(Math.max(0, W - visible - 2))} ${p.rvEnd}`;
+}
 /** W6 — the box: the chrome's top rail. The two ╌ dotted rows become
  *  a rounded box (the box already says "input lives here"); the rails
  *  stay dim, the width is still the full W (the box is a rail with

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cel
 export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";
 export { pendingQueueRows } from "./components.js";
 export { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
-export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, type PanelArgs, type PanelFlavor, type PanelPhase, type PanelSel, type PanelState, type PanelVerdict, type PanelView, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, } from "./approval-panel.js";
+export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, type PanelArgs, type PanelFlavor, type PanelPhase, deletionRiskHint, SAFER_BACK, SAFER_DEGRADED, type SaferOption, type SaferRuntime, panelOptions, type PanelOption, type PanelOptionKind, type PanelState, type PanelVerdict, type PanelView, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, } from "./approval-panel.js";
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, type TrustArtifact, } from "./strings.js";
 export { extensionsBannerText, helpRows, unansweredAskView, type BannerExtension } from "./strings.js";
 export { displayVerb } from "./strings.js";

package/dist/index.js

@@ -17,7 +17,7 @@ export { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 // that replaces the running tool's live window while a human-chain
 // approval is pending. Types + the row/lead/status renderers; the
 // verdict mapping lives in the cli, never here.
-export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, } from "./approval-panel.js";
+export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, deletionRiskHint, SAFER_BACK, SAFER_DEGRADED, panelOptions, } from "./approval-panel.js";
 // KC3 slice 1 (the extraction): the human-facing strings the CLI's
 // trust-ui.ts used to build inline — the prompt, the project-trust
 // listing/view/note, the uncertain execution's view. The flow stays in

package/dist/md.d.ts

@@ -0,0 +1,137 @@
+/**
+ * TUI2-MD — the markdown renderer. Hand-rolled, zero dependencies, and
+ * deliberately a SUBSET: the constructs assistant prose actually uses,
+ * rendered under the mono discipline (attributes over colours, zero
+ * syntax highlighting).
+ *
+ * THE BLOCK-FREEZE DISCIPLINE. kiso's committed bytes are never
+ * re-emitted (ADR-0046) — the terminal's own scrollback is the
+ * transcript. A renderer that re-lexes the whole message per delta (the
+ * shape a whole-text parser forces on you) can therefore not be used
+ * here at all: it would need to repaint lines that have already left
+ * the live region. So the scanner below IS the streaming state machine.
+ * It consumes appended text and yields two things:
+ *
+ *   - CLOSED blocks: their source is final, so their render is final;
+ *     the compositor commits them through the path it already had.
+ *   - the OPEN TAIL block: the live region's occupant, re-rendered in
+ *     place per delta, bounded by construction (one block).
+ *
+ * The freeze property — a closed block's rendered lines never change as
+ * more text arrives — is earned by ONE rule: block boundaries are
+ * decided only on COMPLETE lines. A trailing partial line renders
+ * eagerly but can never close anything, because a decision taken on an
+ * incomplete line can be wrong ("#" is a heading until it becomes
+ * "#hashtag") and a wrong decision here is a wrong commit.
+ *
+ * Everything else follows: an unclosed `**` renders literal and flips
+ * when it closes, but only ever inside the open block; a fence body
+ * line is line-local (no highlighting means no cross-line lexer state),
+ * so it closes the instant its newline arrives and long code blocks
+ * never bloat the live region; a table re-layouts as rows stream, and
+ * only inside the tail.
+ *
+ * The style table is the round's normative one (the owner's circled
+ * group D): the BLOCK half is `blockBody` below, the INLINE half is
+ * `inlineSpans`, and every entry is pinned by a fixture rather than
+ * described twice.
+ */
+/** The block kinds. `fence-open`/`fence-line` are separate kinds on
+ *  purpose: a fence's rows must be able to freeze ONE AT A TIME. */
+export type MdKind = "para" | "heading" | "list" | "table" | "quote" | "rule" | "fence-open" | "fence-line";
+/** One block: its SOURCE lines, never a rendered form. The render is a
+ *  pure function of (block, width), which is what makes the freeze
+ *  property a property of the scanner alone. */
+export interface MdBlock {
+    readonly kind: MdKind;
+    readonly lines: readonly string[];
+    /** a blank row precedes this block — the markdown rhythm, owned here
+     *  rather than by the compositor's W11 join formula (which reads row
+     *  COUNTS and so cannot express "no blank between two rows of one
+     *  fence"). */
+    readonly gap: boolean;
+    /** the fence's language tag; "" everywhere else. */
+    readonly lang: string;
+}
+export declare class MdStream {
+    #private;
+    /** Append streamed text. Only COMPLETE lines reach the state machine. */
+    push(text: string): void;
+    /** The message ended: the trailing partial line is a complete line
+     *  after all, and the open block closes. */
+    end(): void;
+    /** Every block so far: `closed()` of them are FINAL, and at most one
+     *  open tail follows. Fresh objects — a closed block's source can
+     *  never be reached through this. */
+    blocks(): readonly MdBlock[];
+    /** How many leading blocks are CLOSED — the commit-eligible count. */
+    closed(): number;
+}
+/** The whole message at once — the freeze property's oracle, and the
+ *  path a non-streaming caller takes. */
+export declare function renderMarkdown(text: string, W: number): string[];
+/** One block's screen rows. Pure in (block, W) — this is the whole
+ *  freeze guarantee: same source, same width, same bytes, forever. */
+export declare function renderBlock(b: MdBlock, W: number): string[];
+/**
+ * The inline pass — the mono style table applied to one block's text.
+ *
+ * Scoped to `**bold**`, `*italic*`, `` `code` ``, `[text](url)` and the
+ * backslash escape, with two rules that matter more than coverage:
+ *
+ *   RAW UNTIL CLOSED — an opener with no closer in this text stays
+ *   literal. That is what lets a half-streamed `**` show its asterisks
+ *   and flip the instant the closer lands, inside the live block and
+ *   nowhere else.
+ *
+ *   CLOSE BACK TO `base` — the block's own style (a heading's bold, a
+ *   quote's dim) is passed in, and every span reopens it on the way
+ *   out, so a nested span can never strand it. Italic is the one span
+ *   that closes surgically (SGR 23), because it can.
+ *
+ * Documented deviations from CommonMark: `_` never emphasizes (it is a
+ * character in identifiers far more often than a marker in prose);
+ * emphasis does not nest across a code span; `~~` is not a construct at
+ * all — the markers are content (the strict tokenizer both reference
+ * implementations converged on, taken to its honest conclusion, since
+ * SGR 9's terminal support is too fragmented to promise).
+ */
+export declare function inlineSpans(text: string, base: string): string;
+/** Split a table line into cells. The `|` walls are found on the RAW
+ *  line, but a pipe INSIDE a code span is content — two independent
+ *  reference implementations both patched exactly this, because a
+ *  command in a cell (`grep a | wc`) is common and splitting it puts
+ *  the human's own text in the wrong column. A backslash-escaped pipe
+ *  is content too. */
+export declare function splitCells(line: string): string[];
+export type MdAlign = "left" | "center" | "right";
+export interface MdTable {
+    readonly header: readonly string[];
+    readonly align: readonly MdAlign[];
+    readonly rows: readonly (readonly string[])[];
+}
+/** The table shape, or null when these lines are NOT a table.
+ *
+ *  Two rejections, both borrowed: a second line that is not a delimiter
+ *  row means this is prose that contains pipes; and a body row carrying
+ *  MORE columns than the header is malformed — rendering it would have
+ *  to guess where the extra content belongs, and a guess printed into
+ *  scrollback is indistinguishable from a fact. Rejected tables fall
+ *  back to their own source bytes, which are still valid markdown. */
+export declare function tableShape(lines: readonly string[]): MdTable | null;
+/**
+ * Wrap styled text into rows of at most W columns, with a HANGING
+ * INDENT: `first` prefixes the first row, `hang` every later one, and
+ * the text column is what continuations align to.
+ *
+ * The SGR spans open at a break are closed at the row's end and
+ * reopened at the next row's start, so no style leaks into the padding
+ * and none is lost across the break. Italic's own close (23) is
+ * understood, so `\x1b[3m…\x1b[23m` inside a bold heading tracks
+ * correctly.
+ *
+ * Every emitted row measures ≤ W through the SAME width authority the
+ * compositor's invariant ① measures with — which is the only way the
+ * two can agree.
+ */
+export declare function mdWrap(text: string, W: number, first: string, hang: string): string[];