nou-cli 0.5.4 → 0.5.10

package/dist/src/ui/Settings.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useEffect, useState } from "react";
 import { Box, Text, useAnimation, useInput } from "ink";
 import TextInput from "ink-text-input";
-import { AUTO_SAVE, CODE_THEMES, EFFORTS, FOLLOW_SPEEDS } from "../config/index.js";
+import { AUTO_SAVE, CODE_THEMES, UI_THEMES, EFFORT_LABELS, EFFORTS, FOLLOW_SPEEDS } from "../config/index.js";
 import { highlightLines } from "./text.js";
 import { GAMES } from "../games/index.js";
 import { saveCredentials } from "../config/credentials.js";
@@ -19,13 +19,15 @@ export function greet(name: string, times = 2): string {
 }`;
 const TABS = ["Model", "Engine", "Preferences", "Plugins", "Games"];
 const PREFS = [
-    { key: "effort", label: "Reasoning effort", help: "How hard Claude thinks (low → max). Higher is smarter but slower and pricier." },
+    { key: "effort", label: "Speed vs smarts", help: "How hard the model thinks before it answers (Claude, Codex, pi and Nou's engine with Claude)." },
     { key: "followSpeed", label: "Follow mode speed", help: "How long each file Nou reads stays on screen in follow mode (f): slow, normal, fast, or as it happens." },
+    { key: "uiTheme", label: "Nou's colors", help: "For a dark or a light terminal; auto asks the terminal which it is. Applies when Nou next starts." },
     { key: "codeTheme", label: "Code colors", help: "The theme for code. ←/→ to try them; github-light is for light terminals." },
     { key: "autoSave", label: "Auto-save", help: "delay: a second after you stop typing · focus: when you leave the editor · off: only Ctrl+S." },
     { key: "mouse", label: "Mouse", help: "Wheel scrolls the pane under the pointer; click to focus or open files. Hold Shift to select text." },
     { key: "followMode", label: "Follow mode on start", help: "The code view jumps to files Nou reads and edits." },
     { key: "reuseToolConfig", label: "Use Claude Code / Codex keys", help: "Use the API keys from Claude Code's or Codex's settings when you haven't set one. Applies on restart." },
+    { key: "sendNowWhileBusy", label: "Send while Nou works", help: "On: Enter stops Nou and sends your message now (Alt+Enter queues it). Off: Enter queues it for when Nou finishes." },
     { key: "gitContext", label: "Git context", help: "Give the model your branch, changes and commits, plus git tools." },
     { key: "autoApproveEdits", label: "Auto-approve edits", help: "Apply file edits without asking (diffs are still shown).", warn: true },
     { key: "autoApproveCommands", label: "Auto-approve commands", help: "Run shell commands without asking. Only turn on if you trust the model.", warn: true },
@@ -40,9 +42,11 @@ export function Settings({ width, height, settings, choice, plugins, connectTo,
     const [models, setModels] = useState({});
     const [connecting, setConnecting] = useState(connectTo?.connect ? { step: 0, values: {} } : null);
     const [field, setField] = useState(() => (connectTo?.connect ? initialValue(connectTo.connect[0]) : ""));
-    const { frame } = useAnimation({ interval: ANIMATION_MS });
     const provider = providers[row] ?? providers[0];
     const listed = models[provider.id];
+    // Only "loading models…" animates; a timer running the whole time settings is open would redraw it 10
+    // times a second for nothing.
+    const { frame } = useAnimation({ interval: ANIMATION_MS, isActive: listed === "loading" });
     // Load the model list for the highlighted provider.
     useEffect(() => {
         if (tab !== "Model" || connecting || provider.unavailable() || models[provider.id])
@@ -157,6 +161,9 @@ export function Settings({ width, height, settings, choice, plugins, connectTo,
             else if (pref.key === "codeTheme") {
                 onChange({ codeTheme: CODE_THEMES[(CODE_THEMES.indexOf(settings.codeTheme) + step + CODE_THEMES.length) % CODE_THEMES.length] });
             }
+            else if (pref.key === "uiTheme") {
+                onChange({ uiTheme: UI_THEMES[(UI_THEMES.indexOf(settings.uiTheme) + step + UI_THEMES.length) % UI_THEMES.length] });
+            }
             else if (pref.key === "autoSave") {
                 onChange({ autoSave: AUTO_SAVE[(AUTO_SAVE.indexOf(settings.autoSave) + step + AUTO_SAVE.length) % AUTO_SAVE.length] });
             }
@@ -190,6 +197,11 @@ export function Settings({ width, height, settings, choice, plugins, connectTo,
             used += cost(--first);
         return { first, last };
     })();
+    const gameWindow = (() => {
+        const fit = Math.max(1, Math.floor((boxHeight - 4) / 3));
+        const first = Math.max(0, Math.min((tab === "Games" ? row : 0) - fit + 1, GAMES.length - fit));
+        return { first, last: first + fit };
+    })();
     const toggle = (on, warn) => (_jsx(Text, { color: on ? (warn ? C.orange : C.green) : C.dim, bold: true, children: on ? "● ON " : "○ OFF" }));
     const body = () => {
         if (tab === "Model") {
@@ -244,15 +256,17 @@ export function Settings({ width, height, settings, choice, plugins, connectTo,
                         const value = settings[pref.key];
                         return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { ...(selected ? { backgroundColor: C.panel } : {}), children: [_jsx(Text, { color: selected ? C.accent2 : C.dim, children: selected ? "▸ " : "  " }), _jsx(Text, { color: C.text, bold: selected, children: pref.label.padEnd(26) }), pref.key === "codeTheme"
                                             ? _jsxs(Text, { children: [_jsx(Text, { color: C.dim, children: "\u2039 " }), _jsx(Text, { color: C.accent2, bold: true, children: String(value) }), _jsxs(Text, { color: C.dim, children: [" \u203A  ", CODE_THEMES.indexOf(value) + 1, "/", CODE_THEMES.length] })] })
-                                            : pref.key === "effort" || pref.key === "autoSave" || pref.key === "followSpeed"
-                                                ? _jsx(Text, { children: (pref.key === "effort" ? EFFORTS : pref.key === "autoSave" ? AUTO_SAVE : FOLLOW_SPEEDS).map((e) => _jsx(Text, { color: e === value ? C.accent2 : C.dim, bold: e === value, children: e === value ? `[${e}]` : ` ${e} ` }, e)) })
-                                                : toggle(value, pref.warn)] }), _jsxs(Text, { color: C.dim, wrap: "truncate-end", children: ["    ", pref.help] }), pref.key === "codeTheme" && selected
+                                            : pref.key === "effort"
+                                                ? _jsx(Text, { children: EFFORTS.map((e) => _jsx(Text, { color: e === value ? C.accent2 : C.dim, bold: e === value, children: e === value ? `[${EFFORT_LABELS[e].name}]` : ` ${EFFORT_LABELS[e].name} ` }, e)) })
+                                                : pref.key === "autoSave" || pref.key === "followSpeed" || pref.key === "uiTheme"
+                                                    ? _jsx(Text, { children: (pref.key === "autoSave" ? AUTO_SAVE : pref.key === "uiTheme" ? UI_THEMES : FOLLOW_SPEEDS).map((e) => _jsx(Text, { color: e === value ? C.accent2 : C.dim, bold: e === value, children: e === value ? `[${e}]` : ` ${e} ` }, e)) })
+                                                    : toggle(value, pref.warn)] }), _jsxs(Text, { color: C.dim, wrap: "truncate-end", children: ["    ", pref.key === "effort" ? `${EFFORT_LABELS[settings.effort].tradeoff}` : pref.help] }), pref.key === "codeTheme" && selected
                                     ? highlightLines("preview.ts", THEME_PREVIEW).map((line, n) => _jsxs(Text, { wrap: "truncate-end", children: ["    ", line] }, n))
                                     : null] }, pref.key));
                     }), prefWindow.last < PREFS.length ? _jsxs(Text, { color: C.dim, children: ["  \u2193 ", PREFS.length - prefWindow.last, " more"] }) : null] }));
         }
         if (tab === "Games") {
-            return (_jsxs(Box, { flexDirection: "column", height: boxHeight, borderStyle: "round", borderColor: C.accent, paddingX: 1, children: [_jsx(Text, { color: C.dim, children: "Little games for a break while Nou works. Added ones show in the Games panel: /games, or ? then \"games\"." }), _jsx(Text, { children: " " }), GAMES.map((g, i) => {
+            return (_jsxs(Box, { flexDirection: "column", height: boxHeight, borderStyle: "round", borderColor: C.accent, paddingX: 1, children: [_jsx(Text, { color: C.dim, wrap: "truncate-end", children: "Little games for a break while Nou works. Added ones show in the Games panel: /games." }), _jsx(Text, { children: " " }), GAMES.map((g, i) => ({ g, i })).slice(gameWindow.first, gameWindow.last).map(({ g, i }) => {
                         const selected = i === row;
                         const added = settings.games.includes(g.id);
                         return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { ...(selected ? { backgroundColor: C.panel } : {}), children: [_jsx(Text, { color: selected ? C.accent2 : C.dim, children: selected ? "▸ " : "  " }), added ? _jsx(Text, { color: C.green, bold: true, children: "\u2713 ADDED" }) : _jsx(Text, { color: C.accent2, bold: true, children: "\u2B07 GET  " }), _jsxs(Text, { color: C.text, bold: true, children: [" ", g.title] }), _jsxs(Text, { color: C.dim, children: ["  ", g.controls] })] }), _jsxs(Text, { color: C.dim, wrap: "truncate-end", children: ["    ", g.blurb] })] }, g.id));

package/dist/src/ui/Terminal.js

@@ -8,7 +8,7 @@ const COLORS = { out: C.text, command: C.accent, info: C.dim, error: C.red };
  * what you type goes to it; Ctrl+C stops it. ↑↓ go through what you ran, Ctrl+L clears, Esc leaves.
  * Drag its top border (or Alt+↑/↓) to make it taller or shorter.
  */
-export const Terminal = memo(function Terminal({ shell, version, width, height, focused, wheel, onLeave, onResize }) {
+export const Terminal = memo(function Terminal({ shell, version, width, height, focused, wheel, onLeave, onClose, onResize }) {
     const [input, setInput] = useState("");
     const [history, setHistory] = useState([]);
     const [back, setBack] = useState(-1);
@@ -48,6 +48,12 @@ export const Terminal = memo(function Terminal({ shell, version, width, height,
         if (key.ctrl && typed === "l")
             return shell.clear();
         if (key.return) {
+            // Each command runs in its own shell, so `exit` would end only that one and nothing would seem to
+            // happen: at the prompt it closes the terminal instead.
+            if (!shell.running && /^\s*(exit|logout)(\s+\d+)?\s*$/.test(input)) {
+                setInput("");
+                return onClose();
+            }
             if (!shell.running && input.trim())
                 setHistory((h) => [...h.filter((c) => c !== input.trim()), input.trim()].slice(-100));
             if (shell.running)

package/dist/src/ui/background.js

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+export async function detectBackground(timeoutMs = 150) {
+    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 new Promise((resolve) => {
+        let reply = "";
+        const wasRaw = stdin.isRaw;
+        const finish = (result) => {
+            clearTimeout(timer);
+            stdin.off("data", onData);
+            stdin.setRawMode(wasRaw);
+            stdin.pause();
+            resolve(result);
+        };
+        const onData = (data) => {
+            reply += data.toString("latin1");
+            const palette = paletteFromOsc11(reply);
+            if (palette)
+                finish(palette);
+        };
+        const timer = setTimeout(() => finish(null), 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\\");
+    });
+}
+/** "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));
+    if (!value || !Number.isInteger(bg))
+        return null;
+    // 7 (light gray) and 9-15 (bright colors, white) are light backgrounds; 0-6 and 8 are dark.
+    return bg === 7 || (bg >= 9 && bg <= 15) ? "light" : "dark";
+}
+/** The terminal's answer to OSC 11: ESC ] 11 ; rgb:RRRR/GGGG/BBBB (1-4 hex digits a channel), then BEL or ESC \. */
+export function paletteFromOsc11(reply) {
+    // eslint-disable-next-line no-control-regex -- the reply starts with ESC
+    const m = reply.match(/\x1b\]11;rgba?:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})/i);
+    if (!m)
+        return null;
+    const channel = (hex) => parseInt(hex, 16) / (16 ** hex.length - 1);
+    const [r, g, b] = [channel(m[1]), channel(m[2]), channel(m[3])];
+    // Perceived brightness (Rec. 709 weights); above half is a light background.
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b > 0.5 ? "light" : "dark";
+}

package/dist/src/ui/commands.js

@@ -2,19 +2,58 @@
  * Commands that only change what's on screen (or handle a busy Nou themselves): they run right away
  * while Nou works instead of waiting in the queue behind it.
  */
-const INSTANT = new Set(["new", "tab", "close", "terminal", "games", "open", "settings", "auto", "diff", "sessions", "history", "problems", "copy", "help", "version", "cancel"]);
+const INSTANT = new Set(["now", "fold", "unfold", "redraw", "new", "tab", "close", "terminal", "games", "open", "settings", "auto", "diff", "sessions", "history", "problems", "copy", "help", "version", "cancel"]);
 /** Whether a typed command runs right away while Nou works (see INSTANT); `/showme` counts only to look or step. */
+/**
+ * The command a mistyped name means: the same letters in another order ("/termnial"), or one letter off
+ * ("/termial", "/terminall"). Only when exactly one command fits, so a typo never runs the wrong one.
+ */
+export function closestCommand(name, names) {
+    const word = name.toLowerCase();
+    if (word.length < 3)
+        return null;
+    const sorted = (s) => [...s].sort().join("");
+    const anagrams = names.filter((n) => n.length === word.length && sorted(n) === sorted(word));
+    if (anagrams.length === 1)
+        return anagrams[0];
+    if (anagrams.length > 1)
+        return null;
+    const near = names.filter((n) => editDistance(word, n) <= 1);
+    return near.length === 1 ? near[0] : null;
+}
+/** Levenshtein distance, stopping early once it's over 1 (all closestCommand needs). */
+function editDistance(a, b) {
+    if (Math.abs(a.length - b.length) > 1)
+        return 2;
+    let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        const row = [i];
+        for (let j = 1; j <= b.length; j++)
+            row[j] = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        if (Math.min(...row) > 1)
+            return 2;
+        prev = row;
+    }
+    return prev[b.length];
+}
 export function runsWhileBusy(text) {
     const [name, ...rest] = text.slice(1).trim().split(/\s+/);
-    if (name === "showme" || name === "teach")
-        return !rest.length || /^(next|skip|stop|end)$/.test(rest.join(" "));
-    return text.startsWith("/") && INSTANT.has(name ?? "");
+    if (name === "showme" || name === "teach" || name === "teachme")
+        return !rest.length || /^(next|skip|back|prev|previous|stop|end|done)$/.test(rest.join(" "));
+    if (!text.startsWith("/") || !name)
+        return false;
+    return INSTANT.has(name) || INSTANT.has(closestCommand(name, SLASH_COMMANDS.map((c) => c.name)) ?? "");
 }
+/** Whether a command only changes what's on screen, so running it for a typo can't do harm. */
+export const onlyChangesScreen = (name) => INSTANT.has(name);
 export const SLASH_COMMANDS = [
     { name: "model", args: "[provider:model]", description: "show or switch the model" },
     { name: "models", args: "[provider]", description: "list the models a provider offers" },
     { name: "connect", args: "<provider>", description: "enter an API key (and URL) for a provider" },
     { name: "open", args: "<file>[:line]", description: "open a file in the code view (part of its name is enough)" },
+    { name: "effort", args: "[fastest|fast|balanced|smarter|smartest]", description: "speed vs smarts: how hard the model thinks (cheaper + faster, or smarter)" },
+    { name: "workspace", args: "[new <folder> | n]", description: "several projects in this window, a tab each in the header: open one, or switch" },
+    { name: "now", description: "stop Nou and send your queued messages right away (or click them)" },
     { name: "settings", description: "models, engine, preferences and plugins" },
     { name: "auto", args: "[ask|auto-edit|auto]", description: "how much Nou does without asking" },
     { name: "engine", args: "[name]", description: "which agent answers: nou, claude-code, codex or pi" },
@@ -28,17 +67,20 @@ export const SLASH_COMMANDS = [
     { name: "copy", args: "[code|file]", description: "copy the last reply, its last code block, or the open file" },
     { name: "compact", description: "summarize the conversation to free up context" },
     { name: "clear", description: "start a fresh conversation" },
-    { name: "showme", args: "<what you want>", description: "Nou shows you how, step by step, and you type it (with the code shown ahead of your cursor)" },
-    { name: "teach", args: "<what you want>", description: "same as /showme: Nou teaches you to make the change yourself, step by step" },
+    { name: "showme", args: "<question>", description: "Nou explains it and opens the places in the code, highlighted (next/back step through them); any engine" },
+    { name: "teach", args: "<what you want>", description: "Nou walks you through making the change yourself, step by step, with the code shown ahead of your cursor" },
     { name: "new", description: "a new conversation tab: another agent, working alongside this one" },
     { name: "tab", args: "[n]", description: "list the conversation tabs, or switch to tab n" },
     { name: "close", description: "close this conversation tab (it stays saved for /resume)" },
+    { name: "fold", description: "fold every function and block in the open file to its first line (z toggles)" },
+    { name: "unfold", description: "open every fold in the open file" },
+    { name: "redraw", description: "draw the whole screen again (Ctrl+L), if it ever looks shifted or clicks land a row off" },
     { name: "terminal", description: "a terminal under the code, like VS Code's (or press `)" },
     { name: "resume", args: "[number|last]", description: "pick up an earlier conversation in this folder (any engine)" },
     { name: "pull", args: "<model>", description: "download an Ollama model" },
     { name: "plugins", args: "[add|new <name>]", description: "your plugins and the starter ones" },
     { name: "mcp", args: "[add|remove|import]", description: "MCP servers: tools from other programs (/mcp add browser for a browser)" },
