@xingjisoft/neutrino 0.1.3 → 0.1.4

package/dist/screens/start.js

@@ -168,6 +168,20 @@ export class StartScreen extends Screen {
             return;
         }
     }
+    /**
+     * The message box, the tabs below it and the hint row are persistent chrome;
+     * repainting them every frame keeps them self-healing against terminal-side
+     * drift (see Screen.alwaysRepaintRows).
+     */
+    alwaysRepaintRows() {
+        const { inputY, tabY } = this.layout();
+        const h = this.app.height;
+        const rows = [];
+        for (let y = inputY; y <= tabY + TAB_H; y++)
+            if (y >= 0 && y < h)
+                rows.push(y);
+        return rows;
+    }
     layout() {
         const w = this.app.width;
         const h = this.app.height;

package/dist/selection.js

@@ -6,11 +6,16 @@ export function normalizeSelection(sel) {
         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. */
+/**
+ * Index of the last cell on a row that holds real content, or -1 when the row
+ * has none. UI chrome (a scrollbar) and blank cells are ignored, so a highlight
+ * never spills over the scrollbar column.
+ */
 function lastContentCol(buf, y) {
     const row = buf.cells[y];
     for (let x = row.length - 1; x >= 0; x--) {
-        if (row[x].ch !== " ")
+        const cell = row[x];
+        if (!cell.chrome && cell.ch !== " ")
             return x;
     }
     return -1;
@@ -34,8 +39,8 @@ export function applySelection(buf, sel) {
             continue;
         for (let x = x0; x <= x1; x++) {
             const cell = buf.cells[y][x];
-            if (!cell)
-                continue;
+            if (!cell || cell.chrome)
+                continue; // never highlight the scrollbar
             cell.style = {
                 fg: C.white,
                 bg: C.selection,
@@ -46,9 +51,18 @@ export function applySelection(buf, sel) {
     }
 }
 /**
- * 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.
+ * Extract the plain text covered by a selection.
+ *
+ * Three kinds of cell are skipped so the result is clean, pasteable text:
+ *   - UI chrome (the scrollbar), which is never content;
+ *   - wide-character continuation cells (`""`), which would duplicate a CJK
+ *     glyph;
+ *   - trailing blanks, trimmed per line (shell-style).
+ *
+ * Intermediate lines are copied out to the buffer's full width and only then
+ * trimmed, which keeps indentation intact while dropping the padding on the
+ * right. Skipping the scrollbar *before* trimming is what lets that trim
+ * actually reach the end of the text instead of stopping at the bar.
  */
 export function selectionText(buf, sel) {
     const { start, end } = normalizeSelection(sel);
@@ -57,12 +71,12 @@ export function selectionText(buf, sel) {
     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;
+        const x1 = y === end.y ? Math.min(buf.width - 1, end.x) : buf.width - 1;
         let line = "";
-        for (let x = x0; x <= Math.min(buf.width - 1, x1); x++) {
+        for (let x = x0; x <= x1; x++) {
             const cell = buf.cells[y][x];
-            if (!cell || cell.ch === "")
-                continue; // "" is the tail of a wide glyph
+            if (!cell || cell.chrome || cell.ch === "")
+                continue;
             line += cell.ch;
         }
         lines.push(line.replace(/[ \t]+$/, ""));

package/dist/terminal/buffer.js

@@ -1,5 +1,6 @@
 import { C, EMPTY_STYLE } from "../colors.js";
 import { displayWidth, wcwidth } from "../width.js";
+import { isControlChar } from "../sanitize.js";
 const emptyCell = () => ({ ch: " ", style: { bg: C.black } });
 function normalize(style) {
     return style.bg ? style : { ...style, bg: C.black };
@@ -56,6 +57,12 @@ export class Buffer {
         row[x] = { ch: "", style: normalize(style) };
     }
     writeChar(x, y, ch, style) {
+        // A control character (ESC, TAB, CR, …) would be written verbatim by the
+        // renderer and interpreted by the terminal as a command. Neutralise it to a
+        // space, which matches the single-column width wcwidth() reports for it, so
+        // the layout stays exactly as the caller measured it.
+        if (isControlChar(ch))
+            ch = " ";
         if (cellWidth(ch) === 2) {
             if (x + 1 >= this.width) {
                 // No room for the tail: degrade to a space so the line never overflows
@@ -70,8 +77,6 @@ export class Buffer {
         this.overwriteCell(x, y, ch, style);
     }
     set(x, y, ch, style = EMPTY_STYLE) {
-        if (ch === "\r" || ch === "\n")
-            return;
         if (x < 0 || x >= this.width || y < 0 || y >= this.height)
             return;
         this.writeChar(x, y, ch, style);
@@ -81,8 +86,14 @@ export class Buffer {
             return;
         let col = x;
         for (const ch of text) {
+            // Measure the character as the caller will have measured it, *then*
+            // neutralise control codes, so the column bookkeeping stays identical to
+            // the wrapping done upstream (see sanitize.ts).
+            const ctrl = isControlChar(ch);
             const w = wcwidth(ch.codePointAt(0) ?? 0);
             if (w === 0) {
+                if (ctrl)
+                    continue; // zero-width control (NUL): drop it
                 // 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 !== "") {
@@ -96,7 +107,7 @@ export class Buffer {
                 col += w;
                 continue;
             }
-            this.writeChar(col, y, ch, style);
+            this.writeChar(col, y, ctrl ? " " : ch, style);
             col += w;
         }
     }
@@ -124,6 +135,16 @@ export class Buffer {
         }
         this.writeText(x, y + h - 1, bottom, style);
     }
+    /**
+     * Flag a cell as non-copyable chrome (e.g. a scrollbar). The flag lives on
+     * the cell and is cleared automatically whenever the cell is written again,
+     * since every frame starts from a fresh buffer.
+     */
+    markChrome(x, y) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
+            return;
+        this.cells[y][x].chrome = true;
+    }
     clear() {
         for (let j = 0; j < this.height; j++) {
             const row = this.cells[j];

package/dist/terminal/renderer.js

@@ -1,4 +1,5 @@
 import process from "node:process";
+import { isControlChar } from "../sanitize.js";
 function styleKey(st) {
     let k = "";
     if (st.fg)
@@ -46,6 +47,14 @@ export class Renderer {
     prevW = 0;
     prevH = 0;
     out = process.stdout;
+    /**
+     * The most recent frame and the rows that were force-repainted for it. Kept
+     * so `repaint()` can re-emit the exact same frame — without re-running the
+     * screen's (potentially expensive) render — to heal any drift the terminal
+     * introduced behind our back.
+     */
+    lastBuf = null;
+    lastForce = [];
     init() {
         this.write("\x1b[?1049h"); // alternate screen
         this.write("\x1b[?25l"); // hide cursor
@@ -59,7 +68,31 @@ export class Renderer {
         this.write("\x1b[?1049l");
         this.write("\x1b[0m");
     }
-    render(buf) {
+    /**
+     * @param forceRows rows to repaint unconditionally, even when their contents
+     *   are unchanged. Screens use this for persistent chrome (input box, hints)
+     *   so that terminal-side drift can never leave it stale (see
+     *   `Screen.alwaysRepaintRows`).
+     */
+    render(buf, forceRows = []) {
+        this.lastBuf = buf;
+        this.lastForce = forceRows;
+        this.draw(buf, forceRows);
+    }
+    /**
+     * Re-emit the last frame in full. Cheap (no screen re-render) and visually a
+     * no-op when nothing drifted, but it repairs rows the terminal moved on its
+     * own (resize reflow, stray scroll). Called periodically as a safety net.
+     */
+    repaint() {
+        if (!this.lastBuf)
+            return;
+        const all = [];
+        for (let y = 0; y < this.lastBuf.height; y++)
+            all.push(y);
+        this.draw(this.lastBuf, all);
+    }
+    draw(buf, forceRows) {
         const w = buf.width;
         const h = buf.height;
         if (w !== this.prevW || h !== this.prevH) {
@@ -67,11 +100,12 @@ export class Renderer {
             this.prevW = w;
             this.prevH = h;
         }
+        const force = forceRows.length ? new Set(forceRows) : null;
         let out = "";
         for (let y = 0; y < h; y++) {
             const row = buf.cells[y];
             const sig = rowSignature(row);
-            if (sig !== this.prevSig[y]) {
+            if (sig !== this.prevSig[y] || (force !== null && force.has(y))) {
                 out += this.renderRow(y, row);
                 this.prevSig[y] = sig;
             }
@@ -96,7 +130,11 @@ export class Renderer {
                 s += sgr(cell.style);
                 lastKey = sk;
             }
-            s += cell.ch;
+            // Final safety net: the byte stream is the one place a stray control
+            // character would be executed by the terminal (cursor moves, screen
+            // clears, …). The Buffer already neutralises them; this guarantees it
+            // even if a cell is ever populated by some other path.
+            s += isControlChar(cell.ch) ? " " : cell.ch;
         }
         s += "\x1b[0m";
         return s;

package/dist/terminal/screen.js

@@ -9,6 +9,21 @@ export class Screen {
     scrollbar() {
         return null;
     }
+    /**
+     * Rows this screen draws as persistent "chrome" (an input box, key hints, …)
+     * that must be repainted on *every* frame, even when their contents are
+     * unchanged.
+     *
+     * The renderer normally emits only rows whose cells changed, which is what
+     * keeps redraws cheap. But the terminal can shift its own contents behind our
+     * back — ConPTY reflowing the buffer mid-resize, a size-race repaint, a stray
+     * scroll — and a diffed row would then stay stale forever (the classic
+     * "input box swallowed by the log" artefact). Redrawing this small strip by
+     * absolute position every frame makes it self-healing.
+     */
+    alwaysRepaintRows() {
+        return [];
+    }
     /**
      * 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

package/dist/ui.js

@@ -199,6 +199,9 @@ export function drawScrollbar(buf, x, top, bottom, total, viewport, offset, opts
     for (let i = 0; i < g.trackH; i++) {
         const isThumb = i >= g.thumbTop && i < g.thumbTop + g.thumbH;
         buf.set(x, top + i, isThumb ? "█" : "│", { fg: isThumb ? thumbColor : trackColor });
+        // The bar is chrome, not content: mark it so copying a selection never
+        // drags the scrollbar (or the padding before it) into the clipboard.
+        buf.markChrome(x, top + i);
     }
 }
 export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
   "type": "module",
   "license": "Apache-2.0",
@@ -17,7 +17,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs",
+    "test": "npm run build && node scripts/test-paste.mjs && node scripts/test-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-copy.mjs && node scripts/test-scrollbar.mjs && node scripts/test-render.mjs && node scripts/test-drift.mjs && node scripts/test-sanitize.mjs && node scripts/test-markdown.mjs && node scripts/test-wrap.mjs && node scripts/test-fetch.mjs && node scripts/test-compact.mjs && node scripts/test-tools.mjs",
     "prepare": "npm run build"
   },
   "keywords": [