chesspal 0.1.0 → 0.2.0

package/dist/commands/status.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { type GameSummary, type Speech } from "./game-summary.ts";
+import { type GameSummary } from "./game-summary.ts";
+import { type Speech } from "./speech.ts";
 interface Status {
     version: string;
     folder: string;
@@ -14,15 +15,20 @@ interface Status {
     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 (T-65). */
+    /** 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 (T-92). */
+    /** 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>;

package/dist/commands/status.js

@@ -1,14 +1,18 @@
 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 { closingLines, newGameStep, positionLines, sidesLine, speechLine, speechOf, summaryOf, withThought, wordLines } from "./game-summary.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",
@@ -19,12 +23,13 @@ export const status = defineCommand({
     readOnly: true,
     alwaysLoad: true,
     showsGame: true,
-    run: (_input, context) => {
+    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 status = { version, folder, ...(player === undefined ? {} : { player }), ...(speech === undefined ? {} : { speech }) };
+        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;
         }
@@ -40,17 +45,22 @@ export const status = defineCommand({
                 status.words = words;
             }
             if (current !== undefined) {
-                status.game = withThought(summaryOf(current, context.now(), archivedName(folder, current)), folder, current);
+                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) {
-                status.analysis = { game: analysis.game, ...(analysis.brought === true ? { brought: true } : {}) };
+                // 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) {
@@ -58,16 +68,22 @@ export const status = defineCommand({
         }
         return status;
     },
-    format: ({ version, folder, page, pageClosed, player, speech, game, problem, words = [], analysis, fromBefore }) => [
+    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)),
+        ...(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;
 /**
@@ -87,17 +103,26 @@ 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 (T-92). */
-function analysisLine({ game, brought }) {
-    return brought === true
-        ? `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.`
+/** 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 (T-92). */
-function gameLines(game, words, brought) {
+/**
+ * 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.", ...(brought ? wordLines(words) : closingLines(game, words))];
+        return ["No game.", ...closing];
     }
     const moves = game.lastMoves === "" ? [] : [`Moves: ${game.lastMoves}`];
-    return [`Game: ${sidesLine(game.ai)}, ${levelText(game.level)}.`, ...moves, ...positionLines(game), ...(brought ? wordLines(words) : closingLines(game, words))];
+    return [`Game: ${sidesLine(game.ai)}, ${levelText(game.level)}.`, ...moves, ...positionLines(game), ...closing];
 }

package/dist/commands/study-games.js

@@ -14,7 +14,7 @@ export const studyGames = defineCommand({
     input: z.object({}),
     readOnly: true,
     idempotent: true,
-    run: (_input, context) => {
+    run: (input, context) => {
         const folder = gameFolder(context.home());
         return { games: keptGames(folder).flatMap((name) => studyLines(folder, name)) };
     },

package/dist/commands/study.js

@@ -2,7 +2,7 @@
 // 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, keptGames } from "../games/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";
@@ -41,7 +41,7 @@ export function gameToStudy(context, name) {
 /** 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 = fullName(folder, name);
+    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. */
@@ -52,7 +52,7 @@ export function moveIndex(record, move) {
 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) => {
+    return record.moves.map((move, index) => {
         const ply = index + blackFirst;
         return `${start.moveNumber + Math.floor(ply / 2)}${ply % 2 === 0 ? "." : "..."}`;
     });
@@ -79,22 +79,6 @@ export function positionLine({ game, move }, name) {
     const { outcome, position } = game;
     return `${where}: ${outcome.over ? `the board ends the game by ${outcome.ending}` : `${colourName(position.turn)} to move`}.`;
 }
-/**
- * A game's name as the lists write it, from a name without its folder or its .pgn too: 2026-11-04-173054 is games/2026-11-04-173054.pgn, or the game kept
- * to study by that name when no game played has it; any other name as it is, for the archive to refuse.
- */
-function fullName(folder, name) {
-    const [, shelf, stem] = /^\s*(?:(games|study)\/)?(\d{4}-\d{2}-\d{2}-\d{6})(?:\.pgn)?\s*$/.exec(name) ?? [];
-    if (stem === undefined) {
-        return name;
-    }
-    if (shelf !== undefined) {
-        return `${shelf}/${stem}.pgn`;
-    }
-    const played = `games/${stem}.pgn`;
-    const kept = `study/${stem}.pgn`;
-    return !archivedGames(folder).includes(played) && keptGames(folder).includes(kept) ? kept : played;
-}
 function plyOf(record, numbers, move) {
     const [, number, dots, san] = movePattern.exec(move) ?? [];
     if (number === undefined) {

package/dist/core/facts.js

@@ -23,6 +23,21 @@ const order = { k: 0, q: 1, r: 2, b: 3, n: 4, p: 5 };
 // The lines from a square: a step on the file and the rank, and the slider that moves along it besides the queen.
 const lines = [[0, 1, "r"], [0, -1, "r"], [1, 0, "r"], [-1, 0, "r"], [1, 1, "b"], [1, -1, "b"], [-1, 1, "b"], [-1, -1, "b"]];
 const files = "abcdefgh";
+/** Which pieces attack a square as the facts count them: a piece pinned to its king only along the pin's line, though it still gives check; no en passant. */
+export function attacksOf(chess) {
+    return alongPins(chess, piecesOf(chess).filter((piece) => piece.type === "k").flatMap((king) => pinsTo(chess, king)));
+}
+/** The squares strictly between two squares on one line. */
+export function squaresBetween(from, to) {
+    const ray = rayFrom(from, Math.sign(fileOf(to) - fileOf(from)), Math.sign(rankOf(to) - rankOf(from)));
+    return ray.slice(0, ray.indexOf(to));
+}
+export function fileOf(square) {
+    return files.indexOf(square[0]);
+}
+export function rankOf(square) {
+    return Number(square[1]);
+}
 function computed(chess, legal) {
     const placed = piecesOf(chess);
     const turn = chess.turn();
@@ -49,10 +64,6 @@ function computed(chess, legal) {
     };
     return chess.inCheck() ? facts : { ...facts, otherChecks: otherChecks(chess) };
 }
-/** Which pieces attack a square as the facts count them: a piece pinned to its king only along the pin's line, though it still gives check; no en passant. */
-export function attacksOf(chess) {
-    return alongPins(chess, piecesOf(chess).filter((piece) => piece.type === "k").flatMap((king) => pinsTo(chess, king)));
-}
 function reachOf(chess, kingPins, legal) {
     const direct = alongPins(chess, kingPins);
     const enPassant = enPassantVictim(chess);
@@ -148,17 +159,6 @@ function rayFrom(from, fileStep, rankStep) {
     }
     return ray;
 }
-/** The squares strictly between two squares on one line. */
-export function squaresBetween(from, to) {
-    const ray = rayFrom(from, Math.sign(fileOf(to) - fileOf(from)), Math.sign(rankOf(to) - rankOf(from)));
-    return ray.slice(0, ray.indexOf(to));
-}
-export function fileOf(square) {
-    return files.indexOf(square[0]);
-}
-export function rankOf(square) {
-    return Number(square[1]);
-}
 /** Compares two names of squares or colours: a fixed alphabet, no locale. */
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;

package/dist/core/game.d.ts

@@ -73,7 +73,7 @@ export declare class Game {
     get lastMove(): Move | undefined;
     /** What the position shows (D-26): attackers and defenders, pieces at risk, pins, checks, the moves of each piece; computed once for each position. */
     get facts(): Facts;
-    /** The positional profile (D-19, T-12): pawns, files, outposts, space, mobility, development, king safety, control, phase, draws; computed once for each position. */
+    /** The positional profile (D-19): pawns, files, outposts, space, mobility, development, king safety, control, phase, draws; computed once for each position. */
     get profile(): Profile;
     /** The legal moves, or those of the piece on a square. */
     legalMoves(square?: Square): readonly Move[];
@@ -91,3 +91,5 @@ export declare class Game {
     private illegal;
     private snapshot;
 }
+/** A text with SAN's letters and signs for the figurines and signs others write: ♘f3 as Nf3, × as x; a pawn's figurine says nothing. */
+export declare function withSanLetters(text: string): string;

package/dist/core/game.js

@@ -65,7 +65,7 @@ export class Game {
     get facts() {
         return factsOf(this.chess, legalMovesOf(this.chess));
     }
-    /** The positional profile (D-19, T-12): pawns, files, outposts, space, mobility, development, king safety, control, phase, draws; computed once for each position. */
+    /** The positional profile (D-19): pawns, files, outposts, space, mobility, development, king safety, control, phase, draws; computed once for each position. */
     get profile() {
         const key = this.chess.hash();
         return profileOf(this.chess, { repetitions: this.keys.filter((seen) => seen === key).length, castled: this.castled, fromFen: this.tags.FEN !== undefined }, legalMovesOf(this.chess));
@@ -150,7 +150,7 @@ export class Game {
         }
         const [, piece, file, rank, separator, target = "", promotion] = parts;
         const capture = separator === "x" || separator === ":";
-        // "bc4" is a bishop without its capital, or a pawn's capture without its x, as "bb4" or "cc6" is a piece or a pawn: never guessed (T-11, Anatolij, round of D-87).
+        // "bc4" is a bishop without its capital, or a pawn's capture without its x, as "bb4" or "cc6" is a piece or a pawn: never guessed (Anatolij, round of D-87).
         if (piece === undefined && file !== undefined && rank === undefined && !capture) {
             return smallLetter(input, file, target);
         }
@@ -210,6 +210,10 @@ const asciiOf = {
     "♙": "",
     "♟": "",
 };
+/** A text with SAN's letters and signs for the figurines and signs others write: ♘f3 as Nf3, × as x; a pawn's figurine says nothing. */
+export function withSanLetters(text) {
+    return text.replace(/[︎️]/g, "").replace(/[–—−×♔-♟]/g, (sign) => asciiOf[sign] ?? sign);
+}
 // The pieces' letters of other languages that name one piece only: the Italian, French, Spanish and German ones; R is the rook in SAN.
 const foreignPieces = {
     C: ["knight", "N"],
@@ -260,7 +264,7 @@ function normalized(text) {
     return text.trim()
         .replace(/^\d+\s*(?:\.[\s.]*|…\s*)/, "")
         .replace(/[︎️]/g, "")
-        // A space after the piece's letter, "N f3", as an AI may show the player how to write (Priya, retest of T-54).
+        // A space after the piece's letter, "N f3", as an AI may show the player how to write (Priya).
         .replace(/^([A-Z♔-♟])\s+(?=[a-h1-8x:])/, "$1")
         .replace(/[–—−×♔-♟]/g, (sign) => asciiOf[sign] ?? sign)
         // A small t too, so that "tf1" is told the rook's R as "Tf1" is.
@@ -298,7 +302,7 @@ function kingInCheckOffTurn(chess) {
 function gameOver({ ending, result }) {
     return { refusal: "over", message: `The game is over by ${ending} (${result}): no move can follow.` };
 }
-/** A move written with a piece's letter of another language (T-11): Cf3 for an Italian or French knight, Dd1 for a queen; none for another mistake. */
+/** A move written with a piece's letter of another language: Cf3 for an Italian or French knight, Dd1 for a queen; none for another mistake. */
 function foreignLetter(input, bare) {
     const [, move = "", becomes = ""] = /^(.*[18])=?([A-Z])$/.exec(bare) ?? [];
     if (becomes !== "" && !"QRBN".includes(becomes)) {

package/dist/core/illegal.js

@@ -1,4 +1,4 @@
-// Why the board refuses a move, without judging anything (D-18): the page tells the player who tried it (T-11).
+// Why the board refuses a move, without judging anything (D-18): the page tells the player who tried it.
 import { Chess } from "chess.js";
 import { fileOf, rankOf, squaresBetween } from "./facts.js";
 /** Why the piece of the side to move on one square cannot go to another, which its legal moves do not reach; undefined when no rule says why. */

package/dist/core/index.d.ts

@@ -2,18 +2,19 @@ export { boardText, figurinesOf } from "./board-text.ts";
 export { canMate, clockAfterMove, clockOfComment, clockStarted, clockTag, clockText, startClock, timeControlOf, timeControlOfTag, timeControlTag, timeControlText, timeLeft } from "./clock.ts";
 export type { Clock, TimeControl } from "./clock.ts";
 export type { Facts, PieceFacts, PieceLetter, Pin } from "./facts.ts";
-export { Game } from "./game.ts";
+export { Game, withSanLetters } from "./game.ts";
 export type { Ending, Move, Outcome, Played, Position, Promotion, Refusal, Side, Square } from "./game.ts";
 export type { Illegal, IllegalReason } from "./illegal.ts";
+export { type Lead, leadOf, leadText, readLead, withLead } from "./lead.ts";
 export { aiLevels, layersOf, levelForPlayer, levelOf, levelTag, sees, suggestedLevel } from "./levels.ts";
 export type { AiLevel, Layer } from "./levels.ts";
 export { materialOf } from "./material.ts";
 export type { Material } from "./material.ts";
-export { endWithMood, type Mood, moodAt, moodMoves, type MoodNow, moodOf, moods, moodTag, withoutMoods } from "./moods.ts";
-export { bookDepth, bookMoves, indexBook, indexOpenings, inOpenings, openingOf, outOfBookMove } from "./openings.ts";
+export { endWithMood, type Mood, moodAt, type MoodNow, moodOf, moods, moodTag, withoutMoods } from "./moods.ts";
+export { bookMoves, indexBook, indexOpenings, inOpenings, openingOf, outOfBookMove } from "./openings.ts";
 export type { Opening, OpeningBook, OpeningIndex } from "./openings.ts";
 export { pgnDate, readPgn, writePgn } from "./pgn.ts";
 export type { BishopFacts, CentreSquare, KingFacts, Outpost, PawnFacts, PawnSquare, Phase, Profile, SideProfile } from "./profile.ts";
 export { movesOnly } from "./record.ts";
 export type { Annotation, GameRecord, RecordedMove } from "./record.ts";
-export { type AiModel, aiModelIn, annotatorOf, arrowOf, type Badge, badges, closingOf, type DrawColour, drawingsIn, drawingsText, type DrawnArrow, type DrawnSquare, gameReviewOf, isBadge, type MoveReview, reviewed, reviewOf, squareOf, withAiModel, withAnnotator, withGameReview, } from "./review.ts";
+export { type AiModel, aiModelIn, annotatorOf, arrowOf, type Badge, badges, closingOf, type DrawColour, drawingsIn, drawingsText, type DrawnArrow, type DrawnSquare, gameReviewOf, isReviewed, type MoveReview, reviewed, reviewOf, squareOf, unreviewed, withAiModel, withAnnotator, withGameReview, } from "./review.ts";

package/dist/core/index.js

@@ -1,11 +1,12 @@
 // The chess core: the game and its rules, the facts of a position, its record, PGN, the openings. It runs in the browser too (D-17, D-18).
 export { boardText, figurinesOf } from "./board-text.js";
 export { canMate, clockAfterMove, clockOfComment, clockStarted, clockTag, clockText, startClock, timeControlOf, timeControlOfTag, timeControlTag, timeControlText, timeLeft } from "./clock.js";
-export { Game } from "./game.js";
+export { Game, withSanLetters } from "./game.js";
+export { leadOf, leadText, readLead, withLead } from "./lead.js";
 export { aiLevels, layersOf, levelForPlayer, levelOf, levelTag, sees, suggestedLevel } from "./levels.js";
 export { materialOf } from "./material.js";
-export { endWithMood, moodAt, moodMoves, moodOf, moods, moodTag, withoutMoods } from "./moods.js";
-export { bookDepth, bookMoves, indexBook, indexOpenings, inOpenings, openingOf, outOfBookMove } from "./openings.js";
+export { endWithMood, moodAt, moodOf, moods, moodTag, withoutMoods } from "./moods.js";
+export { bookMoves, indexBook, indexOpenings, inOpenings, openingOf, outOfBookMove } from "./openings.js";
 export { pgnDate, readPgn, writePgn } from "./pgn.js";
 export { movesOnly } from "./record.js";
-export { aiModelIn, annotatorOf, arrowOf, badges, closingOf, drawingsIn, drawingsText, gameReviewOf, isBadge, reviewed, reviewOf, squareOf, withAiModel, withAnnotator, withGameReview, } from "./review.js";
+export { aiModelIn, annotatorOf, arrowOf, badges, closingOf, drawingsIn, drawingsText, gameReviewOf, isReviewed, reviewed, reviewOf, squareOf, unreviewed, withAiModel, withAnnotator, withGameReview, } from "./review.js";

package/dist/core/lead.d.ts

@@ -0,0 +1,15 @@
+import { type RecordedMove } from "./record.ts";
+/** Who is ahead after a move: pawns from White's side (+1.5 White, -3 Black), or a mate in so many moves (#3 White's, #-3 Black's). */
+export type Lead = {
+    readonly pawns: number;
+} | {
+    readonly mate: number;
+};
+/** A lead as the AI writes it: +1.5, -3, 0, #3, #-2; none when it is not one. */
+export declare function readLead(text: string): Lead | undefined;
+/** A lead as the PGN and the page write it: +1.5, -3, 0, #3, #-2. */
+export declare function leadText(lead: Lead): string;
+/** The lead a move's comment carries, when the AI estimated one. */
+export declare function leadOf(comment: string | undefined): Lead | undefined;
+/** The move with the AI's lead in place of the one it had, beside what its comment held. */
+export declare function withLead(move: RecordedMove, lead: Lead): RecordedMove;

package/dist/core/lead.js

@@ -0,0 +1,40 @@
+// Who is ahead in a position, as the AI estimates it (D-90): in pawns from White's side, as chess.com shows it, or a mate it sees. It rides in a move's
+// comment as [%lead +1.5] or [%lead #-3], Chesspal's own command and not [%eval], which elsewhere would pass for an engine's. Chesspal keeps it and draws
+// it, never computes it (D-6, D-19).
+import { recordedMove } from "./record.js";
+/** A lead as the AI writes it: +1.5, -3, 0, #3, #-2; none when it is not one. */
+export function readLead(text) {
+    const plain = text.trim().replaceAll("−", "-").replace(/^M/i, "#").replace(/^([+-])[#M]/i, "#$1");
+    const mate = /^#([+-]?)(\d+)$/.exec(plain);
+    if (mate !== null) {
+        const moves = Number(mate[2]);
+        return moves < 1 || moves > leadLimit ? undefined : { mate: mate[1] === "-" ? -moves : moves };
+    }
+    if (!/^[+-]?\d+(\.\d+)?$/.test(plain)) {
+        return undefined;
+    }
+    // To a tenth, a half away from zero on both sides; never a negative zero: -0.04 is an even game.
+    const figure = Number(plain);
+    const pawns = Math.sign(figure) * Math.round(Math.abs(figure) * 10) / 10;
+    return Math.abs(pawns) > leadLimit ? undefined : { pawns: pawns === 0 ? 0 : pawns };
+}
+/** A lead as the PGN and the page write it: +1.5, -3, 0, #3, #-2. */
+export function leadText(lead) {
+    if ("mate" in lead) {
+        return `#${lead.mate}`;
+    }
+    return lead.pawns > 0 ? `+${lead.pawns}` : `${lead.pawns}`;
+}
+/** The lead a move's comment carries, when the AI estimated one. */
+export function leadOf(comment) {
+    const found = leadPattern.exec(comment ?? "")?.[1];
+    return found === undefined ? undefined : readLead(found);
+}
+/** The move with the AI's lead in place of the one it had, beside what its comment held. */
+export function withLead(move, lead) {
+    const comment = [(move.comment ?? "").replace(/\s*\[%lead [^\]]*\]/g, "").trim(), `[%lead ${leadText(lead)}]`].filter((part) => part !== "").join(" ");
+    return recordedMove(move.san, move.nags, comment);
+}
+const leadPattern = /\[%lead ([^\]]*)\]/;
+// The largest lead Chesspal keeps, in pawns or moves to mate: beyond it the AI's figure says nothing more.
+const leadLimit = 99;

package/dist/core/levels.d.ts

@@ -2,7 +2,7 @@ import type { GameRecord } from "./record.ts";
 /** The AI's levels, the weakest first. */
 export declare const aiLevels: readonly ["beginner", "club", "strong", "master"];
 export type AiLevel = (typeof aiLevels)[number];
-/** The layers of facts: the board as the player sees it (D-59), the tactical view (D-26), the positional profile (T-12), the opening book's moves (D-15). */
+/** The layers of facts: the board as the player sees it (D-59), the tactical view (D-26), the positional profile, the opening book's moves (D-15). */
 declare const layers: readonly ["board", "tactics", "strategy", "theory"];
 export type Layer = (typeof layers)[number];
 /** The PGN tag that keeps a game's level, so the archive keeps it too. */

package/dist/core/levels.js

@@ -1,6 +1,6 @@
 /** The AI's levels, the weakest first. */
 export const aiLevels = ["beginner", "club", "strong", "master"];
-/** The layers of facts: the board as the player sees it (D-59), the tactical view (D-26), the positional profile (T-12), the opening book's moves (D-15). */
+/** The layers of facts: the board as the player sees it (D-59), the tactical view (D-26), the positional profile, the opening book's moves (D-15). */
 const layers = ["board", "tactics", "strategy", "theory"];
 /** The PGN tag that keeps a game's level, so the archive keeps it too. */
 export const levelTag = "AILevel";

package/dist/core/moods.d.ts

@@ -4,8 +4,6 @@ import type { GameRecord } from "./record.ts";
 export declare const moods: readonly ["neutral", "happy", "surprised", "worried", "thoughtful", "sad"];
 /** A mood of the AI. */
 export type Mood = (typeof moods)[number];
-/** How many of the AI's moves each mood lasts, the one it comes with included: a surprise is a flash (Julián, round of T-107). */
-export declare const moodMoves: Readonly<Record<Mood, number>>;
 /** The AI's mood at a point of a game, and how many more of its moves keep it before it fades: 0 when its next move ends it. */
 export interface MoodNow {
     readonly mood: Mood;

package/dist/core/moods.js

@@ -1,7 +1,7 @@
 /** The moods of the AI, which the Torretta shows. */
 export const moods = ["neutral", "happy", "surprised", "worried", "thoughtful", "sad"];
-/** How many of the AI's moves each mood lasts, the one it comes with included: a surprise is a flash (Julián, round of T-107). */
-export const moodMoves = { neutral: 0, happy: 3, surprised: 1, worried: 3, thoughtful: 3, sad: 3 };
+/** How many of the AI's moves each mood lasts, the one it comes with included: a surprise is a flash (Julián). */
+const moodMoves = { neutral: 0, happy: 3, surprised: 1, worried: 3, thoughtful: 3, sad: 3 };
 /** The mood as a move's comment carries it. */
 export function moodTag(mood) {
     return `[%mood ${mood}]`;

package/dist/core/openings.d.ts

@@ -15,8 +15,6 @@ export interface Opening {
     /** Whether the game's position now is a named one; when not, it left the book at the ply after `ply`. */
     readonly inBook: boolean;
 }
-/** No line of the book is longer: past it, no position is looked up. */
-export declare const bookDepth = 40;
 /** The book's moves: each position on a line of Lichess's files to the moves its lines play from it, the theory the AI knows at the master level (D-15, D-60). */
 export type OpeningBook = Readonly<Record<string, readonly string[]>>;
 /** The index of the openings in Lichess's TSV files (eco, name, pgn), each line keyed by the position its moves reach. */

package/dist/core/openings.js

@@ -1,7 +1,7 @@
 // The openings by position (D-15, D-16): Lichess's names, indexed by the position each line reaches, so transpositions find them too.
 import { Chess } from "chess.js";
 /** No line of the book is longer: past it, no position is looked up. */
-export const bookDepth = 40;
+const bookDepth = 40;
 /** The index of the openings in Lichess's TSV files (eco, name, pgn), each line keyed by the position its moves reach. */
 export function indexOpenings(tsv) {
     const index = {};

package/dist/core/profile.js

@@ -1,4 +1,4 @@
-// The positional profile (D-19, T-12): pawns, files, bishops, outposts, space and centre, mobility, development, king safety, control, phase, draws and
+// The positional profile (D-19): pawns, files, bishops, outposts, space and centre, mobility, development, king safety, control, phase, draws and
 // the geometry of pawn endings, each a separate fact; never weighed, never summed.
 import { Chess } from "chess.js";
 import { attacksOf, fileOf, rankOf } from "./facts.js";

package/dist/core/record.d.ts

@@ -13,7 +13,7 @@ export interface GameRecord {
     readonly comment?: string;
     readonly moves: readonly RecordedMove[];
 }
-/** The game with its tags and moves alone, without comments, plans or judgments: for Lichess or chess.com to load (T-59). */
+/** The game with its tags and moves alone, without comments, plans or judgments: for Lichess or chess.com to load. */
 export declare function movesOnly(record: GameRecord): GameRecord;
 /** A recorded move, frozen, with only the annotations it has. */
 export declare function recordedMove(san: string, nags?: readonly number[], comment?: string): RecordedMove;

package/dist/core/record.js

@@ -1,5 +1,5 @@
 // A game as plain data: the form it takes on disk (D-27) and in a PGN.
-/** The game with its tags and moves alone, without comments, plans or judgments: for Lichess or chess.com to load (T-59). */
+/** The game with its tags and moves alone, without comments, plans or judgments: for Lichess or chess.com to load. */
 export function movesOnly(record) {
     return { tags: record.tags, moves: record.moves.map((move) => ({ san: move.san })) };
 }

package/dist/core/review.d.ts

@@ -4,7 +4,7 @@ export declare const badges: readonly ["brilliant", "great", "best", "excellent"
 /** A move's badge. */
 export type Badge = (typeof badges)[number];
 /** The colours the AI draws with on the board, by the letters PGN's [%cal] and [%csl] write them with. */
-export declare const drawColours: {
+declare const drawColours: {
     readonly G: "green";
     readonly R: "red";
     readonly Y: "yellow";
@@ -42,8 +42,15 @@ export declare function squareOf(text: string): DrawnSquare | undefined;
 export declare function gameReviewOf(record: GameRecord): string | undefined;
 /** The AI's last word on how the game ended, when it wrote one. */
 export declare function closingOf(record: GameRecord): string | undefined;
+/** Whether the analyst has reviewed a game: its word on the whole game or on how it ended. The badges given during the game with the helps on are not a review (D-78). */
+export declare function isReviewed(record: GameRecord): boolean;
 /** The move with the AI's review in place of the one it had: the NAG of its badge, and its badge and note in the comment, beside what the comment held. */
 export declare function reviewed(move: RecordedMove, review: MoveReview): RecordedMove;
+/**
+ * The record without the AI's review (D-92): the badges with the NAGs they wrote, the notes, drawings and estimates of who is ahead on the moves, the word on
+ * the game and who signed it. What the comments held besides stays, as do the NAGs of moves without a badge and the Annotator of a game it never reviewed.
+ */
+export declare function unreviewed(record: GameRecord): GameRecord;
 /** The arrows and squares as PGN's [%cal] and [%csl] write them, for a comment; empty without any. */
 export declare function drawingsText({ arrows, squares }: Pick<MoveReview, "arrows" | "squares">): string;
 /** The record with who reviewed it (D-81): the model, else the host, as PGN's Annotator, and the effort only when known; an effort no longer known goes. */
@@ -70,5 +77,4 @@ export declare function withGameReview(record: GameRecord, { summary, closing }:
     summary?: string;
     closing?: string;
 }): GameRecord;
-/** Whether a word is one of the badges. */
-export declare function isBadge(word: string | undefined): word is Badge;
+export {};