@vincemakes/kiso-tui 0.1.29 → 0.1.32

package/dist/body.d.ts

@@ -93,12 +93,17 @@ export declare class Body {
     /** Teardown — flush a pending frame, stop the timers. */
     close(): void;
     /**
-     * TUI v4 #16a: a resize reflows the terminal's scrollback — the frozen
-     * rows' positions are no longer what we tracked (and the frozen CONTENT
-     * is never re-emitted: the terminal reflowed it, we only redraw the
-     * dock + active tail). The counters reset so the next render writes new
-     * frozen lines through the REAL-LF scroll path above the tail, never at
-     * a stale CUP row (the drag-garbage the #16 user saw).
+     * #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. */

package/dist/body.js

@@ -36,8 +36,9 @@ export class Body {
     #opts;
     #cells = [];
     #nextFrozen = 0; // index of the first not-yet-printed cell
-    #frozenRows = 0; // the frozen area's rows filled WITHOUT scrolling (then the real LFs take over)
-    #oldTailTop = 0; // the tail's previous first row — for the clear pass
+    #height = 0; // the last DRAWN height — the resize handler clears with the OLD geometry
+    #oldTailTop = 0; // the last-drawn tail top — the clear pass + the resize handler's clear
+    #oldTailHeight = 0; // the last-drawn tail's height — the clear covers EXACTLY it (never the frozen area)
     #frameTimer = null;
     #heartbeat = null;
     #dirty = false;
@@ -53,14 +54,13 @@ export class Body {
         this.#opts = opts;
         this.#write = opts.write ?? ((s) => process.stdout.write(s));
         this.#active = opts.active();
+        this.#height = opts.height();
         if (this.#isActive()) {
-            // TUI v4 #16a: the resize event — the terminal reflows its
-            // scrollback, so OUR row bookkeeping is stale. The frozen
-            // content is never re-emitted (the terminal reflowed it); the
-            // counters reset so the next render lands new frozen lines via
-            // the REAL-LF scroll path (just above the tail), never at stale
-            // CUP rows — the overwrite garbage after a drag (the #16
-            // defect). The dock redraws its own chrome on the same event.
+            // #17 (P1): the resize handler — clear the OLD tail + dock area
+            // (old geometry, EL/ED only — no LF), then redraw at the new
+            // geometry. The #16a assumption is retired: the terminal's
+            // reflow does NOT erase the old chrome rows (the recorded
+            // separator wall + the tail ghost prove it) — the clear does.
             this.#resizeHandler = () => this.onResize();
             process.stdout.on("resize", this.#resizeHandler);
             this.#heartbeat = setInterval(() => {
@@ -104,23 +104,31 @@ export class Body {
             this.render();
     }
     /**
-     * TUI v4 #16a: a resize reflows the terminal's scrollback — the frozen
-     * rows' positions are no longer what we tracked (and the frozen CONTENT
-     * is never re-emitted: the terminal reflowed it, we only redraw the
-     * dock + active tail). The counters reset so the next render writes new
-     * frozen lines through the REAL-LF scroll path above the tail, never at
-     * a stale CUP row (the drag-garbage the #16 user saw).
+     * #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() {
         if (!this.#isActive())
             return;
-        this.#frozenRows = Number.MAX_SAFE_INTEGER; // the frozen area is "full" — the next line scrolls
-        this.#oldTailTop = 0; // the reflowed tail's old rows are gone — clear only the new area
-        // NO #dirty: an immediate frame would re-render the ACTIVE TAIL —
-        // re-emitting its bytes (the terminal already reflowed the tail's
-        // content; a re-print duplicates the text in the byte stream — the
-        // #16 storm gate's "response text exactly once"). The geometry
-        // reset takes effect at the next NATURAL render (the next event).
+        const from = this.#oldTailTop > 0 ? this.#oldTailTop : Math.max(1, this.#height - 3);
+        const H = this.#opts.height(); // the NEW height — the clamp for a shrunk screen
+        const out = [];
+        // The cursor home + the ED land with the NEW geometry — rows beyond
+        // the old screen are already gone; rows below the old tail top are
+        // exactly the tail + the dock areas (the old tail, the old chrome).
+        out.push(`\x1b[${Math.min(from, Math.max(1, H))};1H\x1b[0J`);
+        this.#write(out.join(""));
+        this.#dirty = true; // the immediate redraw at the NEW geometry
+        this.render();
     }
     /** The last COMPLETE thinking block, for /think. */
     lastThinking() {
@@ -364,45 +372,63 @@ export class Body {
         const W = this.#opts.width();
         if (H < 4)
             return;
+        this.#height = H;
         const out = [];
-        // #13 (P1), v2d-B: NO DECSTBM — overflow scrolls with a REAL LF at
-        // the screen's last row, so the frozen lines enter the terminal's
-        // NATIVE scrollback deterministically (region-scrolled lines are
-        // terminal-dependent; some terminals drop them — the measured v2d-A
-        // defect). The body fills from the top without scrolling; once full,
-        // every new frozen line scrolls the whole screen (\x1b[H;1H\n — the
-        // top line leaves into the scrollback) and lands at the body's
-        // bottom row, just above the active tail. The dock is redrawn after.
+        // #13 (P1), v2d-B: NO DECSTBM — a frozen line scrolls with a REAL
+        // LF at the screen's last row (\x1b[H;1H\n — the top line leaves
+        // into the NATIVE scrollback) and lands at the body's bottom row,
+        // just above the active tail. The dock is redrawn after.
+        // #17 (P1): the pre-fill phase is GONE — EVERY frozen line takes
+        // this REAL-LF path, short sessions included. The old pre-fill drew
+        // at absolute CUP rows with NO real LF: the terminal's resize
+        // reflow treated those rows as soft lines — the recorded fold/body
+        // MERGE (the /think suffix lost), the tail ghost, the separator
+        // wall. A real-LF line reflows as ONE logical line, never merged
+        // with a neighbor; the only soft lines left are the active tail +
+        // the dock (small, redrawn every frame / cleared by onResize).
         // The tail (the remaining ACTIVE cells) and its geometry — computed
         // FIRST from the final nextFrozen, so the frozen cells are NOT in it
         // (a stale tail would re-draw them — the double-render).
         let nextFrozen = this.#nextFrozen;
         while (nextFrozen < this.#cells.length && this.#cells[nextFrozen].done)
             nextFrozen += 1;
+        // #17: the tail holds ONLY the unfinished cells — slice(nextFrozen)
+        // also captures the DONE cells that follow (an approval verdict
+        // freezing behind a live text+tool), inflating tailHeight so the
+        // tail's top rises INTO the frozen area and its clear pass wipes
+        // the freshly-frozen lines (the fold's /think suffix — recorded).
         const tail = this.#cells.slice(nextFrozen);
-        const tailHeight = tail.reduce((n, c) => n + this.#cellHeight(c, W), 0);
+        // #17: the tail HEIGHT counts only the unfinished cells — slice()
+        // also captures the DONE cells that follow (an approval verdict
+        // freezing behind a live text+tool); counting them inflates the
+        // height so the tail's top rises INTO the frozen area and its
+        // clear pass wipes the freshly-frozen lines (the fold's /think
+        // suffix — recorded). The tail array itself keeps the old shape.
+        const tailHeight = tail.reduce((n, c) => n + (c.done ? 0 : this.#cellHeight(c, W)), 0);
         const tailTop = Math.max(1, H - 3 - tailHeight); // v3 §03: 4 dock rows below
         const writeRow = Math.max(1, tailTop - 1); // the frozen area's bottom row
         let scrolled = 0;
         for (let i = this.#nextFrozen; i < nextFrozen; i += 1) {
             for (const line of this.#cellLines(this.#cells[i], W)) {
-                if (this.#frozenRows < writeRow) {
-                    this.#frozenRows += 1;
-                    out.push(`\x1b[${this.#frozenRows};1H\x1b[0K${line}`);
-                }
-                else {
-                    out.push(`\x1b[${H};1H\n`); // the REAL LF — the whole screen scrolls
-                    out.push(`\x1b[${writeRow};1H\x1b[0K${line}`);
-                    scrolled += 1;
-                }
+                out.push(`\x1b[${H};1H\n`); // the REAL LF — the whole screen scrolls
+                out.push(`\x1b[${writeRow};1H\x1b[0K${line}`);
+                scrolled += 1;
             }
             this.#nextFrozen += 1;
         }
-        // 2. the active tail — clear its old area (shifted up by the freeze
-        // scrolls) and the current area, draw the cells at the body's bottom.
+        // 2. the active tail — clear EXACTLY its old area (shifted up by the
+        // freeze scrolls) and the current area, draw the cells at the body's
+        // bottom. #17: the old code cleared clearFrom..H-4 unconditionally —
+        // harmless when the frozen lines sat at the TOP (pre-fill), but with
+        // the real-LF commits the frozen lines land just ABOVE the tail, so
+        // an over-wide clear wipes the freshly-frozen cells (the recorded
+        // fold/response vanishing).
         out.push("\x1b[?2026h");
+        const oldBottom = this.#oldTailHeight > 0 ? this.#oldTailTop + this.#oldTailHeight - 1 - scrolled : -1;
+        const newBottom = tailHeight > 0 ? tailTop + tailHeight - 1 : -1;
         const clearFrom = Math.min(this.#oldTailTop === 0 ? tailTop : this.#oldTailTop - scrolled, tailTop);
-        for (let row = clearFrom; row <= H - 4; row += 1) {
+        const clearTo = Math.max(oldBottom, newBottom);
+        for (let row = clearFrom; row <= Math.min(clearTo, H - 4); row += 1) {
             out.push(`\x1b[${row};1H\x1b[0K`);
         }
         let row = tailTop;
@@ -412,6 +438,8 @@ export class Body {
                 row += 1;
             }
         }
+        this.#oldTailTop = tailTop; // the last-drawn tail top — the resize clear starts here
+        this.#oldTailHeight = tailHeight;
         // 3. the cursor home — the input line's edit column.
         out.push(`\x1b[${H};${this.#opts.editCol()}H`);
         out.push("\x1b[?2026l");
@@ -429,14 +457,22 @@ export class Body {
                 // rail — a bright-white BOLD ▍ per line, then the text (the
                 // reverse-video block is RETIRED: it washed out on light
                 // themes). Multi-line whole: every line carries the rail
-                // (多行连贯); resize-safe; NO_COLOR → the rail renders plain.
+                // (coherent across lines); resize-safe; NO_COLOR → the rail renders plain.
                 return cell.text.split("\n").map((l) => `${p.bold}▍${p.reset} ${escapeTerminal(l)}`);
             case "thinking": {
                 const block = cell.text;
                 const trimmed = escapeTerminal(block.trim());
                 if (trimmed.length <= 100)
                     return [`${p.dim}…${trimmed}${p.reset}`];
-                return [`${p.dim}…${trimmed.slice(0, 100)} (${block.length} chars · /think)${p.reset}`];
+                const suffix = ` (${block.length} chars · /think)`;
+                // #17: the fold must FIT its row — every frozen line commits
+                // via the REAL-LF scroll path at the SAME write row; a
+                // soft-wrapped fold's continuation row would be clobbered by
+                // the next line's commit write (the /think suffix lost — the
+                // recorded symptom). The slice shrinks with the width; the
+                // suffix always rides the fold's own row.
+                const slice = Math.max(1, W - 1 - suffix.length);
+                return [`${p.dim}…${trimmed.slice(0, slice)}${suffix}${p.reset}`];
             }
             case "tool": {
                 const name = escapeTerminal(cell.name);
@@ -478,7 +514,7 @@ export class Body {
                 // TUI v5 #16e: the inline-code tint — backtick spans in
                 // assistant body text, matched PER LINE after the wrap (a
                 // span opened on one line and closed on another does NOT
-                // match — 跨行不匹配). NO_COLOR → the codes are empty →
+                // match — no cross-line matching). NO_COLOR → the codes are empty →
                 // byte-identical.
                 return wrapped.length > 0 ? wrapped.map((l) => colorInlineCode(l)) : [""];
             }
@@ -490,7 +526,7 @@ export class Body {
                 // SGR is applied at COMPOSITION time (renderRecap/startupBanner),
                 // and model/tool content was already escapeTerminal'd there.
                 // Re-escaping at render STRIPPED the ESC from the SGR — the
-                // literal "[38;5;75m▞[0m" garbage the user saw (the #16 乱码,
+                // literal "[38;5;75m▞[0m" garbage the user saw (the #16 mojibake,
                 // also the banner's dim). Verbatim: the injection guard lives
                 // at composition, not here.
                 return cell.lines;

package/dist/components.d.ts

@@ -0,0 +1,116 @@
+/**
+ * TUI v6 (ADR-0046) — the components: EVERY screen line's renderer.
+ *
+ * Each component turns one piece of state into display lines (SGR
+ * included, raw — the compositor writes them verbatim). The folding
+ * lives HERE: every line a component returns must fit the terminal
+ * width — the compositor's crash-on-violation invariant backs it up
+ * (a component that forgets to fold CRASHES with a diagnostic, never
+ * silently truncates — pi tui-main-screen.ts:447-473).
+ *
+ * The fold is SGR-AWARE: a line whose bold/dim span would straddle a
+ * fold boundary closes the span at the break and reopens it on the
+ * next row — the #16b contract (no literal "[2m" fragments) survives
+ * folding. displayWidth/charWidth (editor.ts) are the width primitives
+ * (untouched); render.ts supplies the original text (palette, escape,
+ * tint, fold wording).
+ */
+import { foldThinking, foldResult, renderToolSummary } from "./render.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
+ *  that make a live render non-deterministic (the running tool's glyph
+ *  and elapsed). Everything else is a pure function of the cell. */
+export interface FrameCtx {
+    readonly spinnerI: number;
+    readonly now: number;
+}
+/** ONE screen line a component emits (raw, SGR included). */
+export type RenderLine = string;
+/**
+ * The fold — split a display-width line into ≤W rows, preserving SGR
+ * spans across the break: a span open at the break closes (reset) at
+ * the row's end and reopens on the next row. The rows are what the
+ * terminal's own soft-wrap would have produced — except the compositor
+ * folds FIRST, so the terminal never reflows a component's line (the
+ * #17 merge class cannot reach committed content).
+ */
+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;
+/** A component: render the display lines for one piece of state. */
+export interface Component {
+    render(width: number, ctx: FrameCtx): string[];
+}
+/** The container — vertical concatenation of its children. */
+export declare class Container implements Component {
+    private readonly children;
+    constructor(children: Component[]);
+    render(width: number, ctx: FrameCtx): string[];
+}
+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;
+};
+declare const TOOL_SUMMARY_MAX = 60;
+/** The component for one cell — the mapping table lives here so the
+ *  compositor stays a pure writer. */
+export declare function cellComponent(cell: BodyCell): Component;
+/** The status container's row: the status text (+ the tail) with the
+ *  right-aligned "/ commands · ↑ history" hint in the idle state —
+ *  the hint CUT FIRST when the width is short (the #16g rule); when
+ *  the STATUS ITSELF cannot fit, it cuts with a "…" — the last resort,
+ *  enforced by invariant ① (the old code let the status soft-wrap). */
+export declare function statusLine(status: string, tail: string, question: boolean, W: number): string;
+/** The footer — the ONE dotted row (the old two-row chrome is gone;
+ *  the wall cannot return by construction). */
+export declare function footerLine(W: number): string;
+/** The terminal label + rhythm gap (the pipe path's v2c bytes — the
+ *  exact render the passthrough needs). */
+export declare function terminalPipe(label: string, statusLineText: string): string;
+/** The pipe-path pieces the passthrough reuses (byte-identical). */
+export { foldThinking, foldResult, renderToolSummary, TOOL_SUMMARY_MAX };