@xingjisoft/neutrino 0.1.0 → 0.1.2

package/dist/screens/settings.js

@@ -2,9 +2,11 @@ import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { INTENSITY_LEVELS, MODEL_FILE, loadConfig, saveConfig } from "../config.js";
 import { drawHeader } from "../header.js";
-import { centerVertically } from "../ui.js";
+import { centerVertically, drawHint } from "../ui.js";
 export class SettingsScreen extends Screen {
     intensityIdx = 2;
+    lastHoverX = -1;
+    lastHoverY = -1;
     onActivate() {
         const config = loadConfig();
         const current = String(config.default_intensity ?? "High");
@@ -28,6 +30,66 @@ export class SettingsScreen extends Screen {
             this.app.popScreen();
         }
     }
+    onMouse(ev) {
+        const layout = this.layout();
+        if (!layout)
+            return;
+        if (ev.type === "move") {
+            if (ev.x === this.lastHoverX && ev.y === this.lastHoverY)
+                return;
+            this.lastHoverX = ev.x;
+            this.lastHoverY = ev.y;
+            for (let i = 0; i < layout.optionYs.length; i++) {
+                if (ev.y === layout.optionYs[i] && i !== this.intensityIdx) {
+                    this.intensityIdx = i;
+                    this.app.render();
+                    return;
+                }
+            }
+            return;
+        }
+        if (ev.type === "wheel") {
+            this.intensityIdx =
+                (this.intensityIdx + (ev.dir === -1 ? -1 : 1) + INTENSITY_LEVELS.length) % INTENSITY_LEVELS.length;
+            this.app.render();
+            return;
+        }
+        if (ev.type === "click") {
+            if (ev.button === 2) {
+                this.save();
+                this.app.popScreen();
+                return;
+            }
+            for (let i = 0; i < layout.optionYs.length; i++) {
+                if (ev.y === layout.optionYs[i]) {
+                    this.intensityIdx = i;
+                    this.save();
+                    this.app.render();
+                    return;
+                }
+            }
+            if (ev.y === layout.hintY) {
+                this.save();
+                this.app.popScreen();
+            }
+        }
+    }
+    layout() {
+        const h = this.app.height;
+        const lines = [
+            "Settings",
+            "",
+            `Model: ${this.app.state.selectedProvider}/${this.app.state.selectedModelName}`,
+            `Default intensity:`,
+        ];
+        const total = lines.length + INTENSITY_LEVELS.length + 2;
+        const top = centerVertically(h, total);
+        const optionYs = INTENSITY_LEVELS.map((_, i) => top + 4 + i);
+        const hintY = top + 4 + INTENSITY_LEVELS.length + 2;
+        if (hintY > h - 1)
+            return null;
+        return { optionYs, hintY };
+    }
     save() {
         const config = loadConfig();
         config.default_intensity = INTENSITY_LEVELS[this.intensityIdx];
@@ -64,7 +126,7 @@ export class SettingsScreen extends Screen {
         buf.centerText(y, `model.json: ${MODEL_FILE}`, { fg: C.dim });
         y += 1;
         if (y < h) {
-            buf.centerText(y, "↑/↓ change  ·  Enter apply  ·  Esc back", { fg: C.dim });
+            drawHint(buf, y, "↑/↓ change  ·  Enter apply  ·  click to choose  ·  right-click back  ·  Esc back");
         }
     }
 }

package/dist/screens/start.js

@@ -1,21 +1,46 @@
 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, drawInputBox, drawTabButton } from "../ui.js";
+import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, } from "../ui.js";
 const TABS = ["Model", "History", "Settings"];
 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;
     focusIdx = 0; // 0 = input box, 1..3 = tabs
+    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;
+    }
     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;
         }
@@ -72,8 +97,110 @@ export class StartScreen extends Screen {
             this.app.render();
         }
     }
