@xingjisoft/neutrino 0.1.2 → 0.1.4

package/README.md

@@ -7,6 +7,9 @@ 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).
+- **Paste-friendly input** — like OpenCode, a pasted block has its newlines turned into spaces so it stays one line, and only a manually typed `Enter` submits the message.
+- **Faithful log rendering** — text in the chat log keeps its indentation, blank lines and column alignment; when a long tool-output line wraps, continuation lines stay indented instead of snapping back to the left margin.
+- **Scrollable context log** — a vertical scrollbar is drawn on the right edge of the chat (and the agent-conversation viewer) whenever the conversation is taller than the view. Scroll with the wheel, `PgUp`/`PgDn` or `↑`/`↓`, or grab the scrollbar with the mouse and drag it like in a GUI.
 - **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`).
@@ -48,7 +51,7 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 
 | Keys | Action |
 | --- | --- |
-| `Enter` | Send message / confirm |
+| `Enter` | Send message / confirm (only a manually typed Enter sends) |
 | `←`/`→`, `↑`/`↓` | Move focus / navigate |
 | `Ctrl+E` | Open model config |
 | `Ctrl+B` | Back to menu (from chat) |
@@ -69,10 +72,11 @@ Type a message on the start screen and press `Enter` to begin a new chat.
 | 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 |
+| Drag the scrollbar | Grab the thumb on the right edge of the chat/log and drag it to scroll |
 | 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.
+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. UI chrome (such as the scrollbar) is skipped when copying and highlighting, so a copy never picks up the bar or the padding in front of it.
 
 ## Configuration
 
@@ -113,17 +117,47 @@ npm test         # build, then run every test below
 Individual tests:
 
 ```sh
+node scripts/test-paste.mjs      # verify pasted newlines are flattened to spaces
 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-copy.mjs       # verify a copy never includes the scrollbar or trailing padding
+node scripts/test-scrollbar.mjs  # verify the conversation scrollbar size/position and drag maths
+node scripts/test-markdown.mjs   # verify markdown/table rendering (incl. ragged rows)
+node scripts/test-wrap.mjs       # verify indentation & spacing are preserved when wrapping
 node scripts/test-render.mjs     # fuzz the diff renderer + render the chat screen,
                                  # asserting no stale/residual cells are left behind
