run-dmcp 0.2.0 → 0.4.0

package/dist/register/abilities.js

@@ -1,165 +0,0 @@
-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/register/combat.d.ts

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

package/dist/register/combat.js

@@ -1,207 +0,0 @@
-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/register/mcp-prompts.d.ts

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