run-dmcp 0.1.0

package/dist/register/images.js

@@ -0,0 +1,400 @@
+import { z } from "zod";
+import * as imageTools from "../tools/images.js";
+import * as gameTools from "../tools/game.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+export function registerImageTools(server) {
+    server.registerTool("store_image", {
+        description: "Store an image for an entity. Provide a URL and the image will be downloaded and stored locally.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            entityId: z
+                .string()
+                .max(100)
+                .describe("ID of the entity (character, location, item, etc.)"),
+            entityType: z
+                .string()
+                .max(50)
+                .describe("Type of entity (e.g., character, location, item, scene, faction, quest, ability)"),
+            url: z.string().max(2000).describe("URL to fetch the image from"),
+            label: z
+                .string()
+                .max(LIMITS.NAME_MAX)
+                .optional()
+                .describe("Label for the image (e.g., 'Portrait', 'Battle Pose')"),
+            description: z
+                .string()
+                .max(LIMITS.DESCRIPTION_MAX)
+                .optional()
+                .describe("Description of what's in the image"),
+            mimeType: z
+                .string()
+                .max(100)
+                .optional()
+                .describe("MIME type (e.g., 'image/png'). Inferred from response headers if not provided."),
+            generationTool: z
+                .string()
+                .max(100)
+                .optional()
+                .describe("Tool used to generate (e.g., 'dalle', 'sdxl', 'midjourney', 'comfyui')"),
+            generationPrompt: z
+                .string()
+                .max(LIMITS.CONTENT_MAX)
+                .optional()
+                .describe("The prompt used to generate the image"),
+            setAsPrimary: z
+                .boolean()
+                .optional()
+                .describe("Set this as the primary image for the entity"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        try {
+            const image = await imageTools.storeImage(params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(image, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error storing image: ${error}` }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("get_image", {
+        description: "Get image metadata by ID",
+        inputSchema: {
+            imageId: z.string().max(100).describe("The image ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ imageId }) => {
+        const image = imageTools.getImage(imageId);
+        if (!image) {
+            return {
+                content: [{ type: "text", text: "Image not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(image, null, 2) }],
+        };
+    });
+    server.registerTool("get_image_data", {
+        description: "Get image with base64 data included (for displaying or processing). Supports format conversion, resizing, and quality control.",
+        inputSchema: {
+            imageId: z.string().max(100).describe("The image ID"),
+            format: z
+                .enum(["jpeg", "webp", "png"])
+                .optional()
+                .describe("Output format. If not specified, returns original format."),
+            width: z
+                .number()
+                .int()
+                .positive()
+                .max(4096)
+                .optional()
+                .describe("Target width in pixels. Image will be resized proportionally if only width is specified."),
+            height: z
+                .number()
+                .int()
+                .positive()
+                .max(4096)
+                .optional()
+                .describe("Target height in pixels. Image will be resized proportionally if only height is specified."),
+            quality: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe("Quality for JPEG/WebP (1-100). Default is 80. For PNG, controls compression level."),
+            fit: z
+                .enum(["cover", "contain", "fill", "inside", "outside"])
+                .optional()
+                .describe("How to fit the image when both width and height are specified. Default is 'inside' (preserve aspect ratio, fit within dimensions)."),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ imageId, format, width, height, quality, fit }) => {
+        const result = await imageTools.getImageData(imageId, {
+            format,
+            width,
+            height,
+            quality,
+            fit,
+        });
+        if (!result) {
+            return {
+                content: [{ type: "text", text: "Image not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("list_entity_images", {
+        description: "List all images for an entity",
+        inputSchema: {
+            entityId: z.string().max(100).describe("ID of the entity"),
+            entityType: z
+                .string()
+                .max(50)
+                .describe("Type of entity (e.g., character, location, item, scene, faction, quest, ability)"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ entityId, entityType }) => {
+        const result = imageTools.listEntityImages(entityId, entityType);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("list_entities_missing_images", {
+        description: "List all entities in a game that don't have a primary image. Useful for batch image generation workflows. Returns entities grouped by type with counts.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            entityType: z
+                .string()
+                .max(50)
+                .optional()
+                .describe("Filter by entity type (optional, returns all types if not specified). Common types: character, location, item, faction."),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, entityType }) => {
+        const result = imageTools.listEntitiesMissingImages(gameId, entityType);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                }],
+        };
+    });
+    server.registerTool("delete_image", {
+        description: "Delete a stored image (removes file and database record)",
+        inputSchema: {
+            imageId: z.string().max(100).describe("The image ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ imageId }) => {
+        const success = imageTools.deleteImage(imageId);
+        return {
+            content: [
+                { type: "text", text: success ? "Image deleted" : "Image not found" },
+            ],
+            isError: !success,
+        };
+    });
+    server.registerTool("set_primary_image", {
+        description: "Set an image as the primary image for its entity",
+        inputSchema: {
+            imageId: z.string().max(100).describe("The image ID to set as primary"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ imageId }) => {
+        const image = imageTools.setPrimaryImage(imageId);
+        if (!image) {
+            return {
+                content: [{ type: "text", text: "Image not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(image, null, 2) }],
+        };
+    });
+    server.registerTool("update_image_metadata", {
+        description: "Update label, description, or entity association of an image",
+        inputSchema: {
+            imageId: z.string().max(100).describe("The image ID"),
+            label: z.string().max(LIMITS.NAME_MAX).optional().describe("New label"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("New description"),
+            entityId: z.string().max(100).optional().describe("New entity ID to associate the image with"),
+            entityType: z.string().max(50).optional().describe("New entity type (required if changing to a different type of entity)"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ imageId, label, description, entityId, entityType }) => {
+        try {
+            const image = imageTools.updateImageMetadata(imageId, {
+                label,
+                description,
+                entityId,
+                entityType,
+            });
+            if (!image) {
+                return {
+                    content: [{ type: "text", text: "Image not found" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(image, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error updating image: ${error}` }],
+                isError: true,
+            };
+        }
+    });
+    // ============================================================================
+    // BUILD IMAGE PROMPT - construct prompt from entity's structured imageGen data
+    // ============================================================================
+    server.registerTool("build_image_prompt", {
+        description: "Build an image generation prompt from an entity's structured imageGen data. If a template exists for the entity type (or a specific templateId is provided), uses template-based building. Otherwise combines imageGen schema, notes/description, and preset defaults.",
+        inputSchema: {
+            entityId: z.string().max(100).describe("The entity ID"),
+            entityType: z.string().max(50).describe("Type of entity (e.g., character, location, item, faction)"),
+            gameId: z.string().max(100).optional().describe("Game ID (optional, inferred from entity if not provided)"),
+            templateId: z.string().max(100).optional().describe("Specific template ID to use (optional, uses default for entity type if not provided)"),
+        },
+        outputSchema: {
+            entityId: z.string(),
+            entityType: z.string(),
+            entityName: z.string(),
+            prompt: z.string().describe("The constructed positive prompt"),
+            negativePrompt: z.string().describe("The constructed negative prompt"),
+            summary: z.string().describe("Human-readable summary for verification"),
+            source: z.object({
+                fromImageGen: z.boolean().describe("Whether imageGen schema was used"),
+                fromNotes: z.boolean().describe("Whether notes/description was used"),
+                fromPreset: z.boolean().describe("Whether game preset was applied"),
+                fromTemplate: z.boolean().describe("Whether a template was used"),
+            }),
+            templateUsed: z.string().optional().describe("Name of template used, if any"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ entityId, entityType, gameId, templateId }) => {
+        const { buildImagePrompt } = await import("../tools/image-prompt.js");
+        const result = buildImagePrompt(entityId, entityType, gameId, templateId);
+        if (!result) {
+            return {
+                content: [{ type: "text", text: `Entity not found: ${entityType} ${entityId}` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+        };
+    });
+    // ============================================================================
+    // IMAGE PROMPT TEMPLATES - Template-based prompt building
+    // ============================================================================
+    server.registerTool("list_image_prompt_templates", {
+        description: "List all image prompt templates for a game. Templates allow configurable prompt building from entity data using placeholder syntax.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId }) => {
+        const templates = gameTools.listImagePromptTemplates(gameId);
+        const summary = templates.map(t => ({
+            id: t.id,
+            name: t.name,
+            entityType: t.entityType,
+            description: t.description,
+            isDefault: t.isDefault,
+            priority: t.priority,
+        }));
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        count: templates.length,
+                        templates: summary,
+                    }, null, 2),
+                }],
+        };
+    });
+    server.registerTool("get_image_prompt_template", {
+        description: "Get full details of an image prompt template including the template strings.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            templateId: z.string().max(100).describe("The template ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, templateId }) => {
+        const template = gameTools.getImagePromptTemplate(gameId, templateId);
+        if (!template) {
+            return {
+                content: [{ type: "text", text: "Template not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(template, null, 2) }],
+        };
+    });
+    server.registerTool("create_image_prompt_template", {
+        description: `Create a new image prompt template for building prompts from entity data. Templates use placeholder syntax:
+- {{field.path}} - simple value substitution
+- {{field.path|"default"}} - value with default if missing
+- {{field.path|}} - value or empty string if missing
+
+Available fields include: name, notes, subject.primaryDescription, subject.physicalTraits.*, subject.attire.*, subject.environment.*, style.*, composition.*, and any imageGen data.`,
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Template name"),
+            entityType: z.string().max(50).describe("Which entity type this template handles (e.g., character, location, item, faction)"),
+            promptTemplate: z.string().max(LIMITS.CONTENT_MAX).describe("Main prompt template with placeholders"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("What this template is for"),
+            negativePromptTemplate: z.string().max(LIMITS.CONTENT_MAX).optional().describe("Negative prompt template"),
+            promptPrefix: z.string().max(500).optional().describe("Text added before the filled template"),
+            promptSuffix: z.string().max(500).optional().describe("Text added after the filled template (e.g., quality tags)"),
+            fieldAliases: z.record(z.string().max(100), z.string().max(200)).optional().describe("Alias mappings for complex paths"),
+            defaults: z.record(z.string().max(100), z.string().max(200)).optional().describe("Default values for missing fields"),
+            priority: z.number().optional().describe("Priority for template selection (higher = preferred)"),
+            isDefault: z.boolean().optional().describe("Make this the default template for its entity type"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async ({ gameId, ...params }) => {
+        const template = gameTools.createImagePromptTemplate(gameId, params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(template, null, 2) }],
+        };
+    });
+    server.registerTool("update_image_prompt_template", {
+        description: "Update an existing image prompt template. Only specified fields are updated.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            templateId: z.string().max(100).describe("The template ID to update"),
+            name: z.string().min(1).max(LIMITS.NAME_MAX).optional().describe("New template name"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("New description"),
+            promptTemplate: z.string().max(LIMITS.CONTENT_MAX).optional().describe("New prompt template"),
+            negativePromptTemplate: z.string().max(LIMITS.CONTENT_MAX).optional().describe("New negative prompt template"),
+            promptPrefix: z.string().max(500).optional().describe("New prefix"),
+            promptSuffix: z.string().max(500).optional().describe("New suffix"),
+            fieldAliases: z.record(z.string().max(100), z.string().max(200)).optional().describe("New field aliases"),
+            defaults: z.record(z.string().max(100), z.string().max(200)).optional().describe("New defaults"),
+            priority: z.number().optional().describe("New priority"),
+            isDefault: z.boolean().optional().describe("Make this the default for its entity type"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ gameId, templateId, ...updates }) => {
+        const template = gameTools.updateImagePromptTemplate(gameId, templateId, updates);
+        if (!template) {
+            return {
+                content: [{ type: "text", text: "Template not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(template, null, 2) }],
+        };
+    });
+    server.registerTool("delete_image_prompt_template", {
+        description: "Delete an image prompt template. This is IRREVERSIBLE.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            templateId: z.string().max(100).describe("The template ID to delete"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ gameId, templateId }) => {
+        const success = gameTools.deleteImagePromptTemplate(gameId, templateId);
+        return {
+            content: [{ type: "text", text: success ? "Template deleted" : "Template not found" }],
+            isError: !success,
+        };
+    });
+}

package/dist/register/inventory.d.ts

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

package/dist/register/inventory.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import * as inventoryTools from "../tools/inventory.js";
+import { imageGenSchema } from "../schemas/index.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+export function registerInventoryTools(server) {
+    server.registerTool("create_item", {
+        description: "Create a new item. IMPORTANT: Call this IMMEDIATELY when introducing any item in narrative - whether found, given, purchased, or mentioned. Items must exist in the database before being referenced in dialogue or description.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            ownerId: z.string().max(100).describe("Character or location ID that owns the item"),
+            ownerType: z.enum(["character", "location"]).describe("Owner type"),
+            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Item name"),
+            properties: z.object({
+                description: z.string().max(LIMITS.DESCRIPTION_MAX).optional(),
+                type: z.string().max(100).optional(),
+                weight: z.number().optional(),
+                value: z.number().optional(),
+                effects: z.array(z.string().max(LIMITS.NAME_MAX)).max(LIMITS.ARRAY_MAX).optional(),
+            }).optional().describe("Item properties"),
+            imageGen: imageGenSchema.optional().describe("Image generation metadata for item art"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const item = inventoryTools.createItem(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(item, null, 2) }],
+        };
+    });
+    server.registerTool("get_item", {
+        description: "Get item details",
+        inputSchema: {
+            itemId: z.string().max(100).describe("The item ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ itemId }) => {
+        const item = inventoryTools.getItem(itemId);
+        if (!item) {
+            return {
+                content: [{ type: "text", text: "Item not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(item, null, 2) }],
+        };
+    });
+    server.registerTool("update_item", {
+        description: "Update an item",
+        inputSchema: {
+            itemId: z.string().max(100).describe("The item ID"),
+            name: z.string().max(LIMITS.NAME_MAX).optional().describe("New name"),
+            properties: z.record(z.string(), z.unknown()).optional().describe("Property updates"),
+            imageGen: imageGenSchema.nullable().optional().describe("Image generation metadata (null to remove)"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ itemId, name, properties, imageGen }) => {
+        const item = inventoryTools.updateItem(itemId, { name, properties, imageGen });
+        if (!item) {
+            return {
+                content: [{ type: "text", text: "Item not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(item, null, 2) }],
+        };
+    });
+    server.registerTool("delete_item", {
+        description: "Delete an item permanently",
+        inputSchema: {
+            itemId: z.string().max(100).describe("The item ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ itemId }) => {
+        const success = inventoryTools.deleteItem(itemId);
+        return {
+            content: [{ type: "text", text: success ? "Item deleted" : "Item not found" }],
+            isError: !success,
+        };
+    });
+    server.registerTool("transfer_item", {
+        description: "Transfer an item to a new owner. Call this whenever an item changes hands - given, dropped, picked up, stolen, purchased, etc. The database should always reflect current item ownership.",
+        inputSchema: {
+            itemId: z.string().max(100).describe("The item ID"),
+            newOwnerId: z.string().max(100).describe("New owner ID"),
+            newOwnerType: z.enum(["character", "location"]).describe("New owner type"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ itemId, newOwnerId, newOwnerType }) => {
+        const item = inventoryTools.transferItem(itemId, newOwnerId, newOwnerType);
+        if (!item) {
+            return {
+                content: [{ type: "text", text: "Item not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(item, null, 2) }],
+        };
+    });
+    server.registerTool("get_inventory", {
+        description: "Get inventory for a character or location",
+        inputSchema: {
+            ownerId: z.string().max(100).describe("Owner ID"),
+            ownerType: z.enum(["character", "location"]).describe("Owner type"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ ownerId, ownerType }) => {
+        const items = inventoryTools.getInventory(ownerId, ownerType);
+        return {
+            content: [{ type: "text", text: JSON.stringify(items, null, 2) }],
+        };
+    });
+}

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

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