+node scripts/test-sanitize.mjs   # verify ANSI/control codes never reach the screen
+node scripts/test-drift.mjs      # verify the input area self-heals after terminal drift
+node scripts/test-fetch.mjs      # verify streamed requests release aborts and retry drops
+node scripts/test-compact.mjs    # verify context-compression planning
+node scripts/test-tools.mjs      # verify tool-output folding
 ```
 
 ### 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.
 
+Because only *changed* rows are emitted, a row whose contents happen to be identical from one frame to the next is never rewritten — so if the terminal shifts its own contents behind our back (ConPTY reflowing the buffer mid-resize, a size-race repaint, a stray scroll) that row would stay stale. Two defences cover this: the persistent chrome (input box, tabs, key hints) is repainted on every frame via `Screen.alwaysRepaintRows()`, and the app periodically re-emits the whole cached frame (`Renderer.repaint()`) as a safety net. Both are no-ops when nothing drifted.
+
+### Text hygiene
+
+A cell's glyph is copied straight into the output stream, so a cell holding a *control* character becomes a command the terminal executes — an ESC sequence can move the cursor, clear the screen or leave the alternate buffer, and a TAB shifts the rest of the row. Tool output (ANSI colours from `ls --color`, `git`, `npm`, progress bars, …), file contents and pasted text all carry such bytes, so they are neutralised in three places:
+
+1. `src/sanitize.ts` — `sanitizeText()` removes whole escape sequences (not just the ESC byte, which would leave `[31m` behind as literal text), expands tabs so measured widths match what the terminal draws, and drops any remaining control code. It is applied where untrusted text enters the display (chat messages, tool results, pasted input).
+2. `Buffer` — writing a control character stores a space instead, preserving the column width the caller measured, so no cell can ever hold one.
+3. `Renderer` — a last-resort check when emitting a row, so the byte stream cannot carry a control code even if a cell were populated another way.
+
+### Network resilience
+
+Model responses arrive over a streamed connection that can drop at any point. A single blip should not end the session, so three cases are handled:
+
+- **The request never goes out** (`fetch` rejects) — retried a couple of times with a short backoff, bounded by a connect timeout.
+- **The stream dies before the first byte** — the server or a proxy closed the connection mid-flight (`TypeError: terminated`, `other side closed`, …). Nothing has reached the user, so the request is simply re-issued.
+- **The stream dies after output has started** — retrying would duplicate text, so the error is surfaced instead, with the real reason expanded out of the `error.cause` chain (`fetch failed` alone says nothing useful).
+
+Any stream the consumer walks away from (pause, or a newer turn taking over) always has its body cancelled, so sockets are not leaked.
+
 ## License
 
 Apache-2.0. See [LICENSE](./LICENSE).

package/dist/app.js

@@ -6,6 +6,7 @@ import { defaultState } from "./state.js";
 import { loadConfig, saveConfig } from "./config.js";
 import { C } from "./colors.js";
 import { applySelection, selectionText } from "./selection.js";
+import { offsetFromThumbTop, scrollbarGeometry } from "./ui.js";
 import { copyToClipboard } from "./clipboard.js";
 import { ChatScreen } from "./screens/chat.js";
 import { HistoryScreen } from "./screens/history.js";
@@ -15,6 +16,10 @@ import { SettingsScreen } from "./screens/settings.js";
 import { StartScreen } from "./screens/start.js";
 const CURSOR_BLINK_MS = 530;
 const TOAST_MS = 1600;
+// How often the whole frame is re-emitted as a safety net, so terminal-side
+// drift (ConPTY reflow, stray scroll) can never leave any row stale for long.
+// Re-emitting the cached frame is a no-op when nothing drifted.
+const REPAINT_MS = 2000;
 export class App {
     state = defaultState();
     width;
@@ -27,6 +32,7 @@ export class App {
     blinkTimer = null;
     cursorTimer = null;
     toastTimer = null;
+    repaintTimer = 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.
@@ -37,6 +43,9 @@ export class App {
     // never moves, so it is forwarded to the screen and leaves no selection.
     pressed = false;
     pressStart = null;
+    // Active scrollbar drag: how many rows below the thumb's top the press
+    // landed, so the thumb stays under the pointer as it moves.
+    barDrag = null;
     resizeHandler = () => this.onResize();
     constructor() {
         this.width = process.stdout.columns || 80;
@@ -77,6 +86,7 @@ export class App {
             if (this.syncSize())
                 this.render();
         }, 200);
+        this.repaintTimer = setInterval(() => this.renderer.repaint(), REPAINT_MS);
         this.pushScreen(new StartScreen());
     }
     onResize() {
@@ -129,7 +139,7 @@ export class App {
         if (this.state.selection)
             applySelection(buf, this.state.selection);
         this.drawToast(buf);
-        this.renderer.render(buf);
+        this.renderer.render(buf, this.top?.alwaysRepaintRows() ?? []);
     }
     drawToast(buf) {
         if (!this.toast)
@@ -157,6 +167,14 @@ export class App {
         this.state.cursorOn = true;
     }
     handleEvent(ev) {
+        if (ev.type === "paste") {
+            // Pasted text arrives with its newlines already flattened to spaces, so
+            // it is inserted into the input instead of being submitted.
+            this.resetMouse();
+            this.wakeCursor();
+            this.top?.onPaste(ev.text);
+            return;
+        }
         if (ev.type === "key") {
             const k = ev.key;
             // Any keystroke ends a pending mouse gesture (in case a release was lost).
@@ -194,6 +212,28 @@ export class App {
     handleMouse(ev) {
         if (ev.type === "click") {
             this.wakeCursor();
+            // A left-press on the scrollbar starts a thumb drag rather than a text
+            // selection or a click on the screen behind it.
+            if (ev.button === 0) {
+                const bar = this.top?.scrollbar();
+                if (bar && ev.x >= bar.x && ev.y >= bar.top && ev.y <= bar.bottom) {
+                    const g = scrollbarGeometry(bar.top, bar.bottom, bar.total, bar.viewport, bar.offset);
+                    let grab = ev.y - bar.top - g.thumbTop;
+                    if (grab < 0 || grab >= g.thumbH) {
+                        // Pressed the groove: centre the thumb under the pointer.
+                        grab = Math.floor(g.thumbH / 2);
+                        const thumbTop = Math.max(0, Math.min(ev.y - bar.top - grab, g.maxThumbTop));
+                        bar.scrollTo(offsetFromThumbTop(g, thumbTop));
+                    }
+                    this.barDrag = { grab };
+                    this.pressed = false;
+                    this.pressStart = null;
+                    if (this.state.selection)
+                        this.state.selection = null;
+                    this.render();
+                    return;
+                }
+            }
             this.pressed = true;
             this.pressStart = { x: ev.x, y: ev.y };
             if (this.state.selection) {
@@ -206,6 +246,24 @@ export class App {
             return;
         }
         if (ev.type === "move") {
+            // A release can be lost (the pointer left the window, the terminal did
+            // not report button-up, …). Motion with no button held means the gesture
+            // is over, so drop any stale press/drag instead of letting a bare hover
+            // keep scrolling the log or grow a phantom selection.
+            if (!ev.drag) {
+                this.pressed = false;
+                this.pressStart = null;
+                this.barDrag = null;
+            }
+            if (this.barDrag) {
+                const bar = this.top?.scrollbar();
+                if (bar) {
+                    const g = scrollbarGeometry(bar.top, bar.bottom, bar.total, bar.viewport, bar.offset);
+                    const thumbTop = Math.max(0, Math.min(ev.y - bar.top - this.barDrag.grab, g.maxThumbTop));
+                    bar.scrollTo(offsetFromThumbTop(g, thumbTop));
+                }
+                return;
+            }
             if (this.pressed && this.pressStart) {
                 const s = this.pressStart;
                 if (ev.x !== s.x || ev.y !== s.y) {
@@ -223,6 +281,7 @@ export class App {
             const sel = this.state.selection;
             this.pressed = false;
             this.pressStart = null;
+            this.barDrag = null;
             if (sel) {
                 if (this.lastBuffer) {
                     const text = selectionText(this.lastBuffer, sel);
@@ -245,6 +304,7 @@ export class App {
     resetMouse() {
         this.pressed = false;
         this.pressStart = null;
+        this.barDrag = null;
     }
     copySelection() {
         const sel = this.state.selection;
@@ -328,6 +388,10 @@ export class App {
         this.running = true;
         if (this.sizeTimer)
             clearInterval(this.sizeTimer);
+        if (this.repaintTimer) {
+            clearInterval(this.repaintTimer);
+            this.repaintTimer = null;
+        }
         if (this.blinkTimer) {
             clearInterval(this.blinkTimer);
             this.blinkTimer = null;

package/dist/colors.js

@@ -12,5 +12,7 @@ export const C = {
     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
+    scrollTrack: [45, 58, 62], // dim groove behind the scrollbar thumb
+    scrollThumb: [130, 142, 190], // draggable scrollbar thumb
 };
 export const EMPTY_STYLE = {};

package/dist/compact.js

@@ -0,0 +1,68 @@
+/**
+ * Helpers for compressing a long conversation so it fits back inside the
+ * model's context window.
+ *
+ * Everything here is pure: deciding *what* to summarise, and flattening that
+ * part into a plain transcript. The actual "ask the model to summarise" step
+ * lives in `LLMClient.summarize`, so this module stays trivially unit-testable.
+ */
+/** How many trailing messages are always kept verbatim when compressing. */
+export const COMPACT_KEEP = 4;
+/** Per-message character budget fed to the summariser, to bound its own input. */
+export const COMPACT_MAX_CHARS_PER_MESSAGE = 4000;
+/**
+ * Split `messages` into an older prefix to summarise and a recent suffix to
+ * keep. The kept suffix never begins with a bare tool result — that would be an
+ * orphan without the assistant tool-call that produced it — so such messages
+ * are folded into the prefix instead.
+ *
+ * Returns null when there is nothing worth compressing (the conversation is
+ * already short enough).
+ */
+export function planCompaction(messages, keep = COMPACT_KEEP) {
+    if (keep < 1)
+        keep = 1;
+    const head = [];
+    const tail = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (tail.length < keep)
+            tail.unshift(messages[i]);
+        else
+            head.push(messages[i]);
+    }
+    head.reverse();
+    // Never open the kept suffix with an orphan tool result.
+    while (tail.length > 1 && tail[0].role === "tool") {
+        head.push(tail.shift());
+    }
+    if (head.length === 0 || tail.length === 0)
+        return null;
+    return { head, tail };
+}
+/**
+ * Flatten messages into a plain transcript for the summariser, clipping each
+ * message so a single huge tool result cannot dominate the summary request.
+ */
+export function transcriptFor(messages, maxCharsPerMessage = COMPACT_MAX_CHARS_PER_MESSAGE) {
+    const clip = (s) => {
+        const t = s.replace(/\r\n?/g, "\n").trim();
+        return t.length > maxCharsPerMessage ? t.slice(0, maxCharsPerMessage) + "\n…[truncated]" : t;
+    };
+    const parts = [];
+    for (const m of messages) {
+        const body = clip(m.content ?? "");
+        if (m.role === "tool") {
+            parts.push(`TOOL ${m.name ?? ""} RESULT:\n${body}`);
+        }
+        else if (m.role === "assistant") {
+            parts.push(`ASSISTANT:\n${body}`);
+        }
+        else if (m.role === "user") {
+            parts.push(`USER:\n${body}`);
+        }
+        else {
+            parts.push(`${m.role.toUpperCase()}:\n${body}`);
+        }
+    }
+    return parts.join("\n\n");
+}

package/dist/config.js

@@ -36,6 +36,9 @@ export const DEFAULT_CONFIG = {
     language: "en",
     theme: "default",
     default_intensity: "High",
+    // Estimated prompt tokens above which the conversation is auto-compressed.
+    // 0 disables auto-compression.
+    context_compress_threshold: 32000,
 };
 export const INTENSITY_LEVELS = ["Low", "Medium", "High", "Max", "Ultra"];
 export const INTENSITY_PARAMS = {
@@ -45,6 +48,18 @@ export const INTENSITY_PARAMS = {
     Max: { temperature: 1.0, top_p: 1.0 },
     Ultra: { temperature: 1.5, top_p: 1.0 },
 };
+/**
+ * Selectable auto-compression thresholds, in estimated prompt tokens.
+ * `0` turns the feature off. Rendered as-is in the settings screen.
+ */
+export const COMPRESS_THRESHOLD_OPTIONS = [
+    { value: 0, label: "Off" },
+    { value: 8000, label: "8K tokens" },
+    { value: 16000, label: "16K tokens" },
+    { value: 32000, label: "32K tokens" },
+    { value: 64000, label: "64K tokens" },
+    { value: 128000, label: "128K tokens" },
+];
 export function ensureDirs() {
     fs.mkdirSync(NEUTRINO_DIR, { recursive: true });
     fs.mkdirSync(SESSION_DIR, { recursive: true });