chesspal 0.0.1 → 0.2.0

package/dist/commands/context.d.ts

@@ -0,0 +1,67 @@
+/** What a command runs with, besides its input: given by the command line or the MCP server, and by the tests. */
+export interface Context {
+    /** The folder Chesspal runs in: the player's, where the AI host started it, which keeps only the host's files (D-71). */
+    folder: string;
+    /** The player's data folder (D-71), with a profile in it: the profiles, their games and the games kept to study, the same for every chat. */
+    home: () => string;
+    /** A number from 0 to 1, as Math.random gives: the colour drawn for the AI. */
+    random: () => number;
+    /** The time now: when a game starts. */
+    now: () => Date;
+    /** Waits a while, in milliseconds: a tool that waits for the player, as ponder does; the tests move their clock instead. */
+    pause?: (milliseconds: number) => Promise<void>;
+    /** The operating system, as process.platform names it: how a host starts the server. */
+    platform: string;
+    /** The player's language, as the system names it (it-IT): the command line's words to the player, in English when none or another. */
+    language?: string;
+    /** The address of the board page, when the MCP server serves it (D-47). */
+    page?: string;
+    /** Whether a browser has the board page open now, when the MCP server serves it. */
+    pageOpen?: () => boolean;
+    /** Opens a folder in the system's file manager: the data folder, from the board page; whether it could; none in the tests. */
+    openFolder?: (folder: string) => Promise<boolean>;
+    /** Opens the New game window on the board pages open now, where the player chooses the game: whether one was open. */
+    askNewGame?: () => boolean;
+    /** The AI host, as it names itself to the MCP server: claude-code, which notes how each chat starts (D-57); none on the command line. */
+    host?: () => string | undefined;
+    /** The player's words on the board page given to the AI in this process, by line: each comes once. */
+    readonly given: Set<string>;
+    /** Told when the board page has news that no file holds: words the AI was given, which it shows read (D-53), and the AI's model (D-82). */
+    heard?: () => void;
+    /** Told when the chat calls a tool, before it runs: the board page hears the chat listens, and the AI's clock, held while nobody did, starts. */
+    calls?: () => void;
+    /** Told when the AI starts thinking on the player's time (D-72), with the position, and when it is done: the board page shows it. */
+    ponders?: (position: SeenPosition | undefined) => void;
+    /** The game the chat saw when its last tool ended, its folder and its stamp: the doorbell wakes it only for a game changed since. */
+    seen?: string | undefined;
+    /**
+     * The position the last tool that showed the game showed the chat: its moves are refused on a game changed since, by another chat or on the page
+     * (D-71); null in a chat no tool has shown the game yet, none outside a chat.
+     */
+    positionSeen?: SeenPosition | null | undefined;
+    /** The instructions the MCP server gave in this chat, by their name and the chat's start: each comes once a chat (D-68); none on the command line. */
+    told?: Set<string>;
+    /** Who makes this tool call, as far as the host ties it to the call (D-81); none on the command line. */
+    caller?: () => Promise<Caller | undefined>;
+    /** The agent that makes this call of a tool it shares with the chat, as the analyst (D-89); none for the chat, or when it cannot be told. */
+    agent?: string;
+}
+/** Who made a tool call: the model, else the host's name, never what the AI says of itself; the effort only when the host gives it. */
+export interface Caller {
+    readonly annotator: string;
+    readonly effort?: string;
+    /** The annotator is the host's name: the model is not known. */
+    readonly hostOnly?: boolean;
+}
+/**
+ * Where the game a chat sees stands: the game by its start, none when there is none, and how many plies it has. Not by its folder, which a profile
+ * completed renames (D-71); a game in another profile started at another time.
+ */
+export interface SeenPosition {
+    readonly started?: string;
+    readonly plies: number;
+}
+/** The context of a process started in the player's folder: the data folder is found at the first command that needs it, once. */
+export declare function defaultContext(): Context;
+/** A data folder with a profile in it, the first made when there is none, named after the system's account (D-71). */
+export declare function withProfile(folder: string, account: string): string;

