nou-cli 0.5.4 → 0.5.10

package/dist/src/games/index.js

@@ -12,8 +12,13 @@ function rng(seed) {
         return (s >>> 0) / 4294967296;
     };
 }
-const blank = (w, h) => Array.from({ length: h }, () => Array(w).fill(" "));
+const blank = (w, h) => Array.from({ length: Math.max(0, h) }, () => Array(Math.max(0, w)).fill(" "));
 const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+/** Draws a character if (x, y) is on the grid: games never write outside it, whatever its size. */
+const put = (grid, x, y, ch) => {
+    if (grid[y]?.[x] !== undefined)
+        grid[y][x] = ch;
+};
 const PADDLE = 3;
 const PONG_WIN = 7;
 function serve(s, toward) {
@@ -26,8 +31,11 @@ export const pong = {
     blurb: "The classic: you on the left, the computer on the right. First to 7.",
     controls: "↑↓ or w/s move",
     tickMs: 50,
+    minWidth: 16,
+    minHeight: 6,
     colors: { "█": "#61afef", "●": "#e5c07b", "┊": "#5c6370" },
     create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
         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);
     },
@@ -65,18 +73,16 @@ export const pong = {
     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)] = "┊";
+            put(grid, Math.floor(s.w / 2), y, "┊");
         for (let k = 0; k < PADDLE; k++) {
-            grid[s.you + k][1] = "█";
-            grid[Math.round(s.them) + k][s.w - 2] = "█";
+            put(grid, 1, s.you + k, "█");
+            put(grid, s.w - 2, Math.round(s.them) + k, "█");
         }
-        const bx = Math.round(s.bx);
-        const by = Math.round(s.by);
-        if (grid[by]?.[bx] !== undefined)
-            grid[by][bx] = "●";
+        put(grid, Math.round(s.bx), Math.round(s.by), "●");
         const [a, b] = s.scores;
         return {
             lines: grid.map((r) => r.join("")),
+            score: a,
             status: `you ${a} · ${b} computer   ↑↓ move`,
             ...(a >= PONG_WIN ? { over: "You win! ✦" } : b >= PONG_WIN ? { over: "The computer wins." } : {}),
         };
@@ -98,8 +104,13 @@ export const snake = {
     blurb: "Eat, grow, don't bite yourself or the walls.",
     controls: "arrows or wasd steer",
     tickMs: 110,
+    minWidth: 10,
+    minHeight: 5,
+    // A little faster with every few eaten, down to a floor.
+    speed: (s) => Math.max(55, 110 - Math.floor(s.score / 3) * 8),
     colors: { "█": "#98c379", "▓": "#7ec16e", "◆": "#e06c75" },
     create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
         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) };
@@ -110,7 +121,7 @@ export const snake = {
         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) {
+            if (i !== "action" && i !== OPPOSITE[dir] && i !== dir) {
                 dir = i;
                 break;
             }
@@ -126,36 +137,42 @@ export const snake = {
     },
     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.` } : {}) };
+        put(grid, s.food.x, s.food.y, "◆");
+        s.body.forEach((b, i) => put(grid, b.x, b.y, i === 0 ? "█" : "▓"));
+        return { lines: grid.map((r) => r.join("")), score: s.score, 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 };
+    // Each level the ball starts a little faster.
+    const pace = 0.6 * (1 + (s.level - 1) * 0.12);
+    return { ...s, bx: s.paddle + PAD / 2, by: s.h - 3, vx: (s.random() < 0.5 ? -1 : 1) * pace, vy: -pace };
 }
+const wall = (w) => Array.from({ length: BRICK_ROWS }, () => Array(Math.floor(w / 3)).fill(true));
 export const breakout = {
     id: "breakout",
     title: "Breakout",
-    blurb: "Knock out every brick with the ball. Three lives.",
+    blurb: "Knock out every brick with the ball; each wall you clear brings a faster one. Three lives.",
     controls: "←→ or a/d move",
     tickMs: 45,
+    minWidth: 18,
+    minHeight: 9,
     colors: { "▀": "#e06c75", "▄": "#d19a66", "▬": "#61afef", "●": "#e5c07b" },
     create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
         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),
+            bricks: wall(w), lives: 3, score: 0, level: 1, random: rng(seed),
         };
         return launch(s);
     },
     tick(s, inputs) {
-        if (s.lives <= 0 || s.bricks.every((r) => r.every((b) => !b)))
+        if (s.lives <= 0)
             return s;
+        // A cleared wall: the next level, a little faster.
+        if (s.bricks.every((r) => r.every((b) => !b)))
+            return launch({ ...s, bricks: wall(s.w), level: s.level + 1 });
         let paddle = s.paddle;
         for (const i of inputs)
             paddle += i === "left" ? -2 : i === "right" ? 2 : 0;
@@ -195,23 +212,196 @@ export const breakout = {
         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 ? "▄" : "▀";
+                    put(grid, x * 3 + k, y + 1, 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));
+            put(grid, s.paddle + k, s.h - 1, "▬");
+        if (s.lives > 0)
+            put(grid, Math.round(s.bx), Math.round(s.by), "●");
         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.` } : {}),
