run-dmcp 0.1.0

package/dist/tools/status.d.ts

@@ -0,0 +1,36 @@
+import type { StatusEffect } from "../types/index.js";
+export declare function applyStatusEffect(params: {
+    gameId: string;
+    targetId: string;
+    name: string;
+    description?: string;
+    effectType?: "buff" | "debuff" | "neutral";
+    duration?: number;
+    stacks?: number;
+    maxStacks?: number;
+    effects?: Record<string, number>;
+    sourceId?: string;
+    sourceType?: string;
+    expiresAt?: string;
+}): StatusEffect;
+export declare function getStatusEffect(id: string): StatusEffect | null;
+export declare function removeStatusEffect(id: string): boolean;
+export declare function listStatusEffects(targetId: string, filter?: {
+    effectType?: "buff" | "debuff" | "neutral";
+}): StatusEffect[];
+export interface TickResult {
+    expired: StatusEffect[];
+    remaining: StatusEffect[];
+}
+export declare function tickDurations(gameId: string, amount?: number): TickResult;
+export declare function modifyStacks(id: string, delta: number): StatusEffect | null;
+export declare function clearEffects(targetId: string, filter?: {
+    effectType?: "buff" | "debuff" | "neutral";
+    name?: string;
+}): number;
+export interface EffectiveModifiers {
+    targetId: string;
+    modifiers: Record<string, number>;
+    effects: StatusEffect[];
+}
+export declare function getEffectiveModifiers(targetId: string): EffectiveModifiers;

package/dist/tools/status.js