+    onMouse(ev) {
+        if (ev.type === "move") {
+            // avoid redundant work when the pointer hasn't moved to a new cell
+            if (ev.x === this.lastHoverX && ev.y === this.lastHoverY)
+                return;
+            this.lastHoverX = ev.x;
+            this.lastHoverY = ev.y;
+            const layout = this.layout();
+            let hover = -1;
+            if (layout && inRect(ev.x, ev.y, { x: layout.inputX, y: layout.inputY, w: layout.inputW, h: INPUT_H })) {
+                hover = 0;
+            }
+            else if (layout && ev.y >= layout.tabY && ev.y < layout.tabY + TAB_H) {
+                for (let i = 0; i < layout.tabs.length; i++) {
+                    if (inRect(ev.x, ev.y, { x: layout.tabs[i].x, y: layout.tabY, w: layout.tabs[i].w, h: TAB_H })) {
+                        hover = i + 1;
+                        break;
+                    }
+                }
+            }
+            if (hover !== this.hoverIdx) {
+                this.hoverIdx = hover;
+                this.app.render();
+            }
+            return;
+        }
+        if (ev.type === "click") {
+            const layout = this.layout();
+            if (!layout)
+                return;
+            if (ev.button === 2)
+                return; // right click: no-op on start screen
+            if (ev.y === 0) {
+                this.app.openModelConfig();
+                return;
+            }
+            if (inRect(ev.x, ev.y, { x: layout.inputX, y: layout.inputY, w: layout.inputW, h: INPUT_H })) {
+                this.focusIdx = 0;
+                if (ev.y === layout.inputY + 1 && ev.x >= layout.inputX + 2) {
+                    const innerW = layout.inputW - 4;
+                    const col = Math.min(innerW - 1, ev.x - (layout.inputX + 2));
+                    const win = computeInputWindow(this.inputValue, this.cursor, innerW);
+                    this.cursor = cursorFromColumn(this.inputValue, col, win);
+                }
+                this.app.render();
+                return;
+            }
+            if (ev.y >= layout.tabY && ev.y < layout.tabY + TAB_H) {
+                for (let i = 0; i < layout.tabs.length; i++) {
+                    if (inRect(ev.x, ev.y, { x: layout.tabs[i].x, y: layout.tabY, w: layout.tabs[i].w, h: TAB_H })) {
+                        this.focusIdx = i + 1;
+                        this.hoverIdx = i + 1;
+                        this.enterTab();
+                        return;
+                    }
+                }
+            }
+            return;
+        }
+    }
+    layout() {
+        const w = this.app.width;
+        const h = this.app.height;
+        const inputW = Math.min(78, w - 4);
+        const inputX = Math.floor((w - inputW) / 2);
+        const logoLines = LOGO.replace(/\n+$/, "").split("\n");
+        const gap = 1;
+        const contentH = logoLines.length + 1 + INPUT_H + gap + TAB_H;
+        const inputY = centerVertically(h, contentH) + logoLines.length + 1;
+        const tabY = inputY + INPUT_H + gap;
+        const tabGap = 2;
+        const tabInner = inputW - tabGap * (TABS.length - 1);
+        const baseW = Math.floor(tabInner / TABS.length);
+        const extra = tabInner - baseW * TABS.length;
+        const tabs = [];
+        let tx = inputX;
+        for (let i = 0; i < TABS.length; i++) {
+            const tw = baseW + (i < extra ? 1 : 0);
+            tabs.push({ x: tx, w: tw });
+            tx += tw + tabGap;
+        }
+        return { inputX, inputY, inputW, tabY, tabs };
+    }
     move(delta) {
         this.focusIdx = (this.focusIdx + delta + FOCUS_COUNT) % FOCUS_COUNT;
+        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() {
@@ -94,9 +221,7 @@ export class StartScreen extends Screen {
         const logoMax = logoLines.reduce((m, l) => Math.max(m, l.length), 0);
         const logoX = Math.max(0, Math.floor((w - logoMax) / 2));
         const gap = 1;
-        const inputBoxH = 3;
-        const tabH = 3;
-        const contentH = logoLines.length + 1 + inputBoxH + gap + tabH;
+        const contentH = logoLines.length + 1 + INPUT_H + gap + TAB_H;
         const top = centerVertically(h, contentH);
         let y = top;
         for (const line of logoLines) {
@@ -106,9 +231,10 @@ 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 += inputBoxH + gap;
+        y += INPUT_H + gap;
         const tabGap = 2;
         const tabInner = inputW - tabGap * (TABS.length - 1);
         const baseW = Math.floor(tabInner / TABS.length);
@@ -116,14 +242,27 @@ export class StartScreen extends Screen {
         let tx = inputX;
         for (let i = 0; i < TABS.length; i++) {
             const tw = baseW + (i < extra ? 1 : 0);
-            drawTabButton(buf, tx, y, tw, TABS[i], i === this.focusIdx - 1);
+            const selected = i === this.focusIdx - 1 || i === this.hoverIdx - 1;
+            drawTabButton(buf, tx, y, tw, TABS[i], selected);
             tx += tw + tabGap;
         }
-        const hintY = y + tabH + 1;
-        if (hintY < h) {
-            buf.centerText(hintY, "←/→ / ↑/↓ switch  ·  Enter confirm  ·  Ctrl+E model  ·  Ctrl+Q quit", {
-                fg: C.dim,
-            });
+        // 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 && (!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

@@ -7,5 +7,8 @@ export function defaultState() {
         selectedModelStreaming: true,
         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

@@ -155,6 +155,15 @@ export class InputReader {
                 this.emitKey("end", false, false, false, "\x1b[4~");
         }
     }
+    /**
+     * Parse SGR (extended) mouse sequences: ESC [ < b ; x ; y M/m
+     *
+     * `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(";");
         if (parts.length < 3)
@@ -164,14 +173,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;
+        }
+        if (final === "m") {
+            this.emitMouse({ type: "release", x, y, button });
+            return;
         }
-        else if (b === 65) {
-            this.emitMouse({ type: "wheel", dir: 1, 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) {

package/dist/terminal/renderer.js

@@ -11,6 +11,8 @@ function styleKey(st) {
         k += "d";
     if (st.inverse)
         k += "i";
+    if (st.italic)
+        k += "I";
     return k;
 }
 function sgr(st) {
@@ -19,6 +21,8 @@ function sgr(st) {
         codes.push("1");
     if (st.dim)
         codes.push("2");
+    if (st.italic)
+        codes.push("3");
     if (st.inverse)
         codes.push("7");
     if (st.fg)
@@ -45,10 +49,10 @@ export class Renderer {
     init() {
         this.write("\x1b[?1049h"); // alternate screen
         this.write("\x1b[?25l"); // hide cursor
-        this.write("\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?1015h"); // mouse tracking
+        this.write("\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h\x1b[?1015h"); // mouse tracking (incl. any-event for hover)
     }
     dispose() {
-        this.write("\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?1015l");
+        this.write("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l");
         this.write("\x1b[?25h");
         this.write("\x1b[?1049l");
         this.write("\x1b[0m");
@@ -74,12 +78,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,11 @@
 export class Screen {
     app;
     onMouse(_ev) { }
+    /** 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() { }
 }