package/dist/commands/context.js

@@ -0,0 +1,37 @@
+// What every command runs with besides its input, injected by the command line, the MCP server or the tests: the folders, the time, the randomness.
+import { userInfo } from "node:os";
+import { dataFolder, openFolder } from "../home/index.js";
+import { ensureProfile } from "../profiles/index.js";
+/** The context of a process started in the player's folder: the data folder is found at the first command that needs it, once. */
+export function defaultContext() {
+    let found;
+    const home = () => withProfile(found ??= dataFolder(), accountName());
+    return {
+        folder: process.cwd(),
+        home,
+        random: Math.random,
+        now: () => new Date(),
+        platform: process.platform,
+        language: systemLanguage(),
+        given: new Set(),
+        openFolder: (folder) => openFolder(folder, process.platform),
+    };
+}
+/** A data folder with a profile in it, the first made when there is none, named after the system's account (D-71). */
+export function withProfile(folder, account) {
+    ensureProfile(folder, account);
+    return folder;
+}
+/** The name the system knows the user by, for the first profile: Player when it has none. */
+function accountName() {
+    try {
+        return userInfo().username.trim() || "Player";
+    }
+    catch {
+        return "Player";
+    }
+}
+/** The system's language, as Node reads it: the user's locale on Windows, LANG and LC_ALL elsewhere. */
+function systemLanguage() {
+    return Intl.DateTimeFormat().resolvedOptions().locale;
+}

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

@@ -0,0 +1,7 @@
+import { z } from "zod";
+/** Deletes a game of the profile in use, by its name as past_games or study_games writes it. */
+export declare const deleteGame: import("./registry.ts").Command<z.ZodObject<{
+    game: z.ZodString;
+}, z.core.$strip>, {
+    deleted: string;
+}>;

package/dist/commands/delete-game.js

@@ -0,0 +1,30 @@
+// A game deleted from a profile (D-92): played here or kept to study, with its review. Only the command line and the page delete, never the AI.
+import { z } from "zod";
+import { deleteGame as deleteGameFile, endAnalysis, gameInAnalysis, isOverOnTable, listedName, removeGame } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { defineCommand } from "./registry.js";
+/** Deletes a game of the profile in use, by its name as past_games or study_games writes it. */
+export const deleteGame = defineCommand({
+    name: "delete_game",
+    description: "Deletes a game of the profile in use, played here or kept to study, with its review: it cannot be undone. "
+        + "Example: chesspal delete_game games/2026-11-02-153012.pgn.",
+    input: z.object({ game: z.string().min(1).describe("the game, as past_games or study_games writes it") }),
+    cliOnly: true,
+    destructive: true,
+    positionals: ["game"],
+    run: ({ game }, context) => {
+        const folder = gameFolder(context.home());
+        const name = listedName(folder, game);
+        // Asked before deleting, so that nothing fails halfway: the game over still on the table would go back to the archive with the next game.
+        const onTable = isOverOnTable(folder, name);
+        deleteGameFile(folder, name);
+        if (gameInAnalysis(folder)?.game === name) {
+            endAnalysis(folder);
+        }
+        if (onTable) {
+            removeGame(folder);
+        }
+        return { deleted: name };
+    },
+    format: ({ deleted }) => `${deleted} deleted, with its review.`,
+});

package/dist/commands/delete-review.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/** Deletes the review of a game of the profile in use, by its name as past_games or study_games writes it. */
+export declare const deleteReview: import("./registry.ts").Command<z.ZodObject<{
+    game: z.ZodString;
+}, z.core.$strip>, {
+    game: string;
+    reviewed: boolean;
+}>;

package/dist/commands/delete-review.js

