@xingjisoft/neutrino 0.1.1 → 0.1.3

package/dist/screens/start.js

@@ -1,6 +1,6 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
-import { loadLogo } from "../config.js";
+import { loadLogo, loadVersion } from "../config.js";
 import { drawHeader } from "../header.js";
 import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, } from "../ui.js";
 const TABS = ["Model", "History", "Settings"];
@@ -8,6 +8,9 @@ const LOGO = loadLogo();
 const FOCUS_COUNT = TABS.length + 1; // input box + 3 tabs
 const INPUT_H = 3;
 const TAB_H = 3;
+function isLowSurrogate(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}
 export class StartScreen extends Screen {
     inputValue = "";
     cursor = 0;
@@ -15,12 +18,40 @@ export class StartScreen extends Screen {
     hoverIdx = -1; // -1 = nothing, 0 = input box, 1..3 = tabs
     lastHoverX = -1;
     lastHoverY = -1;
+    showsCursor() {
+        // The input cursor is only drawn for the focused, non-empty input box.
+        return this.focusIdx === 0 && this.inputValue.length > 0;
+    }
+    onPaste(text) {
+        if (!text)
+            return;
+        // A paste always targets the message box, so focus it first.
+        this.focusIdx = 0;
+        this.hoverIdx = -1;
+        this.inputValue =
+            this.inputValue.slice(0, this.cursor) + text + this.inputValue.slice(this.cursor);
+        this.cursor += text.length;
+        this.app.render();
+    }
     onKey(key) {
-        if (key.name === "left" || key.name === "up") {
+        // When the input box is focused and holds text, left/right move the text
+        // cursor instead of switching between the input box and the tabs. When the
+        // input box is empty (or another control is focused), left/right switch.
+        // Up/down always switch.
+        if (key.name === "left" || key.name === "right") {
+            if (this.focusIdx === 0 && this.inputValue.length > 0) {
+                this.moveCursor(key.name === "left" ? -1 : 1);
+            }
+            else {
+                this.move(key.name === "left" ? -1 : 1);
+            }
+            return;
+        }
+        if (key.name === "up") {
             this.move(-1);
             return;
         }
-        if (key.name === "right" || key.name === "down") {
+        if (key.name === "down") {
             this.move(1);
             return;
         }
@@ -165,6 +196,24 @@ export class StartScreen extends Screen {
         this.hoverIdx = -1;
         this.app.render();
     }
+    /** Move the text cursor by one character, staying within bounds and on
+     *  surrogate-pair boundaries. */
+    moveCursor(delta) {
+        const len = this.inputValue.length;
+        let next = Math.max(0, Math.min(len, this.cursor + delta));
+        if (delta === 1) {
+            if (next < len && isLowSurrogate(this.inputValue.charCodeAt(next))) {
+                next = Math.min(len, next + 1);
+            }
+        }
+        else if (next > 0 && isLowSurrogate(this.inputValue.charCodeAt(next))) {
+            next = Math.max(0, next - 1);
+        }
+        if (next === this.cursor)
+            return;
+        this.cursor = next;
+        this.app.render();
+    }
     enterTab() {
         if (this.focusIdx === 1)
             this.app.openModelConfig();
@@ -193,6 +242,7 @@ export class StartScreen extends Screen {
         y += 1;
         drawInputBox(buf, inputX, y, inputW, this.inputValue, this.cursor, {
             active: this.focusIdx === 0,
+            cursorOn: this.app.state.cursorOn,
             placeholder: "Type a message to start a new chat...",
         });
         y += INPUT_H + gap;
@@ -207,9 +257,23 @@ export class StartScreen extends Screen {
             drawTabButton(buf, tx, y, tw, TABS[i], selected);
             tx += tw + tabGap;
         }
+        // The version label is pinned one row above the very bottom of the screen,
+        // leaving the last row blank. It is read from package.json at runtime so it
+        // can never drift out of sync with the published package version.
+        const version = loadVersion();
+        const versionY = h - 2;
+        const showVersion = version.length > 0 && versionY >= 1;
+        // The hint sits right below the tabs, but is dropped when it would land on
+        // or below the reserved version row so the two never collide.
         const hintY = y + TAB_H + 1;
-        if (hintY < h) {
-            drawHint(buf, hintY, "←/→ / ↑/↓ switch  ·  Enter confirm  ·  click to choose  ·  Ctrl+E model  ·  Ctrl+Q quit");
+        if (hintY < h && (!showVersion || hintY < versionY)) {
+            const nav = this.focusIdx === 0 && this.inputValue.length > 0
+                ? "←/→ move cursor · ↑/↓ switch"
+                : "←/→ / ↑/↓ switch";
+            drawHint(buf, hintY, `${nav} · Enter confirm · drag to copy · Ctrl+E model · Ctrl+Q quit`);
+        }
+        if (showVersion) {
+            buf.centerText(versionY, `v${version}`, { fg: C.dim });
         }
     }
 }

package/dist/selection.js

@@ -0,0 +1,75 @@
+import { C } from "./colors.js";
+/** Order the two ends of a selection into reading order (top-left first). */
+export function normalizeSelection(sel) {
+    const { anchor: a, cursor: b } = sel;
+    if (a.y < b.y || (a.y === b.y && a.x <= b.x))
+        return { start: a, end: b };
+    return { start: b, end: a };
+}
+/** Index of the last non-blank cell on a row, or -1 when the row is empty. */
+function lastContentCol(buf, y) {
+    const row = buf.cells[y];
+    for (let x = row.length - 1; x >= 0; x--) {
+        if (row[x].ch !== " ")
+            return x;
+    }
+    return -1;
+}
+/**
+ * Paint the selection highlight directly onto the rendered buffer. Working on
+ * the buffer (rather than on each screen) means the highlight automatically
+ * follows whatever is on screen — chat output, the input box, menus, …
+ *
+ * Intermediate lines stop at the last non-blank cell so a multi-line selection
+ * doesn't paint a block out to the right edge of the terminal.
+ */
+export function applySelection(buf, sel) {
+    const { start, end } = normalizeSelection(sel);
+    const y0 = Math.max(0, start.y);
+    const y1 = Math.min(buf.height - 1, end.y);
+    for (let y = y0; y <= y1; y++) {
+        const x0 = y === start.y ? Math.max(0, start.x) : 0;
+        const x1 = y === end.y ? Math.min(buf.width - 1, end.x) : lastContentCol(buf, y);
+        if (x1 < x0)
+            continue;
+        for (let x = x0; x <= x1; x++) {
+            const cell = buf.cells[y][x];
+            if (!cell)
+                continue;
+            cell.style = {
+                fg: C.white,
+                bg: C.selection,
+                bold: cell.style.bold,
+                italic: cell.style.italic,
+            };
+        }
+    }
+}
+/**
+ * Extract the plain text covered by a selection. Trailing whitespace is trimmed
+ * per line (shell-style) and wide-character continuation cells are skipped, so
+ * the result can be pasted straight back into a terminal.
+ */
+export function selectionText(buf, sel) {
+    const { start, end } = normalizeSelection(sel);
+    const y0 = Math.max(0, start.y);
+    const y1 = Math.min(buf.height - 1, end.y);
+    const lines = [];
+    for (let y = y0; y <= y1; y++) {
+        const x0 = y === start.y ? Math.max(0, start.x) : 0;
+        let x1 = y === end.y ? end.x : buf.width - 1;
+        let line = "";
+        for (let x = x0; x <= Math.min(buf.width - 1, x1); x++) {
+            const cell = buf.cells[y][x];
+            if (!cell || cell.ch === "")
+                continue; // "" is the tail of a wide glyph
+            line += cell.ch;
+        }
+        lines.push(line.replace(/[ \t]+$/, ""));
+    }
+    while (lines.length > 0 && lines[0] === "")
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.join("\n");
+}

package/dist/state.js

@@ -8,5 +8,7 @@ export function defaultState() {
         selectedIntensity: "High",
         isThinking: false,
         blinkOn: false,
+        cursorOn: true,
+        selection: null,
     };
 }

package/dist/terminal/buffer.js

@@ -4,6 +4,9 @@ const emptyCell = () => ({ ch: " ", style: { bg: C.black } });
 function normalize(style) {
     return style.bg ? style : { ...style, bg: C.black };
 }
+function cellWidth(ch) {
+    return ch ? wcwidth(ch.codePointAt(0) ?? 0) : 0;
+}
 export class Buffer {
     width;
     height;
@@ -13,12 +16,65 @@ export class Buffer {
         this.height = height;
         this.cells = Array.from({ length: height }, () => Array.from({ length: width }, emptyCell));
     }
+    /**
+     * Write a single cell, keeping the wide-glyph invariant intact. The renderer
+     * (and the selection logic) rely on the rule that a `""` cell is *always* the
+     * right half of a double-width glyph at `x - 1`. If the invariant is broken an
+     * orphan tail is left behind: the renderer skips it, so that column is never
+     * repainted and a stale glyph from the previous frame stays on screen (the
+     * "residual line" bug). To preserve it we blank the *other* half whenever we
+     * overwrite one half of a wide glyph.
+     */
+    overwriteCell(x, y, ch, style) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
+            return;
+        const row = this.cells[y];
+        const prev = row[x];
+        if (prev.ch === "" && x > 0) {
+            // We're overwriting a wide glyph's tail: blank its head.
+            row[x - 1] = { ch: " ", style: row[x - 1].style };
+        }
+        else if (cellWidth(prev.ch) === 2 && x + 1 < this.width) {
+            // We're overwriting a wide glyph's head: blank its tail.
+            row[x + 1] = { ch: " ", style: row[x + 1].style };
+        }
+        row[x] = { ch, style: normalize(style) };
+    }
+    /**
+     * Mark `x` as the tail (`""`) of the wide glyph at `x - 1`. Unlike
+     * `overwriteCell` this never blanks the cell to the left, because that cell is
+     * the glyph we are currently writing.
+     */
+    writeTail(x, y, style) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
+            return;
+        const row = this.cells[y];
+        const prev = row[x];
+        if (cellWidth(prev.ch) === 2 && x + 1 < this.width) {
+            row[x + 1] = { ch: " ", style: row[x + 1].style };
+        }
+        row[x] = { ch: "", style: normalize(style) };
+    }
+    writeChar(x, y, ch, style) {
+        if (cellWidth(ch) === 2) {
+            if (x + 1 >= this.width) {
+                // No room for the tail: degrade to a space so the line never overflows
+                // (which would make the terminal wrap and scroll).
+                this.overwriteCell(x, y, " ", style);
+                return;
+            }
+            this.overwriteCell(x, y, ch, style);
+            this.writeTail(x + 1, y, style);
+            return;
+        }
+        this.overwriteCell(x, y, ch, style);
+    }
     set(x, y, ch, style = EMPTY_STYLE) {
         if (ch === "\r" || ch === "\n")
             return;
-        if (y < 0 || y >= this.height || x < 0 || x >= this.width)
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
             return;
-        this.cells[y][x] = { ch, style: normalize(style) };
+        this.writeChar(x, y, ch, style);
     }
     writeText(x, y, text, style = EMPTY_STYLE) {
         if (y < 0 || y >= this.height)
@@ -27,8 +83,10 @@ export class Buffer {
         for (const ch of text) {
             const w = wcwidth(ch.codePointAt(0) ?? 0);
             if (w === 0) {
-                if (col - 1 >= x && col - 1 >= 0 && col - 1 < this.width) {
-                    this.cells[y][col - 1].ch += ch;
+                // Combining mark: attach it to the glyph immediately to the left.
+                const px = col - 1;
+                if (px >= 0 && px < this.width && this.cells[y][px].ch !== "") {
+                    this.cells[y][px].ch += ch;
                 }
                 continue;
             }
@@ -38,10 +96,7 @@ export class Buffer {
                 col += w;
                 continue;
             }
-            this.cells[y][col] = { ch, style: normalize(style) };
-            if (w === 2 && col + 1 < this.width) {
-                this.cells[y][col + 1] = { ch: "", style: normalize(style) };
-            }
+            this.writeChar(col, y, ch, style);
             col += w;
         }
     }

package/dist/terminal/input.js

@@ -1,11 +1,44 @@
 import process from "node:process";
 const ESC_TIMEOUT = 30;
+// Bracketed paste: once enabled, the terminal wraps pasted text in
+// ESC [ 2 0 0 ~ ... ESC [ 2 0 1 ~ so a paste can be told apart from typing.
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+/** Flatten a pasted blob so its line breaks become ordinary spaces. */
+function flattenNewlines(s) {
+    return s.replace(/\r\n|\r|\n/g, " ");
+}
+/**
+ * Heuristic used when a terminal does not speak bracketed paste: a chunk of raw
+ * input counts as a paste when it carries a line break that is not merely the
+ * chunk's trailing one. A single line break at the very end is a manual Enter,
+ * and an all-whitespace chunk is just repeated Enter/space presses.
+ */
+function looksLikePaste(s) {
+    const body = s.replace(/(\r\n|\r|\n)$/, "");
+    if (!/\r|\n/.test(body))
+        return false;
+    if (/^\s*$/.test(s))
+        return false;
+    return true;
+}
+/** Length of the longest suffix of `s` that prefixes `marker` (0 if none). */
+function partialMarkerLength(s, marker) {
+    const max = Math.min(s.length, marker.length - 1);
+    for (let len = max; len > 0; len--) {
+        if (s.slice(s.length - len) === marker.slice(0, len))
+            return len;
+    }
+    return 0;
+}
 export class InputReader {
     decoder = new TextDecoder("utf-8");
     pending = "";
     state = "normal";
     csiBuf = "";
     escTimer = null;
+    inPaste = false;
+    pasteBuf = "";
     handler = null;
     dataHandler = (chunk) => this.onData(chunk);
     start(handler) {
@@ -31,8 +64,34 @@ export class InputReader {
     }
     process() {
         const s = this.pending;
+        // An unwrapped multi-line paste (terminals without bracketed-paste support
+        // deliver the raw text). Flatten it so the whole paste stays on one line
+        // and nothing gets submitted — only a manual Enter submits.
+        if (!this.inPaste && this.state === "normal" && !s.includes(PASTE_START) && looksLikePaste(s)) {
+            this.pending = "";
+            this.emitPaste(flattenNewlines(s));
+            return;
+        }
         let i = 0;
         while (i < s.length) {
+            if (this.inPaste) {
+                const end = s.indexOf(PASTE_END, i);
+                if (end === -1) {
+                    // No terminator yet: buffer what we have, holding back a possible
+                    // partial terminator so it can be matched with the next chunk.
+                    const rest = s.slice(i);
+                    const keep = partialMarkerLength(rest, PASTE_END);
+                    this.pasteBuf += rest.slice(0, rest.length - keep);
+                    this.pending = rest.slice(rest.length - keep);
+                    return;
+                }
+                this.pasteBuf += s.slice(i, end);
+                this.inPaste = false;
+                this.emitPaste(flattenNewlines(this.pasteBuf));
+                this.pasteBuf = "";
+                i = end + PASTE_END.length;
+                continue;
+            }
             const c = s[i];
             if (this.state === "normal") {
                 if (c === "\x1b") {
@@ -44,7 +103,8 @@ export class InputReader {
                 const code = c.charCodeAt(0);
                 if (c === "\r" || c === "\n") {
                     this.emitKey("return", false, false, false, c);
-                    i++;
+                    // A CRLF pair is one Return, not two.
+                    i += c === "\r" && s[i + 1] === "\n" ? 2 : 1;
                     continue;
                 }
                 if (c === "\t") {
@@ -153,17 +213,25 @@ export class InputReader {
                 this.emitKey("home", false, false, false, "\x1b[1~");
             else if (param === "4" || param === "8")
                 this.emitKey("end", false, false, false, "\x1b[4~");
+            else if (param === "200") {
+                // Start of a bracketed paste.
+                this.inPaste = true;
+                this.pasteBuf = "";
+            }
+            else if (param === "201") {
+                // End marker without a preceding start: ignore.
+                this.inPaste = false;
+            }
         }
     }
     /**
      * Parse SGR (extended) mouse sequences: ESC [ < b ; x ; y M/m
      *
-     * Button codes (SGR mode, any-event tracking ?1003):
-     *   0/1/2  left/middle/right press
-     *   3      release (ignored)
-     *   32     motion with no buttons held (hover)
-     *   35     motion with left button held (drag)
-     *   64/65  wheel up / wheel down
+     * `b` is a bit field: the low two bits are the button (0 left, 1 middle,
+     * 2 right, 3 none/release), bit 5 (32) marks a motion event and bit 6 (64)
+     * marks a wheel event. A trailing `M` is a press/motion while `m` is a
+     * release. So motion with the left button held (a drag) is `b = 32`, whereas
+     * plain hover is `b = 35` (32 | 3).
      */
     handleMouse(s, final) {
         const parts = s.slice(1).split(";");
@@ -174,18 +242,23 @@ export class InputReader {
         const y = parseInt(parts[2], 10) - 1;
         if (Number.isNaN(b) || Number.isNaN(x) || Number.isNaN(y))
             return;
-        if (b === 64) {
-            this.emitMouse({ type: "wheel", dir: -1, x, y });
+        const button = b & 3;
+        const motion = (b & 32) !== 0;
+        const wheel = (b & 64) !== 0;
+        if (wheel) {
+            this.emitMouse({ type: "wheel", dir: button === 0 ? -1 : 1, x, y });
+            return;
         }
-        else if (b === 65) {
-            this.emitMouse({ type: "wheel", dir: 1, x, y });
+        if (final === "m") {
+            this.emitMouse({ type: "release", x, y, button });
+            return;
         }
-        else if (final === "M" && (b === 32 || b === 35)) {
-            // hover / drag motion
-            this.emitMouse({ type: "move", x, y });
+        if (motion) {
+            this.emitMouse({ type: "move", x, y, drag: button === 0 });
+            return;
         }
-        else if (final === "M" && (b === 0 || b === 1 || b === 2)) {
-            this.emitMouse({ type: "click", x, y, button: b });
+        if (button !== 3) {
+            this.emitMouse({ type: "click", x, y, button });
         }
     }
     emitKey(name, ctrl, meta, shift, char) {
@@ -203,6 +276,11 @@ export class InputReader {
             },
         });
     }
+    emitPaste(text) {
+        if (!this.handler || !text)
+            return;
+        this.handler({ type: "paste", text });
+    }
     emitMouse(event) {
         if (!this.handler)
             return;

package/dist/terminal/renderer.js

@@ -50,8 +50,10 @@ export class Renderer {
         this.write("\x1b[?1049h"); // alternate screen
         this.write("\x1b[?25l"); // hide cursor
         this.write("\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h\x1b[?1015h"); // mouse tracking (incl. any-event for hover)
+        this.write("\x1b[?2004h"); // bracketed paste (so pastes can be told apart from typing)
     }
     dispose() {
+        this.write("\x1b[?2004l");
         this.write("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l");
         this.write("\x1b[?25h");
         this.write("\x1b[?1049l");
@@ -78,12 +80,17 @@ export class Renderer {
             this.write(out);
     }
     renderRow(y, row) {
-        let s = `\x1b[${y + 1};1H`;
+        // Move to the row, reset attributes and erase the whole line first. The
+        // erase is belt-and-braces: every cell is written below anyway, but this
+        // guarantees no stale glyph can survive even if a row somehow ends up
+        // shorter than what was on screen before (this is what produced the
+        // "residual line above the input box" artefact).
+        let s = `\x1b[${y + 1};1H\x1b[0m\x1b[K`;
         let lastKey = "";
         for (let x = 0; x < row.length; x++) {
             const cell = row[x];
             if (cell.ch === "")
-                continue;
+                continue; // tail of the wide glyph to the left
             const sk = styleKey(cell.style);
             if (sk !== lastKey) {
                 s += sgr(cell.style);

package/dist/terminal/screen.js

@@ -1,6 +1,25 @@
 export class Screen {
     app;
     onMouse(_ev) { }
+    /**
+     * Describe the on-screen scrollbar so the app can drag it, or null when this
+     * screen has none / its content fits. Geometry is only valid right after a
+     * render, which is exactly when the app needs it.
+     */
+    scrollbar() {
+        return null;
+    }
+    /**
+     * Handle a bracketed (or detected) paste. `text` already has its newlines
+     * flattened to spaces, so it can be inserted as a single line. Screens that
+     * have no text input can leave this as a no-op.
+     */
+    onPaste(_text) { }
+    /** Whether this screen currently shows a blinking text cursor. Used by the
+     *  app to run (or stop) the cursor blink timer. */
+    showsCursor() {
+        return false;
+    }
     onActivate() { }
     onDeactivate() { }
 }