nou-cli 0.5.11 → 0.5.12

package/README.md

@@ -94,7 +94,7 @@ Every change is reviewed like a code review:
 | <kbd>Tab</kbd> | switch between files, code and chat |
 | <kbd>Shift</kbd>+<kbd>Tab</kbd> | ask → auto-edit (edits apply without asking) → auto (commands too); everything stays undoable |
 | <kbd>Ctrl</kbd>+<kbd>P</kbd> | fuzzy-find a file; the files you've opened are listed first |
-| <kbd>+</kbd> / <kbd>-</kbd> (in the code) or `/zoom in` / `/zoom out` | make the code panel bigger or smaller, a step at a time: the files and chat give or take the room; <kbd>=</kbd> or `/zoom reset` puts it back (for bigger text, use your terminal's zoom, Cmd/Ctrl and +) |
+| <kbd>Ctrl</kbd>+<kbd>=</kbd> / <kbd>Ctrl</kbd>+<kbd>-</kbd> from anywhere (or <kbd>+</kbd> / <kbd>-</kbd> in the code or files) | zoom the code panel bigger or smaller, a step at a time: the files and chat give or take the room; <kbd>Ctrl</kbd>+<kbd>0</kbd> or <kbd>=</kbd> puts it back. Ctrl+= and Ctrl+- need a terminal with the kitty keyboard protocol (Ghostty, kitty, WezTerm, iTerm2). For bigger text, use your terminal's own zoom |
 | <kbd>b</kbd> | back to the previous file (press again to flip back) |
 | <kbd>Ctrl</kbd>+<kbd>F</kbd> (<kbd>Cmd</kbd>+<kbd>F</kbd> on a Mac, in terminals that report Cmd: Ghostty, kitty, WezTerm, iTerm2) | find in the open file, from any pane: matches are highlighted and counted; <kbd>Enter</kbd>/<kbd>↓</kbd> next, <kbd>↑</kbd> previous, <kbd>Esc</kbd> close |
 | 🗂️ Tabs | every file you open gets a tab over the code: click one to switch, any tab's × to close it, ‹ › for ones that don't fit · <kbd>[</kbd>/<kbd>]</kbd> previous/next · <kbd>x</kbd> or <kbd>Ctrl</kbd>+<kbd>W</kbd> close |
@@ -135,7 +135,7 @@ Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]`
 
 A small typo in a command still works when it only changes the screen (`/termnial` opens the terminal); for others Nou asks "Did you mean...?" instead of guessing.
 
-New lines in a message: <kbd>Shift</kbd>/<kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+<kbd>Enter</kbd> in terminals that report them (kitty, Ghostty, WezTerm, iTerm2 and others with the kitty keyboard protocol), or type `\` and press <kbd>Enter</kbd> in any terminal.
+New lines in a message: <kbd>Shift</kbd>/<kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+<kbd>Enter</kbd> in terminals that report them (kitty, Ghostty, WezTerm, iTerm2 and others with the kitty keyboard protocol, which Nou checks for before it starts; also xterm's modifyOtherKeys form), or type `\` and press <kbd>Enter</kbd> in any terminal.
 
 Conversations are saved per folder after each reply. `/resume` opens a picker (↑↓ and Enter, type to filter, or type its number) and `/resume 2` (or `nou --continue` for the last one, `nou --resume` for the list) picks one back up with the engine it was on: Nou's own engine restores its messages, Claude Code its session and Codex its thread; pi is handed the conversation so far. Sessions you started in Claude Code's or Codex's own CLI in this folder are listed too (marked "CLI"), and resuming one carries it on in that engine inside Nou.
 

package/dist/src/cli.js

@@ -15,7 +15,7 @@ import { App } from "./ui/App.js";
 import { installFastOutput } from "./ui/fast-output.js";
 import { RENDER_OPTIONS } from "./ui/render-options.js";
 import { setScreenClear } from "./ui/redraw.js";
-import { detectBackground } from "./ui/background.js";
+import { detectTerminal } from "./ui/background.js";
 import { setPalette } from "./ui/theme.js";
 import { runHost, workspaceFolder } from "./workspaces/host.js";
 import { pendingWorkspaces } from "./workspaces/client.js";
@@ -96,7 +96,11 @@ async function main() {
             console.error(`Not a folder, so not opened: ${missing.join(", ")}`);
         const uiTheme = loadSettings().uiTheme;
         // Every workspace uses the colors found for this terminal (they can't ask it themselves from the background).
-        process.env.NOU_PALETTE = uiTheme === "dark" || uiTheme === "light" ? uiTheme : (await detectBackground()) ?? "dark";
+        // The host asks the terminal once and tells every workspace (in the background they can't ask it).
+        const term = await detectTerminal();
+        process.env.NOU_PALETTE = uiTheme === "dark" || uiTheme === "light" ? uiTheme : term.palette ?? "dark";
+        if (term.kitty !== null)
+            process.env.NOU_KITTY = term.kitty ? "1" : "0";
         const firstArgs = args.includes("--continue") || args.includes("-c") ? ["--continue"] : [];
         process.exit(await runHost(folders.length ? folders : [process.cwd()], firstArgs));
     }
@@ -163,7 +167,13 @@ async function main() {
     // Colors that are readable on this terminal: a dark or a light set, from the setting or the background.
     const uiTheme = loadSettings().uiTheme;
     const fromHost = process.env.NOU_PALETTE;
-    setPalette(uiTheme === "dark" || uiTheme === "light" ? uiTheme : fromHost === "light" || fromHost === "dark" ? fromHost : (await detectBackground()) ?? "dark");
+    const hostKnows = fromHost === "light" || fromHost === "dark";
+    const term = hostKnows ? { palette: fromHost, kitty: process.env.NOU_KITTY ? process.env.NOU_KITTY === "1" : null } : await detectTerminal();
+    setPalette(uiTheme === "dark" || uiTheme === "light" ? uiTheme : term.palette ?? "dark");
+    // Turn the kitty keyboard protocol on when the terminal said it speaks it (Shift/Ctrl/Cmd+Enter, Cmd+F and
+    // Ctrl+= need it), off when it answered without it; ask the way Ink does only if it answered nothing.
+    if (term.kitty !== null && RENDER_OPTIONS.kittyKeyboard)
+        RENDER_OPTIONS.kittyKeyboard = { ...RENDER_OPTIONS.kittyKeyboard, mode: term.kitty ? "enabled" : "disabled" };
     await installFastOutput();
     // While Nou is on screen, anything a library prints (console.log, warnings, stderr) goes to a log file:
     // written into the terminal, it would scroll the screen out from under the mouse.

package/dist/src/ui/App.js

@@ -1484,6 +1484,12 @@ export function App({ initialModel, permContext, resume }) {
             if (focus !== "chat" && input === "o" && pendingChange)
                 return openPending();
         }
+        // Zoom the code panel from anywhere: Ctrl+= / Ctrl+- / Ctrl+0, in terminals that report Ctrl with those
+        // keys (the kitty keyboard protocol Nou asks for). Elsewhere Ctrl+- is the same key as Ctrl+/, so it's
+        // left alone; + and - in the code or the files work in every terminal.
+        if (key.ctrl && (input === "=" || input === "+" || input === "-" || input === "0") && !key.meta) {
+            return zoomCode(input === "0" ? 0 : input === "-" ? -1 : 1);
+        }
         if (key.ctrl && input === "p") {
             setQuickOpen("");
             return;
@@ -1555,7 +1561,7 @@ export function App({ initialModel, permContext, resume }) {
             setPaneWidths(null);
             updateSettings({ paneWidths: null });
         }
-        else if ((input === "+" || input === "-") && focus === "code") {
+        else if ((input === "+" || input === "-") && (focus === "code" || focus === "tree")) {
             zoomCode(input === "+" ? 1 : -1);
         }
         else if (input === "v")
@@ -2500,7 +2506,7 @@ ${snippet}
                         ? [["Enter", "open"], ["e", "edit"], ["/", "command"], ["c", "changes"], ["Ctrl+P", "find"], ["u", "undo"], ["p", "problems"], ["< >", "resize"], ["m", "select text"], ["s", "settings"]]
                         : diff
                             ? [["Esc", "close diff"], ["n/N", "next/prev change"], ...(diffMode === "session" ? [["[ ]", "prev/next file"]] : []), ["v", "cycle diff"]]
-                            : [["double-click/e", "edit"], [FIND_KEY, "find"], ["v", "diff"], ...(recent.length > 1 ? [["b", "back"]] : []), ["u", "undo"], ["/", "command"], ["p", "problems"], ["< >", "resize"], ["m", "select text"], ["s", "settings"]];
+                            : [["double-click/e", "edit"], [FIND_KEY, "find"], ["v", "diff"], ...(recent.length > 1 ? [["b", "back"]] : []), ["u", "undo"], ["/", "command"], ["p", "problems"], ["+ -", "zoom"], ["< >", "resize"], ["m", "select text"], ["s", "settings"]];
     const followChip = follow ? ` ◉ follow${followLag ? ` ·${followLag}` : ""} ` : " ○ follow ";
     const statusUsed = mode.label.length + 2 + autoMode.length + 2 + followChip.length + ` ✗ ${totals.errors} ▲ ${totals.warnings} `.length + (checking.length ? 4 + checking.join(", ").length : 0) + 2;
     const shownHints = [];
@@ -2515,7 +2521,7 @@ ${snippet}
         y: () => answer(true), n: approval ? () => answer(false) : undefined, o: openPending,
         "Shift+Tab": () => cycleAutoMode(), "/": () => typeCommand("/"), "Ctrl+P": () => setQuickOpen(""),
         Tab: () => setFocus((f) => FOCUS_ORDER[(FOCUS_ORDER.indexOf(f) + 1) % FOCUS_ORDER.length]),
-        e: startEditing, "double-click/e": startEditing, b: goBack, [FIND_KEY]: showEditor ? undefined : startFind, v: cycleDiff, u: undoLast, p: toggleProblems, m: toggleMouse,
+        "+ -": () => zoomCode(1), e: startEditing, "double-click/e": startEditing, b: goBack, [FIND_KEY]: showEditor ? undefined : startFind, v: cycleDiff, u: undoLast, p: toggleProblems, m: toggleMouse,
         s: () => setView("settings"), "/help": () => void runCommand("/help"),
         Esc: busy ? stop : diff && !showEditor ? () => setDiffMode("off") : undefined,
     };

package/dist/src/ui/Chat.js

@@ -9,7 +9,7 @@ import { copyToClipboard } from "./clipboard.js";
 import { C, SPINNER, ANIMATION_MS } from "./theme.js";
 import { useTerminalFocused } from "./focus.js";
 import { Pane } from "./Pane.js";
-import { matchCommands } from "./commands.js";
+import { SLASH_COMMANDS, matchCommands } from "./commands.js";
 import { Scrollbar, topFor } from "./scroll.js";
 /**
  * What the agent did between replies (files read, commands run...) folds into one line, like Claude's
@@ -203,6 +203,14 @@ export const Chat = memo(function Chat({ width, height, focused, entries, stream
     const menuOpen = focused && !approval && input.startsWith("/") && !input.includes(" ") && !input.includes("\n");
     const matches = useMemo(() => (menuOpen ? matchCommands(input, extraCommands) : []), [menuOpen, input, extraCommands]);
     const showMenu = matches.length > 0;
+    // A known command typed at the start of the input ("/zoom in") is drawn in the command color.
+    const commandLength = useMemo(() => {
+        const name = /^\/(\S+)/.exec(input)?.[1];
+        if (!name)
+            return 0;
+        const known = SLASH_COMMANDS.some((c) => c.name === name) || !!extraCommands?.some((c) => c.name === name);
+        return known ? name.length + 1 : 0;
+    }, [input, extraCommands]);
     useEffect(() => onMenu?.(showMenu), [showMenu]);
     const menuRows = Math.min(matches.length, Math.max(1, Math.min(7, height - 12)));
     const menuStart = Math.max(0, Math.min(menuRow - menuRows + 1, matches.length - menuRows));
@@ -408,6 +416,11 @@ export const Chat = memo(function Chat({ width, height, focused, entries, stream
                     }) })] })) })), [lines, firstShown, visible.length, selection, inner, empty]);
     return (_jsxs(Pane, { title: title, width: width, height: height, focused: focused, children: [_jsxs(Box, { flexDirection: "row", height: rows, children: [_jsx(Box, { flexDirection: "column", width: inner, flexShrink: 0, children: messages }), _jsx(Scrollbar, { total: lines.length, top: firstShown, rows: rows, focused: focused })] }), _jsx(Box, { flexDirection: "column", children: footer.map((line, i) => render(line, `f${i}`)) }), showMenu ? (_jsx(Box, { flexDirection: "column", children: matches.slice(menuStart, menuStart + menuRows).map((c, i) => {
                     const selected = menuStart + i === menuRow;
-                    return (_jsxs(Text, { wrap: "truncate-end", ...(selected ? { backgroundColor: C.panel } : {}), children: [_jsx(Text, { color: selected ? C.accent2 : C.dim, children: selected ? "▸" : " " }), _jsxs(Text, { color: selected ? C.accent : C.text, bold: selected, children: ["/", c.name] }), c.args && inner >= 56 ? _jsxs(Text, { color: C.dim, children: [" ", c.args] }) : null /* narrow: the description matters more */, _jsxs(Text, { color: C.dim, children: ["  ", c.description] })] }, c.name));
-                }) })) : (_jsx(Text, { wrap: "truncate-end", color: C.dim, children: contextChip ? _jsxs(_Fragment, { children: [_jsx(Text, { color: C.cyan, children: "@" }), " ", contextChip] }) : " " })), _jsx(Text, { color: focused ? C.accent : C.dim, children: "─".repeat(Math.max(0, inner + 1)) }), _jsx(ChatInput, { value: input, onChange: (text) => focusedNow.current && setInput(text), onSubmit: submit, focus: focused && !(approval && !input), width: inner + 1, history: sent, arrowsTaken: showMenu, placeholder: busy ? (inner >= 44 ? (sendNowFirst ? "Enter sends now · Alt+Enter queues · Esc stops" : "Enter queues · Alt+Enter sends now · Esc stops") : sendNowFirst ? "Enter sends now · Esc stops" : "Enter queues · Esc stops") : showMenu ? "↑↓ choose · Tab complete · Enter run" : inner >= 44 ? "Ask anything · / for commands · ↑ history" : "Ask anything · / commands" })] }));
+                    // What's typed so far shows in the command color; the rest of the name follows. A plugin's
+                    // command says so, so Nou's own stand apart.
+                    const typed = input.slice(1).toLowerCase();
+                    const typedLen = typed && c.name.startsWith(typed) ? typed.length : 0;
+                    const fromPlugin = !!extraCommands?.some((e) => e.name === c.name);
+                    return (_jsxs(Text, { wrap: "truncate-end", ...(selected ? { backgroundColor: C.panel } : {}), children: [_jsx(Text, { color: selected ? C.accent2 : C.dim, children: selected ? "▸" : " " }), _jsx(Text, { color: C.accent2, bold: true, children: "/" }), _jsx(Text, { color: C.yellow, bold: true, children: c.name.slice(0, typedLen) }), _jsx(Text, { color: C.accent2, bold: selected, children: c.name.slice(typedLen) }), fromPlugin && _jsx(Text, { color: C.cyan, children: " plugin" }), c.args && inner >= 56 ? _jsxs(Text, { color: C.dim, children: [" ", c.args] }) : null /* narrow: the description matters more */, _jsxs(Text, { color: C.dim, children: ["  ", c.description] })] }, c.name));
+                }) })) : (_jsx(Text, { wrap: "truncate-end", color: C.dim, children: contextChip ? _jsxs(_Fragment, { children: [_jsx(Text, { color: C.cyan, children: "@" }), " ", contextChip] }) : " " })), _jsx(Text, { color: focused ? C.accent : C.dim, children: "─".repeat(Math.max(0, inner + 1)) }), _jsx(ChatInput, { value: input, onChange: (text) => focusedNow.current && setInput(text), onSubmit: submit, focus: focused && !(approval && !input), width: inner + 1, history: sent, arrowsTaken: showMenu, command: commandLength, placeholder: busy ? (inner >= 44 ? (sendNowFirst ? "Enter sends now · Alt+Enter queues · Esc stops" : "Enter queues · Alt+Enter sends now · Esc stops") : sendNowFirst ? "Enter sends now · Esc stops" : "Enter queues · Esc stops") : showMenu ? "↑↓ choose · Tab complete · Enter run" : inner >= 44 ? "Ask anything · / for commands · ↑ history" : "Ask anything · / commands" })] }));
 });

package/dist/src/ui/ChatInput.js

@@ -1,6 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from "react";
-import { Box, Text, useInput, usePaste } from "ink";
+import { Box, Text, useInput, usePaste, useStdin } from "ink";
 import { C } from "./theme.js";
 /** Word-wraps `text` into segments of at most `width` characters, honoring newlines. */
 export function layout(text, width) {
@@ -35,7 +35,7 @@ function cursorLine(segments, cursor) {
     }
     return segments.length - 1;
 }
-export function ChatInput({ value, onChange, onSubmit, focus, width, placeholder, history, maxLines = 6, arrowsTaken = false }) {
+export function ChatInput({ value, onChange, onSubmit, focus, width, placeholder, history, maxLines = 6, arrowsTaken = false, command = 0 }) {
     const [cursor, setCursor] = useState(value.length);
     const [recall, setRecall] = useState(null);
     const stash = useRef("");
@@ -57,6 +57,24 @@ export function ChatInput({ value, onChange, onSubmit, focus, width, placeholder
         setCursor(Math.max(0, Math.min(next.length, nextCursor)));
     };
     const insert = (text) => set(value.slice(0, pos) + text + value.slice(pos), pos + text.length);
+    // Shift/Ctrl/Cmd+Enter as xterm's modifyOtherKeys sends them (ESC [27;<mods>;13~, from terminals set up that
+    // way): Ink drops these, so they're caught here and add a line, like the kitty protocol's form does.
+    const { stdin } = useStdin();
+    const insertLine = useRef(() => { });
+    insertLine.current = () => insert("\n");
+    useEffect(() => {
+        if (!focus || !stdin)
+            return;
+        const onData = (data) => {
+            // eslint-disable-next-line no-control-regex -- the sequence starts with ESC
+            if (/\x1b\[27;([2-9]|1[0-6]);13~/.test(String(data)))
+                insertLine.current();
+        };
+        stdin.on("data", onData);
+        return () => {
+            stdin.off("data", onData);
+        };
+    }, [focus, stdin]);
     const recallHistory = (step) => {
         if (!history.length)
             return false;
@@ -131,11 +149,16 @@ export function ChatInput({ value, onChange, onSubmit, focus, width, placeholder
     return (_jsx(Box, { flexDirection: "column", children: shown.map((s, i) => {
             const text = value.slice(s.start, s.end).replace(/\n/g, "");
             const isCursor = focus && first + i === line;
+            // A known command at the start ("/zoom in") in the command color, the rest as typed.
+            const paint = (from, to) => {
+                const cmdEnd = Math.max(from, Math.min(to, command - s.start));
+                return (_jsxs(_Fragment, { children: [cmdEnd > from && _jsx(Text, { color: C.accent2, bold: true, children: text.slice(from, cmdEnd) }), _jsx(Text, { color: C.text, children: text.slice(cmdEnd, to) })] }));
+            };
             if (!isCursor) {
-                return _jsxs(Text, { children: [prompt(i), _jsx(Text, { color: C.text, children: text || " " })] }, first + i);
+                return _jsxs(Text, { children: [prompt(i), text ? paint(0, text.length) : " "] }, first + i);
             }
             const at = pos - s.start;
-            return (_jsxs(Text, { children: [prompt(i), _jsx(Text, { color: C.text, children: text.slice(0, at) }), _jsx(Text, { inverse: true, children: text[at] ?? " " }), _jsx(Text, { color: C.text, children: text.slice(at + 1) })] }, first + i));
+            return (_jsxs(Text, { children: [prompt(i), paint(0, at), _jsx(Text, { inverse: true, children: text[at] ?? " " }), paint(at + 1, text.length)] }, first + i));
         }) }));
 }
 /** How many rows the input will take, so the chat can size its history above it. */

package/dist/src/ui/background.js

@@ -1,42 +1,51 @@
 /**
- * Whether the terminal's background is light or dark, so Nou can pick colors that are readable on it.
- *
- * COLORFGBG (set by rxvt, Konsole and others: "foreground;background" as color numbers) answers at once.
- * Otherwise Nou asks the terminal for its background color (OSC 11, answered by iTerm2, Terminal.app,
- * kitty, Ghostty, WezTerm, Alacritty, foot, GNOME's and VS Code's terminals and recent Windows Terminal).
- * A terminal that doesn't answer within `timeoutMs` gets null, and Nou keeps its dark colors.
+ * Asks the terminal, once, before Nou draws anything:
+ * - its background color (OSC 11), so the colors are readable on it (COLORFGBG answers that without asking);
+ * - whether it speaks the kitty keyboard protocol (CSI ? u), which tells Shift/Ctrl/Cmd+Enter, Cmd+F and
+ *   Ctrl+= apart from plain keys. Ink can ask too, but only after the first frame is drawn, and with a big
+ *   project the answer lands after its 200 ms timeout, so the protocol never came on (Shift+Enter sent).
+ * Then DA1 (CSI c), which every terminal answers, and in order: once its answer is in, so are the others.
  */
-export async function detectBackground(timeoutMs = 150) {
+export async function detectTerminal(timeoutMs = 400) {
     const fromEnv = paletteFromColorFgBg(process.env.COLORFGBG);
-    if (fromEnv)
-        return fromEnv;
     const stdin = process.stdin;
     if (!stdin.isTTY || !process.stdout.isTTY || typeof stdin.setRawMode !== "function")
-        return null;
+        return { palette: fromEnv, kitty: null };
     return new Promise((resolve) => {
         let reply = "";
         const wasRaw = stdin.isRaw;
-        const finish = (result) => {
+        const finish = () => {
             clearTimeout(timer);
             stdin.off("data", onData);
             stdin.setRawMode(wasRaw);
             stdin.pause();
-            resolve(result);
+            resolve(readTerminalReply(reply, fromEnv));
         };
         const onData = (data) => {
             reply += data.toString("latin1");
-            const palette = paletteFromOsc11(reply);
-            if (palette)
-                finish(palette);
+            if (DA1.test(reply))
+                finish();
         };
-        const timer = setTimeout(() => finish(null), timeoutMs);
+        const timer = setTimeout(finish, timeoutMs);
         stdin.setRawMode(true);
         stdin.resume();
         stdin.on("data", onData);
-        // ST-terminated (ESC \): the form most terminals answer in kind.
-        process.stdout.write("\x1b]11;?\x1b\\");
+        // OSC 11 is ST-terminated (ESC \): the form most terminals answer in kind.
+        process.stdout.write(`${fromEnv ? "" : "\x1b]11;?\x1b\\"}\x1b[?u\x1b[c`);
     });
 }
+// eslint-disable-next-line no-control-regex -- terminal answers start with ESC
+const KITTY = /\x1b\[\?\d+u/;
+// eslint-disable-next-line no-control-regex -- terminal answers start with ESC
+const DA1 = /\x1b\[\?[\d;]*c/;
+/** What the terminal's answers say (see detectTerminal); `fromEnv` is the background COLORFGBG gave, if any. */
+export function readTerminalReply(reply, fromEnv = null) {
+    return { palette: fromEnv ?? paletteFromOsc11(reply), kitty: KITTY.test(reply) ? true : DA1.test(reply) ? false : null };
+}
+/** Just the background (see detectTerminal). */
+export async function detectBackground(timeoutMs = 400) {
+    return (await detectTerminal(timeoutMs)).palette;
+}
 /** "15;0" (light text on black) → dark; "0;15" → light. The last number is the background's color index. */
 export function paletteFromColorFgBg(value) {
     const bg = Number(value?.split(";").at(-1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nou-cli",
-  "version": "0.5.11",
+  "version": "0.5.12",
   "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": {