run-dmcp 0.1.0

package/dist/tools/tags.js

@@ -0,0 +1,176 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase } from "../db/connection.js";
+export function addTag(params) {
+    const db = getDatabase();
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    // Check if tag already exists (unique constraint)
+    const existing = db.prepare(`
+    SELECT id FROM tags
+    WHERE game_id = ? AND entity_id = ? AND entity_type = ? AND tag = ?
+  `).get(params.gameId, params.entityId, params.entityType, params.tag);
+    if (existing) {
+        // Update existing tag
+        const existingId = existing.id;
+        db.prepare(`
+      UPDATE tags SET color = ?, notes = ? WHERE id = ?
+    `).run(params.color || null, params.notes || "", existingId);
+        const updated = getTag(existingId);
+        if (!updated) {
+            throw new Error(`Failed to retrieve updated tag '${existingId}'`);
+        }
+        return updated;
+    }
+    db.prepare(`
+    INSERT INTO tags (id, game_id, entity_id, entity_type, tag, color, notes, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, params.gameId, params.entityId, params.entityType, params.tag, params.color || null, params.notes || "", now);
+    return {
+        id,
+        gameId: params.gameId,
+        entityId: params.entityId,
+        entityType: params.entityType,
+        tag: params.tag,
+        color: params.color || null,
+        notes: params.notes || "",
+        createdAt: now,
+    };
+}
+export function getTag(id) {
+    const db = getDatabase();
+    const row = db.prepare(`SELECT * FROM tags WHERE id = ?`).get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        entityId: row.entity_id,
+        entityType: row.entity_type,
+        tag: row.tag,
+        color: row.color,
+        notes: row.notes,
+        createdAt: row.created_at,
+    };
+}
+export function removeTag(params) {
+    const db = getDatabase();
+    const result = db.prepare(`
+    DELETE FROM tags
+    WHERE game_id = ? AND entity_id = ? AND entity_type = ? AND tag = ?
+  `).run(params.gameId, params.entityId, params.entityType, params.tag);
+    return result.changes > 0;
+}
+export function listTags(gameId) {
+    const db = getDatabase();
+    const rows = db.prepare(`
+    SELECT tag, color, COUNT(*) as count
+    FROM tags
+    WHERE game_id = ?
+    GROUP BY tag
+    ORDER BY count DESC, tag ASC
+  `).all(gameId);
+    return rows.map(row => ({
+        tag: row.tag,
+        count: row.count,
+        color: row.color,
+    }));
+}
+export function getEntityTags(entityId, entityType) {
+    const db = getDatabase();
+    const rows = db.prepare(`
+    SELECT * FROM tags WHERE entity_id = ? AND entity_type = ?
+    ORDER BY tag
+  `).all(entityId, entityType);
+    return rows.map(row => ({
+        id: row.id,
+        gameId: row.game_id,
+        entityId: row.entity_id,
+        entityType: row.entity_type,
+        tag: row.tag,
+        color: row.color,
+        notes: row.notes,
+        createdAt: row.created_at,
+    }));
+}
+export function findByTag(gameId, tag, entityType) {
+    const db = getDatabase();
+    let query = `SELECT * FROM tags WHERE game_id = ? AND tag = ?`;
+    const params = [gameId, tag];
+    if (entityType) {
+        query += ` AND entity_type = ?`;
+        params.push(entityType);
+    }
+    query += ` ORDER BY entity_type, created_at`;
+    const rows = db.prepare(query).all(...params);
+    return rows.map(row => ({
+        entityId: row.entity_id,
+        entityType: row.entity_type,
+        tag: {
+            id: row.id,
+            gameId: row.game_id,
+            entityId: row.entity_id,
+            entityType: row.entity_type,
+            tag: row.tag,
+            color: row.color,
+            notes: row.notes,
+            createdAt: row.created_at,
+        },
+    }));
+}
+export function renameTag(gameId, oldTag, newTag) {
+    const db = getDatabase();
+    const result = db.prepare(`
+    UPDATE tags SET tag = ? WHERE game_id = ? AND tag = ?
+  `).run(newTag, gameId, oldTag);
+    return result.changes;
+}
+export function deleteTagById(id) {
+    const db = getDatabase();
+    const result = db.prepare(`DELETE FROM tags WHERE id = ?`).run(id);
+    return result.changes > 0;
+}
+/**
+ * Modify tags on an entity - add and/or remove in a single call.
+ * This consolidated function reduces the number of tool calls needed.
+ */
+export function modifyTags(params) {
+    const added = [];
+    const removed = [];
+    // Remove tags first
+    if (params.remove) {
+        for (const tag of params.remove) {
+            const success = removeTag({
+                gameId: params.gameId,
+                entityId: params.entityId,
+                entityType: params.entityType,
+                tag,
+            });
+            if (success) {
+                removed.push(tag);
+            }
+        }
+    }
+    // Add new tags
+    if (params.add) {
+        for (const tagData of params.add) {
+            addTag({
+                gameId: params.gameId,
+                entityId: params.entityId,
+                entityType: params.entityType,
+                tag: tagData.tag,
+                color: tagData.color,
+                notes: tagData.notes,
+            });
+            added.push(tagData.tag);
+        }
+    }
+    // Get final tag list
+    const finalTags = getEntityTags(params.entityId, params.entityType);
+    return {
+        entityId: params.entityId,
+        entityType: params.entityType,
+        tags: finalTags.map(t => t.tag),
+        added,
+        removed,
+    };
+}

package/dist/tools/time.d.ts

@@ -0,0 +1,33 @@
+import type { GameTime, GameDateTime, CalendarConfig, ScheduledEvent, ExpiryConsequence } from "../types/index.js";
+export declare function setCalendar(gameId: string, config: Partial<CalendarConfig>, currentTime?: GameDateTime): GameTime;
+export declare function getTime(gameId: string): GameTime | null;
+export declare function setTime(gameId: string, time: GameDateTime): GameTime | null;
+export interface ConsequenceFailure {
+    eventId: string;
+    eventName: string;
+    consequence: ExpiryConsequence;
+    error: string;
+}
+export interface AdvanceResult {
+    previousTime: GameDateTime;
+    newTime: GameDateTime;
+    triggeredEvents: ScheduledEvent[];
+    consequenceFailures: ConsequenceFailure[];
+}
+export declare function advanceTime(gameId: string, duration: {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+}): AdvanceResult | null;
+export declare function scheduleEvent(params: {
+    gameId: string;
+    name: string;
+    description?: string;
+    triggerTime: GameDateTime;
+    recurring?: string;
+    metadata?: Record<string, unknown>;
+    consequence?: ExpiryConsequence;
+}): ScheduledEvent;
+export declare function listScheduledEvents(gameId: string, includeTriggered?: boolean): ScheduledEvent[];
+export declare function cancelEvent(eventId: string): boolean;
+export declare function formatDateTime(dt: GameDateTime, config: CalendarConfig): string;

package/dist/tools/time.js

@@ -0,0 +1,276 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase, withTransaction } from "../db/connection.js";
+import { safeJsonParse } from "../utils/json.js";
+import { updateResourceValue } from "./resource.js";
+import { createLogger } from "../utils/logger.js";
+const log = createLogger("time");
+function parseConsequence(raw) {
+    if (typeof raw !== "string" || raw.length === 0)
+        return null;
+    return safeJsonParse(raw, null);
+}
+// Default calendar (fantasy-style)
+const DEFAULT_CALENDAR = {
+    monthNames: [
+        "Deepwinter", "Thawing", "Seedtime", "Blossoming", "Highsun", "Summertide",
+        "Harvest", "Leaffall", "Dimming", "Frostfall", "Darknight", "Yearsend"
+    ],
+    daysPerMonth: [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+    hoursPerDay: 24,
+    minutesPerHour: 60,
+    startYear: 1,
+    eraName: "Age of Wonder",
+};
+function dateTimeToMinutes(dt, config) {
+    let totalMinutes = dt.minute;
+    totalMinutes += dt.hour * config.minutesPerHour;
+    totalMinutes += dt.day * config.hoursPerDay * config.minutesPerHour;
+    // Add days from previous months
+    for (let m = 0; m < dt.month; m++) {
+        totalMinutes += config.daysPerMonth[m] * config.hoursPerDay * config.minutesPerHour;
+    }
+    // Add days from previous years
+    const daysPerYear = config.daysPerMonth.reduce((a, b) => a + b, 0);
+    totalMinutes += (dt.year - config.startYear) * daysPerYear * config.hoursPerDay * config.minutesPerHour;
+    return totalMinutes;
+}
+function minutesToDateTime(totalMinutes, config) {
+    const minutesPerHour = config.minutesPerHour;
+    const minutesPerDay = config.hoursPerDay * minutesPerHour;
+    const daysPerYear = config.daysPerMonth.reduce((a, b) => a + b, 0);
+    const minutesPerYear = daysPerYear * minutesPerDay;
+    let remaining = totalMinutes;
+    const year = config.startYear + Math.floor(remaining / minutesPerYear);
+    remaining = remaining % minutesPerYear;
+    let month = 0;
+    for (let m = 0; m < config.daysPerMonth.length; m++) {
+        const monthMinutes = config.daysPerMonth[m] * minutesPerDay;
+        if (remaining < monthMinutes) {
+            month = m;
+            break;
+        }
+        remaining -= monthMinutes;
+    }
+    const day = Math.floor(remaining / minutesPerDay);
+    remaining = remaining % minutesPerDay;
+    const hour = Math.floor(remaining / minutesPerHour);
+    const minute = remaining % minutesPerHour;
+    return { year, month, day, hour, minute };
+}
+function compareDateTime(a, b, config) {
+    return dateTimeToMinutes(a, config) - dateTimeToMinutes(b, config);
+}
+export function setCalendar(gameId, config, currentTime) {
+    const db = getDatabase();
+    const calendarConfig = {
+        ...DEFAULT_CALENDAR,
+        ...config,
+    };
+    const time = currentTime || {
+        year: calendarConfig.startYear,
+        month: 0,
+        day: 0,
+        hour: 8,
+        minute: 0,
+    };
+    // Upsert
+    const existing = db.prepare(`SELECT game_id FROM game_time WHERE game_id = ?`).get(gameId);
+    if (existing) {
+        db.prepare(`UPDATE game_time SET current_time = ?, calendar_config = ? WHERE game_id = ?`)
+            .run(JSON.stringify(time), JSON.stringify(calendarConfig), gameId);
+    }
+    else {
+        db.prepare(`INSERT INTO game_time (game_id, current_time, calendar_config) VALUES (?, ?, ?)`)
+            .run(gameId, JSON.stringify(time), JSON.stringify(calendarConfig));
+    }
+    return { gameId, currentTime: time, calendarConfig };
+}
+export function getTime(gameId) {
+    const db = getDatabase();
+    const row = db.prepare(`SELECT * FROM game_time WHERE game_id = ?`).get(gameId);
+    if (!row)
+        return null;
+    return {
+        gameId: row.game_id,
+        currentTime: safeJsonParse(row.current_time, { year: 1, month: 1, day: 1, hour: 0, minute: 0 }),
+        calendarConfig: safeJsonParse(row.calendar_config, DEFAULT_CALENDAR),
+    };
+}
+export function setTime(gameId, time) {
+    const db = getDatabase();
+    const gameTime = getTime(gameId);
+    if (!gameTime)
+        return null;
+    db.prepare(`UPDATE game_time SET current_time = ? WHERE game_id = ?`)
+        .run(JSON.stringify(time), gameId);
+    return { ...gameTime, currentTime: time };
+}
+export function advanceTime(gameId, duration) {
+    const db = getDatabase();
+    const gameTime = getTime(gameId);
+    if (!gameTime)
+        return null;
+    const { currentTime, calendarConfig } = gameTime;
+    const previousTime = { ...currentTime };
+    // Convert to minutes, add, convert back
+    let totalMinutes = dateTimeToMinutes(currentTime, calendarConfig);
+    totalMinutes += (duration.minutes || 0);
+    totalMinutes += (duration.hours || 0) * calendarConfig.minutesPerHour;
+    totalMinutes += (duration.days || 0) * calendarConfig.hoursPerDay * calendarConfig.minutesPerHour;
+    const newTime = minutesToDateTime(totalMinutes, calendarConfig);
+    // Update time. This happens unconditionally and outside any per-event
+    // transaction below -- the clock is global state, not tied to any one
+    // event's consequence, so a broken consequence on one event must never
+    // block time from moving for everyone else.
+    db.prepare(`UPDATE game_time SET current_time = ? WHERE game_id = ?`)
+        .run(JSON.stringify(newTime), gameId);
+    // Check for triggered events
+    const events = db.prepare(`
+    SELECT * FROM scheduled_events
+    WHERE game_id = ? AND triggered = 0
+  `).all(gameId);
+    const triggeredEvents = [];
+    const consequenceFailures = [];
+    for (const row of events) {
+        const triggerTime = safeJsonParse(row.trigger_time, { year: 1, month: 1, day: 1, hour: 0, minute: 0 });
+        // Check if event should trigger (trigger time is between previous and new time)
+        if (compareDateTime(triggerTime, previousTime, calendarConfig) >= 0 &&
+            compareDateTime(triggerTime, newTime, calendarConfig) <= 0) {
+            const eventId = row.id;
+            const eventName = row.name;
+            const recurring = row.recurring;
+            const consequence = parseConsequence(row.consequence);
+            // Recurring events reschedule instead of being marked triggered=1.
+            const newTrigger = recurring ? rescheduleEvent(triggerTime, recurring, calendarConfig) : null;
+            // The row mutation (triggered=1, or reschedule to the next
+            // occurrence) and the consequence application must land together or
+            // not at all -- otherwise a failed consequence could leave the event
+            // permanently marked "handled" with its effect never applied, and
+            // exactly-once would be broken forever with no way to retry.
+            try {
+                withTransaction(() => {
+                    if (newTrigger) {
+                        db.prepare(`UPDATE scheduled_events SET trigger_time = ? WHERE id = ?`)
+                            .run(JSON.stringify(newTrigger), eventId);
+                    }
+                    else {
+                        db.prepare(`UPDATE scheduled_events SET triggered = 1 WHERE id = ?`)
+                            .run(eventId);
+                    }
+                    if (consequence) {
+                        const applied = updateResourceValue({
+                            resourceId: consequence.resourceId,
+                            mode: "delta",
+                            value: consequence.delta,
+                            reason: `Expiry consequence: ${eventName}`,
+                        });
+                        if (!applied) {
+                            throw new Error(`Resource '${consequence.resourceId}' not found for consequence of scheduled event '${eventName}' (${eventId})`);
+                        }
+                    }
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                log.error("Failed to apply expiry consequence for scheduled event; leaving it pending", {
+                    gameId,
+                    eventId,
+                    eventName,
+                    consequence,
+                    error: message,
+                });
+                if (consequence) {
+                    consequenceFailures.push({ eventId, eventName, consequence, error: message });
+                }
+                // Transaction rolled back: the row is untouched, so the event stays
+                // pending (not triggered, not rescheduled) and is excluded from
+                // triggeredEvents below -- no expired-but-unapplied state.
+                continue;
+            }
+            triggeredEvents.push({
+                id: eventId,
+                gameId: row.game_id,
+                name: eventName,
+                description: row.description || "",
+                triggerTime,
+                recurring,
+                triggered: !newTrigger,
+                metadata: safeJsonParse(row.metadata || "{}", {}),
+                consequence,
+            });
+        }
+    }
+    return { previousTime, newTime, triggeredEvents, consequenceFailures };
+}
+function rescheduleEvent(current, recurring, config) {
+    const minutesPerDay = config.hoursPerDay * config.minutesPerHour;
+    const daysPerYear = config.daysPerMonth.reduce((a, b) => a + b, 0);
+    let minutes = dateTimeToMinutes(current, config);
+    switch (recurring) {
+        case "daily":
+            minutes += minutesPerDay;
+            break;
+        case "weekly":
+            minutes += minutesPerDay * 7;
+            break;
+        case "monthly":
+            minutes += config.daysPerMonth[current.month] * minutesPerDay;
+            break;
+        case "yearly":
+            minutes += daysPerYear * minutesPerDay;
+            break;
+    }
+    return minutesToDateTime(minutes, config);
+}
+export function scheduleEvent(params) {
+    const db = getDatabase();
+    const id = uuidv4();
+    const consequence = params.consequence ?? null;
+    db.prepare(`
+    INSERT INTO scheduled_events (id, game_id, name, description, trigger_time, recurring, metadata, consequence)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, params.gameId, params.name, params.description || "", JSON.stringify(params.triggerTime), params.recurring || null, JSON.stringify(params.metadata || {}), consequence ? JSON.stringify(consequence) : null);
+    return {
+        id,
+        gameId: params.gameId,
+        name: params.name,
+        description: params.description || "",
+        triggerTime: params.triggerTime,
+        recurring: params.recurring || null,
+        triggered: false,
+        metadata: params.metadata || {},
+        consequence,
+    };
+}
+export function listScheduledEvents(gameId, includeTriggered = false) {
+    const db = getDatabase();
+    let query = `SELECT * FROM scheduled_events WHERE game_id = ?`;
+    if (!includeTriggered) {
+        query += ` AND triggered = 0`;
+    }
+    query += ` ORDER BY trigger_time`;
+    const rows = db.prepare(query).all(gameId);
+    return rows.map(row => ({
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        description: row.description || "",
+        triggerTime: safeJsonParse(row.trigger_time, { year: 1, month: 1, day: 1, hour: 0, minute: 0 }),
+        recurring: row.recurring,
+        triggered: row.triggered === 1,
+        metadata: safeJsonParse(row.metadata || "{}", {}),
+        consequence: parseConsequence(row.consequence),
+    }));
+}
+export function cancelEvent(eventId) {
+    const db = getDatabase();
+    const result = db.prepare(`DELETE FROM scheduled_events WHERE id = ?`).run(eventId);
+    return result.changes > 0;
+}
+export function formatDateTime(dt, config) {
+    const monthName = config.monthNames[dt.month] || `Month ${dt.month + 1}`;
+    const hour = dt.hour.toString().padStart(2, "0");
+    const minute = dt.minute.toString().padStart(2, "0");
+    const era = config.eraName ? ` ${config.eraName}` : "";
+    return `${dt.day + 1} ${monthName}, Year ${dt.year}${era} - ${hour}:${minute}`;
+}