@@ -0,0 +1,34 @@
+// A game's review deleted (D-92): the game stays, to analyse again, with another model or effort or after an update. Only the command line and the page
+// delete, never the AI.
+import { z } from "zod";
+import { isReviewed, unreviewed } from "../core/index.js";
+import { forgetCoach, gameInAnalysis, isOverOnTable, rewriteGame, startAnalysis } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { defineCommand } from "./registry.js";
+import { namedGame } from "./study.js";
+/** Deletes the review of a game of the profile in use, by its name as past_games or study_games writes it. */
+export const deleteReview = defineCommand({
+    name: "delete_review",
+    description: "Deletes the review of a game of the profile in use: the badges, notes, drawings and estimates on its moves, the word on the game and who "
+        + "signed it, the coach's judgments too; the game stays, to analyse again. Example: chesspal delete_review games/2026-11-02-153012.pgn.",
+    input: z.object({ game: z.string().min(1).describe("the game, as past_games or study_games writes it") }),
+    cliOnly: true,
+    destructive: true,
+    idempotent: true,
+    positionals: ["game"],
+    run: ({ game }, context) => {
+        const folder = gameFolder(context.home());
+        const { record, name } = namedGame(context, game);
+        rewriteGame(folder, name, unreviewed(record));
+        // The coach's judgments on the game just over would go back into it.
+        if (isOverOnTable(folder, name)) {
+            forgetCoach(folder);
+        }
+        // The page showing the game hears of it, and shows it without its review.
+        if (gameInAnalysis(folder)?.game === name) {
+            startAnalysis(folder, name, context.now());
+        }
+        return { game: name, reviewed: isReviewed(record) };
+    },
+    format: ({ game, reviewed }) => `${game}: ${reviewed ? "review deleted" : "it had no review; the judgments on its moves are deleted"}. analyse_game goes over it again.`,
+});

package/dist/commands/draw-offer.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from "./context.ts";
+/** A draw offer or answer refused, and why, for the page to say it in the player's language: one stands already, none stands, or no side has moved yet. */
+export declare class DrawRefused extends Error {
+    readonly reason: "offered" | "none" | "early";
+    constructor(message: string, reason: DrawRefused["reason"]);
+}
+/** The player offers a draw on their turn, once each side has moved: it stands until the AI accepts it or moves, and one stands at a time. */
+export declare function offerDraw(context: Context): void;
+/** The player's answer to the AI's draw offer: accepted, the game ends drawn by agreement; declined, it goes on. */
+export declare function answerDraw(context: Context, accept: boolean): void;

package/dist/commands/draw-offer.js

@@ -0,0 +1,43 @@
+// The draw offers of the board page (D-65): the player's, made on their turn as on Lichess, and their answer to the AI's, which ai_move makes with its move.
+import { bothSidesMoved, drawOfferOf, saveGame } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { endGame } from "./end-game.js";
+import { gameGoingOn } from "./game-summary.js";
+/** A draw offer or answer refused, and why, for the page to say it in the player's language: one stands already, none stands, or no side has moved yet. */
+export class DrawRefused extends Error {
+    reason;
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+    }
+}
+/** The player offers a draw on their turn, once each side has moved: it stands until the AI accepts it or moves, and one stands at a time. */
+export function offerDraw(context) {
+    const folder = gameFolder(context.home());
+    const current = gameGoingOn(folder, context.now());
+    const offer = drawOfferOf(current);
+    if (current.game.position.turn === current.ai) {
+        throw new Error("Offer a draw on your turn: wait for the AI's move. Nothing changed.");
+    }
+    if (!bothSidesMoved(current.game)) {
+        throw new DrawRefused("A draw can be offered once each side has made a move. Nothing changed.", "early");
+    }
+    if (offer !== undefined) {
+        throw new DrawRefused(offer === "player" ? "You have offered a draw already: it stands until the AI's move. Nothing changed." : "The AI offers a draw: accept it or decline it. Nothing changed.", "offered");
+    }
+    saveGame(folder, { ...current, drawOffer: "player" });
+}
+/** The player's answer to the AI's draw offer: accepted, the game ends drawn by agreement; declined, it goes on. */
+export function answerDraw(context, accept) {
+    const folder = gameFolder(context.home());
+    const current = gameGoingOn(folder, context.now());
+    if (drawOfferOf(current) !== "ai") {
+        throw new DrawRefused("The AI offers no draw to answer. Nothing changed.", "none");
+    }
+    if (accept) {
+        endGame.run({ result: "draw_agreed" }, context);
+    }
+    else {
+        saveGame(folder, { ...current, drawOffer: undefined });
+    }
+}

