nou-cli 0.5.15 → 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/cli.js

@@ -16,9 +16,10 @@ import { installFastOutput } from "./ui/fast-output.js";
 import { RENDER_OPTIONS } from "./ui/render-options.js";
 import { setScreenClear } from "./ui/redraw.js";
 import { detectTerminal } from "./ui/background.js";
+import { setTerminalTitle } from "./ui/title.js";
 import { setPalette } from "./ui/theme.js";
 import { runHost, workspaceFolder } from "./workspaces/host.js";
-import { pendingWorkspaces } from "./workspaces/client.js";
+import { isHosted, pendingWorkspaces } from "./workspaces/client.js";
 import { spawn } from "child_process";
 import { appendFileSync, mkdirSync } from "fs";
 import path from "path";
@@ -97,6 +98,7 @@ async function main() {
         const uiTheme = loadSettings().uiTheme;
         // Every workspace uses the colors found for this terminal (they can't ask it themselves from the background).
         // The host asks the terminal once and tells every workspace (in the background they can't ask it).
+        setTerminalTitle();
         const term = await detectTerminal();
         process.env.NOU_PALETTE = uiTheme === "dark" || uiTheme === "light" ? uiTheme : term.palette ?? "dark";
         if (term.kitty !== null)
@@ -108,6 +110,9 @@ async function main() {
         console.error("Nou needs an interactive terminal (try Windows Terminal, PowerShell, or Terminal/iTerm on macOS).");
         process.exit(1);
     }
+    // The tab says Nou CLI, not the shell it runs in (a workspace's host already set it).
+    if (!isHosted())
+        setTerminalTitle();
     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.

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,42 +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}` });
-                }
+            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/dist/src/guide/index.js

@@ -148,8 +148,25 @@ export function showPlacesTool(onStops) {
         },
     };
 }
-/** The fenced block other engines (which can't call Nou's tools) list their places in. */
-const SHOW_BLOCK = /```nou-show\s*\n([\s\S]*?)\n```/;
+/**
+ * The fenced block other engines (which can't call Nou's tools) list their places in. Models also write it
+ * with ~~~, with CRLF, with the closing fence on the JSON's last line, or (unfenced) as a "nou-show" line
+ * followed by the JSON array at the end of the reply.
+ */
+const SHOW_BLOCK = /(?:```|~~~)[ \t]*nou-show[ \t]*\r?\n([\s\S]*?)\r?\n?[ \t]*(?:```|~~~)|(?:^|\n)[ \t]*nou-show[ \t]*\r?\n[ \t]*(\[[\s\S]*\])\s*$/;
+/**
+ * A reply as the chat shows it: Nou's blocks (nou-show, nou-steps) are for Nou, not you, so they're never
+ * drawn, including one still arriving mid-stream.
+ */
+export function hideNouBlocks(text) {
+    if (!text.includes("nou-"))
+        return text;
+    return text
+        .replace(/(?:```|~~~)[ \t]*nou-(?:show|steps)[ \t]*\r?\n[\s\S]*?(?:```|~~~)/g, "")
+        .replace(/(?:```|~~~)[ \t]*nou-(?:show|steps)[\s\S]*$/, "")
+        .replace(/(?:^|\n)[ \t]*nou-(?:show|steps)[ \t]*\r?\n[ \t]*\[[\s\S]*$/, "")
+        .trimEnd();
+}
 /**
  * For Claude Code, Codex and pi, which can't call show_places: how to point at places, added to what they
  * know about the project, so explaining "where does X happen" opens the files on any engine.
@@ -166,7 +183,7 @@ export function stopsFromReply(text) {
     if (!m)
         return null;
     try {
-        const stops = tidyStops(JSON.parse(m[1]));
+        const stops = tidyStops(JSON.parse((m[1] ?? m[2])));
         return { stops, rest: text.replace(m[0], "").trim() };
     }
     catch {

package/dist/src/ui/Chat.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { hideNouBlocks } from "../guide/index.js";
 import { memo, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useAnimation, useInput } from "ink";
 import { statSync } from "fs";
@@ -54,7 +55,7 @@ function entryLines(entry, inner, links = true) {
     }
     else if (entry.kind === "assistant") {
         out.push({ text: "◆ nou", color: C.accent2, bold: true, lead: BAR, leadColor: C.accent2 });
-        for (const line of renderMarkdown(entry.text, inner - 3, links ? isProjectFile : undefined)) {
+        for (const line of renderMarkdown(hideNouBlocks(entry.text), inner - 3, links ? isProjectFile : undefined)) {
             const color = line.kind === "heading" ? C.accent2 : line.kind === "quote" ? C.dim : undefined;
             out.push({ text: "", spans: line.spans, ...(color ? { color } : {}), lead: BAR, leadColor: C.accent2 });
         }

package/dist/src/ui/FileTree.js

@@ -192,6 +192,6 @@ export const FileTree = memo(function FileTree({ width, height, focused, openFil
                             const room = Math.max(1, inner - marker.length - 1);
                             const shown = label.length > room ? `${label.slice(0, room - 1)}…` : label.padEnd(room);
                             const iconAt = shown.indexOf(icon);
-                            return (_jsxs(Text, { wrap: "truncate-end", ...(selected && focused ? { backgroundColor: C.panel } : {}), children: [_jsx(Text, { ...(nameColor ? { color: nameColor } : {}), bold: isOpen, children: shown.slice(0, iconAt) }), _jsx(Text, { color: color, children: shown.slice(iconAt, iconAt + icon.length) }), working?.has(node.path) ? (_jsx(Text, { bold: true, inverse: selected && focused, children: gradient(shown.slice(iconAt + icon.length), frame).map((g, j) => _jsx(Text, { color: g.color, children: g.ch }, j)) })) : (_jsx(Text, { ...(nameColor ? { color: nameColor } : {}), bold: isOpen, inverse: selected && focused, children: shown.slice(iconAt + icon.length) })), _jsxs(Text, { color: markerColor, children: [" ", marker] })] }, node.path));
+                            return (_jsxs(Text, { wrap: "truncate-end", ...(isOpen ? { backgroundColor: C.openRow } : selected && focused ? { backgroundColor: C.panel } : {}), children: [_jsx(Text, { ...(nameColor ? { color: nameColor } : {}), bold: isOpen, children: shown.slice(0, iconAt) }), _jsx(Text, { color: color, children: shown.slice(iconAt, iconAt + icon.length) }), working?.has(node.path) ? (_jsx(Text, { bold: true, inverse: selected && focused, children: gradient(shown.slice(iconAt + icon.length), frame).map((g, j) => _jsx(Text, { color: g.color, children: g.ch }, j)) })) : (_jsx(Text, { ...(nameColor ? { color: nameColor } : {}), bold: isOpen, inverse: selected && focused, children: shown.slice(iconAt + icon.length) })), _jsxs(Text, { color: markerColor, children: [" ", marker] })] }, node.path));
                         })] }), _jsx(Scrollbar, { total: nodes.length, top: start, rows: rows, focused: focused })] }) }));
 });

package/dist/src/ui/theme.js

@@ -16,6 +16,8 @@ const DARK = {
     /** Lines around panes that aren't focused: quieter than text, since they aren't read. */
     border: "#565f89",
     panel: "#1f2335",
