nou-cli 0.5.11 → 0.5.13

package/dist/src/ui/line-update-shim.js

@@ -0,0 +1,55 @@
+/**
+ * Stands in for Ink's line-update (see fast-width.ts), which works out how much of a changed line can stay
+ * on screen. For any line with a character outside plain ASCII (every line with a box border, so nearly all
+ * of Nou's) it splits both versions into graphemes, every frame. Lines made only of one-column characters
+ * that never combine (fast-width's NARROW) have one grapheme per character, so this answers those directly,
+ * with exactly what Ink would, and hands every other line to Ink's own code.
+ */
+import { NARROW } from "./fast-width.js";
+// eslint-disable-next-line no-control-regex -- SGR starts with ESC
+const SGR = /\u001b\[[\d;]*m/gu;
+/** Ink's lineUpdate with the fast path in front. Same answers; exported for tests. */
+export function fastLineUpdate(real) {
+    return (previous, next, columns) => {
+        if (columns === undefined || Number.isNaN(columns) || columns < 1)
+            return real(previous, next, columns);
+        let common = 0;
+        while (common < previous.length && common < next.length && previous[common] === next[common])
+            common++;
+        if (common === 0)
+            return real(previous, next, columns);
+        const previousText = previous.replaceAll(SGR, "");
+        const nextText = next.replaceAll(SGR, "");
+        // Controls are excluded by NARROW too (it starts at the space).
+        if (!NARROW.test(previousText) || !NARROW.test(nextText))
+            return real(previous, next, columns);
+        const codes = [...next.matchAll(SGR)];
+        let textLimit = common;
+        for (const match of codes) {
+            if (match.index >= common)
+                break;
+            textLimit -= Math.min(match[0].length, common - match.index);
+        }
+        // One character a grapheme and a column, so this is the grapheme walk Ink does.
+        let textLength = 0;
+        while (textLength < textLimit && previousText[textLength] === nextText[textLength])
+            textLength++;
+        const column = textLength;
+        const full = `\u001b[1G\u001b[K${next}`;
+        if (column === 0 || column >= columns || previousText.length > columns || nextText.length > columns)
+            return full;
+        let offset = textLength;
+        let styles = "";
+        for (const match of codes) {
+            if (match.index > offset || match.index + match[0].length > common)
+                break;
+            offset += match[0].length;
+            styles += match[0];
+        }
+        const partial = `\u001b[${column + 1}G\u001b[K${styles}${next.slice(offset)}`;
+        return partial.length < full.length ? partial : full;
+    };
+}
+const of = new URL(import.meta.url).searchParams.get("of");
+const real = of ? (await import(of)).default : null;
+export default real ? fastLineUpdate(real) : null;

package/dist/src/ui/scroll.js

@@ -1,6 +1,33 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+import { useState, useSyncExternalStore } from "react";
 import { C } from "./theme.js";
+const wheels = new Map();
+const wheelListeners = new Map();
+/**
+ * Hands a pane its wheel total. Only that pane draws again, not the whole app: scrolling is the most
+ * frequent thing there is, and every pane redrawing for it was most of its cost.
+ */
+export function sendWheel(pane, lines, columns) {
+    wheels.set(pane, { lines, columns, nonce: (wheels.get(pane)?.nonce ?? 0) + 1 });
+    for (const fn of wheelListeners.get(pane) ?? [])
+        fn();
+}
+/** The latest wheel total for `pane` (see sendWheel) since this pane appeared; null before that. */
+export function usePaneWheel(pane) {
+    // A pane that opens later (the editor, say) mustn't replay a wheel meant for what was there before.
+    const [since] = useState(() => (pane ? wheels.get(pane)?.nonce ?? 0 : 0));
+    const wheel = useSyncExternalStore((fn) => {
+        if (!pane)
+            return () => { };
+        let set = wheelListeners.get(pane);
+        if (!set)
+            wheelListeners.set(pane, (set = new Set()));
+        set.add(fn);
+        return () => set.delete(fn);
+    }, () => (pane ? wheels.get(pane) ?? null : null));
+    return wheel && wheel.nonce > since ? wheel : null;
+}
 /** Lines a single wheel notch moves. */
 export const WHEEL_STEP = 3;
 /** Where to scroll to for a scrollbar click at `fraction` of the track. */

package/dist/src/ui/text.js

@@ -274,7 +274,7 @@ export function renderMarkdown(text, width, isFile) {
         const item = raw.match(/^(\s*)([-*+]|\d+[.)])\s+(\[[ xX]\]\s+)?(.*)/);
         if (item) {
             const depth = Math.floor(item[1].length / 2) * 2;
-            const task = item[3] ? (/x/i.test(item[3]) ? "☑ " : "☐ ") : "";
+            const task = item[3] ? (/x/i.test(item[3]) ? "■ " : "□ ") : "";
             const bullet = `${" ".repeat(depth)}${/\d/.test(item[2]) ? item[2] : "•"} ${task}`;
             for (const line of wrapSpans([{ text: bullet }, ...spansOf(item[4])], width, bullet.length))
                 out.push({ kind: "text", spans: line });

package/dist/src/ui/theme.js

@@ -79,7 +79,7 @@ const ICONS = Object.fromEntries(Object.entries(iconColors()).map(([ext, color])
 export function fileIcon(file) {
     const base = path.basename(file).toLowerCase();
     if (base.startsWith(".env"))
-        return { icon: "⚿", color: C.yellow };
+        return { icon: "⌁", color: C.yellow };
     if (base.startsWith(".git"))
         return { icon: "◌", color: C.orange };
     if (base === "package.json")

package/dist/src/workspaces/client.js

@@ -51,6 +51,8 @@ export function connectToHost(on) {
             on.redraw();
         else if (msg.type === "error")
             on.error(msg.text);
+        else if (msg.type === "quit")
+            on.quit();
     }));
     s.on("error", () => { });
     s.on("close", () => (socket = null));

package/dist/src/workspaces/host.js

@@ -68,6 +68,17 @@ export async function runHost(folders, firstArgs, command = [process.execPath, p
                 if (to && to !== active)
                     activate(to);
             }
+            else if (msg.type === "close") {
+                const w = workspaces[msg.index];
+                if (!w)
+                    return;
+                // Asked to quit, it saves and exits as when you quit it; one that doesn't is stopped.
+                if (w.socket)
+                    send(w, { type: "quit" });
+                else
+                    w.pty.kill();
+                setTimeout(() => workspaces.includes(w) && w.pty.kill(), 3000);
+            }
             else if (msg.type === "new") {
                 const folder = workspaceFolder(msg.folder, from.folder);
                 if (!folder)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nou-cli",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "description": "Nou: an IDE-style AI coding assistant for your terminal. Local (Ollama, LM Studio) and cloud (Claude, OpenAI, Gemini...) models, live diffs, git-aware, built-in editor.",
   "type": "module",
   "bin": {