package/dist/commands/drawings.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { type DrawnArrow, type DrawnSquare } from "../core/index.ts";
+/** A note of the AI's on a move, as its input reads it: on one line of commands, so without brackets or braces. */
+export declare const noteInput: z.ZodString;
+/** The arrows the AI draws, as their input reads them. */
+export declare const arrowsInput: z.ZodOptional<z.ZodArray<z.ZodString>>;
+/** The squares the AI marks, as their input reads them. */
+export declare const squaresInput: z.ZodOptional<z.ZodArray<z.ZodString>>;
+/** The arrows and squares drawn, those that read; none of either left out. */
+export declare function drawingsOf(arrows?: readonly string[], squares?: readonly string[]): {
+    arrows?: DrawnArrow[];
+    squares?: DrawnSquare[];
+};

package/dist/commands/drawings.js

@@ -0,0 +1,25 @@
+// What the AI draws on the board to show what it says, as the analyst (D-69) and the opponent with the helps on (D-78): arrows and squares, as PGN's
+// %cal and %csl write them.
+import { z } from "zod";
+import { arrowOf, squareOf } from "../core/index.js";
+/** The most a note of the AI's on a move may hold: a few sentences. */
+const noteLimit = 700;
+// The most arrows, and the most squares, on one move.
+const drawLimit = 6;
+/** A note of the AI's on a move, as its input reads it: on one line of commands, so without brackets or braces. */
+export const noteInput = z.string().trim().min(1).max(noteLimit).regex(/^[^[\]{}]*$/, "write it without [ ] { }");
+// A drawing as the AI may write it, spaced or with a dash, as PGN writes it: "R f2 e1" and "Rf2-e1" are Rf2e1 (Priya).
+const drawing = z.string().overwrite((text) => text.replace(/[\s-]+/g, ""));
+/** The arrows the AI draws, as their input reads them. */
+export const arrowsInput = z.array(drawing.regex(/^[GRYB][a-h][1-8][a-h][1-8]$/, "an arrow is a colour's letter and two squares: Gf6e4; a single square goes in squares")
+    .refine((arrow) => arrow.slice(1, 3) !== arrow.slice(3, 5), "an arrow goes from a square to another: a single square goes in squares")).max(drawLimit).optional()
+    .describe("arrows on the board, as PGN's %cal writes them: Rf2e1. G green: the better move or the good idea; R red: a threat or the mistake; Y yellow: another way; B blue: a plan.");
+/** The squares the AI marks, as their input reads them. */
+export const squaresInput = z.array(drawing.regex(/^[GRYB][a-h][1-8]$/, "a square is a colour's letter and the square: Rf2")).max(drawLimit).optional()
+    .describe("squares to mark, as PGN's %csl writes them: Rf2; colours as for arrows");
+/** The arrows and squares drawn, those that read; none of either left out. */
+export function drawingsOf(arrows = [], squares = []) {
+    const drawnArrows = arrows.map(arrowOf).filter((arrow) => arrow !== undefined);
+    const drawnSquares = squares.map(squareOf).filter((square) => square !== undefined);
+    return { ...(drawnArrows.length === 0 ? {} : { arrows: drawnArrows }), ...(drawnSquares.length === 0 ? {} : { squares: drawnSquares }) };
+}

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { type GameSummary } from "./game-summary.ts";
+interface Ended {
+    game: GameSummary;
+    warning?: string;
+}
+/** The endings the board cannot see: a resignation, a draw agreed on an offer (D-65). Checkmate, stalemate and the draws by rule end the game by themselves (D-37). */
+export declare const endGame: import("./registry.ts").Command<z.ZodObject<{
+    result: z.ZodEnum<{
+        player_resigns: "player_resigns";
+        ai_resigns: "ai_resigns";
+        draw_agreed: "draw_agreed";
+    }>;
+    mood: z.ZodOptional<z.ZodEnum<{
+        neutral: "neutral";
+        happy: "happy";
+        surprised: "surprised";
+        worried: "worried";
+        thoughtful: "thoughtful";
+        sad: "sad";
+    }>>;
+}, z.core.$strip>, Ended>;
+export {};

