@vincemakes/kiso-tui-cells 0.6.0 → 0.8.0

package/dist/approval-panel.d.ts

@@ -27,6 +27,54 @@
 export type PanelFlavor = "approval" | "simple";
 export type PanelPhase = "options" | "rule" | "amend";
 export type PanelSel = 0 | 1 | 2 | 3;
+/** One option of a question: the label the human picks, plus an
+ *  optional one-line description (the model's own words). */
+export interface AskOption {
+    readonly label: string;
+    readonly description?: string;
+}
+/** One question: 2-4 options, single- or multi-select, and an optional
+ *  ≤12-cell header (the panel's title when present — the schema caps
+ *  it so the title never fights the counter for the row). */
+export interface AskQuestion {
+    readonly question: string;
+    readonly header?: string;
+    readonly options: readonly AskOption[];
+    readonly multiSelect?: boolean;
+}
+/** The whole ask_user call: 1-4 questions, walked in order. */
+export interface AskSpec {
+    readonly questions: readonly AskQuestion[];
+}
+/** One answered question — the three shapes the tool_result carries:
+ *  a single choice, a multi-select list, or the typed-in answer. */
+export type AskAnswer = {
+    readonly q: string;
+    readonly choice: string;
+} | {
+    readonly q: string;
+    readonly choices: readonly string[];
+} | {
+    readonly q: string;
+    readonly custom: string;
+};
+/** The ask's outcome: every question answered, or the decline — an
+ *  HONEST recorded outcome that names what was skipped, never silence. */
+export type AskResult = {
+    readonly answers: readonly AskAnswer[];
+} | {
+    readonly declined: readonly string[];
+};
+/** The ask panel's runtime state — the editor owns and advances it,
+ *  the compositor reads it. `picks` and `custom` are per question, so
+ *  a walk back (←) shows what was already chosen. */
+export interface AskRuntime {
+    readonly qIndex: number;
+    readonly cursor: number;
+    readonly picks: readonly (readonly number[])[];
+    readonly custom: readonly (string | null)[];
+    readonly phase: "options" | "custom";
+}
 /** 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
@@ -64,6 +112,10 @@ export interface PanelView {
     /** The fallback question — the y/n text for the dock-less path
      *  (a TTY without a dock, or a pipe). */
     readonly fallbackQuestion: string;
