chesspal 0.4.1 → 0.5.0

package/dist/server/table/hosts/hosts.js

@@ -1,20 +1,28 @@
-// The AI hosts the table opens a chat in (D-104): Claude Code and Codex, each with the start message, and the model and effort the player chose on the page
+// The AI hosts the table opens a chat in (D-104, D-115): Claude Code, Codex and Antigravity, each with the start message, and the model and effort the player chose on the page
 // for the profile in use, or each host's middle ones until they choose: the chat never starts with whatever the host was left at.
 import { speaksItalian } from "../../../commands/index.js";
-/** The hosts the page offers, by their command's name. */
-export const hostNames = ["claude", "codex"];
+/** The hosts the page offers, by the name `chesspal play` takes. */
+export const hostNames = ["claude", "codex", "antigravity"];
+/** Each host's program, as its installer names it. */
+export const hostPrograms = { claude: "claude", codex: "codex", antigravity: "agy" };
 /**
  * Each host's choices, as tried in each (Priya): a value outside them would fail only at the chat's first turn. Claude Code's are its aliases; Codex's, the
- * models a ChatGPT account lists, which change with its releases.
+ * models a ChatGPT account lists, which change with its releases; Antigravity's, the Gemini Flash its free plan gives, its effort apart (D-115), until
+ * the table has read the models of the player's account.
  */
 export const hostChoices = {
     claude: { models: ["fable", "opus", "sonnet", "haiku"], efforts: ["low", "medium", "high", "xhigh", "max"], model: "sonnet", effort: "medium" },
     codex: { models: ["gpt-6.1-sol", "gpt-6-astra", "gpt-6.1-terra", "gpt-6-luna"], efforts: ["low", "medium", "high", "xhigh", "max"], model: "gpt-6.1-terra", effort: "medium" },
+    antigravity: { models: ["gemini-3.8-flash"], efforts: ["low", "medium", "high"], model: "gemini-3.8-flash", effort: "medium" },
 };
 /** Whether a word names a host the page offers. */
 export function isHostName(name) {
     return hostNames.includes(name);
 }
+/** The efforts a host offers for one of its models: none for a model that has no effort to choose. */
+export function effortsOf(choices, model) {
+    return choices.modelEfforts?.[model] ?? choices.efforts;
+}
 /**
  * The message a chat opened by the table starts with, in the player's language: the AI answers it by calling status, as every chat does. A chat opened
  * `toAnalyse` the game the page shows is asked for that: told to play, it opened the New game window over the analysis it had just started.
@@ -27,29 +35,39 @@ export function startMessage(language, toAnalyse = false) {
 }
 /**
  * The start message and the choices the host knows: first for Claude Code, whose options may take the word after; last for Codex, where "resume" is no
- * subcommand, kept from its update screen, which an Enter would accept.
+ * subcommand, kept from its update screen, which an Enter would accept; for Antigravity after -i, which keeps the chat open, with Chesspal's tools
+ * allowed and the table's `folder` trusted for this chat alone, never saved in its settings: a folder trusted only at its first chat's dialog leaves that
+ * chat without its hooks. A model with no effort to choose is given none. `choices` are those the host offers, as read for Antigravity.
  */
