nou-cli 0.5.3 → 0.5.4

package/README.md

@@ -50,7 +50,9 @@ Needs **Node 22.12+** and an interactive terminal (Windows Terminal, PowerShell,
 | 🔀 **Live diffs** | Every edit Nou proposes shows up side by side, and the files it is editing shimmer in the file tree while it works. <kbd>y</kbd> accepts, <kbd>n</kbd> rejects. Nothing touches disk without you. |
 | ✍️ **Built-in editor** | Press <kbd>e</kbd> to edit the open file yourself, with undo/redo and **auto-save**. |
 | 📍 **Shows you where things are** | Ask "where is the LiveKit integration?" and Nou finds it and opens it in the middle panel, jumped to the exact lines and highlighted. Any file a reply mentions (`src/a.ts:12`) is a link: click it. `/open name[:line]` opens a file yourself. |
-| 🎮 **Games for a break** | Add Pong, Snake and Breakout in settings → Games, then `/games` opens a panel docked under the chat: it splits that column instead of covering anything. Drag its title onto the files, code or chat to dock it there, and × at its top right closes it. A game runs only while the panel has the keyboard: Esc goes back to your code and it waits. |
+| 🗂️ **Several agents at once** | `/new` (or **+** in the chat's title) opens another conversation tab while the first keeps working. Each tab has its own agent and history; a working tab shows ●, one waiting for your OK shows !, and a click (or `/tab 2`) switches. `/close` closes one; it stays in `/resume`. |
+| 🧑‍🏫 **Show me how** | `/showme add a --verbose flag` and Nou finds where the change goes, then walks you through typing it yourself: each step opens the file at the right line, says why, and shows the code to type dim ahead of your cursor, like autocomplete (<kbd>Tab</kbd> fills in a line). It moves on when what you typed matches, and saves as it goes. `/showme next` skips a step, `/showme stop` ends it. Works with every engine (Nou's, Claude Code, Codex and pi): any edit one makes anyway is put back. `/teach` does the same. |
+| 🎮 **Games for a break** | Add Pong, Snake and Breakout in settings → Games, then `/games` opens a panel docked under the chat: it splits that column instead of covering anything. Drag its title onto the files, code or chat to dock it there, and × at its top right closes it. Drag its top edge to make it taller or shorter. A game runs only while the panel has the keyboard: Esc goes back to your code and it waits. |
 | 🧠 **A capable engine** | Reads and searches in parallel, numbered reads for exact line references, edits that survive small whitespace mismatches, several edits to a file as one change, a plan for longer tasks, full command output (stderr too) with exit codes and timeouts, retries when a provider is overloaded or a connection drops (Codex too: it picks the turn back up instead of stopping at "Reconnecting..."), and conversation caching with Claude. It follows your repo's `AGENTS.md`, `CLAUDE.md` and `NOU.md` (and `~/.nou/NOU.md`). |
 | 🔎 **Finds its way around** | The agent searches your code (`grep`, `glob`) without asking, reads only what it needs, runs your tests to check its work, and summarizes long conversations to stay within the model's context (`/compact` does it on demand). |
 | ↶ **Undo anything** | Every change, Nou's or yours, is recorded. <kbd>u</kbd> undoes Nou's last edit, `/rewind` undoes its whole last turn, and your own later edits are kept. |
@@ -98,11 +100,12 @@ Every change is reviewed like a code review:
 | <kbd>c</kbd> | in the file tree: show only changed files |
 | <kbd>f</kbd> | follow mode (off by default): watch along as Nou works. Each file it reads (the exact lines, highlighted) is shown a step at a time, a little behind it, and its edits as they happen. The status bar shows how many steps behind it is; set the speed in settings → Preferences (slow · normal · fast · instant) |
 | <kbd>&lt;</kbd> / <kbd>&gt;</kbd> / <kbd>=</kbd> | make the focused pane narrower / wider / reset the layout |
-| <kbd>`</kbd> | a terminal under the code, like VS Code's (also `/terminal`): Enter runs a command, Ctrl+C stops it, ↑↓ history, Esc back to the code, × closes it. Commands run through your shell one at a time, so full-screen programs like vim don't draw there |
+| <kbd>`</kbd> | a terminal under the code, like VS Code's (also `/terminal`): Enter runs a command, Ctrl+C stops it, ↑↓ history, Esc back to the code, × closes it; drag its top border (or <kbd>Alt</kbd>+↑/↓) to make it taller or shorter. Commands run through your shell one at a time, so full-screen programs like vim don't draw there |
+| <kbd>Ctrl</kbd>+<kbd>O</kbd> | in the chat: open or fold every "▸ N steps" line (what the agent read and ran between replies folds into one; click one to open just it) |
 | <kbd>m</kbd> | mouse on/off, so you can select and copy text in the terminal (in the chat, just drag over the text: it's copied when you let go) |
 | <kbd>s</kbd> | settings: model, preferences, plugins |
 | <kbd>y</kbd> / <kbd>n</kbd> | accept / reject a proposed edit or command, from any pane; the rest of Nou keeps working while it waits (<kbd>o</kbd> shows the edit) |
-| <kbd>Enter</kbd> while Nou works | queue the message: it goes when Nou finishes, together with anything else you queued, as one message (<kbd>Alt</kbd>+<kbd>Enter</kbd>: stop Nou and send it now) |
+| <kbd>Enter</kbd> while Nou works | queue the message: it goes when Nou finishes, together with anything else you queued, as one message; commands that only change the screen, like `/terminal`, `/games` or `/open`, run right away (<kbd>Alt</kbd>+<kbd>Enter</kbd>: stop Nou and send it now) |
 | <kbd>Esc</kbd> | stop Nou (anything queued goes back in the input) · close a diff · back to chat |
 | <kbd>Ctrl</kbd>+<kbd>C</kbd> | stop Nou while it works · press twice to quit |
 
@@ -120,7 +123,7 @@ In the editor:
 | <kbd>Ctrl</kbd>+<kbd>K</kbd> · <kbd>Ctrl</kbd>+<kbd>G</kbd> | hover info · go to definition (with a language server) |
 | <kbd>Esc</kbd> | clear the selection, or leave the editor |
 
-Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/pull <model>` · `/engine [name]` · `/auto [ask|auto-edit|auto]` · `/copy [code|file]` · `/undo` · `/rewind` · `/history` · `/diff [file or n]` · `/sessions` · `/problems` · `/compact` · `/clear` · `/resume [n|last]` · `/terminal` · `/help`
+Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/pull <model>` · `/engine [name]` · `/auto [ask|auto-edit|auto]` · `/copy [code|file]` · `/undo` · `/rewind` · `/history` · `/diff [file or n]` · `/sessions` · `/problems` · `/compact` · `/clear` · `/resume [n|last]` · `/terminal` · `/showme <what you want>` · `/help`
 
 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.
 

package/dist/src/config/index.js

@@ -26,6 +26,8 @@ export const DEFAULT_SETTINGS = {
     trustedFolders: [],
     games: [],
     gameDock: "chat",
+    terminalRows: null,
+    gameRows: null,
     plugins: {},
     trustedPlugins: {},
 };

package/dist/src/guide/index.js

@@ -0,0 +1,100 @@
+import path from "path";
+export const SHOW_STEPS = "show_steps";
+/** The tool the engine hands its steps back with. `onSteps` gets them; the engine is told they're shown. */
+export function showStepsTool(onSteps) {
+    return {
+        definition: {
+            name: SHOW_STEPS,
+            description: "Only when the user asked you to show them how ([Show me how] in their message): hand back the change as steps for them to type themselves, instead of editing. Each step adds whole lines of code before a line of a file, with why it's needed. Call it once, with every step in order.",
+            parameters: {
+                type: "object",
+                properties: {
+                    steps: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                file: { type: "string", description: "Project-relative path of the file to add to." },
+                                line: { type: "number", description: "1-based line the code goes in before (the line after the last one appends)." },
+                                code: { type: "string", description: "The lines to type, indented as they'll be in the file." },
+                                why: { type: "string", description: "One or two plain sentences: what this does and why it's needed." },
+                            },
+                            required: ["file", "line", "code", "why"],
+                        },
+                    },
+                },
+                required: ["steps"],
+            },
+        },
+        readOnly: true,
+        source: "nou",
+        run: (args) => {
+            const steps = tidySteps(args.steps);
+            if (!steps.length)
+                return "No usable steps: each needs a file, a line and the code to type. Call show_steps again.";
+            onSteps(steps);
+            return `Shown to the user as ${steps.length} step${steps.length > 1 ? "s" : ""} to type. Don't edit the files yourself; finish with a one-line summary.`;
+        },
+    };
+}
+/** Steps as the model gave them, kept when usable: a file, a line, code to type. */
+function tidySteps(raw) {
+    return (Array.isArray(raw) ? raw : [])
+        .filter((s) => typeof s?.file === "string" && typeof s?.code === "string" && s.code.trim())
+        .map((s) => ({ file: path.relative(process.cwd(), path.resolve(s.file)).split(path.sep).join("/"), line: Math.max(1, Math.floor(Number(s.line) || 1)), code: s.code.replace(/\r\n/g, "\n").replace(/\n+$/, ""), why: String(s.why ?? "") }));
+}
+/** The fenced block other engines (which can't call Nou's tools) put their steps in. */
+const BLOCK = /```nou-steps\s*\n([\s\S]*?)\n```/;
+/**
+ * The message that asks for steps. Nou's own engine hands them back with the show_steps tool; Claude
+ * Code, Codex and pi can't call Nou's tools, so they end their reply with a ```nou-steps block instead.
+ */
+export function showMePrompt(task, withTool) {
+    const how = withTool
+        ? `call ${SHOW_STEPS} once with the steps in order`
+        : "end your reply with the steps in order as a JSON array in a fenced block marked nou-steps, like:\n```nou-steps\n[{\"file\": \"src/cli.ts\", \"line\": 12, \"code\": \"const verbose = args.includes(\\\"--verbose\\\");\", \"why\": \"Reads the new flag.\"}]\n```";
+    return `[Show me how] ${task}\n\nDon't edit any files: I want to type it myself. Read what you need to find where it goes, then ${how} (each step: file, the line to add the code before, the exact lines of code to type, and why). Keep each step small, a few lines, so it's easy to follow.`;
+}
+/** Steps from a reply's ```nou-steps block, and the reply without it; null when there's none. */
+export function stepsFromReply(text) {
+    const m = BLOCK.exec(text);
+    if (!m)
+        return null;
+    try {
+        const steps = tidySteps(JSON.parse(m[1]));
+        return steps.length ? { steps, rest: text.replace(m[0], "").trim() } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * How far the text typed so far (`typed`, from where the step starts to the cursor) gets through
+ * `expected`: the index reached in `expected`, or -1 when it doesn't match. Leading indentation on each
+ * line is ignored either way, since the editor indents new lines itself.
+ */
+export function guideProgress(typed, expected) {
+    let i = 0;
+    let j = 0;
+    const skipIndent = (s, k) => {
+        while (k < s.length && (s[k] === " " || s[k] === "\t"))
+            k++;
+        return k;
+    };
+    i = skipIndent(typed, i);
+    j = skipIndent(expected, j);
+    while (i < typed.length) {
+        if (j >= expected.length || typed[i] !== expected[j])
+            return -1;
+        const newline = typed[i] === "\n";
+        i++;
+        j++;
+        if (newline) {
+            i = skipIndent(typed, i);
+            // The rest of the expected indentation counts as typed only once something follows it.
+            if (i < typed.length)
+                j = skipIndent(expected, j);
+        }
+    }
+    return j;
+}

package/dist/src/syntax/index.js

@@ -101,28 +101,27 @@ const CALLS = /^(call_expression|call|method_invocation|new_expression)$/;
 /** A named string node (anonymous keyword nodes can also be called "string", e.g. the TS type). */
 const isString = (n) => n.isNamed && STRINGS.test(n.type);
 const hasSubstitution = (n) => n.children.some((c) => c !== null && /substitution|interpolation/.test(c.type));
-function colorFor(node) {
+/**
+ * The color of a leaf. Its `parent` and `grand`parent and whether it's `inString` come from the walk over
+ * the tree: asking the node for them (node.parent) crosses into wasm, and every token used to, several times.
+ */
+function colorFor(node, parent, grand, inString) {
     const type = node.type;
     if (type.includes("comment"))
         return "comment";
     // Inside a string (but not inside ${...} substitutions)?
-    for (let p = node; p; p = p.parent) {
-        if (/substitution|interpolation/.test(p.type))
-            break;
-        if (isString(p))
-            return "string";
-    }
+    if (inString || isString(node))
+        return "string";
     // Built-in type names (`number`, `string`) and Python annotations (`name: str`).
-    if (node.parent?.type === "predefined_type" || (node.parent?.type === "type" && /identifier$/.test(type)))
+    if (parent?.type === "predefined_type" || (parent?.type === "type" && /identifier$/.test(type)))
         return "type";
     if (NUMBERS.test(type))
         return "number";
     if (CONSTANTS.test(type) || CONSTANTS.test(node.text))
         return node.isNamed || /^[a-zA-Z]+$/.test(node.text) ? "constant" : null;
-    if (TYPES.test(type) && (node.isNamed || node.parent?.type === "predefined_type"))
+    if (TYPES.test(type) && (node.isNamed || parent?.type === "predefined_type"))
         return "type";
     if (/identifier$/.test(type)) {
-        const parent = node.parent;
         if (parent && FUNCTION_PARENTS.test(parent.type) && parent.childForFieldName("name")?.equals(node))
             return "func";
         if (parent && CALLS.test(parent.type) && parent.childForFieldName("function")?.equals(node))
@@ -131,7 +130,7 @@ function colorFor(node) {
         const member = parent && /member_expression|attribute|field_expression|selector_expression/.test(parent.type)
             ? parent.childForFieldName("property") ?? parent.childForFieldName("attribute") ?? parent.childForFieldName("field")
             : null;
-        if (member?.equals(node) && parent.parent && CALLS.test(parent.parent.type) && parent.parent.childForFieldName("function")?.equals(parent))
+        if (member?.equals(node) && grand && CALLS.test(grand.type) && grand.childForFieldName("function")?.equals(parent))
             return "func";
     }
     if (PROPERTIES.test(type))
@@ -146,7 +145,7 @@ function colorFor(node) {
         return null;
     }
     if (!node.isNamed) {
-        if (node.parent?.type === "predefined_type")
+        if (parent?.type === "predefined_type")
             return "type";
         return /^[a-z_]+$/i.test(type) ? "keyword" : "punctuation";
     }
@@ -162,14 +161,14 @@ export function highlightTree(file, text) {
     let out = "";
     let pos = 0;
     const cursor = tree.walk();
-    // Depth-first over leaves, coloring each span.
-    const visit = () => {
+    // Depth-first over leaves, coloring each span; each level knows its parent, grandparent and whether it's in a string.
+    const visit = (parent, grand, inString) => {
         do {
             const node = cursor.currentNode;
             if (node.childCount === 0 || node.type.includes("comment") || (isString(node) && !hasSubstitution(node))) {
                 if (node.startIndex >= pos) {
                     out += themeColors().plain(text.slice(pos, node.startIndex));
-                    const color = colorFor(node);
+                    const color = colorFor(node, parent, grand, inString);
                     const span = text.slice(node.startIndex, node.endIndex);
                     // Color each line separately so styles don't bleed across line breaks.
                     out += span.split("\n").map((part) => (color ? themeColors()[color](part) : themeColors().plain(part))).join("\n");
@@ -177,13 +176,14 @@ export function highlightTree(file, text) {
                 }
             }
             else if (cursor.gotoFirstChild()) {
-                visit();
+                // A ${...} substitution inside a string starts code again.
+                visit(node, parent, /substitution|interpolation/.test(node.type) ? false : inString || isString(node));
                 cursor.gotoParent();
             }
         } while (cursor.gotoNextSibling());
     };
     if (cursor.gotoFirstChild())
-        visit();
+        visit(tree.rootNode, null, false);
     out += themeColors().plain(text.slice(pos));
     tree.delete();
     return out.split("\n");