@xingjisoft/neutrino 0.1.1 → 0.1.2

package/README.md

@@ -6,6 +6,7 @@ A CLI coding agent that lives in your terminal. Neutrino gives you an interactiv
 
 - **Interactive terminal UI** — logo screen, chat, model select, history, and settings screens.
 - **Full mouse support** — hover to highlight, click to select/open/position the cursor, wheel to scroll, right-click to go back (like OpenCode).
+- **Select & copy** — drag the mouse over any text (agent output, the input box, menus, …) to select it; releasing the button copies the selection to the clipboard (via OSC 52, with a native fallback).
 - **LLM providers** — ships with DeepSeek, OpenAI, and Anthropic presets; works with any OpenAI-compatible endpoint.
 - **Tool calling** — the agent can run shell commands, read files, write files, and list directories in your working directory.
 - **Streaming responses** — token-by-token output with pause/resume (`ESC ESC`).
@@ -53,8 +54,10 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 | `Ctrl+B` | Back to menu (from chat) |
 | `Ctrl+L` | Clear conversation (from chat) |
 | `Esc Esc` | Pause / resume streaming |
+| `Esc` | Clear an active selection |
 | `PgUp` / `PgDn` | Scroll chat history |
-| `Ctrl+C` / `Ctrl+Q` | Quit |
+| `Ctrl+C` | Copy the selection, or quit if nothing is selected |
+| `Ctrl+Q` | Quit |
 
 ### Mouse
 
@@ -63,11 +66,14 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 | Hover over an item | Highlight / select it in lists and menus |
 | Click an item | Select and confirm (open a screen, load a session, apply a setting…) |
 | Click the input box | Focus it and place the cursor at the clicked position |
+| Click and drag | Select text under the rectangle; releasing copies it to the clipboard |
 | Click the header (left of `ⓘ`) | Open the model selector |
 | Click `ⓘ` (chat header) | Toggle token usage stats |
 | Scroll wheel | Scroll the chat/log, or move through lists |
 | Right-click | Go back (like `Esc`) |
 
+The selection highlight is drawn over whatever is on screen, so it works uniformly on the chat log, the input box and every menu. Selected text is copied with trailing whitespace trimmed per line (shell-style), so it can be pasted straight back into a terminal.
+
 ## Configuration
 
 Settings are stored under `~/.neutrino/`:
@@ -101,10 +107,23 @@ The agent can call the following tools during a conversation:
 
 ```sh
 npm run build    # compile TypeScript to dist/
-node scripts/test-mouse.mjs    # verify mouse escape-sequence parsing
-node scripts/test-cursor.mjs   # verify click-to-position-cursor math
+npm test         # build, then run every test below
 ```
 
+Individual tests:
+
+```sh
+node scripts/test-mouse.mjs      # verify mouse escape-sequence parsing
+node scripts/test-cursor.mjs     # verify click-to-position-cursor math
+node scripts/test-selection.mjs  # verify selection highlighting & text extraction
+node scripts/test-render.mjs     # fuzz the diff renderer + render the chat screen,
+                                 # asserting no stale/residual cells are left behind
+```
+
+### Rendering model
+
+The screen is drawn into a `Buffer` of cells which is diffed against the previous frame, so only changed rows are emitted. Rows are erased to the end of the line before being repainted, and the buffer keeps double-width glyphs consistent (writing over one half of a wide character blanks the other half). Together these guarantee that a repainted row can never leave a stale cell behind.
+
 ## License
 
 Apache-2.0. See [LICENSE](./LICENSE).

package/dist/app.js

@@ -4,12 +4,17 @@ import { InputReader } from "./terminal/input.js";
 import { Renderer } from "./terminal/renderer.js";
 import { defaultState } from "./state.js";
 import { loadConfig, saveConfig } from "./config.js";
+import { C } from "./colors.js";
+import { applySelection, selectionText } from "./selection.js";
+import { copyToClipboard } from "./clipboard.js";
 import { ChatScreen } from "./screens/chat.js";
 import { HistoryScreen } from "./screens/history.js";
 import { AgentSelectScreen } from "./screens/agentSelect.js";
 import { ModelSelectScreen } from "./screens/modelSelect.js";
 import { SettingsScreen } from "./screens/settings.js";
 import { StartScreen } from "./screens/start.js";
