nou-cli 0.5.1 → 0.5.2

package/README.md

@@ -49,12 +49,15 @@ Needs **Node 22.12+** and an interactive terminal (Windows Terminal, PowerShell,
 | 🗂️ **File explorer** | Browse your project with file icons and git status (`M` modified, `?` new). Press <kbd>c</kbd> to see only changed files. |
 | 🔀 **Live diffs** | Every edit Nou proposes shows up side by side. <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 floating panel you can drag anywhere by its title. 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, 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. |
 | 🧾 **Session diffs** | `/diff` shows everything that changed this session, file by file (<kbd>[</kbd> <kbd>]</kbd> to step through). `/sessions` lists earlier sessions and `/diff 2` shows one. |
 | 🩺 **Problems, live** | Syntax errors instantly, plus ESLint, TypeScript, Ruff and language servers when your project has them. Shown in the gutter, inline, and in a <kbd>p</kbd> Problems panel. |
 | 🤖 **Self-correcting** | Nou checks its own edits: you see "⚠ +1 problem" *before* approving, and any problems it introduced are fed back so it fixes them. |
-| 🎨 **Real syntax highlighting** | tree-sitter parsing for 14 languages (TS, JS, Python, Go, Rust, Java, C, JSON, YAML…). |
+| 🎨 **Real syntax highlighting** | tree-sitter parsing for 14 languages (TS, JS, Python, Go, Rust, Java, C, JSON, YAML…), in your choice of theme: One Dark (default), Tokyo Night, GitHub Dark, Dracula, High Contrast or GitHub Light (settings → Preferences → Code colors, with a preview). |
 | 🧭 **Code intelligence** | <kbd>Ctrl</kbd>+<kbd>K</kbd> hover info and <kbd>Ctrl</kbd>+<kbd>G</kbd> go-to-definition via language servers (typescript-language-server, pyright, rust-analyzer, gopls, clangd). |
 | 👀 **Knows what you're looking at** | The open file, visible lines, your cursor and unsaved edits ride along with each message. "Fix this function" just works. |
 | 🌿 **Git aware** | Sees your branch, uncommitted changes and recent commits, and can diff on its own. Press <kbd>v</kbd> to diff any file against `HEAD`. |
@@ -78,21 +81,28 @@ Every change is reviewed like a code review:
 | --- | --- |
 | 🖱️ Mouse | wheel scrolls the pane under the pointer (<kbd>Shift</kbd>+wheel or a tilt wheel: sideways) · click or drag a scrollbar to jump · click a file to open it · **double-click in the code to edit right there** (in the editor: select a word), drag to select · drag a border between panes to resize them (press <kbd>m</kbd> to turn the mouse off and select text in your terminal) |
 | <kbd>PgUp</kbd>/<kbd>PgDn</kbd>, <kbd>Shift</kbd>+<kbd>↑</kbd>/<kbd>↓</kbd> | scroll the chat; scrolled up, new replies wait below instead of yanking the view (<kbd>Ctrl</kbd>+<kbd>End</kbd> jumps back) |
-| <kbd>/</kbd> | start a command from any pane |
+| <kbd>?</kbd> | **every action, searchable**, each with its shortcut (also <kbd>Ctrl</kbd>+<kbd>P</kbd> then `>`) |
+| <kbd>/</kbd> | start a command from any pane: a menu lists every command with what it does (<kbd>↑</kbd>/<kbd>↓</kbd> choose, <kbd>Tab</kbd> complete, <kbd>Enter</kbd> run) |
+| 🖱️ Status bar | click the mode to switch it, `follow` to toggle it, the ✖/▲ counts for the Problems panel, or any shortcut hint to do it · click the model in the header to change it |
 | <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 |
+| <kbd>Ctrl</kbd>+<kbd>P</kbd> | fuzzy-find a file; the files you've opened are listed first |
+| <kbd>b</kbd> | back to the previous file (press again to flip back) |
+| <kbd>Ctrl</kbd>+<kbd>F</kbd> | find in the open file: 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, its × to close · <kbd>[</kbd>/<kbd>]</kbd> previous/next · <kbd>x</kbd> close |
+| <kbd>Ctrl</kbd>+click | on a name in the code (or <kbd>Option</kbd>+click, or right-click): go to its definition; an imported name goes to its import, and the import's path opens that file |
 | <kbd>e</kbd> or a double-click | edit the open file (see the editor keys below) |
 | <kbd>p</kbd> | Problems panel: every error and warning, <kbd>Enter</kbd> jumps to it |
 | <kbd>u</kbd> | undo Nou's last edit |
 | <kbd>v</kbd> | diff the open file vs git `HEAD`, Nou's last edit, or this session · <kbd>n</kbd>/<kbd>N</kbd> jump between changes · <kbd>[</kbd>/<kbd>]</kbd> previous/next file in a session diff |
 | <kbd>c</kbd> | in the file tree: show only changed files |
-| <kbd>f</kbd> | follow mode (off by default): jump to files as Nou reads and edits them |
+| <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>m</kbd> | mouse on/off, so you can select and copy text in the terminal |
 | <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>Esc</kbd> | stop Nou · close a diff · back to chat |
+| <kbd>Enter</kbd> while Nou works | queue the message: it goes when Nou finishes (<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 |
 
 In the editor:
@@ -165,6 +175,20 @@ nou --version
 
 Set `NOU_NO_UPDATE_CHECK=1` to turn the check off.
 
+## 🔌 MCP servers and browser control
+
+Nou's engine can use tools from [MCP](https://modelcontextprotocol.io) servers: a browser, GitHub, your database...
+
+- **Already use some?** Nou finds the MCP servers you've set up in Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, Gemini CLI and Codex, and offers them on start: `/mcp import` brings them over, with their settings. (Your Claude Code and Codex API keys are picked up too; see *Use Claude Code / Codex keys* in settings.)
+- **Browser control:** `/mcp add browser` adds [Playwright's MCP server](https://github.com/microsoft/playwright-mcp), so you can ask Nou to open a page, click through it, fill a form or check what your app shows.
+- **Your own:** `/mcp add <name> <command and arguments>` or `/mcp add <name> <url>`; `/mcp` lists them and their status, `/mcp remove <name>` removes one. They live in `~/.nou/mcp.json` (same format as Claude Code and Cursor); a project's `.mcp.json` is used too, in folders you trust.
+
+Tools that say they only read run on their own; any other MCP tool asks you first, like Nou's edits and commands. A server's own output never reaches Nou's screen.
+
+## 🔒 Trusting a folder
+
+The first time you open a folder, Nou asks whether you trust its files: it reads them, and can run the folder's MCP servers and plugins. Say no and Nou doesn't open it. Trusted folders are listed in `~/.nou/config.json`.
+
 ## 🧩 Plugins *(early)*
 
 **Starter plugins** ship with Nou and are optional: open <kbd>s</kbd> settings → **Plugins** and press Enter on one, or type `/plugins add <name>`. Adding one copies it into `~/.nou/plugins/`, where it's yours to edit.
@@ -207,7 +231,17 @@ npm run screenshot   # regenerate docs/screenshot.svg
 npm run eval         # how well the agent does real tasks with a real model (see evals/)
 ```
 
-Releasing: bump `version` in `package.json`, merge to `master`, then run **Actions → Publish to npm**. It tests, publishes with provenance, and creates the git tag and GitHub Release. (Or publish a GitHub release tagged `vX.Y.Z`.) The token lives in the `production` environment as `NPM_TOKEN`.
+### Releasing
+
+**Always bump the version first.** npm never accepts the same version twice, so publishing without a bump fails with *"nou-cli@X.Y.Z is already published. Bump "version" in package.json first."* Every release goes:
+
+1. **Bump the version** in a PR: `npm version patch --no-git-tag-version` (or `minor` / `major`), which updates `package.json` and `package-lock.json` together. Patch (0.5.1 → 0.5.2) for fixes and small features, minor (0.5 → 0.6) for bigger ones.
+2. **Merge it** to `master` once CI is green.
+3. **Run Actions → Publish to npm** (Run workflow on `master`), then **approve** the `production` environment when GitHub asks. It tests, publishes with provenance, and creates the `vX.Y.Z` git tag and GitHub Release. (Publishing a GitHub release tagged `vX.Y.Z` does the same, taking the version from the tag.)
+
+The npm token lives in the `production` environment as `NPM_TOKEN`. Check what's live with `npm view nou-cli version`.
+
+The workflows run on the actions' Node 24 versions (`actions/checkout@v5`, `actions/setup-node@v5`, `codeql-action@v4`), so GitHub's Node 20 deprecation warning no longer applies; Dependabot keeps them current. Jobs run on `ubuntu-latest`, which GitHub moves to Ubuntu 26 from October 19, 2026: nothing to change for that.
 
 Upkeep runs on its own:
 - **CI** on every PR: type-check, lint, build, unit and end-to-end tests on Linux, macOS and Windows (Node 22.12 and 24 too), plus installing the packed tarball to check the package works.

package/dist/index.js

@@ -1,103 +1,13 @@
 #!/usr/bin/env node
 // Must stay the first import: loads .env before any provider reads its keys and URLs.
 import "./src/env.js";
-import { createElement } from "react";
-import { render } from "ink";
-import * as p from "@clack/prompts";
-import chalk from "chalk";
-import { artWork } from "./src/util/index.js";
-import { ensureProjectContext, loadPermanentContext } from "./src/context/index.js";
-import { describe, initialModel, resolveModel, saveModel } from "./src/providers/index.js";
-import { loadSettings } from "./src/config/index.js";
-import { loadCredentials } from "./src/config/credentials.js";
-import { borrowToolConfig, ensureLocalModel, pickStartingModel } from "./src/setup/index.js";
-import { checkForUpdate, currentVersion, installUpdate, relaunch } from "./src/update/index.js";
-import { lsp } from "./src/lsp/index.js";
-import { App } from "./src/ui/App.js";
-import { installFastOutput } from "./src/ui/fast-output.js";
-import { RENDER_OPTIONS } from "./src/ui/render-options.js";
-const HELP = `nou ${currentVersion()}: an AI coding assistant for your terminal
-
-Usage:
-  nou              open Nou in the current folder
-  nou update       update to the latest version
-  nou --version    print the version
-  nou --help       show this help
-
-Settings live in ~/.nou/config.json (or press s inside Nou); keys you enter there, or with /connect, in ~/.nou/credentials.json. Set NOU_NO_UPDATE_CHECK=1 to skip update checks.`;
-async function main() {
-    const args = process.argv.slice(2);
-    if (args.includes("--version") || args.includes("-v")) {
-        console.log(currentVersion());
-        return;
-    }
-    if (args.includes("--help") || args.includes("-h")) {
-        console.log(HELP);
-        return;
-    }
-    if (args[0] === "update") {
-        const latest = await checkForUpdate({ force: true, timeout: 10_000 });
-        if (!latest) {
-            console.log(`nou ${currentVersion()} is up to date.`);
-            return;
-        }
-        console.log(`Updating nou ${currentVersion()} → ${latest}...`);
-        if (await installUpdate(latest))
-            process.exit(0);
-        if (process.platform !== "win32")
-            console.log("If that was a permissions error, run: sudo npm install -g nou-cli@latest");
-        process.exit(1);
-    }
-    if (!process.stdin.isTTY) {
-        console.error("Nou needs an interactive terminal (try Windows Terminal, PowerShell, or Terminal/iTerm on macOS).");
-        process.exit(1);
-    }
-    p.intro(chalk.cyan(`${artWork} \n Hello I am Nou! 🌞  ${chalk.dim(`v${currentVersion()}`)}`));
-    const latest = await checkForUpdate();
-    if (latest) {
-        const update = await p.confirm({ message: `Nou ${chalk.green(latest)} is available (you have ${currentVersion()}). Update now?` });
-        if (update === true) {
-            const ok = await installUpdate(latest);
-            if (ok) {
-                p.log.success(`Updated to ${latest}. Restarting...`);
-                relaunch();
-                return;
-            }
-            p.log.warn(process.platform === "win32"
-                ? "The update failed. You can retry later with: npm install -g nou-cli@latest"
-                : "The update failed. If it was a permissions error, run: sudo npm install -g nou-cli@latest");
-        }
-    }
-    const settings = loadSettings();
-    loadCredentials(); // keys entered inside Nou, for whatever the environment and .env leave unset
-    const borrowed = settings.reuseToolConfig ? borrowToolConfig() : [];
-    for (const b of borrowed)
-        p.log.info(`Using the ${b.provider === "anthropic" ? "Anthropic" : "OpenAI"} API key from your ${b.tool} settings.`);
-    let choice = initialModel();
-    // First run: start with a model that's already here, if there is one.
-    if (!process.env.NOU_MODEL && !settings.model) {
-        const picked = await pickStartingModel(borrowed);
-        if (picked) {
-            choice = picked;
-            saveModel(picked);
-        }
-    }
-    const problem = choice.provider.unavailable();
-    if (problem) {
-        p.log.warn(`${choice.provider.label} isn't set up (${problem}), falling back to local Ollama.`);
-        choice = resolveModel("ollama");
-    }
-    const ready = await ensureLocalModel(choice);
-    if (ready !== choice)
-        saveModel(ready); // picked a model that's already installed instead
-    choice = ready;
-    p.log.info(`Model: ${chalk.yellow(describe(choice))}  (change it any time with /model)`);
-    await ensureProjectContext(choice);
-    const permContext = await loadPermanentContext();
-    await installFastOutput();
-    const app = render(createElement(App, { initialModel: choice, permContext }), RENDER_OPTIONS);
-    await app.waitUntilExit();
-    lsp.stopAll();
-    p.outro(chalk.cyan("Bye bye!"));
+import { installFastWidth } from "./src/ui/fast-width.js";
+// Answered before loading the rest, which takes most of a second.
+if (process.argv[2] === "--version" || process.argv[2] === "-v") {
+    const { currentVersion } = await import("./src/update/index.js");
+    console.log(currentVersion());
+    process.exit(0);
 }
-main().catch(console.error);
+// Ink's text measuring has to be swapped before Ink loads, so everything else is imported after it.
+installFastWidth();
+await import("./src/cli.js");

package/dist/src/agent/index.js

@@ -1,11 +1,26 @@
 import { randomUUID } from "crypto";
+import { existsSync, statSync } from "fs";
 import { toolDefs } from "../tools/index.js";
-import { applyChange, capOutput, fileTree, isInProject, proposeEdit, proposeWrite, readForModel, runCommand, toRelative, } from "../commands/index.js";
+import { applyChange, capOutput, fileTree, isInProject, proposeEdit, proposeEdits, proposeWrite, readForModel, runCommand, toRelative, } from "../commands/index.js";
 import { describe, keyHint } from "../providers/index.js";
 import { newCallId } from "../providers/ids.js";
 import { globFiles, grep } from "../search/index.js";
 /** Model requests per user message before stopping; real tasks (explore, edit, test, fix) take a few dozen. */
 const MAX_STEPS = 60;
+/** Tries per model request when it fails for a passing reason (see withRetries). */
+const RETRIES = 6;
+/** Errors worth retrying: overloaded, rate limited, a server error, a dropped or timed-out connection. */
+function transient(error) {
+    const status = Number(error?.status ?? error?.statusCode);
+    if (status === 408 || status === 409 || status === 429 || status >= 500)
+        return true;
+    if (status >= 400)
+        return false;
+    const text = String(error?.message ?? error);
+    if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|Invalid URL|api key|unauthori[sz]ed/i.test(text))
+        return false;
+    return /overloaded|rate.?limit|too many requests|ECONNRESET|socket hang up|ETIMEDOUT|timed? ?out|EPIPE|network|premature close|terminated|\b(429|5\d\d)\b/i.test(text);
+}
 /** Messages kept word for word when older ones are summarized. */
 const KEEP_RECENT = 8;
 const TRIMMED_OUTPUT = "\n[... trimmed to save context; run the tool again if you need it]";
@@ -24,6 +39,13 @@ How to work:
 4. Keep going until the task is done. The user approves each edit and command as it happens, so don't stop to ask permission between steps; ask only when the request is unclear or you need a decision.
 5. End with a short summary of what you changed and why. When the user only asks a question, answer it without editing anything.
 
+- Make independent calls together: several reads or searches in one response run at the same time.
+- Use grep, glob and read_file to look around, not run_command with grep, find or cat. Several edits to one file go in one multi_edit.
+- If an edit fails twice, read the file again before the next try.
+- For work with three or more steps, keep a plan with update_plan and update it as you go.
+- Don't commit, push, install packages or delete files unless the user asked. Don't add comments the code didn't need.
+- Before saying something works, check it (run the tests or the code). If you couldn't, say so.
+- When the user asks where something is, or to show, open or find something, search for it (grep, glob), read enough to be sure, then call open_file on the exact place (with line and end_line) so it opens in their code view, and answer in a sentence or two with path:line.
 - If the user rejects an edit or command, don't retry it: ask what they would like instead.
 - Keep replies short. Refer to code as path:line.
 
@@ -66,6 +88,11 @@ export class Agent {
         this.hooks = hooks;
     }
     configure(options) {
+        // A different system prompt or tool list (an MCP server connected, a plugin switched) changes what the
+        // earlier thinking was written against: newer Claude models reject replaying it, so it's dropped.
+        const toolsChanged = options.extraTools && options.extraTools.map((t) => t.definition.name).join() !== this.extraTools.map((t) => t.definition.name).join();
+        if (this.messages.length && ((options.system !== undefined && options.system !== this.system) || toolsChanged))
+            this.forgetThinking();
         if (options.system !== undefined)
             this.system = options.system;
         if (options.extraTools)
@@ -123,6 +150,8 @@ export class Agent {
                 trimmed++;
             }
         }
+        if (trimmed)
+            this.forgetThinking();
         if (!force && this.requestSize() <= budget * 0.8) {
             this.hooks.onEntry({ kind: "info", text: `Trimmed ${trimmed} old tool outputs to fit the model's context.` });
             return true;
@@ -140,6 +169,7 @@ export class Agent {
                 throw error;
             summary = `(The earlier conversation was dropped to fit the context; summarizing it failed: ${error.message})`;
         }
+        this.forgetThinking();
         const intro = `[Summary of the conversation so far]\n${summary}`;
         const rest = this.messages.slice(split);
         const first = rest[0];
@@ -152,6 +182,26 @@ export class Agent {
         });
         return true;
     }