package/dist/commands/end-game.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { canMate, endWithMood, Game, moods, timeLeft } from "../core/index.js";
+import { archiveEnded, bothSidesMoved, drawOfferOf, saveGame } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { withAnalyst } from "./agents.js";
+import { nextStep, positionLines } from "./answer-lines.js";
+import { gameGoingOn, summaryOf } from "./game-summary.js";
+import { refuseUnseenPosition } from "./play-move.js";
+import { defineCommand } from "./registry.js";
+import { colourName } from "./view.js";
+/** The endings the board cannot see: a resignation, a draw agreed on an offer (D-65). Checkmate, stalemate and the draws by rule end the game by themselves (D-37). */
+export const endGame = defineCommand({
+    name: "end_game",
+    description: "Ends the game by a resignation or a draw agreed; checkmate, stalemate and the draws by rule end it by themselves. Call it to resign, when "
+        + 'the player resigns in the chat, or to agree a draw while an offer stands: theirs, or yours they accept in the chat. Example: end_game {result: "player_resigns"}.',
+    input: z.object({
+        result: z.enum(["player_resigns", "ai_resigns", "draw_agreed"]).describe("how the game ends"),
+        mood: z.enum(moods).optional().describe("how you feel as the game ends, which your face on the board page keeps"),
+    }),
+    idempotent: true,
+    showsGame: true,
+    positionals: ["result"],
+    run: ({ result, mood }, context) => {
+        const now = context.now();
+        const folder = gameFolder(context.home());
+        refuseUnseenPosition(context, folder);
+        const current = gameGoingOn(folder, now);
+        if (result === "draw_agreed") {
+            refuseDraw(current);
+        }
+        const ending = result === "draw_agreed" ? { Result: "1/2-1/2", Termination: "draw agreed" } : resignation(current, result === "player_resigns" ? player(current) : current.ai);
+        const { record } = current.game;
+        const game = new Game({ ...record, tags: { ...record.tags, ...ending } });
+        if (mood !== undefined) {
+            endWithMood(game, mood);
+        }
+        // The clock stops at the end, with the time the side to move had spent.
+        const ended = current.clock === undefined
+            ? { ...current, game }
+            : { ...current, game, clock: { ...current.clock, left: timeLeft(current.clock, current.game.position.turn, now), since: now.toISOString() } };
+        saveGame(folder, ended);
+        const { archive, warning } = archiveEnded(folder, ended);
+        const summary = withAnalyst(summaryOf(ended, now, archive), context);
+        return warning === undefined ? { game: summary } : { game: summary, warning };
+    },
+    format: ({ game, warning }) => [...positionLines(game), ...(warning === undefined ? [] : [warning]), nextStep(game)].join("\n"),
+});
+/** A draw is agreed only on an offer that stands, once each side has moved (FIDE 5.2.3). */
+function refuseDraw(current) {
+    if (!bothSidesMoved(current.game)) {
+        throw new Error("A draw is agreed only once each side has made a move. Nothing changed.");
+    }
+    if (drawOfferOf(current) === undefined) {
+        throw new Error("No draw offer stands: the player offers one with their move (player_move with offer_draw), you with yours (ai_move with offer_draw). Nothing changed.");
+    }
+}
+/** The side that resigns loses, unless the other could not mate by any series of legal moves: then the game is drawn (FIDE 5.1.2). */
+function resignation(current, loser) {
+    const winner = loser === "white" ? "black" : "white";
+    if (canMate(current.game.position.fen, winner)) {
+        return { Result: loser === "white" ? "0-1" : "1-0", Termination: `${colourName(loser)} resigns` };
+    }
+    return { Result: "1/2-1/2", Termination: `${colourName(loser)} resigns and ${colourName(winner)} cannot mate` };
+}
+function player(current) {
+    return current.ai === "white" ? "black" : "white";
+}

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