+    /** The band behind the file that's open, wherever it's listed: every name color stays 4.5:1 on it. */
+    openRow: "#2a3352",
     /** Text on a colored badge (CHAT, CLOUD, EDITING...). */
     onBadge: "#1a1b26",
 };
@@ -32,6 +34,7 @@ const LIGHT = {
     dim: "#5a607a",
     border: "#a8aecb",
     panel: "#e6e7ed",
+    openRow: "#edf1fc",
     onBadge: "#ffffff",
 };
 /** The colors in use: dark unless the terminal is light (see setPalette). Read at render time, so set it first. */

package/dist/src/ui/title.js

@@ -0,0 +1,16 @@
+/**
+ * The terminal's window or tab title. Windows Terminal, iTerm2, Ghostty and the rest show the running shell
+ * ("Windows PowerShell") unless the program sets its own with OSC 0, which Nou does: "Nou CLI".
+ * The title before is saved (CSI 22;0t) and put back (CSI 23;0t) on the way out, in terminals that keep a
+ * title stack (xterm, kitty, Ghostty, WezTerm, iTerm2); the others ignore those codes, and the shell retitles
+ * its tab soon after.
+ */
+export const TITLE = "Nou CLI";
+let set = false;
+export function setTerminalTitle(title = TITLE) {
+    if (set || !process.stdout.isTTY)
+        return;
+    set = true;
+    process.stdout.write(`\x1b[22;0t\x1b]0;${title}\x07`);
+    process.on("exit", () => process.stdout.write("\x1b[23;0t"));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nou-cli",
-  "version": "0.5.15",
+  "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": {