chesspal 0.2.3 → 0.2.4

package/dist/page/talk/talk.js

@@ -59,29 +59,35 @@ export function Legend({ review, words }) {
 }
 /**
  * The player's words of the game, the newest by the box they write in with how far it got, and the box: Enter or the button sends the words alone, the next
- * move takes them with it. 200 characters from one move of the AI's to the next: once they are written, the box goes until its move (D-54).
+ * move takes them with it. 200 characters from one move of the AI's to the next: once they are written, the box goes until its move (D-54). In analysis the
+ * AI's answers are in the same thread, and each line of the player's names the move it was written on (D-101).
  */
-export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, canMove, name, problem, text }) {
+export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, canMove, name, problem, about, text }) {
     const list = useRef(null);
     useOnlyWhole(list, lines.map((line) => line.text));
     const left = talkLimits.line - spent;
     const blank = draft.trim() === "";
+    const lastWritten = lines.findLastIndex((line) => line.who === "player");
+    const lastAnswer = lines.findLastIndex((line) => line.who === "ai");
+    const prompt = about === undefined ? text.writeTo(name) : text.askAbout(name);
     const submit = () => {
         if (!blank) {
             onSend();
         }
     };
-    return (_jsxs(_Fragment, { children: [_jsx("ol", { ref: list, class: "sent", "aria-live": "polite", children: inOrder(lines.map((line, index) => (_jsxs("li", { style: aged(lines.length - 1 - index), children: [_jsx("p", { class: "said", children: line.text }), index === lines.length - 1 ? _jsx(Status, { heard: line.heard, name: name, text: text }) : null] }, index))), newestFirst) }), left <= 0 ? null : (_jsxs("form", { class: "compose", onSubmit: (event) => {
+    return (_jsxs(_Fragment, { children: [_jsx("ol", { ref: list, class: "sent", "aria-live": "polite", children: inOrder(lines.map((line, index) => (_jsxs("li", { class: line.who === "ai" ? "from-ai" : undefined, style: about === undefined ? aged(lines.length - 1 - index) : reread(index, lastAnswer), children: [line.who === "ai"
+                            ? (_jsx("p", { class: "say", children: _jsx(Marked, { text: line.text }) }))
+                            : (_jsxs("p", { class: "said", children: [about === undefined || line.shown?.move === undefined ? null : _jsx(ShownMove, { move: line.shown.move, onShow: () => about.onShow(line.shown.at), text: text }), line.text] })), index === lastWritten ? _jsx(Status, { heard: line.heard, name: name, text: text }) : null] }, index))), newestFirst) }), left <= 0 ? null : (_jsxs("form", { class: about === undefined ? "compose" : "compose asking", onSubmit: (event) => {
                     event.preventDefault();
                     submit();
-                }, children: [_jsx("p", { class: "limit", role: "status", children: problem ?? "" }), _jsx("textarea", { rows: 2, maxLength: left, placeholder: text.writeTo(name), "aria-label": text.writeTo(name), value: draft, onInput: (event) => onDraft(event.currentTarget.value), onKeyDown: (event) => {
+                }, children: [_jsx("p", { class: "limit", role: "status", children: problem ?? "" }), _jsx("textarea", { rows: 2, maxLength: left, placeholder: prompt, "aria-label": prompt, value: draft, onInput: (event) => onDraft(event.currentTarget.value), onKeyDown: (event) => {
                             if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {
                                 event.preventDefault();
                                 submit();
                             }
                         } }), _jsxs("div", { class: "foot", children: [spent + draft.length >= talkLimits.line - 50
                                 ? _jsxs("span", { class: "count", children: [spent + draft.length, "/", talkLimits.line] })
-                                : _jsx("span", { class: "hint", children: !blank && canMove ? text.withMove : "" }), _jsxs("button", { class: "send", type: "submit", disabled: blank, children: [text.send, _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M5 12H18M13 7L18 12L13 17" }) })] })] })] }))] }));
+                                : _jsx("span", { class: "hint", children: about === undefined ? !blank && canMove ? text.withMove : "" : _jsx(OnMove, { ply: about.ply, text: text }) }), _jsxs("button", { class: "send", type: "submit", disabled: blank, children: [text.send, _jsx("svg", { class: "icon", viewBox: "0 0 24 24", "aria-hidden": "true", children: _jsx("path", { d: "M5 12H18M13 7L18 12L13 17" }) })] })] })] }))] }));
 }
 /**
  * The talk narrowed to a card beside the board: the Torretta above, the player below, each with their name and side written down the card, a ring on
@@ -90,6 +96,18 @@ export function Compose({ lines, newestFirst, spent, draft, onDraft, onSend, can
 export function TalkFaces({ name, aiPicture, you, picture, ai, player, aiMoves, playerMoves, unread, text }) {
     return (_jsxs("div", { class: "faces", children: [_jsx(RailPlayer, { place: "ai", picture: aiPicture ?? _jsx(Torretta, { size: 40 }), name: name, ...(ai === undefined ? {} : { side: text.sides[ai] }), moves: aiMoves, unread: unread }), _jsx(RailPlayer, { place: "you", picture: picture, name: you, ...(player === undefined ? {} : { side: text.sides[player] }), moves: playerMoves })] }));
 }
+/** The move a line of the player's was written on, 14.♘f3, small at the line's head: a press shows it on the board again (Zoe). */
+function ShownMove({ move, onShow, text }) {
+    const [, number = "", san = move] = /^(\d+\.+)(.+)$/.exec(move) ?? [];
+    return (_jsxs("button", { type: "button", class: "shown-move", title: text.goTo(move), "aria-label": text.goTo(move), onClick: onShow, children: [_jsx("span", { class: "move-number", children: number }), _jsx(Figurines, { san: san, side: number.endsWith("...") ? "black" : "white" })] }));
+}
+/** What the words go with in analysis: the move shown, or the whole game at its start. */
+function OnMove({ ply, text }) {
+    if (ply === undefined) {
+        return _jsx(_Fragment, { children: text.onWholeGame });
+    }
+    return (_jsxs(_Fragment, { children: [text.onMove, " ", _jsxs("span", { class: "move-number", children: [ply.number, ply.side === "white" ? "." : "..."] }), _jsx(Figurines, { san: ply.san, side: ply.side })] }));
+}
 function OnBoard({ text }) {
     const point = useContext(PointSquare);
     return (_jsx(_Fragment, { children: text.split(boardWords).map((part, index) => index % 2 === 1
@@ -130,6 +148,10 @@ function inOrder(items, newestFirst) {
 function aged(age) {
     return { opacity: age === 0 ? 1 : Math.max(0.2, 0.4 - (age - 1) * 0.1) };
 }
+/** In analysis the talk is read again: the AI's last answer and what follows it whole, the older lines a little back, still readable (Zoe). */
+function reread(index, lastAnswer) {
+    return { opacity: index >= lastAnswer ? 1 : 0.75 };
+}
 /**
  * A list that never scrolls: a bubble that does not fit whole in it is hidden, the oldest first since the newest sit by the card, and shows again when the
  * window grows.

package/dist/page/text.js

@@ -64,7 +64,7 @@ const english = {
     noGame: "No game yet: press + to start one, or ask for one in the chat.",
     foldCard: "Fold the card",
     openCard: "Open the card",
-    saveMoves: "Moves-only PGN",
+    saveMoves: "PGN",
     saveMovesHint: "The moves alone, to open on Lichess or chess.com",
     noGameNow: "No game in progress",
     analysing: "Analysis in progress",
@@ -103,6 +103,8 @@ const english = {
     send: "Send",
     sent: "Sent",
     withMove: "Or move: your words go with it",
+    onMove: "On",
+    onWholeGame: "On the whole game",
     talk: "The talk",
     move: "Move",
     draw: "draw",
@@ -129,6 +131,7 @@ const english = {
     startClocks: "Start",
     thinking: { move: "Thinking about its move", ponder: "Thinking while you play" },
     asleep: (name) => `${name} is not listening: write a message, such as "hi", in the window where you opened ${name}, not here. Its clock waits until it answers.`,
+    asleepInAnalysis: (name) => `${name} is not listening: write to it in the window where you opened it, not here.`,
     commandHere: (name) => `/clear and the other commands go in the window where you opened ${name}, not here.`,
     refused: {
         "no-game": () => "There is no game going on: press + to start one, or ask for one in the chat.",
@@ -149,6 +152,8 @@ const english = {
     piece: (letter, side) => `${side} ${englishNames[letter]}`,
     taken: (pieces, ahead) => `Pieces taken: ${pieces.length === 0 ? "none" : pieces.join(", ")}${ahead > 0 ? `; ahead by ${ahead}` : ""}`,
     writeTo: (name) => `Write to ${name}…`,
+    askAbout: (name) => `Ask ${name} about this game…`,
+    goTo: (move) => `Go to ${move}`,
     readBy: (name) => `Read by ${name}`,
     wrote: (name) => `${name} wrote`,
     offers: "offers a draw",
@@ -325,6 +330,19 @@ const english = {
         pawnSquare: (pawn, caught) => `The enemy king is ${caught ? "inside" : "outside"} the square of the pawn on ${pawn}`,
         opposition: (side) => `${side === "white" ? "White" : "Black"} has the opposition`,
     },
+    legend: {
+        title: "Marks on the board",
+        hint: "Marks on the board (?)",
+        none: "No marks on the board now",
+        badge: "the move's judgment",
+        sign: (kind, tone) => `${tone === "threat" ? "Your" : tone === "chance" ? "Opponent's" : "A"} ${{ risk: "piece at risk", pin: "pinned piece", skewer: "skewered piece" }[kind]}`,
+        pinLine: "The pin's line",
+        skewerLine: "The skewer's line",
+        drawnBy: (name) => `drawn by ${name}`,
+        drawnByCoach: "drawn by the coach",
+        control: "How many of White's pieces and of Black's reach the square",
+        ends: { crown: "Won", mate: "Checkmated", flag: "Resigned", half: "Draw, half a point each" },
+    },
 };
 const italian = {
     language: "it",
@@ -385,7 +403,7 @@ const italian = {
     noGame: "Nessuna partita: premi + per iniziarne una, o chiedila nella chat.",
     foldCard: "Chiudi la scheda",
     openCard: "Apri la scheda",
-    saveMoves: "PGN solo mosse",
+    saveMoves: "PGN",
     saveMovesHint: "Solo le mosse, da aprire su Lichess o chess.com",
     noGameNow: "Nessuna partita in corso",
     analysing: "Analisi in corso",
@@ -424,6 +442,8 @@ const italian = {
     send: "Manda",
     sent: "Mandato",
     withMove: "Oppure muovi: parte con la mossa",
+    onMove: "Su",
+    onWholeGame: "Su tutta la partita",
     talk: "Conversazione",
     move: "Mossa",
     draw: "patta",
@@ -450,6 +470,7 @@ const italian = {
     startClocks: "Inizia",
     thinking: { move: "Sta pensando alla sua mossa", ponder: "Pensa mentre giochi tu" },
     asleep: (name) => `${name} non ti sta ascoltando: scrivi un messaggio, per esempio "ciao", nella finestra dove hai aperto ${name}, non qui. Il suo orologio aspetta che risponda.`,
+    asleepInAnalysis: (name) => `${name} non ti sta ascoltando: scrivigli nella finestra dove l'hai aperto, non qui.`,
     commandHere: (name) => `/clear e gli altri comandi vanno scritti nella finestra dove hai aperto ${name}, non qui.`,
     refused: {
         "no-game": () => "Nessuna partita in corso: premi + per iniziarne una, o chiedila nella chat.",
@@ -471,6 +492,8 @@ const italian = {
     piece: (letter, side) => `${italianNames[letter]} ${side === "white" ? (letter === "Q" || letter === "R" ? "bianca" : "bianco") : (letter === "Q" || letter === "R" ? "nera" : "nero")}`,
     taken: (pieces, ahead) => `Pezzi presi: ${pieces.length === 0 ? "nessuno" : pieces.join(", ")}${ahead > 0 ? `; avanti di ${ahead}` : ""}`,
     writeTo: (name) => `Scrivi a ${name}…`,
+    askAbout: (name) => `Chiedi a ${name} di questa partita…`,
+    goTo: (move) => `Vai a ${move}`,
     readBy: (name) => `Letto da ${name}`,
     wrote: (name) => `${name} ha scritto`,
     offers: "propone patta",
@@ -647,6 +670,19 @@ const italian = {
         pawnSquare: (pawn, caught) => `Il re nemico è ${caught ? "dentro il" : "fuori dal"} quadrato del pedone in ${pawn}`,
         opposition: (side) => `L'opposizione è del ${side === "white" ? "Bianco" : "Nero"}`,
     },
+    legend: {
+        title: "Segni sulla scacchiera",
+        hint: "Segni sulla scacchiera (?)",
+        none: "Nessun segno sulla scacchiera ora",
+        badge: "il giudizio della mossa",
+        sign: (kind, tone) => `${tone === "threat" ? "Tuo pezzo" : tone === "chance" ? "Pezzo avversario" : "Pezzo"} ${{ risk: "in pericolo", pin: "inchiodato", skewer: "infilato" }[kind]}`,
+        pinLine: "Linea dell'inchiodatura",
+        skewerLine: "Linea dell'infilata",
+        drawnBy: (name) => `disegnato da ${name}`,
+        drawnByCoach: "disegnato dall'allenatore",
+        control: "Quanti pezzi del Bianco e del Nero raggiungono la casa",
+        ends: { crown: "Ha vinto", mate: "Scacco matto", flag: "Ha abbandonato", half: "Patta, mezzo punto a testa" },
+    },
 };
 // How each piece moves, said when it was taken where it cannot go (Anatolij's words).
 const englishMoves = {

package/dist/server/mcp.js

@@ -154,14 +154,16 @@ function toolConfig(command) {
     return { description: command.description, inputSchema: z.looseObject({}).meta({ ...shownInput(command), $schema: undefined }), annotations, _meta: meta };
 }
 async function runTool(command, input, context, caller, meta) {
-    const agent = await sharingAgent(command, meta, context);
+    const calling = await sharingCaller(command, meta, context);
+    const agent = calling !== undefined && "agent" in calling ? calling.agent : undefined;
     const chat = command.byAgents === undefined && agent === undefined;
     let refused = false;
     try {
         if (chat) {
             context.calls?.();
         }
-        const result = await command.run(checkedInput(command, input), { ...context, caller, ...(agent === undefined ? {} : { agent }) });
+        const who = agent !== undefined ? { agent } : calling !== undefined ? { chat: true } : {};
+        const result = await command.run(checkedInput(command, input), { ...context, caller, ...who });
         return { content: [{ type: "text", text: command.format(result, context) }] };
     }
     catch (error) {
@@ -177,16 +179,16 @@ async function runTool(command, input, context, caller, meta) {
     }
 }
 /**
- * The agent that calls a tool it shares with the chat, as the analyst (D-89), by its type: looked up only in a folder where one may run and while no game
- * goes on, so that no call of the chat's waits for it while it plays; none for the chat, or when it cannot be told.
+ * Who calls a tool the chat shares with an agent, as the analyst (D-89): the chat, or the agent by its type; looked up only in a folder where one may run
+ * and while no game goes on, so that no call of the chat's waits for it while it plays. None when it cannot be told, or for an agent the tool is not shared with.
  */
-async function sharingAgent(command, meta, context) {
+async function sharingCaller(command, meta, context) {
     const agents = command.sharedWith?.filter((agent) => hasAgent(context.folder, agent, context.host?.())) ?? [];
     if (agents.length === 0 || gameGoingOn(context)) {
         return undefined;
     }
     const caller = await callingAgent(meta, context.folder);
-    return caller !== undefined && "agent" in caller && agents.includes(caller.agent) ? caller.agent : undefined;
+    return caller !== undefined && "agent" in caller && !agents.includes(caller.agent) ? undefined : caller;
 }
 /** Whether a game goes on, or may: a game that cannot be read is the command's to report, as the chat's call (Federico). */
 function gameGoingOn(context) {

package/dist/server/page/game.js

@@ -1,4 +1,4 @@
-import { analyseGame, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, startNewGame, } from "../../commands/index.js";
+import { analyseGame, answerDraw, bookPlies, ChatNotClear, DrawRefused, endGame, gameAt, gameToStudy, namedGame, newGame, offerDraw, playMove, samePosition, say, shownPosition, startNewGame, } from "../../commands/index.js";
 import { clockStarted, isReviewed, writePgn } from "../../core/index.js";
 import { aiModelOf, archiveName, coachShown, coachWords, drawOfferOf, endOf, gameInAnalysis, heardLines, loadGame, loadTableTalk, playerPgn, ponderingOn, saveGame, startAnalysis, talkLimits, thoughtKey, wakesTheChat, WordsRefused, } from "../../games/index.js";
 import { gameFolder, helpsIn } from "../../profiles/index.js";
@@ -72,28 +72,34 @@ async function moveFromPage(request, response, served) {
     served.bell.ring();
     send(response, 200, json, JSON.stringify({ played: true }));
 }
-/** The player's words from the page, without a move: saved with the game as player_say saves them, refused in the player's words, the doorbell rung for the first. */
+/**
+ * The player's words from the page, without a move: saved with the game as player_say saves them, refused in the player's words, the doorbell rung for the
+ * first; in analysis with the position the page shows, and the doorbell rung for each (D-101).
+ */
 async function messageFromPage(request, response, served) {
     if (!isJson(request)) {
         send(response, 415, json, JSON.stringify({ error: 'Send the message as JSON: {"text": "…"}.' }));
         return;
     }
-    const text = textOf(jsonOf(await bodyOf(request))?.text);
+    const body = jsonOf(await bodyOf(request));
+    const text = textOf(body?.text);
+    const shown = typeof body?.game === "string" && typeof body.at === "number" ? shownPosition(served.context, body.game, body.at) : undefined;
     if (text === undefined) {
         send(response, 400, json, JSON.stringify({ error: `Send the message as JSON, ${talkLimits.player} characters at most: {"text": "…"}.` }));
         return;
     }
     let current;
     try {
-        current = say(gameFolder(served.context.home()), "player", text, served.context.now());
+        current = say(gameFolder(served.context.home()), "player", text, served.context.now(), undefined, shown);
     }
     catch (error) {
         const noGame = refusalOf(served)?.refusal === "no-game";
         send(response, 409, json, JSON.stringify(refusalFrom(error, noGame ? "no-game" : undefined)));
         return;
     }
-    // The first words of a move wake the chat, and between games the first since the AI spoke; the AI finds the rest at its next call (D-54, D-74).
-    if (wakesTheChat(current)) {
+    // The first words of a move wake the chat, and between games the first since the AI spoke; the AI finds the rest at its next call (D-54, D-74). In
+    // analysis every line does: a chat that answered in its own window would not hear the next (Priya).
+    if (shown !== undefined || wakesTheChat(current)) {
         served.bell.ring();
     }
     send(response, 200, json, JSON.stringify({ said: true }));
@@ -244,7 +250,14 @@ function sendGame(response, served) {
     // With no game the page still shows the talk before the first (D-77).
     const spoken = current ?? loadTableTalk(folder);
     const heard = heardLines(spoken, served.context.given);
-    const talk = spoken.talk.map(({ who, text, ply }, index) => heard[index] === undefined ? { who, text, ply } : { who, text, ply, heard: heard[index] });
+    const talk = spoken.talk.map(({ who, text, ply, shown }, index) => ({
+        who,
+        text,
+        ply,
+        ...(heard[index] === undefined ? {} : { heard: heard[index] }),
+        // In analysis the page goes back to the move the player wrote about (D-101).
+        ...(shown === undefined ? {} : { shown }),
+    }));
     const offer = current === undefined ? undefined : drawOfferOf(current);
     const coach = coachOn(folder, current);
     const game = current === undefined ? null : {

package/dist/server/page/page.js

@@ -4,7 +4,7 @@ import { watch } from "node:fs";
 import { createServer } from "node:http";
 import { join } from "node:path";
 import { positionIn, samePosition } from "../../commands/index.js";
-import { gameStamp } from "../../games/index.js";
+import { gameStamp, tableTalkStamp } from "../../games/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { Bell, bellProbe, pagePorts } from "../bell.js";
@@ -111,12 +111,14 @@ function answer(request, response, served) {
 function hasNews(context) {
     return gameSeen(context) !== context.seen;
 }
-// The game the chat sees: the profile's folder, and the stamp of its game.json; none while the data folder cannot be made.
+// The game the chat sees: the profile's folder, and the stamps of its game.json and of the talk with no game, where the player's words go in analysis
+// before any game was played here (Priya); none while the data folder cannot be made.
 function gameSeen(context) {
     try {
         const folder = gameFolder(context.home());
         return `${folder}
-${gameStamp(folder) ?? ""}`;
+${gameStamp(folder) ?? ""}
+${tableTalkStamp(folder) ?? ""}`;
     }
     catch {
         return "";

package/instructions/opponent.md

@@ -10,6 +10,6 @@ This folder is the player's chess table, and you are their opponent: you choose
 - You have a face on the board page, and it shows how you feel. Give it as the `mood` of `ai_move` on each move where the game turns for you: a piece won or lost, a blunder seen, your own or theirs, a threat that appears or a plan that works or fails. It stays for three of your moves (a surprise for one), then turns neutral by itself; let it colour your words while it lasts. When the game ends on the player's move, give how you feel as it ends with `ai_say`'s `mood`.
 - Draws and resignations: `offer_draw` on `ai_move` offers a draw, on `player_move` records the player's, made with their move; an offer stands until the other side moves; `end_game` `draw_agreed` accepts a standing offer, `player_resigns` records the player's resignation in the chat, `ai_resigns` resigns yours. On the board page the player offers, answers and resigns there.
 - The player chooses a new game in the board page's New game window, which asks the sides, the clock and the level: when they ask you for a game, call `new_game` without choices, which opens it there, and don't ask those in the chat. Ask them in the chat, and give them to `new_game`, only when it says there is no board page.
-- To go over a game with the player once no game goes on, the one just over or one they bring as a PGN, give it to `analyse_game`: it reads the PGN for you; where Chesspal's answers say to start the analyst agent for it, start that instead, once per game: when it has gone over the game, go over it with the player from what it told you, and never tell them it starts again, even when they ask for the analysis again. While a game goes on, go over no game, not even in your head or from a PGN they paste: tell them it waits until this one ends.
+- To go over a game with the player once no game goes on, the one just over or one they bring as a PGN, give it to `analyse_game`: it reads the PGN for you; where Chesspal's answers say to start the analyst agent for it, start that instead, once per game, and never tell them it starts again, even when they ask for the analysis again. While it works, and after, talk the game over whenever the player asks: `look` and `position` with game and move show you any of its positions. When they show you something the review missed, first correct that move's note with `annotate_game` {game, notes: [{move, badge, note}]}, that move only, then answer. Words from the board page you answer with `ai_say`; words in the chat, in the chat. While a game goes on, go over no game, not even in your head or from a PGN they paste: tell them it waits until this one ends.
 - How to read the facts: attackers and defenders count only the pieces that reach the square directly, and a piece in brackets stands behind them; "Loose" means neither attacked nor defended, not attacked now; "At risk" lists the pieces attacked and undefended, attacked by a cheaper piece, or attacked more times than defended.
 - Talk with the player in their language, in a few words. The facts and the tools are for you: tell the player what a chess player would say, never the lists or the tools' names. Name pieces and moves in words, as people talk at the board ("your bishop took on f7"); when you write a move, yours or the player's, write it with the pieces' figurines, as the tools show it (♞f6 for Nf6, ♝xf7+ for Bxf7+), for both sides and in every language: never with letters, neither N B R Q K nor the player's own (Cf6), even when they write them.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chesspal",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Play chess against an AI with a character, and learn with an AI coach: Chesspal keeps the rules, the board, the games and the memory; the AI plays, reasons and talks.",
   "type": "module",
   "bin": {