+    /** KC3.5: the questions, when this view is an ASK. Present = the
+     *  panel renders the ask block and the editor routes the ask keys;
+     *  absent = the approval/simple panel, unchanged. */
+    readonly ask?: AskSpec;
 }
 export type PanelVerdict = {
     readonly action: "allow";
@@ -76,6 +128,13 @@ export type PanelVerdict = {
     readonly reason: string;
 } | {
     readonly action: "cancel";
+}
+/** KC3.5: the ask's own verdict — the answers (or the decline) the
+ *  cli hands back to the tool. Only ask views ever produce it, so
+ *  the approval path's switch is untouched. */
+ | {
+    readonly action: "answers";
+    readonly result: AskResult;
 };
 /** The bound panel state the compositor reads — the editor owns the
  *  phase/selection state machine and the key routing; the compositor
@@ -84,6 +143,8 @@ export interface PanelState {
     readonly view: PanelView;
     readonly phase: PanelPhase;
     readonly sel: PanelSel;
+    /** KC3.5: the ask's walk — present exactly when `view.ask` is. */
+    readonly ask?: AskRuntime;
 }
 /** 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

package/dist/index.d.ts

@@ -10,5 +10,7 @@ export { SPINNER, foldLine, visibleWidth, bodySpacing, Container, cellComponent,
 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, } from "./approval-panel.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 { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, type TrustArtifact, } from "./strings.js";
+export { extensionsBannerText, helpRows, unansweredAskView, type BannerExtension } from "./strings.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, colorInlineCode, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";

package/dist/index.js

@@ -18,4 +18,11 @@ export { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 // 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";
+// 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
+// the cli; what the human reads is presentation.
+export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, } from "./strings.js";
+// KC3.5: the interrupted-ask copy and the extracted /help table.
+export { extensionsBannerText, helpRows, unansweredAskView } from "./strings.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, colorInlineCode, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";

package/dist/render.d.ts

@@ -11,12 +11,23 @@
  * RETIRED — the identity accents (the you> prompt, the banner tagline,
  * ✓ marks, slash-command names, the input brick) are bright-white BOLD
  * (SGR 1); the user message is the SGR-7 chip (the 2026-08-09 ruling
- * retired the ▍ rail); `code` is the content semantic tint for
- * inline code spans in assistant text (256-color 110 — the cube color
- * nearest the design's #8fb4d8); red for errors, dim for metadata,
- * green for the diff additions. NO_COLOR set, or a non-TTY output →
- * every code is empty, so pipes and CI carry ZERO ANSI (the existing
- * byte-level e2e assertions guard it). Everything not listed is plain.
+ * retired the ▍ rail); red for errors, dim for metadata, green for the
+ * diff additions. NO_COLOR set, or a non-TTY output → every code is
+ * empty, so pipes and CI carry ZERO ANSI (the existing byte-level e2e
+ * assertions guard it). Everything not listed is plain.
+ *
+ * KC3 §2 — THE MONO DISCIPLINE (the owner's 2026-08-17 ruling, a
+ * DECLARED SUPERSESSION under ADR-0051 Amendment 3). The interface's
+ * body is carried by shades of black and white; green ✓, yellow warn
+ * and red error are the ONLY functional exceptions. v5 had already
+ * taken the identity accents to bold; `code` was the one chromatic
+ * entry left — the light BLUE 38;5;110 — and it becomes the light GRAY
+ * 38;5;252. A tint still says "this span is code", which is the job it
+ * was hired for; saying it in a hue was never the job.
+ *
+ * The functional colors are deliberately NOT moved and not
+ * approximated: red stays SGR 31, green stays SGR 32. A reader who has
+ * learned that colour means something must keep being right.
  */
 export interface Palette {
     readonly bold: string;

package/dist/render.js

@@ -6,7 +6,7 @@
  * dependencies (the tui-cells package has none).
  */
 import { charWidth, displayWidth } from "./width.js";
-export const COLOR_ON = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", code: "\x1b[38;5;110m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
+export const COLOR_ON = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", code: "\x1b[38;5;252m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
 export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", code: "", rv: "", rvEnd: "", reset: "" };
 export function palette() {
     return process.env.NO_COLOR === undefined && process.stdout.isTTY ? COLOR_ON : COLOR_OFF;

package/dist/strings.d.ts

@@ -0,0 +1,107 @@
+/**
+ * tui-cells — the human-facing STRINGS (KC3 slice 1, the ADR-0041
+ * escape hatch: extraction, never a raise): the readline prompt, the
+ * project-trust listing rows and its panel view, the uncertain
+ * execution's panel view, and the non-TTY not-trusted note. All five
+ * were built inline in the CLI's trust-ui.ts before the move.
+ *
+ * The split is the one the ADR names. The FLOW stays in the CLI: who is
+ * asked, when the ask happens, whether a TTY exists, and what a verdict
+ * MEANS (granted loads, refused is sticky, a cancel records nothing) is
+ * trust-ui.ts's and is untouched by this move. What the human READS is
+ * presentation, and presentation belongs to the terminal layer — the
+ * same reasoning that moved the status rows here in KC2 §5.
+ *
+ * Pure by construction: every function is (data) → bytes. No node
+ * builtins, no I/O, no clock — the package's zero-dependency promise is
+ * why the caller passes paths and counts in rather than having them
+ * looked up here.
+ */
+import type { PanelView } from "./approval-panel.js";
+/** v2a: the interactive prompt — the identity accent. readline owns the
+ *  echo of what the user types; we own the prompt's color. (v2c: the
+ *  readline prompt keeps "you> " — the brick ▌ is the dock's row only;
+ *  pipe bytes must not change.) */
+export declare function interactivePrompt(): string;
+/** E3 (ADR-0037) — one discovered project artifact: the relative path
+ *  and its content digest. Structural on purpose — the runtime's
+ *  ProjectArtifacts satisfies it without this package importing the
+ *  runtime (it imports nothing). */
+export interface TrustArtifact {
+    readonly path: string;
+    readonly digest: string;
+}
+/**
+ * E3 — the artifact listing: `<path>  (<digest6>)`, one row per file.
+ *
+ * The two callers differ by exactly the INDENT and nothing else: the
+ * scrollback record indents two (its rows sit under the root's own
+ * line), the panel's args do not (the block's frame supplies the
+ * inset). Before the move the two rows were written out separately, two
+ * template literals that had to agree by hand; the parameter keeps the
+ * one real difference visible while making the rest provably identical.
+ */
+export declare function projectTrustRows(files: readonly TrustArtifact[], indent?: string): string[];
+/** E3 — the trust gate's panel: the SIMPLE flavor (1 Yes / 3 No — no
+ *  "don't ask again" rule exists for a project), the root as the title,
+ *  the artifact listing as the always-verbose args, and the question as
+ *  the rule override. The same rows the scrollback records — the panel
+ *  is a bounded block, the record is not. */
+export declare function projectTrustView(root: string, files: readonly TrustArtifact[]): PanelView;
+/** E3 — the non-TTY note: artifacts were found and deliberately NOT
+ *  loaded, with the one path back (run once interactively). Printed to
+ *  stderr by the caller; never silent. */
+export declare function projectUntrustedNote(count: number, root: string): string;
+/** rounds 8/10 — the uncertain execution's panel: the SIMPLE flavor
+ *  again, with the options re-labelled in the rule line (1 rerun · 3
+ *  abandon). The tool name is escaped for the dock-less fallback
+ *  question because it reaches the terminal as raw text there; the
+ *  panel's own rows are escaped by the panel renderer. */
+export declare function uncertainView(name: string, executionId: string): PanelView;
+/**
+ * KC3.5 — the SAME uncertainty gate, said honestly for an ask_user call.
+ *
+ * "Did the interrupted execution apply?" is the right question for a
+ * side effect and the wrong one for a question: nothing applied, the
+ * human simply never answered. The COPY special-cases ask_user; the
+ * mechanism does not — the verdict still maps to the runtime's own
+ * rerun/abandoned resolution, whose error-fill text is untouched.
+ *
+ * (The round's ① probe pinned why this surface exists at all: the
+ * shipped recovery blocks on a started-unreported execution regardless
+ * of idempotency, so an interrupted ask meets this gate on the way
+ * back. Re-asking is safe — that is what "1 re-ask" says out loud.)
+ */
+export declare function unansweredAskView(executionId: string): PanelView;
+/** An extension as the banner names it — the live `connecting` flag is
+ *  the MCP bridge's in-flight state ("mcp (connecting…)"). Structural on
+ *  purpose: the runtime's KisoExtension satisfies it without this
+ *  package importing the runtime. */
+export interface BannerExtension {
+    readonly name: string;
+    readonly connecting?: boolean;
+}
+/**
+ * KC3.5 slice ⓪ (the extraction) — the `[N extensions: …]` banner text:
+ * the built-in column, then the user-level names, then the project-level
+ * ones marked `project:`.
+ *
+ * A pure function of three name lists, so what the banner SAYS is
+ * testable without a terminal — which matters this round, because the
+ * count is where the ask's TTY gate becomes visible: an interactive
+ * session reads `built-in: mcp, skills, subagent, ask` and a piped one
+ * reads `built-in: mcp, skills, subagent`, from this one composition.
+ */
+export declare function extensionsBannerText(builtIn: readonly BannerExtension[], user: readonly BannerExtension[], project: readonly BannerExtension[]): string;
+/**
+ * KC3.5 slice ⓪ (the extraction) — the /help command table.
+ *
+ * The rows were eight bodyLog calls in the CLI's dispatcher; they are
+ * presentation, and presentation belongs here (the KC3 §1 pattern —
+ * the FLOW, which is "print these on the chain, then re-prompt", stays
+ * in dispatch.ts). The last row carries its own newline exactly as it
+ * did inline: bodyLog splits on \n, so `exit` and `keys` land as two
+ * rows from one call — the shape the KC1/KC2/KC3 gestures were added
+ * to, unchanged.
+ */
+export declare function helpRows(): string[];

package/dist/strings.js

@@ -0,0 +1,157 @@
+/**
+ * tui-cells — the human-facing STRINGS (KC3 slice 1, the ADR-0041
+ * escape hatch: extraction, never a raise): the readline prompt, the
+ * project-trust listing rows and its panel view, the uncertain
+ * execution's panel view, and the non-TTY not-trusted note. All five
+ * were built inline in the CLI's trust-ui.ts before the move.
+ *
+ * The split is the one the ADR names. The FLOW stays in the CLI: who is
+ * asked, when the ask happens, whether a TTY exists, and what a verdict
+ * MEANS (granted loads, refused is sticky, a cancel records nothing) is
+ * trust-ui.ts's and is untouched by this move. What the human READS is
+ * presentation, and presentation belongs to the terminal layer — the
+ * same reasoning that moved the status rows here in KC2 §5.
+ *
+ * Pure by construction: every function is (data) → bytes. No node
+ * builtins, no I/O, no clock — the package's zero-dependency promise is
+ * why the caller passes paths and counts in rather than having them
+ * looked up here.
+ */
+import { escapeTerminal, palette } from "./render.js";
+/** v2a: the interactive prompt — the identity accent. readline owns the
+ *  echo of what the user types; we own the prompt's color. (v2c: the
+ *  readline prompt keeps "you> " — the brick ▌ is the dock's row only;
+ *  pipe bytes must not change.) */
+export function interactivePrompt() {
+    const p = palette();
+    return `${p.bold}you> ${p.reset}`;
+}
+/**
+ * E3 — the artifact listing: `<path>  (<digest6>)`, one row per file.
+ *
+ * The two callers differ by exactly the INDENT and nothing else: the
+ * scrollback record indents two (its rows sit under the root's own
+ * line), the panel's args do not (the block's frame supplies the
+ * inset). Before the move the two rows were written out separately, two
+ * template literals that had to agree by hand; the parameter keeps the
+ * one real difference visible while making the rest provably identical.
+ */
+export function projectTrustRows(files, indent = "") {
+    return files.map((f) => `${indent}${f.path}  (${f.digest.slice(0, 6)})`);
+}
+/** E3 — the trust gate's panel: the SIMPLE flavor (1 Yes / 3 No — no
+ *  "don't ask again" rule exists for a project), the root as the title,
+ *  the artifact listing as the always-verbose args, and the question as
+ *  the rule override. The same rows the scrollback records — the panel
+ *  is a bounded block, the record is not. */
+export function projectTrustView(root, files) {
+    return {
+        flavor: "simple",
+        name: "project trust",
+        title: root,
+        speaker: "kiso",
+        statusText: "▸ project trust",
+        args: { kind: "text", lines: projectTrustRows(files) },
+        ruleOverride: "trust this project's .kiso?",
+        fallbackQuestion: `trust this project's .kiso? (y/n) `,
+    };
+}
+/** E3 — the non-TTY note: artifacts were found and deliberately NOT
+ *  loaded, with the one path back (run once interactively). Printed to
+ *  stderr by the caller; never silent. */
+export function projectUntrustedNote(count, root) {
+    return `[project .kiso] found ${count} artifact(s) in ${root} — not trusted, not loaded (run kiso interactively once to decide)`;
+}
+/** rounds 8/10 — the uncertain execution's panel: the SIMPLE flavor
+ *  again, with the options re-labelled in the rule line (1 rerun · 3
+ *  abandon). The tool name is escaped for the dock-less fallback
+ *  question because it reaches the terminal as raw text there; the
+ *  panel's own rows are escaped by the panel renderer. */
+export function uncertainView(name, executionId) {
+    return {
+        flavor: "simple",
+        name: "uncertain execution",
+        title: `${name} (${executionId})`,
+        speaker: "kiso",
+        statusText: "▸ uncertain execution",
+        args: { kind: "text", lines: [executionId] },
+        ruleOverride: "did the interrupted execution apply? — 1 rerun · 3 abandon",
+        fallbackQuestion: `⚠ interrupted execution: ${escapeTerminal(name)} (${executionId}) — did it apply? (y)es / (n)o `,
+    };
+}
+/**
+ * KC3.5 — the SAME uncertainty gate, said honestly for an ask_user call.
+ *
+ * "Did the interrupted execution apply?" is the right question for a
+ * side effect and the wrong one for a question: nothing applied, the
+ * human simply never answered. The COPY special-cases ask_user; the
+ * mechanism does not — the verdict still maps to the runtime's own
+ * rerun/abandoned resolution, whose error-fill text is untouched.
+ *
+ * (The round's ① probe pinned why this surface exists at all: the
+ * shipped recovery blocks on a started-unreported execution regardless
+ * of idempotency, so an interrupted ask meets this gate on the way
+ * back. Re-asking is safe — that is what "1 re-ask" says out loud.)
+ */
+export function unansweredAskView(executionId) {
+    return {
+        flavor: "simple",
+        name: "unanswered question",
+        title: `ask_user (${executionId})`,
+        speaker: "kiso",
+        statusText: "▸ unanswered question",
+        args: { kind: "text", lines: [executionId] },
+        ruleOverride: "an unanswered question was interrupted — ask it again? — 1 re-ask · 3 drop",
+        fallbackQuestion: `⚠ an unanswered question was interrupted (${executionId}) — ask it again? (y)es / (n)o `,
+    };
+}
+/**
+ * KC3.5 slice ⓪ (the extraction) — the `[N extensions: …]` banner text:
+ * the built-in column, then the user-level names, then the project-level
+ * ones marked `project:`.
+ *
+ * A pure function of three name lists, so what the banner SAYS is
+ * testable without a terminal — which matters this round, because the
+ * count is where the ask's TTY gate becomes visible: an interactive
+ * session reads `built-in: mcp, skills, subagent, ask` and a piped one
+ * reads `built-in: mcp, skills, subagent`, from this one composition.
+ */
+export function extensionsBannerText(builtIn, user, project) {
+    const total = builtIn.length + user.length + project.length;
+    if (total === 0)
+        return "";
+    const label = (e) => (e.connecting === true ? `${e.name} (connecting…)` : e.name);
+    const parts = [];
+    if (builtIn.length > 0)
+        parts.push(`built-in: ${builtIn.map(label).join(", ")}`);
+    if (user.length > 0)
+        parts.push(user.map(label).join(", "));
+    if (project.length > 0)
+        parts.push(`project: ${project.map(label).join(", ")}`);
+    return ` · [${total} extension${total === 1 ? "" : "s"}: ${parts.join(" · ")}]`;
+}
+/**
+ * KC3.5 slice ⓪ (the extraction) — the /help command table.
+ *
+ * The rows were eight bodyLog calls in the CLI's dispatcher; they are
+ * presentation, and presentation belongs here (the KC3 §1 pattern —
+ * the FLOW, which is "print these on the chain, then re-prompt", stays
+ * in dispatch.ts). The last row carries its own newline exactly as it
+ * did inline: bodyLog splits on \n, so `exit` and `keys` land as two
+ * rows from one call — the shape the KC1/KC2/KC3 gestures were added
+ * to, unchanged.
+ */
+export function helpRows() {
+    const p = palette();
+    const cmd = (name, desc) => `${p.bold}${name}${p.reset}    ${desc}`;
+    return [
+        cmd("/help", "print this list of commands"),
+        cmd("/think", "show the last full thinking block"),
+        cmd("/last", "show the most recent tool call's input and output"),
+        cmd("/status", "show session id, event count, and context estimate"),
+        cmd("/mode", "show the approval tier; /mode <name> switches (manual/default/accept-edits/plan/bypass)"),
+        cmd("/model", "list model profiles; /model <name|provider/model> switches"),
+        cmd("/compact", "summarize the older conversation to free context"),
+        `${cmd("exit", "leave the session")}\n${cmd("keys", "enter sends · ctrl+J newline (shift+enter where encoded) · esc stops the run · alt+⏎ stops it and sends this instead · @ files · 1-4 answers an ask")}`,
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui-cells",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "kiso tui-cells — the components cell renderer (components, diff, width, the render slice). Zero runtime dependencies: input is data, output is bytes.",
   "type": "module",
   "license": "MIT",
@@ -28,6 +28,10 @@
     "./render": {
       "types": "./dist/render.d.ts",
       "default": "./dist/render.js"
+    },
+    "./strings": {
+      "types": "./dist/strings.d.ts",
+      "default": "./dist/strings.js"
     }
   },
   "files": [