chesspal 0.0.1 → 0.2.0

package/dist/commands/status.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { type GameSummary } from "./game-summary.ts";
+import { type Speech } from "./speech.ts";
+interface Status {
+    version: string;
+    folder: string;
+    /** The board page's address, where the player plays when the chat serves it. */
+    page?: string;
+    /** No browser has the board page open: the player needs its address first. */
+    pageClosed?: true;
+    /** 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;
+    game?: GameSummary;
+    /** Why the game on disk cannot be read, when it cannot. */
+    problem?: string;
+    /** What the player wrote on the board page that the AI has not answered yet, all of it. */
+    words?: string[];
+    /** The game in analysis on the board page once none goes on (D-69), which the player may have brought there. */
+    analysis?: {
+        game: string;
+        brought?: true;
+        analyst?: true;
+    };
+    /** A game going on from before this chat, told once a chat: the player says whether to go on with it. */
+    fromBefore?: true;
+    /** The coach to start, once, for the player's move that ended the game (D-88). */
+    coach?: true;
+    /** The files an older init wrote in the player's folder, which this version would write otherwise. */
+    outdated?: string[];
+}
+/** What Chesspal sees now, the first call of a chat: a dashboard under 150 tokens while the player is to move, with the next step. */
+export declare const status: import("./registry.ts").Command<z.ZodObject<{}, z.core.$strip>, Status>;
+export {};

