@xingjisoft/neutrino 0.1.2 → 0.1.4

package/dist/screens/start.js

@@ -22,6 +22,17 @@ export class StartScreen extends Screen {
         // The input cursor is only drawn for the focused, non-empty input box.
         return this.focusIdx === 0 && this.inputValue.length > 0;
     }
+    onPaste(text) {
+        if (!text)
+            return;
+        // A paste always targets the message box, so focus it first.
+        this.focusIdx = 0;
+        this.hoverIdx = -1;
+        this.inputValue =
+            this.inputValue.slice(0, this.cursor) + text + this.inputValue.slice(this.cursor);
+        this.cursor += text.length;
+        this.app.render();
+    }
     onKey(key) {
         // 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
@@ -157,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/input.js

@@ -1,11 +1,44 @@
 import process from "node:process";
 const ESC_TIMEOUT = 30;
+// Bracketed paste: once enabled, the terminal wraps pasted text in
+// ESC [ 2 0 0 ~ ... ESC [ 2 0 1 ~ so a paste can be told apart from typing.
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+/** Flatten a pasted blob so its line breaks become ordinary spaces. */
+function flattenNewlines(s) {
+    return s.replace(/\r\n|\r|\n/g, " ");
+}
+/**
+ * Heuristic used when a terminal does not speak bracketed paste: a chunk of raw
+ * input counts as a paste when it carries a line break that is not merely the
+ * chunk's trailing one. A single line break at the very end is a manual Enter,
+ * and an all-whitespace chunk is just repeated Enter/space presses.
+ */
+function looksLikePaste(s) {
+    const body = s.replace(/(\r\n|\r|\n)$/, "");
+    if (!/\r|\n/.test(body))
+        return false;
+    if (/^\s*$/.test(s))
+        return false;
+    return true;
+}
+/** Length of the longest suffix of `s` that prefixes `marker` (0 if none). */
+function partialMarkerLength(s, marker) {
+    const max = Math.min(s.length, marker.length - 1);
+    for (let len = max; len > 0; len--) {
+        if (s.slice(s.length - len) === marker.slice(0, len))
+            return len;
+    }
+    return 0;
+}
 export class InputReader {
     decoder = new TextDecoder("utf-8");
     pending = "";
     state = "normal";
     csiBuf = "";
     escTimer = null;
+    inPaste = false;
+    pasteBuf = "";
     handler = null;
     dataHandler = (chunk) => this.onData(chunk);
     start(handler) {
@@ -31,8 +64,34 @@ export class InputReader {
     }
     process() {
         const s = this.pending;
+        // An unwrapped multi-line paste (terminals without bracketed-paste support
+        // deliver the raw text). Flatten it so the whole paste stays on one line
+        // and nothing gets submitted — only a manual Enter submits.
+        if (!this.inPaste && this.state === "normal" && !s.includes(PASTE_START) && looksLikePaste(s)) {
+            this.pending = "";
+            this.emitPaste(flattenNewlines(s));
+            return;
+        }
         let i = 0;
         while (i < s.length) {
+            if (this.inPaste) {
+                const end = s.indexOf(PASTE_END, i);
+                if (end === -1) {
+                    // No terminator yet: buffer what we have, holding back a possible
+                    // partial terminator so it can be matched with the next chunk.
+                    const rest = s.slice(i);
+                    const keep = partialMarkerLength(rest, PASTE_END);
+                    this.pasteBuf += rest.slice(0, rest.length - keep);
+                    this.pending = rest.slice(rest.length - keep);
+                    return;
+                }
+                this.pasteBuf += s.slice(i, end);
+                this.inPaste = false;
+                this.emitPaste(flattenNewlines(this.pasteBuf));
+                this.pasteBuf = "";
+                i = end + PASTE_END.length;
+                continue;
+            }
             const c = s[i];
             if (this.state === "normal") {
                 if (c === "\x1b") {
@@ -44,7 +103,8 @@ export class InputReader {
                 const code = c.charCodeAt(0);
                 if (c === "\r" || c === "\n") {
                     this.emitKey("return", false, false, false, c);
-                    i++;
+                    // A CRLF pair is one Return, not two.
+                    i += c === "\r" && s[i + 1] === "\n" ? 2 : 1;
                     continue;
                 }
                 if (c === "\t") {
@@ -153,6 +213,15 @@ export class InputReader {
                 this.emitKey("home", false, false, false, "\x1b[1~");
             else if (param === "4" || param === "8")
                 this.emitKey("end", false, false, false, "\x1b[4~");
+            else if (param === "200") {
+                // Start of a bracketed paste.
+                this.inPaste = true;
+                this.pasteBuf = "";
+            }
+            else if (param === "201") {
+                // End marker without a preceding start: ignore.
+                this.inPaste = false;
+            }
         }
     }
     /**
@@ -207,6 +276,11 @@ export class InputReader {
             },
         });
     }
+    emitPaste(text) {
+        if (!this.handler || !text)
+            return;
+        this.handler({ type: "paste", text });
+    }
     emitMouse(event) {
         if (!this.handler)
             return;

package/dist/terminal/renderer.js

@@ -1,4 +1,5 @@
 import process from "node:process";
+import { isControlChar } from "../sanitize.js";
 function styleKey(st) {
     let k = "";
     if (st.fg)
@@ -46,18 +47,52 @@ 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
         this.write("\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h\x1b[?1015h"); // mouse tracking (incl. any-event for hover)
+        this.write("\x1b[?2004h"); // bracketed paste (so pastes can be told apart from typing)
     }
     dispose() {
+        this.write("\x1b[?2004l");
         this.write("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l");
         this.write("\x1b[?25h");
         this.write("\x1b[?1049l");
         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) {
@@ -65,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;
             }
@@ -94,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

@@ -1,6 +1,35 @@
 export class Screen {
     app;
     onMouse(_ev) { }
+    /**
+     * Describe the on-screen scrollbar so the app can drag it, or null when this
+     * screen has none / its content fits. Geometry is only valid right after a
+     * render, which is exactly when the app needs it.
+     */
+    scrollbar() {
+        return null;
+    }
+    /**
+     * 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
+     * have no text input can leave this as a no-op.
+     */
+    onPaste(_text) { }
     /** Whether this screen currently shows a blinking text cursor. Used by the
      *  app to run (or stop) the cursor blink timer. */
     showsCursor() {

package/dist/ui.js

@@ -23,52 +23,78 @@ function chunkByWidth(text, width) {
 export function wrapText(text, width) {
     if (width <= 0)
         width = 1;
-    const lines = [];
-    for (const para of text.split("\n")) {
+    const out = [];
+    const paragraphs = text.replace(/\r\n?/g, "\n").split("\n");
+    for (const para of paragraphs) {
         if (para.length === 0) {
-            lines.push("");
+            out.push("");
             continue;
         }
-        let line = "";
-        let lineW = 0;
-        for (const word of para.split(" ")) {
-            const wordW = displayWidth(word);
-            if (line.length === 0) {
-                if (wordW <= width) {
-                    line = word;
-                    lineW = wordW;
-                }
-                else {
-                    const chunks = chunkByWidth(word, width);
-                    for (let i = 0; i < chunks.length - 1; i++)
-                        lines.push(chunks[i]);
-                    line = chunks[chunks.length - 1];
-                    lineW = displayWidth(line);
-                }
-                continue;
+        // Preserve the original indentation. Continuation lines reuse it so
+        // wrapped command output / code keeps its nesting instead of being
+        // flattened to the left margin.
+        const leadMatch = para.match(/^[ \t]*/);
+        const leadRaw = leadMatch ? leadMatch[0] : "";
+        const indent = leadRaw.replace(/\t/g, "  ");
+        const indentW = displayWidth(indent);
+        const body = para.slice(leadRaw.length);
+        // Split into words and the whitespace runs between them so runs of spaces
+        // (alignment padding in command output) are kept verbatim rather than
+        // collapsed to a single space.
+        const parts = body.match(/\s+|\S+/g) ?? [];
+        let line = indent;
+        let lineW = indentW;
+        let hasContent = false;
+        // Whitespace seen since the last word. It is only emitted together with
+        // the next word, so a line break never leaves trailing blanks behind.
+        let pending = "";
+        const newLine = () => {
+            out.push(line);
+            line = " ".repeat(indentW);
+            lineW = indentW;
+            hasContent = false;
+        };
+        const placeWord = (word) => {
+            const gap = hasContent ? pending : "";
+            pending = "";
+            const gapW = displayWidth(gap);
+            const w = displayWidth(word);
+            if (lineW + gapW + w <= width) {
+                line += gap + word;
+                lineW += gapW + w;
+                hasContent = true;
+                return;
             }
-            if (lineW + 1 + wordW <= width) {
-                line += " " + word;
-                lineW += 1 + wordW;
+            // Does not fit: break the line and drop the gap that caused the break.
+            if (hasContent)
+                newLine();
+            if (lineW + w <= width) {
+                line += word;
+                lineW += w;
+                hasContent = true;
+                return;
             }
-            else {
-                lines.push(line);
-                if (wordW <= width) {
-                    line = word;
-                    lineW = wordW;
-                }
-                else {
-                    const chunks = chunkByWidth(word, width);
-                    for (let i = 0; i < chunks.length - 1; i++)
-                        lines.push(chunks[i]);
-                    line = chunks[chunks.length - 1];
-                    lineW = displayWidth(line);
-                }
+            // Word is wider than an entire line: hard-wrap it by columns.
+            const avail = Math.max(1, width - lineW);
+            const chunks = chunkByWidth(word, avail);
+            for (let i = 0; i < chunks.length - 1; i++) {
+                line += chunks[i];
+                newLine();
+            }
+            line += chunks[chunks.length - 1];
+            lineW += displayWidth(chunks[chunks.length - 1]);
+            hasContent = true;
+        };
+        for (const part of parts) {
+            if (/^\s+$/.test(part)) {
+                pending += part.replace(/\t/g, "  ");
+                continue;
             }
+            placeWord(part);
         }
-        lines.push(line);
+        out.push(line);
     }
-    return lines;
+    return out;
 }
 /**
  * Compute which part of the input value is visible inside the box, given the
@@ -137,6 +163,47 @@ export function drawHint(buf, y, text) {
     const t = displayWidth(text) <= max ? text : truncateByWidth(text, max - 1) + "…";
     buf.centerText(y, t, { fg: C.dim });
 }
+/**
+ * Geometry of a vertical scrollbar, shared by the drawing code and the app's
+ * hit-testing / dragging so the two can never disagree.
+ */
+export function scrollbarGeometry(top, bottom, total, viewport, offset) {
+    const trackH = Math.max(0, bottom - top + 1);
+    const thumbH = Math.max(1, Math.round((trackH * viewport) / total));
+    const maxThumbTop = Math.max(0, trackH - thumbH);
+    const maxOffset = Math.max(1, total - viewport);
+    const clamped = Math.max(0, Math.min(offset, maxOffset));
+    const thumbTop = maxThumbTop === 0 ? 0 : Math.round((maxThumbTop * clamped) / maxOffset);
+    return { trackH, thumbH, maxThumbTop, maxOffset, thumbTop };
+}
+/**
+ * Inverse of the thumb positioning above: the scroll offset that places the
+ * thumb's top at 'thumbTop'. Used while dragging the thumb; feeding the result
+ * back through scrollbarGeometry reproduces the same 'thumbTop'.
+ */
+export function offsetFromThumbTop(g, thumbTop) {
+    if (g.maxThumbTop === 0)
+        return 0;
+    const t = Math.max(0, Math.min(thumbTop, g.maxThumbTop));
+    return Math.round((g.maxOffset * t) / g.maxThumbTop);
+}
+export function drawScrollbar(buf, x, top, bottom, total, viewport, offset, opts = {}) {
+    const trackH = bottom - top + 1;
+    if (trackH <= 0 || x < 0 || x >= buf.width)
+        return;
+    if (total <= viewport || viewport <= 0)
+        return; // nothing to scroll: hide it
+    const trackColor = opts.track ?? C.scrollTrack;
+    const thumbColor = opts.thumb ?? C.scrollThumb;
+    const g = scrollbarGeometry(top, bottom, total, viewport, offset);
+    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 = {}) {
     const active = opts.active ?? true;
     const dimmed = opts.dimmed ?? false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.1.2",
+  "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-mouse.mjs && node scripts/test-cursor.mjs && node scripts/test-selection.mjs && node scripts/test-render.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": [