@vincemakes/kiso-tui-cells 0.8.0 → 0.10.0

package/dist/approval-panel.d.ts

@@ -75,6 +75,38 @@ export interface AskRuntime {
     readonly custom: readonly (string | null)[];
     readonly phase: "options" | "custom";
 }
+/** One thing that can be picked: what it is, and what qualifies it. */
+export interface PickOption {
+    readonly label: string;
+    /** the dim qualifier ("profile: ds \u00b7 current") \u2014 what tells two
+     *  similar rows apart */
+    readonly note?: string;
+}
+/** The whole pick: the header sentence, the options, the free-text
+ *  escape hatch, and the honest empty state. */
+export interface PickSpec {
+    readonly header: string;
+    readonly options: readonly PickOption[];
+    /** the `t` row \u2014 typing it directly is always available, because a
+     *  list of profiles is never the list of models that exist */
+    readonly typeHint: string;
+    /** shown INSTEAD of the options when there are none. The copy is the
+     *  caller's and is reproduced verbatim. */
+    readonly emptyNote?: string;
+}
+/** The pick panel's runtime state \u2014 the editor owns it, the compositor
+ *  reads it (the AskRuntime precedent, two fields instead of five). */
+export interface PickRuntime {
+    readonly cursor: number;
+    readonly phase: "options" | "custom";
+}
+/** What was picked: a listed option by INDEX (never a label the caller
+ *  would have to re-match against its own list), or typed text. */
+export type PickResult = {
+    readonly index: number;
+} | {
+    readonly custom: string;
+};
 /** The ALWAYS-verbose args (the panel's body): the untruncated diff
  *  (edit/write), or the full text (shell = the command line, other =
  *  the pretty-printed JSON). The CLI composes them UNTRUNCATED — the
@@ -116,6 +148,9 @@ export interface PanelView {
      *  panel renders the ask block and the editor routes the ask keys;
      *  absent = the approval/simple panel, unchanged. */
     readonly ask?: AskSpec;