+            score: s.score,
+            status: `level ${s.level} · score ${s.score} · lives ${"♥".repeat(Math.max(0, s.lives))}`,
+            ...(s.lives <= 0 ? { over: `Game over: ${s.score} points, level ${s.level}.` } : {}),
         };
     },
 };
+/** Rocks fall; slide along the bottom to dodge them and catch the stars. It gets busier as you last. */
+export const dodge = {
+    id: "dodge",
+    title: "Dodge",
+    blurb: "Rocks fall faster and thicker the longer you last. Catch ★ for points.",
+    controls: "←→ or a/d move",
+    tickMs: 90,
+    minWidth: 12,
+    minHeight: 6,
+    speed: (s) => Math.max(45, 90 - Math.floor(s.ticks / 60) * 5),
+    colors: { "▲": "#61afef", "●": "#d19a66", "★": "#e5c07b" },
+    create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
+        return { w, h, x: Math.floor(w / 2), rocks: [], stars: [], score: 0, ticks: 0, dead: false, random: rng(seed) };
+    },
+    tick(s, inputs) {
+        if (s.dead)
+            return s;
+        let x = s.x;
+        for (const i of inputs)
+            x += i === "left" ? -1 : i === "right" ? 1 : 0;
+        x = clamp(x, 0, s.w - 1);
+        const fall = (p) => ({ x: p.x, y: p.y + 1 });
+        const rocks = s.rocks.map(fall).filter((p) => p.y < s.h);
+        let stars = s.stars.map(fall).filter((p) => p.y < s.h);
+        // More rocks per row as the game goes on.
+        const chance = Math.min(0.55, 0.18 + s.ticks / 900);
+        if (s.random() < chance)
+            rocks.push({ x: Math.floor(s.random() * s.w), y: 0 });
+        if (s.random() < 0.05)
+            stars.push({ x: Math.floor(s.random() * s.w), y: 0 });
+        const at = (p) => p.x === x && p.y === s.h - 1;
+        let score = s.score + (s.ticks % 10 === 9 ? 1 : 0);
+        if (stars.some(at)) {
+            score += 10;
+            stars = stars.filter((p) => !at(p));
+        }
+        const dead = rocks.some(at);
+        return { ...s, x, rocks, stars, score, ticks: s.ticks + 1, dead };
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        for (const r of s.rocks)
+            put(grid, r.x, r.y, "●");
+        for (const r of s.stars)
+            put(grid, r.x, r.y, "★");
+        put(grid, s.x, s.h - 1, "▲");
+        return { lines: grid.map((r) => r.join("")), score: s.score, status: `score ${s.score}`, ...(s.dead ? { over: `Hit! ${s.score} points.` } : {}) };
+    },
+};
+const HOP_X = 3;
+/** Run along the ground and hop the walls that come at you; they come faster as you go. */
+export const hop = {
+    id: "hop",
+    title: "Hop",
+    blurb: "Run and hop over the walls coming at you. One hit and it's over.",
+    controls: "↑ or Enter hops",
+    tickMs: 70,
+    minWidth: 20,
+    minHeight: 6,
+    speed: (s) => Math.max(35, 70 - Math.floor(s.score / 5) * 4),
+    colors: { "◉": "#98c379", "█": "#c678dd", "▔": "#5c6370" },
+    create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
+        return { w, h, y: 0, vy: 0, walls: [], score: 0, ticks: 0, dead: false, random: rng(seed) };
+    },
+    tick(s, inputs) {
+        if (s.dead)
+            return s;
+        // Height above the ground; a hop goes up and comes back down.
+        let { y, vy } = s;
+        if (y === 0 && inputs.some((i) => i === "up" || i === "action"))
+            vy = 1.15;
+        y = Math.max(0, y + vy);
+        vy = y === 0 ? 0 : vy - 0.22;
+        const walls = s.walls.map((wl) => ({ ...wl, x: wl.x - 1 })).filter((wl) => wl.x >= 0);
+        const passed = s.walls.length - walls.length;
+        const last = walls[walls.length - 1];
+        // A new wall, far enough from the last that every gap can be cleared.
+        if ((!last || last.x < s.w - 9) && s.random() < 0.12)
+            walls.push({ x: s.w - 1, tall: 1 + Math.floor(s.random() * Math.min(2, s.h - 3)) });
+        const dead = walls.some((wl) => wl.x === HOP_X && Math.round(y) < wl.tall);
+        return { ...s, y, vy, walls, score: s.score + passed, ticks: s.ticks + 1, dead };
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        const ground = s.h - 1;
+        for (let x = 0; x < s.w; x++)
+            put(grid, x, ground, "▔");
+        for (const wl of s.walls)
+            for (let k = 1; k <= wl.tall; k++)
+                put(grid, wl.x, ground - k, "█");
+        put(grid, HOP_X, ground - 1 - Math.round(s.y), "◉");
+        return { lines: grid.map((r) => r.join("")), score: s.score, status: `walls hopped ${s.score}`, ...(s.dead ? { over: `Bonk! ${s.score} hopped.` } : {}) };
+    },
+};
+const SYMBOLS = ["◆", "●", "▲", "■", "★", "♥", "♣", "♠", "☀", "☂", "♪", "✿"];
+/** Cards face down: flip two at a time and find every matching pair in as few moves as you can. */
+export const pairs = {
+    id: "pairs",
+    title: "Pairs",
+    blurb: "Flip two cards at a time; find every matching pair in as few moves as you can.",
+    controls: "arrows move · Enter flips",
+    tickMs: 100,
+    minWidth: 16,
+    minHeight: 5,
+    colors: { "◆": "#e06c75", "●": "#e5c07b", "▲": "#61afef", "■": "#98c379", "★": "#e5c07b", "♥": "#e06c75", "♣": "#98c379", "♠": "#c678dd", "☀": "#d19a66", "☂": "#56b6c2", "♪": "#c678dd", "✿": "#56b6c2", "▒": "#5c6370", "▸": "#e5c07b", "◂": "#e5c07b" },
+    create(w, h, seed = Date.now()) {
+        [w, h] = [Math.max(w, this.minWidth), Math.max(h, this.minHeight)];
+        // As many cards as fit (each 4 wide, rows 2 apart), an even number, up to every symbol twice.
+        const cols = Math.max(2, Math.min(6, Math.floor(w / 4)));
+        const rows = Math.max(2, Math.min(4, Math.floor((h + 1) / 2)));
+        const count = Math.min(SYMBOLS.length * 2, cols * rows - ((cols * rows) % 2));
+        const random = rng(seed);
+        const deck = SYMBOLS.slice(0, count / 2).flatMap((sym) => [sym, sym]);
+        for (let i = deck.length - 1; i > 0; i--) {
+            const j = Math.floor(random() * (i + 1));
+            [deck[i], deck[j]] = [deck[j], deck[i]];
+        }
+        return { cols, rows, w, h, cards: deck, found: deck.map(() => false), open: [], cursor: 0, moves: 0, wait: 0 };
+    },
+    tick(s, inputs) {
+        if (s.found.every(Boolean))
+            return s;
+        let { cursor, open, found, moves, wait } = s;
+        // Two face-up cards that don't match stay shown a moment, then turn back over.
+        if (open.length === 2 && wait > 0) {
+            wait--;
+            if (wait === 0)
+                open = [];
+            return { ...s, open, wait };
+        }
+        const n = s.cards.length;
+        for (const i of inputs) {
+            if (i === "left")
+                cursor = (cursor + n - 1) % n;
+            else if (i === "right")
+                cursor = (cursor + 1) % n;
+            else if (i === "up")
+                cursor = cursor - s.cols >= 0 ? cursor - s.cols : cursor;
+            else if (i === "down")
+                cursor = cursor + s.cols < n ? cursor + s.cols : cursor;
+            else if (i === "action" && !found[cursor] && !open.includes(cursor) && open.length < 2) {
+                open = [...open, cursor];
+                if (open.length === 2) {
+                    moves++;
+                    if (s.cards[open[0]] === s.cards[open[1]]) {
+                        found = found.map((f, k) => f || open.includes(k));
+                        open = [];
+                    }
+                    else
+                        wait = 8;
+                }
+            }
+        }
+        return { ...s, cursor, open, found, moves, wait };
+    },
+    view(s) {
+        const grid = blank(s.w, s.h);
+        s.cards.forEach((card, i) => {
+            const x = (i % s.cols) * 4;
+            const y = Math.floor(i / s.cols) * 2;
+            const shown = s.found[i] || s.open.includes(i);
+            if (i === s.cursor) {
+                put(grid, x, y, "▸");
+                put(grid, x + 2, y, "◂");
+            }
+            put(grid, x + 1, y, s.found[i] ? card : shown ? card : "▒");
+        });
+        const done = s.found.every(Boolean);
+        const pairsLeft = s.found.filter((f) => !f).length / 2;
+        // Fewer moves is better: the score counts what you saved.
+        const score = Math.max(0, s.cards.length * 2 - s.moves);
+        return { lines: grid.map((r) => r.join("")), score, status: `moves ${s.moves} · ${pairsLeft} pairs left`, ...(done ? { over: `All found in ${s.moves} moves ✦` } : {}) };
+    },
+};
 /** Every game Nou has, in the order settings lists them. */