-    { name: "games", description: "open or close the Games panel (Pong, Snake, Breakout)" },
+    { name: "games", description: "open or close the Games panel (Pong, Snake, Breakout, Dodge, Hop, Pairs)" },
     { name: "version", description: "which version of Nou this is" },
     { name: "help", description: "all commands and keys" },
 ];

package/dist/src/ui/focus.js

@@ -0,0 +1,59 @@
+import { useEffect, useSyncExternalStore } from "react";
+import { useStdin } from "ink";
+/**
+ * Whether Nou's terminal window is the one in front. Terminals that report focus (xterm's mode 1004:
+ * iTerm2, Terminal.app, kitty, Ghostty, WezTerm, Windows Terminal, VS Code's, tmux with focus-events on)
+ * send ESC [ I and ESC [ O as you switch windows; Nou then stops its spinners and git polling while you're
+ * elsewhere, so it doesn't keep the CPU (and the terminal's redraws) busy for something nobody is watching.
+ * Terminals that don't report it never send either, and Nou stays "focused" as before.
+ */
+let focused = true;
+const listeners = new Set();
+export function setTerminalFocused(next) {
+    if (next === focused)
+        return;
+    focused = next;
+    for (const listener of listeners)
+        listener();
+}
+export const terminalFocused = () => focused;
+export function onTerminalFocus(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function useTerminalFocused() {
+    return useSyncExternalStore(onTerminalFocus, terminalFocused, terminalFocused);
+}
+/** The last focus report in a chunk of terminal input, if there is one. Ink ignores these, so they're never typed. */
+export function parseFocus(chunk) {
+    const at = Math.max(chunk.lastIndexOf("\x1b[I"), chunk.lastIndexOf("\x1b[O"));
+    return at < 0 ? null : chunk[at + 2] === "I";
+}
+const ENABLE = "\x1b[?1004h";
+const DISABLE = "\x1b[?1004l";
+let exitHookInstalled = false;
+/** Asks the terminal to report focus while mounted, and keeps `useTerminalFocused` up to date. */
+export function useFocusReporting(enabled) {
+    const { stdin } = useStdin();
+    useEffect(() => {
+        if (!enabled || !stdin)
+            return;
+        const terminal = process.stdout.isTTY ? process.stdout : null;
+        terminal?.write(ENABLE);
+        if (terminal && !exitHookInstalled) {
+            process.on("exit", () => process.stdout.write(DISABLE));
+            exitHookInstalled = true;
+        }
+        const onData = (data) => {
+            const next = parseFocus(String(data));
+            if (next !== null)
+                setTerminalFocused(next);
+        };
+        stdin.on("data", onData);
+        return () => {
+            stdin.off("data", onData);
+            terminal?.write(DISABLE);
+            setTerminalFocused(true);
+        };
+    }, [enabled, stdin]);
+}

package/dist/src/ui/redraw.js

@@ -0,0 +1,16 @@
+/**
+ * A full repaint: the app normally rewrites only the lines that changed, so if anything outside it ever
+ * wrote to the terminal, the screen would stay shifted (clicks landing a row off) until something forces
+ * every line out again. The CLI hands over Ink's clear here; /redraw and Ctrl+L call it.
+ */
+let clearScreen = null;
+export function setScreenClear(fn) {
+    clearScreen = fn;
+}
+/** Forgets what's on screen, so the next frame is drawn in full; false where there's no terminal (tests). */
+export function forgetScreen() {
+    if (!clearScreen)
+        return false;
+    clearScreen();
+    return true;
+}

package/dist/src/ui/render-options.js

@@ -8,6 +8,9 @@ export const RENDER_OPTIONS = {
     incrementalRendering: true,
     // Up to 60 frames a second, so scrolling and typing keep up with the keyboard and mouse.
     maxFps: 60,
+    // Library output goes to ~/.nou/nou.log instead (see cli.ts): Ink's console patch would print it into
+    // the full-screen app, scrolling it so clicks land a row off.
+    patchConsole: false,
     // Terminals that speak the kitty keyboard protocol (kitty, Ghostty, WezTerm, iTerm2, foot...) then tell
     // Enter from Ctrl+Enter, Cmd+Enter and Shift+Enter, so those can add a line in the chat. Others just
     // don't answer the query and keys work as before.

package/dist/src/ui/text.js

@@ -413,3 +413,48 @@ export function closeOpenMarkdown(text) {
         out += "**";
     return out;
 }
+/**
+ * Regions that can fold, from indentation (like VS Code without a language server): a line followed by
+ * more-indented lines folds them, and the closing bracket that ends the block. 1-based line -> last line.
+ */
+export function foldRanges(text) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const indent = (s) => s.match(/^[ \t]*/)[0].replace(/\t/g, "  ").length;
+    const blank = (s) => !s.trim();
+    const out = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        if (blank(lines[i]))
+            continue;
+        const base = indent(lines[i]);
+        let j = i + 1;
+        while (j < lines.length && blank(lines[j]))
+            j++;
+        if (j >= lines.length || indent(lines[j]) <= base)
+            continue;
+        let end = j;
+        for (let k = j; k < lines.length; k++) {
+            if (blank(lines[k]))
+                continue;
+            if (indent(lines[k]) <= base)
+                break;
+            end = k;
+        }
+        // The line that closes the block (`}`, `)`, `]`, `end`...) folds with it.
+        const next = end + 1;
+        if (next < lines.length && indent(lines[next]) === base && /^\s*([}\])]|end\b|<\/)/.test(lines[next]))
+            end = next;
+        if (end > i)
+            out.set(i + 1, end + 1);
+    }
+    return out;
+}
+/** The file lines (1-based) left showing with `folded` regions (start lines) closed. */
+export function unfoldedLines(count, ranges, folded) {
+    const out = [];
+    for (let n = 1; n <= count; n++) {
+        out.push(n);
+        if (folded.has(n) && ranges.has(n))
+            n = ranges.get(n);
+    }
+    return out;
+}

