nou-cli 0.0.0-stage → 0.2.0

package/.env.example

@@ -0,0 +1,24 @@
+# Copy to .env and fill in only the providers you use. .env is gitignored.
+
+# Pick the starting model as provider:model (or switch in the app with /model).
+# NOU_MODEL=ollama:qwen3:8b
+# NOU_MODEL=anthropic:claude-opus-5-5
+
+# --- Local ---
+# OLLAMA_HOST=http://127.0.0.1:11434
+# LMSTUDIO_BASE_URL=http://localhost:1234/v1
+# LLAMACPP_BASE_URL=http://localhost:8080/v1
+# Any other OpenAI-compatible server (vLLM, Jan, LocalAI, ...):
+# NOU_BASE_URL=http://localhost:8000/v1
+# NOU_API_KEY=
+
+# --- Cloud ---
+# ANTHROPIC_API_KEY=
+# OPENAI_API_KEY=
+# GEMINI_API_KEY=
+# OPENROUTER_API_KEY=
+# GROQ_API_KEY=
+# DEEPSEEK_API_KEY=
+
+# Claude effort level: low | medium | high | xhigh | max (default high)
+# NOU_EFFORT=high

package/README.md

@@ -1,3 +1,164 @@
-# Temporary Holding Version
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JorgeOchoaReyes/nou/HEAD/docs/banner.svg" alt="Nou: your AI coding companion, right in the terminal" width="100%">
+</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<p align="center">
+  <a href="https://www.npmjs.com/package/nou-cli"><img src="https://img.shields.io/npm/v/nou-cli?style=for-the-badge&color=bb9af7&labelColor=1a1b26&logo=npm&logoColor=white" alt="npm version"></a>
+  <a href="https://github.com/JorgeOchoaReyes/nou/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/JorgeOchoaReyes/nou/ci.yml?branch=master&style=for-the-badge&label=CI&labelColor=1a1b26&color=9ece6a&logo=githubactions&logoColor=white" alt="CI"></a>
+  <img src="https://img.shields.io/node/v/nou-cli?style=for-the-badge&color=7dcfff&labelColor=1a1b26&logo=nodedotjs&logoColor=white" alt="node version">
+  <img src="https://img.shields.io/npm/l/nou-cli?style=for-the-badge&color=e0af68&labelColor=1a1b26" alt="license">
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Ollama-local-9ece6a?style=flat-square&logo=ollama&logoColor=white&labelColor=1a1b26" alt="Ollama">
+  <img src="https://img.shields.io/badge/LM%20Studio-local-9ece6a?style=flat-square&labelColor=1a1b26" alt="LM Studio">
+  <img src="https://img.shields.io/badge/Claude-cloud-bb9af7?style=flat-square&logo=anthropic&logoColor=white&labelColor=1a1b26" alt="Claude">
+  <img src="https://img.shields.io/badge/OpenAI-cloud-bb9af7?style=flat-square&labelColor=1a1b26" alt="OpenAI">
+  <img src="https://img.shields.io/badge/Gemini-cloud-bb9af7?style=flat-square&logo=googlegemini&logoColor=white&labelColor=1a1b26" alt="Gemini">
+  <img src="https://img.shields.io/badge/OpenRouter%20·%20Groq%20·%20DeepSeek-cloud-bb9af7?style=flat-square&labelColor=1a1b26" alt="More providers">
+</p>
+
+<p align="center">
+  <b>An IDE that lives in your terminal.</b> Browse your code, watch the AI's edits as live side-by-side diffs,<br>
+  approve them with a keypress, edit files yourself, and switch between local and cloud models on the fly.
+</p>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JorgeOchoaReyes/nou/HEAD/docs/screenshot.svg" alt="Nou proposing an edit as a side-by-side diff, with the file tree and chat" width="100%">
+</p>
+
+---
+
+## ⚡ Quick start
+
+```bash
+npm install -g nou-cli
+cd your-project
+nou
+```
+
+> [!TIP]
+> Want it fully local and free? Install [Ollama](https://ollama.com), run `ollama pull qwen3:8b`, and you're set. That's the default model.
+
+Needs **Node 22.12+** and an interactive terminal (Windows Terminal, PowerShell, macOS/Linux terminals).
+
+## ✨ What it does
+
+| | |
+| --- | --- |
+| 🗂️ **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**. |
+| ↶ **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. |
+| 🩺 **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…). |
+| 🧭 **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`. |
+| 🔌 **Any model** | Local (Ollama, LM Studio, llama.cpp) or cloud (Claude, OpenAI, Gemini, OpenRouter, Groq, DeepSeek). Switch mid-conversation. |
+| 🧩 **Plugins** | Add your own tools and slash commands with a single file. |
+| 🔎 **Quick open** | <kbd>Ctrl</kbd>+<kbd>P</kbd> fuzzy-finds any file. |
+
+Every change is reviewed like a code review:
+
+```diff
+ function resolveInProject(filePath: string): string {
+-  const fullPath = path.resolve(process.cwd(), filePath);
++  const root = realpathSync(process.cwd());
++  const fullPath = path.resolve(root, filePath);
+```
+
+## ⌨️ Keys
+
+| Key | Does |
+| --- | --- |
+| <kbd>Tab</kbd> | switch between files, code and chat |
+| <kbd>Ctrl</kbd>+<kbd>P</kbd> | fuzzy-find a file |
+| <kbd>e</kbd> | edit the open file (<kbd>Ctrl</kbd>+<kbd>S</kbd> save · <kbd>Ctrl</kbd>+<kbd>Z</kbd>/<kbd>Y</kbd> undo/redo · <kbd>Ctrl</kbd>+<kbd>K</kbd> info · <kbd>Ctrl</kbd>+<kbd>G</kbd> definition · <kbd>Esc</kbd> close) |
+| <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` (or Nou's last edit) · <kbd>n</kbd>/<kbd>N</kbd> jump between changes |
+| <kbd>c</kbd> | in the file tree: show only changed files |
+| <kbd>f</kbd> | follow mode: jump to files as Nou reads and edits them |
+| <kbd>s</kbd> | settings: model, preferences, plugins |
+| <kbd>y</kbd> / <kbd>n</kbd> | accept / reject a proposed edit or command |
+| <kbd>Esc</kbd> | stop Nou · close a diff · back to chat |
+| <kbd>Ctrl</kbd>+<kbd>C</kbd> | stop Nou while it works · press twice to quit |
+
+Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/undo` · `/rewind` · `/history` · `/problems` · `/clear` · `/help`
+
+## 🧠 Models
+
+Pick one in <kbd>s</kbd> settings, with `/model anthropic` or `/model ollama:qwen3:8b`, or set `NOU_MODEL=provider:model`. API keys come from your environment or a `.env` file in your project; see [.env.example](.env.example).
+
+<details>
+<summary><b>All providers and how to set them up</b></summary>
+
+| Provider | Type | Setup |
+| --- | --- | --- |
+| 🦙 Ollama *(default)* | 🟢 local | runs locally · `OLLAMA_HOST` to change |
+| 🖥️ LM Studio | 🟢 local | start its local server |
+| ⚙️ llama.cpp server | 🟢 local | start `llama-server` |
+| 🔧 Any OpenAI-compatible server | 🟢 local | `NOU_BASE_URL`, optional `NOU_API_KEY` |
+| 🟣 Anthropic (Claude) | ☁️ cloud | `ANTHROPIC_API_KEY` |
+| ⚪ OpenAI | ☁️ cloud | `OPENAI_API_KEY` |
+| 🔷 Google Gemini | ☁️ cloud | `GEMINI_API_KEY` |
+| 🔀 OpenRouter | ☁️ cloud | `OPENROUTER_API_KEY` |
+| ⚡ Groq | ☁️ cloud | `GROQ_API_KEY` |
+| 🐋 DeepSeek | ☁️ cloud | `DEEPSEEK_API_KEY` |
+
+</details>
+
+## 🔄 Updating
+
+Nou checks npm once a day and offers to update when a new version is out (one keypress, then it restarts itself). Or run it yourself:
+
+```bash
+nou update          # or: npm install -g nou-cli@latest
+nou --version
+```
+
+Set `NOU_NO_UPDATE_CHECK=1` to turn the check off.
+
+## 🧩 Plugins *(early)*
+
+Drop a `.js` / `.mjs` file into `.nou/plugins/` (this project) or `~/.nou/plugins/` (everywhere), then switch it on in <kbd>s</kbd> settings → **Plugins**. A plugin can give the model new tools, add slash commands, add to the system prompt, and add **checkers** (linters) whose problems show in the editor. The built-in ESLint, TypeScript, Ruff, syntax and language-server checkers are plugins too, so you can switch any of them off.
+
+```js
+export default {
+  name: "word-count",
+  tools: [{ readOnly: true, definition: { name: "word_count", /* ... */ }, run: (args) => "42 words" }],
+  commands: [{ name: "wc", description: "Count words", run: (args) => "42 words" }],
+  diagnostics: [{
+    id: "todo", name: "TODOs", checksText: true, matches: (f) => f.endsWith(".ts"), available: () => true,
+    check: async (file, text) => text.split("\n").flatMap((l, i) => l.includes("TODO")
+      ? [{ file, line: i + 1, col: 1, severity: "info", message: "TODO left here", source: "todo" }] : []),
+  }],
+};
+```
+
+Full example: [examples/plugins/word-count.mjs](examples/plugins/word-count.mjs).
+
+> [!WARNING]
+> Plugins run code on your machine, so they stay **off** until you enable them.
+
+## 🛠️ Development
+
+```bash
+npm install
+npm run dev          # run from source
+npm run build        # compile to dist/ (and copy the syntax grammars)
+npm test             # end-to-end tests: drives the real UI with simulated keys
+npm run screenshot   # regenerate docs/screenshot.svg
+```
+
+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`.
+
+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.
+- **Dependabot** opens weekly PRs for dependency and GitHub Actions updates.
+- **CodeQL** scans for security issues on every PR and weekly.
+- **npm audit** fails CI if a dependency users install has a high-severity vulnerability.
+
+<p align="center"><sub>Made with 🌞 by <a href="https://github.com/JorgeOchoaReyes">Jorge Ochoa-Reyes</a></sub></p>

package/dist/index.js

@@ -0,0 +1,84 @@
+#!/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 } from "./src/providers/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";
+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). 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");
+        }
+    }
+    let choice = initialModel();
+    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");
+    }
+    p.log.info(`Model: ${chalk.yellow(describe(choice))}  (change it any time with /model)`);
+    await ensureProjectContext(choice);
+    const permContext = await loadPermanentContext();
+    // Ctrl+C is handled inside the app: press it twice to quit, so a stray press doesn't lose work.
+    const app = render(createElement(App, { initialModel: choice, permContext }), {
+        alternateScreen: true,
+        exitOnCtrlC: false,
+    });
+    await app.waitUntilExit();
+    lsp.stopAll();
+    p.outro(chalk.cyan("Bye bye!"));
+}
+main().catch(console.error);

