run-dmcp 0.1.0

package/dist/schemas/index.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+// Reusable Zod schemas for image generation
+export const subjectDescriptionSchema = z.object({
+    type: z.enum(["character", "location", "item", "scene"]),
+    primaryDescription: z.string(),
+    physicalTraits: z.object({
+        age: z.string().optional(),
+        gender: z.string().optional(),
+        bodyType: z.string().optional(),
+        height: z.string().optional(),
+        skinTone: z.string().optional(),
+        hairColor: z.string().optional(),
+        hairStyle: z.string().optional(),
+        eyeColor: z.string().optional(),
+        facialFeatures: z.string().optional(),
+        distinguishingMarks: z.array(z.string()).optional(),
+    }).optional(),
+    attire: z.object({
+        description: z.string(),
+        colors: z.array(z.string()).optional(),
+        materials: z.array(z.string()).optional(),
+        accessories: z.array(z.string()).optional(),
+    }).optional(),
+    environment: z.object({
+        setting: z.string(),
+        timeOfDay: z.string().optional(),
+        weather: z.string().optional(),
+        lighting: z.string().optional(),
+        architecture: z.string().optional(),
+        vegetation: z.string().optional(),
+        notableFeatures: z.array(z.string()).optional(),
+    }).optional(),
+    objectDetails: z.object({
+        material: z.string().optional(),
+        size: z.string().optional(),
+        condition: z.string().optional(),
+        glowOrEffects: z.string().optional(),
+    }).optional(),
+    pose: z.string().optional(),
+    expression: z.string().optional(),
+    action: z.string().optional(),
+});
+export const styleDescriptionSchema = z.object({
+    artisticStyle: z.string(),
+    genre: z.string(),
+    mood: z.string(),
+    colorScheme: z.string().optional(),
+    influences: z.array(z.string()).optional(),
+    qualityTags: z.array(z.string()).optional(),
+    negativeElements: z.array(z.string()).optional(),
+});
+export const compositionDescriptionSchema = z.object({
+    framing: z.string(),
+    cameraAngle: z.string().optional(),
+    aspectRatio: z.string().optional(),
+    focusPoint: z.string().optional(),
+    background: z.string().optional(),
+    depth: z.string().optional(),
+});
+export const comfyUIPromptSchema = z.object({
+    positive: z.string(),
+    negative: z.string(),
+    checkpoint: z.string().optional(),
+    loras: z.array(z.object({
+        name: z.string(),
+        weight: z.number(),
+    })).optional(),
+    samplerSettings: z.object({
+        sampler: z.string().optional(),
+        scheduler: z.string().optional(),
+        steps: z.number().optional(),
+        cfg: z.number().optional(),
+    }).optional(),
+});
+export const generatedImageSchema = z.object({
+    id: z.string(),
+    tool: z.string(),
+    prompt: z.string(),
+    url: z.string().optional(),
+    base64: z.string().optional(),
+    seed: z.number().optional(),
+    timestamp: z.string(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+export const imageGenSchema = z.object({
+    subject: subjectDescriptionSchema,
+    style: styleDescriptionSchema,
+    composition: compositionDescriptionSchema,
+    prompts: z.object({
+        generic: z.string().optional(),
+        sdxl: z.string().optional(),
+        dalle: z.string().optional(),
+        midjourney: z.string().optional(),
+        flux: z.string().optional(),
+        comfyui: comfyUIPromptSchema.optional(),
+    }).optional(),
+    generations: z.array(generatedImageSchema).optional(),
+    consistency: z.object({
+        characterRef: z.string().optional(),
+        seedImage: z.string().optional(),
+        colorPalette: z.array(z.string()).optional(),
+        styleRef: z.string().optional(),
+    }).optional(),
+}).describe("Image generation metadata for visual representation");
+// Voice schema for characters
+export const voiceSchema = z.object({
+    pitch: z.enum(["very_low", "low", "medium", "high", "very_high"]).describe("Voice pitch"),
+    speed: z.enum(["very_slow", "slow", "medium", "fast", "very_fast"]).describe("Speaking speed"),
+    tone: z.string().describe("Voice tone (e.g., 'gravelly', 'melodic', 'nasal', 'breathy')"),
+    accent: z.string().optional().describe("Accent (e.g., 'Scottish', 'French', 'Brooklyn')"),
+    quirks: z.array(z.string()).optional().describe("Speech quirks (e.g., 'stutters when nervous')"),
+    description: z.string().optional().describe("Free-form voice description for more nuance"),
+});
+// Random table entry schema
+export const tableEntrySchema = z.object({
+    minRoll: z.number().optional().describe("Minimum roll to get this result (for ranged tables)"),
+    maxRoll: z.number().optional().describe("Maximum roll for this result"),
+    weight: z.number().optional().describe("Weight for weighted random selection"),
+    result: z.string().describe("The result text"),
+    effects: z.record(z.unknown()).optional().describe("Optional structured effects"),
+});

package/dist/test-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test-setup.js

@@ -0,0 +1,13 @@
+// Vitest setupFiles entry (see vitest.config.ts): a process-wide safety net
+// guaranteeing no test can ever open the real on-disk database.
+//
+// `getDatabase()` resolves DMCP_DB_PATH lazily, so the per-test fixture in
+// src/db/__tests__/testDb.ts is normally sufficient. This exists for the
+// cases the fixture cannot cover -- a `getDatabase()` reached at module scope,
+// or from code a test imports before its own `beforeEach` runs. A setupFiles
+// module is imported before the test file itself, so this lands first.
+//
+// Nothing should ever `delete` this env var mid-run; doing so re-opens the
+// hole for every subsequent test.
+process.env.DMCP_DB_PATH = ":memory:";
+export {};

package/dist/tools/__tests__/audio.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/__tests__/audio.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { v4 as uuidv4 } from 'uuid';
+import { createTestDb, destroyTestDb } from '../../db/__tests__/testDb.js';
+import { getDatabase } from '../../db/connection.js';
+import { createGame } from '../game.js';
+import { createCharacter } from '../character.js';
+import { getAudio, setPrimaryAudio } from '../audio.js';
+// Inserts a stored_audio row directly via SQL so these tests can exercise
+// setPrimaryAudio() without going through storeAudio()'s file I/O / network
+// fetch, which is unrelated to the atomicity behavior under test here.
+function insertStoredAudio(params) {
+    const db = getDatabase();
+    const id = uuidv4();
+    db.prepare(`
+    INSERT INTO stored_audio (id, game_id, entity_id, entity_type, file_path, file_size, mime_type, source, is_primary, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, params.gameId, params.entityId, params.entityType, `${id}.mp3`, 100, 'audio/mpeg', 'uploaded', params.isPrimary ? 1 : 0, new Date().toISOString());
+    return id;
+}
+describe('setPrimaryAudio', () => {
+    let gameId;
+    let characterId;
+    beforeEach(() => {
+        createTestDb();
+        gameId = createGame({ name: 'Test Game', setting: 'Test Setting', style: 'Test Style' }).id;
+        characterId = createCharacter({ gameId, name: 'Narrator', isPlayer: false }).id;
+    });
+    afterEach(() => {
+        destroyTestDb();
+    });
+    it('unsets the previous primary and sets the new one', () => {
+        const first = insertStoredAudio({ gameId, entityId: characterId, entityType: 'character', isPrimary: true });
+        const second = insertStoredAudio({ gameId, entityId: characterId, entityType: 'character', isPrimary: false });
+        setPrimaryAudio(second);
+        expect(getAudio(first)?.isPrimary).toBe(false);
+        expect(getAudio(second)?.isPrimary).toBe(true);
+    });
+    it('leaves NO partial write when the second update fails mid-operation: the old primary stays primary', () => {
+        const first = insertStoredAudio({ gameId, entityId: characterId, entityType: 'character', isPrimary: true });
+        const second = insertStoredAudio({ gameId, entityId: characterId, entityType: 'character', isPrimary: false });
+        // Fault injection: make the UPDATE that sets `second` as primary fail,
+        // simulating a mid-operation failure between the unset and the set.
+        const db = getDatabase();
+        db.exec(`
+      CREATE TRIGGER fail_set_new_primary_audio
+      BEFORE UPDATE ON stored_audio
+      WHEN NEW.id = '${second}' AND NEW.is_primary = 1
+      BEGIN
+        SELECT RAISE(ABORT, 'simulated failure');
+      END;
+    `);
+        expect(() => setPrimaryAudio(second)).toThrow();
+        // Without a real transaction, the first UPDATE (unsetting `first`)
+        // would have already committed, leaving NO primary at all. With a
+        // transaction, `first` must still be primary.
+        expect(getAudio(first)?.isPrimary).toBe(true);
+        expect(getAudio(second)?.isPrimary).toBe(false);
+    });
+});

package/dist/tools/__tests__/conserved.test.d.ts

@@ -0,0 +1 @@
+export {};