package/dist/src/ui/theme.js

@@ -1,6 +1,9 @@
 import path from "path";
-/** Tokyo Night inspired palette (truecolor; Windows Terminal supports it). */
-export const C = {
+/**
+ * Tokyo Night inspired palette (truecolor; Windows Terminal supports it). Secondary text ("dim") is still at
+ * least 4.5:1 against common dark backgrounds, so hints and help lines stay easy to read.
+ */
+const DARK = {
     accent: "#7aa2f7",
     accent2: "#bb9af7",
     cyan: "#7dcfff",
@@ -9,27 +12,70 @@ export const C = {
     orange: "#ff9e64",
     red: "#f7768e",
     text: "#c0caf5",
-    dim: "#565f89",
+    dim: "#8b93c0",
+    /** Lines around panes that aren't focused: quieter than text, since they aren't read. */
+    border: "#565f89",
     panel: "#1f2335",
+    /** Text on a colored badge (CHAT, CLOUD, EDITING...). */
+    onBadge: "#1a1b26",
 };
+/** For terminals with a light background: the same roles, dark enough to read on white (4.5:1 or more). */
+const LIGHT = {
+    accent: "#2e59c9",
+    accent2: "#7341c2",
+    cyan: "#007197",
+    green: "#3b7a1e",
+    yellow: "#8f5e00",
+    orange: "#b4501b",
+    red: "#c2264b",
+    text: "#1f2335",
+    dim: "#5a607a",
+    border: "#a8aecb",
+    panel: "#e6e7ed",
+    onBadge: "#ffffff",
+};
+/** The colors in use: dark unless the terminal is light (see setPalette). Read at render time, so set it first. */
+export const C = { ...DARK };
+let current = "dark";
+export const palette = () => current;
+/** Switches every color to the dark or light set. Call before the first render. */
+export function setPalette(which) {
+    current = which;
+    Object.assign(C, which === "light" ? LIGHT : DARK);
+    Object.assign(GIT_COLORS, gitColors());
+    for (const [ext, color] of Object.entries(iconColors()))
+        ICONS[ext][1] = color;
+}
 /** Every spinner and shimmer ticks on this one interval, so they redraw together in a single frame. */
 export const ANIMATION_MS = 100;
 export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const GRADIENT = [C.accent, "#8c9cf7", C.accent2, "#c39af2", "#e08ad6", C.red, C.orange, C.yellow, C.green, C.cyan];
+const gradientColors = () => current === "light"
+    ? [C.accent, "#4b4fc4", C.accent2, "#8a3fb0", "#a8327f", C.red, C.orange, C.yellow, C.green, C.cyan]
+    : [C.accent, "#8c9cf7", C.accent2, "#c39af2", "#e08ad6", C.red, C.orange, C.yellow, C.green, C.cyan];
 /** Colors for each character of a label, shifted by `frame` so it shimmers when animated. */
 export function gradient(text, frame = 0) {
-    return [...text].map((ch, i) => ({ ch, color: GRADIENT[(i + frame) % GRADIENT.length] }));
+    const colors = gradientColors();
+    return [...text].map((ch, i) => ({ ch, color: colors[(i + frame) % colors.length] }));
 }
-export const GIT_COLORS = {
-    M: C.yellow, A: C.green, "?": C.green, D: C.red, R: C.cyan, U: C.orange,
+const gitColors = () => ({ M: C.yellow, A: C.green, "?": C.green, D: C.red, R: C.cyan, U: C.orange });
+export const GIT_COLORS = gitColors();
+/** Each file type's icon color: language colors, with JavaScript's yellow darkened on a light background. */
+const iconColors = () => {
+    const js = current === "light" ? "#8a7400" : "#f1e05a";
+    return {
+        ".ts": "#3178c6", ".tsx": C.cyan, ".mts": "#3178c6", ".cts": "#3178c6",
+        ".js": js, ".jsx": C.cyan, ".mjs": js, ".cjs": js,
+        ".py": "#3572a5", ".json": C.yellow, ".md": C.text, ".css": C.accent2,
+        ".html": C.orange, ".yml": C.red, ".yaml": C.red, ".go": C.cyan,
+        ".rs": C.orange, ".sh": C.green, ".ps1": C.accent, ".lock": C.dim,
+    };
 };
-const ICONS = {
-    ".ts": ["◆", "#3178c6"], ".tsx": ["◆", C.cyan], ".mts": ["◆", "#3178c6"], ".cts": ["◆", "#3178c6"],
-    ".js": ["◆", "#f1e05a"], ".jsx": ["◆", C.cyan], ".mjs": ["◆", "#f1e05a"], ".cjs": ["◆", "#f1e05a"],
-    ".py": ["◆", "#3572a5"], ".json": ["◇", C.yellow], ".md": ["≡", C.text], ".css": ["◆", C.accent2],
-    ".html": ["◆", C.orange], ".yml": ["◇", C.red], ".yaml": ["◇", C.red], ".go": ["◆", C.cyan],
-    ".rs": ["◆", C.orange], ".sh": ["$", C.green], ".ps1": ["$", C.accent], ".lock": ["◌", C.dim],
+const ICON_SHAPES = {
+    ".ts": "◆", ".tsx": "◆", ".mts": "◆", ".cts": "◆", ".js": "◆", ".jsx": "◆", ".mjs": "◆", ".cjs": "◆",
+    ".py": "◆", ".json": "◇", ".md": "≡", ".css": "◆", ".html": "◆", ".yml": "◇", ".yaml": "◇", ".go": "◆",
+    ".rs": "◆", ".sh": "$", ".ps1": "$", ".lock": "◌",
 };
+const ICONS = Object.fromEntries(Object.entries(iconColors()).map(([ext, color]) => [ext, [ICON_SHAPES[ext], color]]));
 export function fileIcon(file) {
     const base = path.basename(file).toLowerCase();
     if (base.startsWith(".env"))

package/dist/src/workspaces/client.js

@@ -0,0 +1,69 @@
+import net from "net";
+import path from "path";
+import { useSyncExternalStore } from "react";
+let tabs = [];
+const listeners = new Set();
+let socket = null;
+/** Whether this Nou is one workspace of several (run by the host). */
+export const isHosted = () => !!process.env.NOU_HOST_PORT && !!process.env.NOU_WORKSPACE_ID;
+export function workspaceTabs() {
+    return tabs;
+}
+export function useWorkspaceTabs() {
+    return useSyncExternalStore((fn) => {
+        listeners.add(fn);
+        return () => listeners.delete(fn);
+    }, workspaceTabs, workspaceTabs);
+}
+/** One JSON message a line. */
+export function lineReader(onMessage) {
+    let carry = "";
+    return (chunk) => {
+        carry += String(chunk);
+        let at;
+        while ((at = carry.indexOf("\n")) >= 0) {
+            const line = carry.slice(0, at);
+            carry = carry.slice(at + 1);
+            try {
+                onMessage(JSON.parse(line));
+            }
+            catch {
+                // not ours
+            }
+        }
+    };
+}
+/** Connects to the host (when hosted) and passes on what it says. */
+export function connectToHost(on) {
+    if (!isHosted() || socket)
+        return;
+    const s = net.connect(Number(process.env.NOU_HOST_PORT), "127.0.0.1");
+    s.unref(); // never what keeps Nou running once you quit it
+    socket = s;
+    s.on("connect", () => sendToHost({ type: "hello", id: process.env.NOU_WORKSPACE_ID, token: process.env.NOU_HOST_TOKEN ?? "" }));
+    s.on("data", lineReader((msg) => {
+        if (msg.type === "tabs") {
+            tabs = msg.tabs;
+            for (const fn of listeners)
+                fn();
+        }
+        else if (msg.type === "redraw")
+            on.redraw();
+        else if (msg.type === "error")
+            on.error(msg.text);
+    }));
+    s.on("error", () => { });
+    s.on("close", () => (socket = null));
+}
+export function sendToHost(msg) {
+    if (!socket || socket.destroyed)
+        return false;
+    socket.write(`${JSON.stringify(msg)}\n`);
+    return true;
+}
+/** What a tab is called: the folder's name. */
+export const tabName = (folder) => path.basename(path.resolve(folder)) || folder;
+/** Set when this Nou should reopen as a workspaces window as it quits (see cli.ts). */
+let reopenAs = null;
+export const reopenAsWorkspaces = (folders) => (reopenAs = folders);
+export const pendingWorkspaces = () => reopenAs;