nou-cli 0.5.16 → 0.5.17

package/README.md

@@ -135,7 +135,7 @@ Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]`
 
 A small typo in a command still works when it only changes the screen (`/termnial` opens the terminal); for others Nou asks "Did you mean...?" instead of guessing.
 
-New lines in a message: <kbd>Shift</kbd>/<kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+<kbd>Enter</kbd> in terminals that report them (kitty, Ghostty, WezTerm, iTerm2 and others with the kitty keyboard protocol, which Nou checks for before it starts; also xterm's modifyOtherKeys form), or type `\` and press <kbd>Enter</kbd> in any terminal.
+New lines in a message: <kbd>Shift</kbd>/<kbd>Ctrl</kbd>/<kbd>Cmd</kbd>+<kbd>Enter</kbd> in terminals that report them (kitty, Ghostty, WezTerm, iTerm2 and others with the kitty keyboard protocol, which Nou checks for before it starts; also xterm's modifyOtherKeys form), or type `\` and press <kbd>Enter</kbd> in any terminal. On Windows, <kbd>Ctrl</kbd>+<kbd>Enter</kbd> works in every Windows Terminal and the console; <kbd>Shift</kbd>+<kbd>Enter</kbd> needs Windows Terminal 1.25 or later (older versions send it as a plain Enter).
 
 Conversations are saved per folder after each reply. `/resume` opens a picker (↑↓ and Enter, type to filter, or type its number) and `/resume 2` (or `nou --continue` for the last one, `nou --resume` for the list) picks one back up with the engine it was on: Nou's own engine restores its messages, Claude Code its session and Codex its thread; pi is handed the conversation so far. Sessions you started in Claude Code's or Codex's own CLI in this folder are listed too (marked "CLI"), and resuming one carries it on in that engine inside Nou.
 

package/dist/src/engines/claude.js

@@ -48,6 +48,7 @@ export class ClaudeCodeEngine extends ExternalEngine {
         super(choice, hooks, "Claude Code");
     }
     resetConversation() {
+        this.closeLive();
         this.claudeSession = undefined;
     }
     snapshot() {
@@ -57,6 +58,7 @@ export class ClaudeCodeEngine extends ExternalEngine {
     restore(state) {
         if (typeof state?.claudeSession !== "string")
             return false;
+        this.closeLive();
         this.claudeSession = state.claudeSession;
         return true;
     }
@@ -64,15 +66,45 @@ export class ClaudeCodeEngine extends ExternalEngine {
     setModel(choice) {
         this.choice = choice;
     }
-    async run(prompt, signal) {
-        const sdk = await loadPackage("@anthropic-ai/claude-agent-sdk");
-        const abortController = new AbortController();
-        signal.addEventListener("abort", () => abortController.abort());
+    dispose() {
+        this.closeLive();
+    }
+    /**
+     * One Claude Code process per conversation, kept running between messages: each message is fed into it
+     * and a turn is over at its result. A process per message didn't work: one that left something running
+     * (a dev server, a background command) never closed its stream, so the turn never ended, and the next
+     * message's process found the session still in use and ended without a word.
+     */
+    live = null;
+    /** The turn being waited on: settled at its result, or when the process ends. */
+    waiting = null;
+    streamed = "";
+    closeLive() {
+        const live = this.live;
+        this.live = null;
+        live?.close();
+    }
+    /** What the process was started with; a change (model, effort, project context) means a new one. */
+    liveKey() {
+        return JSON.stringify([this.choice.provider.id === "anthropic" ? this.choice.model : null, this.effort ?? null, this.extras]);
+    }
+    openLive(sdk, key) {
+        const queue = [];
+        let wake = null;
+        let closed = false;
+        const input = async function* () {
+            while (!closed) {
+                if (queue.length)
+                    yield queue.shift();
+                else
+                    await new Promise((resolve) => (wake = resolve));
+            }
+        };
         const allow = { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow" } };
         const deny = (reason) => ({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } });
-        const preToolUse = async (input) => {
-            const tool = input.tool_name;
-            const args = (input.tool_input ?? {});
+        const preToolUse = async (hookInput) => {
+            const tool = hookInput.tool_name;
+            const args = (hookInput.tool_input ?? {});
             if (EDIT_TOOLS.has(tool) && args.file_path) {
                 const ok = await this.tracker.approve(args.file_path, proposedContent(tool, args), tool);
                 return ok ? allow : deny("The user rejected this change. Ask them what they would like instead.");
@@ -86,9 +118,9 @@ export class ClaudeCodeEngine extends ExternalEngine {
             // Reads and searches follow Claude Code's own rules; anything else that needs asking reaches canUseTool.
             return {};
         };
-        const postToolUse = async (input) => {
-            const tool = input.tool_name;
-            const args = (input.tool_input ?? {});
+        const postToolUse = async (hookInput) => {
+            const tool = hookInput.tool_name;
+            const args = (hookInput.tool_input ?? {});
             if (EDIT_TOOLS.has(tool) && args.file_path) {
                 const problems = await this.tracker.applied(args.file_path);
                 return problems
@@ -109,10 +141,9 @@ export class ClaudeCodeEngine extends ExternalEngine {
             return {};
         };
         const query = sdk.query({
-            prompt,
+            prompt: input(),
             options: {
                 cwd: process.cwd(),
-                abortController,
                 ...(this.claudeSession ? { resume: this.claudeSession } : {}),
                 ...(this.choice.provider.id === "anthropic" ? { model: this.choice.model } : {}),
                 ...(this.effort && EFFORTS.has(this.effort) ? { effort: this.effort } : {}),
@@ -122,45 +153,124 @@ export class ClaudeCodeEngine extends ExternalEngine {
                 settingSources: ["project"],
                 systemPrompt: { type: "preset", preset: "claude_code", append: this.extras.join("\n\n") },
                 hooks: { PreToolUse: [{ hooks: [preToolUse] }], PostToolUse: [{ hooks: [postToolUse] }] },
-                canUseTool: async (tool, input) => {
-                    const ok = await this.hooks.approve({ kind: "tool", name: tool, args: input });
+                canUseTool: async (tool, toolInput) => {
+                    const ok = await this.hooks.approve({ kind: "tool", name: tool, args: toolInput });
                     if (!ok)
-                        this.hooks.onEntry({ kind: "tool", text: `Denied: ${describeTool(tool, input)}` });
-                    return ok ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: "The user denied this." };
+                        this.hooks.onEntry({ kind: "tool", text: `Denied: ${describeTool(tool, toolInput)}` });
+                    return ok ? { behavior: "allow", updatedInput: toolInput } : { behavior: "deny", message: "The user denied this." };
                 },
             },
         });
-        let streamed = "";
-        for await (const message of query) {
-            if (message.type === "system" && message.subtype === "init") {
-                this.claudeSession = message.session_id;
-            }
-            else if (message.type === "stream_event" && !message.parent_tool_use_id) {
-                const event = message.event;
-                if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
-                    streamed += event.delta.text;
-                    this.hooks.onStream(streamed);
+        const live = {
+            key,
+            query,
+            push: (text) => {
+                queue.push({ type: "user", message: { role: "user", content: text }, parent_tool_use_id: null, session_id: this.claudeSession ?? "" });
+                wake?.();
+                wake = null;
+            },
+            close: () => {
+                process.off("exit", live.close);
+                closed = true;
+                wake?.();
+                try {
+                    query.close?.();
                 }
+                catch {
+                    // already gone
+                }
+            },
+        };
+        process.once("exit", live.close); // Claude Code doesn't outlive Nou
+        // Reads everything Claude Code says, for as long as the process runs. Between turns that's what a
+        // background task it started brings back (it may carry on by itself); it goes to the chat too.
+        void (async () => {
+            let failure;
+            try {
+                for await (const message of query)
+                    this.handle(message, live);
             }
-            else if (message.type === "assistant" && !message.parent_tool_use_id) {
-                const text = message.message.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
-                streamed = "";
-                this.hooks.onStream("");
-                if (text)
-                    this.hooks.onEntry({ kind: "assistant", text });
-                this.hooks.onBusy("Claude Code is working...");
+            catch (error) {
+                failure = error instanceof Error ? error : new Error(String(error));
             }
-            else if (message.type === "result") {
-                this.claudeSession = message.session_id ?? this.claudeSession;
-                if (message.subtype !== "success" || message.is_error) {
-                    const detail = message.errors?.join("; ") || message.result || message.subtype;
-                    if (!signal.aborted)
-                        this.hooks.onEntry({ kind: "error", text: `Claude Code: ${detail}` });
-                }
-                // The turn is over: don't wait for Claude Code's process to close its stream as well. Something it
-                // left running (a background command, an MCP server) kept that open, and Nou "working" forever.
-                break;
+            finally {
+                if (this.live === live)
+                    this.live = null;
+                if (this.waiting?.live === live)
+                    this.waiting.done(failure ?? (closed ? undefined : new Error("Claude Code stopped before it answered.")));
             }
+        })();
+        return live;
+    }
+    handle(message, live) {
+        if (message.type === "system" && message.subtype === "init") {
+            this.claudeSession = message.session_id;
+        }
+        else if (message.type === "stream_event" && !message.parent_tool_use_id) {
+            const event = message.event;
+            if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+                this.streamed += event.delta.text;
+                this.hooks.onStream(this.streamed);
+            }
+        }
+        else if (message.type === "assistant" && !message.parent_tool_use_id) {
+            const text = message.message.content.filter((b) => b.type === "text").map((b) => b.text).join("").trim();
+            this.streamed = "";
+            this.hooks.onStream("");
+            if (text)
+                this.hooks.onEntry({ kind: "assistant", text });
+            if (this.waiting)
+                this.hooks.onBusy("Claude Code is working...");
+        }
+        else if (message.type === "result") {
+            this.claudeSession = message.session_id ?? this.claudeSession;
+            this.streamed = "";
+            this.hooks.onStream("");
+            if (message.subtype !== "success" || message.is_error) {
+                const detail = message.errors?.join("; ") || message.result || message.subtype;
+                // A turn you stopped ends with an error result; that isn't news.
+                if (!this.stopping)
+                    this.hooks.onEntry({ kind: "error", text: `Claude Code: ${detail}` });
+            }
+            this.stopping = false;
+            if (this.waiting?.live === live)
+                this.waiting.done();
+        }
+    }
+    stopping = false;
+    async run(prompt, signal) {
+        const sdk = await loadPackage("@anthropic-ai/claude-agent-sdk");
+        const key = this.liveKey();
+        if (this.live && this.live.key !== key)
+            this.closeLive();
+        const live = (this.live ??= this.openLive(sdk, key));
+        this.streamed = "";
+        let settle;
+        const finished = new Promise((resolve, reject) => (settle = (error) => (error ? reject(error) : resolve())));
+        const waiting = { live, done: (error) => settle(error) };
+        this.waiting = waiting;
+        // Stopping: Claude Code interrupts the turn and ends it with a result; if it doesn't promptly, the
+        // process goes (the next message starts a new one, resuming the session).
+        const onAbort = () => {
+            this.stopping = true;
+            Promise.resolve(live.query.interrupt?.()).catch(() => { });
+            setTimeout(() => {
+                if (this.waiting !== waiting)
+                    return;
+                if (this.live === live)
+                    this.closeLive();
+                waiting.done();
+            }, 3000);
+        };
+        signal.addEventListener("abort", onAbort);
+        try {
+            live.push(prompt);
+            await finished;
+        }
+        finally {
+            signal.removeEventListener("abort", onAbort);
+            if (this.waiting === waiting)
+                this.waiting = null;
         }
         if (signal.aborted)
             throw new Error("aborted");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nou-cli",
-  "version": "0.5.16",
+  "version": "0.5.17",
   "description": "Nou: an IDE-style AI coding assistant for your terminal. Local (Ollama, LM Studio) and cloud (Claude, OpenAI, Gemini...) models, live diffs, git-aware, built-in editor.",
   "type": "module",
   "bin": {