@vincemakes/kiso-code 0.1.13 → 0.1.15

package/dist/dock.js

@@ -1,18 +1,23 @@
 /**
- * v2b — the bottom-anchored UI (TTY + color only). Borrows pi-tui's IDEA —
- * a DECSTBM scroll region with a reserved bottom — without its
+ * 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-3 = the scroll region (the body
  * streams and scrolls here, never touching the bottom), row H-2 = the dim
- * separator, row H-1 = the live status bar (or a takeover question), row
- * H = the input line (blue you> + readline). Bottom redraws are wrapped in
- * CSI 2026 (synchronized output) to avoid flicker — the pi trick.
+ * dotted separator (╌), row H-1 = the live status bar (or a takeover
+ * question), row H = the input line (the blue brick ▌you> + the v2c
+ * editor's row — readline is gone from the TTY path). 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 separator — 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).
  */
+import { displayWidth } from "./editor.js";
 import { palette } from "./render.js";
 export class Dock {
     #active = false;
@@ -83,9 +88,16 @@ export class Dock {
     }
     /** Body output: position the cursor inside the scroll region at the
      *  body's tracked position, write, and hand the cursor back to the
-     *  input line. The row/col tracking is approximate for width-wrapped
-     *  and wide-char lines (documented) — the region clamp keeps the
-     *  bottom rows safe regardless. */
+     *  input line's EDIT position. The row/col tracking is approximate for
+     *  width-wrapped and wide-char lines (documented) — the region clamp
+     *  keeps the bottom rows safe regardless.
+     *
+     *  The edit-position return is a correctness requirement, not
+     *  cosmetics: readline tracks its cursor internally and NEVER
+     *  re-syncs after an external move — a body write that left the
+     *  cursor at column 1 made the next keystroke overwrite the prompt
+     *  (probe-confirmed; the dock's redraw self-repaired ~200ms later,
+     *  which read the user as cursor drift). */
     writeBody(text) {
         if (!this.#active) {
             process.stdout.write(text);
@@ -104,7 +116,21 @@ export class Dock {
                 this.#bodyCol += 1;
             }
         }
-        process.stdout.write(`\x1b[${this.#height};1H`); // back to the input line
+        process.stdout.write(`\x1b[${this.#height};${this.#inputCol()}H`); // back to the edit position
+    }
+    /** 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() {
+        return this.#inputCol();
+    }
+    #inputCol() {
+        const inp = this.#inputState();
+        const promptWidth = displayWidth(this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, ""));
+        return promptWidth + inp.cursor + 1;
     }
     /** The status bar's base text (usage, ctx, session, …). */
     setStatus(text) {
@@ -128,25 +154,30 @@ export class Dock {
     }
     /** The bottom three rows, wrapped in CSI 2026 (synchronized output —
      *  the pi trick against flicker). The cursor ends at the input line's
-     *  edit position. */
+     *  edit position. v2c: the separator is the dim dotted ╌ (a weaker
+     *  presence than the solid ─), the status line is dim (blue accents
+     *  inside come from the CLI's composition), the input row is the blue
+     *  brick ▌you> + the editor's visible slice. */
     redraw() {
         if (!this.#active)
             return;
         const p = palette();
         const H = this.#height;
         const W = this.#width;
-        const sep = `${p.dim}${"─".repeat(W)}${p.reset}`;
+        const sep = `${p.dim}${"╌".repeat(W)}${p.reset}`;
         const status = `${this.#status}${this.#tail === "" ? "" : ` · ${this.#tail}`}`;
-        const statusLine = this.#question ?? status;
+        const statusLine = this.#question ?? `${p.dim}${status}${p.reset}`;
         const inp = this.#inputState();
-        const promptWidth = this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, "").length;
         const out = [];
-        out.push("\x1b[2026h"); // synchronized output ON
+        // P3 (审查): the DEC private-mode SET/RESET needs the "?" prefix —
+        // \x1b[?2026h/l, the pi source's exact form. Without it terminals
+        // silently ignore the mode and the anti-flicker never engages.
+        out.push("\x1b[?2026h"); // synchronized output ON (DEC 2026)
         out.push(`\x1b[${H - 2};1H\x1b[0K${sep}`);
         out.push(`\x1b[${H - 1};1H\x1b[0K${statusLine}`);
         out.push(`\x1b[${H};1H\x1b[0K${this.#inputPrompt}${inp.line}`);
-        out.push(`\x1b[${H};${promptWidth + inp.cursor + 1}H`); // back to the edit position
-        out.push("\x1b[2026l"); // synchronized output OFF
+        out.push(`\x1b[${H};${this.#inputCol()}H`); // back to the edit position
+        out.push("\x1b[?2026l"); // synchronized output OFF
         process.stdout.write(out.join(""));
     }
 }

package/dist/editor.d.ts

@@ -0,0 +1,64 @@
+/**
+ * v2c — the raw-mode single-line editor that REPLACES readline on the TTY
+ * path. Root cause of the v2b drift (plan 2026-08-05-tui-v2b §11): readline
+ * re-renders its line by CHARACTER count and assumes it owns the row
+ * exclusively — a CJK wide character (2 cells) shifts every following
+ * column, and the dock's redraws make the mismatch permanent. Patching
+ * readline is a dead end; the TTY path draws its own input row instead.
+ * Non-TTY paths keep readline untouched (pipe bytes unchanged).
+ *
+ * Zero dependencies. The eastAsianWidth table is a ~40-line subset (CJK
+ * ideographs/kana/hangul/fullwidth/common wide symbols = 2, everything
+ * else = 1). Known limitation, documented in the README: emoji ZWJ
+ * clusters (family emoji etc.) are not guaranteed perfect — each code
+ * point counts as its width.
+ *
+ * The editor is a SINGLE line: bracketed paste (?2004h) unwraps and
+ * inserts, internal newlines become spaces.
+ */
+/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
+export declare function charWidth(cp: number): number;
+/** Display width of a code-point array (cursor math, scrolling). */
+export declare function widthOf(chars: readonly number[]): number;
+/** Display width of a string. */
+export declare function displayWidth(text: string): number;
+export declare const PROMPT = "\u258Cyou> ";
+export declare const PROMPT_WIDTH: number;
+/**
+ * The editor. Raw mode + bracketed paste (?2004h) on enter, restored on
+ * exit. The input row is rendered by `onRender` (the CLI wires it to the
+ * dock's redraw when docked, the editor's own self-render otherwise) —
+ * the editor itself never writes while docked. The event handlers are
+ * settable — the chat/resume contexts wire them after construction.
+ */
+export declare class Editor {
+    #private;
+    readonly closed: Promise<void>;
+    constructor(onRender: () => void);
+    onLine(cb: (line: string) => void): void;
+    onSigint(cb: () => void): void;
+    onEot(cb: () => void): void;
+    onEscape(cb: () => void): void;
+    /** The whole buffer as text (the CLI's line()/clearLine()). */
+    line(): string;
+    clearLine(): void;
+    /** The visible slice (dim "…" prefix when scrolled) + the cursor's
+     *  display column within it — the dock's input-row state. */
+    dockState(): {
+        line: string;
+        cursor: number;
+    };
+    /** One-shot question mode: the NEXT submit answers, not a turn. */
+    question(_query: string, cb: (answer: string) => void): void;
+    /** Cancel a pending question — the buffer stays (its text becomes the
+     *  next turn on Enter, the readline re-emit equivalent). */
+    cancelQuestion(): void;
+    enter(): void;
+    exit(): void;
+    /** The row's own render when the dock is inactive (a TTY without a
+     *  real size): \r + clear + blue brick prompt + visible + cursor
+     *  column. */
+    selfRender(): void;
+    /** Feed raw stdin bytes — the parser. Public for unit tests. */
+    feed(raw: Uint8Array): void;
+}

package/dist/editor.js

@@ -0,0 +1,378 @@
+/**
+ * v2c — the raw-mode single-line editor that REPLACES readline on the TTY
+ * path. Root cause of the v2b drift (plan 2026-08-05-tui-v2b §11): readline
+ * re-renders its line by CHARACTER count and assumes it owns the row
+ * exclusively — a CJK wide character (2 cells) shifts every following
+ * column, and the dock's redraws make the mismatch permanent. Patching
+ * readline is a dead end; the TTY path draws its own input row instead.
+ * Non-TTY paths keep readline untouched (pipe bytes unchanged).
+ *
+ * Zero dependencies. The eastAsianWidth table is a ~40-line subset (CJK
+ * ideographs/kana/hangul/fullwidth/common wide symbols = 2, everything
+ * else = 1). Known limitation, documented in the README: emoji ZWJ
+ * clusters (family emoji etc.) are not guaranteed perfect — each code
+ * point counts as its width.
+ *
+ * The editor is a SINGLE line: bracketed paste (?2004h) unwraps and
+ * inserts, internal newlines become spaces.
+ */
+/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
+export function charWidth(cp) {
+    if (cp >= 0x1100 && cp <= 0x115f)
+        return 2; // hangul jamo
+    if (cp >= 0x2e80 && cp <= 0x303e)
+        return 2; // radicals .. CJK punctuation
+    if (cp >= 0x3041 && cp <= 0x33ff)
+        return 2; // kana, CJK compat
+    if (cp >= 0x3400 && cp <= 0x4dbf)
+        return 2; // CJK ext A
+    if (cp >= 0x4e00 && cp <= 0x9fff)
+        return 2; // CJK unified
+    if (cp >= 0xa000 && cp <= 0xa4cf)
+        return 2; // yi
+    if (cp >= 0xa960 && cp <= 0xa97f)
+        return 2; // hangul jamo ext
+    if (cp >= 0xac00 && cp <= 0xd7a3)
+        return 2; // hangul syllables
+    if (cp >= 0xf900 && cp <= 0xfaff)
+        return 2; // CJK compat ideographs
+    if (cp >= 0xfe10 && cp <= 0xfe19)
+        return 2; // vertical forms
+    if (cp >= 0xfe30 && cp <= 0xfe6f)
+        return 2; // CJK compat forms
+    if (cp >= 0xff00 && cp <= 0xff60)
+        return 2; // fullwidth forms
+    if (cp >= 0xffe0 && cp <= 0xffe6)
+        return 2; // fullwidth signs
+    if (cp >= 0x1f300 && cp <= 0x1f64f)
+        return 2; // emoji (misc + emoticons)
+    if (cp >= 0x1f900 && cp <= 0x1f9ff)
+        return 2; // supplemental emoji
+    if (cp >= 0x20000 && cp <= 0x3fffd)
+        return 2; // CJK ext B..G
+    return 1;
+}
+/** Display width of a code-point array (cursor math, scrolling). */
+export function widthOf(chars) {
+    let w = 0;
+    for (const cp of chars)
+        w += charWidth(cp);
+    return w;
+}
+/** Display width of a string. */
+export function displayWidth(text) {
+    let w = 0;
+    for (const ch of text)
+        w += charWidth(ch.codePointAt(0));
+    return w;
+}
+import { palette } from "./render.js";
+export const PROMPT = "▌you> "; // the kiso brick motif: one blue half-block, then you>
+export const PROMPT_WIDTH = displayWidth(PROMPT);
+/**
+ * The editor. Raw mode + bracketed paste (?2004h) on enter, restored on
+ * exit. The input row is rendered by `onRender` (the CLI wires it to the
+ * dock's redraw when docked, the editor's own self-render otherwise) —
+ * the editor itself never writes while docked. The event handlers are
+ * settable — the chat/resume contexts wire them after construction.
+ */
+export class Editor {
+    #chars = [];
+    #cursor = 0;
+    #scroll = 0; // chars scrolled off the left (width-based reflow)
+    #questionCb = null;
+    #pasting = false;
+    #lineCb = null;
+    #pendingLines = []; // submits before onLine is wired (startup) — never dropped
+    #sigintCb = null;
+    #eotCb = null;
+    #escapeCb = null;
+    #onRender;
+    #pending = ""; // an incomplete ESC/CSI prefix across chunks
+    #decoder = new TextDecoder();
+    #entered = false;
+    #onData;
+    #closedResolve;
+    closed;
+    constructor(onRender) {
+        this.#onRender = onRender;
+        this.#onData = (raw) => this.feed(raw);
+        this.closed = new Promise((resolve) => {
+            this.#closedResolve = resolve;
+        });
+    }
+    onLine(cb) {
+        this.#lineCb = cb;
+        // Flush submits that arrived before the handler was wired (typed
+        // during startup) — readline buffered these; the editor must too.
+        for (const line of this.#pendingLines)
+            cb(line);
+        this.#pendingLines.length = 0;
+    }
+    onSigint(cb) {
+        this.#sigintCb = cb;
+    }
+    onEot(cb) {
+        this.#eotCb = cb;
+    }
+    onEscape(cb) {
+        this.#escapeCb = cb;
+    }
+    /** The whole buffer as text (the CLI's line()/clearLine()). */
+    line() {
+        return String.fromCodePoint(...this.#chars);
+    }
+    clearLine() {
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#scroll = 0;
+        this.#onRender();
+    }
+    /** The visible slice (dim "…" prefix when scrolled) + the cursor's
+     *  display column within it — the dock's input-row state. */
+    dockState() {
+        const visible = String.fromCodePoint(...this.#chars.slice(this.#scroll));
+        const prefix = this.#scroll > 0 ? "\x1b[2m…\x1b[0m" : "";
+        const col = (this.#scroll > 0 ? 1 : 0) + widthOf(this.#chars.slice(this.#scroll, this.#cursor));
+        return { line: `${prefix}${visible}`, cursor: col };
+    }
+    /** One-shot question mode: the NEXT submit answers, not a turn. */
+    question(_query, cb) {
+        this.#questionCb = cb;
+    }
+    /** Cancel a pending question — the buffer stays (its text becomes the
+     *  next turn on Enter, the readline re-emit equivalent). */
+    cancelQuestion() {
+        this.#questionCb = null;
+    }
+    enter() {
+        if (this.#entered)
+            return;
+        this.#entered = true;
+        process.stdin.setRawMode(true);
+        process.stdout.write("\x1b[?2004h"); // bracketed paste ON
+        process.stdin.on("data", this.#onData);
+        this.#onRender();
+    }
+    exit() {
+        if (!this.#entered)
+            return;
+        this.#entered = false;
+        process.stdin.off("data", this.#onData);
+        process.stdout.write("\x1b[?2004l"); // bracketed paste OFF
+        process.stdin.setRawMode(false);
+        this.#closedResolve();
+    }
+    /** The row's own render when the dock is inactive (a TTY without a
+     *  real size): \r + clear + blue brick prompt + visible + cursor
+     *  column. */
+    selfRender() {
+        const p = palette();
+        const st = this.dockState();
+        const W = (process.stdout.columns ?? 0) || 80; // a degenerate 0 size (no TIOCSWINSZ) falls back
+        const cursorCol = Math.min(1 + PROMPT_WIDTH + st.cursor, W);
+        process.stdout.write(`\r\x1b[0K${p.blue}${PROMPT}${p.reset}${st.line}\x1b[${cursorCol}G`);
+    }
+    // ---- input ----
+    /** Feed raw stdin bytes — the parser. Public for unit tests. */
+    feed(raw) {
+        const text = this.#pending + this.#decoder.decode(raw, { stream: true });
+        this.#pending = "";
+        let i = 0;
+        while (i < text.length) {
+            const c = text[i];
+            if (c === "\x1b") {
+                const rest = text.slice(i + 1);
+                if (rest.startsWith("[")) {
+                    const m = rest.match(/^\[([0-9;?]*)([A-Za-z~])/);
+                    if (m === null) {
+                        this.#pending = text.slice(i); // incomplete CSI — wait for more
+                        break;
+                    }
+                    this.#csi(m[1], m[2]);
+                    i += m[0].length + 1;
+                }
+                else if (rest.startsWith("O")) {
+                    i += 3; // SS3 (function keys) — ignored
+                }
+                else {
+                    this.#escapeCb?.();
+                    i += 1;
+                }
+            }
+            else if (c === "\x0d" || c === "\x0a") {
+                if (this.#pasting) {
+                    this.#insert(0x20); // single-line editor: newlines become spaces
+                }
+                else {
+                    this.#submit();
+                }
+                i += 1;
+            }
+            else if (c === "\x7f" || c === "\x08") {
+                this.#backspace();
+                i += 1;
+            }
+            else if (c === "\x03") {
+                this.#sigintCb?.();
+                i += 1;
+            }
+            else if (c === "\x04") {
+                this.#eotCb?.();
+                i += 1;
+            }
+            else if (c === "\x15") {
+                this.#killToStart();
+                i += 1;
+            }
+            else if (c === "\x0b") {
+                this.#killToEnd();
+                i += 1;
+            }
+            else if (c === "\x17") {
+                this.#killWord();
+                i += 1;
+            }
+            else if (c === "\x01") {
+                this.#cursor = 0;
+                this.#reflow();
+                this.#onRender();
+                i += 1;
+            }
+            else if (c === "\x05") {
+                this.#cursor = this.#chars.length;
+                this.#reflow();
+                this.#onRender();
+                i += 1;
+            }
+            else if (c !== undefined && c < " ") {
+                i += 1; // other control — ignored
+            }
+            else {
+                this.#insert(text.codePointAt(i));
+                i += c.length;
+            }
+        }
+    }
+    #csi(params, final) {
+        if (final === "~") {
+            const n = Number(params);
+            if (n === 3)
+                this.#delete();
+            else if (n === 200)
+                this.#pasting = true;
+            else if (n === 201) {
+                this.#pasting = false;
+                this.#onRender();
+            }
+        }
+        else if (final === "D") {
+            this.#move(-1);
+        }
+        else if (final === "C") {
+            this.#move(1);
+        }
+        else if (final === "H") {
+            this.#cursor = 0;
+            this.#reflow();
+        }
+        else if (final === "F") {
+            this.#cursor = this.#chars.length;
+            this.#reflow();
+        }
+    }
+    // ---- editing ----
+    #insert(cp) {
+        this.#chars.splice(this.#cursor, 0, cp);
+        this.#cursor += 1;
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #backspace() {
+        if (this.#cursor === 0)
+            return;
+        this.#chars.splice(this.#cursor - 1, 1);
+        this.#cursor -= 1;
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #delete() {
+        if (this.#cursor >= this.#chars.length)
+            return;
+        this.#chars.splice(this.#cursor, 1);
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #move(delta) {
+        this.#cursor = Math.max(0, Math.min(this.#chars.length, this.#cursor + delta));
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #killToStart() {
+        this.#chars.splice(0, this.#cursor);
+        this.#cursor = 0;
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #killToEnd() {
+        this.#chars.length = this.#cursor;
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #killWord() {
+        let i = this.#cursor;
+        while (i > 0 && this.#chars[i - 1] === 0x20)
+            i -= 1; // trailing spaces
+        while (i > 0 && this.#chars[i - 1] !== 0x20)
+            i -= 1; // the word
+        this.#chars.splice(i, this.#cursor - i);
+        this.#cursor = i;
+        this.#reflow();
+    }
+    #submit() {
+        const line = String.fromCodePoint(...this.#chars);
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#scroll = 0;
+        const cb = this.#questionCb;
+        this.#questionCb = null;
+        if (cb !== null) {
+            cb(line);
+        }
+        else if (this.#lineCb !== null) {
+            this.#lineCb(line);
+        }
+        else {
+            this.#pendingLines.push(line); // nobody wired yet — hold it
+        }
+        this.#onRender();
+    }
+    // ---- width-based horizontal scroll ----
+    #reflow() {
+        const W = (process.stdout.columns ?? 0) || 80; // degenerate 0 falls back to 80
+        const maxW = Math.max(1, W - PROMPT_WIDTH - 1); // 1 col for the "…"
+        const curCol = widthOf(this.#chars.slice(0, this.#cursor));
+        const scrolledW = widthOf(this.#chars.slice(0, this.#scroll));
+        if (curCol < scrolledW) {
+            this.#scroll = this.#indexAtWidth(curCol);
+        }
+        else if (curCol >= scrolledW + maxW) {
+            this.#scroll = this.#indexAtWidth(Math.max(0, curCol - maxW + 1));
+        }
+    }
+    #indexAtWidth(target) {
+        let w = 0;
+        for (let i = 0; i < this.#chars.length; i += 1) {
+            if (w >= target)
+                return i;
+            w += charWidth(this.#chars[i]);
+        }
+        return this.#chars.length;
+    }
+}