run-dmcp 0.1.0 → 0.2.0

package/dist/rpg/index.d.ts

@@ -0,0 +1,29 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Mechanic } from "../timeline/resolve.js";
+import type { RenderVocabulary } from "../timeline/render.js";
+/**
+ * Register every RPG-layer tool, resource and prompt onto an existing
+ * server. Combat brings dice with it (registerCombatTools registers both,
+ * matching how the pre-split assembly registered them as one domain).
+ */
+export declare function registerRpgTools(server: McpServer): void;
+/**
+ * Build the FULL assembly: every core tool plus every RPG tool, resource and
+ * prompt this engine has always served. Same name, same `{ mechanics?,
+ * vocabulary? }` options as the pre-split `createMcpServer` in
+ * src/mcp-server.ts -- this is that function, now composed from two layers
+ * instead of one, so src/bin/run-dmcp.ts's zero-argument call site keeps
+ * working unchanged and the registered tool/resource/prompt set is
+ * unchanged too (src/__tests__/layerBoundary.test.ts asserts this exactly).
+ */
+export declare function createMcpServer(options?: {
+    mechanics?: readonly Mechanic[];
+    vocabulary?: RenderVocabulary;
+}): McpServer;
+export { createHttpServer, startHttpServer } from "../http/server.js";
+export * from "./tools/dice.js";
+export * from "./tools/combat.js";
+export * from "./tools/ability.js";
+export * from "./tools/status.js";
+export * from "./tools/tables.js";
+export * from "./tools/quest.js";

package/dist/rpg/index.js

@@ -0,0 +1,55 @@
+import { createCoreMcpServer } from "../mcp-server.js";
+import { registerCombatTools } from "./register/combat.js";
+import { registerAbilityTools } from "./register/abilities.js";
+import { registerStatusTools } from "./register/status.js";
+import { registerTableTools } from "./register/tables.js";
+import { registerQuestTools } from "./register/quests.js";
+import { registerRpgBatchTools } from "./register/batch.js";
+import { registerRpgMcpResources } from "./register/mcp-resources.js";
+import { registerMcpPrompts } from "./register/mcp-prompts.js";
+/**
+ * Register every RPG-layer tool, resource and prompt onto an existing
+ * server. Combat brings dice with it (registerCombatTools registers both,
+ * matching how the pre-split assembly registered them as one domain).
+ */
+export function registerRpgTools(server) {
+    registerCombatTools(server); // Combat, Dice, Checks
+    registerQuestTools(server); // Quests, Objectives
+    registerTableTools(server); // Random Tables
+    registerStatusTools(server); // Status Effects
+    registerAbilityTools(server); // Abilities/Powers
+    registerRpgBatchTools(server); // setup_combat_encounter
+    registerRpgMcpResources(server); // game-quests, quest
+    registerMcpPrompts(server); // Reusable prompt templates (game-master session library)
+}
+/**
+ * Build the FULL assembly: every core tool plus every RPG tool, resource and
+ * prompt this engine has always served. Same name, same `{ mechanics?,
+ * vocabulary? }` options as the pre-split `createMcpServer` in
+ * src/mcp-server.ts -- this is that function, now composed from two layers
+ * instead of one, so src/bin/run-dmcp.ts's zero-argument call site keeps
+ * working unchanged and the registered tool/resource/prompt set is
+ * unchanged too (src/__tests__/layerBoundary.test.ts asserts this exactly).
+ */
+export function createMcpServer(options) {
+    const server = createCoreMcpServer(options);
+    registerRpgTools(server);
+    return server;
+}
+// The web UI. An application opts into serving it; importing this never
+// does. It lives on disk at src/http/server.ts, not under src/rpg/ -- it
+// imports RPG tools (quest/ability/combat), which is why it cannot be
+// reachable from the core entry point, but its CLIENT_DIST path resolution
+// is depth-sensitive in both src/ and compiled dist/, so it stays put and
+// only its EXPORT moves up to this layer.
+export { createHttpServer, startHttpServer } from "../http/server.js";
+// The RPG tool modules, exported as library functions -- the same shape
+// core's index.ts uses for the timeline (replay, changesWithin, and so on):
+// a consumer that wants to call combat/quest/table/status/ability/dice logic
+// directly, without going through an MCP tool call, can.
+export * from "./tools/dice.js";
+export * from "./tools/combat.js";
+export * from "./tools/ability.js";
+export * from "./tools/status.js";
+export * from "./tools/tables.js";
+export * from "./tools/quest.js";

