@vincemakes/kiso-code 0.1.29 → 0.1.31

package/dist/body.js

@@ -1,491 +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).
- */
-import { truncateDiff } from "./diff.js";
-import { displayWidth } from "./editor.js";
-import { escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, } from "./render.js";
-/** The spinner glyphs, cycled by the heartbeat (v3 §05 — the working family). */
-const SPINNER = ["▖", "▘", "▝", "▗"];
-const TOOL_SUMMARY_MAX = 60; // the tool line's parameter summary, chars
-const FRAME_MS = 16; // state changes coalesce to ≥16ms frames
-const HEARTBEAT_MS = 200; // spinner / elapsed cadence
-export class Body {
-    #active;
-    #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
-    #frameTimer = null;
-    #heartbeat = null;
-    #dirty = false;
-    #spinnerI = 0;
-    #lastThinking = null;
-    #lastTool = null;
-    #pendingCalls = new Map();
-    #pipeBuf = ""; // the passthrough's thinking buffer — the cell model needs no buffer
-    #toolCells = new Map(); // callId → cell index (parallel tools)
-    #write;
-    constructor(opts) {
-        this.#opts = opts;
-        this.#write = opts.write ?? ((s) => process.stdout.write(s));
-        this.#active = opts.active();
-        if (this.#isActive()) {
-            this.#heartbeat = setInterval(() => {
-                // #14/#15: the idle heartbeat PAINTS NOTHING unless an
-                // ANIMATION advances — only a RUNNING tool's glyph/elapsed
-                // changes between beats. The #14 fix skipped an all-frozen
-                // body; #15 widened the skip to ANY no-change body: a cell
-                // that stays unfinished without animating (an unclosed text
-                // or thinking block) would otherwise re-paint the tail AND
-                // the dock every 200ms with zero change — the short-session
-                // leak (measured: 51KB / 46 beats after the recap, LF=0).
-                if (!this.#cells.some((c) => c.kind === "tool" && c.state === "running"))
-                    return;
-                this.#spinnerI = (this.#spinnerI + 1) % SPINNER.length;
-                this.#dirty = true; // the running cells' glyph/elapsed advance
-                this.#scheduleFrame();
-            }, HEARTBEAT_MS);
-            this.#heartbeat.unref();
-        }
-    }
-    /** Live re-check — a TTY whose size lands after construction flips in. */
-    #isActive() {
-        this.#active = this.#opts.active();
-        return this.#active;
-    }
-    /** Teardown — flush a pending frame, stop the timers. */
-    close() {
-        if (this.#frameTimer !== null) {
-            clearTimeout(this.#frameTimer);
-            this.#frameTimer = null;
-        }
-        if (this.#heartbeat !== null) {
-            clearInterval(this.#heartbeat);
-            this.#heartbeat = null;
-        }
-        if (this.#dirty)
-            this.render();
-    }
-    /** The last COMPLETE thinking block, for /think. */
-    lastThinking() {
-        return this.#lastThinking;
-    }
-    /** The last completed tool call, for /last. */
-    lastTool() {
-        return this.#lastTool;
-    }
-    // ---- mutations (the ONLY way the CLI touches the body) ----
-    userLine(text) {
-        if (!this.#isActive()) {
-            this.#closeOpenThinking();
-            this.#closeOpenText();
-            const p = palette();
-            this.#write(`${p.blue}you> ${escapeTerminal(text)}${p.reset}\n`);
-            return;
-        }
-        this.#closeOpenThinking();
-        this.#closeOpenText();
-        this.#cells.push({ kind: "user", text, done: true });
-        this.#mark();
-    }
-    thinkingAppend(text) {
-        if (!this.#isActive()) {
-            this.#pipeBuf += text; // buffered; the fold prints at the block's end
-            return;
-        }
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "thinking" && !last.done) {
-            last.text += text;
-        }
-        else {
-            this.#cells.push({ kind: "thinking", text, done: false });
-        }
-        this.#mark();
-    }
-    thinkingEnd() {
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "thinking" && !last.done) {
-            last.done = true;
-            this.#lastThinking = last.text;
-            if (!this.#isActive())
-                process.stdout.write(foldThinking(last.text));
-            this.#mark();
-        }
-    }
-    toolStart(name, callId, input) {
-        const summary = JSON.stringify(input).slice(0, TOOL_SUMMARY_MAX);
-        // Registered BEFORE the passthrough branch — /last and the pipe
-        // summary need the call on BOTH paths.
-        this.#pendingCalls.set(callId, { name, input, result: { content: "", isError: false } });
-        if (!this.#isActive()) {
-            this.#closeOpenThinking();
-            this.#closeOpenText();
-            process.stdout.write(`→ ${escapeTerminal(name)}(${escapeTerminal(JSON.stringify(input).slice(0, 200))})\n`);
-            return;
-        }
-        this.#toolCells.set(callId, this.#cells.length);
-        this.#cells.push({ kind: "tool", name, input: summary, state: "pending", isError: false, resultText: "", diff: null, added: 0, removed: 0, startedAt: null, doneAt: null, done: false });
-        this.#mark();
-    }
-    toolApproval(callId, diff) {
-        if (!this.#isActive())
-            return;
-        const cell = this.#toolCell(callId);
-        if (cell !== null && cell.kind === "tool" && !cell.done) {
-            cell.state = "approval";
-            // v2e: the mini-diff renders BELOW the tool line at the approval
-            // moment — the human sees the change before deciding. Auto-allowed
-            // tools pass null (nobody is looking — no diff, no cost).
-            cell.diff = diff === null ? null : truncateDiff(diff.lines);
-            cell.added = diff?.added ?? 0;
-            cell.removed = diff?.removed ?? 0;
-        }
-        this.#mark();
-    }
-    toolRunning(callId) {
-        if (!this.#isActive()) {
-            const p = palette();
-            process.stdout.write(`${p.dim}  running…${p.reset}\n`);
-            return;
-        }
-        const cell = this.#toolCell(callId);
-        if (cell !== null && cell.kind === "tool" && !cell.done) {
-            cell.state = "running";
-            cell.startedAt = Date.now();
-        }
-        this.#mark();
-    }
-    toolSucceeded(callId) {
-        if (!this.#isActive()) {
-            process.stdout.write(`  ok\n`);
-        }
-    }
-    toolFailed(callId, error) {
-        if (!this.#isActive()) {
-            const p = palette();
-            process.stdout.write(`${p.red}  failed: ${escapeTerminal(error.slice(0, 160))}${p.reset}\n`);
-        }
-    }
-    toolResult(callId, result) {
-        const call = this.#pendingCalls.get(callId);
-        if (call !== undefined) {
-            call.result = result;
-            this.#lastTool = { name: call.name, input: call.input, result };
-            this.#pendingCalls.delete(callId);
-        }
-        if (!this.#isActive()) {
-            // The v2b/v2c pipe bytes: the summary line + the [result] line.
-            const p = palette();
-            process.stdout.write(`${renderToolSummary(call?.name ?? "?", call?.input ?? {}, result)}\n` +
-                `${p.dim}${result.isError ? p.red : p.dim}  [result${result.isError ? " ✗" : ""}] ${foldResult(result.content)}${p.reset}\n`);
-            return;
-        }
-        const cell = this.#toolCell(callId);
-        this.#toolCells.delete(callId);
-        if (cell !== null && cell.kind === "tool" && !cell.done) {
-            cell.state = "done";
-            cell.isError = result.isError;
-            cell.resultText = result.content;
-            cell.doneAt = Date.now();
-            cell.done = true;
-        }
-        this.#mark();
-    }
-    textAppend(text) {
-        if (!this.#isActive()) {
-            this.#closeOpenThinking();
-            this.#closeOpenText();
-            process.stdout.write(escapeTerminal(text));
-            return;
-        }
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "text" && !last.done) {
-            last.text += text;
-        }
-        else {
-            this.#closeOpenThinking();
-            this.#closeOpenText();
-            this.#cells.push({ kind: "text", text, done: false });
-        }
-        this.#mark();
-    }
-    textEnd() {
-        if (!this.#isActive()) {
-            process.stdout.write("\n");
-            return;
-        }
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "text" && !last.done)
-            last.done = true;
-        this.#mark();
-    }
-    /** The terminal's status line + the rhythm gap (one blank). */
-    terminal(label, statusLine) {
-        if (!this.#isActive()) {
-            this.#closeOpenThinking();
-            this.#closeOpenText();
-            // the v2c bytes: the terminal label (\ndone\n) + the status gap.
-            process.stdout.write(label + renderTerminalGap(statusLine));
-            return;
-        }
-        this.#closeOpenThinking();
-        this.#closeOpenText();
-        this.#cells.push({ kind: "terminal", label: label.trim(), line: statusLine, done: true });
-        this.#mark();
-    }
-    notice(text) {
-        if (!this.#isActive()) {
-            this.#closeOpenThinking();
-            this.#closeOpenText();
-            process.stdout.write(`${text}\n`);
-            return;
-        }
-        this.#closeOpenThinking();
-        this.#closeOpenText();
-        this.#cells.push({ kind: "notice", text, done: true });
-        this.#mark();
-    }
-    /** A pre-rendered block (the banner, the session line, slash-command
-     *  outputs) — frozen immediately. */
-    raw(lines) {
-        if (!this.#isActive()) {
-            this.#closeOpenThinking();
-            this.#closeOpenText();
-            for (const line of lines)
-                process.stdout.write(`${line}\n`);
-            return;
-        }
-        this.#closeOpenThinking();
-        this.#closeOpenText();
-        this.#cells.push({ kind: "raw", lines, done: true });
-        this.#mark();
-    }
-    // ---- rendering ----
-    #mark() {
-        if (!this.#isActive())
-            return;
-        this.#dirty = true;
-        this.#scheduleFrame();
-    }
-    #scheduleFrame() {
-        if (this.#frameTimer !== null)
-            return;
-        this.#frameTimer = setTimeout(() => {
-            this.#frameTimer = null;
-            if (this.#dirty) {
-                this.#dirty = false;
-                this.render();
-            }
-        }, FRAME_MS);
-        this.#frameTimer.unref();
-    }
-    /** The one writer. Frozen cells print once; the tail redraws in place,
-     *  CSI 2026 wrapped; the cursor lands at the input edit column. */
-    render() {
-        if (!this.#isActive())
-            return;
-        const H = this.#opts.height();
-        const W = this.#opts.width();
-        if (H < 4)
-            return;
-        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.
-        // 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;
-        const tail = this.#cells.slice(nextFrozen);
-        const tailHeight = tail.reduce((n, c) => n + 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;
-                }
-            }
-            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.
-        out.push("\x1b[?2026h");
-        const clearFrom = Math.min(this.#oldTailTop === 0 ? tailTop : this.#oldTailTop - scrolled, tailTop);
-        for (let row = clearFrom; row <= H - 4; row += 1) {
-            out.push(`\x1b[${row};1H\x1b[0K`);
-        }
-        let row = tailTop;
-        for (const cell of tail) {
-            for (const line of this.#cellLines(cell, W)) {
-                out.push(`\x1b[${row};1H${line}`);
-                row += 1;
-            }
-        }
-        // 3. the cursor home — the input line's edit column.
-        out.push(`\x1b[${H};${this.#opts.editCol()}H`);
-        out.push("\x1b[?2026l");
-        this.#write(out.join(""));
-        // 4. the dock rows — the freeze scrolls shifted them; redraw (the
-        // dock's own redraw re-pins the cursor at the edit position).
-        this.#opts.onDock?.();
-    }
-    // ---- cell → lines ----
-    #cellLines(cell, W) {
-        const p = palette();
-        switch (cell.kind) {
-            case "user":
-                // v3 §02: the user message is a SGR BACKGROUND block, no
-                // prefix — every line carries the block's background
-                // (multi-line whole; resize-safe). Pipes stay plain.
-                return cell.text.split("\n").map((l) => `${p.bg}${escapeTerminal(l)}${p.reset}`);
-            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}`];
-            }
-            case "tool": {
-                const name = escapeTerminal(cell.name);
-                const summary = escapeTerminal(cell.input);
-                if (cell.state === "done") {
-                    const elapsed = cell.startedAt !== null && cell.doneAt !== null ? ((cell.doneAt - cell.startedAt) / 1000).toFixed(1) : "?";
-                    if (cell.isError) {
-                        const err = escapeTerminal(cell.resultText.split("\n")[0].slice(0, 60));
-                        return [`${p.red}✗ ${name} (${err}, ${elapsed}s)${p.reset}`];
-                    }
-                    const delta = cell.added + cell.removed > 0 ? `, +${cell.added} -${cell.removed}` : "";
-                    return [`${p.blue}✓ ${name}${p.reset} (${summary}${delta}, ${elapsed}s)`];
-                }
-                if (cell.state === "approval") {
-                    const lines = [`→ ${name} ${summary} ${p.blue}⏸${p.reset}`];
-                    // v2e: the mini-diff — ▎ blue edge (the brick motif), - red /
-                    // + green / context dim; NO_COLOR keeps the ± prefixes plain.
-                    if (cell.diff !== null) {
-                        for (const d of cell.diff) {
-                            const body = d.kind === "-"
-                                ? `${p.red}- ${escapeTerminal(d.text)}${p.reset}`
-                                : d.kind === "+"
-                                    ? `${p.green}+ ${escapeTerminal(d.text)}${p.reset}`
-                                    : `${p.dim}  ${escapeTerminal(d.text)}${p.reset}`;
-                            lines.push(`${p.blue}▎${p.reset}${body}`);
-                        }
-                    }
-                    return lines;
-                }
-                if (cell.state === "running") {
-                    const elapsed = cell.startedAt !== null ? Math.max(1, Math.round((Date.now() - cell.startedAt) / 1000)) : 1;
-                    return [`→ ${name} ${summary} ${p.blue}${SPINNER[this.#spinnerI % SPINNER.length]}${p.reset} ${elapsed}s`];
-                }
-                return [`→ ${name} ${summary}`];
-            }
-            case "text": {
-                const text = escapeTerminal(cell.text);
-                const wrapped = this.#wrap(text, W);
-                return wrapped.length > 0 ? wrapped : [""];
-            }
-            case "notice":
-                return [escapeTerminal(cell.text)];
-            case "raw":
-                return cell.lines.map((l) => escapeTerminal(l));
-            case "terminal":
-                // the honest label (done / aborted / error) + the status + the
-                // rhythm gap blank
-                return [cell.label, cell.line, ""];
-        }
-    }
-    #cellHeight(cell, W) {
-        const lines = this.#cellLines(cell, W);
-        return Math.max(1, lines.length);
-    }
-    /** Wrap a body text by display width (the terminal's own wrapping,
-     *  approximated — documented; the region clamp keeps the dock safe). */
-    #wrap(text, W) {
-        if (W < 4)
-            return [text];
-        const out = [];
-        let current = "";
-        let width = 0;
-        for (const ch of text) {
-            const cw = displayWidth(ch);
-            if (ch === "\n" || width + cw > W) {
-                out.push(current);
-                current = "";
-                width = 0;
-                if (ch === "\n")
-                    continue;
-            }
-            current += ch;
-            width += cw;
-        }
-        out.push(current);
-        return out;
-    }
-    #toolCell(callId) {
-        const i = this.#toolCells.get(callId);
-        return i === undefined ? null : (this.#cells[i] ?? null);
-    }
-    /** Close an open TEXT cell when a new cell starts — the runtime emits
-     *  no text_end (it is an adapter-level event), so the stream's next
-     *  cell is the close signal; without it the freeze blocks behind the
-     *  open text and everything after it re-renders in the tail forever
-     *  (the #13 flood reproduced the overwrite). */
-    #closeOpenText() {
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "text" && !last.done)
-            last.done = true;
-    }
-    /** Close an open thinking cell when a new cell starts (the block's
-     *  fold freezes at the transition). */
-    #closeOpenThinking() {
-        if (!this.#isActive() && this.#pipeBuf !== "") {
-            this.#lastThinking = this.#pipeBuf;
-            process.stdout.write(foldThinking(this.#pipeBuf));
-            this.#pipeBuf = "";
-            return;
-        }
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "thinking" && !last.done) {
-            last.done = true;
-            this.#lastThinking = last.text;
-        }
-    }
-}

