run-dmcp 0.1.0

package/dist/tools/images.js

@@ -0,0 +1,449 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase, getDataDir, withTransaction } from "../db/connection.js";
+import { writeFileSync, readFileSync, mkdirSync, existsSync, unlinkSync, rmSync, } from "fs";
+import { dirname, join } from "path";
+import sharp from "sharp";
+import { getCharacter } from "./character.js";
+import { getLocation } from "./world.js";
+import { getItem } from "./inventory.js";
+import { getFaction } from "./faction.js";
+// Use the same data directory as the database
+function getImagesDir() {
+    return join(getDataDir(), "images");
+}
+// Helper: Validate entity exists and return its name
+// For known entity types (character, location, item, faction), validates the entity exists
+// For other types (scene, quest, ability, etc.), skips validation and returns capitalized type name
+function validateEntityAndGetName(entityId, entityType) {
+    let entity = null;
+    switch (entityType) {
+        case "character":
+            entity = getCharacter(entityId);
+            break;
+        case "location":
+            entity = getLocation(entityId);
+            break;
+        case "item":
+            entity = getItem(entityId);
+            break;
+        case "faction":
+            entity = getFaction(entityId);
+            break;
+        default:
+            // For other entity types (scene, quest, ability, note, etc.), skip validation
+            // These may not have dedicated tables or the caller knows the entity exists
+            return entityType.charAt(0).toUpperCase() + entityType.slice(1);
+    }
+    if (!entity) {
+        throw new Error(`${entityType} not found: ${entityId}`);
+    }
+    return entity.name;
+}
+// Helper: Validate entity exists (legacy wrapper)
+function validateEntityExists(entityId, entityType) {
+    validateEntityAndGetName(entityId, entityType);
+}
+// Helper: Ensure directory exists
+function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+// Helper: Get extension from mime type
+function getExtension(mimeType) {
+    const map = {
+        "image/png": "png",
+        "image/jpeg": "jpg",
+        "image/jpg": "jpg",
+        "image/gif": "gif",
+        "image/webp": "webp",
+        "image/svg+xml": "svg",
+    };
+    return map[mimeType] || "png";
+}
+// Helper: Map database row to StoredImage
+function mapRowToStoredImage(row) {
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        entityId: row.entity_id,
+        entityType: row.entity_type,
+        filePath: row.file_path,
+        fileSize: row.file_size,
+        mimeType: row.mime_type,
+        width: row.width,
+        height: row.height,
+        label: row.label,
+        description: row.description,
+        source: row.source,
+        sourceUrl: row.source_url,
+        generationTool: row.generation_tool,
+        generationPrompt: row.generation_prompt,
+        isPrimary: row.is_primary === 1,
+        createdAt: row.created_at,
+    };
+}
+export async function storeImage(params) {
+    // Validate entity exists and get its name for confirmation
+    const entityName = validateEntityAndGetName(params.entityId, params.entityType);
+    const db = getDatabase();
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    // Fetch image from URL
+    const response = await fetch(params.url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch image: ${response.status}`);
+    }
+    const imageBuffer = Buffer.from(await response.arrayBuffer());
+    let mimeType = response.headers.get("content-type") || params.mimeType || "image/png";
+    const source = params.generationTool ? "generated" : "url";
+    const sourceUrl = params.url;
+    // Get image metadata using sharp
+    let width = null;
+    let height = null;
+    try {
+        const metadata = await sharp(imageBuffer).metadata();
+        width = metadata.width || null;
+        height = metadata.height || null;
+        // Use sharp's detected format if available
+        if (metadata.format) {
+            const formatToMime = {
+                jpeg: "image/jpeg",
+                png: "image/png",
+                gif: "image/gif",
+                webp: "image/webp",
+                svg: "image/svg+xml",
+                tiff: "image/tiff",
+                avif: "image/avif",
+            };
+            mimeType = formatToMime[metadata.format] || mimeType;
+        }
+    }
+    catch {
+        // If sharp can't parse it, proceed without dimensions
+    }
+    // Build file path
+    const ext = getExtension(mimeType);
+    const relativePath = join(params.gameId, `${params.entityType}s`, params.entityId, `${id}.${ext}`);
+    const fullPath = join(getImagesDir(), relativePath);
+    // Ensure directory exists and write file
+    ensureDir(dirname(fullPath));
+    writeFileSync(fullPath, imageBuffer);
+    // If setting as primary, unset current primary first
+    if (params.setAsPrimary) {
+        db.prepare(`
+      UPDATE stored_images SET is_primary = 0
+      WHERE entity_id = ? AND entity_type = ?
+    `).run(params.entityId, params.entityType);
+    }
+    // Insert database record
+    const stmt = db.prepare(`
+    INSERT INTO stored_images (
+      id, game_id, entity_id, entity_type, file_path, file_size, mime_type,
+      width, height, label, description, source, source_url, generation_tool,
+      generation_prompt, is_primary, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(id, params.gameId, params.entityId, params.entityType, relativePath, imageBuffer.length, mimeType, width, height, params.label || null, params.description || null, source, sourceUrl, params.generationTool || null, params.generationPrompt || null, params.setAsPrimary ? 1 : 0, now);
+    return {
+        id,
+        gameId: params.gameId,
+        entityId: params.entityId,
+        entityType: params.entityType,
+        entityName,
+        filePath: relativePath,
+        fileSize: imageBuffer.length,
+        mimeType,
+        width,
+        height,
+        label: params.label || null,
+        description: params.description || null,
+        source,
+        sourceUrl,
+        generationTool: params.generationTool || null,
+        generationPrompt: params.generationPrompt || null,
+        isPrimary: params.setAsPrimary || false,
+        createdAt: now,
+    };
+}
+export function getImage(imageId) {
+    const db = getDatabase();
+    const row = db.prepare(`SELECT * FROM stored_images WHERE id = ?`).get(imageId);
+    if (!row)
+        return null;
+    return mapRowToStoredImage(row);
+}
+export async function getImageData(imageId, options) {
+    const image = getImage(imageId);
+    if (!image)
+        return null;
+    const fullPath = join(getImagesDir(), image.filePath);
+    if (!existsSync(fullPath))
+        return null;
+    const originalBuffer = readFileSync(fullPath);
+    // If no processing options, return original
+    if (!options || (!options.format && !options.width && !options.height && !options.quality)) {
+        const base64 = `data:${image.mimeType};base64,${originalBuffer.toString("base64")}`;
+        return { image, base64, outputFormat: image.mimeType, outputSize: originalBuffer.length };
+    }
+    // Process with Sharp
+    let pipeline = sharp(originalBuffer);
+    // Resize if dimensions specified
+    if (options.width || options.height) {
+        pipeline = pipeline.resize({
+            width: options.width,
+            height: options.height,
+            fit: options.fit || "inside",
+            withoutEnlargement: true,
+        });
+    }
+    // Convert format and apply quality
+    let outputMimeType;
+    const quality = options.quality ?? 80;
+    switch (options.format) {
+        case "jpeg":
+            pipeline = pipeline.jpeg({ quality });
+            outputMimeType = "image/jpeg";
+            break;
+        case "webp":
+            pipeline = pipeline.webp({ quality });
+            outputMimeType = "image/webp";
+            break;
+        case "png":
+            pipeline = pipeline.png({ compressionLevel: Math.floor((100 - quality) / 10) });
+            outputMimeType = "image/png";
+            break;
+        default:
+            // Keep original format but apply quality if it's a lossy format
+            if (image.mimeType === "image/jpeg") {
+                pipeline = pipeline.jpeg({ quality });
+            }
+            else if (image.mimeType === "image/webp") {
+                pipeline = pipeline.webp({ quality });
+            }
+            outputMimeType = image.mimeType;
+    }
+    const processedBuffer = await pipeline.toBuffer();
+    const base64 = `data:${outputMimeType};base64,${processedBuffer.toString("base64")}`;
+    return { image, base64, outputFormat: outputMimeType, outputSize: processedBuffer.length };
+}
+export function listEntityImages(entityId, entityType) {
+    const db = getDatabase();
+    const rows = db
+        .prepare(`
+    SELECT * FROM stored_images
+    WHERE entity_id = ? AND entity_type = ?
+    ORDER BY is_primary DESC, created_at DESC
+  `)
+        .all(entityId, entityType);
+    const images = rows.map(mapRowToStoredImage);
+    const primaryImage = images.find((img) => img.isPrimary) || null;
+    return { entityId, entityType, images, primaryImage };
+}
+export function listEntitiesMissingImages(gameId, entityType) {
+    const db = getDatabase();
+    const result = {
+        gameId,
+        entities: [],
+        totalMissing: 0,
+        byType: { characters: 0, locations: 0, items: 0, factions: 0 },
+    };
+    // Helper to check if entity has a primary image
+    const hasPrimaryImage = (entityId, type) => {
+        const row = db.prepare(`
+      SELECT 1 FROM stored_images
+      WHERE entity_id = ? AND entity_type = ? AND is_primary = 1
+      LIMIT 1
+    `).get(entityId, type);
+        return !!row;
+    };
+    // Check characters
+    if (!entityType || entityType === "character") {
+        const characters = db.prepare(`
+      SELECT id, name, is_player, image_gen FROM characters WHERE game_id = ?
+    `).all(gameId);
+        for (const char of characters) {
+            if (!hasPrimaryImage(char.id, "character")) {
+                result.entities.push({
+                    id: char.id,
+                    name: char.name,
+                    entityType: "character",
+                    hasImageGen: !!char.image_gen,
+                    isPlayer: char.is_player === 1,
+                });
+                result.byType.characters++;
+            }
+        }
+    }
+    // Check locations
+    if (!entityType || entityType === "location") {
+        const locations = db.prepare(`
+      SELECT id, name, image_gen FROM locations WHERE game_id = ?
+    `).all(gameId);
+        for (const loc of locations) {
+            if (!hasPrimaryImage(loc.id, "location")) {
+                result.entities.push({
+                    id: loc.id,
+                    name: loc.name,
+                    entityType: "location",
+                    hasImageGen: !!loc.image_gen,
+                });
+                result.byType.locations++;
+            }
+        }
+    }
+    // Check items
+    if (!entityType || entityType === "item") {
+        const items = db.prepare(`
+      SELECT id, name, image_gen FROM items WHERE game_id = ?
+    `).all(gameId);
+        for (const item of items) {
+            if (!hasPrimaryImage(item.id, "item")) {
+                result.entities.push({
+                    id: item.id,
+                    name: item.name,
+                    entityType: "item",
+                    hasImageGen: !!item.image_gen,
+                });
+                result.byType.items++;
+            }
+        }
+    }
+    // Check factions
+    if (!entityType || entityType === "faction") {
+        const factions = db.prepare(`
+      SELECT id, name FROM factions WHERE game_id = ?
+    `).all(gameId);
+        for (const faction of factions) {
+            if (!hasPrimaryImage(faction.id, "faction")) {
+                result.entities.push({
+                    id: faction.id,
+                    name: faction.name,
+                    entityType: "faction",
+                    hasImageGen: false, // Factions don't have imageGen column
+                });
+                result.byType.factions++;
+            }
+        }
+    }
+    result.totalMissing = result.entities.length;
+    return result;
+}
+export function deleteImage(imageId) {
+    const db = getDatabase();
+    const image = getImage(imageId);
+    if (!image)
+        return false;
+    // Delete file
+    const fullPath = join(getImagesDir(), image.filePath);
+    if (existsSync(fullPath)) {
+        unlinkSync(fullPath);
+    }
+    // Delete database record
+    const result = db.prepare(`DELETE FROM stored_images WHERE id = ?`).run(imageId);
+    return result.changes > 0;
+}
+export function setPrimaryImage(imageId) {
+    const image = getImage(imageId);
+    if (!image)
+        return null;
+    // Unsetting the old primary and setting the new one must happen
+    // together -- a failure between the two could otherwise leave the entity
+    // with zero primaries, or briefly with two.
+    withTransaction(() => {
+        const db = getDatabase();
+        // Unset current primary
+        db.prepare(`
+      UPDATE stored_images SET is_primary = 0
+      WHERE entity_id = ? AND entity_type = ?
+    `).run(image.entityId, image.entityType);
+        // Set new primary
+        db.prepare(`UPDATE stored_images SET is_primary = 1 WHERE id = ?`).run(imageId);
+    });
+    return { ...image, isPrimary: true };
+}
+export function updateImageMetadata(imageId, updates) {
+    const db = getDatabase();
+    const current = getImage(imageId);
+    if (!current)
+        return null;
+    const newLabel = updates.label !== undefined ? updates.label : current.label;
+    const newDescription = updates.description !== undefined ? updates.description : current.description;
+    // Handle entity re-association
+    let newEntityId = current.entityId;
+    let newEntityType = current.entityType;
+    let newFilePath = current.filePath;
+    if (updates.entityId !== undefined || updates.entityType !== undefined) {
+        newEntityId = updates.entityId ?? current.entityId;
+        newEntityType = updates.entityType ?? current.entityType;
+        // Validate new entity exists
+        validateEntityExists(newEntityId, newEntityType);
+        // If entity changed, move the file
+        if (newEntityId !== current.entityId || newEntityType !== current.entityType) {
+            const oldFullPath = join(getImagesDir(), current.filePath);
+            const ext = current.filePath.split(".").pop() || "png";
+            newFilePath = join(current.gameId, `${newEntityType}s`, newEntityId, `${imageId}.${ext}`);
+            const newFullPath = join(getImagesDir(), newFilePath);
+            // Ensure new directory exists
+            ensureDir(dirname(newFullPath));
+            // Move the file
+            if (existsSync(oldFullPath)) {
+                const fileData = readFileSync(oldFullPath);
+                writeFileSync(newFullPath, fileData);
+                unlinkSync(oldFullPath);
+            }
+        }
+    }
+    db.prepare(`
+    UPDATE stored_images
+    SET label = ?, description = ?, entity_id = ?, entity_type = ?, file_path = ?
+    WHERE id = ?
+  `).run(newLabel, newDescription, newEntityId, newEntityType, newFilePath, imageId);
+    return {
+        ...current,
+        label: newLabel,
+        description: newDescription,
+        entityId: newEntityId,
+        entityType: newEntityType,
+        filePath: newFilePath,
+    };
+}
+// Cleanup helper - delete all images for a game
+export function deleteGameImages(gameId) {
+    const db = getDatabase();
+    // Delete files
+    const sessionDir = join(getImagesDir(), gameId);
+    if (existsSync(sessionDir)) {
+        rmSync(sessionDir, { recursive: true, force: true });
+    }
+    // Delete records (cascade should handle this, but be explicit)
+    const result = db
+        .prepare(`DELETE FROM stored_images WHERE game_id = ?`)
+        .run(gameId);
+    return result.changes;
+}
+// Get primary image for an entity
+export function getPrimaryImage(entityId, entityType) {
+    const db = getDatabase();
+    const row = db
+        .prepare(`
+    SELECT * FROM stored_images
+    WHERE entity_id = ? AND entity_type = ? AND is_primary = 1
+  `)
+        .get(entityId, entityType);
+    if (!row)
+        return null;
+    return mapRowToStoredImage(row);
+}
+// List all images in a game
+export function listGameImages(gameId) {
+    const db = getDatabase();
+    const rows = db
+        .prepare(`
+    SELECT * FROM stored_images
+    WHERE game_id = ?
+    ORDER BY created_at DESC
+  `)
+        .all(gameId);
+    return rows.map(mapRowToStoredImage);
+}

package/dist/tools/inventory.d.ts

@@ -0,0 +1,20 @@
+import type { Item, ItemProperties, ImageGeneration } from "../types/index.js";
+export declare function createItem(params: {
+    gameId: string;
+    ownerId: string;
+    ownerType: "character" | "location";
+    name: string;
+    properties?: Partial<ItemProperties>;
+    imageGen?: ImageGeneration;
+}): Item;
+export declare function getItem(id: string): Item | null;
+export declare function updateItem(id: string, updates: {
+    name?: string;
+    properties?: Partial<ItemProperties>;
+    imageGen?: ImageGeneration | null;
+}): Item | null;
+export declare function deleteItem(id: string): boolean;
+export declare function transferItem(itemId: string, newOwnerId: string, newOwnerType: "character" | "location"): Item | null;
+export declare function getInventory(ownerId: string, ownerType: "character" | "location"): Item[];
+export declare function findItemByName(gameId: string, name: string): Item | null;
+export declare function listGameItems(gameId: string): Item[];

package/dist/tools/inventory.js

@@ -0,0 +1,145 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase } from "../db/connection.js";
+import { safeJsonParse } from "../utils/json.js";
+import { gameEvents } from "../events/emitter.js";
+import { validateGameExists } from "./game.js";
+export function createItem(params) {
+    // Validate game exists to prevent orphaned records
+    validateGameExists(params.gameId);
+    const db = getDatabase();
+    const id = uuidv4();
+    const properties = {
+        description: "",
+        type: "misc",
+        ...params.properties,
+    };
+    const stmt = db.prepare(`
+    INSERT INTO items (id, game_id, owner_id, owner_type, name, properties, image_gen)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(id, params.gameId, params.ownerId, params.ownerType, params.name, JSON.stringify(properties), params.imageGen ? JSON.stringify(params.imageGen) : null);
+    return {
+        id,
+        gameId: params.gameId,
+        ownerId: params.ownerId,
+        ownerType: params.ownerType,
+        name: params.name,
+        properties,
+        imageGen: params.imageGen || null,
+    };
+}
+export function getItem(id) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT * FROM items WHERE id = ?`);
+    const row = stmt.get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        ownerId: row.owner_id,
+        ownerType: row.owner_type,
+        name: row.name,
+        properties: safeJsonParse(row.properties, { description: "", type: "misc" }),
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+    };
+}
+export function updateItem(id, updates) {
+    const db = getDatabase();
+    const current = getItem(id);
+    if (!current)
+        return null;
+    const newName = updates.name ?? current.name;
+    const newProperties = updates.properties
+        ? { ...current.properties, ...updates.properties }
+        : current.properties;
+    const newImageGen = updates.imageGen !== undefined ? updates.imageGen : current.imageGen;
+    const stmt = db.prepare(`
+    UPDATE items SET name = ?, properties = ?, image_gen = ? WHERE id = ?
+  `);
+    stmt.run(newName, JSON.stringify(newProperties), newImageGen ? JSON.stringify(newImageGen) : null, id);
+    return {
+        ...current,
+        name: newName,
+        properties: newProperties,
+        imageGen: newImageGen,
+    };
+}
+export function deleteItem(id) {
+    const db = getDatabase();
+    const stmt = db.prepare(`DELETE FROM items WHERE id = ?`);
+    const result = stmt.run(id);
+    return result.changes > 0;
+}
+export function transferItem(itemId, newOwnerId, newOwnerType) {
+    const db = getDatabase();
+    const item = getItem(itemId);
+    if (!item)
+        return null;
+    const stmt = db.prepare(`
+    UPDATE items SET owner_id = ?, owner_type = ? WHERE id = ?
+  `);
+    stmt.run(newOwnerId, newOwnerType, itemId);
+    // Emit realtime event
+    gameEvents.emit({
+        type: "inventory:updated",
+        gameId: item.gameId,
+        entityId: itemId,
+        entityType: "item",
+        timestamp: new Date().toISOString(),
+        data: { name: item.name, newOwnerId, newOwnerType },
+    });
+    return {
+        ...item,
+        ownerId: newOwnerId,
+        ownerType: newOwnerType,
+    };
+}
+export function getInventory(ownerId, ownerType) {
+    const db = getDatabase();
+    const stmt = db.prepare(`
+    SELECT * FROM items WHERE owner_id = ? AND owner_type = ?
+  `);
+    const rows = stmt.all(ownerId, ownerType);
+    return rows.map((row) => ({
+        id: row.id,
+        gameId: row.game_id,
+        ownerId: row.owner_id,
+        ownerType: row.owner_type,
+        name: row.name,
+        properties: safeJsonParse(row.properties, { description: "", type: "misc" }),
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+    }));
+}
+export function findItemByName(gameId, name) {
+    const db = getDatabase();
+    const stmt = db.prepare(`
+    SELECT * FROM items WHERE game_id = ? AND name = ? LIMIT 1
+  `);
+    const row = stmt.get(gameId, name);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        ownerId: row.owner_id,
+        ownerType: row.owner_type,
+        name: row.name,
+        properties: safeJsonParse(row.properties, { description: "", type: "misc" }),
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+    };
+}
+export function listGameItems(gameId) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT * FROM items WHERE game_id = ?`);
+    const rows = stmt.all(gameId);
+    return rows.map((row) => ({
+        id: row.id,
+        gameId: row.game_id,
+        ownerId: row.owner_id,
+        ownerType: row.owner_type,
+        name: row.name,
+        properties: safeJsonParse(row.properties, { description: "", type: "misc" }),
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+    }));
+}

package/dist/tools/narrative.d.ts

@@ -0,0 +1,58 @@
+import type { NarrativeEvent } from "../types/index.js";
+export declare function logEvent(params: {
+    gameId: string;
+    eventType: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+}): NarrativeEvent;
+export declare function getEvent(id: string): NarrativeEvent | null;
+export declare function getHistory(gameId: string, options?: {
+    limit?: number;
+    offset?: number;
+    eventType?: string;
+    since?: string;
+}): NarrativeEvent[];
+export declare function getRecentHistory(gameId: string, count?: number): NarrativeEvent[];
+export declare function getSummary(gameId: string): {
+    totalEvents: number;
+    eventTypes: Record<string, number>;
+    firstEvent: string | null;
+    lastEvent: string | null;
+    recentEvents: NarrativeEvent[];
+};
+export declare function deleteEvent(id: string): boolean;
+export declare function clearHistory(gameId: string): number;
+export interface StoryExportData {
+    game: {
+        name: string;
+        setting: string;
+        style: string;
+        createdAt: string;
+    };
+    characters: Array<{
+        name: string;
+        isPlayer: boolean;
+        notes: string;
+    }>;
+    locations: Array<{
+        name: string;
+        description: string;
+    }>;
+    quests: Array<{
+        name: string;
+        description: string;
+        status: string;
+        objectives: Array<{
+            description: string;
+            completed: boolean;
+        }>;
+    }>;
+    chapters: Array<{
+        title: string;
+        events: NarrativeEvent[];
+    }>;
+    totalEvents: number;
+    exportStyle: string;
+    instruction: string;
+}
+export declare function exportStoryData(gameId: string, style: string): StoryExportData | null;