nou-cli 0.5.1 → 0.5.2

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")}` : "";
 }

package/dist/src/games/index.js

@@ -0,0 +1,217 @@
+/**
+ * Little games for the Games panel, drawn with text. Each one is plain state and three functions, so the
+ * panel can run any of them and the tests can play them without a terminal.
+ */
+/** A small seeded random number generator, so games can be replayed in tests. */
+function rng(seed) {
+    let s = seed >>> 0 || 1;
+    return () => {
+        s ^= s << 13;
+        s ^= s >>> 17;
+        s ^= s << 5;
+        return (s >>> 0) / 4294967296;
+    };
+}
+const blank = (w, h) => Array.from({ length: h }, () => Array(w).fill(" "));
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+const PADDLE = 3;
+const PONG_WIN = 7;
+function serve(s, toward) {
+    const vy = (s.random() - 0.5) * 1.2;
+    return { ...s, bx: s.w / 2, by: s.h / 2, vx: toward * 0.9, vy: Math.abs(vy) < 0.2 ? 0.4 : vy };
+}
+export const pong = {
+    id: "pong",
+    title: "Pong",
+    blurb: "The classic: you on the left, the computer on the right. First to 7.",
+    controls: "↑↓ or w/s move",
+    tickMs: 50,
+    colors: { "█": "#61afef", "●": "#e5c07b", "┊": "#5c6370" },
+    create(w, h, seed = Date.now()) {
+        const s = { w, h, you: Math.floor((h - PADDLE) / 2), them: Math.floor((h - PADDLE) / 2), bx: 0, by: 0, vx: 0, vy: 0, scores: [0, 0], random: rng(seed) };
+        return serve(s, -1);
+    },
+    tick(s, inputs) {
+        if (s.scores[0] >= PONG_WIN || s.scores[1] >= PONG_WIN)
+            return s;
+        let you = s.you;
+        for (const i of inputs)
+            you += i === "up" ? -1 : i === "down" ? 1 : 0;
+        you = clamp(you, 0, s.h - PADDLE);
+        // The computer follows the ball, a bit slower than it moves, so it can be beaten.
+        const target = s.by - PADDLE / 2;
+        const them = clamp(s.them + clamp(target - s.them, -0.55, 0.55), 0, s.h - PADDLE);
+        let { bx, by, vx, vy } = s;
+        bx += vx;
+        by += vy;
+        if (by < 0)
+            [by, vy] = [-by, -vy];
+        if (by > s.h - 1)
+            [by, vy] = [2 * (s.h - 1) - by, -vy];
+        // Paddles at x=1 and x=w-2; where the ball hits the paddle sets its angle.
+        if (vx < 0 && bx <= 1.5 && bx >= 0.5 && by >= you - 0.5 && by <= you + PADDLE - 0.5) {
+            [bx, vx, vy] = [1.5, Math.min(1.4, -vx * 1.05), (by - (you + PADDLE / 2 - 0.5)) * 0.5];
+        }
+        if (vx > 0 && bx >= s.w - 2.5 && bx <= s.w - 1.5 && by >= them - 0.5 && by <= them + PADDLE - 0.5) {
+            [bx, vx, vy] = [s.w - 2.5, -Math.min(1.4, vx * 1.05), (by - (them + PADDLE / 2 - 0.5)) * 0.5];
+        }
+        const next = { ...s, you, them, bx, by, vx, vy };
+        if (bx < 0)
+            return serve({ ...next, scores: [s.scores[0], s.scores[1] + 1] }, -1);
+        if (bx > s.w - 1)
+            return serve({ ...next, scores: [s.scores[0] + 1, s.scores[1]] }, 1);
+        return next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        for (let y = 0; y < s.h; y += 2)
+            grid[y][Math.floor(s.w / 2)] = "┊";
+        for (let k = 0; k < PADDLE; k++) {
+            grid[s.you + k][1] = "█";
+            grid[Math.round(s.them) + k][s.w - 2] = "█";
+        }
+        const bx = Math.round(s.bx);
+        const by = Math.round(s.by);
+        if (grid[by]?.[bx] !== undefined)
+            grid[by][bx] = "●";
+        const [a, b] = s.scores;
+        return {
+            lines: grid.map((r) => r.join("")),
+            status: `you ${a} · ${b} computer   ↑↓ move`,
+            ...(a >= PONG_WIN ? { over: "You win! ✦" } : b >= PONG_WIN ? { over: "The computer wins." } : {}),
+        };
+    },
+};
+const DIRS = { up: { x: 0, y: -1 }, down: { x: 0, y: 1 }, left: { x: -1, y: 0 }, right: { x: 1, y: 0 } };
+const OPPOSITE = { up: "down", down: "up", left: "right", right: "left" };
+function placeFood(s) {
+    for (let tries = 0; tries < 500; tries++) {
+        const p = { x: Math.floor(s.random() * s.w), y: Math.floor(s.random() * s.h) };
+        if (!s.body.some((b) => b.x === p.x && b.y === p.y))
+            return p;
+    }
+    return { x: 0, y: 0 };
+}
+export const snake = {
+    id: "snake",
+    title: "Snake",
+    blurb: "Eat, grow, don't bite yourself or the walls.",
+    controls: "arrows or wasd steer",
+    tickMs: 110,
+    colors: { "█": "#98c379", "▓": "#7ec16e", "◆": "#e06c75" },
+    create(w, h, seed = Date.now()) {
+        const y = Math.floor(h / 2);
+        const s = { w, h, body: [{ x: 4, y }, { x: 3, y }, { x: 2, y }], dir: "right", food: { x: 0, y: 0 }, score: 0, dead: false, random: rng(seed) };
+        return { ...s, food: placeFood(s) };
+    },
+    tick(s, inputs) {
+        if (s.dead)
+            return s;
+        let dir = s.dir;
+        // One turn per tick (the first that isn't straight back), so quick double taps don't fold it onto itself.
+        for (const i of inputs) {
+            if (i !== OPPOSITE[dir] && i !== dir) {
+                dir = i;
+                break;
+            }
+        }
+        const head = { x: s.body[0].x + DIRS[dir].x, y: s.body[0].y + DIRS[dir].y };
+        const eats = head.x === s.food.x && head.y === s.food.y;
+        const rest = eats ? s.body : s.body.slice(0, -1);
+        const dead = head.x < 0 || head.y < 0 || head.x >= s.w || head.y >= s.h || rest.some((b) => b.x === head.x && b.y === head.y);
+        if (dead)
+            return { ...s, dir, dead: true };
+        const next = { ...s, dir, body: [head, ...rest], score: s.score + (eats ? 1 : 0) };
+        return eats ? { ...next, food: placeFood(next) } : next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        grid[s.food.y][s.food.x] = "◆";
+        s.body.forEach((b, i) => {
+            if (grid[b.y]?.[b.x] !== undefined)
+                grid[b.y][b.x] = i === 0 ? "█" : "▓";
+        });
+        return { lines: grid.map((r) => r.join("")), status: `length ${s.body.length} · score ${s.score}`, ...(s.dead ? { over: `Game over: ${s.score} eaten.` } : {}) };
+    },
+};
+const PAD = 7;
+const BRICK_ROWS = 4;
+function launch(s) {
+    return { ...s, bx: s.paddle + PAD / 2, by: s.h - 3, vx: (s.random() < 0.5 ? -1 : 1) * 0.6, vy: -0.6 };
+}
+export const breakout = {
+    id: "breakout",
+    title: "Breakout",
+    blurb: "Knock out every brick with the ball. Three lives.",
+    controls: "←→ or a/d move",
+    tickMs: 45,
+    colors: { "▀": "#e06c75", "▄": "#d19a66", "▬": "#61afef", "●": "#e5c07b" },
+    create(w, h, seed = Date.now()) {
+        const s = {
+            w, h, paddle: Math.floor((w - PAD) / 2), bx: 0, by: 0, vx: 0, vy: 0,
+            bricks: Array.from({ length: BRICK_ROWS }, () => Array(Math.floor(w / 3)).fill(true)), lives: 3, score: 0, random: rng(seed),
+        };
+        return launch(s);
+    },
+    tick(s, inputs) {
+        if (s.lives <= 0 || s.bricks.every((r) => r.every((b) => !b)))
+            return s;
+        let paddle = s.paddle;
+        for (const i of inputs)
+            paddle += i === "left" ? -2 : i === "right" ? 2 : 0;
+        paddle = clamp(paddle, 0, s.w - PAD);
+        let { bx, by, vx, vy } = s;
+        bx += vx;
+        by += vy;
+        if (bx < 0 || bx > s.w - 1)
+            [bx, vx] = [clamp(bx, 0, s.w - 1), -vx];
+        if (by < 0)
+            [by, vy] = [0, -vy];
+        // Bricks are three columns wide, on rows 1.. so there's a gap at the top.
+        const bricks = s.bricks.map((r) => [...r]);
+        let score = s.score;
+        const row = Math.floor(by) - 1;
+        const col = Math.floor(bx / 3);
+        if (row >= 0 && row < BRICK_ROWS && bricks[row]?.[col]) {
+            bricks[row][col] = false;
+            score += (BRICK_ROWS - row) * 10;
+            vy = -vy;
+        }
+        // The paddle sits on the last row; where the ball lands on it sets the angle.
+        if (vy > 0 && by >= s.h - 2 && by < s.h - 1 && bx >= paddle - 0.5 && bx <= paddle + PAD - 0.5) {
+            vy = -Math.abs(vy);
+            vx = clamp((bx - (paddle + PAD / 2 - 0.5)) * 0.25, -1, 1) || 0.3;
+            by = s.h - 2;
+        }
+        const next = { ...s, paddle, bx, by, vx, vy, bricks, score };
+        if (by > s.h - 1) {
+            const lives = s.lives - 1;
+            return lives > 0 ? launch({ ...next, lives }) : { ...next, lives };
+        }
+        return next;
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        s.bricks.forEach((r, y) => r.forEach((alive, x) => {
+            if (alive)
+                for (let k = 0; k < 3; k++)
+                    if (x * 3 + k < s.w - 0)
+                        grid[y + 1][x * 3 + k] = y % 2 ? "▄" : "▀";
+        }));
+        for (let k = 0; k < PAD; k++)
+            grid[s.h - 1][s.paddle + k] = "▬";
+        const bx = Math.round(s.bx);
+        const by = Math.round(s.by);
+        if (s.lives > 0 && grid[by]?.[bx] !== undefined)
+            grid[by][bx] = "●";
+        const cleared = s.bricks.every((r) => r.every((b) => !b));
+        return {
+            lines: grid.map((r) => r.join("")),
+            status: `score ${s.score} · lives ${"♥".repeat(Math.max(0, s.lives))}`,
+            ...(cleared ? { over: `Cleared! ${s.score} points ✦` } : s.lives <= 0 ? { over: `Game over: ${s.score} points.` } : {}),
+        };
+    },
+};
+/** Every game Nou has, in the order settings lists them. */
+export const GAMES = [pong, snake, breakout];
+export const gameById = (id) => GAMES.find((g) => g.id === id);