package/dist/rpg/register/abilities.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAbilityTools(server: McpServer): void;

package/dist/rpg/register/abilities.js

@@ -0,0 +1,165 @@
+import { z } from "zod";
+import * as abilityTools from "../tools/ability.js";
+import { LIMITS } from "../../utils/validation.js";
+import { ANNOTATIONS } from "../../utils/tool-annotations.js";
+export function registerAbilityTools(server) {
+    server.registerTool("create_ability", {
+        description: "Create an ability template or character-owned ability",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            ownerType: z.enum(["template", "character"]).describe("'template' for reusable, 'character' for owned"),
+            ownerId: z.string().max(100).optional().describe("Character ID if ownerType is 'character'"),
+            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Ability name"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Ability description"),
+            category: z.string().max(100).optional().describe("Category (e.g., 'spell', 'skill', 'power')"),
+            cost: z.record(z.number()).optional().describe("Resource costs (e.g., {mana: 10, stamina: 5})"),
+            cooldown: z.number().optional().describe("Cooldown in rounds"),
+            effects: z.array(z.string().max(LIMITS.DESCRIPTION_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("Effect descriptions"),
+            requirements: z.record(z.number()).optional().describe("Requirements (e.g., {level: 5, strength: 10})"),
+            tags: z.array(z.string().max(LIMITS.NAME_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("Tags for categorization"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const ability = abilityTools.createAbility(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(ability, null, 2) }],
+        };
+    });
+    server.registerTool("get_ability", {
+        description: "Get an ability by ID",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ abilityId }) => {
+        const ability = abilityTools.getAbility(abilityId);
+        if (!ability) {
+            return {
+                content: [{ type: "text", text: "Ability not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(ability, null, 2) }],
+        };
+    });
+    server.registerTool("update_ability", {
+        description: "Update an ability's details",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+            name: z.string().max(LIMITS.NAME_MAX).optional().describe("New name"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("New description"),
+            category: z.string().max(100).nullable().optional().describe("New category"),
+            cost: z.record(z.number()).optional().describe("New cost"),
+            cooldown: z.number().nullable().optional().describe("New cooldown"),
+            effects: z.array(z.string().max(LIMITS.DESCRIPTION_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("New effects"),
+            requirements: z.record(z.number()).optional().describe("New requirements"),
+            tags: z.array(z.string().max(LIMITS.NAME_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("New tags"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ abilityId, ...updates }) => {
+        const ability = abilityTools.updateAbility(abilityId, updates);
+        if (!ability) {
+            return {
+                content: [{ type: "text", text: "Ability not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(ability, null, 2) }],
+        };
+    });
+    server.registerTool("delete_ability", {
+        description: "Delete an ability",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ abilityId }) => {
+        const success = abilityTools.deleteAbility(abilityId);
+        return {
+            content: [{ type: "text", text: success ? "Ability deleted" : "Ability not found" }],
+            isError: !success,
+        };
+    });
+    server.registerTool("list_abilities", {
+        description: "List abilities with optional filters",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            ownerType: z.enum(["template", "character"]).optional().describe("Filter by owner type"),
+            ownerId: z.string().max(100).optional().describe("Filter by owner ID"),
+            category: z.string().max(100).optional().describe("Filter by category"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, ...filter }) => {
+        const abilities = abilityTools.listAbilities(gameId, filter);
+        return {
+            content: [{ type: "text", text: JSON.stringify(abilities, null, 2) }],
+        };
+    });
+    server.registerTool("learn_ability", {
+        description: "Copy a template ability to a character",
+        inputSchema: {
+            templateId: z.string().max(100).describe("The template ability ID"),
+            characterId: z.string().max(100).describe("The character ID to learn the ability"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async ({ templateId, characterId }) => {
+        const ability = abilityTools.learnAbility(templateId, characterId);
+        if (!ability) {
+            return {
+                content: [{ type: "text", text: "Template not found or is not a template" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(ability, null, 2) }],
+        };
+    });
+    server.registerTool("use_ability", {
+        description: "Use an ability (checks cooldown, sets new cooldown)",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+            characterId: z.string().max(100).describe("The character using the ability"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ abilityId, characterId }) => {
+        const result = abilityTools.useAbility(abilityId, characterId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.success,
+        };
+    });
+    server.registerTool("tick_ability_cooldowns", {
+        description: "Reduce all ability cooldowns (call at end of round)",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            amount: z.number().optional().describe("Rounds to tick (default: 1)"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ gameId, amount }) => {
+        const updated = abilityTools.tickCooldowns(gameId, amount);
+        return {
+            content: [{ type: "text", text: JSON.stringify({ updatedCount: updated.length, abilities: updated }, null, 2) }],
+        };
+    });
+    server.registerTool("check_ability_requirements", {
+        description: "Check if a character meets an ability's requirements",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+            characterId: z.string().max(100).describe("The character ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ abilityId, characterId }) => {
+        const result = abilityTools.checkRequirements(abilityId, characterId);
+        if (!result) {
+            return {
+                content: [{ type: "text", text: "Ability or character not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/rpg/register/batch.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRpgBatchTools(server: McpServer): void;

package/dist/rpg/register/batch.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import * as characterTools from "../../tools/character.js";
+import * as narrativeTools from "../../tools/narrative.js";
+import * as combatTools from "../tools/combat.js";
+import { LIMITS } from "../../utils/validation.js";
+import { ANNOTATIONS } from "../../utils/tool-annotations.js";
+// The one multi-entity workflow tool that reaches into combat, split out of
+// src/register/batch.ts (design §8, issue #17): everything else there --
+// batch_create_npcs, scene_transition, get_character_context,
+// get_location_context -- touches only entity/property concepts and stays in
+// core. This one calls combatTools.startCombat, so it is genuinely
+// game-shaped and belongs in the RPG layer above it, not beside it.
+export function registerRpgBatchTools(server) {
+    // ============================================================================
+    // SETUP COMBAT ENCOUNTER - Create NPCs, start combat with all participants
+    // ============================================================================
+    server.registerTool("setup_combat_encounter", {
+        description: "Complete combat setup in one call: creates enemy NPCs and starts combat with all participants (enemies + players at location). Returns the ready-to-play combat state.",
+        inputSchema: {
+            gameId: z.string().describe("The game ID"),
+            locationId: z.string().describe("Location where combat takes place"),
+            enemies: z
+                .array(z.object({
+                name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Enemy name"),
+                attributes: z.record(z.string(), z.number()).optional(),
+                status: z
+                    .object({
+                    health: z.number().optional(),
+                    maxHealth: z.number().optional(),
+                })
+                    .optional(),
+            }))
+                .min(1)
+                .max(10)
+                .describe("Enemies to create and add to combat"),
+            includePlayersAtLocation: z
+                .boolean()
+                .default(true)
+                .describe("Auto-add player characters at this location"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async ({ gameId, locationId, enemies, includePlayersAtLocation = true }) => {
+        // 1. Create enemy NPCs
+        const createdEnemies = [];
+        for (const enemy of enemies) {
+            const character = characterTools.createCharacter({
+                gameId,
+                name: enemy.name,
+                isPlayer: false,
+                attributes: enemy.attributes,
+                status: enemy.status,
+                locationId,
+            });
+            createdEnemies.push(character);
+        }
+        // 2. Get players at location if needed
+        const participantIds = [...createdEnemies.map((e) => e.id)];
+        if (includePlayersAtLocation) {
+            const playersAtLocation = characterTools.listCharacters(gameId, {
+                isPlayer: true,
+                locationId,
+            });
+            participantIds.push(...playersAtLocation.map((p) => p.id));
+        }
+        // 3. Start combat with all participants
+        const combat = combatTools.startCombat({
+            gameId,
+            locationId,
+            participantIds,
+        });
+        // 4. Log the encounter start
+        narrativeTools.logEvent({
+            gameId,
+            eventType: "combat",
+            content: `Combat begins! ${createdEnemies.length} enemies attack.`,
+            metadata: {
+                enemyIds: createdEnemies.map((e) => e.id),
+                locationId,
+            },
+        });
+        const result = {
+            combat,
+            createdEnemies: createdEnemies.map((e) => ({ id: e.id, name: e.name })),
+            participantCount: participantIds.length,
+            summary: `Combat started with ${participantIds.length} participants. ${createdEnemies.length} enemies created.`,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+        };
+    });
+}

package/dist/rpg/register/combat.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerCombatTools(server: McpServer): void;

package/dist/rpg/register/combat.js

@@ -0,0 +1,207 @@
+import { z } from "zod";
+import * as combatTools from "../tools/combat.js";
+import * as diceTools from "../tools/dice.js";
+import { LIMITS } from "../../utils/validation.js";
+import { ANNOTATIONS } from "../../utils/tool-annotations.js";
+export function registerCombatTools(server) {
+    // ============================================================================
+    // DICE & CHECK TOOLS
+    // ============================================================================
+    server.registerTool("roll", {
+        description: "Roll dice using standard notation",
+        inputSchema: {
+            expression: z.string().max(100).describe("Dice expression (e.g., '2d6+3', '1d20', '4d6-2')"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ expression }) => {
+        try {
+            const result = diceTools.roll(expression);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("check", {
+        description: "Perform a skill or ability check",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            characterId: z.string().max(100).describe("The character making the check"),
+            skill: z.string().max(100).optional().describe("Skill to use"),
+            attribute: z.string().max(100).optional().describe("Attribute to use"),
+            difficulty: z.number().describe("Difficulty threshold"),
+            bonusModifier: z.number().optional().describe("Additional modifier"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async (params) => {
+        try {
+            const result = diceTools.check(params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("contest", {
+        description: "Opposed check between two characters",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            attackerId: z.string().max(100).describe("First character ID"),
+            defenderId: z.string().max(100).describe("Second character ID"),
+            attackerSkill: z.string().max(100).optional().describe("Skill for first character"),
+            defenderSkill: z.string().max(100).optional().describe("Skill for second character"),
+            attackerAttribute: z.string().max(100).optional().describe("Attribute for first character"),
+            defenderAttribute: z.string().max(100).optional().describe("Attribute for second character"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async (params) => {
+        try {
+            const result = diceTools.contest(params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: error.message }],
+                isError: true,
+            };
+        }
+    });
+    // ============================================================================
+    // COMBAT TOOLS
+    // ============================================================================
+    server.registerTool("start_combat", {
+        description: "Initialize a combat encounter",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            locationId: z.string().max(100).describe("Location where combat occurs"),
+            participantIds: z.array(z.string().max(100)).max(LIMITS.ARRAY_MAX).describe("Character IDs of all combatants"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const combat = combatTools.startCombat(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(combat, null, 2) }],
+        };
+    });
+    server.registerTool("get_combat", {
+        description: "Get current combat state",
+        inputSchema: {
+            combatId: z.string().max(100).describe("The combat ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ combatId }) => {
+        const combat = combatTools.getCombat(combatId);
+        if (!combat) {
+            return {
+                content: [{ type: "text", text: "Combat not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(combat, null, 2) }],
+        };
+    });
+    server.registerTool("get_active_combat", {
+        description: "Get the active combat for a game",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId }) => {
+        const combat = combatTools.getActiveCombat(gameId);
+        if (!combat) {
+            return {
+                content: [{ type: "text", text: "No active combat" }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(combat, null, 2) }],
+        };
+    });
+    server.registerTool("next_turn", {
+        description: "Advance to the next combatant's turn",
+        inputSchema: {
+            combatId: z.string().max(100).describe("The combat ID"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ combatId }) => {
+        const combat = combatTools.nextTurn(combatId);
+        if (!combat) {
+            return {
+                content: [{ type: "text", text: "Combat not found or ended" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(combat, null, 2) }],
+        };
+    });
+    server.registerTool("add_combat_log", {
+        description: "Add an entry to the combat log",
+        inputSchema: {
+            combatId: z.string().max(100).describe("The combat ID"),
+            entry: z.string().max(LIMITS.DESCRIPTION_MAX).describe("Log entry text"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ combatId, entry }) => {
+        const combat = combatTools.addCombatLog(combatId, entry);
+        if (!combat) {
+            return {
+                content: [{ type: "text", text: "Combat not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(combat, null, 2) }],
+        };
+    });
+    server.registerTool("remove_combatant", {
+        description: "Remove a character from combat (defeated, fled, etc.)",
+        inputSchema: {
+            combatId: z.string().max(100).describe("The combat ID"),
+            characterId: z.string().max(100).describe("The character to remove"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ combatId, characterId }) => {
+        const combat = combatTools.removeParticipant(combatId, characterId);
+        if (!combat) {
+            return {
+                content: [{ type: "text", text: "Combat not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(combat, null, 2) }],
+        };
+    });
+    server.registerTool("end_combat", {
+        description: "End a combat encounter",
+        inputSchema: {
+            combatId: z.string().max(100).describe("The combat ID"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ combatId }) => {
+        const combat = combatTools.endCombat(combatId);
+        if (!combat) {
+            return {
+                content: [{ type: "text", text: "Combat not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(combat, null, 2) }],
+        };
+    });
+}

package/dist/rpg/register/mcp-prompts.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerMcpPrompts(server: McpServer): void;