@vincemakes/kiso-tui 0.5.0 → 0.6.0

package/dist/editor.d.ts

@@ -48,6 +48,11 @@ export declare class Editor {
     onEot(cb: () => void): void;
     onEscape(cb: () => void): void;
     onExpand(cb: () => void): void;
+    /** KC2 §2: the redirect chain — the gesture hands the buffer's text
+     *  over while the run is told to stop. Mirrors onEscape (a list, so
+     *  listeners can coexist); the line arrives already gone from the
+     *  composer, exactly as a submit's does. */
+    onRedirect(cb: (line: string) => void): void;
     /** W22: bind the pending-turn queue — the CLI's live slots. The ↑
      *  pop walks them (each pop leaves the queue, cancelling the turn);
      *  esc ends the walk after one more pop. */

package/dist/editor.js

@@ -87,6 +87,12 @@ export class Editor {
     // (dispatch) coexist; a listener removes itself via an unarmed guard
     // (the compact's handler no-ops after its abort has fired).
     #escapeCbs = [];
+    // KC2 §2: the redirect LIST — mirrors #escapeCbs. The editor FORWARDS
+    // the gesture with the buffer's text; it never interprets it. What a
+    // redirect MEANS (abort the run, then run THIS ahead of the queue) is
+    // the CLI's — here it is only "these two keys, pressed together, hand
+    // the line over by a different door than Enter's".
+    #redirectCbs = [];
     // W15: the expand-key list (ctrl+r) — the CLI's dispatch decides the
     // target (a live cell toggles in place; a committed cell appends the
     // expanded block). Mirrors the escape list: multiple listeners can
@@ -144,6 +150,13 @@ export class Editor {
     onExpand(cb) {
         this.#expandCbs.push(cb);
     }
+    /** KC2 §2: the redirect chain — the gesture hands the buffer's text
+     *  over while the run is told to stop. Mirrors onEscape (a list, so
+     *  listeners can coexist); the line arrives already gone from the
+     *  composer, exactly as a submit's does. */
+    onRedirect(cb) {
+        this.#redirectCbs.push(cb);
+    }
     /** W22: bind the pending-turn queue — the CLI's live slots. The ↑
      *  pop walks them (each pop leaves the queue, cancelling the turn);
      *  esc ends the walk after one more pop. */
@@ -408,6 +421,17 @@ export class Editor {
                 else if (rest.startsWith("O")) {
                     i += 3; // SS3 (function keys) — ignored
                 }
+                else if (rest.startsWith("\x0d") && this.#composerIdle()) {
+                    // KC2 §2 — Alt+Enter. A terminal sends Alt+X as ESC and X in
+                    // ONE write, so SAME-CHUNK is the whole test: no timer, no
+                    // hold, nothing parked. The identical two bytes arriving in
+                    // SEPARATE chunks are NOT combined — they fall to the branch
+                    // below, where the bare Esc fires at once (its immediacy is
+                    // exactly what a hold would spend) and the next chunk's CR
+                    // submits: today's two gestures, untouched.
+                    this.#redirect();
+                    i += 2; // both bytes belong to the one gesture
+                }
                 else if (this.#menuOpen) {
                     // v3 §04: Esc closes the menu and clears the buffer.
                     // CA-4: the closing esc consumes its burst (the `i += 1`
@@ -541,6 +565,18 @@ export class Editor {
             this.#insert(NEWLINE);
             return;
         }
+        // KC2 §2 — Ctrl+Enter, the SAME two encodings with modifier 5
+        // (1 + ctrl): kitty's CSI-u and xterm's modifyOtherKeys. Never
+        // claimed universal — a terminal that encodes neither sends a plain
+        // CR, which is an ordinary submit/queue (the safe degrade). The
+        // chunk-split safety is the existing #pending CSI resume, shared
+        // with Shift+Enter above. Outside the normal composer state the
+        // sequence is simply unknown, exactly like any other stray CSI.
+        if ((final === "u" && params === "13;5") || (final === "~" && params === "27;5;13")) {
+            if (this.#composerIdle())
+                this.#redirect();
+            return;
+        }
         if (final === "~") {
             const n = Number(params);
             if (n === 3)
@@ -783,8 +819,76 @@ export class Editor {
         this.#cursor = i;
         this.#reflow();
     }
+    /** KC1/KC2 — the buffer LEAVES: the flat chars, the cursor, the
+     *  horizontal scroll, the ↑/↓ goal, the menu and the pop-walk all
+     *  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. */
+    #takeLine() {
+        const line = String.fromCodePoint(...this.#chars);
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#scroll = 0;
+        this.#verticalGoalCol = null;
+        this.#menuOpen = false;
+        this.#menuSel = 0;
+        this.#queuePopMode = false;
+        return line;
+    }
+    /** A2: the history remembers submitted TURN lines — never question
+     *  answers, never empties; adjacent duplicates collapse, the tail
+     *  caps at 100. A redirect is a turn, so it is remembered too. */
+    #remember(line) {
+        if (this.#history[this.#history.length - 1] !== line)
+            this.#history.push(line);
+        if (this.#history.length > 100)
+            this.#history.shift();
+    }
+    /** KC2 §2 — the NORMAL composer state: the redirect gesture is live
+     *  ONLY here. The approval panel, the slash menu, the history browse
+     *  and the queue-pop walk each OWN their keys first (the W21 "the
+     *  panel owns the keys" design, restated as a gate); a pending
+     *  question is the panel's dock-less twin (askPanel routes to
+     *  question() when the dock cannot render, so the ask owns the keys
+     *  there too); and a bracketed paste is literal TEXT, where an ESC CR
+     *  is the pasted content's own bytes and never a keypress. In every
+     *  one of those states the two bytes fall through to today's
+     *  handling — two gestures, unchanged. */
+    #composerIdle() {
+        return (this.#panel === null &&
+            !this.#menuOpen &&
+            this.#historyIdx === null &&
+            !this.#queuePopMode &&
+            !this.#pasting &&
+            this.#questionCb === null);
+    }
+    /**
+     * KC2 §2 — the gesture's meaning, kept as small as it can honestly be.
+     *
+     * An EMPTY buffer carries no correction, so the gesture degenerates to
+     * the bare Esc: the abort alone, nothing submitted. With text, the
+     * line leaves exactly as a submit's does and the listeners decide (the
+     * CLI aborts a live run and front-jumps the correction; idle, it is
+     * simply an Enter). UNWIRED — the recovery flow never binds it — the
+     * gesture IS a submit: a line is never lost to a missing binding.
+     */
+    #redirect() {
+        if (this.#chars.length === 0) {
+            for (const cb of [...this.#escapeCbs])
+                cb();
+            return;
+        }
+        if (this.#redirectCbs.length === 0) {
+            this.#submit();
+            return;
+        }
+        const line = this.#takeLine();
+        this.#remember(line);
+        for (const cb of [...this.#redirectCbs])
+            cb(line);
+        this.#onRender();
+    }
     #submit() {
-        let line = String.fromCodePoint(...this.#chars);
         if (this.#menuOpen) {
             // A1 (the feel): Enter submits the EXACT selection directly; a
             // PARTIAL selection COMPLETES the buffer (the Tab semantics)
@@ -792,7 +896,7 @@ export class Editor {
             // again. The old behavior executed the completed command on
             // the first Enter, before the user had seen the completion.
             const m = this.#menuFiltered()[this.#menuSel];
-            if (m !== undefined && m.name !== line) {
+            if (m !== undefined && m.name !== this.line()) {
                 this.#chars = [...m.name].map((ch) => ch.codePointAt(0));
                 this.#cursor = this.#chars.length;
                 this.#reflow();
@@ -801,13 +905,7 @@ export class Editor {
                 return; // completed, not executed
             }
         }
-        this.#chars = [];
-        this.#cursor = 0;
-        this.#scroll = 0;
-        this.#verticalGoalCol = null;
-        this.#menuOpen = false;
-        this.#menuSel = 0;
-        this.#queuePopMode = false; // W22: a submit ends the pop-walk — the next esc at rest interrupts again
+        const line = this.#takeLine();
         const cb = this.#questionCb;
         this.#questionCb = null;
         if (cb !== null) {
@@ -819,14 +917,8 @@ export class Editor {
         else {
             this.#pendingLines.push(line); // nobody wired yet — hold it
         }
-        // A2: the history remembers submitted TURN lines — never question
-        // answers, never empties; adjacent duplicates collapse.
-        if (cb === null && line !== "") {
-            if (this.#history[this.#history.length - 1] !== line)
-                this.#history.push(line);
-            if (this.#history.length > 100)
-                this.#history.shift();
-        }
+        if (cb === null && line !== "")
+            this.#remember(line);
         this.#onRender();
     }
     /** A2: step the history browse; a delta past the newest exits back to

package/dist/index.d.ts

@@ -11,3 +11,4 @@ export { Container, foldLine, visibleWidth, SPINNER, type Component, type FrameC
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, type MenuItem, } from "./editor.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type PathResolver, type RecapStats, type ResumeMeta, type RenderInput, type RenderResult, type RunUsage, } from "./render.js";
 export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";
+export { STATUS_GLYPHS, idleStatus, runningStatus } from "./status.js";

package/dist/index.js

@@ -14,3 +14,6 @@ export { Container, foldLine, visibleWidth, SPINNER } from "./components.js";
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, } from "./editor.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";
 export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";
+// KC2 §5: the status rows' formatters — the CLI keeps the state and the
+// repaint, the terminal layer owns what the row says.
+export { STATUS_GLYPHS, idleStatus, runningStatus } from "./status.js";

package/dist/status.d.ts

@@ -0,0 +1,38 @@
+/**
+ * KC2 §5 — the status line's FORMATTERS, extracted from the CLI (the
+ * ADR-0041 escape hatch: extraction, never a fifth raise). The split is
+ * the one the ADR names: the CLI keeps the STATE (the rotating glyph,
+ * the run's start instant, the live usage, whether the dock is up) and
+ * the REPAINT; what a status row SAYS is presentation, and presentation
+ * belongs to the terminal layer.
+ *
+ * Two callers built these rows independently before the move — chat's
+ * REPL and the recovery flow — with the running row duplicated verbatim
+ * in both. One definition now serves both, and the tier stays a
+ * PARAMETER precisely because the two callers disagree on it (chat
+ * spells plan's read-only posture out per W19, the recovery flow prints
+ * the bare mode): the extraction must not silently unify a difference it
+ * was not asked to settle.
+ *
+ * The rows are byte-for-byte what the CLI built before the move — the
+ * v2b/v3 §03 shapes the e2e transcripts pin by substring — with ONE
+ * deliberate exception: the running row's interrupt hint, which KC2 §2
+ * widens to name the new gesture.
+ */
+/** v3 §03/§05 — the working glyph family; the CLI's 200ms spinner walks
+ *  it and hands each glyph back to `runningStatus`. */
+export declare const STATUS_GLYPHS: readonly ["▖", "▘", "▝", "▗"];
+/**
+ * The RUNNING row: the rotating glyph, the wall seconds since `since`
+ * (never below 1 — a run that just started still reads "1s", so the row
+ * never claims a turn took no time), the streamed output tokens once the
+ * count is known, the interrupt hints, and the live ctx estimate.
+ *
+ * KC2 §2: the hint names BOTH gestures. Esc still stops; alt+⏎ redirects
+ * — stop, and do THIS instead. The row is where the gesture is taught,
+ * because it is on screen exactly when the gesture is useful.
+ */
+export declare function runningStatus(glyph: string, since: number, outTokens: number | null, ctxRatio: number): string;
+/** The IDLE row: the approval tier as the CALLER names it, the /mode
+ *  hint, the model driving the session, and the ctx estimate. */
+export declare function idleStatus(tier: string, model: string, ctxRatio: number): string;

package/dist/status.js

@@ -0,0 +1,52 @@
+/**
+ * KC2 §5 — the status line's FORMATTERS, extracted from the CLI (the
+ * ADR-0041 escape hatch: extraction, never a fifth raise). The split is
+ * the one the ADR names: the CLI keeps the STATE (the rotating glyph,
+ * the run's start instant, the live usage, whether the dock is up) and
+ * the REPAINT; what a status row SAYS is presentation, and presentation
+ * belongs to the terminal layer.
+ *
+ * Two callers built these rows independently before the move — chat's
+ * REPL and the recovery flow — with the running row duplicated verbatim
+ * in both. One definition now serves both, and the tier stays a
+ * PARAMETER precisely because the two callers disagree on it (chat
+ * spells plan's read-only posture out per W19, the recovery flow prints
+ * the bare mode): the extraction must not silently unify a difference it
+ * was not asked to settle.
+ *
+ * The rows are byte-for-byte what the CLI built before the move — the
+ * v2b/v3 §03 shapes the e2e transcripts pin by substring — with ONE
+ * deliberate exception: the running row's interrupt hint, which KC2 §2
+ * widens to name the new gesture.
+ */
+import { kUnit } from "./render.js";
+/** v3 §03/§05 — the working glyph family; the CLI's 200ms spinner walks
+ *  it and hands each glyph back to `runningStatus`. */
+export const STATUS_GLYPHS = ["▖", "▘", "▝", "▗"];
+/** The ~ctx estimate as the whole-percent LEFT. A non-finite ratio (no
+ *  window, no estimate) yields null and the row prints "~null%" — the
+ *  long-standing shape, kept on purpose: an honest null beats an
+ *  invented percentage. */
+function ctxLeft(ratio) {
+    return Number.isFinite(ratio) ? Math.round((1 - ratio) * 100) : null;
+}
+/**
+ * The RUNNING row: the rotating glyph, the wall seconds since `since`
+ * (never below 1 — a run that just started still reads "1s", so the row
+ * never claims a turn took no time), the streamed output tokens once the
+ * count is known, the interrupt hints, and the live ctx estimate.
+ *
+ * KC2 §2: the hint names BOTH gestures. Esc still stops; alt+⏎ redirects
+ * — stop, and do THIS instead. The row is where the gesture is taught,
+ * because it is on screen exactly when the gesture is useful.
+ */
+export function runningStatus(glyph, since, outTokens, ctxRatio) {
+    const out = outTokens !== null ? ` ↓ ${kUnit(outTokens)} tokens` : "";
+    const seconds = Math.max(1, Math.round((Date.now() - since) / 1000));
+    return `${glyph} working ${seconds}s${out} · esc stop · alt+⏎ redirect · ctx left ~${ctxLeft(ctxRatio)}%`;
+}
+/** The IDLE row: the approval tier as the CALLER names it, the /mode
+ *  hint, the model driving the session, and the ctx estimate. */
+export function idleStatus(tier, model, ctxRatio) {
+    return `▸ ${tier} · /mode to switch · ${model} · ctx left ~${ctxLeft(ctxRatio)}%`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "kiso tui — 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.5.0"
+    "@vincemakes/kiso-tui-cells": "0.6.0"
   }
 }