package/dist/src/agent/index.js

@@ -0,0 +1,246 @@
+import { toolDefs } from "../tools/index.js";
+import { applyChange, fileTree, proposeEdit, proposeWrite, readFile, runCommand, toRelative, } from "../commands/index.js";
+import { describe } from "../providers/index.js";
+import { newCallId } from "../providers/ids.js";
+const MAX_STEPS = 25;
+export function buildSystemPrompt(permContext, extras = []) {
+    return `You are Nou, a coding assistant running in the user's terminal, working in ${process.cwd()}.
+You can read, edit and create files and run commands with the tools you have.
+- Read a file before editing it. Prefer edit_file for small changes and write_file for new files.
+- Every edit and command is shown to the user, who approves or rejects it.
+- Keep replies short and to the point.
+
+Project files:
+${fileTree(".", 3)}
+${extras.map((e) => `\n${e}`).join("")}
+${permContext}`;
+}
+/** Checks required arguments are present before a tool runs (models, especially small local ones, skip them). */
+function invalidArgs(call, tools) {
+    if ("__invalid_json" in call.args)
+        return `The arguments were not valid JSON: ${JSON.stringify(call.args.__invalid_json)}`;
+    const def = tools.find((t) => t.name === call.name);
+    if (!def)
+        return null;
+    const missing = def.parameters.required.filter((key) => call.args[key] === undefined || call.args[key] === null);
+    return missing.length ? `Missing or non-string arguments: ${missing.join(", ")}` : null;
+}
+export class Agent {
+    choice;
+    system;
+    hooks;
+    messages = [];
+    controller = null;
+    extraTools = [];
+    effort;
+    notes = [];
+    /** Increments per user message; tags changes so a whole turn can be rewound. */
+    turn = 0;
+    /** Distinguishes this run from earlier ones, since turn numbers restart at 1 every session. */
+    session = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+    get turnId() {
+        return `${this.session}:${this.turn}`;
+    }
+    constructor(choice, system, hooks) {
+        this.choice = choice;
+        this.system = system;
+        this.hooks = hooks;
+    }
+    configure(options) {
+        if (options.system !== undefined)
+            this.system = options.system;
+        if (options.extraTools)
+            this.extraTools = options.extraTools;
+        if (options.effort)
+            this.effort = options.effort;
+    }
+    get tools() {
+        return [...toolDefs, ...this.extraTools.map((t) => t.definition)];
+    }
+    /** Switches model; the conversation carries over. */
+    setModel(choice) {
+        this.choice = choice;
+    }
+    clear() {
+        this.messages = [];
+        this.notes = [];
+    }
+    /** Something the model should know before the next message (e.g. the user undid its edit). */
+    note(text) {
+        this.notes.push(text);
+    }
+    cancel() {
+        this.controller?.abort();
+    }
+    /** `context` (what the user is looking at) is sent to the model but not shown in the chat. */
+    async send(text, context) {
+        this.turn++;
+        const notes = this.notes.length ? `${this.notes.map((n) => `[Note: ${n}]`).join("\n")}\n\n` : "";
+        this.notes = [];
+        this.messages.push({ role: "user", content: `${notes}${text}${context ? `\n\n${context}` : ""}` });
+        this.controller = new AbortController();
+        const { signal } = this.controller;
+        try {
+            for (let step = 0; step < MAX_STEPS; step++) {
+                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);
+                    },
+                });
+                this.hooks.onStream("");
+                // Tool-call ids must be unique across the conversation (results are matched by id, and some APIs
+                // reject duplicates). Some providers reuse ids, so rename any repeat. Claude's own copy of the turn
+                // (raw) keeps its ids, which the API guarantees are unique.
+                const used = new Set(this.messages.flatMap((m) => (m.role === "assistant" ? m.toolCalls.map((c) => c.id) : [])));
+                for (const call of result.toolCalls) {
+                    if (used.has(call.id) && !result.raw)
+                        call.id = newCallId();
+                    used.add(call.id);
+                }
+                this.messages.push({
+                    role: "assistant",
+                    content: result.text,
+                    toolCalls: result.toolCalls,
+                    ...(result.raw ? { raw: result.raw } : {}),
+                });
+                const visible = result.text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+                if (visible)
+                    this.hooks.onEntry({ kind: "assistant", text: visible });
+                if (result.stop === "refusal") {
+                    this.hooks.onEntry({ kind: "error", text: "The model declined this request." });
+                    this.dropUnansweredCalls();
+                    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;
+                }
+                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 ?? await this.runTool(call);
+                    this.messages.push({
+                        role: "tool",
+                        callId: call.id,
+                        name: call.name,
+                        content: problem ? `Error: ${problem}` : output,
+                        ...(problem ? { isError: true } : {}),
+                    });
+                }
+                if (signal.aborted)
+                    throw new Error("aborted");
+            }
+            this.hooks.onEntry({ kind: "error", text: `Stopped after ${MAX_STEPS} steps.` });
+        }
+        catch (error) {
+            this.hooks.onStream("");
+            if (signal.aborted) {
+                this.hooks.onEntry({ kind: "info", text: "Cancelled." });
+            }
+            else {
+                this.hooks.onEntry({ kind: "error", text: `${describe(this.choice)}: ${error.message}` });
+            }
+            this.dropUnansweredCalls();
+        }
+        finally {
+            this.controller = null;
+            this.hooks.onBusy(null);
+        }
+    }
+    /** Every tool call needs a result before the next request, or most APIs reject the history. */
+    dropUnansweredCalls() {
+        const answered = new Set(this.messages.flatMap((m) => (m.role === "tool" ? [m.callId] : [])));
+        for (const m of this.messages) {
+            if (m.role !== "assistant")
+                continue;
+            for (const call of m.toolCalls) {
+                if (answered.has(call.id))
+                    continue;
+                this.messages.push({ role: "tool", callId: call.id, name: call.name, content: "Not run: the turn was interrupted.", isError: true });
+                answered.add(call.id);
+            }
+        }
+    }
+    async runTool(call) {
+        const { name, args } = call;
+        try {
+            switch (name) {
+                case "read_file": {
+                    this.hooks.onRead(toRelative(args.path));
+                    this.hooks.onEntry({ kind: "tool", text: `Read ${args.path}` });
+                    return await readFile(args.path);
+                }
+                case "list_files":
+                case "get_file_tree": {
+                    this.hooks.onEntry({ kind: "tool", text: `Listed ${args.path ?? "."}` });
+                    return fileTree(args.path ?? ".", 4);
+                }
+                case "edit_file":
+                case "write_file": {
+                    const change = name === "edit_file"
+                        ? await proposeEdit(args.path, args.old_string, args.new_string)
+                        : await proposeWrite(args.path, args.content ?? "");
+                    return await this.reviewChange(change);
+                }
+                case "run_command": {
+                    const ok = await this.hooks.approve({ kind: "command", command: args.command });
+                    if (!ok) {
+                        this.hooks.onEntry({ kind: "tool", text: `Denied: ${args.command}` });
+                        return "User denied permission to run this command.";
+                    }
+                    this.hooks.onEntry({ kind: "tool", text: `Ran: ${args.command}` });
+                    const output = await runCommand(args.command);
+                    return output.trim() || "(no output)";
+                }
+                default: {
+                    const extra = this.extraTools.find((t) => t.definition.name === name);
+                    if (!extra)
+                        return `Unknown tool: ${name}`;
+                    if (!extra.readOnly && !(await this.hooks.approve({ kind: "tool", name, args }))) {
+                        this.hooks.onEntry({ kind: "tool", text: `Denied: ${name}` });
+                        return "User denied permission to run this tool.";
+                    }
+                    this.hooks.onEntry({ kind: "tool", text: `${extra.source}: ${name}${args.path ? ` ${args.path}` : ""}` });
+                    return String(await extra.run(args));
+                }
+            }
+        }
+        catch (error) {
+            this.hooks.onEntry({ kind: "error", text: `${name}: ${error.message}` });
+            return `Error: ${error.message}`;
+        }
+    }
+    async reviewChange(change) {
+        this.hooks.onChange(change, "pending", this.turnId);
+        const ok = await this.hooks.approve({ kind: "change", change });
+        if (!ok) {
+            this.hooks.onChange(change, "rejected", this.turnId);
+            this.hooks.onEntry({ kind: "tool", text: `Rejected edit to ${change.path}` });
+            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"))
+            return result;
+        this.hooks.onBusy(`Checking ${change.path} for problems...`);
+        const problems = await this.hooks.checkChange?.(change).catch(() => null);
+        if (problems)
+            this.hooks.onEntry({ kind: "error", text: `New problems in ${change.path}:\n${problems}` });
+        return problems ? `${result}\n\nThis edit introduced problems; fix them:\n${problems}` : result;
+    }
+}