@vincemakes/kiso-tui 0.15.2 → 0.15.4

package/dist/ask-panel.d.ts

@@ -53,13 +53,11 @@ export interface AskStep {
     readonly state: AskRuntime;
     readonly result?: AskResult;
 }
-/**
- * The pure key reducer. `key` is a single logical key: a digit "1".."4",
- * "space", "up"/"down", "left" (walk back), "enter", "t" (type your own),
- * or "esc". The custom phase's TEXT is not routed here — the editor owns
- * the buffer exactly as it does for the rule-input phase, and hands the
- * committed line to `askCommitCustom`.
- */
+/** REL-0152-D4: is the cursor on the type-your-own row? The editor asks
+ *  before it decides what a printable key means — on this row a key is
+ *  the first character of an answer, everywhere else it is a shortcut.
+ *  Exported so that rule lives on ONE definition of the row. */
+export declare function askOnCustomRow(spec: AskSpec, state: AskRuntime): boolean;
 export declare function askKey(spec: AskSpec, state: AskRuntime, key: string): AskStep;
 /** The typed answer commits: it becomes THE answer for this question
  *  (clearing its picks) and the walk advances. An empty line is a

package/dist/ask-panel.js

@@ -103,6 +103,18 @@ function toggle(state, option, multi) {
  * the buffer exactly as it does for the rule-input phase, and hands the
  * committed line to `askCommitCustom`.
  */