-export function hostArgs(host, message, choice = {}) {
-    const { model, effort } = offered(host, choice);
+export function hostArgs(host, message, choice = {}, folder, choices = hostChoices[host]) {
+    const { model, effort } = offered(choices, choice);
     if (host === "claude") {
         return [message, ...(model === undefined ? [] : ["--model", model]), ...(effort === undefined ? [] : ["--effort", effort])];
     }
+    if (host === "antigravity") {
+        const settings = { ...antigravityAllowed, ...(folder === undefined ? {} : { trustedWorkspaces: [folder] }) };
+        return ["-i", message, ...(model === undefined ? [] : ["--model", model]), ...(effort === undefined ? [] : ["--effort", effort]), "--settings", JSON.stringify(settings)];
+    }
     return ["-c", "check_for_update_on_startup=false", ...(model === undefined ? [] : ["-m", model]), ...(effort === undefined ? [] : ["-c", `model_reasoning_effort=${effort}`]), message];
 }
-/** The settings' keys that keep a host's choice in the profile: claudeModel, claudeEffort, codexModel, codexEffort. */
+/** The settings' keys that keep a host's choice in the profile: claudeModel, claudeEffort, codexModel, codexEffort, antigravityModel, antigravityEffort. */
 export function choiceKeys(host) {
     return { model: `${host}Model`, effort: `${host}Effort` };
 }
-/** A host's choice as the profile's settings keep it: the values the host offers alone, the rest is its middle one. */
-export function choiceIn(settings, host) {
+/** A host's choice as the profile's settings keep it: the values the host offers alone, among `choices`, the rest is its middle one. */
+export function choiceIn(settings, host, choices = hostChoices[host]) {
     const keys = choiceKeys(host);
     const text = (value) => (typeof value === "string" ? value : undefined);
-    return offered(host, { model: text(settings?.[keys.model]), effort: text(settings?.[keys.effort]) });
+    return offered(choices, { model: text(settings?.[keys.model]), effort: text(settings?.[keys.effort]) });
 }
-// The choice kept to the values the host offers: its middle model and effort where none is chosen, or one it does not offer.
-function offered(host, choice) {
-    const choices = hostChoices[host];
+// Antigravity's settings for one chat: Chesspal's tools allowed, which it would otherwise ask for at each first use.
+const antigravityAllowed = { permissions: { allow: ["mcp(chesspal/*)"] } };
+// The choice kept to the values the host offers: its middle model where none is chosen, or one it does not offer; the model's middle effort likewise,
+// none for a model without.
+function offered(choices, choice) {
     const model = choice.model !== undefined && choices.models.includes(choice.model) ? choice.model : choices.model;
-    const effort = choice.effort !== undefined && choices.efforts.includes(choice.effort) ? choice.effort : choices.effort;
-    return { model, effort };
+    const efforts = effortsOf(choices, model);
+    const middle = efforts.includes(choices.effort) ? choices.effort : efforts[Math.floor((efforts.length - 1) / 2)];
+    const effort = choice.effort !== undefined && efforts.includes(choice.effort) ? choice.effort : middle;
+    return effort === undefined ? { model } : { model, effort };
 }

package/dist/server/table/hosts/models.d.ts

@@ -0,0 +1,19 @@
+import { type HostChoices, type HostName } from "./hosts.ts";
+/** Runs a program with its arguments: what it wrote on stdout; it fails when the program fails, or has not ended within `timeout` milliseconds. */
+export type RunProgram = (program: string, args: readonly string[], timeout: number) => Promise<string>;
+/** Antigravity's models as the table reads them: the choices offered now, a reading started, and who is told when they come. */
+export interface AntigravityModels {
+    choices(): HostChoices;
+    /** Reads the models with the program, once: again only after a reading that failed. */
+    read(program: string): void;
+    watch(changed: () => void): void;
+}
+/** Antigravity's models read with `run` for the table in `folder`, which keeps the list read for `chesspal play`. */
+export declare function antigravityModels(folder: string, run?: RunProgram): AntigravityModels;
+/**
+ * The choices in what `agy models` lists, an id and a name on each line: an id ending in an effort is that model with that effort, one without a model with
+ * no effort to choose. A Gemini Flash is the middle model where there is one, else the first; none when no line names a model.
+ */
+export declare function antigravityChoices(listed: string): HostChoices | undefined;
+/** The choices a host offers at the table in `folder`: Antigravity's as the table last read them, the others' always the same. */
+export declare function tableChoices(folder: string, host: HostName): HostChoices;

package/dist/server/table/hosts/models.js

@@ -0,0 +1,95 @@
+// Antigravity's models, as `agy models` lists them for the account signed in: Gemini Flash on a free plan, more with a subscription. The table reads them
+// once, without waiting for them, and keeps the list in its folder for `chesspal play`; until it comes, or when it cannot be read, Gemini Flash alone.
+import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeAtomically } from "../../../games/index.js";
+import { hostChoices } from "./hosts.js";
+/** Antigravity's models read with `run` for the table in `folder`, which keeps the list read for `chesspal play`. */
+export function antigravityModels(folder, run = runProgram) {
+    let read;
+    let reading = false;
+    const watchers = [];
+    return {
+        choices: () => read ?? hostChoices.antigravity,
+        read: (program) => {
+            if (read !== undefined || reading) {
+                return;
+            }
+            reading = true;
+            run(program, ["models"], readTime).then((listed) => {
+                reading = false;
+                read = antigravityChoices(listed);
+                if (read !== undefined) {
+                    keepList(folder, listed);
+                    watchers.forEach((changed) => changed());
+                }
+            }, () => {
+                reading = false;
+            });
+        },
+        watch: (changed) => {
+            watchers.push(changed);
+        },
+    };
+}
+/**
+ * The choices in what `agy models` lists, an id and a name on each line: an id ending in an effort is that model with that effort, one without a model with
+ * no effort to choose. A Gemini Flash is the middle model where there is one, else the first; none when no line names a model.
+ */
+export function antigravityChoices(listed) {
+    const modelEfforts = {};
+    for (const line of listed.split(/\r?\n/)) {
+        const id = line.split("\t")[0].trim();
+        if (!modelId.test(id)) {
+            continue;
+        }
+        const [, model = id, effort] = effortEnd.exec(id) ?? [];
+        const efforts = (modelEfforts[model] ??= []);
+        if (effort !== undefined && !efforts.includes(effort)) {
+            efforts.push(effort);
+            efforts.sort((one, other) => effortScale.indexOf(one) - effortScale.indexOf(other));
+        }
+    }
+    const models = Object.keys(modelEfforts);
+    if (models.length === 0) {
+        return undefined;
+    }
+    const efforts = effortScale.filter((effort) => models.some((model) => modelEfforts[model].includes(effort)));
+    const model = models.find((one) => /^gemini-.*flash/.test(one)) ?? models[0];
+    return { models, efforts, model, effort: "medium", modelEfforts };
+}
+/** The choices a host offers at the table in `folder`: Antigravity's as the table last read them, the others' always the same. */
+export function tableChoices(folder, host) {
+    if (host !== "antigravity") {
+        return hostChoices[host];
+    }
+    try {
+        return antigravityChoices(readFileSync(join(folder, listFile), "utf8")) ?? hostChoices.antigravity;
+    }
+    catch {
+        return hostChoices.antigravity;
+    }
+}
+// `agy models` asks Google's servers for the account's models: about a second, at times more.
+const readTime = 15_000;
+const listFile = "antigravity-models.txt";
+// The efforts Antigravity's ids end in, from the least.
+const effortScale = ["low", "medium", "high", "xhigh", "max"];
+const effortEnd = new RegExp(`^(.+)-(${effortScale.join("|")})$`);
+// An id as Antigravity writes them, which a header or a message never is.
+const modelId = /^[a-z0-9][a-z0-9._-]*$/;
+function runProgram(program, args, timeout) {
+    return new Promise((done, failed) => {
+        execFile(program, args, { timeout, windowsHide: true, encoding: "utf8" }, (error, stdout) => (error === null ? done(stdout) : failed(error)));
+    });
+}
+// A list that cannot be written leaves `chesspal play` with Gemini Flash: the chat starts all the same.
+function keepList(folder, listed) {
+    try {
+        writeAtomically(join(folder, listFile), listed);
+    }
+    catch {
+        // Nothing to do: see above.
+    }
+}

package/dist/server/table/hosts/play.d.ts

@@ -31,7 +31,10 @@ export declare function runHost(launch: HostLaunch, again: () => boolean, platfo
     code: number;
     again: boolean;
 }>;
-/** How the host starts for the profile in use: found on the PATH, with its choice; it throws, saying how to install it, when it is not there. */
+/**
+ * How the host starts for the profile in use: found on the PATH, or where its installer puts it, with its choice among those the table offers; it throws,
+ * saying how to install it, when it is not there.
+ */
 export declare function hostLaunch(context: Context, host: HostName, env?: NodeJS.ProcessEnv, exists?: (path: string) => boolean): HostLaunch;
 /**
  * Ends a process and what it started, a host's MCP server among them: on Windows its whole tree, which taskkill ends, never the console (Priya); else the

package/dist/server/table/hosts/play.js

@@ -7,9 +7,10 @@ import { speaksItalian } from "../../../commands/index.js";
 import { endOf, gameInAnalysis, loadGame } from "../../../games/index.js";
 import { tableFolder } from "../../../home/index.js";
 import { activeProfile, gameFolder, languageIn, profileSettings } from "../../../profiles/index.js";
-import { programPath } from "./find.js";
+import { hostProgramPath } from "./find.js";
 import { setUpTable, takeHooksNews } from "./hooks.js";
 import { choiceIn, hostArgs, isHostName, startMessage } from "./hosts.js";
+import { tableChoices } from "./models.js";
 import { askedAgain, leaveSeat, refreshSeat, seatTimes, takeSeat } from "./seat.js";
 import { cmdQuoted } from "./terminal.js";
 /**
@@ -127,21 +128,25 @@ export function runHost(launch, again, platform = process.platform, every = 500)
         });
     });
 }
-/** How the host starts for the profile in use: found on the PATH, with its choice; it throws, saying how to install it, when it is not there. */
+/**
+ * How the host starts for the profile in use: found on the PATH, or where its installer puts it, with its choice among those the table offers; it throws,
+ * saying how to install it, when it is not there.
+ */
 export function hostLaunch(context, host, env = process.env, exists) {
     const home = context.home();
     const folder = tableFolder(home);
-    const found = programPath(host, context.platform, env, exists);
+    const found = hostProgramPath(host, context.platform, env, exists);
     if (found === undefined) {
         throw new Error(`${hostTitle[host]} is not installed on this computer, or not on its PATH: install it (${installHint[host]}), then try again.`);
     }
-    setUpTable(folder, context.platform);
+    setUpTable(folder, context.platform, context.userHome?.());
     // Codex's hooks written, by this play or by the table before it: the note is for Codex's chat, and waits for it.
     const news = host === "codex" ? takeHooksNews(folder) : undefined;
     const hooks = news === undefined ? {} : { hooks: news };
-    const choice = choiceIn(profileSettings(home, activeProfile(home).id), host);
+    const choices = tableChoices(folder, host);
+    const choice = choiceIn(profileSettings(home, activeProfile(home).id), host, choices);
     const games = gameFolder(home);
-    const args = hostArgs(host, startMessage(languageIn(games, context.language), analysisAsked(games)), choice);
+    const args = hostArgs(host, startMessage(languageIn(games, context.language), analysisAsked(games)), choice, folder, choices);
     // An effort the player set for every chat would win over the one chosen on the page: spawn leaves out a variable that is undefined.
     const effort = host === "claude" && choice.effort !== undefined ? { CLAUDE_CODE_EFFORT_LEVEL: undefined } : {};
     // The seat this play holds, by which its chat's server tells the table it is the chat held, and not another opened in the same folder.
@@ -163,7 +168,7 @@ function analysisAsked(folder) {
         return false;
     }
 }
-const hostTitle = { claude: "Claude Code", codex: "Codex" };
+const hostTitle = { claude: "Claude Code", codex: "Codex", antigravity: "Antigravity" };
 // What the player is told before Codex asks about the hooks Chesspal wrote: the first time, and when they changed.
 const hooksWords = {
     new: {
@@ -256,7 +261,11 @@ function savedTerminal(platform) {
 }
 // What marks a chat's own session, which a table started from inside a chat would hand down, and the host take for its own (Priya).
 const sessionMarks = ["CLAUDECODE", "CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION", "CLAUDE_CODE_SESSION_ATTENDED", "CLAUDE_PID", "CLAUDE_EFFORT", "AI_AGENT", "TRACEPARENT"];
-const installHint = { claude: "https://claude.com/claude-code", codex: "npm install -g @openai/codex" };
+const installHint = {
+    claude: "https://claude.com/claude-code",
+    codex: "npm install -g @openai/codex",
+    antigravity: "https://antigravity.google/docs/getting-started",
+};
 /**
  * The script behind npm's Windows shim of Codex, which Node runs as the shim would, without cmd and its quoting of the start message (Priya); none for
  * another program, or when it is not beside the shim.

package/dist/server/table/table.js

@@ -14,7 +14,7 @@ export const tableTimes = { idle: 5 * 60_000, every: 15_000 };
  */
 export async function startTable(context, times = tableTimes, chats, updater) {
     const folder = tableFolder(context.home());
-    setUpTable(folder, context.platform);
+    setUpTable(folder, context.platform, context.userHome?.());
     let quit = () => undefined;
     const quitting = new Promise((done) => {
         quit = done;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chesspal",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "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": {