-export const GAMES = [pong, snake, breakout];
+export const GAMES = [pong, snake, breakout, dodge, hop, pairs];
 export const gameById = (id) => GAMES.find((g) => g.id === id);

package/dist/src/guide/index.js

@@ -98,3 +98,78 @@ export function guideProgress(typed, expected) {
     }
     return j;
 }
+export const SHOW_PLACES = "show_places";
+/** Stops as the model gave them, kept when usable: a file in the project and a line. */
+export function tidyStops(raw) {
+    return (Array.isArray(raw) ? raw : [])
+        .filter((s) => typeof s?.file === "string" && s.file.trim() && Number(s.line) >= 1)
+        .map((s) => {
+        const line = Math.floor(Number(s.line));
+        const end = Math.max(line, Math.floor(Number(s.end_line ?? s.end ?? line)) || line);
+        return { file: path.relative(process.cwd(), path.resolve(s.file)).split(path.sep).join("/"), line, end, note: String(s.note ?? s.why ?? "").trim() };
+    })
+        .filter((s) => !s.file.startsWith(".."))
+        .slice(0, 12);
+}
+/** The tool Nou's own engine points at places with. `onStops` gets them. */
+export function showPlacesTool(onStops) {
+    return {
+        definition: {
+            name: SHOW_PLACES,
+            description: "When you explain how something works or where something happens in this project, point at the exact places so the user sees them: Nou opens each one in their code view, highlighted, in the order given. Call it once, after you've read the code, with the parts that matter (usually 1-6).",
+            parameters: {
+                type: "object",
+                properties: {
+                    places: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                file: { type: "string", description: "Project-relative path." },
+                                line: { type: "number", description: "First line of the part (1-based)." },
+                                end_line: { type: "number", description: "Last line of the part." },
+                                note: { type: "string", description: "One or two plain sentences: what this part does, in terms of the explanation." },
+                            },
+                            required: ["file", "line", "end_line", "note"],
+                        },
+                    },
+                },
+                required: ["places"],
+            },
+        },
+        readOnly: true,
+        source: "nou",
+        run: (args) => {
+            const stops = tidyStops(args.places);
+            if (!stops.length)
+                return "No usable places: each needs a project file and a line. Call show_places again.";
+            onStops(stops);
+            return `Shown to the user: ${stops.length} place${stops.length > 1 ? "s" : ""}, opening the first. Now explain in the order of the places, naming each as path:line.`;
+        },
+    };
+}
+/** 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```/;
+/**
+ * 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.
+ */
+export const SHOW_PLACES_NOTE = "When you explain how something in this project works or where something happens, end your reply with the exact places, in the order to read them, as a JSON array in a fenced block marked nou-show. The user's editor opens each one highlighted:\n```nou-show\n[{\"file\": \"src/auth/session.ts\", \"line\": 40, \"end_line\": 58, \"note\": \"Checks the token and refuses expired ones.\"}]\n```\nOnly for places in this project you've actually read; leave it out when nothing needs showing.";
+/** The message /showme sends: explain, and point at the places. */
+export function explainPrompt(question, withTool) {
+    const how = withTool ? `call ${SHOW_PLACES} with them` : "list them in a nou-show block at the end, as described";
+    return `[Show me] ${question}\n\nExplain this to me and show me where it happens in the code. Don't change any files. Read what you need, find the exact places (file and line range) that matter, ${how}, in the order to read them, and explain in that order, naming each as path:line.`;
+}
+/** Places from a reply's ```nou-show block, and the reply without it; null when there's none. */
+export function stopsFromReply(text) {
+    const m = SHOW_BLOCK.exec(text);
+    if (!m)
+        return null;
+    try {
+        const stops = tidyStops(JSON.parse(m[1]));
+        return { stops, rest: text.replace(m[0], "").trim() };
+    }
+    catch {
+        return null;
+    }
+}