@xingjisoft/neutrino 0.1.0 → 0.1.2

package/README.md

@@ -5,6 +5,8 @@ A CLI coding agent that lives in your terminal. Neutrino gives you an interactiv
 ## Features
 
 - **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`).
@@ -52,9 +54,25 @@ 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 |
-| `PgUp` / `PgDn`, scroll | Scroll chat history |
+| `Esc` | Clear an active selection |
+| `PgUp` / `PgDn` | Scroll chat history |
+| `Ctrl+C` | Copy the selection, or quit if nothing is selected |
+| `Ctrl+Q` | Quit |
+
+### Mouse
+
+| Action | Effect |
+| --- | --- |
+| 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 |
-| `Ctrl+C` / `Ctrl+Q` | Quit |
+| 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
 
@@ -89,8 +107,23 @@ The agent can call the following tools during a conversation:
 
 ```sh
 npm run build    # compile TypeScript to dist/
+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;
@@ -19,6 +24,19 @@ export class App {
     input = new InputReader();
     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;
@@ -71,26 +89,98 @@ 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();
     }
     render() {
+        // Start/stop the "thinking" blink animation. While the agent is thinking,
+        // a timer toggles the blink phase and re-renders so the top status bar
+        // flashes to draw the user's attention.
+        if (this.state.isThinking && !this.blinkTimer) {
+            this.state.blinkOn = true;
+            this.blinkTimer = setInterval(() => {
+                this.state.blinkOn = !this.state.blinkOn;
+                this.render();
+            }, 500);
+        }
+        else if (!this.state.isThinking && this.blinkTimer) {
+            clearInterval(this.blinkTimer);
+            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;
@@ -98,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;
@@ -162,6 +328,18 @@ export class App {
         this.running = true;
         if (this.sizeTimer)
             clearInterval(this.sizeTimer);
+        if (this.blinkTimer) {
+            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

@@ -10,5 +10,7 @@ export const C = {
     white: [226, 232, 240],
     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/header.js

@@ -2,14 +2,19 @@ import { C } from "./colors.js";
 import { truncateByWidth } from "./width.js";
 export function drawHeader(buf, state) {
     const w = buf.width;
-    buf.fillRect(0, 0, w, 1, { bg: C.highlightBg });
-    let text;
     if (state.isThinking) {
-        text = "thinking";
-    }
-    else {
-        text = `${state.selectedProvider}/${state.selectedModelName} | ${state.selectedIntensity}`;
+        // Flashing indicator: the whole bar alternates between highlighted and
+        // dark while the agent is working, so the user always notices it.
+        const on = state.blinkOn;
+        const bg = on ? C.highlightBg : C.black;
+        const fg = on ? C.accent : C.dim;
+        const text = "⚡ thinking";
+        buf.fillRect(0, 0, w, 1, { bg });
+        buf.centerText(0, text, { fg, bg, bold: true });
+        return;
     }
+    buf.fillRect(0, 0, w, 1, { bg: C.highlightBg });
+    let text = `${state.selectedProvider}/${state.selectedModelName} | ${state.selectedIntensity}`;
     text = truncateByWidth(text, w);
     buf.centerText(0, text, { fg: C.accent, bg: C.highlightBg, bold: true });
 }