package/dist/commands/status.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { archivedName, cleanSince, endOf, gameInAnalysis, lastChatStart } from "../games/index.js";
+import { coachAgent, outdatedHostFiles } from "../host-files/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { version } from "../version.js";
+import { agentsLine, analystLine, analystRuns, coachOnEnd, coachRuns, reviewedLine, withAnalyst } from "./agents.js";
+import { closingLines, newGameStep, positionLines, sidesLine, wordLines } from "./answer-lines.js";
+import { gameAt } from "./clock.js";
+import { summaryOf, withThought } from "./game-summary.js";
+import { levelText } from "./levels.js";
+import { closedPage, pageGiven, pageLine } from "./page-link.js";
+import { playerLine } from "./profiles.js";
+import { defineCommand } from "./registry.js";
+import { unansweredWords } from "./say.js";
+import { speechLine, speechOf } from "./speech.js";
+/** What Chesspal sees now, the first call of a chat: a dashboard under 150 tokens while the player is to move, with the next step. */
+export const status = defineCommand({
+    name: "status",
+    description: "Shows what Chesspal sees now: its version, the profile's folder and the game, with your next step. Call it at the start of every chat, "
+        + "before anything else.",
+    input: z.object({}),
+    // Read only for the host: a flag that has fallen is written, as the time already decided.
+    readOnly: true,
+    alwaysLoad: true,
+    showsGame: true,
+    run: (input, context) => {
+        // The folder is the profile's, in the data folder (D-71): the names of its games are relative to it.
+        const folder = gameFolder(context.home());
+        const player = playerLine(context);
+        const speech = speechOf(folder, context.language);
+        const outdated = outdatedHostFiles(context.folder, context.platform);
+        const status = { version, folder, ...(player === undefined ? {} : { player }), ...(speech === undefined ? {} : { speech }), ...(outdated.length === 0 ? {} : { outdated }) };
+        if (context.page !== undefined) {
+            status.page = context.page;
+        }
+        if (closedPage(context) !== undefined) {
+            status.pageClosed = true;
+        }
+        const first = firstInChat(context);
+        try {
+            const current = gameAt(folder, context.now());
+            // With no game the player may have written before the first (D-77).
+            const words = unansweredWords(context);
+            if (words.length > 0) {
+                status.words = words;
+            }
+            if (current !== undefined) {
+                status.game = withAnalyst(withThought(summaryOf(current, context.now(), archivedName(folder, current)), folder, current, coachRuns(context)), context, current);
+                if (status.pageClosed === true) {
+                    pageGiven(context, current.started);
+                }
+                if (first && endOf(current.game) === undefined && fromBeforeChat(context, current.started)) {
+                    status.fromBefore = true;
+                }
+                // The player's move on the board page that ended the game: the coach judges it too (D-88).
+                if (coachOnEnd(context, folder, current)) {
+                    status.coach = true;
+                }
+            }
+            const analysis = current === undefined || status.game?.end !== undefined ? gameInAnalysis(folder) : undefined;
+            if (analysis !== undefined) {
+                // The analyst agent goes over a game the player brought, where it runs, and the chat over what it reviewed (D-89).
+                status.analysis = { game: analysis.game, ...(analysis.brought === true ? { brought: true } : {}), ...(analystRuns(context) ? { analyst: true } : {}) };
+            }
+        }
+        catch (error) {
+            status.problem = error.message;
+        }
+        return status;
+    },
+    format: ({ version, folder, page, pageClosed, player, speech, game, problem, words = [], analysis, fromBefore, coach, outdated }) => [
+        `Chesspal ${version}. Folder: ${folder}`,
+        ...(outdated === undefined ? [] : [outdatedLine(outdated)]),
+        ...(page === undefined ? [] : [pageLine(page, pageClosed === true)]),
+        ...(player === undefined ? [] : [player]),
+        ...(speech === undefined ? [] : [speechLine(speech)]),
+        ...(fromBefore === true ? [fromBeforeLine] : []),
+        ...(problem !== undefined ? [problem] : gameLines(game, words, analysis?.brought === true, pageClosed === true, coach === true)),
+        ...(analysis === undefined ? [] : [analysisLine(analysis)]),
+    ].join("\n"),
+});
+/** An older init's files in the player's folder: the player runs init again, with the chat closed, since the host reads them as a chat starts. */
+function outdatedLine(files) {
+    return `This folder was set up by an older Chesspal (${files.join(", ")}): tell the player, in their language, to close this chat, run "chesspal init" `
+        + "in this folder and open a new chat. Until then the agents and your instructions are the old ones.";
+}
+// The game going on as a chat starts: the player may have come back for it, or want another.
+const fromBeforeLine = "A game from before this chat is going on: ask the player whether to go on with it. For a new one, " + newGameStep;
+/**
+ * Whether this is the chat's first status: once a chat where the MCP server keeps what it told, again in a chat cleared or summarized, since its start keys
+ * it (D-57); never on the command line.
+ */
+function firstInChat(context) {
+    const key = `game before ${lastChatStart(context.folder)?.at ?? ""}`;
+    if (context.told === undefined || context.told.has(key)) {
+        return false;
+    }
+    context.told.add(key);
+    return true;
+}
+/** Whether a game began before the chat: one a summarized or resumed chat still holds is its own; without the host's word, any game is. */
+function fromBeforeChat(context, started) {
+    const start = lastChatStart(context.folder);
+    return start === undefined || cleanSince(start, started);
+}
+/** The game in analysis; the next step when the player has just brought it on the board page. */
+function analysisLine({ game, brought, analyst }) {
+    if (brought === true) {
+        return analyst === true
+            ? `The player brought ${game} on the board page to analyse it. Next: ${analystLine(game)}`
+            : `The player brought ${game} on the board page to analyse it. Next: call analyse_game {"game": "${game}"}, then keep your review on that page with annotate_game, and go over it with them.`;
+    }
+    return analyst === true
+        ? `In analysis on the board page: ${game}. ${reviewedLine(game)}`
+        : `In analysis on the board page: ${game}; analyse_game {"game": "${game}"} goes over it with the player.`;
+}
+/**
+ * The game's lines; a game the player brought to analyse takes the place of the next step. The coach to start goes just before the next step, where
+ * the AI acts on it (Priya).
+ */
+function gameLines(game, words, brought, pageClosed, coach) {
+    const closing = [...(coach ? [agentsLine([coachAgent])] : []), ...(brought ? wordLines(words) : closingLines(game, words, pageClosed))];
+    if (game === undefined) {
+        return ["No game.", ...closing];
+    }
+    const moves = game.lastMoves === "" ? [] : [`Moves: ${game.lastMoves}`];
+    return [`Game: ${sidesLine(game.ai)}, ${levelText(game.level)}.`, ...moves, ...positionLines(game), ...closing];
+}

package/dist/commands/study-games.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+/** The games kept to study, one line each, the latest kept first. */
+export declare const studyGames: import("./registry.ts").Command<z.ZodObject<{}, z.core.$strip>, {
+    games: string[];
+}>;

package/dist/commands/study-games.js

