nou-cli 0.5.0 → 0.5.2

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);

package/dist/src/commands/index.js

@@ -1,7 +1,7 @@
 import path from "path";
 import fs from "fs/promises";
 import { readdirSync } from "fs";
-import { exec } from "child_process";
+import { spawn } from "child_process";
 export const IGNORED = new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", ".venv"]);
 /** Whether a path is inside the project folder (where Nou may read without asking and write at all). */
 export function isInProject(filePath) {
@@ -42,20 +42,35 @@ export async function readForModel(filePath, offset = 1, limit = READ_LINES) {
     const lines = text.split(/\r?\n/);
     if (lines.length > 1 && lines.at(-1) === "")
         lines.pop();
+    if (text === "")
+        return "(The file is empty.)";
     const start = Math.max(1, Math.floor(offset) || 1);
     if (start > lines.length)
         return `(The file has ${lines.length} lines.)`;
     let end = Math.min(lines.length, start + Math.max(1, Math.floor(limit) || READ_LINES) - 1);
-    if (start === 1 && end === lines.length && text.length <= READ_CHARS)
-        return text;
-    let body = lines.slice(start - 1, end).join("\n");
-    if (body.length > READ_CHARS) {
-        body = body.slice(0, READ_CHARS);
-        end = start + body.split("\n").length - 1;
-        body = `${body}\n[... line ${end} cut off: it is very long]`;
+    // Numbered like cat -n, so the model can cite and target exact lines (edit_file ignores the numbers).
+    const width = String(end).length;
+    let body = "";
+    for (let n = start; n <= end; n++) {
+        const line = `${String(n).padStart(width)}\t${lines[n - 1]}\n`;
+        if (body.length + line.length > READ_CHARS) {
+            if (n === start) {
+                // A single huge line (minified code, one-line JSON): show its start rather than nothing.
+                body += `${line.slice(0, READ_CHARS)}\n[... line ${n} cut off: it is ${lines[n - 1].length} characters long]\n`;
+                end = n;
+            }
+            else {
+                end = n - 1;
+                body += `[... stopped at line ${end} to keep this short]\n`;
+            }
+            break;
+        }
+        body += line;
     }
+    if (start === 1 && end === lines.length)
+        return body.trimEnd();
     const more = end < lines.length ? ` Read more with offset=${end + 1}.` : "";
-    return `${body}\n\n[Lines ${start}-${end} of ${lines.length}.${more}]`;
+    return `${body}\n[Lines ${start}-${end} of ${lines.length}.${more}]`;
 }
 /** Keeps tool output a sensible size for the model: the start and, where errors usually are, the end. */
 export function capOutput(text, max = 40_000) {
@@ -65,19 +80,104 @@ export function capOutput(text, max = 40_000) {
     const tail = max - head;
     return `${text.slice(0, head)}\n\n[... ${text.length - max} characters cut ...]\n\n${text.slice(-tail)}`;
 }
-export function runCommand(command) {
-    // Async so the UI keeps rendering while the command runs.
+/** How long run_command waits by default, and at most. */
+export const COMMAND_TIMEOUT = 120_000;
+export const MAX_COMMAND_TIMEOUT = 600_000;
+/** Output kept from a command: the start and the end (where errors and summaries are) when it's longer. */
+const OUTPUT_KEEP = 200_000;
+/**
+ * Runs a shell command and returns its output (stdout and stderr together, in the order written) and,
+ * when it failed, its exit code. Async so the UI keeps rendering while it runs.
+ */
+/** Commands still running, so they can be stopped when Nou exits instead of being left behind. */
+const running = new Set();
+let exitHooked = false;
+/** Stops a command and everything it started. */
+function stopProcess(child) {
+    try {
+        if (process.platform === "win32") {
+            if (child.pid)
+                spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+            else
+                child.kill("SIGKILL");
+        }
+        else if (child.pid)
+            process.kill(-child.pid, "SIGKILL");
+    }
+    catch {
+        child.kill("SIGKILL");
+    }
+}
+/**
+ * Runs a shell command and returns its output (stdout and stderr together, in the order written) and,
+ * when it failed, its exit code. Async so the UI keeps rendering while it runs. `signal` (Esc) stops it.
+ */
+export function runCommand(command, timeout = COMMAND_TIMEOUT, signal) {
     return new Promise((resolve) => {
-        exec(command, { cwd: process.cwd(), timeout: 120_000, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
-            if (error) {
-                const reason = error.killed ? "timed out after 2 minutes" : `Exit Code ${error.code ?? "?"}`;
-                resolve(`Error (${reason}): ${stderr || error.message}${stdout ? `
-${stdout}` : ""}`);
+        const posix = process.platform !== "win32";
+        // Its own process group on macOS and Linux, so stopping it stops everything it started.
+        const child = spawn(command, { cwd: process.cwd(), shell: true, stdio: ["ignore", "pipe", "pipe"], detached: posix });
+        running.add(child);
+        if (!exitHooked) {
+            exitHooked = true;
+            process.on("exit", () => running.forEach(stopProcess));
+            // Closing the terminal ends Nou with SIGHUP, which skips "exit": stop the commands then too.
+            if (process.platform !== "win32") {
+                process.once("SIGHUP", () => {
+                    running.forEach(stopProcess);
+                    process.exit(129);
+                });
             }
-            else {
-                resolve(stdout);
+        }
+        let head = "";
+        let tail = "";
+        let dropped = 0;
+        const take = (text) => {
+            if (head.length < OUTPUT_KEEP / 2) {
+                head += text;
+                return;
             }
-        });
+            tail += text;
+            if (tail.length > OUTPUT_KEEP / 2) {
+                dropped += tail.length - OUTPUT_KEEP / 2;
+                tail = tail.slice(-OUTPUT_KEEP / 2);
+            }
+        };
+        // Decoded as a stream, so a character split across two chunks isn't garbled.
+        child.stdout.setEncoding("utf8").on("data", take);
+        child.stderr.setEncoding("utf8").on("data", take);
+        const limit = Math.min(Math.max(1000, timeout), MAX_COMMAND_TIMEOUT);
+        let stopped = null;
+        const timer = setTimeout(() => {
+            stopped = "timeout";
+            stopProcess(child);
+        }, limit);
+        const onAbort = () => {
+            stopped = "cancelled";
+            stopProcess(child);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        let done = false;
+        const finish = (code, error) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            running.delete(child);
+            const output = (dropped ? `${head}\n[... ${dropped} characters cut ...]\n${tail}` : head + tail).trimEnd();
+            if (error)
+                return resolve(`Error: ${error.message}`);
+            if (stopped === "cancelled")
+                return resolve(`Stopped: the user cancelled it.\n${output}`);
+            if (stopped === "timeout")
+                return resolve(`Error (timed out after ${Math.round(limit / 1000)}s; pass a longer timeout if it needs one):\n${output}`);
+            resolve(code === 0 ? output || "(no output)" : `Error (exit code ${code ?? "?"}):\n${output || "(no output)"}`);
+        };
+        child.on("error", (error) => finish(null, error));
+        child.on("close", (code) => finish(code));
+        if (signal?.aborted)
+            onAbort();
     });
 }
 export function fileTree(dir = ".", maxDepth = 3, maxLines = Infinity) {
@@ -141,29 +241,137 @@ export async function proposeWrite(filePath, content) {
     const before = await readOrEmpty(fullPath);
     return { path: toRelative(filePath), before: before ?? "", after: cleanContent(content), isNew: before === null };
 }
+/** Typographic characters models sometimes put in place of the plain ones in the file. */
+const PLAIN = { "\u2018": "'", "\u2019": "'", "\u201c": "\"", "\u201d": "\"", "\u2013": "-", "\u2014": "-", "\u00a0": " ", "\u2026": "..." };
+const plainChars = (s) => s.replace(/[\u2018\u2019\u201c\u201d\u2013\u2014\u00a0\u2026]/g, (c) => PLAIN[c]);
+/**
+ * Where `target` is in `text`, matching whole lines loosely: ignoring trailing spaces, then indentation,
+ * then typographic quotes and dashes. Only a unique match counts: a wrong edit is worse than none.
+ */
+function looseMatch(text, target) {
+    const lines = text.split("\n");
+    const want = target.replace(/\n$/, "").split("\n");
+    const offsets = [];
+    for (let i = 0, at = 0; i < lines.length; i++) {
+        offsets.push(at);
+        at += lines[i].length + 1;
+    }
+    for (const norm of [(l) => l.trimEnd(), (l) => l.trim(), (l) => plainChars(l).trim()]) {
+        const wanted = want.map(norm);
+        const hits = [];
+        for (let i = 0; i + wanted.length <= lines.length && hits.length < 2; i++) {
+            if (wanted.every((w, k) => norm(lines[i + k]) === w))
+                hits.push(i);
+        }
+        if (hits.length === 1) {
+            const first = hits[0];
+            const last = first + wanted.length - 1;
+            // How the file indents the match versus how old_string did, so new_string can be shifted to match.
+            const k = Math.max(0, want.findIndex((l) => l.trim()));
+            const lead = (l) => l.match(/^\s*/)[0];
+            return { start: offsets[first], end: offsets[last] + lines[last].length, fileIndent: lead(lines[first + k]), targetIndent: lead(want[k]) };
+        }
+        if (hits.length > 1)
+            return null;
+    }
+    return null;
+}
+/** The lines of `text` most like the start of `target`, numbered: a hint for the model's next try. */
+function nearest(text, target) {
+    const lines = text.split("\n");
+    const first = target.split("\n").find((l) => l.trim())?.trim() ?? "";
+    if (!first)
+        return "";
+    const words = new Set(first.split(/\W+/).filter((w) => w.length > 2));
+    let best = -1;
+    let bestScore = 0;
+    lines.forEach((line, i) => {
+        const score = line.split(/\W+/).filter((w) => words.has(w)).length;
+        if (score > bestScore) {
+            best = i;
+            bestScore = score;
+        }
+    });
+    if (best < 0)
+        return "";
+    const from = Math.max(0, best - 2);
+    return lines.slice(from, best + 4).map((l, k) => `${String(from + k + 1).padStart(5)}\t${l}`).join("\n");
+}
+/** Line numbers copied from read_file's output ("  12\tcode"): dropped when old_string doesn't match with them. */
+const stripLineNumbers = (s) => (s.split("\n").every((l) => !l || /^\s*\d+\t/.test(l)) ? s.replace(/^\s*\d+\t/gm, "") : s);
 /** Works out what edit_file would do, without touching the disk. */
 export async function proposeEdit(filePath, oldString, newString, replaceAll = false) {
     const fullPath = resolveInProject(filePath);
     const before = await readOrEmpty(fullPath);
     if (before === null)
         throw new Error(`${filePath} does not exist. Use write_file to create it.`);
+    const after = editText(before, oldString, newString, replaceAll);
+    return { path: toRelative(filePath), before, after, isNew: false };
+}
+/** Applies one edit to a file's text (see proposeEdit), throwing an error the model can act on. */
+export function editText(before, oldString, newString, replaceAll = false) {
     // Models often send LF while Windows files use CRLF, so match on normalized text.
     const eol = before.includes("\r\n") ? "\r\n" : "\n";
     const normalized = before.replace(/\r\n/g, "\n");
-    const target = oldString.replace(/\r\n/g, "\n");
-    const count = target ? normalized.split(target).length - 1 : 0;
-    if (count === 0)
-        throw new Error("old_string was not found in the file. Read the file and copy the text exactly.");
+    let target = oldString.replace(/\r\n/g, "\n");
+    let replacement = newString.replace(/\r\n/g, "\n");
+    if (!target)
+        throw new Error("old_string is empty. To create a file use write_file; to add to one, include the line you're adding after.");
+    let count = normalized.split(target).length - 1;
+    if (count === 0 && stripLineNumbers(target) !== target) {
+        target = stripLineNumbers(target);
+        replacement = stripLineNumbers(replacement);
+        count = normalized.split(target).length - 1;
+    }
+    if (count === 0) {
+        const loose = looseMatch(normalized, target);
+        if (loose) {
+            let text = replacement.replace(/\n$/, "");
+            // old_string was indented differently from the file: shift new_string the same way, so the code stays in its block.
+            // (Only when new_string is indented like old_string; if it already has the file's indentation, it stays.)
+            const newIndent = text.split("\n").find((l) => l.trim())?.match(/^\s*/)[0] ?? "";
+            if (loose.fileIndent !== loose.targetIndent && newIndent === loose.targetIndent) {
+                const { fileIndent: to, targetIndent: from } = loose;
+                text = text.split("\n").map((l) => (!l.trim() ? l : l.startsWith(from) ? to + l.slice(from.length) : l)).join("\n");
+            }
+            // Deleting whole lines takes their line break too, rather than leaving a blank line.
+            const end = !text && normalized[loose.end] === "\n" ? loose.end + 1 : loose.end;
+            return (normalized.slice(0, loose.start) + text + normalized.slice(end)).replace(/\n/g, eol);
+        }
+        const near = nearest(normalized, target);
+        throw new Error(`old_string was not found in the file. Copy it exactly from read_file (without the line numbers).${near ? ` The closest lines are:\n${near}` : " Read the file again first."}`);
+    }
     if (count > 1 && !replaceAll) {
         throw new Error(`old_string appears ${count} times. Include more surrounding lines so it is unique, or set replace_all to change every one.`);
     }
-    const replacement = newString.replace(/\r\n/g, "\n");
-    const after = (replaceAll ? normalized.split(target).join(replacement) : normalized.replace(target, () => replacement)).replace(/\n/g, eol);
+    return (replaceAll ? normalized.split(target).join(replacement) : normalized.replace(target, () => replacement)).replace(/\n/g, eol);
+}
+/** edit_file with several edits: each applies to the result of the one before, and all must work. */
+export async function proposeEdits(filePath, edits) {
+    const fullPath = resolveInProject(filePath);
+    const before = await readOrEmpty(fullPath);
+    if (before === null)
+        throw new Error(`${filePath} does not exist. Use write_file to create it.`);
+    let after = before;
+    edits.forEach((e, i) => {
+        try {
+            after = editText(after, String(e.old_string ?? ""), String(e.new_string ?? ""), e.replace_all === true);
+        }
+        catch (error) {
+            throw new Error(`Edit ${i + 1} of ${edits.length}: ${error.message} (none of the edits were made)`, { cause: error });
+        }
+    });
     return { path: toRelative(filePath), before, after, isNew: false };
 }
 export async function applyChange(change) {
     try {
         const fullPath = resolveInProject(change.path);
+        // The edit was worked out from the file as it was then; if it has changed since (you edited it while
+        // the edit waited for approval), writing it would throw your changes away.
+        const now = await readOrEmpty(fullPath);
+        if (change.isNew ? now !== null : now !== change.before) {
+            return `Failed: ${change.path} changed after the edit was worked out (it was edited meanwhile), so it wasn't written. Read it again and redo the edit.`;
+        }
         await fs.mkdir(path.dirname(fullPath), { recursive: true });
         await fs.writeFile(fullPath, change.after, "utf-8");
         return `Successfully ${change.isNew ? "created" : "updated"} ${change.path}`;

package/dist/src/config/index.js

@@ -5,18 +5,27 @@ export const NOU_HOME = path.join(os.homedir(), ".nou");
 const CONFIG_PATH = path.join(NOU_HOME, "config.json");
 export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 export const AUTO_SAVE = ["delay", "focus", "off"];
+/** How fast follow mode replays what the agent does: a step every so often, or as it happens. */
+export const FOLLOW_SPEEDS = ["slow", "normal", "fast", "instant"];
+/** Color themes for code (see src/syntax/themes.ts). */
+export const CODE_THEMES = ["one-dark", "tokyo-night", "github-dark", "dracula", "high-contrast", "github-light"];
 export const DEFAULT_SETTINGS = {
     model: "",
     engine: "nou",
     effort: "high",
     followMode: false,
+    followSpeed: "normal",
     autoApproveEdits: false,
     autoApproveCommands: false,
     gitContext: true,
     autoSave: "delay",
+    codeTheme: "one-dark",
     mouse: true,
     reuseToolConfig: true,
     paneWidths: null,
+    trustedFolders: [],
+    games: [],
+    gamePanel: null,
     plugins: {},
     trustedPlugins: {},
 };
@@ -41,3 +50,8 @@ export function saveSettings(patch) {
     }
     return next;
 }
+/** Whether you trust this folder (or one it's inside). */
+export function isTrustedFolder(dir = process.cwd(), settings = loadSettings()) {
+    const here = path.resolve(dir);
+    return settings.trustedFolders.some((t) => here === t || here.startsWith(t.endsWith(path.sep) ? t : t + path.sep));
+}

package/dist/src/context/index.js

@@ -1,12 +1,9 @@
-import { highlight } from "cli-highlight";
 import fs from "fs/promises";
 import path from "path";
 import { fileTree, readFile } from "../commands/index.js";
 import { complete } from "../providers/index.js";
 import * as p from "@clack/prompts";
-export const sugarfy = (str) => {
-    return highlight(str, { language: "typescript", ignoreIllegals: true });
-};
+import { NOU_HOME } from "../config/index.js";
 export async function generateContext(contextPath, choice) {
     const s = p.spinner();
     s.start("Analyzing project structure to create NOU.md...");
@@ -41,13 +38,39 @@ export async function ensureProjectContext(choice) {
         await generateContext(contextPath, choice);
     }
 }
+/** Instruction files other coding agents use too, so a repo's existing rules apply to Nou as well. */
+const INSTRUCTION_FILES = ["NOU.md", "AGENTS.md", "CLAUDE.md"];
+const MAX_INSTRUCTIONS = 20_000;
+/**
+ * The project's standing instructions: NOU.md, AGENTS.md and CLAUDE.md here and in the folders above it
+ * up to the repository root (outermost first, so nearer files have the last word), plus ~/.nou/NOU.md.
+ */
 export async function loadPermanentContext() {
-    const contextPath = path.join(process.cwd(), "NOU.md");
-    try {
-        const content = await fs.readFile(contextPath, "utf-8");
-        return `\n\nPROJECT SPECIFIC RULES (from NOU.md):\n${content}`;
+    const dirs = [];
+    for (let dir = process.cwd();; dir = path.dirname(dir)) {
+        dirs.unshift(dir);
+        const atRoot = await fs.access(path.join(dir, ".git")).then(() => true, () => false);
+        if (atRoot || path.dirname(dir) === dir)
+            break;
     }
-    catch {
-        return "";
+    const files = [path.join(NOU_HOME, "NOU.md"), ...dirs.flatMap((dir) => INSTRUCTION_FILES.map((name) => path.join(dir, name)))];
+    const seen = new Set();
+    const parts = [];
+    for (const file of files) {
+        const content = (await fs.readFile(file, "utf-8").catch(() => "")).trim();
+        if (!content || seen.has(content))
+            continue;
+        seen.add(content);
+        const where = file.startsWith(NOU_HOME) ? "~/.nou/NOU.md" : path.relative(process.cwd(), file) || path.basename(file);
+        parts.push(`From ${where}:\n${content.length > MAX_INSTRUCTIONS ? `${content.slice(0, MAX_INSTRUCTIONS)}\n[... cut]` : content}`);
     }
+    return parts.length ? `\n\nPROJECT SPECIFIC RULES:\n${parts.join("\n\n")}` : "";
+}
+/**
+ * Just the NOU.md parts of the project rules, for engines that read AGENTS.md / CLAUDE.md themselves
+ * (Claude Code, Codex): giving them those again would only repeat them.
+ */
+export function nouRulesOnly(rules) {
+    const parts = rules.replace(/^\s*PROJECT SPECIFIC RULES:\n/, "").split(/\n\n(?=From )/).filter((p) => /^From (\S*[\\/])?NOU\.md:|^From ~\/\.nou\/NOU\.md:/.test(p.trim()));
+    return parts.length ? `\n\nPROJECT SPECIFIC RULES:\n${parts.join("\n\n")}` : "";
 }