@@ -0,0 +1,14 @@
+import { z } from "zod";
+interface Exported {
+    format: "pgn" | "moves" | "fen";
+    text: string;
+}
+/** The game as PGN or its position as FEN, for the player to copy or keep: the plans stay hidden while it goes on (D-29); the moves alone for another site. */
+export declare const exportGame: import("./registry.ts").Command<z.ZodObject<{
+    format: z.ZodEnum<{
+        fen: "fen";
+        moves: "moves";
+        pgn: "pgn";
+    }>;
+}, z.core.$strip>, Exported>;
+export {};

package/dist/commands/export-game.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { movesPgn, playerPgn } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { gameAt } from "./clock.js";
+import { defineCommand } from "./registry.js";
+/** The game as PGN or its position as FEN, for the player to copy or keep: the plans stay hidden while it goes on (D-29); the moves alone for another site. */
+export const exportGame = defineCommand({
+    name: "export",
+    description: "Gives the game as PGN, its moves alone as PGN for Lichess or chess.com, or its position as FEN, for the player to copy or keep. While the game goes on, "
+        + 'the PGN leaves out your plans. Example: export {format: "moves"}.',
+    input: z.object({
+        format: z.enum(["pgn", "moves", "fen"]).describe("pgn for the whole game with its comments, moves for the moves alone, to load on Lichess or chess.com, fen for the position"),
+    }),
+    // Read only for the host: a flag that has fallen is written, as the time already decided.
+    readOnly: true,
+    positionals: ["format"],
+    run: ({ format }, context) => {
+        const folder = gameFolder(context.home());
+        const current = gameAt(folder, context.now());
+        if (current === undefined) {
+            throw new Error("There is no game to export: start one with new_game.");
+        }
+        const text = format === "fen" ? current.game.position.fen : format === "moves" ? movesPgn(current) : playerPgn(folder, current);
+        return { format, text };
+    },
+    format: (result) => result.text,
+});

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

