rpg-engine 0.0.0-stage → 0.1.0

package/dist/commands/game-world.js

@@ -0,0 +1,204 @@
+import { join, resolve } from "node:path";
+import { campaignFileName, readCampaignData, readOneSetting, readTextSetting } from "../campaign/index.js";
+import { files, isInside } from "../core/store.js";
+import { comparableText } from "../core/text.js";
+import { loadWorld, searchSystemPages, worldFolderName } from "../pages/index.js";
+import { findCampaignSystem, findSystem, installedSystems, withSettings } from "../systems/index.js";
+/** The world of the campaign in `root`, with the pages of its game system when campaign.yaml names one that is installed (SYS-1, SYS-3). */
+export function campaignWorld(root, context) {
+    // The same world until one of its pages or campaign.yaml changes: in a session, across calls (D-137). A game system does not change while the server runs.
+    const from = [join(root, worldFolderName), join(root, campaignFileName)].map((path) => resolve(path));
+    const dependsOn = (path) => from.some((source) => source === path || isInside(source, path) || isInside(path, source));
+    return files().remember(`world ${resolve(root)}`, dependsOn, () => {
+        const named = readTextSetting(root, "system");
+        const system = campaignSystem(root, context);
+        return loadWorld(root, { system, language: readTextSetting(root, "language"), missingSystem: system === undefined ? named : undefined, noSystem: named === undefined });
+    });
+}
+/**
+ * The installed game system that campaign.yaml names, with what the campaign adds to it (CAM-1, CAM-2): alone when the additions do not read (CAM-3). Undefined
+ * when it names none, or one that is not installed (SYS-1).
+ */
+export function campaignSystem(root, context) {
+    return systemOf(root, context).system;
+}
+/**
+ * The game system campaign.yaml names, with its additions or why they do not read, and as its settings have it (DAT-10), read once until campaign.yaml changes:
+ * a call asks for it many times.
+ */
+function systemOf(root, context) {
+    const settings = resolve(join(root, campaignFileName));
+    return files().remember(`system ${resolve(root)}`, (path) => path === settings, () => {
+        const name = readTextSetting(root, "system");
+        const found = name === undefined ? {} : findCampaignSystem(context.systemFolders, name, readCampaignData(root));
+        return found.system === undefined ? found : { ...found, system: withSettings(found.system, (setting) => readTextSetting(root, setting)) };
+    });
+}
+/** A setting the campaign's game system adds to the setup (DAT-10), by its name in any case; undefined when the system has none by that name. */
+export function systemSetting(root, context, name) {
+    return campaignSystem(root, context)?.settings.find((setting) => comparableText(setting.name) === comparableText(name.trim()));
+}
+/** The value campaign.yaml gives a setting of the system, when it is one the system has (DAT-10). */
+export function systemSettingValue(root, setting) {
+    const written = readTextSetting(root, setting.name);
+    return setting.values.find((value) => written !== undefined && comparableText(value.value) === comparableText(written))?.value;
+}
+/** "xp is not kept with advancement milestones": said when a field the campaign's settings leave out is written or changed (DAT-10); undefined for any other. */
+export function leftOutNote(root, context, field) {
+    const setting = (campaignSystem(root, context)?.settings ?? []).find((candidate) => {
+        const value = candidate.values.find((other) => other.value === systemSettingValue(root, candidate));
+        return value?.without.some((name) => comparableText(name) === comparableText(field)) === true;
+    });
+    return setting === undefined ? undefined : `${field} is not kept with ${setting.name} ${systemSettingValue(root, setting) ?? ""}: config says what it means.`;
+}
+/** A setting of the system written by hand with a value the system does not have (DAT-10): what it takes instead. */
+export function systemSettingProblems(root, context) {
+    return (campaignSystem(root, context)?.settings ?? []).flatMap((setting) => {
+        const written = rawSetting(root, setting.name);
+        return written === undefined || written === null || systemSettingValue(root, setting) !== undefined ? [] : [{
+                path: campaignFileName,
+                message: `${setting.name} is ${JSON.stringify(written)}, which the system ${campaignSystem(root, context)?.name ?? ""} does not take: ${valuesText(setting)}.`,
+                fix: `ask the player, then config, setting ${setting.name}, with ${setting.values.map((value) => `value ${value.value}`).join(" or ")}`,
+            }];
+    });
+}
+/** A setting as campaign.yaml writes it, of any kind; undefined when the file does not read, which validate reports on its own. */
+function rawSetting(root, name) {
+    try {
+        return readOneSetting(root, name);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** "xp or milestones": the values of a setting of the system. */
+export function valuesText(setting) {
+    const values = setting.values.map((value) => value.value);
+    return values.length === 1 ? values[0] : `${values.slice(0, -1).join(", ")} or ${values.at(-1) ?? ""}`;
+}
+/** The occasions of a game system that end effects (DAT-5): those its recipes name, such as long rest. */
+export function occasionsOf(system) {
+    return [...new Set((system?.recipes ?? []).flatMap((recipe) => recipe.ends))];
+}
+/** The occasions of the campaign's game system, with its name; undefined without one. */
+export function systemOccasions(root, context) {
+    const system = campaignSystem(root, context);
+    return system === undefined ? undefined : { system: system.name, names: occasionsOf(system) };
+}
+/** A game system named in campaign.yaml that is not installed (SYS-1, D-167): the commands go on without its pages. */
+export function systemProblems(root, context) {
+    const name = readTextSetting(root, "system");
+    const found = name === undefined ? undefined : systemOf(root, context);
+    // What the campaign adds that does not read: the campaign plays with the system alone (CAM-3).
+    if (found?.problem !== undefined) {
+        return [{
+                path: "campaign.yaml",
+                message: `What campaign.yaml adds to the system ${name ?? ""} does not read, so the campaign plays with the system alone: ${found.problem}`,
+                fix: "fix it first, with the config command or by hand: until then validate does not check what the system works out on the pages",
+            }];
+    }
+    if (name === undefined || found?.system !== undefined) {
+        return [];
+    }
+    const [first] = installedSystems(context.systemFolders);
+    return [{
+            path: "campaign.yaml",
+            message: `The system ${name} is not installed: no creatures, items or rules come from a system. ${installedText(context)}`,
+            fix: first === undefined ? "install the game system" : `ask the player which game you play, then config, setting system, value ${first.name}`,
+        }];
+}
+/** The name of an installed game system, as it is installed; refused, with those that are, when none has it (D-167). */
+export function installedSystemName(name, context, how) {
+    const system = findSystem(context.systemFolders, name);
+    if (system === undefined) {
+        const [first] = installedSystems(context.systemFolders);
+        const example = first === undefined ? "" : ` Give one of them, such as ${how === "init" ? "system" : "setting system, value"} ${first.name}.`;
+        throw new Error(`"${name}" is not an installed system. ${installedText(context)}${example} Nothing changed.`);
+    }
+    return system.name;
+}
+/** "Installed: 5e (the fifth edition, from the SRD 5.1)." */
+function installedText(context) {
+    const systems = installedSystems(context.systemFolders);
+    return systems.length === 0 ? "No system is installed." : `Installed: ${systems.map((system) => `${system.name} (${system.title})`).join(", ")}.`;
+}
+/** " The campaign's system, Quinta edizione, is not installed, so none of its pages can be found: validate says how to fix it.": for a name not found (SYS-1). Empty otherwise. */
+export function missingSystemHint(world) {
+    if (world.noSystem === true) {
+        return " The campaign has no game system yet, so none of its pages can be found: choose it with config.";
+    }
+    return world.missingSystem === undefined ? "" : ` The campaign's system, ${world.missingSystem}, is not installed, so none of its pages can be found: validate says how to fix it.`;
+}
+/**
+ * " find looks for the pages of the system 5e in their names and fields, in English.": how a page of the game system is found, for a name that was not (SYS-3, D-165);
+ * the language only when it is not the campaign's. Empty when there is no system.
+ */
+export function systemSearchHint(world) {
+    const language = foreignSystemLanguage(world);
+    return world.system === undefined ? "" : ` find looks for the pages of the system ${world.system.name} in their names and fields${language === undefined ? "" : `, in ${language}`}.`;
+}
+/** The language the game system names its pages in, such as English, when it is not the campaign's (D-165); undefined when it is, or there is no system. */
+export function foreignSystemLanguage(world) {
+    return world.system === undefined ? undefined : foreignLanguage(world.system.language, world.language);
+}
+/** The language a game system writes in, such as English, when the campaign plays in another one (D-165); undefined when it is the same, or the campaign's is not set. */
+export function foreignLanguage(systemLanguage, campaignLanguage) {
+    return campaignLanguage === undefined || campaignLanguage.split("-")[0] === systemLanguage.split("-")[0] ? undefined : languageName(systemLanguage);
+}
+/**
+ * " If it is a kind of one of the system 5e (named in English: find, type creature, with a text in English), set creature to it, and its numbers come from there.": for a page
+ * created without the base its type may have, when the game system has pages of that type (D-165, SYS-7). Empty otherwise.
+ */
+export function systemBaseHint(world, type, field) {
+    if (world.system === undefined || searchSystemPages(world, { type }).length === 0) {
+        return "";
+    }
+    const language = foreignSystemLanguage(world);
+    const named = language === undefined ? "" : ` (named in ${language}: find, type ${type}, with part of its name in ${language})`;
+    return ` If it is a kind of one of the system ${world.system.name}${named}, set ${field} to it, and its numbers come from there.`;
+}
+/**
+ * " The system 5e has 8 more creatures, named in English: find one with find, type creature and a text in English, then give its name here.": the pages of a type
+ * the game system has, for a message that lists the campaign's (SYS-3). Empty when it has none.
+ */
+export function systemPagesHint(world, type) {
+    const count = world.system === undefined ? 0 : searchSystemPages(world, { type }).length;
+    if (world.system === undefined || count === 0) {
+        return "";
+    }
+    const language = foreignSystemLanguage(world);
+    const named = language === undefined ? "" : `, named in ${language}`;
+    const inLanguage = language === undefined ? "" : ` in ${language}`;
+    return ` The system ${world.system.name} has ${count} ${count === 1 ? type : `${type}s`}${named}: find one with find, type ${type} and part of its name${inLanguage}, then give its name here.`;
+}
+/** The settings still missing, with the installed game systems beside system, the one to ask for among them (D-167): "system (installed: 5e)". */
+export function missingWithSystems(root, missing, context) {
+    const names = installedSystems(context.systemFolders).map((system) => system.name);
+    const system = names.length > 0 ? `system (installed: ${names.join(", ")})` : "system";
+    // What the system adds to the setup, with its values: config says what each means (DAT-10).
+    const added = (campaignSystem(root, context)?.settings ?? []).filter((setting) => systemSettingValue(root, setting) === undefined).map((setting) => `${setting.name} (${valuesText(setting)})`);
+    // The system first (D-167): the other settings may depend on the game.
+    return [...(missing.includes("system") ? [system, ...missing.filter((name) => name !== "system")] : missing), ...added];
+}
+/**
+ * The campaign's system as status shows it, so that the master always knows which rules are played (D-173): "5e, the fifth edition from the SRD 5.1, the 2014 rules";
+ * one that is not installed says so, with the fix (D-167). Undefined when campaign.yaml names none.
+ */
+export function systemInStatus(root, context) {
+    const name = readTextSetting(root, "system");
+    const system = name === undefined ? undefined : findSystem(context.systemFolders, name);
+    if (name === undefined || system !== undefined) {
+        return system === undefined ? undefined : `${system.name}, ${system.title}`;
+    }
+    const [first] = installedSystems(context.systemFolders);
+    return `${name} ${first === undefined ? "(not installed)" : `(not installed: ask the player, then config, setting system, value ${first.name})`}`;
+}
+/** A language as messages name it, such as English for en. */
+function languageName(code) {
+    try {
+        return new Intl.DisplayNames(["en"], { type: "language" }).of(code) ?? code;
+    }
+    catch {
+        return code;
+    }
+}

package/dist/commands/image.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+interface ImageResult {
+    page: string;
+    /** The picture now in the campaign, from its folder; undefined when the page's own was removed. */
+    image?: string;
+    /** Where it came from, when it was copied. */
+    from?: string;
+    /** The page whose picture it shows now that its own is gone, if any. */
+    inheritedFrom?: string;
+    changed: boolean;
+    /** The picture is being made, and comes by itself (D-308). */
+    making?: boolean;
+}
+export declare const image: import("../core/registry.ts").Command<z.ZodObject<{
+    page: z.ZodString;
+    file: z.ZodOptional<z.ZodString>;
+    describe: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, ImageResult>;
+export {};

package/dist/commands/image.js

@@ -0,0 +1,185 @@
+import { join, relative, resolve } from "node:path";
+import { z } from "zod";
+import { readListSetting, readSettings, requireCampaign } from "../campaign/index.js";
+import { appendLogEntry } from "../core/log.js";
+import { defineCommand } from "../core/registry.js";
+import { files, isInside } from "../core/store.js";
+import { comparableText, withArticle } from "../core/text.js";
+import { imageFileName, imageLink, imagesFolderName, readImage } from "../images/index.js";
+import { baseChain, findPage, isPartyMember, ownField, pageNamed, parsePageReference, writePage } from "../pages/index.js";
+import { imageFile, ownImage } from "./game-images.js";
+import { knowledgeOf, knowsPage, playerCharacter } from "./game-knowledge.js";
+import { readOpenScene } from "./game-scene.js";
+import { newDatedLogEntry } from "./game-time.js";
+import { campaignSystem, campaignWorld } from "./game-world.js";
+import { sheetHeadline } from "./sheet.js";
+export const image = defineCommand({
+    name: "image",
+    description: "Give a page its picture: a portrait for a character, an image for a creature, an item or a place, as the dashboard will show it in a round token. "
+        + "It copies the file into the campaign and links it in the page's image field; a page without one shows the picture of the page it derives from, such as a goblin's icon. "
+        + "Use it when the player gives you a picture, or after you made or downloaded one with your own tools. "
+        + "For a place, a quest, a character or a creature of the campaign, describe instead of file has the picture made on this computer, as the campaign's pictures setting allows: "
+        + "for the player character or a companion only when the player asks; for a creature once for each kind, whose copies show it. "
+        + "Example: page Ettore, file C:\\Users\\me\\Pictures\\ettore.png.",
+    group: "game",
+    positionals: ["page", "file"],
+    input: z.object({
+        page: z.string().describe("the page that gets the picture"),
+        file: z.string().optional().describe("the picture's file, PNG, JPEG, WebP or SVG up to 5 MB: its full path or one from the folder the command runs in; leave it out to remove the page's own picture"),
+        describe: z.string().optional().describe("instead of file, in a few lines, never a victim or wounds: for a place, what the party sees arriving; for a quest, what the character knows of it; "
+            + "for one of the party, their look, their people as this world has them and the rest as the player described it; for a character or a creature met, what the character sees of them, "
+            + "a disguise as the disguise; never what the character does not know. The picture is made where it can be, and comes by itself"),
+    }),
+    run(input, context) {
+        const root = requireCampaign(context.folder);
+        const world = campaignWorld(root, context);
+        const page = pageNamed(world, input.page);
+        if (page === undefined) {
+            throw new Error(`${copyRefusal(root, world, input.page) ?? `There is no page ${input.page}: write it first, or look for its name with find.`} Nothing changed.`);
+        }
+        if (page.system !== undefined) {
+            throw new Error(`${systemRefusal(page)} Nothing changed.`);
+        }
+        if (input.describe !== undefined && input.describe.trim() !== "") {
+            if (input.file !== undefined && input.file.trim() !== "") {
+                throw new Error("Give file or describe, not both: file is a picture you have, describe has one made. Nothing changed.");
+            }
+            return madePicture(root, context, world, page, input.describe.trim());
+        }
+        if (input.file === undefined || input.file.trim() === "") {
+            return removeImage(root, context, world, page, imageFile(root, context, ownImage(page)));
+        }
+        return setImage(root, context, world, page, resolve(context.folder, input.file.trim()));
+    },
+    format(result) {
+        if (result.making === true) {
+            return `${result.page}'s picture is being made, in a minute or so: the player's dashboard shows it when it comes. Go on with the story.`;
+        }
+        if (result.image !== undefined) {
+            return `${result.page}'s picture is now ${result.image}${result.from === undefined ? "" : `, copied from ${result.from}`}.`;
+        }
+        const shown = result.inheritedFrom === undefined ? "it has none now" : `it shows the picture of ${result.inheritedFrom}`;
+        return result.changed ? `${result.page} has no picture of its own any more: ${shown}.` : `${result.page} has no picture of its own: ${shown}.`;
+    },
+});
+/** Copies a picture into the campaign's images folder and links it in the page; the page's old picture goes when nothing else links it. */
+function setImage(root, context, world, page, from) {
+    const old = imageFile(root, context, ownImage(page));
+    const picture = readImage(from);
+    if ("problem" in picture) {
+        throw new Error(`${picture.problem} Nothing changed.`);
+    }
+    const target = join(root, imagesFolderName, `${page.name}.${picture.extension}`);
+    if (resolve(target) !== from) {
+        files().writeBytes(target, picture.bytes);
+    }
+    writePage(world, page.name, undefined, { set: { image: imageLink(`${page.name}.${picture.extension}`) } });
+    removeUnused(root, world, page, old, target);
+    appendLogEntry(root, newDatedLogEntry(root, context, "image-set", "public", { page: page.name, image: shownPath(root, target) }));
+    return { page: page.name, image: shownPath(root, target), from: resolve(target) === from ? undefined : from, changed: true };
+}
+/** Why a page of the game system takes no picture, and how to give one: to a page of the campaign that derives from it, which a creature's scenes then bring in. */
+function systemRefusal(page) {
+    const readOnly = `${page.name} is ${withArticle(page.type ?? "page")} of the game system ${page.system}: read-only.`;
+    if (page.type === "creature") {
+        return `${readOnly} Write a creature of the campaign that derives from it: write "<name>", type creature, set creature=[[${page.name}]]; `
+            + `give that its picture with image, and bring it into scenes in place of ${page.name}, as creatures "<name>"=2.`;
+    }
+    const [type, base] = page.type === "item" ? ["item", "item"] : ["character", "creature"];
+    return `${readOnly} Give the picture to a page of the campaign that derives from it, such as one made with write "Grak", type ${type}, set ${base}=[[${page.name}]]; then image Grak with the file.`;
+}
+/** Why a copy in the open scene takes no picture of its own: it shows its creature's, one for all its copies (D-420); undefined when no copy has the name. */
+function copyRefusal(root, world, name) {
+    const copy = Object.entries(readOpenScene(root).scene?.copies ?? {}).find(([copyName]) => comparableText(copyName) === comparableText(parsePageReference(name).name));
+    if (copy === undefined) {
+        return undefined;
+    }
+    const creature = findPage(world, parsePageReference(copy[1].creature).name);
+    const kind = creature?.name ?? parsePageReference(copy[1].creature).name;
+    const own = `${copy[0]} is a copy of ${kind} in the scene, and shows its creature's picture, one for all its copies.`;
+    return creature?.system === undefined ? `${own} Give it to ${kind}: image ${kind}, with file or describe.` : `${own} ${systemRefusal(creature)}`;
+}
+/**
+ * A place's picture made from what the party sees, a quest's from what the character knows of it, the portrait of one of the party as the player described
+ * them, or the token of a character or a kind of creature met, from what the character sees (D-308, D-388, D-408, D-420, PIC-1–PIC-3), where the campaign's
+ * setting allows it and this computer can: in the MCP server it comes by itself while the story goes on; on the command line the command waits for it. A refusal
+ * is never tried again.
+ */
+function madePicture(root, context, world, page, seen) {
+    const kind = page.type === "place" || page.type === "quest" || page.type === "creature" ? page.type : page.type === "character" ? "portrait" : undefined;
+    if (kind === undefined) {
+        throw new Error(`describe makes pictures of places, quests, characters and creatures, and ${page.name} is ${withArticle(page.type ?? "free page")}: give a picture of it with file. Nothing changed.`);
+    }
+    const setting = readSettings(root).pictures;
+    if (setting === undefined || setting === "none") {
+        throw new Error(`The campaign makes no pictures (pictures: ${setting ?? "not chosen"}): ask the player whether they want them, then config pictures: new elements, on request or none. Nothing changed.`);
+    }
+    const ready = context.pictures?.ready(true) ?? { ready: false, why: "Nothing on this computer makes pictures" };
+    if (!ready.ready || context.pictures === undefined) {
+        throw new Error(`${ready.ready ? "Nothing on this computer makes pictures" : ready.why}. If your own tools make pictures, make one and give it with file; else go on without. Nothing changed.`);
+    }
+    const unseen = [...readListSetting(root, "lines"), ...readListSetting(root, "veils")];
+    const { name, who } = kind === "place" || kind === "quest" ? { name: page.name } : isPartyMember(page) ? { name: page.name, who: portraitWho(root, context, world, page) } : metWho(root, world, page);
+    const making = context.pictures.make({ kind, name, ...(who === undefined ? {} : { who }), seen, unseen }).then((made) => {
+        if ("refused" in made) {
+            appendLogEntry(root, newDatedLogEntry(root, context, "image-refused", "hidden", { page: page.name, why: made.refused }));
+            throw new Error(`No picture of ${page.name}: ${made.refused}. Go on without, or give one with file.`);
+        }
+        try {
+            const world = campaignWorld(root, context);
+            const now = world.pages.find((candidate) => candidate.path === page.path) ?? page;
+            // Codex's own copy goes once copied: the picture is the campaign's.
+            return { ...setImage(root, context, world, now, made.file), from: undefined };
+        }
+        finally {
+            made.done();
+        }
+    });
+    if (context.files === undefined) {
+        return making;
+    }
+    // The MCP server lives on: the picture comes by itself, and the dashboard shows it.
+    making.catch(() => undefined);
+    return { page: page.name, changed: false, making: true };
+}
+/** What the game says one of the party is, for their portrait (D-408): what their page derives from, as their people, and the line under their name. */
+function portraitWho(root, context, world, page) {
+    const said = [baseChain(world, page).map((base) => base.name).join(", "), sheetHeadline(world, campaignSystem(root, context), page) ?? ""].filter((part) => part !== "");
+    return said.length === 0 ? undefined : said.join("; ");
+}
+/**
+ * How the brief names one met (D-420): by their name and what they derive from only as far as the player character knows them, so that the picture never tells
+ * what it does not know; else as someone, or a creature, with only what is seen.
+ */
+function metWho(root, world, page) {
+    const pc = playerCharacter(world);
+    const knowledge = pc === undefined ? undefined : knowledgeOf(root, world, pc);
+    const known = (one) => knowledge !== undefined && knowsPage(knowledge, one);
+    const bases = baseChain(world, page).filter(known).map((base) => base.name).join(", ");
+    return { name: known(page) ? page.name : page.type === "creature" ? "a creature" : "someone", ...(bases === "" ? {} : { who: bases }) };
+}
+function removeImage(root, context, world, page, old) {
+    const field = ownField(page, "image");
+    const inheritedFrom = baseChain(world, page).find((base) => imageFileName(ownImage(base)) !== undefined)?.name;
+    if (field === undefined) {
+        return { page: page.name, inheritedFrom, changed: false };
+    }
+    writePage(world, page.name, undefined, { unset: [field] });
+    removeUnused(root, world, page, old, undefined);
+    appendLogEntry(root, newDatedLogEntry(root, context, "image-removed", "public", { page: page.name }));
+    return { page: page.name, inheritedFrom, changed: true };
+}
+/** Removes the campaign's picture that the page linked before, when it is not the new one and no other page links it. */
+function removeUnused(root, world, page, old, kept) {
+    if (old === undefined || !isInside(join(root, imagesFolderName), old) || (kept !== undefined && resolve(old) === resolve(kept))) {
+        return;
+    }
+    const name = imageFileName(ownImage(page))?.toLowerCase();
+    const linkedElsewhere = world.pages.some((other) => other !== page && other.system === undefined && imageFileName(ownImage(other))?.toLowerCase() === name);
+    if (!linkedElsewhere) {
+        files().remove(old);
+    }
+}
+function shownPath(root, path) {
+    return relative(root, path).replaceAll("\\", "/");
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "../core/registry.ts";
+/** Every command of rpg-engine. */
+export declare const commands: Command<any, any>[];

package/dist/commands/index.js

@@ -0,0 +1,57 @@
+import { advance } from "./advance.js";
+import { ask } from "./ask.js";
+import { change } from "./change.js";
+import { config } from "./config.js";
+import { effect } from "./effect.js";
+import { find } from "./find.js";
+import { image } from "./image.js";
+import { init } from "./init.js";
+import { install } from "./install.js";
+import { instructions } from "./instructions.js";
+import { mode } from "./mode.js";
+import { mood } from "./mood.js";
+import { move } from "./move.js";
+import { rename } from "./rename.js";
+import { reveal } from "./reveal.js";
+import { roll } from "./roll.js";
+import { route } from "./route.js";
+import { rules } from "./rules.js";
+import { save } from "./save.js";
+import { scene } from "./scene.js";
+import { show } from "./show.js";
+import { status } from "./status.js";
+import { translate } from "./translate.js";
+import { travel } from "./travel.js";
+import { validate } from "./validate.js";
+import { view } from "./view.js";
+import { write } from "./write.js";
+/** Every command of rpg-engine. */
+export const commands = [
+    init,
+    config,
+    instructions,
+    status,
+    mode,
+    validate,
+    write,
+    rename,
+    move,
+    reveal,
+    image,
+    show,
+    view,
+    find,
+    rules,
+    roll,
+    ask,
+    change,
+    effect,
+    mood,
+    advance,
+    travel,
+    route,
+    scene,
+    save,
+    translate,
+    install,
+];

package/dist/commands/init.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export declare const init: import("../core/registry.ts").Command<z.ZodObject<{
+    folder: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    system: z.ZodOptional<z.ZodString>;
+    difficulty: z.ZodOptional<z.ZodEnum<{
+        story: "story";
+        easy: "easy";
+        normal: "normal";
+        hard: "hard";
+        brutal: "brutal";
+    }>>;
+    lethality: z.ZodOptional<z.ZodEnum<{
+        narrative: "narrative";
+        epic: "epic";
+        dice: "dice";
+    }>>;
+}, z.core.$strip>, {
+    root: string;
+    name: string;
+    note: string;
+}>;

package/dist/commands/init.js

@@ -0,0 +1,44 @@
+import { basename, resolve } from "node:path";
+import { z } from "zod";
+import { createCampaign, difficulties, lethalities } from "../campaign/index.js";
+import { appendLogEntry, newLogEntry } from "../core/log.js";
+import { defineCommand } from "../core/registry.js";
+import { startInstructions } from "../instructions/index.js";
+import { createWorld } from "../pages/index.js";
+import { campaignNote } from "./game-mode.js";
+import { installedSystemName } from "./game-world.js";
+export const init = defineCommand({
+    name: "init",
+    description: "Create a new campaign. "
+        + "It writes the settings, the log, the world's folders, and the .mcp.json, AGENTS.md and CLAUDE.md through which an AI host finds these tools. "
+        + "Use it once, when the player starts a new campaign; then ask the player for the missing settings and set them with config. "
+        + 'Example: name "The Salt Isles", language en, system 5e.',
+    group: "campaign",
+    positionals: ["folder"],
+    input: z.object({
+        folder: z.string().optional().describe("folder of the new campaign; the current folder if left out"),
+        name: z.string().optional().describe("name of the campaign; the folder's name if left out"),
+        language: z.string().optional().describe("language of the game, as a code such as it or en"),
+        system: z.string().optional().describe("game system: one of those installed, such as 5e"),
+        difficulty: z.enum(difficulties).optional().describe(`how hard the world plays: ${difficulties.join(", ")}`),
+        lethality: z.enum(lethalities).optional().describe(`what a fall means: ${lethalities.join(", ")}`),
+    }),
+    run(input, context) {
+        const folder = resolve(context.folder, input.folder ?? ".");
+        // Only an installed system (D-167), as it is installed.
+        const system = input.system === undefined ? undefined : installedSystemName(input.system, context, "init");
+        const settings = { name: input.name ?? basename(folder), language: input.language, system, difficulty: input.difficulty, lethality: input.lethality };
+        const root = createCampaign(folder, settings, context.platform, startInstructions());
+        createWorld(root);
+        appendLogEntry(root, newLogEntry(context, "campaign-created", "public", settings));
+        return { root, name: settings.name, note: campaignNote(root, context) };
+    },
+    // The player reads it first, who made the campaign in a terminal: what to do next; then what the master still agrees with them.
+    format(result) {
+        return [
+            `Created the campaign "${result.name}" in ${result.root}.`,
+            "To play, open Claude Code or Codex in this folder and say hello: the master asks you the rest.",
+            ...(result.note === "" ? [] : ["", `For the master: ${result.note}`]),
+        ].join("\n");
+    },
+});

package/dist/commands/install.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { HelperName } from "../core/context.ts";
+type InstallResult = {
+    kind: "ready";
+    program: HelperName;
+    installed: boolean;
+} | {
+    kind: "waiting";
+    program: HelperName;
+    installed: boolean;
+    link?: string;
+} | {
+    kind: "failed";
+    program: HelperName;
+    why: string;
+};
+export declare const install: import("../core/registry.ts").Command<z.ZodObject<{
+    program: z.ZodEnum<{
+        codex: "codex";
+        claude: "claude";
+    }>;
+}, z.core.$strip>, InstallResult>;
+export {};

package/dist/commands/install.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { requireCampaign } from "../campaign/index.js";
+import { appendLogEntry } from "../core/log.js";
+import { defineCommand } from "../core/registry.js";
+import { newDatedLogEntry } from "./game-time.js";
+// What each program is called, and the account its sign-in asks for.
+const programs = {
+    codex: { name: "Codex", account: "ChatGPT account", gives: "the dashboard is translated in the background from now on, and pictures are made where their plan allows (Plus and up)" },
+    claude: { name: "Claude Code", account: "Claude account, Pro or Max", gives: "the dashboard is translated in the background from now on, and pictures are drawn" },
+};
+export const install = defineCommand({
+    name: "install",
+    description: "Install Codex or Claude Code on the player's computer, and open their sign-in. "
+        + "Once the player says yes as status offers it. It may take half a minute; the sign-in opens in the player's browser. "
+        + "Call it again once the player says they signed in.",
+    group: "campaign",
+    positionals: ["program"],
+    slow: true,
+    input: z.object({
+        program: z.enum(["codex", "claude"]).describe("codex for a ChatGPT account, any plan; claude for Claude Pro or Max"),
+    }),
+    async run(input, context) {
+        const root = requireCampaign(context.folder);
+        const helpers = context.helpers;
+        const program = input.program;
+        if (helpers === undefined) {
+            throw new Error(`Only the game's server installs programs, in a chat. In a terminal: npm install -g ${program === "codex" ? "@openai/codex, then codex login" : "@anthropic-ai/claude-code, then claude auth login"}.`);
+        }
+        const before = helpers.state(program);
+        // Ready, as once the player signed in: the page reads its words again when the campaign changes, and this line tells it they can be translated now.
+        if (before === "ready") {
+            appendLogEntry(root, newDatedLogEntry(root, context, "helper-ready", "hidden", { program }));
+            return { kind: "ready", program, installed: false };
+        }
+        const missing = before === "missing";
+        const why = missing ? await helpers.install(program) : undefined;
+        if (why !== undefined) {
+            return { kind: "failed", program, why: `it could not be installed: ${why}` };
+        }
+        if (missing) {
+            appendLogEntry(root, newDatedLogEntry(root, context, "helper-installed", "hidden", { program }));
+        }
+        const login = await helpers.login(program);
+        if (login.state === "failed") {
+            return { kind: "failed", program, why: login.why };
+        }
+        if (login.state === "waiting") {
+            return { kind: "waiting", program, installed: missing, ...(login.link === undefined ? {} : { link: login.link }) };
+        }
+        // Signed in: with the account the engine uses, or one it never uses, such as an API key.
+        if (helpers.state(program) !== "ready") {
+            return { kind: "failed", program, why: `the sign-in ended, but not with a ${programs[program].account}` };
+        }
+        appendLogEntry(root, newDatedLogEntry(root, context, "helper-ready", "hidden", { program }));
+        return { kind: "ready", program, installed: missing };
+    },
+    format(result) {
+        const { name, account, gives } = programs[result.program];
+        if (result.kind === "ready") {
+            return `${name} is ready on this computer with the player's ${account}: ${gives}. Tell the player in a few words, and go on.`;
+        }
+        if (result.kind === "waiting") {
+            return `${result.installed ? `${name} is installed. Its` : `${name}'s`} sign-in is open in the player's browser: tell them to sign in with their ${account} and to tell you when they are done, `
+                + `then call install again; it waits ten minutes.${result.link === undefined ? "" : ` If no page opened, give them this link: ${result.link}`}`;
+        }
+        return `${name} is not ready: ${result.why}. Offer the player instead to translate the dashboard now, in the chat, with translate.`;
+    },
+});

package/dist/commands/instructions.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const instructions: import("../core/registry.ts").Command<z.ZodObject<{}, z.core.$strip>, {
+    text: string;
+}>;