+const CURSOR_BLINK_MS = 530;
+const TOAST_MS = 1600;
 export class App {
     state = defaultState();
     width;
@@ -20,6 +25,18 @@ export class App {
     running = false;
     sizeTimer = null;
     blinkTimer = null;
+    cursorTimer = null;
+    toastTimer = null;
+    toast = "";
+    // Most recently rendered frame. Kept so a selection can be turned back into
+    // text without having to re-run the screen's render.
+    lastBuffer = null;
+    // Mouse selection bookkeeping. `pressed` is true between a left-button press
+    // and its release; `pressStart` is where the press landed, used as the anchor
+    // once the pointer starts moving (i.e. once it becomes a drag). A plain click
+    // never moves, so it is forwarded to the screen and leaves no selection.
+    pressed = false;
+    pressStart = null;
     resizeHandler = () => this.onResize();
     constructor() {
         this.width = process.stdout.columns || 80;
@@ -72,11 +89,15 @@ export class App {
     pushScreen(screen) {
         screen.app = this;
         this.screens.push(screen);
+        this.resetMouse();
+        this.state.selection = null;
         screen.onActivate();
         this.render();
     }
     popScreen() {
         const screen = this.screens.pop();
+        this.resetMouse();
+        this.state.selection = null;
         screen?.onDeactivate();
         this.render();
     }
@@ -96,17 +117,70 @@ export class App {
             this.blinkTimer = null;
             this.state.blinkOn = false;
         }
+        // The text cursor blinks whenever the top screen shows one. The timer is
+        // only kept alive while needed so idle screens don't repaint needlessly.
+        this.updateCursorBlink();
         const buf = new Buffer(this.width, this.height);
         this.top?.render(buf);
+        this.lastBuffer = buf;
+        // The selection overlay is painted over the finished frame, so it works on
+        // every screen (chat log, input box, menus, …) without each having to know
+        // about selection at all.
+        if (this.state.selection)
+            applySelection(buf, this.state.selection);
+        this.drawToast(buf);
         this.renderer.render(buf);
     }
+    drawToast(buf) {
+        if (!this.toast)
+            return;
+        const y = buf.height - 1;
+        buf.fillRect(0, y, buf.width, 1, { bg: C.black });
+        buf.centerText(y, ` ${this.toast} `, { fg: C.black, bg: C.accent, bold: true });
+    }
+    updateCursorBlink() {
+        const want = this.top?.showsCursor() ?? false;
+        if (want && !this.cursorTimer) {
+            this.cursorTimer = setInterval(() => {
+                this.state.cursorOn = !this.state.cursorOn;
+                this.render();
+            }, CURSOR_BLINK_MS);
+        }
+        else if (!want && this.cursorTimer) {
+            clearInterval(this.cursorTimer);
+            this.cursorTimer = null;
+            this.state.cursorOn = true;
+        }
+    }
+    /** Reset the blink phase so the cursor is solid right after an interaction. */
+    wakeCursor() {
+        this.state.cursorOn = true;
+    }
     handleEvent(ev) {
         if (ev.type === "key") {
             const k = ev.key;
-            if (k.ctrl && (k.name === "c" || k.name === "q")) {
+            // Any keystroke ends a pending mouse gesture (in case a release was lost).
+            this.resetMouse();
+            if (k.ctrl && k.name === "q") {
+                this.quit();
+                return;
+            }
+            if (k.ctrl && k.name === "c") {
+                // Ctrl+C copies the selection when there is one, otherwise it quits —
+                // the usual terminal convention.
+                if (this.state.selection) {
+                    this.copySelection();
+                    return;
+                }
                 this.quit();
                 return;
             }
+            if (k.name === "escape" && this.state.selection) {
+                this.state.selection = null;
+                this.render();
+                return;
+            }
+            this.wakeCursor();
             if (k.ctrl && (k.name === "m" || k.name === "e")) {
                 this.openModelConfig();
                 return;
@@ -114,9 +188,85 @@ export class App {
             this.top?.onKey(k);
         }
         else {
-            this.top?.onMouse(ev.event);
+            this.handleMouse(ev.event);
+        }
+    }
+    handleMouse(ev) {
+        if (ev.type === "click") {
+            this.wakeCursor();
+            this.pressed = true;
+            this.pressStart = { x: ev.x, y: ev.y };
+            if (this.state.selection) {
+                this.state.selection = null;
+                this.render();
+            }
+            // Forward immediately so plain clicks (focus, tabs, header, …) keep
+            // working even in terminals that don't report button releases.
+            this.top?.onMouse(ev);
+            return;
+        }
+        if (ev.type === "move") {
+            if (this.pressed && this.pressStart) {
+                const s = this.pressStart;
+                if (ev.x !== s.x || ev.y !== s.y) {
+                    // The pointer left the press cell, so this is a drag: grow/shrink the
+                    // selection instead of forwarding a hover to the screen.
+                    this.state.selection = { anchor: s, cursor: { x: ev.x, y: ev.y } };
+                    this.render();
+                }
+                return;
+            }
+            this.top?.onMouse(ev);
+            return;
+        }
+        if (ev.type === "release") {
+            const sel = this.state.selection;
+            this.pressed = false;
+            this.pressStart = null;
+            if (sel) {
+                if (this.lastBuffer) {
+                    const text = selectionText(this.lastBuffer, sel);
+                    if (text.trim().length > 0) {
+                        copyToClipboard(text);
+                        this.showToast(`Copied ${text.length} char${text.length === 1 ? "" : "s"}`);
+                        return;
+                    }
+                }
+                this.render();
+            }
+            return;
+        }
+        if (ev.type === "wheel") {
+            if (this.state.selection)
+                this.state.selection = null;
+            this.top?.onMouse(ev);
         }
     }
+    resetMouse() {
+        this.pressed = false;
+        this.pressStart = null;
+    }
+    copySelection() {
+        const sel = this.state.selection;
+        if (!sel || !this.lastBuffer)
+            return;
+        const text = selectionText(this.lastBuffer, sel);
+        if (text.trim().length === 0)
+            return;
+        copyToClipboard(text);
+        this.showToast(`Copied ${text.length} char${text.length === 1 ? "" : "s"}`);
+    }
+    showToast(text) {
+        this.toast = text;
+        if (this.toastTimer)
+            clearTimeout(this.toastTimer);
+        this.toastTimer = setTimeout(() => {
+            this.toastTimer = null;
+            this.toast = "";
+            this.render();
+        }, TOAST_MS);
+        this.render();
+    }
     setModelConfig(providerName, model, intensity) {
         this.state.selectedProvider = providerName;
         this.state.selectedModelName = model.name;
@@ -182,6 +332,14 @@ export class App {
             clearInterval(this.blinkTimer);
             this.blinkTimer = null;
         }
+        if (this.cursorTimer) {
+            clearInterval(this.cursorTimer);
+            this.cursorTimer = null;
+        }
+        if (this.toastTimer) {
+            clearTimeout(this.toastTimer);
+            this.toastTimer = null;
+        }
         this.input.stop();
         this.renderer.dispose();
         process.exit(0);

package/dist/clipboard.js

@@ -0,0 +1,113 @@
+import { Buffer } from "node:buffer";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+/**
+ * Copy `text` to the system clipboard.
+ *
+ * Two independent, best-effort strategies are used so the copy works across as
+ * many terminals as possible:
+ *
+ *   1. OSC 52 — a terminal escape sequence that asks the host terminal to put
+ *      the (base64-encoded) text on the clipboard. This is the only strategy
+ *      that also works over SSH, and is supported by Windows Terminal, iTerm2,
+ *      Kitty, WezTerm, Alacritty, …
+ *   2. A native helper process (`clip` / `pbcopy` / `wl-copy` / `xclip` / …),
+ *      as a fallback for terminals that ignore OSC 52.
+ *
+ * Both are best-effort: any failure is silently ignored.
+ */
+export function copyToClipboard(text) {
+    if (!text)
+        return;
+    copyViaOsc52(text);
+    copyViaNative(text);
+}
+function copyViaOsc52(text) {
+    try {
+        const payload = Buffer.from(text, "utf8").toString("base64");
+        // OSC 52 ; <selection> ; <base64> BEL
+        process.stdout.write(`\x1b]52;c;${payload}\x07`);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function copyViaNative(text) {
+    if (process.platform === "win32") {
+        copyWindows(text);
+        return;
+    }
+    const candidates = process.platform === "darwin"
+        ? [["pbcopy", []]]
+        : process.env.WAYLAND_DISPLAY
+            ? [
+                ["wl-copy", []],
+                ["xclip", ["-selection", "clipboard"]],
+                ["xsel", ["--clipboard", "--input"]],
+            ]
+            : [
+                ["xclip", ["-selection", "clipboard"]],
+                ["xsel", ["--clipboard", "--input"]],
+                ["wl-copy", []],
+            ];
+    pipeToFirstAvailable(candidates, text);
+}
+/** Spawn the first available helper and pipe the text into it. */
+function pipeToFirstAvailable(candidates, text) {
+    let index = 0;
+    const tryNext = () => {
+        if (index >= candidates.length)
+            return;
+        const [cmd, args] = candidates[index++];
+        let child;
+        try {
+            child = spawn(cmd, args, { stdio: ["pipe", "ignore", "ignore"] });
+        }
+        catch {
+            tryNext();
+            return;
+        }
+        child.once("error", () => tryNext());
+        child.once("spawn", () => {
+            child.stdin?.end(text);
+        });
+        child.stdin?.on("error", () => {
+            /* the helper closed early — ignore */
+        });
+    };
+    tryNext();
+}
+/**
+ * Windows: `clip.exe` decodes its input using the console code page, which
+ * mangles non-ASCII text. Instead we drop the text in a temp file and let
+ * PowerShell read it back as UTF-8 via the Unicode-aware Set-Clipboard cmdlet.
+ */
+function copyWindows(text) {
+    let tmp = null;
+    try {
+        tmp = path.join(os.tmpdir(), `neutrino-clip-${process.pid}-${Date.now()}.txt`);
+        fs.writeFileSync(tmp, text, "utf8");
+        const script = `Set-Clipboard -Value ([IO.File]::ReadAllText(${psQuote(tmp)}, [Text.Encoding]::UTF8)); ` +
+            `Remove-Item -LiteralPath ${psQuote(tmp)} -ErrorAction SilentlyContinue`;
+        const child = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { stdio: "ignore", windowsHide: true });
+        child.once("error", () => {
+            if (tmp) {
+                try {
+                    fs.rmSync(tmp, { force: true });
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        });
+    }
+    catch {
+        /* ignore */
+    }
+}
+function psQuote(value) {
+    return "'" + value.replace(/'/g, "''") + "'";
+}

package/dist/colors.js

@@ -11,5 +11,6 @@ export const C = {
     green: [115, 218, 202],
     red: [247, 118, 142],
     codeBg: [27, 35, 49], // dark blue-grey used behind code blocks
+    selection: [56, 92, 138], // muted blue used to highlight selected text
 };
 export const EMPTY_STYLE = {};

package/dist/config.js

@@ -194,3 +194,22 @@ export function loadPrompt() {
     return (readAsset(path.join(PKG_ROOT, "assets", "prompt.txt"), path.join(PKG_ROOT, "prompt.txt")) ??
         "You are Neutrino, a helpful AI coding assistant.");
 }
+let cachedVersion = null;
+/**
+ * Read the CLI version straight from the package's `package.json` so the
+ * displayed version can never drift out of sync with the published package.
+ * The result is cached after the first successful read.
+ */
+export function loadVersion() {
+    if (cachedVersion !== null)
+        return cachedVersion;
+    try {
+        const raw = fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8");
+        const pkg = JSON.parse(raw);
+        cachedVersion = typeof pkg.version === "string" ? pkg.version : "";
+    }
+    catch {
+        cachedVersion = "";
+    }
+    return cachedVersion;
+}

package/dist/screens/chat.js

@@ -78,6 +78,10 @@ export class ChatScreen extends Screen {
             this.app.render();
         }
     }
+    showsCursor() {
+        // The chat input is always focused; a cursor is drawn when it holds text.
+        return this.inputValue.length > 0;
+    }
     onKey(key) {
         if (this.showInfo) {
             this.showInfo = false;
@@ -469,10 +473,11 @@ export class ChatScreen extends Screen {
         drawInputBox(buf, 1, inputY, inW, this.inputValue, this.cursor, {
             active: true,
             dimmed: this.busy,
+            cursorOn: this.app.state.cursorOn,
             placeholder: "Type a message...",
         });
         const hintY = h - 1;
-        const hints = "Enter send  ·  ESC ESC pause  ·  Ctrl+B menu  ·  Ctrl+L clear";
+        const hints = "Enter send · ESC ESC pause · Ctrl+B menu · Ctrl+L clear · drag to copy";
         const hintW = displayWidth(hints);
         const hintX = Math.max(0, w - 1 - hintW);
         const pathAvail = Math.max(0, hintX - 2);

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,29 @@ 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;
+    }
     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 +185,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 +231,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 +246,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

@@ -158,12 +158,11 @@ export class InputReader {
     /**
      * 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 +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;
         }
-        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) {

package/dist/terminal/renderer.js

@@ -78,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() { }
 }

package/dist/ui.js

@@ -141,6 +141,7 @@ export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {
     const active = opts.active ?? true;
     const dimmed = opts.dimmed ?? false;
     const placeholder = opts.placeholder ?? "";
+    const cursorOn = opts.cursorOn ?? true;
     const h = 3;
     const innerX = x + 2;
     const innerW = w - 4;
@@ -158,22 +159,42 @@ export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {
     }
     const win = computeInputWindow(value, cursorPos, innerW);
     const chars = Array.from(value);
+    // Codepoint index of the cursor (cursorPos is a UTF-16 offset).
+    const cursorCp = Math.min(Array.from(value.slice(0, cursorPos)).length, chars.length);
     const visible = chars.slice(win.startCp, win.startCp + win.visibleCount).join("");
     buf.writeText(innerX, innerY, visible, textStyle);
-    const cursorScreenCol = cursorColAt(value, cursorPos, win);
-    if (active && cursorScreenCol >= 0 && cursorScreenCol < innerW) {
-        buf.set(innerX + cursorScreenCol, innerY, " ", { fg: C.black, bg: C.accent });
+    // Blinking block cursor. While it is "on" the character underneath is drawn
+    // inside the block in the opposite colour so the text stays legible instead
+    // of being hidden by the cursor.
+    const cursorScreenCol = cursorColAt(chars, cursorCp, win);
+    if (active && cursorOn && cursorScreenCol >= 0 && cursorScreenCol < innerW) {
+        drawBlockCursor(buf, innerX + cursorScreenCol, innerY, chars, cursorCp, cursorScreenCol, innerW);
     }
 }
-function cursorColAt(value, cursorPos, win) {
-    const chars = Array.from(value);
-    const cursorCp = Math.min(Array.from(value.slice(0, cursorPos)).length, chars.length);
+function cursorColAt(chars, cursorCp, win) {
     let col = win.prefixW;
     for (let i = win.startCp; i < cursorCp; i++) {
         col += wcwidth(chars[i].codePointAt(0) ?? 0);
     }
     return col - win.prefixW;
 }
+/**
+ * Draw a single block cursor cell. The glyph under the cursor (the character
+ * immediately to its right) is rendered in the opposite colour — a dark glyph
+ * on the accent block — so it remains readable. Past the end of the text, or
+ * when the glyph would not fit, a solid block is drawn instead.
+ */
+function drawBlockCursor(buf, x, y, chars, cursorCp, col, innerW) {
+    const cursorStyle = { fg: C.black, bg: C.accent };
+    const ch = cursorCp < chars.length ? chars[cursorCp] : "";
+    const cw = ch ? wcwidth(ch.codePointAt(0) ?? 0) : 0;
+    if (ch && ch !== " " && cw >= 1 && col + cw <= innerW) {
+        buf.writeText(x, y, ch, cursorStyle);
+    }
+    else {
+        buf.set(x, y, " ", cursorStyle);
+    }
+}
 function textStylePlaceholder(active) {
     return active ? { fg: C.dim, bg: C.highlightBg } : { fg: C.dim };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
   "type": "module",
   "license": "Apache-2.0",
@@ -17,6 +17,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-render.mjs",
     "prepare": "npm run build"
   },
   "keywords": [