@@ -0,0 +1,40 @@
+// The games kept to study (D-68): played elsewhere and brought to analyse_game as a PGN, in the folder of the profile that brought them.
+import { z } from "zod";
+import { keptGame, keptGames } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { openingName } from "./opening-book.js";
+import { defineCommand } from "./registry.js";
+import { knownTag } from "./study.js";
+/** The games kept to study, one line each, the latest kept first. */
+export const studyGames = defineCommand({
+    name: "study_games",
+    description: "Lists the games kept to study, which the player brought from elsewhere, the latest kept first: who played, when, "
+        + "the result, the opening, how long, and its name. analyse_game with pgn keeps a game here; analyse_game, look and position take its name as game. "
+        + "Example: study_games {}.",
+    input: z.object({}),
+    readOnly: true,
+    idempotent: true,
+    run: (input, context) => {
+        const folder = gameFolder(context.home());
+        return { games: keptGames(folder).flatMap((name) => studyLines(folder, name)) };
+    },
+    format: ({ games }) => (games.length === 0 ? "No game kept to study yet: analyse_game with the PGN of a game played elsewhere keeps it here." : games.join("\n")),
+});
+/** Ann vs Bob, 2026.10.01: 1-0, C23 Bishop's Opening, 4 moves. study/2026-11-04-153012.pgn; none for a game that cannot be read. */
+function studyLines(root, name) {
+    let record;
+    try {
+        record = keptGame(root, name);
+    }
+    catch {
+        // A game that cannot be read stays out of the list.
+        return [];
+    }
+    const { tags, moves } = record;
+    const date = knownTag(tags.Date);
+    const result = tags.Result === undefined || tags.Result === "*" ? "result unknown" : tags.Result;
+    const opening = openingName(record);
+    const count = Math.ceil(moves.length / 2);
+    const players = `${tags.White ?? "?"} vs ${tags.Black ?? "?"}${date === undefined ? "" : `, ${date}`}`;
+    return [`${players}: ${result}${opening === undefined ? "" : `, ${opening}`}, ${count} ${count === 1 ? "move" : "moves"}. ${name}`];
+}

package/dist/commands/study.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { Game, type GameRecord } from "../core/index.ts";
+import { type CurrentGame } from "../games/index.ts";
+import type { Context } from "./context.ts";
+/** What look and position take to show any position of a game that is over. */
+export declare const studyInput: {
+    game: z.ZodOptional<z.ZodString>;
+    move: z.ZodOptional<z.ZodString>;
+};
+/** A game to study: its record, and its name in the archive when it is there. */
+export interface Studied {
+    readonly record: GameRecord;
+    readonly name?: string;
+}
+/** A position of a game: the game as it stood after a move, and that move as the analysis writes it (12...Kf8); none at the start. */
+export interface StudiedPosition {
+    readonly game: Game;
+    readonly move?: string;
+}
+/** The current game when it is over, or none; refused while it goes on, for every game: games are analysed once the one being played is over. */
+export declare function noGameGoingOn(context: Context): CurrentGame | undefined;
+/** The game played or kept to study by that name; without one, the current game over, or else the latest of the archive; refused while a game goes on. */
+export declare function gameToStudy(context: Context, name?: string): Studied;
+/** A game played or kept to study by its name as the lists write it, or without its folder or its .pgn; refused when it is not there. */
+export declare function namedGame(context: Context, name: string): Required<Studied>;
+/** The index of a move in the game's record, given as analyse_game numbers it: 12. for White's, 12... for Black's, 12...Kf8 too. */
+export declare function moveIndex(record: GameRecord, move: string): number;
+/** The number of each move of a game as the analysis writes it: 1. for White's first move, 1... for Black's. */
+export declare function moveNumbers(record: GameRecord): string[];
+/**
+ * The game as it stood after a move, given by its number (12. for White's, 12... for Black's) and, if wanted, the move itself (12...Kf8), which decides
+ * the side when the dots do not; after the last move without one.
+ */
+export declare function positionAfter(record: GameRecord, move?: string): StudiedPosition;
+/** A tag PGN leaves unknown with ? or -, as nothing. */
+export declare function knownTag(tag: string | undefined): string | undefined;
+/** Where a position of a game studied stands: After 12...Kf8 in games/2026-11-02-153012.pgn: White to move. */
+export declare function positionLine({ game, move }: StudiedPosition, name?: string): string;

package/dist/commands/study.js

