run-dmcp 0.2.0 → 0.4.0

package/dist/register/quests.d.ts

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

package/dist/register/quests.js

@@ -1,118 +0,0 @@
-import { z } from "zod";
-import * as questTools from "../tools/quest.js";
-import { LIMITS } from "../utils/validation.js";
-import { ANNOTATIONS } from "../utils/tool-annotations.js";
-export function registerQuestTools(server) {
-    server.registerTool("create_quest", {
-        description: "Create a new quest. Call this whenever the player receives a mission, task, or goal - whether from an NPC, discovered through exploration, or self-initiated. Include clear objectives that can be tracked.",
-        inputSchema: {
-            gameId: z.string().max(100).describe("The game ID"),
-            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Quest name"),
-            description: z.string().max(LIMITS.DESCRIPTION_MAX).describe("Quest description"),
-            objectives: z.array(z.object({
-                description: z.string().max(LIMITS.DESCRIPTION_MAX),
-                completed: z.boolean().optional(),
-                optional: z.boolean().optional(),
-            })).max(LIMITS.ARRAY_MAX).describe("Quest objectives"),
-            rewards: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Quest rewards"),
-        },
-        annotations: ANNOTATIONS.CREATE,
-    }, async (params) => {
-        const quest = questTools.createQuest({
-            ...params,
-            objectives: params.objectives.map((obj) => ({
-                description: obj.description,
-                completed: obj.completed ?? false,
-                optional: obj.optional,
-            })),
-        });
-        return {
-            content: [{ type: "text", text: JSON.stringify(quest, null, 2) }],
-        };
-    });
-    server.registerTool("get_quest", {
-        description: "Get quest details",
-        inputSchema: {
-            questId: z.string().max(100).describe("The quest ID"),
-        },
-        annotations: ANNOTATIONS.READ_ONLY,
-    }, async ({ questId }) => {
-        const quest = questTools.getQuest(questId);
-        if (!quest) {
-            return {
-                content: [{ type: "text", text: "Quest not found" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(quest, null, 2) }],
-        };
-    });
-    server.registerTool("update_quest", {
-        description: "Update a quest",
-        inputSchema: {
-            questId: z.string().max(100).describe("The quest ID"),
-            name: z.string().max(LIMITS.NAME_MAX).optional().describe("New name"),
-            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("New description"),
-            status: z.enum(["active", "completed", "failed", "abandoned"]).optional().describe("New status"),
-            rewards: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Updated rewards"),
-        },
-        annotations: ANNOTATIONS.UPDATE,
-    }, async ({ questId, ...updates }) => {
-        const quest = questTools.updateQuest(questId, updates);
-        if (!quest) {
-            return {
-                content: [{ type: "text", text: "Quest not found" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(quest, null, 2) }],
-        };
-    });
-    // ============================================================================
-    // MODIFY OBJECTIVES - CONSOLIDATED (replaces add_objective + complete_objective)
-    // ============================================================================
-    server.registerTool("modify_objectives", {
-        description: "Add new objectives and/or mark existing objectives as completed in a single call. Call this immediately when: (1) player completes a quest step, (2) new sub-tasks are discovered, (3) objectives change based on player choices.",
-        inputSchema: {
-            questId: z.string().max(100).describe("The quest ID"),
-            add: z.array(z.object({
-                description: z.string().max(LIMITS.DESCRIPTION_MAX).describe("Objective description"),
-                optional: z.boolean().optional().describe("Is this objective optional?"),
-            })).max(LIMITS.ARRAY_MAX).optional().describe("New objectives to add"),
-            complete: z.array(z.string().max(100)).max(LIMITS.ARRAY_MAX).optional().describe("Objective IDs to mark as completed"),
-        },
-        annotations: ANNOTATIONS.UPDATE,
-    }, async ({ questId, add, complete }) => {
-        if (!add?.length && !complete?.length) {
-            return {
-                content: [{ type: "text", text: "No objectives to add or complete" }],
-                isError: true,
-            };
-        }
-        const result = questTools.modifyObjectives(questId, { add, complete });
-        if (!result) {
-            return {
-                content: [{ type: "text", text: "Quest not found" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
-    });
-    server.registerTool("list_quests", {
-        description: "List quests in a game",
-        inputSchema: {
-            gameId: z.string().max(100).describe("The game ID"),
-            status: z.enum(["active", "completed", "failed", "abandoned"]).optional().describe("Filter by status"),
-        },
-        annotations: ANNOTATIONS.READ_ONLY,
-    }, async ({ gameId, status }) => {
-        const quests = questTools.listQuests(gameId, status ? { status } : undefined);
-        return {
-            content: [{ type: "text", text: JSON.stringify(quests, null, 2) }],
-        };
-    });
-}

package/dist/register/status.d.ts

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

package/dist/register/status.js

@@ -1,130 +0,0 @@
-import { z } from "zod";
-import * as statusTools from "../tools/status.js";
-import { LIMITS } from "../utils/validation.js";
-import { ANNOTATIONS } from "../utils/tool-annotations.js";
-export function registerStatusTools(server) {
-    server.registerTool("apply_status_effect", {
-        description: "Apply a status effect to a character (handles stacking automatically)",
-        inputSchema: {
-            gameId: z.string().max(100).describe("The game ID"),
-            targetId: z.string().max(100).describe("Character ID to apply effect to"),
-            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Effect name (e.g., 'Poisoned', 'Blessed', 'Stunned')"),
-            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Description of the effect"),
-            effectType: z.enum(["buff", "debuff", "neutral"]).optional().describe("Effect category"),
-            duration: z.number().optional().describe("Duration in rounds (null for permanent)"),
-            stacks: z.number().optional().describe("Initial stack count (default: 1)"),
-            maxStacks: z.number().optional().describe("Maximum stacks allowed"),
-            effects: z.record(z.number()).optional().describe("Stat modifiers (e.g., {strength: -2, speed: +1})"),
-            sourceId: z.string().max(100).optional().describe("ID of the source (character, ability, item)"),
-            sourceType: z.string().max(100).optional().describe("Type of the source"),
-        },
-        annotations: ANNOTATIONS.CREATE,
-    }, async (params) => {
-        const effect = statusTools.applyStatusEffect(params);
-        return {
-            content: [{ type: "text", text: JSON.stringify(effect, null, 2) }],
-        };
-    });
-    server.registerTool("get_status_effect", {
-        description: "Get a status effect by ID",
-        inputSchema: {
-            effectId: z.string().max(100).describe("The effect ID"),
-        },
-        annotations: ANNOTATIONS.READ_ONLY,
-    }, async ({ effectId }) => {
-        const effect = statusTools.getStatusEffect(effectId);
-        if (!effect) {
-            return {
-                content: [{ type: "text", text: "Effect not found" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(effect, null, 2) }],
-        };
-    });
-    server.registerTool("remove_status_effect", {
-        description: "Remove a specific status effect",
-        inputSchema: {
-            effectId: z.string().max(100).describe("The effect ID"),
-        },
-        annotations: ANNOTATIONS.DESTRUCTIVE,
-    }, async ({ effectId }) => {
-        const success = statusTools.removeStatusEffect(effectId);
-        return {
-            content: [{ type: "text", text: success ? "Effect removed" : "Effect not found" }],
-            isError: !success,
-        };
-    });
-    server.registerTool("list_status_effects", {
-        description: "List all status effects on a character",
-        inputSchema: {
-            targetId: z.string().max(100).describe("Character ID"),
-            effectType: z.enum(["buff", "debuff", "neutral"]).optional().describe("Filter by effect type"),
-        },
-        annotations: ANNOTATIONS.READ_ONLY,
-    }, async ({ targetId, effectType }) => {
-        const effects = statusTools.listStatusEffects(targetId, effectType ? { effectType } : undefined);
-        return {
-            content: [{ type: "text", text: JSON.stringify(effects, null, 2) }],
-        };
-    });
-    server.registerTool("tick_status_durations", {
-        description: "Reduce duration of all status effects (call at end of round). Returns expired and remaining effects.",
-        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 result = statusTools.tickDurations(gameId, amount);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
-    });
-    server.registerTool("modify_effect_stacks", {
-        description: "Add or remove stacks from a status effect",
-        inputSchema: {
-            effectId: z.string().max(100).describe("The effect ID"),
-            delta: z.number().describe("Change in stacks (positive or negative)"),
-        },
-        annotations: ANNOTATIONS.UPDATE,
-    }, async ({ effectId, delta }) => {
-        const effect = statusTools.modifyStacks(effectId, delta);
-        if (!effect) {
-            return {
-                content: [{ type: "text", text: "Effect not found" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(effect, null, 2) }],
-        };
-    });
-    server.registerTool("clear_status_effects", {
-        description: "Remove all status effects from a character (or filter by type/name)",
-        inputSchema: {
-            targetId: z.string().max(100).describe("Character ID"),
-            effectType: z.enum(["buff", "debuff", "neutral"]).optional().describe("Only clear this type"),
-            name: z.string().max(LIMITS.NAME_MAX).optional().describe("Only clear effects with this name"),
-        },
-        annotations: ANNOTATIONS.DESTRUCTIVE,
-    }, async ({ targetId, effectType, name }) => {
-        const count = statusTools.clearEffects(targetId, { effectType, name });
-        return {
-            content: [{ type: "text", text: `Cleared ${count} effect(s)` }],
-        };
-    });
-    server.registerTool("get_effective_modifiers", {
-        description: "Get the total stat modifiers from all status effects on a character",
-        inputSchema: {
-            targetId: z.string().max(100).describe("Character ID"),
-        },
-        annotations: ANNOTATIONS.READ_ONLY,
-    }, async ({ targetId }) => {
-        const modifiers = statusTools.getEffectiveModifiers(targetId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(modifiers, null, 2) }],
-        };
-    });
-}

package/dist/register/tables.d.ts

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

package/dist/register/tables.js

@@ -1,146 +0,0 @@
-import { z } from "zod";
-import * as tableTools from "../tools/tables.js";
-import { LIMITS } from "../utils/validation.js";
-import { ANNOTATIONS } from "../utils/tool-annotations.js";
-const tableEntrySchema = z.object({
-    minRoll: z.number().describe("Minimum roll to get this result"),
-    maxRoll: z.number().describe("Maximum roll to get this result"),
-    result: z.string().max(LIMITS.DESCRIPTION_MAX).describe("The result text"),
-    weight: z.number().optional().describe("Weight for weighted random selection"),
-    subtable: z.string().max(100).optional().describe("ID of subtable to roll on"),
-    metadata: z.record(z.string(), z.unknown()).optional().describe("Additional data"),
-});
-export function registerTableTools(server) {
-    server.registerTool("create_random_table", {
-        description: "Create a new random table for encounters, loot, weather, etc.",
-        inputSchema: {
-            gameId: z.string().max(100).describe("The game ID"),
-            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Table name"),
-            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Table description"),
-            category: z.string().max(100).optional().describe("Category (e.g., 'encounter', 'loot', 'weather', 'name')"),
-            entries: z.array(tableEntrySchema).max(LIMITS.ARRAY_MAX).optional().describe("Table entries"),
-            rollExpression: z.string().max(100).optional().describe("Dice expression (default: '1d100')"),
-        },
-        annotations: ANNOTATIONS.CREATE,
-    }, async (params) => {
-        const table = tableTools.createTable(params);
-        return {
-            content: [{ type: "text", text: JSON.stringify(table, null, 2) }],
-        };
-    });
-    server.registerTool("get_random_table", {
-        description: "Get a random table by ID",
-        inputSchema: {
-            tableId: z.string().max(100).describe("The table ID"),
-        },
-        annotations: ANNOTATIONS.READ_ONLY,
-    }, async ({ tableId }) => {
-        const table = tableTools.getTable(tableId);
-        if (!table) {
-            return {
-                content: [{ type: "text", text: "Table not found" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(table, null, 2) }],
-        };
-    });
-    server.registerTool("update_random_table", {
-        description: "Update a random table",
-        inputSchema: {
-            tableId: z.string().max(100).describe("The table 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"),
-            entries: z.array(tableEntrySchema).max(LIMITS.ARRAY_MAX).optional().describe("Replace all entries"),
-            rollExpression: z.string().max(100).optional().describe("New dice expression"),
-        },
-        annotations: ANNOTATIONS.UPDATE,
-    }, async ({ tableId, ...updates }) => {
-        const table = tableTools.updateTable(tableId, updates);
-        if (!table) {
-            return {
-                content: [{ type: "text", text: "Table not found" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(table, null, 2) }],
-        };
-    });
-    server.registerTool("delete_random_table", {
-        description: "Delete a random table",
-        inputSchema: {
-            tableId: z.string().max(100).describe("The table ID"),
-        },
-        annotations: ANNOTATIONS.DESTRUCTIVE,
-    }, async ({ tableId }) => {
-        const success = tableTools.deleteTable(tableId);
-        return {
-            content: [{ type: "text", text: success ? "Table deleted" : "Table not found" }],
-            isError: !success,
-        };
-    });
-    server.registerTool("list_random_tables", {
-        description: "List random tables in a game",
-        inputSchema: {
-            gameId: z.string().max(100).describe("The game ID"),
-            category: z.string().max(100).optional().describe("Filter by category"),
-        },
-        annotations: ANNOTATIONS.READ_ONLY,
-    }, async ({ gameId, category }) => {
-        const tables = tableTools.listTables(gameId, category);
-        return {
-            content: [{ type: "text", text: JSON.stringify(tables, null, 2) }],
-        };
-    });
-    server.registerTool("roll_on_table", {
-        description: "Roll on a random table and get a result",
-        inputSchema: {
-            tableId: z.string().max(100).describe("The table ID"),
-            modifier: z.number().optional().describe("Modifier to add to the roll"),
-        },
-        annotations: ANNOTATIONS.READ_ONLY,
-    }, async ({ tableId, modifier }) => {
-        const result = tableTools.rollTable(tableId, modifier);
-        if (!result) {
-            return {
-                content: [{ type: "text", text: "Table not found or has no entries" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
-    });
-    // ============================================================================
-    // MODIFY TABLE ENTRIES - CONSOLIDATED (replaces add_table_entry + remove_table_entry)
-    // ============================================================================
-    server.registerTool("modify_table_entries", {
-        description: "Add and/or remove table entries in a single call. More efficient than separate add/remove calls.",
-        inputSchema: {
-            tableId: z.string().max(100).describe("The table ID"),
-            add: z.array(tableEntrySchema).max(LIMITS.ARRAY_MAX).optional().describe("Entries to add"),
-            remove: z.array(z.number()).max(LIMITS.ARRAY_MAX).optional().describe("Indices of entries to remove (0-based)"),
-        },
-        annotations: ANNOTATIONS.UPDATE,
-    }, async ({ tableId, add, remove }) => {
-        if (!add?.length && !remove?.length) {
-            return {
-                content: [{ type: "text", text: "No entries to add or remove" }],
-                isError: true,
-            };
-        }
-        const result = tableTools.modifyTableEntries(tableId, { add, remove });
-        if (!result) {
-            return {
-                content: [{ type: "text", text: "Table not found" }],
-                isError: true,
-            };
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
-    });
-}

package/dist/tools/ability.d.ts

@@ -1,48 +0,0 @@
-import type { Ability } from "../types/index.js";
-export declare function createAbility(params: {
-    gameId: string;
-    ownerType: "template" | "character";
-    ownerId?: string;
-    name: string;
-    description?: string;
-    category?: string;
-    cost?: Record<string, number>;
-    cooldown?: number;
-    effects?: string[];
-    requirements?: Record<string, number>;
-    tags?: string[];
-}): Ability;
-export declare function getAbility(id: string): Ability | null;
-export declare function updateAbility(id: string, updates: {
-    name?: string;
-    description?: string;
-    category?: string | null;
-    cost?: Record<string, number>;
-    cooldown?: number | null;
-    effects?: string[];
-    requirements?: Record<string, number>;
-    tags?: string[];
-}): Ability | null;
-export declare function deleteAbility(id: string): boolean;
-export declare function listAbilities(gameId: string, filter?: {
-    ownerType?: "template" | "character";
-    ownerId?: string;
-    category?: string;
-}): Ability[];
-export declare function learnAbility(templateId: string, characterId: string): Ability | null;
-export interface UseAbilityResult {
-    success: boolean;
-    ability: Ability;
-    reason?: string;
-    costsPaid?: Record<string, number>;
-}
-export declare function useAbility(abilityId: string, _characterId: string): UseAbilityResult;
-export declare function tickCooldowns(gameId: string, amount?: number): Ability[];
-export interface RequirementCheck {
-    meetsRequirements: boolean;
-    missing: Record<string, {
-        required: number;
-        actual: number;
-    }>;
-}
-export declare function checkRequirements(abilityId: string, characterId: string): RequirementCheck | null;