package/dist/dock.d.ts

@@ -1,75 +0,0 @@
-/**
- * v2b/v2c — the bottom-anchored UI (TTY + color only). Borrows pi-tui's
- * IDEA — a DECSTBM scroll region with a reserved bottom — without its
- * implementation: zero dependencies, line-level ANSI, no differential
- * renderer.
- *
- * Layout (H = terminal height): rows 1..H-4 = the scroll region (the body
- * streams and scrolls here, never touching the bottom), row H-3 = the
- * upper dim dotted separator (╌), row H-2 = the input line (the blue
- * brick ▌you> + the v2c editor's row — readline is gone from the TTY
- * path), row H-1 = the lower dotted separator, row H = the live status
- * bar (v3 §03: idle "▸ <mode> · /mode to switch · …", running
- * "▖ working Ns · …"; a takeover question replaces it). Bottom redraws
- * are wrapped in CSI 2026 (synchronized output) to avoid flicker — the
- * pi trick. The visual identity is the kiso brick motif — ▌ half-block,
- * dotted separators — deliberately NOT the CC rounded frame nor the pi
- * editor (ADR-0039 Amendment 2).
- *
- * Pipes / NO_COLOR: the dock never activates; the v2a line mode stays
- * byte-for-byte (the existing e2e assertions guard it).
- */
-export declare class Dock {
-    #private;
-    /** v2b: docked only on a color TTY — pipes and NO_COLOR stay v2a. */
-    get active(): boolean;
-    /** Bind the CURRENT input line's state — called when a readline takes
-     *  over (the chat REPL, the trust question's short-lived rl, resume). */
-    bindInput(state: () => {
-        line: string;
-        cursor: number;
-    }, prompt: string): void;
-    /** Enter docked mode: draw the chrome. #13 (P1): the DECSTBM scroll
-     *  region is GONE — v2d-B (ADR-0040): the body uses plain LF scrolling
-     *  so frozen lines enter the native scrollback deterministically
-     *  (region-scrolled lines are terminal-dependent — some terminals drop
-     *  them). The dock rows are redrawn by the body after every scroll. A
-     *  TTY without a real window size (rows < 4) stays in the v2a line
-     *  mode — the bottom three rows need room to exist. */
-    enter(): void;
-    /** Teardown — CSI r resets the scroll region, the cursor lands at the
-     *  input line, the bottom rows are cleared: no broken terminal. Called
-     *  from main's finally on EVERY exit path (kill -9 excepted — README:
-     *  `reset` saves it). */
-    exit(): void;
-    /** SIGWINCH: recompute the size, redraw the chrome. */
-    onResize(): void;
-    /** v3 §04: bind the editor's slash-command menu state — the menu rows
-     *  render ABOVE the chrome (over the body's bottom rows; the menu
-     *  opens while the buffer is a "/" prefix, when no tail is live). */
-    bindMenu(state: () => {
-        items: readonly import("./editor.js").MenuItem[];
-        selected: number;
-    } | null): void;
-    /** The input line's edit column — prompt width + cursor + 1. The
-     *  dock's redraw and the body's cursor return both end here, so the
-     *  ACTUAL cursor always equals what the editor tracks. The width is
-     *  DISPLAY width (the editor's cursor column is already width-based —
-     *  the CJK drift root cause, editor.ts). v2d: public — the Body's
-     *  render loop ends at this column. */
-    editCol(): number;
-    /** The status bar's base text (usage, ctx, session, …). */
-    setStatus(text: string): void;
-    /** The live tail — the spinner glyph or "running <tool> Ns". */
-    setTail(tail: string): void;
-    /** Show a takeover question at the status position (answered at the
-     *  input line by the caller's readline); clearQuestion() restores. */
-    showQuestion(question: string): void;
-    clearQuestion(): void;
-    /** The bottom four rows, wrapped in CSI 2026 (synchronized output —
-     *  the pi trick against flicker). The cursor ends at the input line's
-     *  edit position. v3 §03: the upper ╌ row, the input row, the lower
-     *  ╌ row, the status row — the status is dim (blue accents inside
-     *  come from the CLI's composition). */
-    redraw(): void;
-}