@@ -0,0 +1,106 @@
+// A game to study (D-68): one that is over, played here or kept to study, and any position of it, by its moves as the analysis numbers them. While a game
+// goes on, nothing is studied: the analysis would help the game being played (D-60, D-62).
+import { z } from "zod";
+import { Game } from "../core/index.js";
+import { archivedGame, archivedGames, archivedName, endOf, keptGame, listedName } from "../games/index.js";
+import { gameFolder } from "../profiles/index.js";
+import { gameAt } from "./clock.js";
+import { colourName } from "./view.js";
+/** What look and position take to show any position of a game that is over. */
+export const studyInput = {
+    game: z.string().optional().describe("a game's name, as past_games, study_games or analyse_game writes it: one of its positions"),
+    move: z.string().optional().describe("the position after this move of a game over, as analyse_game numbers it: 12. for White's, 12... for Black's"),
+};
+/** The current game when it is over, or none; refused while it goes on, for every game: games are analysed once the one being played is over. */
+export function noGameGoingOn(context) {
+    const current = gameAt(gameFolder(context.home()), context.now());
+    if (current !== undefined && endOf(current.game) === undefined) {
+        throw new Error("A game is going on: games are analysed once it is over, this one and the others, and not by you from a PGN or a file either. Tell the player, and go "
+            + "over it when it ends. Nothing changed.");
+    }
+    return current;
+}
+/** The game played or kept to study by that name; without one, the current game over, or else the latest of the archive; refused while a game goes on. */
+export function gameToStudy(context, name) {
+    const current = noGameGoingOn(context);
+    const folder = gameFolder(context.home());
+    if (name !== undefined) {
+        return namedGame(context, name);
+    }
+    if (current !== undefined) {
+        // The archive's record, which keeps the AI's review (D-69).
+        const archived = archivedName(folder, current);
+        return archived === undefined ? { record: current.game.record } : { record: archivedGame(folder, archived), name: archived };
+    }
+    const [latest] = archivedGames(folder);
+    if (latest === undefined) {
+        throw new Error("There is no game to study: play one with new_game, or give analyse_game the PGN of a game played elsewhere.");
+    }
+    return { record: archivedGame(folder, latest), name: latest };
+}
+/** A game played or kept to study by its name as the lists write it, or without its folder or its .pgn; refused when it is not there. */
+export function namedGame(context, name) {
+    const folder = gameFolder(context.home());
+    const full = listedName(folder, name);
+    return { record: full.startsWith("study/") ? keptGame(folder, full) : archivedGame(folder, full), name: full };
+}
+/** The index of a move in the game's record, given as analyse_game numbers it: 12. for White's, 12... for Black's, 12...Kf8 too. */
+export function moveIndex(record, move) {
+    return plyOf(record, moveNumbers(record), move);
+}
+/** The number of each move of a game as the analysis writes it: 1. for White's first move, 1... for Black's. */
+export function moveNumbers(record) {
+    const start = new Game({ tags: record.tags, moves: [] }).position;
+    const blackFirst = start.turn === "black" ? 1 : 0;
+    return record.moves.map((move, index) => {
+        const ply = index + blackFirst;
+        return `${start.moveNumber + Math.floor(ply / 2)}${ply % 2 === 0 ? "." : "..."}`;
+    });
+}
+/**
+ * The game as it stood after a move, given by its number (12. for White's, 12... for Black's) and, if wanted, the move itself (12...Kf8), which decides
+ * the side when the dots do not; after the last move without one.
+ */
+export function positionAfter(record, move) {
+    const numbers = moveNumbers(record);
+    const ply = move === undefined ? numbers.length - 1 : plyOf(record, numbers, move);
+    if (ply < 0) {
+        return { game: new Game(record) };
+    }
+    return { game: new Game({ ...record, moves: record.moves.slice(0, ply + 1) }), move: `${numbers[ply]}${record.moves[ply].san}` };
+}
+/** A tag PGN leaves unknown with ? or -, as nothing. */
+export function knownTag(tag) {
+    return tag === undefined || /^[?.\-\s]*$/.test(tag) ? undefined : tag;
+}
+/** Where a position of a game studied stands: After 12...Kf8 in games/2026-11-02-153012.pgn: White to move. */
+export function positionLine({ game, move }, name) {
+    const where = `${move === undefined ? "At the start" : `After ${move}`}${name === undefined ? "" : ` in ${name}`}`;
+    const { outcome, position } = game;
+    return `${where}: ${outcome.over ? `the board ends the game by ${outcome.ending}` : `${colourName(position.turn)} to move`}.`;
+}
+function plyOf(record, numbers, move) {
+    const [, number, dots, san] = movePattern.exec(move) ?? [];
+    if (number === undefined) {
+        throw new Error(`"${move}" is not a move of the game: give its number as analyse_game writes it, 12. for White's move and 12... for Black's, such as 12...Kf8.`);
+    }
+    if (numbers.length === 0) {
+        throw new Error("This game has no moves: look and position without move show its position.");
+    }
+    const white = numbers.indexOf(`${Number(number)}.`);
+    const black = numbers.indexOf(`${Number(number)}...`);
+    const plies = (dots === "..." || dots === "…" ? [black] : [white, black]).filter((ply) => ply >= 0);
+    const found = san === undefined ? plies[0] : plies.find((ply) => isMove(record, ply, san));
+    if (found === undefined) {
+        const played = [white, black].filter((ply) => ply >= 0).map((ply) => `${numbers[ply]}${record.moves[ply].san}`);
+        const there = played.length === 0 ? `its moves go from ${numbers[0]}${record.moves[0].san} to ${numbers.at(-1)}${record.moves.at(-1).san}` : `move ${number} is ${played.join(" ")}`;
+        throw new Error(`There is no ${move.trim()} in this game: ${there}.`);
+    }
+    return found;
+}
+/** Whether the move written is the one the game played at that ply, however it is written: Nf3, g1f3, Nf3+. */
+function isMove(record, ply, written) {
+    const played = new Game({ ...record, moves: record.moves.slice(0, ply) }).playRecorded(written);
+    return played.played && played.move.san === record.moves[ply].san;
+}
+const movePattern = /^\s*(\d+)\s*(\.\.\.|\.|…)?\s*(\S+)?\s*$/;

