chesspal 0.0.1 → 0.2.0

package/dist/commands/index.js

@@ -0,0 +1,64 @@
+// The commands: the only way the AI, the command line and the page change a game (D-5, D-27), each defined once in the file named as its tool.
+import { aiMove } from "./ai-move.js";
+import { aiSay } from "./ai-say.js";
+import { analyseGame } from "./analyse-game.js";
+import { annotateGame } from "./annotate-game.js";
+import { coach } from "./coach.js";
+import { deleteGame } from "./delete-game.js";
+import { deleteReview } from "./delete-review.js";
+import { endGame } from "./end-game.js";
+import { exportGame } from "./export-game.js";
+import { init } from "./init.js";
+import { look } from "./look.js";
+import { newGame } from "./new-game.js";
+import { pastGames } from "./past-games.js";
+import { playerMove } from "./player-move.js";
+import { playerSay } from "./player-say.js";
+import { ponder } from "./ponder.js";
+import { position } from "./position.js";
+import { newProfile, profiles, setAccounts, setAvatar, useProfile } from "./profiles.js";
+import { status } from "./status.js";
+import { studyGames } from "./study-games.js";
+// What the server and the command line use besides the list: the context, the reading of an input, and the operations the page shares with the tools.
+export { aiMove } from "./ai-move.js";
+export { analyseGame } from "./analyse-game.js";
+export { gameAt } from "./clock.js";
+export { defaultContext } from "./context.js";
+export { deleteGame } from "./delete-game.js";
+export { deleteReview } from "./delete-review.js";
+export { answerDraw, DrawRefused, offerDraw } from "./draw-offer.js";
+export { endGame } from "./end-game.js";
+export { ChatNotClear, newGame, startNewGame } from "./new-game.js";
+export { bookOpening, bookPlies } from "./opening-book.js";
+export { playMove, PositionChanged, positionIn, samePosition } from "./play-move.js";
+export { chooseDrawnAvatar, GameGoingOn, newProfile, setAccounts, useProfile } from "./profiles.js";
+export { baseType, commandLineFieldProblem, inputProblems, isBoolean, isList, takesNumbers } from "./registry.js";
+export { say } from "./say.js";
+export { gameToStudy, namedGame } from "./study.js";
+/** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
+export const commands = [
+    init,
+    status,
+    newGame,
+    playerMove,
+    playerSay,
+    aiMove,
+    aiSay,
+    ponder,
+    coach,
+    look,
+    position,
+    endGame,
+    exportGame,
+    pastGames,
+    analyseGame,
+    annotateGame,
+    studyGames,
+    deleteReview,
+    deleteGame,
+    profiles,
+    newProfile,
+    useProfile,
+    setAvatar,
+    setAccounts,
+];

package/dist/commands/init.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+/** The player's folder set up for the AI hosts: the folder, and the files written there. */
+interface FolderSetUp {
+    folder: string;
+    written: string[];
+    /** The folder as the player goes into it from where init ran, when it is not that one: chess. */
+    enter?: string;
+    /** Codex's hooks changed in a folder that had them: Codex runs them only once the player trusts them again. */
+    hooksChanged?: true;
+}
+/** Makes a folder the player's chess table: the files through which Claude Code and Codex find Chesspal and the opponent's instructions (D-31). */
+export declare const init: import("./registry.ts").Command<z.ZodObject<{
+    folder: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, FolderSetUp>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,73 @@
+import { existsSync } from "node:fs";
+import { relative, resolve } from "node:path";
+// Colours only on a terminal that shows them: none in a file, a pipe or with NO_COLOR.
+import { styleText } from "node:util";
+import { z } from "zod";
+import { codexHooksPath, setUpHosts } from "../host-files/index.js";
+import { defineCommand } from "./registry.js";
+/** Makes a folder the player's chess table: the files through which Claude Code and Codex find Chesspal and the opponent's instructions (D-31). */
+export const init = defineCommand({
+    name: "init",
+    description: "Sets up a folder to play chess with an AI: the .mcp.json, AGENTS.md, CLAUDE.md and the settings through which Claude Code and Codex find "
+        + "Chesspal. Run it again to update Chesspal's lines; what you wrote there stays. Example: chesspal init chess.",
+    input: z.object({ folder: z.string().optional().describe("the folder to set up; the current folder if left out") }),
+    cliOnly: true,
+    idempotent: true,
+    positionals: ["folder"],
+    run: ({ folder }, context) => {
+        const root = resolve(context.folder, folder ?? ".");
+        const hooks = codexHooksPath(root);
+        const hadHooks = existsSync(hooks);
+        const written = setUpHosts(root, context.platform);
+        const enter = relative(context.folder, root);
+        return {
+            folder: root,
+            written: written.map((path) => relative(root, path)),
+            ...(enter === "" ? {} : { enter }),
+            ...(hadHooks && written.includes(hooks) ? { hooksChanged: true } : {}),
+        };
+    },
+    format: ({ folder, written, enter, hooksChanged }, context) => {
+        const words = wordsFor(context?.language);
+        const steps = [words.open(enter === undefined ? undefined : quoted(enter)), ...words.steps];
+        return [
+            styleText(["bold", "green"], `♜ ${written.length === 0 ? words.ready(folder) : words.set(folder)}`),
+            "",
+            `  ${words.toPlay}`,
+            ...steps.map((step, index) => `  ${styleText("cyan", `${index + 1}.`)} ${step.join("\n     ")}`),
+            ...(hooksChanged === true ? ["", `  ${styleText("yellow", words.hooksChanged)}`] : []),
+            ...(written.length === 0 ? [] : ["", styleText("gray", `  ${words.updated(written.length)}`)]),
+        ].join("\n");
+    },
+});
+const english = {
+    set: (folder) => `Chesspal is ready in ${folder}`,
+    ready: (folder) => `Chesspal is ready in ${folder}: nothing to change`,
+    toPlay: "To play:",
+    open: (enter) => enter === undefined ? ["Open Claude Code or Codex in this folder."] : [`Go into the folder: cd ${enter}`, "then open Claude Code (claude) or Codex (codex)."],
+    steps: [
+        ["The first time, it asks whether to trust the folder: say yes.", "Codex also asks about Chesspal's two hooks: choose Trust all.", "They are small helpers that let it notice your moves on the board."],
+        ["Say hello: the AI gives you the link to the board."],
+    ],
+    hooksChanged: "Chesspal's hooks for Codex have changed: when Codex asks about them, choose Trust all again.",
+    updated: (count) => `Updated ${count} ${count === 1 ? "file" : "files"}.`,
+};
+const italian = {
+    set: (folder) => `Chesspal è pronto in ${folder}`,
+    ready: (folder) => `Chesspal è già pronto in ${folder}: niente da cambiare`,
+    toPlay: "Per giocare:",
+    open: (enter) => enter === undefined ? ["Apri Claude Code o Codex in questa cartella."] : [`Entra nella cartella: cd ${enter}`, "poi apri Claude Code (claude) o Codex (codex)."],
+    steps: [
+        ["La prima volta ti chiede se fidarti della cartella: rispondi sì.", "Codex chiede anche dei due «hook» di Chesspal: scegli Trust all.", "Sono piccoli aiuti che gli fanno vedere le tue mosse sulla scacchiera."],
+        ["Saluta: l'AI ti dà il link della scacchiera."],
+    ],
+    hooksChanged: "Gli «hook» di Chesspal per Codex sono cambiati: quando Codex te lo chiede, scegli di nuovo Trust all.",
+    updated: (count) => count === 1 ? "Aggiornato 1 file." : `Aggiornati ${count} file.`,
+};
+function wordsFor(language) {
+    return language?.slice(0, 2).toLowerCase() === "it" ? italian : english;
+}
+/** A path as a shell reads it as one word: in quotes when it has spaces. */
+function quoted(path) {
+    return /\s/.test(path) ? `"${path}"` : path;
+}

package/dist/commands/lead-input.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { type Lead } from "../core/index.ts";
+/** A lead as its input reads it: pawns from White's side as a number, +1.5 or -3, or a mate it sees, "#3" White's or "#-3" Black's. */
+export declare const leadInput: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+/** Who is ahead in words, the side and by how much, so that the AI reads its own sign back (Anatolij). */
+export declare function aheadWords(lead: Lead): string;
+/** The lead an input gave, checked by leadInput. */
+export declare function leadFrom(value: number | string): Lead;

package/dist/commands/lead-input.js

@@ -0,0 +1,21 @@
+// Who is ahead as the AI gives it (D-90): the analyst after each move of a game over, the coach in the position the player is to move in.
+import { z } from "zod";
+import { readLead } from "../core/index.js";
+/** A lead as its input reads it: pawns from White's side as a number, +1.5 or -3, or a mate it sees, "#3" White's or "#-3" Black's. */
+export const leadInput = z.union([z.number(), z.string()]).refine((value) => readLead(String(value)) !== undefined, 'who is ahead is a number of pawns from White\'s side, 1.5 or -3, or a mate you see in moves of the side that mates, "#3" for White\'s or "#-3" for Black\'s, '
+    + "up to 99");
+/** Who is ahead in words, the side and by how much, so that the AI reads its own sign back (Anatolij). */
+export function aheadWords(lead) {
+    if ("mate" in lead) {
+        return `${lead.mate > 0 ? "White" : "Black"} mates in ${Math.abs(lead.mate)}`;
+    }
+    return lead.pawns === 0 ? "even" : `${lead.pawns > 0 ? "White" : "Black"} ahead by ${Math.abs(lead.pawns)}`;
+}
+/** The lead an input gave, checked by leadInput. */
+export function leadFrom(value) {
+    const lead = readLead(String(value));
+    if (lead === undefined) {
+        throw new Error(`${value} is not who is ahead: give a number of pawns from White's side, 1.5 or -3, or a mate you see, "#3" or "#-3". Nothing changed.`);
+    }
+    return lead;
+}

package/dist/commands/levels.d.ts

@@ -0,0 +1,9 @@
+import { type AiLevel, type Layer } from "../core/index.ts";
+import { type CurrentGame } from "../games/index.ts";
+import type { Context } from "./context.ts";
+/** The level of a new game when the call names none: the game before's, else the one that suits the player in use, else the level before levels came. */
+export declare function levelToPlay(context: Context, before: CurrentGame | undefined): AiLevel;
+/** The level and what the AI sees at it, in few words: at the club level (board and tactical facts: no position). */
+export declare function levelText(level: AiLevel): string;
+/** Throws when the game's level does not give a layer, saying what the level gives instead; a game over gives every layer, to its analysis (D-81). */
+export declare function refuseUnseen(current: CurrentGame, layer: Layer, tool: string): void;

package/dist/commands/levels.js

@@ -0,0 +1,25 @@
+// The level of a game as the AI reads it (D-60, D-61): what it sees, and the refusal of a tool its level does not give.
+import { levelOf, sees, suggestedLevel } from "../core/index.js";
+import { endOf } from "../games/index.js";
+import { activeProfile } from "../profiles/index.js";
+/** The level of a new game when the call names none: the game before's, else the one that suits the player in use, else the level before levels came. */
+export function levelToPlay(context, before) {
+    return suggestedLevel(before?.game.record, before === undefined ? activeProfile(context.home()).level : undefined);
+}
+/** The level and what the AI sees at it, in few words: at the club level (board and tactical facts: no position). */
+export function levelText(level) {
+    return `at the ${level} level (${seenText[level]})`;
+}
+/** Throws when the game's level does not give a layer, saying what the level gives instead; a game over gives every layer, to its analysis (D-81). */
+export function refuseUnseen(current, layer, tool) {
+    const level = levelOf(current.game.record);
+    if (!sees(level, layer) && endOf(current.game) === undefined) {
+        throw new Error(`${tool} is not yours in this game: you play ${levelText(level)}. Decide with the facts you have.`);
+    }
+}
+const seenText = {
+    beginner: "board and legal moves: no tactical facts, no position",
+    club: "board and tactical facts: no position",
+    strong: "board, tactical and positional facts",
+    master: "board, tactical and positional facts, opening book",
+};

package/dist/commands/look.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { type Facts, type Side } from "../core/index.ts";
+import { type GameSummary } from "./game-summary.ts";
+/** The game with the facts of its position, whoever is to move. */
+type Viewed = GameSummary & {
+    facts: Facts;
+};
+/** A position of a game studied (D-68): where it stands, and its facts. */
+interface StudyView {
+    where: string;
+    turn: Side;
+    fen: string;
+    facts: Facts;
+}
+/** The whole view (D-26), when the compact one after the player's move is not enough; or the board for the player, where the host does not show it (D-36). */
+export declare const look: import("./registry.ts").Command<z.ZodObject<{
+    game: z.ZodOptional<z.ZodString>;
+    move: z.ZodOptional<z.ZodString>;
+    only: z.ZodOptional<z.ZodEnum<{
+        board: "board";
+    }>>;
+}, z.core.$strip>, {
+    board: string;
+} | {
+    game: Viewed;
+    words: string[];
+} | {
+    study: StudyView;
+    words: string[];
+}>;
+export {};

package/dist/commands/look.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { boardText, materialOf } from "../core/index.js";
+import { analystAgent } from "../host-files/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { headLines, wordLines } from "./answer-lines.js";
+import { gameAt } from "./clock.js";
+import { summaryOf } from "./game-summary.js";
+import { refuseUnseen } from "./levels.js";
+import { defineCommand } from "./registry.js";
+import { newWords } from "./say.js";
+import { gameToStudy, positionAfter, positionLine, studyInput } from "./study.js";
+import { fullView, materialText } from "./view.js";
+/** The whole view (D-26), when the compact one after the player's move is not enough; or the board for the player, where the host does not show it (D-36). */
+export const look = defineCommand({
+    name: "look",
+    description: "Shows the whole view of the position, from the club level up and at every level once the game is over: the FEN and, for every piece, what attacks and defends it, then the pins, the checks and the legal "
+        + "moves of each piece. The views of player_move, status and new_game give attackers and defenders only for the pieces attacked: call look "
+        + 'before you attack or capture a piece that is not attacked yet, or plan an exchange. With only: "board", the board as text for the player, to '
+        + "copy into your message where they do not see it. With move, and game for a game of the archive, the same of any position of a game over, to "
+        + 'analyse it. Example: look {}, look {move: "12..."}.',
+    input: z.object({ only: z.enum(["board"]).optional().describe("board: only the board as text, for the player"), ...studyInput }),
+    // Read only for the host: a flag that has fallen is written, as the time already decided.
+    readOnly: true,
+    idempotent: true,
+    sharedWith: [analystAgent],
+    run: ({ only, game, move }, context) => {
+        if (game !== undefined || move !== undefined) {
+            return studyLook(context, only, game, move);
+        }
+        const current = gameAt(gameFolder(context.home()), context.now());
+        if (current === undefined) {
+            throw new Error("There is no game to look at: start one with new_game.");
+        }
+        if (only !== "board") {
+            refuseUnseen(current, "tactics", 'look without only: "board"');
+        }
+        return only === "board" ? { board: boardText(current.game.position.fen) } : { game: { ...summaryOf(current, context.now()), facts: current.game.facts }, words: newWords(context) };
+    },
+    format: (look) => {
+        if ("board" in look) {
+            return look.board;
+        }
+        return [...("game" in look ? [...headLines(look.game), ...fullView(look.game.facts, look.game.turn)] : studyLines(look.study)), ...wordLines(look.words)].join("\n");
+    },
+});
+/** A position of a game over, as the view of the game going on gives it. */
+function studyLook(context, only, name, move) {
+    const studied = gameToStudy(context, name);
+    const at = positionAfter(studied.record, move);
+    const { position } = at.game;
+    if (only === "board") {
+        return { board: boardText(position.fen) };
+    }
+    return { study: { where: positionLine(at, studied.name), turn: position.turn, fen: position.fen, facts: at.game.facts }, words: newWords(context) };
+}
+/** Where the position stands, the material, the FEN, and the whole view. */
+function studyLines({ where, turn, fen, facts }) {
+    return [
+        where,
+        `Material: ${materialText(materialOf(fen))}`,
+        `FEN: ${fen}`,
+        ...fullView(facts, turn),
+    ];
+}

package/dist/commands/new-game.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import type { Context } from "./context.ts";
+import { type GameSummary } from "./game-summary.ts";
+import { type Speech } from "./speech.ts";
+interface NewGame {
+    game: GameSummary;
+    /** Where the game before went: one going on, unfinished; one over, when its archive could not be written at its end. */
+    archived?: {
+        name: string;
+        finished: boolean;
+    };
+    /** The last games played with this player, for a chat that starts clean (D-57). */
+    past: string[];
+    /** Who plays, from the profile in use (D-23), once the player has completed it (D-71). */
+    player?: string;
+    /** The player's language when it is not English. */
+    speech?: Speech;
+    /** The board page's address when no browser has it open: the player needs it first. */
+    closedPage?: string;
+}
+/** The player chooses the game in the board page's window instead: open in a browser, or to be opened first at its address. */
+interface Asked {
+    window: "opened" | "closed";
+    page?: string;
+}
+declare const newGameInput: z.ZodObject<{
+    ai_colour: z.ZodOptional<z.ZodEnum<{
+        white: "white";
+        black: "black";
+        random: "random";
+    }>>;
+    from: z.ZodOptional<z.ZodString>;
+    clock: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<{
+        beginner: "beginner";
+        club: "club";
+        strong: "strong";
+        master: "master";
+    }>>;
+    replace: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/** A new game against the player, from the standard position or from a FEN or PGN; a game going on is never lost (D-41). */
+export declare const newGame: import("./registry.ts").Command<z.ZodObject<{
+    ai_colour: z.ZodOptional<z.ZodEnum<{
+        white: "white";
+        black: "black";
+        random: "random";
+    }>>;
+    from: z.ZodOptional<z.ZodString>;
+    clock: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<{
+        beginner: "beginner";
+        club: "club";
+        strong: "strong";
+        master: "master";
+    }>>;
+    replace: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, NewGame | Asked>;
+/**
+ * Starts the new game with the player's choices: those the AI asked in the chat, or the page's window gave (D-76). Only the chat's is refused on a game
+ * changed since it saw it (D-71): the player who presses New game on the page sees the game there (Federico, round of D-85).
+ */
+export declare function startNewGame({ ai_colour: colour, from, clock, level: chosen, replace }: z.output<typeof newGameInput>, context: Context, by: "chat" | "page"): NewGame;
+/** The refusal of a new game in a chat that still holds the game before (D-57): the board page says it in the player's language. */
+export declare class ChatNotClear extends Error {
+    constructor();
+}
+export {};

package/dist/commands/new-game.js

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import { aiLevels, Game, levelTag, pgnDate, readPgn, startClock, timeControlOf, timeControlTag, withoutMoods } from "../core/index.js";
+import { archivedName, archiveGame, cleanSince, endAnalysis, endOf, endTableTalk, lastChatStart, loadGame, saveGame, startOfNewGame, withoutPlans } from "../games/index.js";
+import { gameFolder, gameFolders } from "../profiles/index.js";
+import { coachRuns } from "./agents.js";
+import { nextStep, positionLines, sidesLine } from "./answer-lines.js";
+import { gameAt } from "./clock.js";
+import { summaryOf, withThought } from "./game-summary.js";
+import { levelText, levelToPlay } from "./levels.js";
+import { closedPage, pageGiven, pageLine } from "./page-link.js";
+import { pastGameLines } from "./past-games.js";
+import { refuseUnseenPosition } from "./play-move.js";
+import { playerLine } from "./profiles.js";
+import { defineCommand } from "./registry.js";
+import { speechLine, speechOf } from "./speech.js";
+const newGameInput = z.object({
+    ai_colour: z.enum(["white", "black", "random"]).optional().describe("the colour you play: random draws it; left out with the rest, the page's window asks"),
+    from: z.string().optional().describe("a FEN or a PGN to go on from, instead of the standard position"),
+    clock: z.string().optional().describe("the time control, minutes each and seconds added after each move, such as 10+5 or 3+0; none, or left out, for a game without a clock"),
+    level: z.enum(aiLevels).optional().describe("the facts you, not the player, get: beginner the board and the legal moves, club also the tactical facts, strong also the positional ones, master "
+        + "also the opening book's moves; left out, the last game's, or for the first game the one that suits the player's profile"),
+    replace: z.boolean().default(false).describe("start even though a game is going on: it goes to the archive unfinished"),
+});
+/** A new game against the player, from the standard position or from a FEN or PGN; a game going on is never lost (D-41). */
+export const newGame = defineCommand({
+    name: "new_game",
+    description: "Starts a new game against the player. Without choices it opens the board page's New game window, where the player chooses the colour, the clock "
+        + "and the level; where there is no board page, it tells you to ask them in the chat. With choices it starts the game: only where there is no board page, "
+        + 'or from a FEN or PGN the player gives. Example: new_game {}; new_game {ai_colour: "black", from: "<FEN or PGN>", level: "club"}.',
+    input: newGameInput,
+    alwaysLoad: true,
+    showsGame: true,
+    positionals: ["ai_colour"],
+    run: (input, context) => {
+        const { ai_colour: colour, from, clock, level } = input;
+        if (colour === undefined && from === undefined && clock === undefined && level === undefined) {
+            return askedOnPage(context);
+        }
+        // The game is played on the board page, and chosen in its window (D-85); a position to go on from is what the window cannot set.
+        if (context.page !== undefined && from === undefined) {
+            throw new Error("The player chooses a new game in the board page's New game window: call new_game without choices, which opens it, or gives you its address "
+                + "when nobody has the page open. Nothing changed.");
+        }
+        return startNewGame(input, context, "chat");
+    },
+    format: (result) => "window" in result ? askedLine(result) : startedLines(result),
+});
+/**
+ * Starts the new game with the player's choices: those the AI asked in the chat, or the page's window gave (D-76). Only the chat's is refused on a game
+ * changed since it saw it (D-71): the player who presses New game on the page sees the game there (Federico, round of D-85).
+ */
+export function startNewGame({ ai_colour: colour, from, clock, level: chosen, replace }, context, by) {
+    if (colour === undefined) {
+        throw new Error(from === undefined
+            ? "ai_colour: say the colour you play, white, black or random, with the other choices; or leave them all out for the page's window. Nothing changed."
+            : "ai_colour: say the colour you play from this position, white, black or random. Nothing changed.");
+    }
+    const control = clock === undefined || /^\s*none\s*$/i.test(clock) ? undefined : timeControlFrom(clock);
+    const now = context.now();
+    const folder = gameFolder(context.home());
+    const before = gameAt(folder, now);
+    const going = before !== undefined && endOf(before.game) === undefined ? before : undefined;
+    if (going !== undefined && !replace) {
+        const { moveNumber } = going.game.position;
+        throw new Error(`A game is going on, at move ${moveNumber}: end it with end_game, or call new_game with replace: true, which archives it unfinished. Nothing changed.`);
+    }
+    if (going !== undefined && by === "chat") {
+        refuseUnseenPosition(context, folder);
+    }
+    if (chatToClear(context)) {
+        throw new ChatNotClear();
+    }
+    const ai = colour === "random" ? (context.random() < 0.5 ? "white" : "black") : colour;
+    const level = chosen ?? levelToPlay(context, before);
+    const started = startOfNewGame(folder, now, before);
+    const game = startingGame(from, { ai, level }, started, control);
+    const current = control === undefined
+        ? { game, ai, started: started.toISOString(), talk: [] }
+        : { game, ai, started: started.toISOString(), talk: [], clock: startClock(control, now, context.pageOpen?.() === true) };
+    const archived = before === undefined || (going === undefined && archivedName(folder, before) !== undefined) ? undefined : archiveBefore(folder, before);
+    saveGame(folder, current);
+    endAnalysis(folder);
+    endTableTalk(folder);
+    const past = pastGameLines(folder, remembered);
+    const closed = closedPage(context);
+    const player = playerLine(context);
+    const speech = speechOf(folder, context.language);
+    if (closed !== undefined) {
+        pageGiven(context, current.started);
+    }
+    return {
+        game: withThought(summaryOf(current, now), folder, current, coachRuns(context)),
+        ...(archived === undefined ? {} : { archived: { name: archived, finished: going === undefined } }),
+        past,
+        ...(player === undefined ? {} : { player }),
+        ...(speech === undefined ? {} : { speech }),
+        ...(closed === undefined ? {} : { closedPage: closed }),
+    };
+}
+/** The new game's lines for the AI. */
+function startedLines({ game, archived, past, player, speech, closedPage: closed }) {
+    return [
+        `New game: ${sidesLine(game.ai)}, ${levelText(game.level)}.`,
+        ...(player === undefined ? [] : [player]),
+        ...(speech === undefined ? [] : [speechLine(speech)]),
+        ...(archived === undefined ? [] : [`The game before is in ${archived.name}${archived.finished ? "" : ", unfinished"}.`]),
+        ...(past.length === 0 ? [] : ["Last games with this player (past_games gives more, and their moves):", ...past]),
+        ...positionLines(game),
+        ...(closed === undefined ? [] : [pageLine(closed, true)]),
+        nextStep(game),
+    ].join("\n");
+}
+/**
+ * The New game window opened on the board page, or its address for the player to open it first; a chat to clear refuses it as a new game does (D-57), and
+ * without the page the player is asked in the chat.
+ */
+function askedOnPage(context) {
+    if (chatToClear(context)) {
+        throw new ChatNotClear();
+    }
+    if (context.askNewGame?.() === true) {
+        return { window: "opened" };
+    }
+    if (context.page !== undefined) {
+        return { window: "closed", page: context.page };
+    }
+    throw new Error("There is no board page here: ask the player which colour they want, whether they want a clock and at which level you play, then call new_game with "
+        + "them. Nothing changed.");
+}
+function askedLine({ window, page }) {
+    return window === "opened"
+        ? "The New game window is open on the board page: the player chooses the game there. Don't ask in the chat; end your turn, the doorbell wakes you when "
+            + "the game starts."
+        : `Nobody has the board page open: give the player its address, ${page}, and tell them to start the game there with its New game button. End your turn.`;
+}
+/** The refusal of a new game in a chat that still holds the game before (D-57): the board page says it in the player's language. */
+export class ChatNotClear extends Error {
+    constructor() {
+        super("The game before was played in this chat: ask the player to write /clear here, which empties the chat and keeps the games on disk, then "
+            + "start the new game. A clean chat plays faster and costs less. Nothing changed.");
+    }
+}
+/** How many of the last games new_game recalls. */
+const remembered = 3;
+/** From how many plies a game played in a chat asks for a clean one before the next (D-57): one left after a few moves does not. */
+const pliesBeforeClearing = 20;
+// A FEN's board: eight ranks of pieces and empty counts.
+const fenPattern = /^[pnbrqkPNBRQK1-8]+(?:\/[pnbrqkPNBRQK1-8]+){7}(?:\s|$)/;
+/**
+ * Whether the chat must be cleared first: the last game begun, in any profile, was played in it at some length, and the host says how chats start (the hook
+ * of Claude Code and Codex). Another profile does not clear the chat (D-66), nor a game another chat played, which this one was never shown (D-71).
+ */
+function chatToClear(context) {
+    const start = lastChatStart(context.folder);
+    if (!hostsNotingChats.has(context.host?.() ?? "") || start === undefined) {
+        return false;
+    }
+    const last = gameFolders(context.home()).flatMap((folder) => loadGame(folder) ?? []).sort((one, other) => Date.parse(other.started) - Date.parse(one.started))[0];
+    return last !== undefined && last.started === context.positionSeen?.started && last.game.record.moves.length >= pliesBeforeClearing && !cleanSince(start, last.started);
+}
+// The hosts whose SessionStart hook, written by init, notes how each chat starts: Claude Code and Codex, by the names they give the server.
+const hostsNotingChats = new Set(["claude-code", "codex-mcp-client"]);
+function archiveBefore(folder, before) {
+    try {
+        return archiveGame(folder, before);
+    }
+    catch (error) {
+        throw new Error(`${error.message} Nothing changed.`, { cause: error });
+    }
+}
+/**
+ * The new game: the standard position, or the one a FEN or PGN gives, which must still be going on. Its tags are Chesspal's, the AI's level among them:
+ * an imported game gives its position only.
+ */
+function startingGame(from, { ai, level }, started, control) {
+    const tags = {
+        Event: "Chesspal",
+        Date: pgnDate(started),
+        White: ai === "white" ? "AI" : "Player",
+        Black: ai === "black" ? "AI" : "Player",
+        [levelTag]: level,
+        ...(control === undefined ? {} : { TimeControl: timeControlTag(control) }),
+    };
+    let game;
+    try {
+        const record = from === undefined ? { tags: {}, moves: [] } : importedRecord(from.trim());
+        const fen = record.tags.FEN === undefined ? {} : { SetUp: "1", FEN: record.tags.FEN };
+        game = new Game({ tags: { ...tags, ...fen }, moves: record.moves });
+    }
+    catch (error) {
+        throw new Error(`from: ${error.message} Nothing changed.`);
+    }
+    const end = endOf(game);
+    if (end !== undefined) {
+        throw new Error(`from holds a game already over (${end.result}): give one still going on, or leave from out for a new game. Nothing changed.`);
+    }
+    return game;
+}
+function timeControlFrom(clock) {
+    try {
+        return timeControlOf(clock);
+    }
+    catch (error) {
+        throw new Error(`clock: ${error.message} Nothing changed.`);
+    }
+}
+function importedRecord(from) {
+    if (fenPattern.test(from)) {
+        return { tags: { SetUp: "1", FEN: from }, moves: [] };
+    }
+    const records = readPgn(from);
+    const [record] = records;
+    if (record === undefined || records.length > 1) {
+        throw new Error(`it holds ${records.length} games: give one, in PGN, or a FEN.`);
+    }
+    // Another game's [%plan] and [%mood] comments are not the AI's.
+    return withoutMoods(withoutPlans(record));
+}

package/dist/commands/opening-book.d.ts

@@ -0,0 +1,13 @@
+import { type GameRecord, type Opening } from "../core/index.ts";
+/** The game's opening as the AI reads it: ECO and name, and the move it left the book at; none outside the book, or where the build made no index. */
+export declare function openingLine(record: GameRecord): string | undefined;
+/** The moves the book knows from a position (D-15), for the AI at the master level; none out of the book, or where the build made no book. */
+export declare function knownMoves(fen: string): readonly string[];
+/** How many plies from the start the book knows, to the last before the game left it (D-69); none from another position. */
+export declare function bookPlies(record: GameRecord): number;
+/** Whether a line of Lichess's openings reaches a position, by any order of moves (D-68); never where the build made no book. */
+export declare function bookReaches(fen: string): boolean;
+/** The opening a game reached, ECO and name, without where it left the book: for the games in the archive. */
+export declare function openingName(record: GameRecord): string | undefined;
+/** The last named opening a game reached, and at which ply; none outside the book, or where the build made no index. */
+export declare function bookOpening(record: GameRecord): Opening | undefined;