@@ -0,0 +1,218 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase } from "../db/connection.js";
+import { safeJsonParse } from "../utils/json.js";
+import { validateGameExists } from "./game.js";
+export function applyStatusEffect(params) {
+    // Validate game exists to prevent orphaned records
+    validateGameExists(params.gameId);
+    const db = getDatabase();
+    const now = new Date().toISOString();
+    // Check if effect already exists on target
+    const existing = db.prepare(`
+    SELECT * FROM status_effects WHERE game_id = ? AND target_id = ? AND name = ?
+  `).get(params.gameId, params.targetId, params.name);
+    if (existing) {
+        // Stack the effect - use existing maxStacks (can't change stack limit after creation)
+        const currentStacks = existing.stacks;
+        const existingMaxStacks = existing.max_stacks;
+        const newStacks = existingMaxStacks !== null
+            ? Math.min(currentStacks + (params.stacks ?? 1), existingMaxStacks)
+            : currentStacks + (params.stacks ?? 1);
+        // Refresh duration if provided
+        const newDuration = params.duration ?? existing.duration;
+        db.prepare(`
+      UPDATE status_effects SET stacks = ?, duration = ? WHERE id = ?
+    `).run(newStacks, newDuration, existing.id);
+        const updated = getStatusEffect(existing.id);
+        if (!updated) {
+            throw new Error(`Failed to retrieve updated status effect '${existing.id}'`);
+        }
+        return updated;
+    }
+    // Create new effect
+    const id = uuidv4();
+    db.prepare(`
+    INSERT INTO status_effects (id, game_id, target_id, name, description, effect_type, duration, stacks, max_stacks, effects, source_id, source_type, expires_at, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, params.gameId, params.targetId, params.name, params.description || "", params.effectType || null, params.duration ?? null, params.stacks ?? 1, params.maxStacks ?? null, JSON.stringify(params.effects || {}), params.sourceId || null, params.sourceType || null, params.expiresAt || null, now);
+    return {
+        id,
+        gameId: params.gameId,
+        targetId: params.targetId,
+        name: params.name,
+        description: params.description || "",
+        effectType: params.effectType || null,
+        duration: params.duration ?? null,
+        stacks: params.stacks ?? 1,
+        maxStacks: params.maxStacks ?? null,
+        effects: params.effects || {},
+        sourceId: params.sourceId || null,
+        sourceType: params.sourceType || null,
+        expiresAt: params.expiresAt || null,
+        createdAt: now,
+    };
+}
+export function getStatusEffect(id) {
+    const db = getDatabase();
+    const row = db.prepare(`SELECT * FROM status_effects WHERE id = ?`).get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        targetId: row.target_id,
+        name: row.name,
+        description: row.description,
+        effectType: row.effect_type,
+        duration: row.duration,
+        stacks: row.stacks,
+        maxStacks: row.max_stacks,
+        effects: safeJsonParse(row.effects || "{}", {}),
+        sourceId: row.source_id,
+        sourceType: row.source_type,
+        expiresAt: row.expires_at,
+        createdAt: row.created_at,
+    };
+}
+export function removeStatusEffect(id) {
+    const db = getDatabase();
+    const result = db.prepare(`DELETE FROM status_effects WHERE id = ?`).run(id);
+    return result.changes > 0;
+}
+export function listStatusEffects(targetId, filter) {
+    const db = getDatabase();
+    let query = `SELECT * FROM status_effects WHERE target_id = ?`;
+    const params = [targetId];
+    if (filter?.effectType) {
+        query += ` AND effect_type = ?`;
+        params.push(filter.effectType);
+    }
+    query += ` ORDER BY created_at`;
+    const rows = db.prepare(query).all(...params);
+    return rows.map(row => ({
+        id: row.id,
+        gameId: row.game_id,
+        targetId: row.target_id,
+        name: row.name,
+        description: row.description,
+        effectType: row.effect_type,
+        duration: row.duration,
+        stacks: row.stacks,
+        maxStacks: row.max_stacks,
+        effects: safeJsonParse(row.effects || "{}", {}),
+        sourceId: row.source_id,
+        sourceType: row.source_type,
+        expiresAt: row.expires_at,
+        createdAt: row.created_at,
+    }));
+}
+// NOTE on expiry consequences: status effects do NOT support the declared
+// on-expiry consequence mechanism that scheduled_events (time.ts) and
+// timers (timers.ts) support. tickDurations() only decrements duration and
+// deletes the row at zero, exactly as before. Status effects were left out
+// deliberately -- unifying all three expiry systems behind one consequence
+// mechanism is a larger refactor than this feature warrants; see the
+// scheduled_events/timers implementations for the supported pattern if this
+// gets extended later.
+export function tickDurations(gameId, amount = 1) {
+    const db = getDatabase();
+    // Get all effects with duration
+    const effects = db.prepare(`
+    SELECT * FROM status_effects WHERE game_id = ? AND duration IS NOT NULL
+  `).all(gameId);
+    const expired = [];
+    const remaining = [];
+    for (const row of effects) {
+        const currentDuration = row.duration;
+        const newDuration = currentDuration - amount;
+        if (newDuration <= 0) {
+            // Effect expired
+            db.prepare(`DELETE FROM status_effects WHERE id = ?`).run(row.id);
+            expired.push({
+                id: row.id,
+                gameId: row.game_id,
+                targetId: row.target_id,
+                name: row.name,
+                description: row.description,
+                effectType: row.effect_type,
+                duration: 0,
+                stacks: row.stacks,
+                maxStacks: row.max_stacks,
+                effects: safeJsonParse(row.effects || "{}", {}),
+                sourceId: row.source_id,
+                sourceType: row.source_type,
+                expiresAt: row.expires_at,
+                createdAt: row.created_at,
+            });
+        }
+        else {
+            // Update duration
+            db.prepare(`UPDATE status_effects SET duration = ? WHERE id = ?`).run(newDuration, row.id);
+            remaining.push({
+                id: row.id,
+                gameId: row.game_id,
+                targetId: row.target_id,
+                name: row.name,
+                description: row.description,
+                effectType: row.effect_type,
+                duration: newDuration,
+                stacks: row.stacks,
+                maxStacks: row.max_stacks,
+                effects: safeJsonParse(row.effects || "{}", {}),
+                sourceId: row.source_id,
+                sourceType: row.source_type,
+                expiresAt: row.expires_at,
+                createdAt: row.created_at,
+            });
+        }
+    }
+    return { expired, remaining };
+}
+export function modifyStacks(id, delta) {
+    const db = getDatabase();
+    const effect = getStatusEffect(id);
+    if (!effect)
+        return null;
+    const newStacks = effect.stacks + delta;
+    if (newStacks <= 0) {
+        // Remove effect
+        db.prepare(`DELETE FROM status_effects WHERE id = ?`).run(id);
+        return { ...effect, stacks: 0 };
+    }
+    const finalStacks = effect.maxStacks !== null
+        ? Math.min(newStacks, effect.maxStacks)
+        : newStacks;
+    db.prepare(`UPDATE status_effects SET stacks = ? WHERE id = ?`).run(finalStacks, id);
+    return { ...effect, stacks: finalStacks };
+}
+export function clearEffects(targetId, filter) {
+    const db = getDatabase();
+    let query = `DELETE FROM status_effects WHERE target_id = ?`;
+    const params = [targetId];
+    if (filter?.effectType) {
+        query += ` AND effect_type = ?`;
+        params.push(filter.effectType);
+    }
+    if (filter?.name) {
+        query += ` AND name = ?`;
+        params.push(filter.name);
+    }
+    const result = db.prepare(query).run(...params);
+    return result.changes;
+}
+export function getEffectiveModifiers(targetId) {
+    const effects = listStatusEffects(targetId);
+    const modifiers = {};
+    for (const effect of effects) {
+        for (const [key, value] of Object.entries(effect.effects)) {
+            // Multiply by stacks
+            const totalValue = value * effect.stacks;
+            modifiers[key] = (modifiers[key] || 0) + totalValue;
+        }
+    }
+    return {
+        targetId,
+        modifiers,
+        effects,
+    };
+}

package/dist/tools/tables.d.ts

@@ -0,0 +1,33 @@
+import type { RandomTable, TableEntry, TableRollResult } from "../types/index.js";
+export declare function createTable(params: {
+    gameId: string;
+    name: string;
+    description?: string;
+    category?: string;
+    entries?: TableEntry[];
+    rollExpression?: string;
+}): RandomTable;
+export declare function getTable(id: string): RandomTable | null;
+export declare function updateTable(id: string, updates: {
+    name?: string;
+    description?: string;
+    category?: string | null;
+    entries?: TableEntry[];
+    rollExpression?: string;
+}): RandomTable | null;
+export declare function deleteTable(id: string): boolean;
+export declare function listTables(gameId: string, category?: string): RandomTable[];
+export declare function rollTable(tableId: string, modifier?: number): TableRollResult | null;
+/**
+ * Modify table entries - add and/or remove entries in a single call.
+ */
+export declare function modifyTableEntries(tableId: string, params: {
+    add?: TableEntry[];
+    remove?: number[];
+}): {
+    table: RandomTable;
+    added: number;
+    removed: number;
+    invalidIndices?: number[];
+} | null;
+export declare function createSimpleTable(gameId: string, name: string, results: string[], category?: string): RandomTable;

package/dist/tools/tables.js

@@ -0,0 +1,209 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase } from "../db/connection.js";
+import { safeJsonParse } from "../utils/json.js";
+import { validateGameExists } from "./game.js";
+import { roll } from "./dice.js";
+export function createTable(params) {
+    // Validate game exists to prevent orphaned records
+    validateGameExists(params.gameId);
+    const db = getDatabase();
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    const entries = params.entries || [];
+    const rollExpression = params.rollExpression || "1d100";
+    db.prepare(`
+    INSERT INTO random_tables (id, game_id, name, description, category, entries, roll_expression, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, params.gameId, params.name, params.description || "", params.category || null, JSON.stringify(entries), rollExpression, now);
+    return {
+        id,
+        gameId: params.gameId,
+        name: params.name,
+        description: params.description || "",
+        category: params.category || null,
+        entries,
+        rollExpression,
+        createdAt: now,
+    };
+}
+export function getTable(id) {
+    const db = getDatabase();
+    const row = db.prepare(`SELECT * FROM random_tables WHERE id = ?`).get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        description: row.description || "",
+        category: row.category,
+        entries: safeJsonParse(row.entries, []),
+        rollExpression: row.roll_expression,
+        createdAt: row.created_at,
+    };
+}
+export function updateTable(id, updates) {
+    const db = getDatabase();
+    const current = getTable(id);
+    if (!current)
+        return null;
+    const newName = updates.name ?? current.name;
+    const newDescription = updates.description ?? current.description;
+    const newCategory = updates.category !== undefined ? updates.category : current.category;
+    const newEntries = updates.entries ?? current.entries;
+    const newRollExpression = updates.rollExpression ?? current.rollExpression;
+    db.prepare(`
+    UPDATE random_tables
+    SET name = ?, description = ?, category = ?, entries = ?, roll_expression = ?
+    WHERE id = ?
+  `).run(newName, newDescription, newCategory, JSON.stringify(newEntries), newRollExpression, id);
+    return {
+        ...current,
+        name: newName,
+        description: newDescription,
+        category: newCategory,
+        entries: newEntries,
+        rollExpression: newRollExpression,
+    };
+}
+export function deleteTable(id) {
+    const db = getDatabase();
+    const result = db.prepare(`DELETE FROM random_tables WHERE id = ?`).run(id);
+    return result.changes > 0;
+}
+export function listTables(gameId, category) {
+    const db = getDatabase();
+    let query = `SELECT * FROM random_tables WHERE game_id = ?`;
+    const params = [gameId];
+    if (category) {
+        query += ` AND category = ?`;
+        params.push(category);
+    }
+    query += ` ORDER BY name`;
+    const rows = db.prepare(query).all(...params);
+    return rows.map(row => ({
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        description: row.description || "",
+        category: row.category,
+        entries: safeJsonParse(row.entries, []),
+        rollExpression: row.roll_expression,
+        createdAt: row.created_at,
+    }));
+}
+export function rollTable(tableId, modifier = 0) {
+    const table = getTable(tableId);
+    if (!table || table.entries.length === 0)
+        return null;
+    const diceRoll = roll(table.rollExpression);
+    const rollTotal = diceRoll.total + modifier;
+    // Find matching entry
+    let matchedEntry = null;
+    for (const entry of table.entries) {
+        if (rollTotal >= entry.minRoll && rollTotal <= entry.maxRoll) {
+            matchedEntry = entry;
+            break;
+        }
+    }
+    // If no range match, try weighted random
+    if (!matchedEntry) {
+        const weightedEntries = table.entries.filter(e => e.weight !== undefined && e.weight > 0);
+        if (weightedEntries.length > 0) {
+            const totalWeight = weightedEntries.reduce((sum, e) => sum + (e.weight || 0), 0);
+            // Use cumulative comparison to avoid floating-point precision issues
+            const target = Math.random() * totalWeight;
+            let cumulative = 0;
+            for (const entry of weightedEntries) {
+                cumulative += entry.weight || 0;
+                if (target < cumulative) {
+                    matchedEntry = entry;
+                    break;
+                }
+            }
+            // Handle edge case where target equals totalWeight due to floating-point
+            if (!matchedEntry && weightedEntries.length > 0) {
+                matchedEntry = weightedEntries[weightedEntries.length - 1];
+            }
+        }
+    }
+    // If still no match, this indicates a table configuration error
+    if (!matchedEntry) {
+        throw new Error(`Table '${table.name}' (${tableId}) has no entry matching roll ${rollTotal} and no weighted entries. Check table configuration.`);
+    }
+    const result = {
+        table,
+        roll: diceRoll,
+        entry: matchedEntry,
+        result: matchedEntry.result,
+    };
+    // Handle subtable
+    if (matchedEntry.subtable) {
+        const subtableResult = rollTable(matchedEntry.subtable, 0);
+        if (subtableResult) {
+            result.subtableResults = [subtableResult];
+        }
+    }
+    return result;
+}
+/**
+ * Modify table entries - add and/or remove entries in a single call.
+ */
+export function modifyTableEntries(tableId, params) {
+    const table = getTable(tableId);
+    if (!table)
+        return null;
+    let entries = [...table.entries];
+    let removedCount = 0;
+    const invalidIndices = [];
+    // Remove entries first (process in reverse order to maintain indices)
+    if (params.remove && params.remove.length > 0) {
+        const uniqueIndices = [...new Set(params.remove)];
+        // Track invalid indices
+        for (const idx of uniqueIndices) {
+            if (idx < 0 || idx >= entries.length) {
+                invalidIndices.push(idx);
+            }
+        }
+        const indicesToRemove = uniqueIndices
+            .filter(i => i >= 0 && i < entries.length)
+            .sort((a, b) => b - a); // Sort descending
+        for (const idx of indicesToRemove) {
+            entries.splice(idx, 1);
+            removedCount++;
+        }
+    }
+    // Add new entries
+    const addedCount = params.add?.length || 0;
+    if (params.add) {
+        entries = [...entries, ...params.add];
+    }
+    const updated = updateTable(tableId, { entries });
+    if (!updated)
+        return null;
+    const result = {
+        table: updated,
+        added: addedCount,
+        removed: removedCount,
+    };
+    if (invalidIndices.length > 0) {
+        result.invalidIndices = invalidIndices;
+    }
+    return result;
+}
+// Helper to create a simple d6 table quickly
+export function createSimpleTable(gameId, name, results, category) {
+    const dieSize = results.length;
+    const entries = results.map((result, i) => ({
+        minRoll: i + 1,
+        maxRoll: i + 1,
+        result,
+    }));
+    return createTable({
+        gameId,
+        name,
+        category,
+        entries,
+        rollExpression: `1d${dieSize}`,
+    });
+}

