run-dmcp 0.1.0

package/dist/register/mcp-resources.d.ts

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

package/dist/register/mcp-resources.js

@@ -0,0 +1,335 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as gameTools from "../tools/game.js";
+import * as characterTools from "../tools/character.js";
+import * as worldTools from "../tools/world.js";
+import * as questTools from "../tools/quest.js";
+import * as narrativeTools from "../tools/narrative.js";
+import * as rulesTools from "../tools/rules.js";
+export function registerMcpResources(server) {
+    // ============================================================================
+    // STATIC RESOURCES
+    // ============================================================================
+    // List all games
+    server.registerResource("games", "dmcp://games", {
+        description: "List all games",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const games = gameTools.listGames();
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(games, null, 2),
+                },
+            ],
+        };
+    });
+    // ============================================================================
+    // GAME-SCOPED RESOURCES (templated)
+    // ============================================================================
+    // Helper to create list callback for game-scoped resources
+    const createGameListCallback = (suffix, nameFormatter) => {
+        return async () => {
+            const games = gameTools.listGames();
+            return {
+                resources: games.map((g) => ({
+                    uri: `dmcp://game/${g.id}${suffix}`,
+                    name: nameFormatter(g),
+                })),
+            };
+        };
+    };
+    // Game details
+    server.registerResource("game", new ResourceTemplate("dmcp://game/{gameId}", {
+        list: createGameListCallback("", (g) => g.name),
+    }), {
+        description: "Game metadata and preferences",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const gameId = variables.gameId;
+        const game = gameTools.loadGame(gameId);
+        if (!game) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "Game not found" }),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(game, null, 2),
+                },
+            ],
+        };
+    });
+    // Game state (overview)
+    server.registerResource("game-state", new ResourceTemplate("dmcp://game/{gameId}/state", {
+        list: createGameListCallback("/state", (g) => `${g.name} - State`),
+    }), {
+        description: "Current game state snapshot with counts",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const gameId = variables.gameId;
+        const state = gameTools.getGameState(gameId);
+        if (!state) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "Game not found" }),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(state, null, 2),
+                },
+            ],
+        };
+    });
+    // Game characters
+    server.registerResource("game-characters", new ResourceTemplate("dmcp://game/{gameId}/characters", {
+        list: createGameListCallback("/characters", (g) => `${g.name} - Characters`),
+    }), {
+        description: "All characters in the game",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const gameId = variables.gameId;
+        const characters = characterTools.listCharacters(gameId);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(characters, null, 2),
+                },
+            ],
+        };
+    });
+    // Game locations
+    server.registerResource("game-locations", new ResourceTemplate("dmcp://game/{gameId}/locations", {
+        list: createGameListCallback("/locations", (g) => `${g.name} - Locations`),
+    }), {
+        description: "All locations in the game",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const gameId = variables.gameId;
+        const locations = worldTools.listLocations(gameId);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(locations, null, 2),
+                },
+            ],
+        };
+    });
+    // Game map (JSON data)
+    server.registerResource("game-map", new ResourceTemplate("dmcp://game/{gameId}/map", {
+        list: createGameListCallback("/map", (g) => `${g.name} - Map`),
+    }), {
+        description: "World map data with location nodes and connections",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const gameId = variables.gameId;
+        const game = gameTools.loadGame(gameId);
+        const mapResult = worldTools.renderMap(gameId, {
+            playerLocationId: game?.currentLocationId || undefined,
+        });
+        if (!mapResult) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "No locations in this game" }),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(mapResult, null, 2),
+                },
+            ],
+        };
+    });
+    // Game quests
+    server.registerResource("game-quests", new ResourceTemplate("dmcp://game/{gameId}/quests", {
+        list: createGameListCallback("/quests", (g) => `${g.name} - Quests`),
+    }), {
+        description: "All quests in the game",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const gameId = variables.gameId;
+        const quests = questTools.listQuests(gameId);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(quests, null, 2),
+                },
+            ],
+        };
+    });
+    // Game history (recent narrative events)
+    server.registerResource("game-history", new ResourceTemplate("dmcp://game/{gameId}/history", {
+        list: createGameListCallback("/history", (g) => `${g.name} - History`),
+    }), {
+        description: "Recent narrative events (last 50)",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const gameId = variables.gameId;
+        const history = narrativeTools.getHistory(gameId, { limit: 50 });
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(history, null, 2),
+                },
+            ],
+        };
+    });
+    // Game rules
+    server.registerResource("game-rules", new ResourceTemplate("dmcp://game/{gameId}/rules", {
+        list: createGameListCallback("/rules", (g) => `${g.name} - Rules`),
+    }), {
+        description: "Rule system for the game",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const gameId = variables.gameId;
+        const rules = rulesTools.getRules(gameId);
+        if (!rules) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "No rules configured for this game" }),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(rules, null, 2),
+                },
+            ],
+        };
+    });
+    // ============================================================================
+    // ENTITY RESOURCES (direct access by ID)
+    // ============================================================================
+    // Character by ID (rendered sheet)
+    server.registerResource("character", new ResourceTemplate("dmcp://character/{characterId}", {
+        list: undefined, // No enumeration - access by ID only
+    }), {
+        description: "Character sheet data",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const characterId = variables.characterId;
+        const sheet = characterTools.renderCharacterSheet(characterId);
+        if (!sheet) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "Character not found" }),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(sheet, null, 2),
+                },
+            ],
+        };
+    });
+    // Location by ID
+    server.registerResource("location", new ResourceTemplate("dmcp://location/{locationId}", {
+        list: undefined, // No enumeration - access by ID only
+    }), {
+        description: "Location details with exits",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const locationId = variables.locationId;
+        const location = worldTools.getLocation(locationId);
+        if (!location) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "Location not found" }),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(location, null, 2),
+                },
+            ],
+        };
+    });
+    // Quest by ID
+    server.registerResource("quest", new ResourceTemplate("dmcp://quest/{questId}", {
+        list: undefined, // No enumeration - access by ID only
+    }), {
+        description: "Quest details with objectives",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const questId = variables.questId;
+        const quest = questTools.getQuest(questId);
+        if (!quest) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ error: "Quest not found" }),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(quest, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/register/narrative.d.ts

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

package/dist/register/narrative.js

@@ -0,0 +1,242 @@
+import { z } from "zod";
+import * as narrativeTools from "../tools/narrative.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+export function registerNarrativeTools(server) {
+    server.registerTool("log_event", {
+        description: "Log a narrative event. CRITICAL: Call this after EVERY significant narrative beat - dialogue exchanges, player actions, combat rounds, discoveries, travel, decisions. This is the primary way to preserve game history. Event types: 'dialogue', 'action', 'discovery', 'combat', 'travel', 'decision', 'scene_transition'.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            eventType: z.string().max(100).describe("Type of event (e.g., 'dialogue', 'action', 'discovery', 'combat')"),
+            content: z.string().max(LIMITS.CONTENT_MAX).describe("Event content/description"),
+            metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const event = narrativeTools.logEvent(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(event, null, 2) }],
+        };
+    });
+    server.registerTool("get_history", {
+        description: "Get narrative history",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            limit: z.number().optional().describe("Maximum events to return"),
+            eventType: z.string().max(100).optional().describe("Filter by event type"),
+            since: z.string().max(100).optional().describe("Only events after this timestamp"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, limit, eventType, since }) => {
+        const events = narrativeTools.getHistory(gameId, { limit, eventType, since });
+        return {
+            content: [{ type: "text", text: JSON.stringify(events, null, 2) }],
+        };
+    });
+    server.registerTool("get_summary", {
+        description: "Get a summary of the narrative so far",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId }) => {
+        const summary = narrativeTools.getSummary(gameId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+        };
+    });
+    server.registerTool("get_export_styles", {
+        description: "Get available narrative styles for story export",
+        inputSchema: {},
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async () => {
+        const styles = [
+            { id: "literary-fiction", name: "Literary Fiction", description: "Sophisticated prose with deep character introspection" },
+            { id: "pulp-adventure", name: "Pulp Adventure", description: "Fast-paced action with bold heroes and cliffhangers" },
+            { id: "epic-fantasy", name: "Epic Fantasy", description: "Grand, sweeping narrative with mythic undertones" },
+            { id: "noir", name: "Noir", description: "Hardboiled prose with moral ambiguity" },
+            { id: "horror", name: "Horror", description: "Atmospheric dread and tension" },
+            { id: "comedic", name: "Comedic", description: "Witty and humorous with clever dialogue" },
+            { id: "young-adult", name: "Young Adult", description: "Accessible and engaging with relatable characters" },
+            { id: "screenplay", name: "Screenplay", description: "Formatted as a film script" },
+            { id: "journal", name: "Journal/Diary", description: "Personal entries from protagonist's perspective" },
+            { id: "chronicle", name: "Chronicle", description: "Historical documentation with a sense of legacy" },
+        ];
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        styles,
+                        instruction: "Present these style options to the player and let them choose how their story should be written.",
+                    }, null, 2),
+                }],
+        };
+    });
+    server.registerTool("export_story", {
+        description: "Export the game history as structured data for reconstruction into a narrative book. Use get_chapter_for_export to fetch individual chapters for writing.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            style: z.string().max(100).describe("Narrative style (e.g., 'literary-fiction', 'pulp-adventure', 'epic-fantasy', 'noir', or custom)"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, style }) => {
+        const exportData = narrativeTools.exportStoryData(gameId, style);
+        if (!exportData) {
+            return {
+                content: [{ type: "text", text: "Game not found" }],
+                isError: true,
+            };
+        }
+        const chapterSummaries = exportData.chapters.map((ch, idx) => ({
+            chapterNumber: idx + 1,
+            title: ch.title,
+            eventCount: ch.events.length,
+            eventTypes: [...new Set(ch.events.map(e => e.eventType))],
+            timeSpan: ch.events.length > 0 ? {
+                start: ch.events[0].timestamp,
+                end: ch.events[ch.events.length - 1].timestamp,
+            } : null,
+        }));
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        game: exportData.game,
+                        characters: exportData.characters,
+                        locations: exportData.locations,
+                        quests: exportData.quests,
+                        chapterSummaries,
+                        totalChapters: exportData.chapters.length,
+                        totalEvents: exportData.totalEvents,
+                        exportStyle: exportData.exportStyle,
+                        instruction: exportData.instruction,
+                        meta: {
+                            exportedAt: new Date().toISOString(),
+                            workflow: [
+                                "1. Review the game, characters, locations, and quests for context",
+                                "2. For each chapter, use get_chapter_for_export to fetch the full event data",
+                                "3. Spawn a subagent for each chapter with the style instruction and chapter data",
+                                "4. Each subagent writes its chapter as narrative prose",
+                                "5. Combine chapters into the final book with front matter",
+                            ],
+                        },
+                    }, null, 2),
+                }],
+        };
+    });
+    server.registerTool("get_chapter_for_export", {
+        description: "Get a single chapter's full event data for writing. Use this to fetch chapters one at a time for subagent processing.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            chapterNumber: z.number().describe("Chapter number (1-indexed)"),
+            style: z.string().max(100).describe("Narrative style for the instruction"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, chapterNumber, style }) => {
+        const exportData = narrativeTools.exportStoryData(gameId, style);
+        if (!exportData) {
+            return {
+                content: [{ type: "text", text: "Game not found" }],
+                isError: true,
+            };
+        }
+        const chapterIndex = chapterNumber - 1;
+        if (chapterIndex < 0 || chapterIndex >= exportData.chapters.length) {
+            return {
+                content: [{ type: "text", text: `Chapter ${chapterNumber} not found. Total chapters: ${exportData.chapters.length}` }],
+                isError: true,
+            };
+        }
+        const chapter = exportData.chapters[chapterIndex];
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        chapterNumber,
+                        totalChapters: exportData.chapters.length,
+                        title: chapter.title,
+                        events: chapter.events,
+                        context: {
+                            gameName: exportData.game.name,
+                            setting: exportData.game.setting,
+                            style: exportData.exportStyle,
+                        },
+                        instruction: exportData.instruction,
+                        subagentPrompt: `You are writing Chapter ${chapterNumber} of "${exportData.game.name}". ${exportData.instruction} Transform the following events into engaging narrative prose. Maintain consistency with the ${exportData.game.setting} setting.`,
+                    }, null, 2),
+                }],
+        };
+    });
+    // PLAYER INTERACTION TOOLS
+    server.registerTool("present_choices", {
+        description: "Present choices to the player with multi-select and free-form input support. Returns structured choice data for the DM agent to display.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            prompt: z.string().max(LIMITS.DESCRIPTION_MAX).describe("The question or situation description to present"),
+            choices: z.array(z.object({
+                id: z.string().max(100).describe("Unique identifier for this choice"),
+                label: z.string().max(LIMITS.NAME_MAX).describe("Short label for the choice (1-5 words)"),
+                description: z.string().max(LIMITS.DESCRIPTION_MAX).describe("Fuller description of what this choice means"),
+                consequences: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Hint at consequences (optional, for DM reference)"),
+            })).min(1).max(6).describe("Available choices (1-6 options)"),
+            allowMultiple: z.boolean().optional().describe("Allow selecting multiple choices (default: false)"),
+            allowFreeform: z.boolean().optional().describe("Allow player to type a custom response (default: true)"),
+            freeformPlaceholder: z.string().max(LIMITS.NAME_MAX).optional().describe("Placeholder text for free-form input (default: 'Or describe what you want to do...')"),
+            context: z.object({
+                locationId: z.string().max(100).optional(),
+                characterIds: z.array(z.string().max(100)).max(LIMITS.ARRAY_MAX).optional(),
+                urgency: z.enum(["low", "medium", "high", "critical"]).optional(),
+            }).optional().describe("Context for the choice"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async ({ gameId, prompt, choices, allowMultiple, allowFreeform, freeformPlaceholder, context }) => {
+        narrativeTools.logEvent({
+            gameId,
+            eventType: "choice_presented",
+            content: prompt,
+            metadata: { choices, allowMultiple, allowFreeform, context },
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        type: "player_choice",
+                        prompt,
+                        choices,
+                        allowMultiple: allowMultiple ?? false,
+                        allowFreeform: allowFreeform ?? true,
+                        freeformPlaceholder: freeformPlaceholder ?? "Or describe what you want to do...",
+                        context,
+                        instruction: "Present these choices to the player. Use AskUserQuestion - players can always select 'Other' to provide free-form input.",
+                    }, null, 2),
+                }],
+        };
+    });
+    server.registerTool("record_choice", {
+        description: "Record the player's choice after they've selected",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            choiceIds: z.array(z.string().max(100)).max(LIMITS.ARRAY_MAX).describe("The ID(s) of the choice(s) the player selected"),
+            customResponse: z.string().max(LIMITS.CONTENT_MAX).optional().describe("If player chose 'Other', their custom response"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async ({ gameId, choiceIds, customResponse }) => {
+        const event = narrativeTools.logEvent({
+            gameId,
+            eventType: "choice_made",
+            content: customResponse || `Player chose: ${choiceIds.join(", ")}`,
+            metadata: { choiceIds, customResponse },
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        recorded: true,
+                        choiceIds,
+                        customResponse,
+                        event,
+                    }, null, 2),
+                }],
+        };
+    });
+}

package/dist/register/notes.d.ts

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