package/dist/tools/timers.d.ts

@@ -0,0 +1,41 @@
+import type { Timer, ExpiryConsequence } from "../types/index.js";
+export declare function createTimer(params: {
+    gameId: string;
+    name: string;
+    description?: string;
+    timerType: "countdown" | "stopwatch" | "clock";
+    currentValue?: number;
+    maxValue?: number;
+    direction?: "up" | "down";
+    triggerAt?: number;
+    unit?: string;
+    visibleToPlayers?: boolean;
+    consequence?: ExpiryConsequence;
+}): Timer;
+export declare function getTimer(id: string): Timer | null;
+export declare function updateTimer(id: string, updates: {
+    name?: string;
+    description?: string;
+    maxValue?: number | null;
+    triggerAt?: number | null;
+    unit?: string;
+    visibleToPlayers?: boolean;
+}): Timer | null;
+export declare function deleteTimer(id: string): boolean;
+export declare function listTimers(gameId: string, includeTriggered?: boolean): Timer[];
+export interface TickResult {
+    timer: Timer;
+    previousValue: number;
+    justTriggered: boolean;
+    consequenceApplied: boolean;
+}
+export declare function tickTimer(id: string, amount?: number): TickResult | null;
+export declare function resetTimer(id: string): Timer | null;
+/**
+ * Modify a timer - tick or reset in a single call.
+ * Use mode: "tick" to advance by amount, mode: "reset" to reset to initial state.
+ */
+export declare function modifyTimerState(id: string, params: {
+    mode: "tick" | "reset";
+    amount?: number;
+}): TickResult | null;