chesspal 0.0.1 → 0.1.0

package/dist/commands/drawings.js

@@ -0,0 +1,23 @@
+// 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. */
+export 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 [ ] { }");
+/** The arrows the AI draws, as their input reads them. */
+export const arrowsInput = z.array(z.string().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(z.string().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,64 @@
+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 { gameGoingOn, nextStep, positionLines, 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);
+        return warning === undefined ? { game: summaryOf(ended, now, archive) } : { game: summaryOf(ended, now, archive), 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 (T-59). */
+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,26 @@
+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 (T-59). */
+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 current = gameAt(gameFolder(context.home()), 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(current);
+        return { format, text };
+    },
+    format: (result) => result.text,
+});

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

@@ -0,0 +1,95 @@
+import { type AiLevel, type Facts, 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), or turned off since it judged or drew on a move. */
+    helps?: "on" | "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, and its name in the archive once it is there. */
+    end?: {
+        result: string;
+        termination?: string;
+        archive?: string;
+    };
+}
+/** 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 (T-65). */
+    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). */
+export declare function withThought(summary: GameSummary, folder: string, current: CurrentGame): 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;
+/** Where the game stands: the AI's position to decide on, with its last move unless the lines before named it; the player's turn; or how it ended. */
+export declare function positionLines(game: GameSummary, withLastMove?: boolean): string[];
+/** The head of a view: where the game stands, the last move unless the lines before named it, the opening, the material as the player sees it, and the FEN. */
+export declare function headLines(game: GameSummary, withLastMove?: boolean): string[];
+/** The last move, as the player is shown it, with its squares: 4.♞g5 (f3-g5). */
+export declare function lastMoveText({ move, from, to }: LastMove): string;
+/**
+ * A numbered move as the player is shown it, with the pieces' figurines (D-86): the form alone, without the SAN, which the AI copied into its message
+ * (Priya, test of D-86): 4.Ng5 is 4.♞g5.
+ */
+export declare function shownMove(move: string): string;
+/** The player's language by its English name when it is not English. */
+export interface Speech {
+    language: string;
+}
+/** The player's speech, from the page's settings or the system's language; undefined in English, which the AI speaks unless told. */
+export declare function speechOf(folder: string, systemLanguage: string | undefined): Speech | undefined;
+/** What the AI is told of the player's speech once a chat (Priya, retest of T-54); the moves are SAN in every language (D-87). */
+export declare function speechLine({ language }: Speech): string;
+/** The lines after a move, which the line before named: its note, where the game stands, a warning. closingLines end them. */
+export declare function moveLines({ note, game, warning }: MovePlayed): string[];
+/** The last lines of a tool's answer: the player's words from the board page, then the next step, which stays the last line. */
+export declare function closingLines(game: GameSummary | undefined, words?: readonly string[]): string[];
+/** The player's words from the board page, one line each: lines they broke are joined, so no line of theirs reads as one of Chesspal's. */
+export declare function wordLines(words: readonly string[]): string[];
+/** What the AI does next: the one line every host reads, even where the server's instructions are not shown. Words of the player's ask for an answer. */
+export declare function nextStep(game: GameSummary | undefined, words?: readonly string[]): string;
+/** How a new game starts: the player chooses it in the board page's window, which new_game without choices opens; in the chat only where there is no page (D-85). */
+export declare const newGameStep: string;
+/** Who plays what, from the AI's side. */
+export declare function sidesLine(ai: Side): string;

package/dist/commands/game-summary.js

