run-dmcp 0.1.0

package/dist/register/secrets.js

@@ -0,0 +1,192 @@
+import { z } from "zod";
+import * as secretTools from "../tools/secrets.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+export function registerSecretTools(server) {
+    // ============================================================================
+    // CREATE SECRET
+    // ============================================================================
+    server.registerTool("create_secret", {
+        description: "Create a secret that can be revealed to specific characters. Call this whenever you introduce plot-relevant hidden information - NPC backstories, hidden motives, location history, quest twists. Even if revealed immediately, secrets should be tracked.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Secret name (for DM reference)"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).describe("The actual secret information"),
+            category: z.string().max(100).optional().describe("Category (e.g., 'plot', 'character', 'location', 'item')"),
+            relatedEntityId: z.string().max(100).optional().describe("ID of related entity"),
+            relatedEntityType: z.string().max(100).optional().describe("Type of related entity"),
+            clues: z.array(z.string().max(LIMITS.DESCRIPTION_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("Clues that hint at this secret"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const secret = secretTools.createSecret(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(secret, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // GET SECRET - read-only
+    // ============================================================================
+    server.registerTool("get_secret", {
+        description: "Get a secret by ID (DM view - shows all info)",
+        inputSchema: {
+            secretId: z.string().max(100).describe("The secret ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ secretId }) => {
+        const secret = secretTools.getSecret(secretId);
+        if (!secret) {
+            return {
+                content: [{ type: "text", text: "Secret not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(secret, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // UPDATE SECRET
+    // ============================================================================
+    server.registerTool("update_secret", {
+        description: "Update a secret's details",
+        inputSchema: {
+            secretId: z.string().max(100).describe("The secret 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"),
+            relatedEntityId: z.string().max(100).nullable().optional().describe("New related entity ID"),
+            relatedEntityType: z.string().max(100).nullable().optional().describe("New related entity type"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ secretId, ...updates }) => {
+        const secret = secretTools.updateSecret(secretId, updates);
+        if (!secret) {
+            return {
+                content: [{ type: "text", text: "Secret not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(secret, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // DELETE SECRET - destructive
+    // ============================================================================
+    server.registerTool("delete_secret", {
+        description: "Delete a secret permanently. This is IRREVERSIBLE.",
+        inputSchema: {
+            secretId: z.string().max(100).describe("The secret ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ secretId }) => {
+        const success = secretTools.deleteSecret(secretId);
+        return {
+            content: [{ type: "text", text: success ? "Secret deleted" : "Secret not found" }],
+            isError: !success,
+        };
+    });
+    // ============================================================================
+    // LIST SECRETS - read-only
+    // ============================================================================
+    server.registerTool("list_secrets", {
+        description: "List secrets with optional filters",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            category: z.string().max(100).optional().describe("Filter by category"),
+            relatedEntityId: z.string().max(100).optional().describe("Filter by related entity"),
+            isPublic: z.boolean().optional().describe("Filter by public status"),
+            knownBy: z.string().max(100).optional().describe("Only secrets known by this character ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, ...filter }) => {
+        const secrets = secretTools.listSecrets(gameId, filter);
+        return {
+            content: [{ type: "text", text: JSON.stringify(secrets, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // MODIFY SECRET VISIBILITY - CONSOLIDATED (replaces reveal_secret + make_secret_public)
+    // ============================================================================
+    server.registerTool("modify_secret_visibility", {
+        description: "Modify secret visibility. Reveal to specific characters and/or make public in a single call. Call this immediately when a character learns something - through dialogue, investigation, or discovery. Track what each character knows.",
+        inputSchema: {
+            secretId: z.string().max(100).describe("The secret ID"),
+            revealTo: z.array(z.string().max(100)).max(LIMITS.ARRAY_MAX).optional().describe("Character IDs to reveal to"),
+            makePublic: z.boolean().optional().describe("Set to true to make the secret public (revealed to everyone)"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ secretId, revealTo, makePublic }) => {
+        if (!revealTo?.length && !makePublic) {
+            return {
+                content: [{ type: "text", text: "No visibility changes specified (provide revealTo or makePublic)" }],
+                isError: true,
+            };
+        }
+        const result = secretTools.modifySecretVisibility(secretId, { revealTo, makePublic });
+        if (!result) {
+            return {
+                content: [{ type: "text", text: "Secret not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // ADD CLUE
+    // ============================================================================
+    server.registerTool("add_clue", {
+        description: "Add a clue to a secret",
+        inputSchema: {
+            secretId: z.string().max(100).describe("The secret ID"),
+            clue: z.string().max(LIMITS.DESCRIPTION_MAX).describe("The clue text"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ secretId, clue }) => {
+        const secret = secretTools.addClue(secretId, clue);
+        if (!secret) {
+            return {
+                content: [{ type: "text", text: "Secret not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(secret, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // GET CHARACTER KNOWLEDGE - read-only
+    // ============================================================================
+    server.registerTool("get_character_knowledge", {
+        description: "Get all secrets and clues known by a character",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            characterId: z.string().max(100).describe("The character ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, characterId }) => {
+        const knowledge = secretTools.getCharacterKnowledge(gameId, characterId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(knowledge, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // CHECK KNOWS SECRET - read-only
+    // ============================================================================
+    server.registerTool("check_knows_secret", {
+        description: "Check if a character knows a specific secret",
+        inputSchema: {
+            secretId: z.string().max(100).describe("The secret ID"),
+            characterId: z.string().max(100).describe("The character ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ secretId, characterId }) => {
+        const knows = secretTools.checkKnowsSecret(secretId, characterId);
+        return {
+            content: [{ type: "text", text: JSON.stringify({ knows }, null, 2) }],
+        };
+    });
+}

package/dist/register/status.d.ts

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

package/dist/register/status.js

@@ -0,0 +1,130 @@
+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

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

package/dist/register/tables.js

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

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

package/dist/register/tags.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import * as tagTools from "../tools/tags.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+import { tagModifyOutputSchema } from "../utils/output-schemas.js";
+export function registerTagTools(server) {
+    // ============================================================================
+    // CONSOLIDATED: MODIFY TAGS (add and/or remove in a single call)
+    // ============================================================================
+    server.registerTool("modify_tags", {
+        description: "Add and/or remove tags from an entity in a single call. More efficient than separate add/remove calls.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            entityId: z.string().max(100).describe("The entity ID to modify tags on"),
+            entityType: z.string().max(100).describe("Type of entity (e.g., 'character', 'location', 'item', 'quest')"),
+            add: z.array(z.object({
+                tag: z.string().min(1).max(LIMITS.NAME_MAX),
+                color: z.string().max(50).optional(),
+                notes: z.string().max(LIMITS.DESCRIPTION_MAX).optional(),
+            })).max(LIMITS.ARRAY_MAX).optional().describe("Tags to add with optional color/notes"),
+            remove: z.array(z.string().max(LIMITS.NAME_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("Tags to remove"),
+        },
+        outputSchema: tagModifyOutputSchema,
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ gameId, entityId, entityType, add, remove }) => {
+        if (!add?.length && !remove?.length) {
+            return {
+                content: [{ type: "text", text: "No tags to add or remove" }],
+                isError: true,
+            };
+        }
+        const result = tagTools.modifyTags({ gameId, entityId, entityType, add, remove });
+        const output = {
+            entityId: result.entityId,
+            entityType: result.entityType,
+            tags: result.tags,
+            action: result.added.length > 0 && result.removed.length > 0
+                ? "modified"
+                : result.added.length > 0
+                    ? "added"
+                    : "removed",
+            tag: result.added[0] || result.removed[0] || "",
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+            structuredContent: output,
+        };
+    });
+    // ============================================================================
+    // LIST TAGS - read-only
+    // ============================================================================
+    server.registerTool("list_tags", {
+        description: "List all unique tags in a game with counts",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId }) => {
+        const tags = tagTools.listTags(gameId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(tags, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // GET ENTITY TAGS - read-only
+    // ============================================================================
+    server.registerTool("get_entity_tags", {
+        description: "Get all tags for a specific entity",
+        inputSchema: {
+            entityId: z.string().max(100).describe("The entity ID"),
+            entityType: z.string().max(100).describe("Type of entity"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ entityId, entityType }) => {
+        const tags = tagTools.getEntityTags(entityId, entityType);
+        return {
+            content: [{ type: "text", text: JSON.stringify(tags, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // FIND BY TAG - read-only
+    // ============================================================================
+    server.registerTool("find_by_tag", {
+        description: "Find all entities with a specific tag",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            tag: z.string().max(LIMITS.NAME_MAX).describe("The tag to search for"),
+            entityType: z.string().max(100).optional().describe("Filter by entity type"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, tag, entityType }) => {
+        const entities = tagTools.findByTag(gameId, tag, entityType);
+        return {
+            content: [{ type: "text", text: JSON.stringify(entities, null, 2) }],
+        };
+    });
+    // ============================================================================
+    // RENAME TAG - update
+    // ============================================================================
+    server.registerTool("rename_tag", {
+        description: "Rename a tag across all entities in a game",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            oldTag: z.string().max(LIMITS.NAME_MAX).describe("The current tag name"),
+            newTag: z.string().min(1).max(LIMITS.NAME_MAX).describe("The new tag name"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ gameId, oldTag, newTag }) => {
+        const count = tagTools.renameTag(gameId, oldTag, newTag);
+        return {
+            content: [{ type: "text", text: `Renamed ${count} tag(s)` }],
+        };
+    });
+}

package/dist/register/time.d.ts

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