@@ -0,0 +1,78 @@
+import { type AiLevel, type Facts, type GameRecord, type MoodNow, type Side, type Square } from "../core/index.ts";
+import { type CurrentGame, type Speaker, type Thought } from "../games/index.ts";
+import { type ClockSummary } from "./clock.ts";
+/** The current game, as the commands give it. */
+export interface GameSummary {
+    ai: Side;
+    /** The AI's level: the layers of facts it gets (D-60). */
+    level: AiLevel;
+    turn: Side;
+    moveNumber: number;
+    fen: string;
+    /** The last moves, numbered: 3.Bc4 Nf6 4.Ng5 d5. */
+    lastMoves: string;
+    /** The last move, numbered, with its squares. */
+    lastMove?: LastMove;
+    /** The opening by Lichess's book (D-15): ECO and name, and the move the game left the book at. */
+    opening?: string;
+    /** When the AI is to move: the facts of the position (D-26); below the club level, only the check and the legal moves of each piece are shown. */
+    facts?: Facts;
+    /** When the AI is to move at the master level, in the book: the moves it knows from the position (D-15, D-60). */
+    book?: readonly string[];
+    /** When the AI is to move: the plan it wrote last. */
+    plan?: string;
+    /** When the AI is to move: what it thought of the player's move on their time (D-72). */
+    thought?: Thought;
+    /** When the AI is to move: the helps on, so it may teach (D-78), with a coach that judges the player's moves (D-88), or turned off since it drew on a move. */
+    helps?: "on" | "coached" | "off now";
+    /** In a game with a time control: the time each side had left when the command ran (D-13). */
+    clock?: ClockSummary;
+    /** Who offered a draw, while the offer stands (D-65). */
+    drawOffer?: Speaker;
+    /** The AI's mood while it lasts, in a game going on (D-70). */
+    mood?: MoodNow;
+    /**
+     * When the game is over: how it ended, its name in the archive once it is there, and, where an analyst agent runs (D-89), whether the chat offers it or
+     * goes over the review it did.
+     */
+    end?: {
+        result: string;
+        termination?: string;
+        archive?: string;
+        analyst?: "offer" | "done";
+    };
+}
+/** A move numbered as in the game (4.Ng5, 4...d5), with the squares it went from and to. */
+export interface LastMove {
+    move: string;
+    from: Square;
+    to: Square;
+}
+/** A move played by the AI or the player, with where the game stands after it. */
+export interface MovePlayed {
+    /** The move, numbered as in the game: 4.Ng5, 4...d5. */
+    move: string;
+    /** A + or # the move was written with and does not give. */
+    note?: string;
+    game: GameSummary;
+    /** What went wrong after the move was saved, such as the archive not written. */
+    warning?: string;
+    /** What the player wrote on the board page that the AI has not been given yet. */
+    words?: string[];
+}
+/** The game as the commands tell it; a game over with the name it has in the archive, when it is there. */
+export declare function summaryOf(current: CurrentGame, now: Date, archive?: string): GameSummary;
+/**
+ * The summary with what the AI reads when it is to move: what it thought of the player's last move on their time (D-72), and whether the helps are on (D-78),
+ * with a coach when `coached`.
+ */
+export declare function withThought(summary: GameSummary, folder: string, current: CurrentGame, coached: boolean): GameSummary;
+/** The current game `now`, refused when there is none or when it is over, on time too. */
+export declare function gameGoingOn(folder: string, now: Date): CurrentGame;
+/** How a game ended, in words: its result, and how it came when known. */
+export declare function endText({ result, termination }: {
+    result: string;
+    termination?: string;
+}): string;
+/** The last plies of a record, numbered as a player writes them, from the move number and side of its FEN. */
+export declare function lastMoves(record: GameRecord, count: number): string;

package/dist/commands/game-summary.js