@@ -0,0 +1,239 @@
+// What the chess commands tell about the current game: plain data for the command line's JSON, and the lines an AI reads.
+import { figurinesOf, levelOf, materialOf, moodAt, sees } from "../core/index.js";
+import { currentPlan, drawOfferOf, endOf, talkLimits, thoughtForLastMove } from "../games/index.js";
+import { onQuickModel } from "../host-files/index.js";
+import { helpsIn, languageIn } from "../profiles/index.js";
+import { clockLine, clockSummaryOf, gameAt } from "./clock.js";
+import { knownMoves, openingLine } from "./opening-book.js";
+import { boardView, colourName, compactView, materialText } from "./view.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). */
+export function withThought(summary, folder, current) {
+    if (summary.turn !== summary.ai || summary.end !== undefined) {
+        return summary;
+    }
+    const thought = thoughtForLastMove(folder, current);
+    const helps = helpsIn(folder) ? "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;
+}
+/** Where the game stands: the AI's position to decide on, with its last move unless the lines before named it; the player's turn; or how it ended. */
+export function positionLines(game, withLastMove = true) {
+    if (game.end !== undefined || game.turn !== game.ai) {
+        return [whereLine(game), ...offerLines(game), ...clockLines(game), ...moodLines(game)];
+    }
+    return [
+        ...headLines(game, withLastMove),
+        ...(game.facts === undefined ? [] : (sees(game.level, "tactics") ? compactView : boardView)(game.facts, game.turn)),
+        ...(game.book === undefined ? [] : [`Book moves, most named lines first: ${game.book.join(", ")}`]),
+        ...(game.plan === undefined ? [] : [`Plan: ${game.plan}`]),
+        ...(game.thought === undefined ? [] : [thoughtLine(game.thought, game.level)]),
+        ...moodLines(game),
+        ...(game.helps === "on" ? [helpsLine] : game.helps === "off now" ? [helpsOffLine] : []),
+    ];
+}
+/** The helps turned on: the AI may teach as the analyst does (D-62, D-78), never playing for the player. */
+const helpsLine = "Helps on: the player wants to learn. Tell your intentions, never their best move; after their move judge it when it stands out (ai_move's badge "
+    + `and note), draw arrows and squares to show what you say, and write up to ${talkLimits.aiHelps} characters.`;
+/** The helps turned off during a game: what the AI said and drew before no longer holds (Priya, round of D-78). */
+const helpsOffLine = `Helps off now: play as at a tournament again: no intentions, badges or arrows, comments of ${talkLimits.ai} characters at most.`;
+/** 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 ?? ""));
+}
+/** The head of a view: where the game stands, the last move unless the lines before named it, the opening, the material as the player sees it, and the FEN. */
+export function headLines(game, withLastMove = true) {
+    return [
+        whereLine(game),
+        ...offerLines(game),
+        ...(withLastMove && game.lastMove !== undefined ? [`Last move: ${lastMoveText(game.lastMove)}.`] : []),
+        ...(game.opening === undefined ? [] : [`Opening: ${game.opening}`]),
+        `Material: ${materialText(materialOf(game.fen))}`,
+        ...clockLines(game),
+        `FEN: ${game.fen}`,
+    ];
+}
+/** The last move, as the player is shown it, with its squares: 4.♞g5 (f3-g5). */
+export function lastMoveText({ move, from, to }) {
+    return `${shownMove(move)} (${from}-${to})`;
+}
+/**
+ * A numbered move as the player is shown it, with the pieces' figurines (D-86): the form alone, without the SAN, which the AI copied into its message
+ * (Priya, test of D-86): 4.Ng5 is 4.♞g5.
+ */
+export function shownMove(move) {
+    const [, number = "", san = move] = /^(\d+\.+)(.+)$/.exec(move) ?? [];
+    return `${number}${figurinesOf(san)}`;
+}
+/** The player's speech, from the page's settings or the system's language; undefined in English, which the AI speaks unless told. */
+export function speechOf(folder, systemLanguage) {
+    const language = languageName(languageIn(folder, systemLanguage));
+    return language === undefined ? undefined : { language };
+}
+/** What the AI is told of the player's speech once a chat (Priya, retest of T-54); the moves are SAN in every language (D-87). */
+export function speechLine({ language }) {
+    return `The player speaks ${language}.`;
+}
+/** The lines after a move, which the line before named: its note, where the game stands, a warning. closingLines end them. */
+export function moveLines({ note, game, warning }) {
+    return [...(note === undefined ? [] : [`Note: ${note}`]), ...positionLines(game, false), ...(warning === undefined ? [] : [warning])];
+}
+/** The last lines of a tool's answer: the player's words from the board page, then the next step, which stays the last line. */
+export function closingLines(game, words = []) {
+    return [...wordLines(words), nextStep(game, words)];
+}
+/** The player's words from the board page, one line each: lines they broke are joined, so no line of theirs reads as one of Chesspal's. */
+export function wordLines(words) {
+    return words.map((text) => `Player wrote on the board page: «${text.replace(/\s+/g, " ")}»`);
+}
+/** What the AI does next: the one line every host reads, even where the server's instructions are not shown. Words of the player's ask for an answer. */
+export function nextStep(game, words = []) {
+    if (game === undefined) {
+        return words.length === 0 ? `Next: when the player wants a game, ${newGameStep}` : `Next: answer the player with ai_say. When they want a game, ${newGameStep}`;
+    }
+    if (game.end !== undefined) {
+        return words.length === 0
+            ? "Next: tell the player how the game ended, with ai_say and how you feel as its mood if they play on the board page; then offer them, in words, another game or "
+                + "to go over this one "
+                + `(analyse_game). For another, ${newGameStep}`
+            : `Next: answer the player with ai_say. When they want another game, ${newGameStep}`;
+    }
+    if (game.turn === game.ai && game.clock?.waiting === true) {
+        return "Next: don't move yet: the player starts the game with Start on the board page, and the doorbell wakes you then. End your turn.";
+    }
+    if (game.turn === game.ai) {
+        return words.length === 0
+            ? "Next: choose your move, then call ai_move with it, your plan and any comment."
+            : "Next: choose your move, then call ai_move with it, your plan and a comment that answers the player.";
+    }
+    if (game.drawOffer === "player") {
+        return "Next: accept the draw with end_game draw_agreed, or answer with ai_say and wait for the player's move.";
+    }
+    return words.length === 0 ? "Next: wait for the player's move, then call player_move with it." : "Next: answer the player with ai_say, then wait for their move.";
+}
+/** How a new game starts: the player chooses it in the board page's window, which new_game without choices opens; in the chat only where there is no page (D-85). */
+export const newGameStep = "call new_game 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.";
+/** Who plays what, from the AI's side. */
+export function sidesLine(ai) {
+    return `you play ${colourName(ai)}, the player ${colourName(ai === "white" ? "black" : "white")}`;
+}
+/** 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;
+    }
+}
+/** The draw offer that stands, and how to answer it or what becomes of it (D-65). */
+function offerLines({ drawOffer, turn, ai }) {
+    if (drawOffer === "ai") {
+        return ["Your draw offer stands until the player moves; if they accept it in the chat, end_game draw_agreed ends the game."];
+    }
+    if (drawOffer === "player") {
+        return [turn === ai ? "The player offers a draw: end_game draw_agreed accepts it; your move declines it." : "The player offers a draw before their move; your next move declines it."];
+    }
+    return [];
+}
+/** What the AI thought on the player's time, saying by which model and that Chesspal checked only that it is legal: the facts do not cover every blunder (Anatolij, round of T-109). */
+function thoughtLine({ move, why }, level) {
+    return `Thought on their time ${onQuickModel(level) ? "by a quicker model" : "by your model"} (legal, not checked): ${move}, ${why}`;
+}
+/** The AI's mood while it lasts, and how long its face shows it (D-70). */
+function moodLines({ mood }) {
+    if (mood === undefined) {
+        return [];
+    }
+    const shown = mood.left === 0 ? "until your next move" : `for ${mood.left} more of your moves`;
+    return [`Your mood: ${mood.mood}, on your face ${shown}, then neutral by itself.`];
+}
+/** Who is to move, or how the game ended. */
+function clockLines(game) {
+    return game.clock === undefined ? [] : [clockLine(game.clock, game.ai)];
+}
+function whereLine(game) {
+    if (game.end !== undefined) {
+        const archived = game.end.archive === undefined ? "" : ` Archived in ${game.end.archive}.`;
+        return `Game over: ${endText(game.end)}.${archived}`;
+    }
+    return `${game.turn === game.ai ? "You" : "Player"} (${colourName(game.turn)}) to move, move ${game.moveNumber}.`;
+}
+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. */
+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(" ");
+}
+/** A language by its English name when it is not English (Italian), from the way the system or the page names it (it-IT, it). */
+function languageName(language) {
+    const code = language?.split(/[-_]/)[0]?.toLowerCase() ?? "";
+    if (!/^[a-z]{2,3}$/.test(code) || code === "en" || code === "und") {
+        return undefined;
+    }
+    const name = new Intl.DisplayNames(["en"], { type: "language" }).of(code);
+    return name === undefined || name === code ? undefined : name;
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,3 @@
+import type { AnyCommand } from "./registry.ts";
+/** Every command of Chesspal, in the order the command line lists them and the MCP server offers them. */
+export declare const commands: AnyCommand[];

package/dist/commands/index.js

@@ -0,0 +1,19 @@
+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 { 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, setAvatar, useProfile } from "./profiles.js";
+import { status } from "./status.js";
+import { studyGames } from "./study-games.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, look, position, endGame, exportGame, pastGames, analyseGame, annotateGame, studyGames, profiles, newProfile, useProfile, setAvatar];

package/dist/commands/init.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+/** The player's folder set up for the AI hosts (T-7): 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 (T-127): chess. */
+    enter?: string;
+    /** Codex's hooks changed in a folder that had them: Codex runs them only once allowed again in /hooks (T-125). */
+    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.", "In Codex, also type /hooks and allow Chesspal's two hooks:", "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: in Codex, type /hooks and allow them 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ì.", "In Codex scrivi anche /hooks e consenti i due «hook» di Chesspal:", "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: in Codex scrivi /hooks e consentili di nuovo.",
+    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/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",
+};