run-dmcp 0.2.0 → 0.4.0

package/dist/tools/ability.js

@@ -1,238 +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 { getCharacter } from "./character.js";
-export function createAbility(params) {
-    // Validate game exists to prevent orphaned records
-    validateGameExists(params.gameId);
-    const db = getDatabase();
-    const id = uuidv4();
-    const now = new Date().toISOString();
-    const ownerId = params.ownerType === "template" ? null : (params.ownerId || null);
-    db.prepare(`
-    INSERT INTO abilities (id, game_id, owner_id, owner_type, name, description, category, cost, cooldown, effects, requirements, tags, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(id, params.gameId, ownerId, params.ownerType, params.name, params.description || "", params.category || null, JSON.stringify(params.cost || {}), params.cooldown ?? null, JSON.stringify(params.effects || []), JSON.stringify(params.requirements || {}), JSON.stringify(params.tags || []), now);
-    return {
-        id,
-        gameId: params.gameId,
-        ownerId,
-        ownerType: params.ownerType,
-        name: params.name,
-        description: params.description || "",
-        category: params.category || null,
-        cost: params.cost || {},
-        cooldown: params.cooldown ?? null,
-        currentCooldown: 0,
-        effects: params.effects || [],
-        requirements: params.requirements || {},
-        tags: params.tags || [],
-        createdAt: now,
-    };
-}
-export function getAbility(id) {
-    const db = getDatabase();
-    const row = db.prepare(`SELECT * FROM abilities WHERE id = ?`).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,
-        description: row.description,
-        category: row.category,
-        cost: safeJsonParse(row.cost || "{}", {}),
-        cooldown: row.cooldown,
-        currentCooldown: row.current_cooldown,
-        effects: safeJsonParse(row.effects || "[]", []),
-        requirements: safeJsonParse(row.requirements || "{}", {}),
-        tags: safeJsonParse(row.tags || "[]", []),
-        createdAt: row.created_at,
-    };
-}
-export function updateAbility(id, updates) {
-    const db = getDatabase();
-    const current = getAbility(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 newCost = updates.cost ?? current.cost;
-    const newCooldown = updates.cooldown !== undefined ? updates.cooldown : current.cooldown;
-    const newEffects = updates.effects ?? current.effects;
-    const newRequirements = updates.requirements ?? current.requirements;
-    const newTags = updates.tags ?? current.tags;
-    db.prepare(`
-    UPDATE abilities
-    SET name = ?, description = ?, category = ?, cost = ?, cooldown = ?, effects = ?, requirements = ?, tags = ?
-    WHERE id = ?
-  `).run(newName, newDescription, newCategory, JSON.stringify(newCost), newCooldown, JSON.stringify(newEffects), JSON.stringify(newRequirements), JSON.stringify(newTags), id);
-    return {
-        ...current,
-        name: newName,
-        description: newDescription,
-        category: newCategory,
-        cost: newCost,
-        cooldown: newCooldown,
-        effects: newEffects,
-        requirements: newRequirements,
-        tags: newTags,
-    };
-}
-export function deleteAbility(id) {
-    const db = getDatabase();
-    const result = db.prepare(`DELETE FROM abilities WHERE id = ?`).run(id);
-    return result.changes > 0;
-}
-export function listAbilities(gameId, filter) {
-    const db = getDatabase();
-    let query = `SELECT * FROM abilities WHERE game_id = ?`;
-    const params = [gameId];
-    if (filter?.ownerType) {
-        query += ` AND owner_type = ?`;
-        params.push(filter.ownerType);
-    }
-    if (filter?.ownerId) {
-        query += ` AND owner_id = ?`;
-        params.push(filter.ownerId);
-    }
-    if (filter?.category) {
-        query += ` AND category = ?`;
-        params.push(filter.category);
-    }
-    query += ` ORDER BY name`;
-    const rows = db.prepare(query).all(...params);
-    return rows.map(row => ({
-        id: row.id,
-        gameId: row.game_id,
-        ownerId: row.owner_id,
-        ownerType: row.owner_type,
-        name: row.name,
-        description: row.description,
-        category: row.category,
-        cost: safeJsonParse(row.cost || "{}", {}),
-        cooldown: row.cooldown,
-        currentCooldown: row.current_cooldown,
-        effects: safeJsonParse(row.effects || "[]", []),
-        requirements: safeJsonParse(row.requirements || "{}", {}),
-        tags: safeJsonParse(row.tags || "[]", []),
-        createdAt: row.created_at,
-    }));
-}
-export function learnAbility(templateId, characterId) {
-    const db = getDatabase();
-    const template = getAbility(templateId);
-    if (!template || template.ownerType !== "template")
-        return null;
-    // Validate character exists before creating ability
-    const character = getCharacter(characterId);
-    if (!character) {
-        throw new Error(`Character '${characterId}' not found. Cannot learn ability without a valid character.`);
-    }
-    const id = uuidv4();
-    const now = new Date().toISOString();
-    db.prepare(`
-    INSERT INTO abilities (id, game_id, owner_id, owner_type, name, description, category, cost, cooldown, effects, requirements, tags, created_at)
-    VALUES (?, ?, ?, 'character', ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(id, template.gameId, characterId, template.name, template.description, template.category, JSON.stringify(template.cost), template.cooldown, JSON.stringify(template.effects), JSON.stringify(template.requirements), JSON.stringify(template.tags), now);
-    return {
-        id,
-        gameId: template.gameId,
-        ownerId: characterId,
-        ownerType: "character",
-        name: template.name,
-        description: template.description,
-        category: template.category,
-        cost: template.cost,
-        cooldown: template.cooldown,
-        currentCooldown: 0,
-        effects: template.effects,
-        requirements: template.requirements,
-        tags: template.tags,
-        createdAt: now,
-    };
-}
-export function useAbility(abilityId, _characterId) {
-    const db = getDatabase();
-    const ability = getAbility(abilityId);
-    if (!ability) {
-        return { success: false, ability: null, reason: "Ability not found" };
-    }
-    // Check cooldown
-    if (ability.currentCooldown > 0) {
-        return {
-            success: false,
-            ability,
-            reason: `Ability on cooldown (${ability.currentCooldown} rounds remaining)`,
-        };
-    }
-    // Check costs (would need character resources to validate)
-    // For now, we just set the cooldown and return success
-    // In a full implementation, we'd deduct from character resources
-    if (ability.cooldown && ability.cooldown > 0) {
-        db.prepare(`UPDATE abilities SET current_cooldown = ? WHERE id = ?`)
-            .run(ability.cooldown, abilityId);
-    }
-    return {
-        success: true,
-        ability: { ...ability, currentCooldown: ability.cooldown || 0 },
-        costsPaid: ability.cost,
-    };
-}
-export function tickCooldowns(gameId, amount = 1) {
-    const db = getDatabase();
-    // Get all abilities on cooldown
-    const rows = db.prepare(`
-    SELECT * FROM abilities WHERE game_id = ? AND current_cooldown > 0
-  `).all(gameId);
-    const updated = [];
-    for (const row of rows) {
-        const currentCooldown = row.current_cooldown;
-        const newCooldown = Math.max(0, currentCooldown - amount);
-        db.prepare(`UPDATE abilities SET current_cooldown = ? WHERE id = ?`)
-            .run(newCooldown, row.id);
-        updated.push({
-            id: row.id,
-            gameId: row.game_id,
-            ownerId: row.owner_id,
-            ownerType: row.owner_type,
-            name: row.name,
-            description: row.description,
-            category: row.category,
-            cost: safeJsonParse(row.cost || "{}", {}),
-            cooldown: row.cooldown,
-            currentCooldown: newCooldown,
-            effects: safeJsonParse(row.effects || "[]", []),
-            requirements: safeJsonParse(row.requirements || "{}", {}),
-            tags: safeJsonParse(row.tags || "[]", []),
-            createdAt: row.created_at,
-        });
-    }
-    return updated;
-}
-export function checkRequirements(abilityId, characterId) {
-    const ability = getAbility(abilityId);
-    if (!ability)
-        return null;
-    const character = getCharacter(characterId);
-    if (!character)
-        return null;
-    const missing = {};
-    for (const [key, required] of Object.entries(ability.requirements)) {
-        // Check attributes first, then status
-        const actual = character.attributes[key]
-            ?? character.status[key]
-            ?? 0;
-        if (actual < required) {
-            missing[key] = { required, actual };
-        }
-    }
-    return {
-        meetsRequirements: Object.keys(missing).length === 0,
-        missing,
-    };
-}

package/dist/tools/combat.d.ts

@@ -1,13 +0,0 @@
-import type { Combat } from "../types/index.js";
-export declare function startCombat(params: {
-    gameId: string;
-    locationId: string;
-    participantIds: string[];
-}): Combat;
-export declare function getCombat(id: string): Combat | null;
-export declare function getActiveCombat(gameId: string): Combat | null;
-export declare function nextTurn(combatId: string): Combat | null;
-export declare function addCombatLog(combatId: string, entry: string): Combat | null;
-export declare function removeParticipant(combatId: string, characterId: string): Combat | null;
-export declare function endCombat(combatId: string): Combat | null;
-export declare function getCurrentCombatant(combatId: string): string | null;

package/dist/tools/combat.js

@@ -1,195 +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";
-import { getCharacter } from "./character.js";
-import { roll } from "./dice.js";
-import { getRules } from "./rules.js";
-export function startCombat(params) {
-    // Validate game exists to prevent orphaned records
-    validateGameExists(params.gameId);
-    const db = getDatabase();
-    const id = uuidv4();
-    const rules = getRules(params.gameId);
-    // Validate all participants exist before processing (prevents race conditions)
-    const characters = params.participantIds.map((charId) => {
-        const character = getCharacter(charId);
-        if (!character) {
-            throw new Error(`Character '${charId}' not found. Cannot start combat with missing participants.`);
-        }
-        return { charId, character };
-    });
-    // Roll initiative for each validated participant
-    const participants = characters.map(({ charId, character }) => {
-        let initiative = 0;
-        if (rules) {
-            // Simple initiative based on a d20 roll
-            // The DM can configure this in combat rules
-            const initRoll = roll("1d20");
-            // Add dexterity modifier if available
-            const dexMod = character.attributes.dexterity
-                ? Math.floor((character.attributes.dexterity - 10) / 2)
-                : 0;
-            initiative = initRoll.total + dexMod;
-        }
-        else {
-            initiative = roll("1d20").total;
-        }
-        return {
-            characterId: charId,
-            initiative,
-            isActive: true,
-        };
-    });
-    // Sort by initiative (highest first)
-    participants.sort((a, b) => b.initiative - a.initiative);
-    const stmt = db.prepare(`
-    INSERT INTO combats (id, game_id, location_id, participants, current_turn, round, status, log)
-    VALUES (?, ?, ?, ?, 0, 1, 'active', '[]')
-  `);
-    stmt.run(id, params.gameId, params.locationId, JSON.stringify(participants));
-    const combat = {
-        id,
-        gameId: params.gameId,
-        locationId: params.locationId,
-        participants,
-        currentTurn: 0,
-        round: 1,
-        status: "active",
-        log: [],
-    };
-    // Emit realtime event
-    gameEvents.emit({
-        type: "combat:started",
-        gameId: params.gameId,
-        entityId: id,
-        entityType: "combat",
-        timestamp: new Date().toISOString(),
-        data: { participantCount: participants.length },
-    });
-    return combat;
-}
-export function getCombat(id) {
-    const db = getDatabase();
-    const stmt = db.prepare(`SELECT * FROM combats WHERE id = ?`);
-    const row = stmt.get(id);
-    if (!row)
-        return null;
-    return {
-        id: row.id,
-        gameId: row.game_id,
-        locationId: row.location_id,
-        participants: safeJsonParse(row.participants, []),
-        currentTurn: row.current_turn,
-        round: row.round,
-        status: row.status,
-        log: safeJsonParse(row.log, []),
-    };
-}
-export function getActiveCombat(gameId) {
-    const db = getDatabase();
-    const stmt = db.prepare(`SELECT * FROM combats WHERE game_id = ? AND status = 'active' LIMIT 1`);
-    const row = stmt.get(gameId);
-    if (!row)
-        return null;
-    return {
-        id: row.id,
-        gameId: row.game_id,
-        locationId: row.location_id,
-        participants: safeJsonParse(row.participants, []),
-        currentTurn: row.current_turn,
-        round: row.round,
-        status: row.status,
-        log: safeJsonParse(row.log, []),
-    };
-}
-export function nextTurn(combatId) {
-    const combat = getCombat(combatId);
-    if (!combat || combat.status !== "active")
-        return null;
-    const db = getDatabase();
-    // Find next active participant
-    let nextTurn = combat.currentTurn;
-    let round = combat.round;
-    let attempts = 0;
-    const maxAttempts = combat.participants.length;
-    do {
-        nextTurn = (nextTurn + 1) % combat.participants.length;
-        if (nextTurn === 0) {
-            round++;
-        }
-        attempts++;
-    } while (!combat.participants[nextTurn].isActive &&
-        attempts < maxAttempts);
-    // If no active participants, end combat
-    if (attempts >= maxAttempts) {
-        return endCombat(combatId);
-    }
-    const stmt = db.prepare(`
-    UPDATE combats SET current_turn = ?, round = ? WHERE id = ?
-  `);
-    stmt.run(nextTurn, round, combatId);
-    return {
-        ...combat,
-        currentTurn: nextTurn,
-        round,
-    };
-}
-export function addCombatLog(combatId, entry) {
-    const combat = getCombat(combatId);
-    if (!combat)
-        return null;
-    const db = getDatabase();
-    const log = [...combat.log, entry];
-    const stmt = db.prepare(`UPDATE combats SET log = ? WHERE id = ?`);
-    stmt.run(JSON.stringify(log), combatId);
-    return {
-        ...combat,
-        log,
-    };
-}
-export function removeParticipant(combatId, characterId) {
-    const combat = getCombat(combatId);
-    if (!combat)
-        return null;
-    const db = getDatabase();
-    const participants = combat.participants.map((p) => p.characterId === characterId ? { ...p, isActive: false } : p);
-    const stmt = db.prepare(`UPDATE combats SET participants = ? WHERE id = ?`);
-    stmt.run(JSON.stringify(participants), combatId);
-    // Check if combat should end
-    const activeCount = participants.filter((p) => p.isActive).length;
-    if (activeCount <= 1) {
-        return endCombat(combatId);
-    }
-    return {
-        ...combat,
-        participants,
-    };
-}
-export function endCombat(combatId) {
-    const combat = getCombat(combatId);
-    if (!combat)
-        return null;
-    const db = getDatabase();
-    const stmt = db.prepare(`UPDATE combats SET status = 'resolved' WHERE id = ?`);
-    stmt.run(combatId);
-    // Emit realtime event
-    gameEvents.emit({
-        type: "combat:ended",
-        gameId: combat.gameId,
-        entityId: combatId,
-        entityType: "combat",
-        timestamp: new Date().toISOString(),
-    });
-    return {
-        ...combat,
-        status: "resolved",
-    };
-}
-export function getCurrentCombatant(combatId) {
-    const combat = getCombat(combatId);
-    if (!combat || combat.status !== "active")
-        return null;
-    return combat.participants[combat.currentTurn]?.characterId || null;
-}

package/dist/tools/dice.d.ts

@@ -1,23 +0,0 @@
-import type { DiceRoll, CheckResult } from "../types/index.js";
-export declare function roll(expression: string): DiceRoll;
-export declare function check(params: {
-    gameId: string;
-    characterId: string;
-    skill?: string;
-    attribute?: string;
-    difficulty: number;
-    bonusModifier?: number;
-}): CheckResult;
-export declare function contest(params: {
-    gameId: string;
-    attackerId: string;
-    defenderId: string;
-    attackerSkill?: string;
-    defenderSkill?: string;
-    attackerAttribute?: string;
-    defenderAttribute?: string;
-}): {
-    attackerResult: CheckResult;
-    defenderResult: CheckResult;
-    winner: "attacker" | "defender" | "tie";
-};

package/dist/tools/dice.js

@@ -1,111 +0,0 @@
-import { getRules } from "./rules.js";
-import { getCharacter } from "./character.js";
-// Maximum limits to prevent DoS attacks
-const MAX_DICE_COUNT = 100;
-const MAX_DICE_SIDES = 1000;
-// Parse and roll dice expressions like "2d6+3", "1d20-2", "3d8"
-export function roll(expression) {
-    const regex = /^(\d+)?d(\d+)([+-]\d+)?$/i;
-    const match = expression.replace(/\s/g, "").match(regex);
-    if (!match) {
-        throw new Error(`Invalid dice expression: ${expression}. Expected format: NdX+M (e.g., 2d6+3)`);
-    }
-    const count = match[1] ? parseInt(match[1], 10) : 1;
-    const sides = parseInt(match[2], 10);
-    const modifier = match[3] ? parseInt(match[3], 10) : 0;
-    // Validate bounds to prevent DoS
-    if (count < 1 || count > MAX_DICE_COUNT) {
-        throw new Error(`Dice count must be between 1 and ${MAX_DICE_COUNT}, got: ${count}`);
-    }
-    if (sides < 1 || sides > MAX_DICE_SIDES) {
-        throw new Error(`Dice sides must be between 1 and ${MAX_DICE_SIDES}, got: ${sides}`);
-    }
-    const rolls = [];
-    for (let i = 0; i < count; i++) {
-        rolls.push(Math.floor(Math.random() * sides) + 1);
-    }
-    const total = rolls.reduce((sum, r) => sum + r, 0) + modifier;
-    return {
-        expression,
-        rolls,
-        modifier,
-        total,
-    };
-}
-// Perform a skill/ability check using game rules
-export function check(params) {
-    const rules = getRules(params.gameId);
-    if (!rules) {
-        throw new Error(`No rules set for game ${params.gameId}`);
-    }
-    const character = getCharacter(params.characterId);
-    if (!character) {
-        throw new Error(`Character ${params.characterId} not found`);
-    }
-    // Calculate modifier from character stats
-    let modifier = params.bonusModifier || 0;
-    if (params.skill && character.skills[params.skill] !== undefined) {
-        modifier += character.skills[params.skill];
-    }
-    if (params.attribute && character.attributes[params.attribute] !== undefined) {
-        // Common formula: (attribute - 10) / 2, but we'll just add the raw value
-        // The DM agent should configure how modifiers work in the rules
-        modifier += Math.floor((character.attributes[params.attribute] - 10) / 2);
-    }
-    // Roll the base dice
-    const diceRoll = roll(rules.checkMechanics.baseDice);
-    const total = diceRoll.total + modifier;
-    // Determine success
-    const success = total >= params.difficulty;
-    const criticalSuccess = rules.checkMechanics.criticalSuccess !== undefined &&
-        diceRoll.rolls[0] >= rules.checkMechanics.criticalSuccess;
-    const criticalFailure = rules.checkMechanics.criticalFailure !== undefined &&
-        diceRoll.rolls[0] <= rules.checkMechanics.criticalFailure;
-    return {
-        roll: diceRoll,
-        modifier,
-        total,
-        difficulty: params.difficulty,
-        success: criticalFailure ? false : criticalSuccess ? true : success,
-        criticalSuccess,
-        criticalFailure,
-        margin: total - params.difficulty,
-    };
-}
-// Opposed check between two characters
-export function contest(params) {
-    const rules = getRules(params.gameId);
-    if (!rules) {
-        throw new Error(`No rules set for game ${params.gameId}`);
-    }
-    // Both roll against difficulty 0, we compare totals
-    const attackerResult = check({
-        gameId: params.gameId,
-        characterId: params.attackerId,
-        skill: params.attackerSkill,
-        attribute: params.attackerAttribute,
-        difficulty: 0,
-    });
-    const defenderResult = check({
-        gameId: params.gameId,
-        characterId: params.defenderId,
-        skill: params.defenderSkill,
-        attribute: params.defenderAttribute,
-        difficulty: 0,
-    });
-    let winner;
-    if (attackerResult.total > defenderResult.total) {
-        winner = "attacker";
-    }
-    else if (defenderResult.total > attackerResult.total) {
-        winner = "defender";
-    }
-    else {
-        winner = "tie";
-    }
-    return {
-        attackerResult,
-        defenderResult,
-        winner,
-    };
-}

package/dist/tools/quest.d.ts

@@ -1,34 +0,0 @@
-import type { Quest, QuestObjective } from "../types/index.js";
-export declare function createQuest(params: {
-    gameId: string;
-    name: string;
-    description: string;
-    objectives: Omit<QuestObjective, "id">[];
-    rewards?: string;
-}): Quest;
-export declare function getQuest(id: string): Quest | null;
-export declare function updateQuest(id: string, updates: {
-    name?: string;
-    description?: string;
-    status?: Quest["status"];
-    rewards?: string;
-}): Quest | null;
-/**
- * Modify quest objectives - add new objectives and/or complete existing ones in a single call.
- */
-export declare function modifyObjectives(questId: string, params: {
-    add?: Array<{
-        description: string;
-        optional?: boolean;
-    }>;
-    complete?: string[];
-}): {
-    quest: Quest;
-    added: QuestObjective[];
-    completed: string[];
-} | null;
-export declare function deleteQuest(id: string): boolean;
-export declare function listQuests(gameId: string, filter?: {
-    status?: Quest["status"];
-}): Quest[];
-export declare function getActiveQuests(gameId: string): Quest[];