@xingjisoft/neutrino 0.1.0 → 0.1.1

package/dist/screens/settings.js

@@ -2,9 +2,11 @@ import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { INTENSITY_LEVELS, MODEL_FILE, loadConfig, saveConfig } from "../config.js";
 import { drawHeader } from "../header.js";
-import { centerVertically } from "../ui.js";
+import { centerVertically, drawHint } from "../ui.js";
 export class SettingsScreen extends Screen {
     intensityIdx = 2;
+    lastHoverX = -1;
+    lastHoverY = -1;
     onActivate() {
         const config = loadConfig();
         const current = String(config.default_intensity ?? "High");
@@ -28,6 +30,66 @@ export class SettingsScreen extends Screen {
             this.app.popScreen();
         }
     }
+    onMouse(ev) {
+        const layout = this.layout();
+        if (!layout)
+            return;
+        if (ev.type === "move") {
+            if (ev.x === this.lastHoverX && ev.y === this.lastHoverY)
+                return;
+            this.lastHoverX = ev.x;
+            this.lastHoverY = ev.y;
+            for (let i = 0; i < layout.optionYs.length; i++) {
+                if (ev.y === layout.optionYs[i] && i !== this.intensityIdx) {
+                    this.intensityIdx = i;
+                    this.app.render();
+                    return;
+                }
+            }
+            return;
+        }
+        if (ev.type === "wheel") {
+            this.intensityIdx =
+                (this.intensityIdx + (ev.dir === -1 ? -1 : 1) + INTENSITY_LEVELS.length) % INTENSITY_LEVELS.length;
+            this.app.render();
+            return;
+        }
+        if (ev.type === "click") {
+            if (ev.button === 2) {
+                this.save();
+                this.app.popScreen();
+                return;
+            }
+            for (let i = 0; i < layout.optionYs.length; i++) {
+                if (ev.y === layout.optionYs[i]) {
+                    this.intensityIdx = i;
+                    this.save();
+                    this.app.render();
+                    return;
+                }
+            }
+            if (ev.y === layout.hintY) {
+                this.save();
+                this.app.popScreen();
+            }
+        }
+    }
+    layout() {
+        const h = this.app.height;
+        const lines = [
+            "Settings",
+            "",
+            `Model: ${this.app.state.selectedProvider}/${this.app.state.selectedModelName}`,
+            `Default intensity:`,
+        ];
+        const total = lines.length + INTENSITY_LEVELS.length + 2;
+        const top = centerVertically(h, total);
+        const optionYs = INTENSITY_LEVELS.map((_, i) => top + 4 + i);
+        const hintY = top + 4 + INTENSITY_LEVELS.length + 2;
+        if (hintY > h - 1)
+            return null;
+        return { optionYs, hintY };
+    }
     save() {
         const config = loadConfig();
         config.default_intensity = INTENSITY_LEVELS[this.intensityIdx];
@@ -64,7 +126,7 @@ export class SettingsScreen extends Screen {
         buf.centerText(y, `model.json: ${MODEL_FILE}`, { fg: C.dim });
         y += 1;
         if (y < h) {
-            buf.centerText(y, "↑/↓ change  ·  Enter apply  ·  Esc back", { fg: C.dim });
+            drawHint(buf, y, "↑/↓ change  ·  Enter apply  ·  click to choose  ·  right-click back  ·  Esc back");
         }
     }
 }

package/dist/screens/start.js

@@ -2,14 +2,19 @@ import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
 import { loadLogo } from "../config.js";
 import { drawHeader } from "../header.js";
-import { centerVertically, drawInputBox, drawTabButton } from "../ui.js";
+import { centerVertically, computeInputWindow, cursorFromColumn, drawHint, drawInputBox, drawTabButton, inRect, } from "../ui.js";
 const TABS = ["Model", "History", "Settings"];
 const LOGO = loadLogo();
 const FOCUS_COUNT = TABS.length + 1; // input box + 3 tabs
+const INPUT_H = 3;
+const TAB_H = 3;
 export class StartScreen extends Screen {
     inputValue = "";
     cursor = 0;
     focusIdx = 0; // 0 = input box, 1..3 = tabs
+    hoverIdx = -1; // -1 = nothing, 0 = input box, 1..3 = tabs
+    lastHoverX = -1;
+    lastHoverY = -1;
     onKey(key) {
         if (key.name === "left" || key.name === "up") {
             this.move(-1);
@@ -72,8 +77,92 @@ export class StartScreen extends Screen {
             this.app.render();
         }
     }
+    onMouse(ev) {
+        if (ev.type === "move") {
+            // avoid redundant work when the pointer hasn't moved to a new cell
+            if (ev.x === this.lastHoverX && ev.y === this.lastHoverY)
+                return;
+            this.lastHoverX = ev.x;
+            this.lastHoverY = ev.y;
+            const layout = this.layout();
+            let hover = -1;
+            if (layout && inRect(ev.x, ev.y, { x: layout.inputX, y: layout.inputY, w: layout.inputW, h: INPUT_H })) {
+                hover = 0;
+            }
+            else if (layout && ev.y >= layout.tabY && ev.y < layout.tabY + TAB_H) {
+                for (let i = 0; i < layout.tabs.length; i++) {
+                    if (inRect(ev.x, ev.y, { x: layout.tabs[i].x, y: layout.tabY, w: layout.tabs[i].w, h: TAB_H })) {
+                        hover = i + 1;
+                        break;
+                    }
+                }
+            }
+            if (hover !== this.hoverIdx) {
+                this.hoverIdx = hover;
+                this.app.render();
+            }
+            return;
+        }
+        if (ev.type === "click") {
+            const layout = this.layout();
+            if (!layout)
+                return;
+            if (ev.button === 2)
+                return; // right click: no-op on start screen
+            if (ev.y === 0) {
+                this.app.openModelConfig();
+                return;
+            }
+            if (inRect(ev.x, ev.y, { x: layout.inputX, y: layout.inputY, w: layout.inputW, h: INPUT_H })) {
+                this.focusIdx = 0;
+                if (ev.y === layout.inputY + 1 && ev.x >= layout.inputX + 2) {
+                    const innerW = layout.inputW - 4;
+                    const col = Math.min(innerW - 1, ev.x - (layout.inputX + 2));
+                    const win = computeInputWindow(this.inputValue, this.cursor, innerW);
+                    this.cursor = cursorFromColumn(this.inputValue, col, win);
+                }
+                this.app.render();
+                return;
+            }
+            if (ev.y >= layout.tabY && ev.y < layout.tabY + TAB_H) {
+                for (let i = 0; i < layout.tabs.length; i++) {
+                    if (inRect(ev.x, ev.y, { x: layout.tabs[i].x, y: layout.tabY, w: layout.tabs[i].w, h: TAB_H })) {
+                        this.focusIdx = i + 1;
+                        this.hoverIdx = i + 1;
+                        this.enterTab();
+                        return;
+                    }
+                }
+            }
+            return;
+        }
+    }
+    layout() {
+        const w = this.app.width;
+        const h = this.app.height;
+        const inputW = Math.min(78, w - 4);
+        const inputX = Math.floor((w - inputW) / 2);
+        const logoLines = LOGO.replace(/\n+$/, "").split("\n");
+        const gap = 1;
+        const contentH = logoLines.length + 1 + INPUT_H + gap + TAB_H;
+        const inputY = centerVertically(h, contentH) + logoLines.length + 1;
+        const tabY = inputY + INPUT_H + gap;
+        const tabGap = 2;
+        const tabInner = inputW - tabGap * (TABS.length - 1);
+        const baseW = Math.floor(tabInner / TABS.length);
+        const extra = tabInner - baseW * TABS.length;
+        const tabs = [];
+        let tx = inputX;
+        for (let i = 0; i < TABS.length; i++) {
+            const tw = baseW + (i < extra ? 1 : 0);
+            tabs.push({ x: tx, w: tw });
+            tx += tw + tabGap;
+        }
+        return { inputX, inputY, inputW, tabY, tabs };
+    }
     move(delta) {
         this.focusIdx = (this.focusIdx + delta + FOCUS_COUNT) % FOCUS_COUNT;
+        this.hoverIdx = -1;
         this.app.render();
     }
     enterTab() {
@@ -94,9 +183,7 @@ export class StartScreen extends Screen {
         const logoMax = logoLines.reduce((m, l) => Math.max(m, l.length), 0);
         const logoX = Math.max(0, Math.floor((w - logoMax) / 2));
         const gap = 1;
-        const inputBoxH = 3;
-        const tabH = 3;
-        const contentH = logoLines.length + 1 + inputBoxH + gap + tabH;
+        const contentH = logoLines.length + 1 + INPUT_H + gap + TAB_H;
         const top = centerVertically(h, contentH);
         let y = top;
         for (const line of logoLines) {
@@ -108,7 +195,7 @@ export class StartScreen extends Screen {
             active: this.focusIdx === 0,
             placeholder: "Type a message to start a new chat...",
         });
-        y += inputBoxH + gap;
+        y += INPUT_H + gap;
         const tabGap = 2;
         const tabInner = inputW - tabGap * (TABS.length - 1);
         const baseW = Math.floor(tabInner / TABS.length);
@@ -116,14 +203,13 @@ export class StartScreen extends Screen {
         let tx = inputX;
         for (let i = 0; i < TABS.length; i++) {
             const tw = baseW + (i < extra ? 1 : 0);
-            drawTabButton(buf, tx, y, tw, TABS[i], i === this.focusIdx - 1);
+            const selected = i === this.focusIdx - 1 || i === this.hoverIdx - 1;
+            drawTabButton(buf, tx, y, tw, TABS[i], selected);
             tx += tw + tabGap;
         }
-        const hintY = y + tabH + 1;
+        const hintY = y + TAB_H + 1;
         if (hintY < h) {
-            buf.centerText(hintY, "←/→ / ↑/↓ switch  ·  Enter confirm  ·  Ctrl+E model  ·  Ctrl+Q quit", {
-                fg: C.dim,
-            });
+            drawHint(buf, hintY, "←/→ / ↑/↓ switch  ·  Enter confirm  ·  click to choose  ·  Ctrl+E model  ·  Ctrl+Q quit");
         }
     }
 }

package/dist/state.js

@@ -7,5 +7,6 @@ export function defaultState() {
         selectedModelStreaming: true,
         selectedIntensity: "High",
         isThinking: false,
+        blinkOn: false,
     };
 }

package/dist/terminal/input.js

@@ -155,6 +155,16 @@ export class InputReader {
                 this.emitKey("end", false, false, false, "\x1b[4~");
         }
     }
+    /**
+     * Parse SGR (extended) mouse sequences: ESC [ < b ; x ; y M/m
+     *
+     * Button codes (SGR mode, any-event tracking ?1003):
+     *   0/1/2  left/middle/right press
+     *   3      release (ignored)
+     *   32     motion with no buttons held (hover)
+     *   35     motion with left button held (drag)
+     *   64/65  wheel up / wheel down
+     */
     handleMouse(s, final) {
         const parts = s.slice(1).split(";");
         if (parts.length < 3)
@@ -170,6 +180,10 @@ export class InputReader {
         else if (b === 65) {
             this.emitMouse({ type: "wheel", dir: 1, x, y });
         }
+        else if (final === "M" && (b === 32 || b === 35)) {
+            // hover / drag motion
+            this.emitMouse({ type: "move", x, y });
+        }
         else if (final === "M" && (b === 0 || b === 1 || b === 2)) {
             this.emitMouse({ type: "click", x, y, button: b });
         }

package/dist/terminal/renderer.js

@@ -11,6 +11,8 @@ function styleKey(st) {
         k += "d";
     if (st.inverse)
         k += "i";
+    if (st.italic)
+        k += "I";
     return k;
 }
 function sgr(st) {
@@ -19,6 +21,8 @@ function sgr(st) {
         codes.push("1");
     if (st.dim)
         codes.push("2");
+    if (st.italic)
+        codes.push("3");
     if (st.inverse)
         codes.push("7");
     if (st.fg)
@@ -45,10 +49,10 @@ export class Renderer {
     init() {
         this.write("\x1b[?1049h"); // alternate screen
         this.write("\x1b[?25l"); // hide cursor
-        this.write("\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?1015h"); // mouse tracking
+        this.write("\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h\x1b[?1015h"); // mouse tracking (incl. any-event for hover)
     }
     dispose() {
-        this.write("\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?1015l");
+        this.write("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l");
         this.write("\x1b[?25h");
         this.write("\x1b[?1049l");
         this.write("\x1b[0m");

package/dist/ui.js

@@ -70,25 +70,12 @@ export function wrapText(text, width) {
     }
     return lines;
 }
-export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {
-    const active = opts.active ?? true;
-    const dimmed = opts.dimmed ?? false;
-    const placeholder = opts.placeholder ?? "";
-    const h = 3;
-    const innerX = x + 2;
-    const innerW = w - 4;
-    const innerY = y + 1;
-    if (active)
-        buf.fillRect(x, y, w, h, { bg: C.highlightBg });
-    const textStyle = dimmed
-        ? { fg: C.dim, bg: C.highlightBg }
-        : active
-            ? { fg: C.white, bg: C.highlightBg }
-            : { fg: C.dim };
-    if (value.length === 0) {
-        buf.writeText(innerX, innerY, truncateByWidth(placeholder, innerW), textStylePlaceholder(active));
-        return;
-    }
+/**
+ * Compute which part of the input value is visible inside the box, given the
+ * cursor position. Shared by `drawInputBox` and mouse click handling so the
+ * rendered text and click-to-position-cursor always agree.
+ */
+export function computeInputWindow(value, cursorPos, innerW) {
     const chars = Array.from(value);
     const widths = chars.map((ch) => wcwidth(ch.codePointAt(0) ?? 0));
     const cursorCp = Math.min(Array.from(value.slice(0, cursorPos)).length, chars.length);
@@ -113,22 +100,80 @@ export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {
     let prefixW = 0;
     for (let i = 0; i < startCp; i++)
         prefixW += widths[i];
-    let endCp = chars.length;
+    let visibleCount = 0;
     let acc = 0;
     for (let i = startCp; i < chars.length; i++) {
-        if (acc + widths[i] > innerW) {
-            endCp = i;
+        if (acc + widths[i] > innerW)
             break;
-        }
         acc += widths[i];
+        visibleCount++;
     }
-    const visible = chars.slice(startCp, endCp).join("");
+    return { startCp, prefixW, visibleCount };
+}
+/**
+ * Map a column inside the input box (0-based, relative to the inner area) to a
+ * cursor index in the full value.
+ */
+export function cursorFromColumn(value, col, win) {
+    const chars = Array.from(value);
+    if (col <= 0)
+        return win.startCp;
+    let acc = 0;
+    let i = win.startCp;
+    while (i < chars.length) {
+        const w = wcwidth(chars[i].codePointAt(0) ?? 0);
+        if (col < acc + w)
+            return i;
+        acc += w;
+        i++;
+    }
+    return i;
+}
+export function inRect(px, py, r) {
+    return px >= r.x && px < r.x + r.w && py >= r.y && py < r.y + r.h;
+}
+export function drawHint(buf, y, text) {
+    const max = buf.width;
+    const t = displayWidth(text) <= max ? text : truncateByWidth(text, max - 1) + "…";
+    buf.centerText(y, t, { fg: C.dim });
+}
+export function drawInputBox(buf, x, y, w, value, cursorPos, opts = {}) {
+    const active = opts.active ?? true;
+    const dimmed = opts.dimmed ?? false;
+    const placeholder = opts.placeholder ?? "";
+    const h = 3;
+    const innerX = x + 2;
+    const innerW = w - 4;
+    const innerY = y + 1;
+    if (active)
+        buf.fillRect(x, y, w, h, { bg: C.highlightBg });
+    const textStyle = dimmed
+        ? { fg: C.dim, bg: C.highlightBg }
+        : active
+            ? { fg: C.white, bg: C.highlightBg }
+            : { fg: C.dim };
+    if (value.length === 0) {
+        buf.writeText(innerX, innerY, truncateByWidth(placeholder, innerW), textStylePlaceholder(active));
+        return;
+    }
+    const win = computeInputWindow(value, cursorPos, innerW);
+    const chars = Array.from(value);
+    const visible = chars.slice(win.startCp, win.startCp + win.visibleCount).join("");
     buf.writeText(innerX, innerY, visible, textStyle);
-    const cursorScreenCol = cursorCol - prefixW;
+    const cursorScreenCol = cursorColAt(value, cursorPos, win);
     if (active && cursorScreenCol >= 0 && cursorScreenCol < innerW) {
         buf.set(innerX + cursorScreenCol, innerY, " ", { fg: C.black, bg: C.accent });
     }
 }
+function cursorColAt(value, cursorPos, win) {
+    const chars = Array.from(value);
+    const cursorCp = Math.min(Array.from(value.slice(0, cursorPos)).length, chars.length);
+    let col = win.prefixW;
+    for (let i = win.startCp; i < cursorCp; i++) {
+        col += wcwidth(chars[i].codePointAt(0) ?? 0);
+    }
+    return col - win.prefixW;
+}
 function textStylePlaceholder(active) {
     return active ? { fg: C.dim, bg: C.highlightBg } : { fg: C.dim };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
   "type": "module",
   "license": "Apache-2.0",