@xingjisoft/neutrino 0.1.2 → 0.1.4

package/dist/llm/client.js

@@ -1,4 +1,138 @@
 import { INTENSITY_PARAMS } from "../config.js";
+/** How many extra times a request is retried when the connection drops. */
+const NETWORK_RETRIES = 2;
+/** Give up if the server has not started to respond within this window. */
+const CONNECT_TIMEOUT_MS = 120_000;
+/**
+ * System prompt used when compressing a long conversation. The instruction
+ * spells out exactly what must survive compression (goals, decisions, files,
+ * commands) so the summary stays useful for continuing the work.
+ */
+const SUMMARY_SYSTEM_PROMPT = "You compress the conversation history of an AI coding assistant so it fits in a smaller context window. " +
+    "Write a dense, factual summary in the same language as the conversation. Preserve: the user's goals and " +
+    "constraints, decisions that were made, files created or modified (with their paths), commands that were run " +
+    "and their meaningful results, and any unresolved problems or next steps. Drop pleasantries, restated " +
+    "instructions and redundant tool output. Output only the summary, with no preface.";
+/**
+ * Terse transport messages that all mean "the connection dropped mid-flight".
+ * The \b keeps "terminated" from matching unrelated text such as
+ * "Unterminated string constant".
+ */
+const DROP_HINT_RE = /\bterminated\b|other side closed|socket hang up|premature close/i;
+/**
+ * Flatten an error and its `cause` chain into one readable line.
+ *
+ * `fetch` reports almost every transport problem as a bare
+ * `TypeError: fetch failed`; the actual reason (`ECONNRESET`, `EMFILE`,
+ * `ENOTFOUND`, `UND_ERR_…`) is tucked away in `error.cause`. Without walking
+ * that chain a failure is impossible to diagnose, so this always reports it.
+ */
+export function describeError(e) {
+    if (!(e instanceof Error))
+        return String(e);
+    const parts = [];
+    const push = (msg, code) => {
+        const text = code && !msg.includes(code) ? `${msg} (${code})` : msg;
+        if (text && !parts.includes(text))
+            parts.push(text);
+    };
+    let cur = e;
+    const seen = new Set();
+    while (cur != null && !seen.has(cur)) {
+        if (typeof cur === "string") {
+            // fetch/undici sometimes stash the real reason in a plain string
+            // (`cause: "other side closed"`), which an object-only walk would miss.
+            push(cur);
+            break;
+        }
+        if (typeof cur !== "object")
+            break;
+        seen.add(cur);
+        const err = cur;
+        const message = typeof err.message === "string" && err.message ? err.message : String(err.name ?? "Error");
+        const code = typeof err.code === "string" ? err.code : undefined;
+        push(message, code);
+        cur = err.cause;
+    }
+    const text = parts.join(": ") || e.message;
+    // A dropped mid-stream connection surfaces as a bare `TypeError: terminated`,
+    // which on its own tells the user nothing worth reading.
+    return DROP_HINT_RE.test(text) ? `${text} — the connection was closed before the response finished` : text;
+}
+/**
+ * Whether a failed request is worth retrying: a transient connection problem
+ * (reset / refused / DNS / timeout) rather than a real response from the API.
+ */
+function isRetriableNetworkError(e) {
+    const transient = new Set([
+        "ECONNRESET",
+        "ECONNREFUSED",
+        "ECONNABORTED",
+        "EPIPE",
+        "ETIMEDOUT",
+        "ENETUNREACH",
+        "ENETDOWN",
+        "EAI_AGAIN",
+        "ERR_STREAM_PREMATURE_CLOSE",
+        "UND_ERR_SOCKET",
+        "UND_ERR_CONNECT_TIMEOUT",
+    ]);
+    let cur = e;
+    const seen = new Set();
+    while (cur != null && !seen.has(cur)) {
+        if (typeof cur === "string") {
+            if (DROP_HINT_RE.test(cur))
+                return true;
+            break;
+        }
+        if (typeof cur !== "object")
+            break;
+        seen.add(cur);
+        const err = cur;
+        if (typeof err.code === "string" && transient.has(err.code))
+            return true;
+        // Our own connect timeout aborts with a plain AbortError; undici wraps a
+        // dropped socket in a SocketError.
+        if (err.name === "AbortError" || err.name === "SocketError")
+            return true;
+        // A stream that dies mid-flight: "terminated", "socket hang up", …
+        if (typeof err.message === "string" && DROP_HINT_RE.test(err.message))
+            return true;
+        cur = err.cause;
+    }
+    // Undici's generic wrapper: assume the socket dropped and try again.
+    return e instanceof Error && /fetch failed/i.test(e.message);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Issue a streaming request, retrying a few times on transient network errors
+ * and giving up with a clear error if the server never starts responding.
+ *
+ * Retries are safe here because they only ever happen *before* a response is
+ * returned; once bytes start flowing the caller is responsible for the stream.
+ */
+async function requestStream(url, init) {
+    let lastErr;
+    for (let attempt = 0; attempt <= NETWORK_RETRIES; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(new Error(`request timed out after ${CONNECT_TIMEOUT_MS / 1000}s`)), CONNECT_TIMEOUT_MS);
+        try {
+            const resp = await fetch(url, { ...init, signal: controller.signal });
+            clearTimeout(timer);
+            return resp;
+        }
+        catch (e) {
+            clearTimeout(timer);
+            lastErr = e;
+            if (attempt === NETWORK_RETRIES || !isRetriableNetworkError(e))
+                throw e;
+            await sleep(300 * (attempt + 1));
+        }
+    }
+    throw lastErr;
+}
 export class LLMClient {
     model;
     provider;
@@ -15,6 +149,25 @@ export class LLMClient {
         this.temperature = params.temperature;
         this.top_p = params.top_p;
     }
+    /**
+     * Ask the model to compress a transcript into a short summary. Returns an
+     * empty string on any failure so the caller can fall back to simply dropping
+     * the old messages. Uses a throw-away request (no tools) via the normal
+     * streaming path, so provider differences are handled for free.
+     */
+    async summarize(transcript) {
+        const messages = [
+            { role: "system", content: SUMMARY_SYSTEM_PROMPT },
+            { role: "user", content: transcript },
+        ];
+        let out = "";
+        for await (const chunk of this.streamTurn(messages))
+            out += chunk;
+        const text = out.trim();
+        if (!text || text.startsWith("[Error"))
+            return "";
+        return text;
+    }
     async *streamTurn(messages, tools) {
         this.toolCalls = [];
         this.usage = null;
@@ -26,10 +179,38 @@ export class LLMClient {
             yield* this.streamOpenAI(messages, tools);
         }
         catch (e) {
-            yield `\n[Error: ${e instanceof Error ? e.message : String(e)}]`;
+            yield `\n[Error: ${describeError(e)}]`;
         }
     }
+    /**
+     * Drive one request, retrying if the stream dies before it produced anything.
+     *
+     * A response can be cut off on the very first read — "terminated" when a
+     * proxy or the server closes the connection mid-flight. Nothing has reached
+     * the user yet, so re-issuing the request is invisible (and cannot duplicate
+     * text). Once a token has been emitted a retry is unsafe, so the error is
+     * surfaced instead.
+     */
     async *streamOpenAI(messages, tools) {
+        for (let attempt = 0;; attempt++) {
+            this.toolCalls = [];
+            let produced = false;
+            try {
+                for await (const token of this.openAIAttempt(messages, tools)) {
+                    produced = true;
+                    yield token;
+                }
+                return;
+            }
+            catch (e) {
+                if (produced || attempt >= NETWORK_RETRIES || !isRetriableNetworkError(e))
+                    throw e;
+                await sleep(400 * (attempt + 1));
+            }
+        }
+    }
+    /** A single streaming attempt; see `streamOpenAI` for the retry policy. */
+    async *openAIAttempt(messages, tools) {
         const url = this.model.url.replace(/\/+$/, "") + "/chat/completions";
         const headers = {
             "Content-Type": "application/json",
@@ -45,7 +226,7 @@ export class LLMClient {
         };
         if (tools && tools.length)
             payload.tools = tools;
-        const resp = await fetch(url, {
+        const resp = await requestStream(url, {
             method: "POST",
             headers,
             body: JSON.stringify(payload),
@@ -64,66 +245,100 @@ export class LLMClient {
         const decoder = new TextDecoder();
         let buf = "";
         let stopped = false;
-        while (!stopped) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buf += decoder.decode(value, { stream: true });
-            let idx;
-            while ((idx = buf.indexOf("\n")) >= 0) {
-                const raw = buf.slice(0, idx).replace(/\r$/, "");
-                buf = buf.slice(idx + 1);
-                const line = raw.trim();
-                if (!line)
-                    continue;
-                if (!line.startsWith("data:"))
-                    continue;
-                const data = line.slice(5).trim();
-                if (data === "[DONE]") {
-                    stopped = true;
+        try {
+            while (!stopped) {
+                const { done, value } = await reader.read();
+                if (done)
                     break;
-                }
-                let chunk;
-                try {
-                    chunk = JSON.parse(data);
-                }
-                catch {
-                    continue;
-                }
-                const usage = chunk.usage;
-                if (usage) {
-                    this.usage = {
-                        prompt: usage.prompt_tokens ?? 0,
-                        completion: usage.completion_tokens ?? 0,
-                        total: usage.total_tokens ?? (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0),
-                    };
-                }
-                const choice = chunk.choices?.[0];
-                const delta = choice?.delta ?? {};
-                const content = delta.content;
-                if (typeof content === "string" && content)
-                    yield content;
-                const toolCalls = delta.tool_calls;
-                if (toolCalls) {
-                    for (const tc of toolCalls) {
-                        const i = tc.index ?? 0;
-                        const entry = (toolCallsByIndex[i] ??= { id: "", name: "", arguments: "" });
-                        if (tc.id)
-                            entry.id = tc.id;
-                        if (tc.function?.name)
-                            entry.name = tc.function.name;
-                        if (tc.function?.arguments)
-                            entry.arguments += tc.function.arguments;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf("\n")) >= 0) {
+                    const raw = buf.slice(0, idx).replace(/\r$/, "");
+                    buf = buf.slice(idx + 1);
+                    const line = raw.trim();
+                    if (!line)
+                        continue;
+                    if (!line.startsWith("data:"))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (data === "[DONE]") {
+                        stopped = true;
+                        break;
+                    }
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const usage = chunk.usage;
+                    if (usage) {
+                        this.usage = {
+                            prompt: usage.prompt_tokens ?? 0,
+                            completion: usage.completion_tokens ?? 0,
+                            total: usage.total_tokens ?? (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0),
+                        };
+                    }
+                    const choice = chunk.choices?.[0];
+                    const delta = choice?.delta ?? {};
+                    const content = delta.content;
+                    if (typeof content === "string" && content)
+                        yield content;
+                    const toolCalls = delta.tool_calls;
+                    if (toolCalls) {
+                        for (const tc of toolCalls) {
+                            const i = tc.index ?? 0;
+                            const entry = (toolCallsByIndex[i] ??= { id: "", name: "", arguments: "" });
+                            if (tc.id)
+                                entry.id = tc.id;
+                            if (tc.function?.name)
+                                entry.name = tc.function.name;
+                            if (tc.function?.arguments)
+                                entry.arguments += tc.function.arguments;
+                        }
                     }
                 }
             }
         }
+        finally {
+            // The consumer may walk away mid-stream (pause, a newer turn taking over,
+            // or `[DONE]` arriving before the body ends). Always release the reader so
+            // the socket is torn down instead of lingering — leaked streaming bodies
+            // are what eventually make every request fail with "fetch failed".
+            try {
+                await reader.cancel();
+            }
+            catch {
+                // Already closed / errored; nothing left to release.
+            }
+        }
         this.toolCalls = Object.keys(toolCallsByIndex)
             .map((k) => Number(k))
             .sort((a, b) => a - b)
             .map((k) => toolCallsByIndex[k]);
     }
+    /** Anthropic counterpart of `streamOpenAI`, with the same retry policy. */
     async *streamAnthropic(messages) {
+        for (let attempt = 0;; attempt++) {
+            this.toolCalls = [];
+            let produced = false;
+            try {
+                for await (const token of this.anthropicAttempt(messages)) {
+                    produced = true;
+                    yield token;
+                }
+                return;
+            }
+            catch (e) {
+                if (produced || attempt >= NETWORK_RETRIES || !isRetriableNetworkError(e))
+                    throw e;
+                await sleep(400 * (attempt + 1));
+            }
+        }
+    }
+    /** A single streaming attempt; see `streamAnthropic` for the retry policy. */
+    async *anthropicAttempt(messages) {
         const url = this.model.url.replace(/\/+$/, "") + "/messages";
         const headers = {
             "Content-Type": "application/json",
@@ -147,7 +362,7 @@ export class LLMClient {
         };
         if (systemMsg)
             payload.system = systemMsg;
-        const resp = await fetch(url, {
+        const resp = await requestStream(url, {
             method: "POST",
             headers,
             body: JSON.stringify(payload),
@@ -165,41 +380,51 @@ export class LLMClient {
         const decoder = new TextDecoder();
         let buf = "";
         let stopped = false;
-        while (!stopped) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buf += decoder.decode(value, { stream: true });
-            let idx;
-            while ((idx = buf.indexOf("\n")) >= 0) {
-                const raw = buf.slice(0, idx).replace(/\r$/, "");
-                buf = buf.slice(idx + 1);
-                const line = raw.trim();
-                if (!line || !line.startsWith("data:"))
-                    continue;
-                const data = line.slice(5).trim();
-                if (data === "[DONE]") {
-                    stopped = true;
-                    break;
-                }
-                let chunk;
-                try {
-                    chunk = JSON.parse(data);
-                }
-                catch {
-                    continue;
-                }
-                const type = chunk.type;
-                if (type === "content_block_delta") {
-                    const text = chunk.delta?.text;
-                    if (text)
-                        yield text;
-                }
-                else if (type === "message_stop") {
-                    stopped = true;
+        try {
+            while (!stopped) {
+                const { done, value } = await reader.read();
+                if (done)
                     break;
+                buf += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buf.indexOf("\n")) >= 0) {
+                    const raw = buf.slice(0, idx).replace(/\r$/, "");
+                    buf = buf.slice(idx + 1);
+                    const line = raw.trim();
+                    if (!line || !line.startsWith("data:"))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (data === "[DONE]") {
+                        stopped = true;
+                        break;
+                    }
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const type = chunk.type;
+                    if (type === "content_block_delta") {
+                        const text = chunk.delta?.text;
+                        if (text)
+                            yield text;
+                    }
+                    else if (type === "message_stop") {
+                        stopped = true;
+                        break;
+                    }
                 }
             }
         }
+        finally {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                // Already closed / errored; nothing left to release.
+            }
+        }
     }
 }

package/dist/markdown.js

@@ -566,7 +566,7 @@ function renderTable(t, width) {
             for (let c = 0; c < nCols; c++) {
                 if (c === 0)
                     spans.push({ text: "│ ", style: borderStyle });
-                const cellLine = wrapped[c][li]?.spans ?? [];
+                const cellLine = wrapped[c]?.[li]?.spans ?? [];
                 for (const s of cellLine) {
                     spans.push(isHeader ? { ...s, style: { ...s.style, bold: true } } : s);
                 }

package/dist/sanitize.js

@@ -0,0 +1,61 @@
+/**
+ * Text hygiene for anything that will be drawn into the terminal Buffer.
+ *
+ * The renderer copies a cell's glyph straight into the output stream, so a cell
+ * that somehow holds a *control* character turns into 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 routinely carry such bytes, so they must be neutralised before
+ * they can reach the screen.
+ *
+ * `sanitizeText` is the *display-side* cleanup: it removes whole escape
+ * sequences (not just the ESC byte, which would leave `[31m` behind as literal
+ * text), expands tabs so every character's measured width matches what the
+ * terminal will draw, and drops any remaining control code. Newlines are kept
+ * because the wrapping/markdown layer needs them to lay text out.
+ */
+// Control Sequence Introducer: ESC [ params intermediates final
+const CSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+// Operating System Command: ESC ] … (BEL | ST)
+const OSC = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+// Device Control / Privacy Message / Application Program Command … ST
+const DCS = /\x1b[P^_X][\s\S]*?\x1b\\/g;
+// Two-character Fe/Fs/Fp escapes (ESC 7, ESC =, ESC (B, …)
+const ESC_SIMPLE = /\x1b[ -/]*[@-~]/g;
+// A lone ESC that nothing else matched.
+const ESC_LONE = /\x1b/g;
+/** Remove ANSI/VT escape sequences from `text`. */
+export function stripAnsi(text) {
+    return text
+        .replace(OSC, "")
+        .replace(DCS, "")
+        .replace(CSI, "")
+        .replace(ESC_SIMPLE, "")
+        .replace(ESC_LONE, "");
+}
+// C0 controls (except LF, which the layout engine needs) plus DEL and C1.
+const OTHER_CONTROLS = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
+/**
+ * Make `text` safe to render: normalise newlines, drop escape sequences, expand
+ * tabs and remove every other control code. The result contains no character
+ * the terminal would interpret as a command, so it can never corrupt the grid.
+ */
+export function sanitizeText(text, opts = {}) {
+    const tabWidth = opts.tabWidth ?? 4;
+    let s = text.replace(/\r\n?/g, "\n");
+    s = stripAnsi(s);
+    if (tabWidth > 0)
+        s = s.replace(/\t/g, " ".repeat(tabWidth));
+    s = s.replace(OTHER_CONTROLS, "");
+    if (opts.singleLine)
+        s = s.replace(/\s*\n\s*/g, " ");
+    return s;
+}
+/** True if `ch` is a character the terminal would treat as a control code. */
+export function isControlChar(ch) {
+    if (!ch)
+        return false;
+    const cp = ch.codePointAt(0) ?? 0;
+    return cp < 32 || (cp >= 0x7f && cp <= 0x9f);
+}

package/dist/screens/agentConversation.js

@@ -1,7 +1,7 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { drawHeader } from "../header.js";
-import { drawHint } from "../ui.js";
+import { drawHint, drawScrollbar } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
 import { ellipsize } from "../width.js";
 export class AgentConversationScreen extends Screen {
@@ -9,6 +9,7 @@ export class AgentConversationScreen extends Screen {
     messages;
     scrollTop = 0;
     followBottom = true;
+    scrollbarGeom = null;
     constructor(title, messages) {
         super();
         this.title = title;
@@ -52,6 +53,25 @@ export class AgentConversationScreen extends Screen {
             this.app.popScreen();
         }
     }
+    scrollbar() {
+        const g = this.scrollbarGeom;
+        if (!g || g.total <= g.viewport)
+            return null;
+        return {
+            x: g.x,
+            top: g.top,
+            bottom: g.bottom,
+            total: g.total,
+            viewport: g.viewport,
+            offset: this.scrollTop,
+            scrollTo: (offset) => {
+                const maxScroll = Math.max(0, g.total - g.viewport);
+                this.scrollTop = Math.max(0, Math.min(offset, maxScroll));
+                this.followBottom = this.scrollTop >= maxScroll;
+                this.app.render();
+            },
+        };
+    }
     buildLines(width) {
         const lines = [];
         for (const m of this.messages) {
@@ -85,12 +105,19 @@ export class AgentConversationScreen extends Screen {
         }
         if (this.scrollTop < 0)
             this.scrollTop = 0;
+        // Expose the bar so the app can drag it (see the scrollbar() method).
+        this.scrollbarGeom =
+            lines.length > viewH
+                ? { x: w - 1, top: logTop, bottom: logBottom, total: lines.length, viewport: viewH }
+                : null;
         for (let y = logTop; y <= logBottom; y++) {
             const li = this.scrollTop + (y - logTop);
             if (li >= lines.length)
                 break;
             drawSpans(buf, 2, y, lines[li].spans, Math.max(4, w - 4));
         }
-        drawHint(buf, h - 1, "↑/↓ scroll  ·  wheel scroll  ·  right-click back  ·  Esc back");
+        // Scrollbar on the right edge, visible only when the log overflows.
+        drawScrollbar(buf, w - 1, logTop, logBottom, lines.length, viewH, this.scrollTop);
+        drawHint(buf, h - 1, "↑/↓ scroll  ·  wheel or drag the bar  ·  right-click back  ·  Esc back");
     }
 }