package/dist/tools/tags.d.ts

@@ -0,0 +1,52 @@
+import type { Tag } from "../types/index.js";
+export declare function addTag(params: {
+    gameId: string;
+    entityId: string;
+    entityType: string;
+    tag: string;
+    color?: string;
+    notes?: string;
+}): Tag;
+export declare function getTag(id: string): Tag | null;
+export declare function removeTag(params: {
+    gameId: string;
+    entityId: string;
+    entityType: string;
+    tag: string;
+}): boolean;
+export interface TagCount {
+    tag: string;
+    count: number;
+    color: string | null;
+}
+export declare function listTags(gameId: string): TagCount[];
+export declare function getEntityTags(entityId: string, entityType: string): Tag[];
+export interface TaggedEntity {
+    entityId: string;
+    entityType: string;
+    tag: Tag;
+}
+export declare function findByTag(gameId: string, tag: string, entityType?: string): TaggedEntity[];
+export declare function renameTag(gameId: string, oldTag: string, newTag: string): number;
+export declare function deleteTagById(id: string): boolean;
+/**
+ * Modify tags on an entity - add and/or remove in a single call.
+ * This consolidated function reduces the number of tool calls needed.
+ */
+export declare function modifyTags(params: {
+    gameId: string;
+    entityId: string;
+    entityType: string;
+    add?: Array<{
+        tag: string;
+        color?: string;
+        notes?: string;
+    }>;
+    remove?: string[];
+}): {
+    entityId: string;
+    entityType: string;
+    tags: string[];
+    added: string[];
+    removed: string[];
+};