+    /**
+     * Drops Claude's thinking blocks from the history. Newer Claude models reject a conversation whose
+     * earlier turns were edited while it still carries their thinking blocks (they're tied to the exact
+     * history they were written in), and trimming or summarizing is such an edit. Without them the model
+     * carries on from the visible text and tool calls, which is what the trimmed history holds anyway.
+     */
+    forgetThinking() {
+        this.messages = this.messages.map((m) => {
+            if (m.role !== "assistant" || m.raw?.provider !== "anthropic" || !Array.isArray(m.raw.data))
+                return m;
+            const kept = m.raw.data.filter((b) => b.type !== "thinking" && b.type !== "redacted_thinking");
+            if (kept.length === m.raw.data.length)
+                return m;
+            if (kept.length)
+                return { ...m, raw: { ...m.raw, data: kept } };
+            const plain = { ...m };
+            delete plain.raw;
+            return plain;
+        });
+    }
     /**
      * Where to cut the history for a summary: as late as possible while keeping the last few messages, and
      * only before a user or assistant message, so no tool call is separated from its result.
@@ -198,22 +248,26 @@ export class Agent {
         this.controller = new AbortController();
         const { signal } = this.controller;
         try {
+            let cutOff = 0;
             for (let step = 0; step < MAX_STEPS; step++) {
                 if (this.requestSize() > this.contextBudget())
                     await this.compact(false, signal);
                 this.hooks.onBusy(`Pondering with ${describe(this.choice)}...`);
                 let streamed = "";
-                const result = await this.choice.provider.chat({
-                    model: this.choice.model,
-                    system: this.system,
-                    messages: this.messages,
-                    tools: this.tools,
-                    signal,
-                    ...(this.effort ? { effort: this.effort } : {}),
-                    onText: (delta) => {
-                        streamed += delta;
-                        this.hooks.onStream(streamed);
-                    },
+                const result = await this.withRetries(signal, () => {
+                    streamed = "";
+                    return this.choice.provider.chat({
+                        model: this.choice.model,
+                        system: this.system,
+                        messages: this.messages,
+                        tools: this.tools,
+                        signal,
+                        ...(this.effort ? { effort: this.effort } : {}),
+                        onText: (delta) => {
+                            streamed += delta;
+                            this.hooks.onStream(streamed);
+                        },
+                    });
                 });
                 this.hooks.onStream("");
                 // Tool-call ids must be unique across the conversation (results are matched by id, and some APIs
@@ -241,30 +295,51 @@ export class Agent {
                     return;
                 }
                 if (result.stop === "max_tokens") {
-                    this.hooks.onEntry({ kind: "error", text: "The response was cut off before its tool call finished. Try asking for a smaller change." });
-                    this.dropUnansweredCalls();
-                    return;
+                    // The reply ran out of room mid tool call (usually a whole file in one write): tell the model and
+                    // let it try in smaller pieces, a couple of times, before giving up.
+                    if (++cutOff > 2) {
+                        this.hooks.onEntry({ kind: "error", text: "The response was cut off before its tool call finished, again. Try asking for a smaller change." });
+                        this.dropUnansweredCalls();
+                        return;
+                    }
+                    for (const call of result.toolCalls) {
+                        this.messages.push({ role: "tool", callId: call.id, name: call.name, isError: true,
+                            content: "Not run: your response hit the output limit before this call was complete. Make the change in smaller steps (edit_file or multi_edit with only the lines that change, not the whole file)." });
+                    }
+                    continue;
                 }
                 if (result.toolCalls.length === 0)
                     return;
-                for (const call of result.toolCalls) {
-                    if (signal.aborted)
-                        break;
-                    this.hooks.onBusy(`Running ${call.name}...`);
-                    const problem = invalidArgs(call, this.tools);
-                    const output = problem ?? capOutput(await this.runTool(call));
-                    this.messages.push({
-                        role: "tool",
-                        callId: call.id,
-                        name: call.name,
-                        content: problem ? `Error: ${problem}` : output,
-                        ...(problem ? { isError: true } : {}),
+                // Calls that only look (reads, searches) run together; the rest run one at a time, in order,
+                // since they may ask you first or change what a later call sees. Results keep the calls' order.
+                const calls = result.toolCalls;
+                for (let i = 0; i < calls.length && !signal.aborted;) {
+                    let j = i + 1;
+                    if (this.onlyLooks(calls[i]))
+                        while (j < calls.length && this.onlyLooks(calls[j]))
+                            j++;
+                    const batch = calls.slice(i, j);
+                    this.hooks.onBusy(batch.length > 1 ? `Running ${batch.length} tools...` : `Running ${batch[0].name}...`);
+                    const outputs = await Promise.all(batch.map(async (call) => {
+                        const problem = invalidArgs(call, this.tools);
+                        return problem ? { error: `Error: ${problem}` } : { output: capOutput(await this.runTool(call)) };
+                    }));
+                    batch.forEach((call, k) => {
+                        const out = outputs[k];
+                        this.messages.push({
+                            role: "tool",
+                            callId: call.id,
+                            name: call.name,
+                            content: "error" in out ? out.error : out.output,
+                            ...("error" in out ? { isError: true } : {}),
+                        });
                     });
+                    i = j;
                 }
                 if (signal.aborted)
                     throw new Error("aborted");
             }
-            this.hooks.onEntry({ kind: "error", text: `Stopped after ${MAX_STEPS} steps.` });
+            this.hooks.onEntry({ kind: "error", text: `Paused after ${MAX_STEPS} steps so it doesn't run away. Say "continue" to let it carry on.` });
         }
         catch (error) {
             this.hooks.onStream("");
@@ -296,6 +371,40 @@ export class Agent {
             }
         }
     }
+    /**
+     * Runs a model request again when it failed for a passing reason (overloaded, rate limited, a server
+     * error, a dropped connection), waiting longer each time. Setup problems (a bad key, a URL that doesn't
+     * answer) fail straight away: waiting won't fix them, and the app shows where to.
+     */
+    async withRetries(signal, request) {
+        for (let attempt = 1;; attempt++) {
+            try {
+                return await request();
+            }
+            catch (error) {
+                if (signal.aborted || attempt >= RETRIES || !transient(error))
+                    throw error;
+                const after = Number(error?.headers?.get?.("retry-after") ?? error?.headers?.["retry-after"]);
+                const wait = Math.min(30_000, after > 0 ? after * 1000 : 1000 * 2 ** (attempt - 1) + Math.random() * 500);
+                this.hooks.onStream("");
+                this.hooks.onBusy(`${describe(this.choice)}: ${String(error?.message ?? error).slice(0, 60)}. Retrying in ${Math.ceil(wait / 1000)}s (${attempt}/${RETRIES - 1})...`);
+                await new Promise((resolve) => {
+                    const timer = setTimeout(resolve, wait);
+                    signal.addEventListener("abort", () => (clearTimeout(timer), resolve()), { once: true });
+                });
+                if (signal.aborted)
+                    throw error;
+            }
+        }
+    }
+    /** Tools that only read, which can run alongside each other. */
+    onlyLooks(call) {
+        if (["grep", "glob", "list_files", "get_file_tree"].includes(call.name))
+            return true;
+        if (call.name === "read_file")
+            return typeof call.args.path === "string" && isInProject(call.args.path);
+        return this.extraTools.some((t) => t.definition.name === call.name && t.readOnly);
+    }
     async runTool(call) {
         const { name, args } = call;
         try {
@@ -309,11 +418,25 @@ export class Agent {
                         }
                     }
                     else {
-                        this.hooks.onRead(toRelative(args.path));
+                        const from = Number(args.offset) > 1 ? Math.floor(Number(args.offset)) : undefined;
+                        const count = Number(args.limit) > 0 ? Math.floor(Number(args.limit)) : undefined;
+                        this.hooks.onRead(toRelative(args.path), from ?? (count ? 1 : undefined), count ? (from ?? 1) + count - 1 : undefined);
                     }
                     this.hooks.onEntry({ kind: "tool", text: `Read ${args.path}` });
                     return await readForModel(args.path, args.offset, args.limit);
                 }