package/dist/commands/view.d.ts

@@ -0,0 +1,14 @@
+import type { Facts, Material, Side } from "../core/index.ts";
+/** The view after the player's move: the check, the pieces attacked, then what is at risk, the pins, the checks and the moves of each piece. */
+export declare function compactView(facts: Facts, turn: Side): string[];
+/** The view of a level without the tactical facts (D-60): the check and the legal moves by piece, which are the rules (D-17). */
+export declare function boardView(facts: Facts, turn: Side): string[];
+/** The whole view, for look: every piece with its attackers and defenders, then the same lines as the compact view. */
+export declare function fullView(facts: Facts, turn: Side): string[];
+/** What is at risk, in one line for a move of the analysis (D-68): undefended Black Nf6; by a cheaper piece White Qd1; outnumbered Black Pe5; none when nothing is. */
+export declare function riskLine(facts: Facts): string | undefined;
+export declare function colourName(side: Side): string;
+/** The material as the player sees it beside the board (D-59): who is ahead and by how much, and the pieces each side took. */
+export declare function materialText(material: Material): string;
+/** Who is ahead in material, and by how many pawns: White +2, or even. */
+export declare function balanceText(balance: number): string;

package/dist/commands/view.js

@@ -0,0 +1,125 @@
+/** The view after the player's move: the check, the pieces attacked, then what is at risk, the pins, the checks and the moves of each piece. */
+export function compactView(facts, turn) {
+    const names = namesOf(facts);
+    const attacked = officersOf(facts).filter((piece) => piece.attackers.length > 0);
+    const pieces = attacked.length === 0 ? ["Attacked pieces: none"] : ["Attacked pieces (attackers / defenders):", ...attacked.map((piece) => pieceLine(piece, names, true))];
+    return [...checkLines(facts, turn, names), ...pieces, ...tacticLines(facts, turn, names)];
+}
+/** The view of a level without the tactical facts (D-60): the check and the legal moves by piece, which are the rules (D-17). */
+export function boardView(facts, turn) {
+    const names = namesOf(facts);
+    return [...checkLines(facts, turn, names), ...legalLines(facts, names)];
+}
+/** The whole view, for look: every piece with its attackers and defenders, then the same lines as the compact view. */
+export function fullView(facts, turn) {
+    const names = namesOf(facts);
+    const sides = sidesInOrder.flatMap((side) => [
+        `${colourName(side)} pieces (attackers / defenders):`,
+        ...officersOf(facts).filter((piece) => piece.side === side).map((piece) => pieceLine(piece, names, false)),
+    ]);
+    return [...checkLines(facts, turn, names), ...sides, ...tacticLines(facts, turn, names)];
+}
+/** What is at risk, in one line for a move of the analysis (D-68): undefended Black Nf6; by a cheaper piece White Qd1; outnumbered Black Pe5; none when nothing is. */
+export function riskLine(facts) {
+    const names = namesOf(facts);
+    const kinds = [["undefended", facts.undefended], ["by a cheaper piece", facts.attackedByCheaper], ["outnumbered", facts.outnumbered]];
+    const text = kinds.filter(([, squares]) => squares.length > 0).map(([kind, squares]) => `${kind} ${bySide(facts, squares, names)}`).join("; ");
+    return text === "" ? undefined : text;
+}
+export function colourName(side) {
+    return side === "white" ? "White" : "Black";
+}
+/** The material as the player sees it beside the board (D-59): who is ahead and by how much, and the pieces each side took. */
+export function materialText(material) {
+    const ahead = balanceText(material.balance);
+    if (material.taken.white.length === 0 && material.taken.black.length === 0) {
+        return `${ahead}, nothing taken`;
+    }
+    return `${ahead} (White took ${takenText(material.taken.white)}, Black took ${takenText(material.taken.black)})`;
+}
+/** Who is ahead in material, and by how many pawns: White +2, or even. */
+export function balanceText(balance) {
+    return balance === 0 ? "even" : `${balance > 0 ? "White" : "Black"} +${Math.abs(balance)}`;
+}
+/** The pieces taken, counted by kind: Q 2R 7P. */
+function takenText(taken) {
+    const kinds = [...new Set(taken)];
+    return kinds.map((piece) => {
+        const count = taken.filter((other) => other === piece).length;
+        return count === 1 ? piece : `${count}${piece}`;
+    }).join(" ") || "nothing";
+}
+const sidesInOrder = ["white", "black"];
+/** The check the side to move is in, from which pieces; none when it is not. */
+function checkLines(facts, turn, names) {
+    return facts.checkedBy === undefined ? [] : [`${colourName(turn)} is in check from ${facts.checkedBy.map(names.piece).join(" and ")}.`];
+}
+/** What is at risk, loose and pinned, the checks of both sides, and the legal moves of the side to move by piece. */
+function tacticLines(facts, turn, names) {
+    const list = (squares) => bySide(facts, squares, names) || "none";
+    const atRisk = facts.undefended.length === 0 && facts.attackedByCheaper.length === 0 && facts.outnumbered.length === 0
+        ? "At risk: none"
+        : `Attacked and undefended: ${list(facts.undefended)}; defended, but attacked by a cheaper piece: ${list(facts.attackedByCheaper)}; `
+            + `attacked more times than defended: ${list(facts.outnumbered)}`;
+    const pins = facts.pins.map((pin) => `${names.sided(pin.square)} to ${names.piece(pin.to)} by ${names.piece(pin.by)}`);
+    return [
+        atRisk,
+        `Loose: ${list(facts.loose)}`,
+        `Pinned: ${pins.join(", ") || "none"}`,
+        ...checksLines(facts, turn),
+        ...legalLines(facts, names),
+    ];
+}
+/** The checks the side to move can give, and those the other side could give if it were to move; one line when neither has any. */
+function checksLines(facts, turn) {
+    if (facts.checks.length === 0 && facts.otherChecks?.length === 0) {
+        return ["Checks: none for either side"];
+    }
+    const other = colourName(turn === "white" ? "black" : "white");
+    const theirs = facts.otherChecks === undefined ? [] : [`Checks ${other} could give if it were to move: ${facts.otherChecks.join(" ") || "none"}`];
+    return [`Checks ${colourName(turn)} (to move) can give: ${facts.checks.join(" ") || "none"}`, ...theirs];
+}
+/** The legal moves of the side to move by piece, with how many, and its pieces that have none; nothing when it has no move, the game over. */
+function legalLines(facts, names) {
+    const mine = facts.pieces.filter((piece) => piece.moves !== undefined);
+    const moving = mine.filter((piece) => piece.moves.length > 0);
+    const stuck = mine.filter((piece) => piece.moves.length === 0).map((piece) => names.piece(piece.square));
+    const count = moving.reduce((total, piece) => total + piece.moves.length, 0);
+    if (count === 0) {
+        return [];
+    }
+    const byPiece = moving.map((piece) => `${names.piece(piece.square)} (${piece.moves.length}) ${piece.moves.join(" ")}`);
+    return [`Legal by piece (${count}): ${[...byPiece, ...(stuck.length === 0 ? [] : [`no moves: ${stuck.join(" ")}`])].join("; ")}`];
+}
+/** A piece with the pieces that attack it and those that defend it, the pieces lined up behind them in brackets: Pf7: Bc4 Ng5 / Ke8; Qd2(+Rd1). */
+function pieceLine(piece, names, withSide) {
+    const list = (squares) => squares.map((square) => `${names.piece(square)}${behindOf(piece, square, names)}`).join(" ") || "-";
+    const name = withSide ? names.sided(piece.square) : names.piece(piece.square);
+    return `${name}: ${list(piece.attackers)} / ${list(piece.defenders)}`;
+}
+function behindOf(piece, square, names) {
+    const behind = piece.behind?.[square];
+    return behind === undefined ? "" : `(+${behind.map(names.piece).join("+")})`;
+}
+/** Pieces by side, White's first: White Ra1 Pb2, Black Ra8. */
+function bySide(facts, squares, names) {
+    const sideAt = new Map(facts.pieces.map((piece) => [piece.square, piece.side]));
+    const groups = sidesInOrder.map((side) => [side, squares.filter((square) => sideAt.get(square) === side)]).filter(([, group]) => group.length > 0);
+    return groups.map(([side, group]) => `${colourName(side)} ${group.map(names.piece).join(" ")}`).join(", ");
+}
+/** The pieces but the kings: a king attacked is a check, said in its own line, and a king is never defended. */
+function officersOf(facts) {
+    return facts.pieces.filter((piece) => piece.piece !== "K");
+}
+function namesOf(facts) {
+    const pieces = new Map(facts.pieces.map((piece) => [piece.square, piece]));
+    const piece = (square) => {
+        const found = pieces.get(square);
+        return found === undefined ? square : `${found.piece}${square}`;
+    };
+    const sided = (square) => {
+        const found = pieces.get(square);
+        return found === undefined ? square : `${colourName(found.side)} ${found.piece}${square}`;
+    };
+    return { piece, sided };
+}