+/** REL-0152-D3 — the index of the type-your-own row: one past the last
+ *  option, which is where `askBlockRows` draws it. Options and this row
+ *  are one list to the eye, so they are one list to the cursor. */
+const customRow = (q) => q.options.length;
+/** REL-0152-D4: is the cursor on the type-your-own row? The editor asks
+ *  before it decides what a printable key means — on this row a key is
+ *  the first character of an answer, everywhere else it is a shortcut.
+ *  Exported so that rule lives on ONE definition of the row. */
+export function askOnCustomRow(spec, state) {
+    const q = spec.questions[state.qIndex];
+    return q !== undefined && state.phase === "options" && state.cursor === customRow(q);
+}
 export function askKey(spec, state, key) {
     const q = spec.questions[state.qIndex];
     const multi = q.multiSelect === true;
@@ -115,23 +127,39 @@ export function askKey(spec, state, key) {
     }
     if (key === "esc")
         return { state, result: askDeclineAll(spec) };
-    if (key === "t")
+    // `t` is the shortcut from anywhere in the list; `type` is the
+    // REL-0152-D4 gesture — the editor sends it when the cursor is
+    // already on the custom row and a printable key arrives, so the
+    // keystroke that opened the phase is also its first character.
+    if (key === "t" || key === "type")
         return { state: { ...state, phase: "custom" } };
     if (key === "left")
         return { state: state.qIndex === 0 ? state : { ...state, qIndex: state.qIndex - 1, cursor: 0 } };
     if (key === "up")
         return { state: { ...state, cursor: Math.max(0, state.cursor - 1) } };
+    // REL-0152-D3: the cursor range includes the type-your-own row, which
+    // askBlockRows renders as the list's last item. It used to stop one
+    // short, so a row the eye counts as fourth could not be reached by
+    // the key that walks the list — the affordance promised a list and
+    // delivered four of its five rows.
     if (key === "down")
-        return { state: { ...state, cursor: Math.min(q.options.length - 1, state.cursor + 1) } };
-    if (key === "enter")
+        return { state: { ...state, cursor: Math.min(customRow(q), state.cursor + 1) } };
+    if (key === "enter") {
+        // on the custom row, enter is the way in — the same gesture the
+        // row's neighbours answer with.
+        if (state.cursor === customRow(q))
+            return { state: { ...state, phase: "custom" } };
         return answered(state, state.qIndex) ? advance(spec, state) : { state };
+    }
     // SPACE selects at the cursor and NEVER commits — in either mode. It
     // used to answer-and-advance a single-select question, which made a
     // stray space (the most pressable key there is) an instant answer of
     // whatever the cursor happened to be on. Enter and the digits are the
     // only gestures that commit; space is how you point at something.
+    // space points at an option; on the custom row it opens the typing
+    // phase rather than toggling an option that is not there.
     if (key === "space")
-        return { state: toggle(state, state.cursor, multi) };
+        return state.cursor === customRow(q) ? { state: { ...state, phase: "custom" } } : { state: toggle(state, state.cursor, multi) };
     const digit = Number.parseInt(key, 10);
     if (Number.isInteger(digit) && digit >= 1 && digit <= q.options.length) {
         const next = toggle(state, digit - 1, multi);
@@ -181,10 +209,22 @@ export function askBlockRows(view, state, W, maxRows) {
     rows.push(cutLine(`${p.dim}─ ${multi ? "pick any — space toggles" : "pick one"} ─${p.reset}`, Math.max(1, W - 2)));
     const picks = state.picks[state.qIndex] ?? [];
     const body = q.options.map((o, i) => `${gutter}${optionRow(o, i + 1, picks.includes(i), state.cursor === i, multi, W)}`);
+    // REL-0152-D3: the row is part of the list, so it carries the same
+    // cursor affordance the options do. Dim-always made a reachable row
+    // look like a footnote.
     const typed = state.custom[state.qIndex];
-    body.push(`${gutter}${cutLine(typed === null || typed === undefined
-        ? `${p.dim} t   type your own answer${p.reset}`
-        : ` t ◉ ${escapeTerminal(typed)}`, Math.max(1, W - 2))}`);
+    const onCustom = state.cursor === customRow(q);
+    // REL-0152-D4: while the phase is OPEN the row becomes the answer's
+    // box — a faint placeholder standing where the text will land, so an
+    // empty typing phase looks like somewhere to type instead of looking
+    // like nothing happened. The placeholder is dim and the answer is
+    // not: the two can never be mistaken for each other.
+    const typingHere = state.phase === "custom";
+    body.push(`${gutter}${cutLine(typed !== null && typed !== undefined
+        ? `${onCustom || typingHere ? p.bold : ""} t ◉ ${escapeTerminal(typed)}${p.reset}`
+        : typingHere
+            ? `${p.bold} t ▸${p.reset} ${p.dim}type your answer — enter sends, esc backs out${p.reset}`
+            : `${onCustom ? p.bold : p.dim} t   type your own answer${p.reset}`, Math.max(1, W - 2))}`);
     // the bounded block: the options fold nothing and cut individually,
     // so the cap drops whole rows with the W21 notice row.
     const budget = Math.max(1, maxRows - 5);
@@ -222,7 +262,10 @@ export function askStatus(view, state) {
 /** The input row's lead: the digit lead while picking, the typing lead
  *  in the custom phase (the rule-input phase's shape, reused). */
 export function askLeadPlain(state) {
-    return state.phase === "custom" ? "your answer: " : "1-4> ";
+    // REL-0152-D3: "1-4> " was hard-coded and wrong twice over — it named
+    // a range even when there were two options, and it excluded the
+    // type-your-own row the list shows.
+    return state.phase === "custom" ? "your answer: " : "pick> ";
 }
 // ── the dispatchers: the panel slot, with the ask branch folded in ────
 export function panelBlockRows(view, phase, cursor, W, maxRows, ask, pick, note, safer) {

package/dist/editor.js

@@ -21,6 +21,7 @@
  * (?2004h) unwraps and inserts its newlines LITERALLY; every newline
  * source funnels through the ONE normalizer in feed() (§3).
  */
+var _a;
 import { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 // the width primitives moved to width.ts (W1, the single width
 // authority) — re-exported so the editor's public surface is unchanged.
@@ -29,7 +30,7 @@ import { palette } from "./render.js";
 import { PICK_MAX, panelOptions, saferDegradedNote, } from "./approval-panel.js";
 // KC3.5: the panel-slot dispatchers — the ask branch folded into the
 // W21 lead/rows, so this file keeps ONE panel and one key owner.
-import { askCommitCustom, askKey, askStart, panelLead } from "./ask-panel.js";
+import { askCommitCustom, askKey, askOnCustomRow, askStart, panelLead } from "./ask-panel.js";
 import { AT_VISIBLE, atFilter } from "./at-picker.js";
 // TUI2-R2 ②: the session picker — the band's THIRD occupant. Its filter
 // is the @ picker's rank aimed at the session id; the editor owns the
@@ -110,6 +111,29 @@ export class Editor {
     // user's next turn.
     #panel = null;
     #pasting = false;
+    /**
+     * REL-0152-D8 — the paste capsule.
+     *
+     * A paste large enough to break the composer's layout is held HERE
+     * and shown in the buffer as `[Pasted text #N +M lines]`. The buffer
+     * is the display; this map is the content; the line that LEAVES the
+     * editor is the content again. That ordering is the whole design —
+     * the capsule can never truncate what gets sent, because expansion
+     * happens on the way out and reads from a map the display cannot
+     * edit.
+     *
+     * A capsule the human deletes is a paste that never happened: the
+     * token is gone, the expansion finds nothing to replace, and the
+     * entry is simply never read. That is how you take a paste back.
+     *
+     * The map is per-editor and grows by one entry per large paste in a
+     * session — bounded by how many times a human can press cmd-V, and
+     * every entry is text they chose to paste and may still submit.
+     */
+    #pastes = new Map();
+    #pasteSeq = 0;
+    /** The buffer index where the in-flight paste began; null outside one. */
+    #pasteAt = null;
     /** TUI2-R3v2 ①: one-shot — a panel that just closed swallows the
      *  habitual trailing enter rather than submitting the restored draft. */
     #swallowEnter = false;
@@ -795,6 +819,22 @@ export class Editor {
                         i += 1;
                         continue;
                     }
+                    // REL-0152-D4 — on the custom row a printable key is TEXT.
+                    // The row names typing as its purpose and then swallowed
+                    // the first thing you typed; only enter or `t` opened the
+                    // phase. Now the keystroke opens it AND lands in the
+                    // buffer, so the character you meant is the character you
+                    // get. This is checked BEFORE the shortcut branch below on
+                    // purpose: on this row "3" and "t" are the start of an
+                    // answer, not a pick and not a mode key. Everywhere else
+                    // in the list they keep their fast-path meaning exactly.
+                    if (askOnCustomRow(panel.view.ask, panel.ask) && c !== undefined && c >= " " && c !== "\x7f") {
+                        this.#askStep("type");
+                        this.#insert(c.codePointAt(0));
+                        this.#onRender();
+                        i += 1;
+                        continue;
+                    }
                     if (!typing && (c === " " || (c !== undefined && c >= "1" && c <= "4") || c === "t" || c === "T")) {
                         this.#askStep(c === " " ? "space" : c === "T" ? "t" : c);
                         i += 1;
@@ -1186,10 +1226,13 @@ export class Editor {
             const n = Number(params);
             if (n === 3)
                 this.#delete();
-            else if (n === 200)
+            else if (n === 200) {
                 this.#pasting = true;
+                this.#pasteAt = this.#cursor; // REL-0152-D8: where the capsule will go
+            }
             else if (n === 201) {
                 this.#pasting = false;
+                this.#encapsulate();
                 this.#onRender();
             }
         }
@@ -1568,7 +1611,10 @@ export class Editor {
             return;
         const spec = panel.view.ask;
         const before = panel.ask.phase;
-        const step = key === "commit" ? askCommitCustom(spec, panel.ask, this.line()) : askKey(spec, panel.ask, key);
+        // REL-0152-D8: a typed ask answer is a line leaving the editor too —
+        // pasting a stack trace into "type your own answer" must send the
+        // stack trace, not the capsule that stands for it.
+        const step = key === "commit" ? askCommitCustom(spec, panel.ask, this.#expandPastes(this.line())) : askKey(spec, panel.ask, key);
         panel.ask = step.state;
         if (step.state.phase !== before) {
             this.#chars = [];
@@ -1737,6 +1783,67 @@ export class Editor {
      *  reset together (W22: a departing line ends the pop-walk, so the
      *  next esc at rest interrupts again). Shared by the submit and the
      *  redirect — the two doors a line can leave by. */
+    /**
+     * REL-0152-D8 — how big a paste has to be before it is a capsule.
+     *
+     * LINES first, because lines are what actually break the layout: the
+     * composer grows a row per line and walks up the terminal. The
+     * character bound catches the pathological one-liner, which wraps to
+     * the same screenful by another route.
+     *
+     * Below both, the paste is left exactly as it arrived. A four-line
+     * snippet is something you want to SEE in the composer, and a capsule
+     * there would be pure obstruction.
+     */
+    static #PASTE_LINES = 8;
+    static #PASTE_CHARS = 900;
+    /** The token a capsule shows as. Parsed back by the same regexp on
+     *  the way out — one definition, so the two can never drift. */
+    static #capsuleText(id, lines) {
+        return `[Pasted text #${id} +${lines} line${lines === 1 ? "" : "s"}]`;
+    }
+    static #CAPSULE = /\[Pasted text #(\d+) \+\d+ lines?\]/g;
+    /**
+     * Close an in-flight paste: if it was large, swap the pasted run out
+     * of the buffer for its capsule and keep the text.
+     *
+     * The swap is a splice at the recorded start, so a paste in the
+     * MIDDLE of a line leaves the prose on both sides of it untouched —
+     * the capsule is a character run like any other from here on, and
+     * every editing operation in this file works on it without knowing
+     * it exists.
+     */
+    #encapsulate() {
+        const start = this.#pasteAt;
+        this.#pasteAt = null;
+        if (start === null || this.#cursor <= start)
+            return;
+        const pasted = String.fromCodePoint(...this.#chars.slice(start, this.#cursor));
+        const lines = pasted.split("\n").length;
+        if (lines < _a.#PASTE_LINES && pasted.length < _a.#PASTE_CHARS)
+            return;
+        this.#pasteSeq += 1;
+        this.#pastes.set(this.#pasteSeq, pasted);
+        const capsule = [..._a.#capsuleText(this.#pasteSeq, lines)].map((ch) => ch.codePointAt(0));
+        this.#chars.splice(start, this.#cursor - start, ...capsule);
+        this.#cursor = start + capsule.length;
+        this.#reflow();
+    }
+    /**
+     * The way out: every capsule token becomes its text again.
+     *
+     * Applied to the line the editor HANDS OVER, never to the buffer —
+     * so what the human sees stays short and what the model receives is
+     * what the human pasted. A token whose entry is missing (a stale id
+     * recalled from history after the map moved on) is left standing as
+     * literal text rather than silently becoming an empty string: a
+     * visible oddity beats a silent deletion of someone's paste.
+     */
+    #expandPastes(line) {
+        if (this.#pastes.size === 0)
+            return line;
+        return line.replace(_a.#CAPSULE, (whole, id) => this.#pastes.get(Number(id)) ?? whole);
+    }
     #takeLine() {
         const line = String.fromCodePoint(...this.#chars);
         this.#chars = [];
@@ -1850,16 +1957,21 @@ export class Editor {
             }
         }
         const line = this.#takeLine();
+        // REL-0152-D8: the capsule expands ON THE WAY OUT. The consumer
+        // gets what was pasted; the HISTORY keeps the short form, so ↑
+        // recalls a readable line that still expands when it is sent
+        // again (the map outlives the buffer, by design).
+        const sent = this.#expandPastes(line);
         const cb = this.#questionCb;
         this.#questionCb = null;
         if (cb !== null) {
-            cb(line);
+            cb(sent);
         }
         else if (this.#lineCb !== null) {
-            this.#lineCb(line);
+            this.#lineCb(sent);
         }
         else {
-            this.#pendingLines.push(line); // nobody wired yet — hold it
+            this.#pendingLines.push(sent); // nobody wired yet — hold it
         }
         if (cb === null && line !== "")
             this.#remember(line);
@@ -1949,3 +2061,4 @@ export class Editor {
         return end;
     }
 }
+_a = Editor;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.15.2",
+	"version": "0.15.4",
 	"description": "kiso tui \u2014 the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.15.2"
+		"@vincemakes/kiso-tui-cells": "0.15.4"
 	}
 }

package/dist/body.d.ts

@@ -1,151 +0,0 @@
-/**
- * v2d — the body renderer: ONE writer for the stdout scroll region.
- *
- * The v2b/v2c body writes streamed directly (each event wrote its bytes),
- * so the tool lines, thinking folds, and text deltas could interleave in
- * the same frame — and a tool's life was scattered across several writes
- * (the "leak"). v2d: every event handler ONLY mutates cell state; the
- * Body's render loop is the only thing that writes the region.
- *
- * Frozen semantics: a completed cell prints its final form into the
- * scroll region ONCE and is never touched again. The ACTIVE TAIL — the
- * unfinished cells — renders at the region's bottom (between the frozen
- * area and the dock) and redraws in place, CSI 2026 wrapped. State
- * changes coalesce to ≥16ms frames; a 200ms heartbeat drives the running
- * spinners and elapsed timers. An over-height tail (rare) overflows to
- * freeze by completion order.
- *
- * Pipes / NO_COLOR: the Body runs in PASSTHROUGH — every mutation writes
- * the v2b/v2c line-mode bytes immediately, byte-for-byte (the existing
- * e2e guards it). The cell renderer never activates.
- *
- * The cell model is ours (UserCell / ThinkingCell / ToolCell / TextCell /
- * NoticeCell / raw block) — deliberately NOT pi's Component interface
- * shape (ADR-0040).
- */
-/** One completed-or-active body line. The renderer's only state. */
-export type BodyCell = {
-    kind: "user";
-    text: string;
-    done: true;
-} | {
-    kind: "thinking";
-    text: string;
-    done: boolean;
-} | {
-    kind: "tool";
-    name: string;
-    input: string;
-    state: "pending" | "approval" | "running" | "done";
-    isError: boolean;
-    resultText: string;
-    diff: import("./diff.js").DiffLine[] | null;
-    added: number;
-    removed: number;
-    startedAt: number | null;
-    doneAt: number | null;
-    done: boolean;
-} | {
-    kind: "text";
-    text: string;
-    done: boolean;
-} | {
-    kind: "notice";
-    text: string;
-    done: true;
-} | {
-    kind: "raw";
-    lines: string[];
-    done: true;
-} | {
-    kind: "terminal";
-    label: string;
-    line: string;
-    done: true;
-} | {
-    kind: "checklist";
-    header: string;
-    items: {
-        text: string;
-        status: "pending" | "active" | "done";
-    }[];
-    done: true;
-};
-export interface BodyOptions {
-    /** Is the cell renderer live? A color TTY with a real size — checked
-     *  per mutation (the TIOCSWINSZ can land after main constructs us). */
-    active: () => boolean;
-    /** The terminal height (rows) — live, for the region geometry. */
-    height: () => number;
-    /** The terminal width (cols) — live, for wrap estimates. */
-    width: () => number;
-    /** The input line's edit column — the render's cursor home. */
-    editCol: () => number;
-    /** The dock's redraw (the bottom three rows) — the body never writes
-     *  below the region, but the frame may call it to re-pin the chrome. */
-    onDock?: () => void;
-    /** The stdout writer — injectable for unit tests (default: stdout). */
-    write?: (s: string) => void;
-}
-export declare class Body {
-    #private;
-    constructor(opts: BodyOptions);
-    /** Teardown — flush a pending frame, stop the timers. */
-    close(): void;
-    /**
-     * #17 (P1): a resize reflows the terminal's buffer — the old chrome
-     * rows SURVIVE the reflow at their shifted positions (the recorded
-     * separator wall + the tail ghost — the #16a assumption that the
-     * reflow erases them was wrong). The handler: (1) clear the old tail +
-     * dock area with the OLD geometry (one ED from the last-drawn tail
-     * top; EL/ED only, zero LF — the #16 storm gate's invariants hold);
-     * (2) redraw immediately at the NEW geometry (the tail, the cursor
-     * home, the dock — via the normal render). The frozen content is
-     * strictly ABOVE the old tail top — the clear never touches it (the
-     * frozen bytes stay emitted exactly once). Consecutive resizes are
-     * idempotent: the clear covers an already-clear area.
-     */
-    onResize(): void;
-    /** The last COMPLETE thinking block, for /think. */
-    lastThinking(): string | null;
-    /** The last completed tool call, for /last. */
-    lastTool(): {
-        name: string;
-        input: Record<string, unknown>;
-        result: {
-            content: string;
-            isError: boolean;
-        };
-    } | null;
-    userLine(text: string): void;
-    thinkingAppend(text: string): void;
-    thinkingEnd(): void;
-    toolStart(name: string, callId: string, input: Record<string, unknown>): void;
-    toolApproval(callId: string, diff: import("./diff.js").DiffResult | null): void;
-    toolRunning(callId: string): void;
-    toolSucceeded(callId: string): void;
-    toolFailed(callId: string, error: string): void;
-    toolResult(callId: string, result: {
-        content: string;
-        isError: boolean;
-    }): void;
-    textAppend(text: string): void;
-    textEnd(): void;
-    /** The terminal's status line + the rhythm gap (one blank). */
-    terminal(label: string, statusLine: string): void;
-    notice(text: string): void;
-    /** ⑥ todo round: the durable checklist — header + one brick-glyph line
-     *  per item, frozen immediately (it is static content). The CLI
-     *  translates a tagged tool result into the structured items; the
-     *  passthrough writes the same lines (byte-identical in pipes). */
-    checklist(header: string, items: {
-        text: string;
-        status: "pending" | "active" | "done";
-    }[]): void;
-    /** A pre-rendered block (the banner, the session line, slash-command
-     *  outputs) — frozen immediately. */
-    raw(lines: string[]): void;
-    /** The one writer. Frozen cells print once; the tail redraws in place,
-     *  CSI 2026 wrapped; the cursor lands at the input edit column. */
-    render(): void;
-}