+    /** TUI2-R2 \u2463: the options, when this view is a PICK. Same contract
+     *  as `ask`, one payload over. */
+    readonly pick?: PickSpec;
 }
 export type PanelVerdict = {
     readonly action: "allow";
@@ -135,6 +170,13 @@ export type PanelVerdict = {
  | {
     readonly action: "answers";
     readonly result: AskResult;
+}
+/** TUI2-R2 \u2463: the pick's verdict \u2014 the chosen index or the typed
+ *  text. Only pick views ever produce it, so the approval path's
+ *  switch is untouched. */
+ | {
+    readonly action: "picked";
+    readonly result: PickResult;
 };
 /** The bound panel state the compositor reads — the editor owns the
  *  phase/selection state machine and the key routing; the compositor
@@ -145,6 +187,8 @@ export interface PanelState {
     readonly sel: PanelSel;
     /** KC3.5: the ask's walk — present exactly when `view.ask` is. */
     readonly ask?: AskRuntime;
+    /** TUI2-R2 \u2463: the pick's walk — present exactly when `view.pick` is. */
+    readonly pick?: PickRuntime;
 }
 /** The block's rows — EXACTLY the preview's frame shape, the gutter at
  *  the left edge (the preview's two-space mock indent is its own
@@ -168,3 +212,34 @@ export declare function panelStatus(view: PanelView, phase: PanelPhase, sel: Pan
  *  phase's keys. The approval flavor gains the tab-amend path; the
  *  simple flavor (the trust/uncertain gates) never does. */
 export declare function panelAffordance(view: PanelView, phase: PanelPhase, sel: PanelSel): string;
+/**
+ * The pick block's rows — the prototype's C frame.
+ *
+ * The header says what is in effect right now, because the first
+ * question anyone opening this panel has is "what am I on?". The
+ * options are numbered from 1 and the number IS the key. The `t` row is
+ * last and always present: a profile list is a convenience, never the
+ * set of models that exist, and a picker that can only offer what
+ * someone remembered to configure is a smaller product than the one it
+ * replaced.
+ *
+ * Single-row discipline: every row CUTS, never folds — the block's
+ * height is its row count (the W20 rule the #checked throw demands).
+ */
+export declare function pickBlockRows(view: PanelView, state: PickRuntime, W: number, maxRows: number): string[];
+/** The digits are the keys, so the list the panel offers is bounded by
+ *  the digits there are. Beyond it, `/model <name>` still takes any
+ *  profile — the panel says so rather than paginating. */
+export declare const PICK_MAX = 9;
+/** The input row's lead: the digit range while picking, the named
+ *  prompt while typing one out. */
+export declare function pickLeadPlain(view: PanelView, state: PickRuntime): string;
+export declare function pickLead(view: PanelView, state: PickRuntime): string;
+/** The status row's left text \u2014 the CALLER's, because only the caller
+ *  knows whether a run is paused behind this panel. */
+export declare function pickStatus(view: PanelView): string;
+export declare function pickAffordance(state: PickRuntime): string;
+/** Compose a pick view. The flavor/name/title/args fields exist for the
+ *  approval path and are given inert values here \u2014 the pick block
+ *  reads none of them. */
+export declare function modelPickView(spec: PickSpec, statusText: string): PanelView;

package/dist/approval-panel.js

@@ -26,6 +26,9 @@
  */
 import { displayWidth } from "./width.js";
 import { cutLine, diffBody, gutterFold, visibleWidth, widthCut } from "./components.js";
+// TUI2-R2pre ④: strings.js takes only a TYPE from this module, so the
+// import is erased at compile time and no runtime cycle exists.
+import { displayVerb } from "./strings.js";
 import { escapeTerminal, palette } from "./render.js";
 /** The rule line's text — the why-asked line (the R3 chain): the tool
  *  name, the first non-abstain speaker, the fix hint (the §3.5 table,
@@ -37,7 +40,11 @@ function panelRuleText(view) {
     if (view.ruleOverride !== undefined)
         return escapeTerminal(view.ruleOverride);
     const hint = view.hint;
-    const base = `${p.bold}${escapeTerminal(view.name)}${p.reset} ${p.dim}needs approval — asked by${p.reset} ${p.bold}${escapeTerminal(view.speaker)}${p.reset}`;
+    // TUI2-R2pre ④: the rule line is the panel's header — it says the ACT
+    // ("edit needs approval"). view.name keeps the RAW tool name, which is
+    // what the option-2 rule prefill and the fallbackQuestion (the
+    // dock-less/pipe path — byte-identical by ruling) still read.
+    const base = `${p.bold}${escapeTerminal(displayVerb(view.name))}${p.reset} ${p.dim}needs approval — asked by${p.reset} ${p.bold}${escapeTerminal(view.speaker)}${p.reset}`;
     return hint ? `${base}${p.dim} ·${p.reset} ${p.code}${escapeTerminal(hint)}${p.reset}` : base;
 }
 /** The numbered options row — "1 Yes  2 Yes, don't ask again for
@@ -50,10 +57,14 @@ function panelRuleText(view) {
  *  single-row discipline — the row never folds). */
 function panelOptionsRow(view, sel, W) {
     const p = palette();
+    // TUI2-R1.5 ⑪ (VD-13): ONE separator grammar. The options were
+    // two-space separated while every other metadata group in the product
+    // uses `·`, and at 80 columns that put `3 No` far enough from its
+    // neighbours to read as detached rather than as the third option.
     const o1 = sel === 1 ? `${p.bold} 1 Yes${p.reset}` : ` 1 Yes`;
-    const o3 = sel === 3 ? `${p.bold} 3 No${p.reset}` : ` 3 No`;
+    const o3 = sel === 3 ? `${p.bold}3 No${p.reset}` : `3 No`;
     if (view.flavor === "simple")
-        return `${o1}  ${o3}`;
+        return `${o1} · ${o3}`;
     // the option-2 span: " 2 Yes, don't ask again for <name>" — the
     // fixed part is 45 (the gutter + the 1/3 options + the separators +
     // the 28-cell prefix); the name cuts to W−46 + "…". The "…" needs
@@ -62,13 +73,18 @@ function panelOptionsRow(view, sel, W) {
     // DROPS: the rule name is the cuttable span, the 1/3 options are
     // the semantics — the approval decision must survive a narrow
     // winch, and invariant ① must never fire on the options row.
-    if (W < 47)
-        return cutLine(`${o1}  ${o3}`, Math.max(1, W - 2));
-    const name = escapeTerminal(view.name);
-    const budget = W - 46;
-    const shown = visibleWidth(name) > W - 45 ? `${widthCut(name, budget)}…` : name;
-    const o2 = sel === 2 ? `${p.bold} 2 Yes, don't ask again for ${shown}${p.reset}` : ` 2 Yes, don't ask again for ${shown}`;
-    return `${o1}  ${o2}  ${o3}`;
+    // TUI2-R1.5 ⑪: option 2 states what it DOES; the tool it would do it
+    // for is the panel's title, one row above, and repeating it here was
+    // what made this row the widest thing in the block. The fixed part is
+    // now 33 cells, so the whole row survives far narrower windows than the
+    // 47 the rule name used to demand.
+    const o2 = sel === 2 ? `${p.bold}2 Yes, don't ask again${p.reset}` : `2 Yes, don't ask again`;
+    const full = `${o1} · ${o2} · ${o3}`;
+    if (visibleWidth(full) <= W - 2)
+        return full;
+    // too narrow for the middle option: the 1/3 decision is the semantics
+    // and must survive any winch (invariant ① never fires on this row).
+    return cutLine(`${o1} · ${o3}`, Math.max(1, W - 2));
 }
 /** The block's rows — EXACTLY the preview's frame shape, the gutter at
  *  the left edge (the preview's two-space mock indent is its own
@@ -80,7 +96,11 @@ export function panelBlockRows(view, phase, sel, W, maxRows) {
     const rows = [];
     rows.push(`${gutter}${cutLine(panelRuleText(view), Math.max(1, W - 2))}`);
     rows.push(`${gutter}${cutLine(`${p.bold}${escapeTerminal(view.title)}${p.reset}`, Math.max(1, W - 2))}`);
-    rows.push(`${cutLine(`${p.dim}─ the full args — never truncated ─${p.reset}`, Math.max(1, W - 2))}`);
+    // TUI2-R1.5 ⑤ (VD-11): the divider is a LABEL, not a design note. "the
+    // full args — never truncated" is a sentence about the implementation,
+    // addressed to whoever was building the panel; the human reading it
+    // during an approval wants to know what the block below is.
+    rows.push(`${cutLine(`${p.dim}─ args (full) ─${p.reset}`, Math.max(1, W - 2))}`);
     // the args — the bounded block's body: fold, then cap. The └ cut is
     // ONE row (the W20 discipline): when the args exceed the budget, one
     // notice row carries the count and where the rest is (the event log).
@@ -100,7 +120,15 @@ export function panelBlockRows(view, phase, sel, W, maxRows) {
     rows.push(...shown);
     rows.push(`${gutter}${panelOptionsRow(view, sel, W)}`);
     rows.push(`${gutter}${p.dim}${panelAffordance(view, phase, sel)}${p.reset}`);
-    rows.push(`${p.dim}└ ${p.reset}`);
+    // TUI2-R1.5 11 (VD-13): a real bottom RULE, in the block's own edge
+    // vocabulary — the same box-drawing run its divider already uses —
+    // anchored at the gutter column. It used to be `\u2514 `: a two-cell stub
+    // floating at column 1, with no rule running from it and no corner
+    // above it to answer. Worse, `\u2514 ` is the cut-notice prefix everywhere
+    // else in the product, so a CAPPED panel emitted two elbow rows in a
+    // row meaning entirely different things. The rule reads as an edge,
+    // and the cut notice above it reads as a notice.
+    rows.push(`${p.dim}\u2514${"\u2500".repeat(Math.max(0, W - 1))}${p.reset}`);
     return rows;
 }
 /** The input row's lead for the panel's phase (the preview's chrome
@@ -149,3 +177,88 @@ export function panelAffordance(view, phase, sel) {
         return sel === 0 ? "tab amend · esc cancel" : "enter sends · esc backs out";
     return sel === 0 ? "esc cancel" : "enter sends";
 }
+// ── TUI2-R2 ④: the pick block, its lead, its status, its affordance ──
+/**
+ * The pick block's rows — the prototype's C frame.
+ *
+ * The header says what is in effect right now, because the first
+ * question anyone opening this panel has is "what am I on?". The
+ * options are numbered from 1 and the number IS the key. The `t` row is
+ * last and always present: a profile list is a convenience, never the
+ * set of models that exist, and a picker that can only offer what
+ * someone remembered to configure is a smaller product than the one it
+ * replaced.
+ *
+ * Single-row discipline: every row CUTS, never folds — the block's
+ * height is its row count (the W20 rule the #checked throw demands).
+ */
+export function pickBlockRows(view, state, W, maxRows) {
+    const p = palette();
+    const spec = view.pick;
+    const gutter = `${p.dim}\u2502${p.reset} `;
+    const rows = [];
+    const room = Math.max(1, W - 2);
+    rows.push(`${gutter}${cutLine(`${p.bold}${escapeTerminal(spec.header.split(" \u2014 ")[0] ?? spec.header)}${p.reset}${p.dim}${escapeTerminal(spec.header.slice((spec.header.split(" \u2014 ")[0] ?? "").length))}${p.reset}`, room)}`);
+    if (spec.options.length === 0) {
+        // the honest empty state \u2014 the caller's own copy, verbatim
+        rows.push(`${gutter}${cutLine(`${p.dim} ${escapeTerminal(spec.emptyNote ?? "no options")}${p.reset}`, room)}`);
+    }
+    else {
+        // the budget: the header, the t row, the affordance and the rule
+        const budget = Math.max(1, maxRows - 4);
+        const shown = spec.options.slice(0, Math.min(budget, PICK_MAX));
+        for (let i = 0; i < shown.length; i += 1) {
+            const o = shown[i];
+            const mark = i === state.cursor && state.phase === "options";
+            const head = `${mark ? p.bold : ""} ${i + 1} ${escapeTerminal(o.label)}${mark ? p.reset : ""}`;
+            const note = o.note === undefined ? "" : `${p.dim}   ${escapeTerminal(o.note)}${p.reset}`;
+            rows.push(`${gutter}${cutLine(`${head}${note}`, room)}`);
+        }
+        if (spec.options.length > shown.length) {
+            rows.push(`${gutter}${cutLine(`${p.dim} \u2514 +${spec.options.length - shown.length} more \u2014 /model <name> takes any of them${p.reset}`, room)}`);
+        }
+    }
+    rows.push(`${gutter}${cutLine(`${state.phase === "custom" ? p.bold : ""} t ${p.reset}${p.dim}${escapeTerminal(spec.typeHint)}${p.reset}`, room)}`);
+    rows.push(`${gutter}${p.dim}${cutLine(pickAffordance(state), room)}${p.reset}`);
+    rows.push(`${p.dim}\u2514${"\u2500".repeat(Math.max(0, W - 1))}${p.reset}`);
+    return rows;
+}
+/** The digits are the keys, so the list the panel offers is bounded by
+ *  the digits there are. Beyond it, `/model <name>` still takes any
+ *  profile — the panel says so rather than paginating. */
+export const PICK_MAX = 9;
+/** The input row's lead: the digit range while picking, the named
+ *  prompt while typing one out. */
+export function pickLeadPlain(view, state) {
+    if (state.phase === "custom")
+        return "provider/model: ";
+    const n = Math.min(view.pick.options.length, PICK_MAX);
+    return n === 0 ? "t> " : `1-${n}> `;
+}
+export function pickLead(view, state) {
+    const p = palette();
+    return `${p.bold}${pickLeadPlain(view, state)}${p.reset}`;
+}
+/** The status row's left text \u2014 the CALLER's, because only the caller
+ *  knows whether a run is paused behind this panel. */
+export function pickStatus(view) {
+    return view.statusText;
+}
+export function pickAffordance(state) {
+    return state.phase === "custom" ? "enter commits \u00b7 esc backs out" : "digits pick \u00b7 \u23ce confirms \u00b7 esc";
+}
+/** Compose a pick view. The flavor/name/title/args fields exist for the
+ *  approval path and are given inert values here \u2014 the pick block
+ *  reads none of them. */
+export function modelPickView(spec, statusText) {
+    return {
+        flavor: "simple",
+        name: "model",
+        title: "model",
+        speaker: "you",
+        statusText,
+        args: { kind: "text", lines: [] },
+        fallbackQuestion: "switch model? (name) ",
+        pick: spec,
+    };
+}

package/dist/components.d.ts

@@ -108,12 +108,19 @@ export type BodyCell = {
      *  the head of an N > 2 same-tool run renders the group (the
      *  work order's claimed shape: "✓ read  5 files (2.4k lines,
      *  1.1s)" + the target children). The members carry null — the
-     *  compositor's rolled-heads bookkeeping renders them []. */
+     *  compositor's rolled-heads bookkeeping renders them [].
+     *  TUI2-R1 (B): `parts` is set when the run spans MORE THAN ONE
+     *  read-only tool — the same mechanism, the exploration row.
+     *  Absent (a single-name run) keeps W13's row byte for byte. */
     rolled: null | {
         count: number;
         lines: number;
         elapsed: string;
         targets: string[];
+        parts?: readonly {
+            name: string;
+            subjects: readonly string[];
+        }[];
     };
     /** W19: a DENIED call's reason (the CLI extracted it from the
      *  result's "[Permission denied] " prefix, keyed on the "denied"
@@ -152,6 +159,7 @@ export type BodyCell = {
     kind: "raw";
     lines: string[];
     done: true;
+    wrap?: "words";
 } | {
     kind: "terminal";
     label: string;
@@ -196,11 +204,7 @@ export declare function cellComponent(cell: BodyCell): Component;
  *  (the gutter's 2 cells), so a long line hard-folds INSIDE the chip
  *  and invariant ① holds on the band. */
 export declare function pendingQueueRows(lines: readonly string[], W: number): string[];
-/** Fold a line's CONTENT at W−2 and prefix EVERY row with the gutter
- *  (W2: a wrapped tool row keeps its state mark — the left edge alone
- *  distinguishes the states at --plain; the UserMessage rail precedent,
- *  v5 #16f). The gutter carries its own SGR (e.g. the bold ✓). W21:
- *  exported for the approval panel's text args (the same │ gutter). */
+export declare function foldWords(line: string, W: number): string[];
 export declare function gutterFold(gutter: string, line: string, W: number): string[];
 /** A6: the tool-header variant — ONE cut row, never a fold. A wide
  *  header (a long target path, a wordy denial reason) used to wrap
@@ -210,12 +214,57 @@ export declare function gutterFold(gutter: string, line: string, W: number): str
  *  full content. The budget: the gutter's own visible width + the
  *  ellipsis ride the row (the invariant ① cap holds). */
 export declare function gutterCut(gutter: string, line: string, W: number): string[];
+export declare function expandSuffix(lines: number | null, room: number): string;
+/**
+ * TUI2-R2 ⑤ (D, candidate 1) — the FOCUS tint.
+ *
+ * The cell the next ctrl+r will act on brightens its own `ctrl+r` token
+ * to the code tint; the rest of the suffix — the separator, the count —
+ * stays dim, because what is being marked is the KEY's target, not the
+ * row. Zero new rows, zero new columns: the affordance the cell already
+ * prints is the marker.
+ *
+ * Applied to a row rather than composed into it on purpose. The token is
+ * emitted from several places (the settled suffix, the renderer's own
+ * `└ +N … · ctrl+r` cut rows) and threading a flag through all of them
+ * would put the invariant "exactly one bright token" in as many hands as
+ * there are emitters. Here it has exactly one.
+ *
+ * NO_COLOR: p.code is empty, so the row's bytes are untouched.
+ */
+export declare function focusToken(row: string, W: number): string;
 /** W13 — the rollup opt-in table: which tools collapse, and the count
  *  NOUN (read_file calls → "5 files", list_dir → "5 dirs", search_text
  *  → "5 matches"). Only these tools opt in — a shell burst is never
  *  rolled up (its rows carry meaning). The folded-turn line (W14) reuses
  *  the plurals for its other-tool terms ("2 dirs", "1 match"). */
 export declare const ROLLUP_NOUN: Readonly<Record<string, string>>;
+/** TUI2-R1 (B) — the verb column of the expanded list names the ACT.
+ *  TUI2-R2pre ④: this used to be a private three-tool table saying the
+ *  same thing as the card head's `_file` strip, in a different way and
+ *  for a different set of tools. Both are `displayVerb` now — the whole
+ *  point of the ruling is that there is ONE answer to "what does the
+ *  screen call this". The cut note, which used to be the deliberate
+ *  exception here, moved with it (see toolCutNote). */
+/** Whether a tool joins an exploration run. Exactly the read-only set —
+ *  writes, edits, shells and extension tools never group (a burst of
+ *  side effects is a list of things that HAPPENED, and every row of it
+ *  carries meaning). */
+export declare function isExploreTool(name: string): boolean;
+/** "8 files · 14 searches" — the per-tool counts in first-call order. */
+export declare function exploreCounts(parts: readonly {
+    name: string;
+    subjects: readonly string[];
+}[]): string;
+/** TUI2-R1 (B) — the expanded list: ONE row per tool, the verb column
+ *  then the distinct subjects in first-call order, a repeated subject
+ *  carrying its ×count, the first three shown and the rest counted.
+ *  A search's subject is its PATTERN (quoted — the thing that was
+ *  looked for); a read's or a list's is its path. */
+export declare function exploreRows(parts: readonly {
+    name: string;
+    subjects: readonly string[];
+}[], W: number): string[];
 /** W14 — the folded-turn line: a whole QUIET turn (no text), once it is
  *  scrollback, becomes ONE line — the work order's claimed shape
  *  (`▞ thought 19s · 5 reads · no edits`), the counts accumulated at