package/dist/core/board-text.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The board of a FEN as text: White at the bottom, the pieces as Unicode figurines, the empty squares and the files as signs a browser draws as wide as the
+ * figurines and a terminal in one cell each, so that the columns stay in line in Claude's desktop app and in a terminal alike.
+ */
+export declare function boardText(fen: string): string;
+/** A move in SAN as the player is shown it, with the pieces' solid figurines for either side (D-86): Nxe4 is ♞xe4 and e8=Q is e8=♛. */
+export declare function figurinesOf(san: string): string;

package/dist/core/board-text.js

@@ -0,0 +1,18 @@
+// The board and the moves as text for the player in the chat (D-36), with the pieces' figurines (D-86): the moves for the AI to copy, never its view of the board (D-26).
+/**
+ * The board of a FEN as text: White at the bottom, the pieces as Unicode figurines, the empty squares and the files as signs a browser draws as wide as the
+ * figurines and a terminal in one cell each, so that the columns stay in line in Claude's desktop app and in a terminal alike.
+ */
+export function boardText(fen) {
+    const ranks = (fen.split(" ")[0] ?? "").split("/").map((rank) => rank.replace(/\d/g, (empty) => ".".repeat(Number(empty))));
+    const files = `  ${fileSigns.join(" ")}`;
+    return [files, ...ranks.map((rank, index) => `${8 - index} ${[...rank].map((square) => figurines[square] ?? emptySquare).join(" ")} ${8 - index}`), files].join("\n");
+}
+/** A move in SAN as the player is shown it, with the pieces' solid figurines for either side (D-86): Nxe4 is ♞xe4 and e8=Q is e8=♛. */
+export function figurinesOf(san) {
+    return san.replace(/^[KQRBN]|(?<==)[QRBN]/g, (letter) => figurines[letter.toLowerCase()] ?? letter);
+}
+// The pieces' figurines by their FEN letters; the black pawn's asks for its text form, since alone it shows as an emoji.
+const figurines = { K: "♔", Q: "♕", R: "♖", B: "♗", N: "♘", P: "♙", k: "♚", q: "♛", r: "♜", b: "♝", n: "♞", p: "♟︎" };
+const emptySquare = "⊙";
+const fileSigns = [..."ⓐⓑⓒⓓⓔⓕⓖⓗ"];