@@ -0,0 +1,102 @@
+// The current game as the commands give it: plain data for the command line's JSON, from which answer-lines.ts writes the lines an AI reads.
+import { levelOf, moodAt, sees } from "../core/index.js";
+import { currentPlan, drawOfferOf, endOf, thoughtForLastMove } from "../games/index.js";
+import { helpsIn } from "../profiles/index.js";
+import { clockSummaryOf, gameAt } from "./clock.js";
+import { knownMoves, openingLine } from "./opening-book.js";
+/** The game as the commands tell it; a game over with the name it has in the archive, when it is there. */
+export function summaryOf(current, now, archive) {
+    const { game, ai } = current;
+    const { position, record, lastMove } = game;
+    const end = endOf(game);
+    const level = levelOf(record);
+    const summary = { ai, level, turn: position.turn, moveNumber: position.moveNumber, fen: position.fen, lastMoves: lastMoves(record, 6) };
+    if (lastMove !== undefined) {
+        summary.lastMove = { move: lastMoves(record, 1), from: lastMove.from, to: lastMove.to };
+    }
+    const opening = openingLine(record);
+    const clock = clockSummaryOf(current, now);
+    const drawOffer = drawOfferOf(current);
+    if (drawOffer !== undefined) {
+        summary.drawOffer = drawOffer;
+    }
+    const mood = moodAt(record, ai);
+    if (end === undefined && mood.mood !== "neutral") {
+        summary.mood = mood;
+    }
+    if (clock !== undefined) {
+        summary.clock = clock;
+    }
+    if (opening !== undefined) {
+        summary.opening = opening;
+    }
+    if (end !== undefined) {
+        summary.end = archive === undefined ? end : { ...end, archive };
+    }
+    else if (position.turn === ai) {
+        addAiFacts(summary, current);
+    }
+    return summary;
+}
+/**
+ * The summary with what the AI reads when it is to move: what it thought of the player's last move on their time (D-72), and whether the helps are on (D-78),
+ * with a coach when `coached`.
+ */
+export function withThought(summary, folder, current, coached) {
+    if (summary.turn !== summary.ai || summary.end !== undefined) {
+        return summary;
+    }
+    const thought = thoughtForLastMove(folder, current);
+    const helps = helpsIn(folder) ? (coached ? "coached" : "on") : judgedBefore(current) ? "off now" : undefined;
+    return { ...summary, ...(thought === undefined ? {} : { thought }), ...(helps === undefined ? {} : { helps }) };
+}
+/** The current game `now`, refused when there is none or when it is over, on time too. */
+export function gameGoingOn(folder, now) {
+    const current = gameAt(folder, now);
+    if (current === undefined) {
+        throw new Error("There is no game going on: start one with new_game. Nothing changed.");
+    }
+    const end = endOf(current.game);
+    if (end !== undefined) {
+        throw new Error(`The game is over (${endText(end)}): new_game starts another. Nothing changed.`);
+    }
+    return current;
+}
+/** How a game ended, in words: its result, and how it came when known. */
+export function endText({ result, termination }) {
+    return termination === undefined ? result : `${result}, ${termination}`;
+}
+/** The last plies of a record, numbered as a player writes them, from the move number and side of its FEN. */
+export function lastMoves(record, count) {
+    const [, turn, , , , number] = (record.tags.FEN ?? "").split(" ");
+    const startNumber = Number(number) || 1;
+    // The ply count from white's move of the first move number: 1 when black moves first.
+    const offset = turn === "b" ? 1 : 0;
+    const first = Math.max(0, record.moves.length - count);
+    return record.moves.slice(first).map((move, index) => {
+        const ply = first + index + offset;
+        const moveNumber = startNumber + Math.floor(ply / 2);
+        if (ply % 2 === 0) {
+            return `${moveNumber}.${move.san}`;
+        }
+        return index === 0 ? `${moveNumber}...${move.san}` : move.san;
+    }).join(" ");
+}
+/** Whether the AI judged or drew on a move of this game, which only the helps allow: a sign they were on. */
+function judgedBefore(current) {
+    return current.game.record.moves.some((move) => /\[%(badge|review|cal|csl) /.test(move.comment ?? ""));
+}
+/** What the AI gets when it is to move: the facts its level sees (D-60), and its plan. */
+function addAiFacts(summary, { game }) {
+    const plan = currentPlan(game.record);
+    summary.facts = game.facts;
+    if (sees(summary.level, "theory")) {
+        const book = knownMoves(summary.fen);
+        if (book.length > 0) {
+            summary.book = book;
+        }
+    }
+    if (plan !== undefined) {
+        summary.plan = plan;
+    }
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,18 @@
+import type { AnyCommand } from "./registry.ts";
+export { aiMove } from "./ai-move.ts";
+export { analyseGame } from "./analyse-game.ts";
+export { gameAt } from "./clock.ts";
+export { type Caller, type Context, defaultContext, type SeenPosition } from "./context.ts";
+export { deleteGame } from "./delete-game.ts";
+export { deleteReview } from "./delete-review.ts";
+export { answerDraw, DrawRefused, offerDraw } from "./draw-offer.ts";
+export { endGame } from "./end-game.ts";
+export { ChatNotClear, newGame, startNewGame } from "./new-game.ts";
+export { bookOpening, bookPlies } from "./opening-book.ts";
+export { playMove, PositionChanged, positionIn, samePosition } from "./play-move.ts";
+export { chooseDrawnAvatar, GameGoingOn, newProfile, setAccounts, useProfile } from "./profiles.ts";
+export { type AnyCommand, baseType, type Command, commandLineFieldProblem, inputProblems, isBoolean, isList, takesNumbers } from "./registry.ts";
+export { say } from "./say.ts";
+export { gameToStudy, namedGame } from "./study.ts";
+/** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
+export declare const commands: AnyCommand[];