run-dmcp 0.3.0 → 0.4.0

package/dist/tools/quest.js

@@ -1,164 +0,0 @@
-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 createQuest(params) {
-    // Validate game exists to prevent orphaned records
-    validateGameExists(params.gameId);
-    const db = getDatabase();
-    const id = uuidv4();
-    const objectives = params.objectives.map((obj) => ({
-        id: uuidv4(),
-        description: obj.description,
-        completed: obj.completed || false,
-        optional: obj.optional,
-    }));
-    const stmt = db.prepare(`
-    INSERT INTO quests (id, game_id, name, description, objectives, status, rewards)
-    VALUES (?, ?, ?, ?, ?, 'active', ?)
-  `);
-    stmt.run(id, params.gameId, params.name, params.description, JSON.stringify(objectives), params.rewards || null);
-    return {
-        id,
-        gameId: params.gameId,
-        name: params.name,
-        description: params.description,
-        objectives,
-        status: "active",
-        rewards: params.rewards,
-    };
-}
-export function getQuest(id) {
-    const db = getDatabase();
-    const stmt = db.prepare(`SELECT * FROM quests WHERE id = ?`);
-    const row = stmt.get(id);
-    if (!row)
-        return null;
-    return {
-        id: row.id,
-        gameId: row.game_id,
-        name: row.name,
-        description: row.description,
-        objectives: safeJsonParse(row.objectives, []),
-        status: row.status,
-        rewards: row.rewards,
-    };
-}
-export function updateQuest(id, updates) {
-    const db = getDatabase();
-    const current = getQuest(id);
-    if (!current)
-        return null;
-    const newName = updates.name ?? current.name;
-    const newDescription = updates.description ?? current.description;
-    const newStatus = updates.status ?? current.status;
-    const newRewards = updates.rewards ?? current.rewards;
-    const stmt = db.prepare(`
-    UPDATE quests SET name = ?, description = ?, status = ?, rewards = ? WHERE id = ?
-  `);
-    stmt.run(newName, newDescription, newStatus, newRewards || null, id);
-    const updated = {
-        ...current,
-        name: newName,
-        description: newDescription,
-        status: newStatus,
-        rewards: newRewards,
-    };
-    // Emit realtime event
-    gameEvents.emit({
-        type: "quest:updated",
-        gameId: current.gameId,
-        entityId: id,
-        entityType: "quest",
-        timestamp: new Date().toISOString(),
-        data: { name: newName, status: newStatus },
-    });
-    return updated;
-}
-/**
- * Modify quest objectives - add new objectives and/or complete existing ones in a single call.
- */
-export function modifyObjectives(questId, params) {
-    const db = getDatabase();
-    const quest = getQuest(questId);
-    if (!quest)
-        return null;
-    const objectives = [...quest.objectives];
-    const added = [];
-    const completed = [];
-    // Complete objectives first
-    if (params.complete) {
-        for (const objectiveId of params.complete) {
-            const idx = objectives.findIndex((o) => o.id === objectiveId);
-            if (idx !== -1 && !objectives[idx].completed) {
-                objectives[idx] = { ...objectives[idx], completed: true };
-                completed.push(objectiveId);
-            }
-        }
-    }
-    // Add new objectives
-    if (params.add) {
-        for (const obj of params.add) {
-            const newObjective = {
-                id: uuidv4(),
-                description: obj.description,
-                completed: false,
-                optional: obj.optional,
-            };
-            objectives.push(newObjective);
-            added.push(newObjective);
-        }
-    }
-    // Check if all required objectives are complete
-    const requiredComplete = objectives
-        .filter((o) => !o.optional)
-        .every((o) => o.completed);
-    const shouldComplete = requiredComplete && quest.status === "active";
-    const newStatus = shouldComplete ? "completed" : quest.status;
-    // Update objectives and status atomically in a single statement
-    const stmt = db.prepare(`UPDATE quests SET objectives = ?, status = ? WHERE id = ?`);
-    stmt.run(JSON.stringify(objectives), newStatus, questId);
-    // Emit event if quest was completed
-    if (shouldComplete) {
-        gameEvents.emit({
-            type: "quest:updated",
-            gameId: quest.gameId,
-            entityId: questId,
-            entityType: "quest",
-            timestamp: new Date().toISOString(),
-            data: { name: quest.name, status: "completed" },
-        });
-    }
-    const finalQuest = { ...quest, objectives, status: newStatus };
-    return { quest: finalQuest, added, completed };
-}
-export function deleteQuest(id) {
-    const db = getDatabase();
-    const stmt = db.prepare(`DELETE FROM quests WHERE id = ?`);
-    const result = stmt.run(id);
-    return result.changes > 0;
-}
-export function listQuests(gameId, filter) {
-    const db = getDatabase();
-    let query = `SELECT * FROM quests WHERE game_id = ?`;
-    const params = [gameId];
-    if (filter?.status) {
-        query += ` AND status = ?`;
-        params.push(filter.status);
-    }
-    const stmt = db.prepare(query);
-    const rows = stmt.all(...params);
-    return rows.map((row) => ({
-        id: row.id,
-        gameId: row.game_id,
-        name: row.name,
-        description: row.description,
-        objectives: safeJsonParse(row.objectives, []),
-        status: row.status,
-        rewards: row.rewards,
-    }));
-}
-export function getActiveQuests(gameId) {
-    return listQuests(gameId, { status: "active" });
-}

package/dist/tools/status.d.ts

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

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

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

@@ -1,209 +0,0 @@
-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}`,
-    });
-}