+                case "open_file": {
+                    const file = toRelative(String(args.path));
+                    if (!isInProject(file))
+                        return "Error: only files in the project can be shown.";
+                    if (!existsSync(file) || !statSync(file).isFile())
+                        return `Error: ${file} is not a file. Find it with glob first.`;
+                    const line = Number(args.line) > 0 ? Math.floor(Number(args.line)) : undefined;
+                    const to = line && Number(args.end_line) >= line ? Math.floor(Number(args.end_line)) : line;
+                    this.hooks.onOpen?.(file, line, to);
+                    this.hooks.onEntry({ kind: "tool", text: `Opened ${file}${line ? `:${line}${to && to !== line ? `-${to}` : ""}` : ""}` });
+                    return this.hooks.onOpen ? "It is now open in the user's code view." : "This interface can't show files; give the user the path instead.";
+                }
                 case "list_files":
                 case "get_file_tree": {
                     this.hooks.onEntry({ kind: "tool", text: `Listed ${args.path ?? "."}` });
@@ -335,12 +458,21 @@ export class Agent {
                     return globFiles(String(args.pattern), typeof args.path === "string" ? args.path : ".");
                 }
                 case "edit_file":
+                case "multi_edit":
                 case "write_file": {
+                    if (name === "multi_edit" && (!Array.isArray(args.edits) || !args.edits.length))
+                        return "Error: edits must be a list of {old_string, new_string}.";
                     const change = name === "edit_file"
                         ? await proposeEdit(args.path, args.old_string, args.new_string, args.replace_all === true)
-                        : await proposeWrite(args.path, args.content ?? "");
+                        : name === "multi_edit" ? await proposeEdits(args.path, args.edits) : await proposeWrite(args.path, args.content ?? "");
                     return await this.reviewChange(change);
                 }
+                case "update_plan": {
+                    const steps = Array.isArray(args.steps) ? args.steps : [];
+                    const mark = { done: "✓", in_progress: "▸", pending: "○" };
+                    this.hooks.onEntry({ kind: "tool", text: `Plan:\n${steps.map((st) => `${mark[st.status] ?? "○"} ${st.step}`).join("\n")}` });
+                    return "Plan updated.";
+                }
                 case "run_command": {
                     const ok = await this.hooks.approve({ kind: "command", command: args.command });
                     if (!ok) {
@@ -348,7 +480,9 @@ export class Agent {
                         return "User denied permission to run this command.";
                     }
                     this.hooks.onEntry({ kind: "tool", text: `Ran: ${args.command}` });
-                    const output = await runCommand(args.command);
+                    // Timeouts are in seconds; a model that sends milliseconds still gets a sensible limit.
+                    const seconds = Number(args.timeout) > 0 ? Number(args.timeout) : 0;
+                    const output = await runCommand(args.command, seconds ? (seconds > 3600 ? seconds : seconds * 1000) : undefined, this.controller?.signal);
                     return output.trim() || "(no output)";
                 }
                 default: {
@@ -378,10 +512,12 @@ export class Agent {
             return "User rejected this change. Ask them what they would like instead.";
         }
         const result = await applyChange(change);
-        this.hooks.onChange(change, "applied", this.turnId);
         this.hooks.onEntry({ kind: "tool", text: result });
-        if (result.startsWith("Failed"))
+        if (result.startsWith("Failed")) {
+            this.hooks.onChange(change, "rejected", this.turnId);
             return result;
+        }
+        this.hooks.onChange(change, "applied", this.turnId);
         this.hooks.onBusy(`Checking ${change.path} for problems...`);
         const problems = await this.hooks.checkChange?.(change).catch(() => null);
         if (problems)

package/dist/src/cli.js

@@ -0,0 +1,115 @@
+// The whole command line program; index.ts loads it once the environment is ready.
+import { createElement } from "react";
+import { render } from "ink";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { artWork } from "./util/index.js";
+import { ensureProjectContext, loadPermanentContext } from "./context/index.js";
+import { describe, initialModel, resolveModel, saveModel } from "./providers/index.js";
+import { isTrustedFolder, loadSettings, saveSettings } from "./config/index.js";
+import { loadCredentials } from "./config/credentials.js";
+import { borrowToolConfig, ensureLocalModel, pickStartingModel } from "./setup/index.js";
+import { checkForUpdate, currentVersion, installUpdate, relaunch } from "./update/index.js";
+import { lsp } from "./lsp/index.js";
+import { App } from "./ui/App.js";
+import { installFastOutput } from "./ui/fast-output.js";
+import { RENDER_OPTIONS } from "./ui/render-options.js";
+const HELP = `nou ${currentVersion()}: an AI coding assistant for your terminal
+
+Usage:
+  nou              open Nou in the current folder
+  nou update       update to the latest version
+  nou --version    print the version
+  nou --help       show this help
+
+Settings live in ~/.nou/config.json (or press s inside Nou); keys you enter there, or with /connect, in ~/.nou/credentials.json. Set NOU_NO_UPDATE_CHECK=1 to skip update checks.`;
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--version") || args.includes("-v")) {
+        console.log(currentVersion());
+        return;
+    }
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(HELP);
+        return;
+    }
+    if (args[0] === "update") {
+        const latest = await checkForUpdate({ force: true, timeout: 10_000 });
+        if (!latest) {
+            console.log(`nou ${currentVersion()} is up to date.`);
+            return;
+        }
+        console.log(`Updating nou ${currentVersion()} → ${latest}...`);
+        if (await installUpdate(latest))
+            process.exit(0);
+        if (process.platform !== "win32")
+            console.log("If that was a permissions error, run: sudo npm install -g nou-cli@latest");
+        process.exit(1);
+    }
+    if (!process.stdin.isTTY) {
+        console.error("Nou needs an interactive terminal (try Windows Terminal, PowerShell, or Terminal/iTerm on macOS).");
+        process.exit(1);
+    }
+    p.intro(chalk.cyan(`${artWork} \n Hello I am Nou! 🌞  ${chalk.dim(`v${currentVersion()}`)}`));
+    // A folder's files can run things (its MCP servers, plugins, the commands Nou is asked to run), so a
+    // folder is trusted once, like Claude Code and VS Code ask.
+    if (!isTrustedFolder()) {
+        const here = process.cwd();
+        p.log.warn(`Nou will read the files in ${chalk.bold(here)} and can run its MCP servers and plugins, and commands you approve.`);
+        const trust = await p.confirm({ message: "Do you trust the files in this folder?" });
+        if (trust !== true) {
+            p.outro("OK, not opening it. Run nou in a folder you trust.");
+            return;
+        }
+        saveSettings({ trustedFolders: [...loadSettings().trustedFolders, here] });
+    }
+    const latest = await checkForUpdate();
+    if (latest) {
+        const update = await p.confirm({ message: `Nou ${chalk.green(latest)} is available (you have ${currentVersion()}). Update now?` });
+        if (update === true) {
+            const ok = await installUpdate(latest);
+            if (ok) {
+                p.log.success(`Updated to ${latest}. Restarting...`);
+                relaunch();
+                return;
+            }
+            p.log.warn(process.platform === "win32"
+                ? "The update failed. You can retry later with: npm install -g nou-cli@latest"
+                : "The update failed. If it was a permissions error, run: sudo npm install -g nou-cli@latest");
+        }
+    }
+    const settings = loadSettings();
+    loadCredentials(); // keys entered inside Nou, for whatever the environment and .env leave unset
+    const borrowed = settings.reuseToolConfig ? borrowToolConfig() : [];
+    for (const b of borrowed)
+        p.log.info(`Using the ${b.provider === "anthropic" ? "Anthropic" : "OpenAI"} API key from your ${b.tool} settings.`);
+    let choice = initialModel();
+    // First run: start with a model that's already here, if there is one.
+    if (!process.env.NOU_MODEL && !settings.model) {
+        const picked = await pickStartingModel(borrowed);
+        if (picked) {
+            choice = picked;
+            saveModel(picked);
+        }
+    }
+    const problem = choice.provider.unavailable();
+    if (problem) {
+        p.log.warn(`${choice.provider.label} isn't set up (${problem}), falling back to local Ollama.`);
+        choice = resolveModel("ollama");
+    }
+    const ready = await ensureLocalModel(choice);
+    if (ready !== choice)
+        saveModel(ready); // picked a model that's already installed instead
+    choice = ready;
+    p.log.info(`Model: ${chalk.yellow(describe(choice))}  (change it any time with /model)`);
+    // NOU.md is for Nou's own engine; the others read their own files (CLAUDE.md, AGENTS.md).
+    if ((settings.engine ?? "nou") === "nou")
+        await ensureProjectContext(choice);
+    const permContext = await loadPermanentContext();
+    await installFastOutput();
+    const app = render(createElement(App, { initialModel: choice, permContext }), RENDER_OPTIONS);
+    await app.waitUntilExit();
+    lsp.stopAll();
+    p.outro(chalk.cyan("Bye bye!"));
+}
+main().catch(console.error);