eventmodeler 0.2.5 → 0.2.6

package/dist/index.js

@@ -35,6 +35,7 @@ import { createStateChangeSlice } from './slices/create-state-change-slice/index
 import { createAutomationSlice } from './slices/create-automation-slice/index.js';
 import { createStateViewSlice } from './slices/create-state-view-slice/index.js';
 import { createFlow } from './slices/create-flow/index.js';
+import { codegenSlice } from './slices/codegen-slice/index.js';
 const args = process.argv.slice(2);
 function getNamedArg(argList, ...names) {
     for (let i = 0; i < argList.length; i++) {
@@ -94,12 +95,14 @@ COMMANDS:
   create state-change-slice --xml <data>
                                  Create a state-change slice (Screen → Command → Event)
   create automation-slice --xml <data>
-                                 Create an automation slice (Processor → Command → Event)
+                                 Create an automation slice (ReadModel → Processor → Command → Event)
   create state-view-slice --xml <data>
                                  Create a state-view slice (Read Model)
   create flow --from <source> --to <target>
                                  Create a flow between elements (Event→ReadModel, ReadModel→Screen/Processor)
 
+  codegen slice <name>           Generate code-ready JSON for a slice (includes dependencies, mappings, scenarios)
+
   summary                        Show model summary statistics
 
   export json                    Export entire model as JSON
@@ -476,6 +479,24 @@ async function main() {
                     process.exit(1);
             }
             break;
+        case 'codegen':
+            switch (subcommand) {
+                case 'slice': {
+                    const sliceName = filteredArgs[2];
+                    if (!sliceName) {
+                        console.error('Error: slice name is required');
+                        console.error('Usage: eventmodeler codegen slice <name>');
+                        process.exit(1);
+                    }
+                    codegenSlice(model, sliceName);
+                    break;
+                }
+                default:
+                    console.error(`Unknown codegen target: ${subcommand}`);
+                    console.error('Valid targets: slice');
+                    process.exit(1);
+            }
+            break;
         default:
             console.error(`Unknown command: ${command}`);
             printHelp();

package/dist/lib/slice-utils.d.ts

@@ -24,6 +24,12 @@ export declare const STATE_CHANGE_SLICE: {
 export declare const AUTOMATION_SLICE: {
     width: number;
     height: number;
+    readModel: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
     processor: {
         width: number;
         height: number;

package/dist/lib/slice-utils.js

@@ -7,11 +7,12 @@ export const STATE_CHANGE_SLICE = {
     event: { width: 160, height: 100, offsetX: 360, offsetY: 860 },
 };
 export const AUTOMATION_SLICE = {
-    width: 560,
+    width: 880,
     height: 1000,
-    processor: { width: 120, height: 120, offsetX: 40, offsetY: 120 },
-    command: { width: 160, height: 100, offsetX: 180, offsetY: 460 },
-    event: { width: 160, height: 100, offsetX: 360, offsetY: 860 },
+    readModel: { width: 160, height: 100, offsetX: 40, offsetY: 460 },
+    processor: { width: 120, height: 120, offsetX: 280, offsetY: 120 },
+    command: { width: 160, height: 100, offsetX: 440, offsetY: 460 },
+    event: { width: 160, height: 100, offsetX: 680, offsetY: 860 },
 };
 export const STATE_VIEW_SLICE = {
     width: 380,

package/dist/slices/codegen-slice/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function codegenSlice(model: EventModel, sliceName: string): void;

package/dist/slices/codegen-slice/index.js

@@ -0,0 +1,384 @@
+import { outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
+// Get components inside a slice by checking if center point is within bounds
+function getSliceComponents(model, slice) {
+    const bounds = {
+        left: slice.position.x,
+        right: slice.position.x + slice.size.width,
+        top: slice.position.y,
+        bottom: slice.position.y + slice.size.height,
+    };
+    function isInSlice(pos, width, height) {
+        const centerX = pos.x + width / 2;
+        const centerY = pos.y + height / 2;
+        return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
+    }
+    return {
+        commands: [...model.commands.values()].filter(c => isInSlice(c.position, c.width, c.height)),
+        events: [...model.events.values()].filter(e => isInSlice(e.position, e.width, e.height)),
+        readModels: [...model.readModels.values()].filter(rm => isInSlice(rm.position, rm.width, rm.height)),
+        screens: [...model.screens.values()].filter(s => isInSlice(s.position, s.width, s.height)),
+        processors: [...model.processors.values()].filter(p => isInSlice(p.position, p.width, p.height)),
+    };
+}
+// Find which slice contains a node
+function findSliceForNode(model, nodeId) {
+    const event = model.events.get(nodeId);
+    const readModel = model.readModels.get(nodeId);
+    const screen = model.screens.get(nodeId);
+    const command = model.commands.get(nodeId);
+    const processor = model.processors.get(nodeId);
+    const node = event ?? readModel ?? screen ?? command ?? processor;
+    if (!node)
+        return null;
+    for (const slice of model.slices.values()) {
+        const centerX = node.position.x + node.width / 2;
+        const centerY = node.position.y + node.height / 2;
+        if (centerX >= slice.position.x &&
+            centerX <= slice.position.x + slice.size.width &&
+            centerY >= slice.position.y &&
+            centerY <= slice.position.y + slice.size.height) {
+            return slice;
+        }
+    }
+    return null;
+}
+// Find which aggregate an event belongs to
+function findAggregateForEvent(model, event) {
+    const centerX = event.position.x + event.width / 2;
+    const centerY = event.position.y + event.height / 2;
+    for (const aggregate of model.aggregates.values()) {
+        if (centerX >= aggregate.position.x &&
+            centerX <= aggregate.position.x + aggregate.size.width &&
+            centerY >= aggregate.position.y &&
+            centerY <= aggregate.position.y + aggregate.size.height) {
+            return aggregate.name;
+        }
+    }
+    return undefined;
+}
+// Find which actor a screen belongs to
+function findActorForScreen(model, screen) {
+    const centerX = screen.position.x + screen.width / 2;
+    const centerY = screen.position.y + screen.height / 2;
+    for (const actor of model.actors.values()) {
+        if (centerX >= actor.position.x &&
+            centerX <= actor.position.x + actor.size.width &&
+            centerY >= actor.position.y &&
+            centerY <= actor.position.y + actor.size.height) {
+            return actor.name;
+        }
+    }
+    return undefined;
+}
+// Convert Field to JSON-friendly format
+function fieldToJson(field) {
+    const result = {
+        name: field.name,
+        type: field.fieldType,
+    };
+    if (field.isList)
+        result.list = true;
+    if (field.isGenerated)
+        result.generated = true;
+    if (field.isOptional)
+        result.optional = true;
+    if (field.isUserInput)
+        result.userInput = true;
+    if (field.subfields && field.subfields.length > 0) {
+        result.subfields = field.subfields.map(fieldToJson);
+    }
+    return result;
+}
+// Determine slice type based on components, returns null for invalid configurations
+function determineSliceType(hasProcessors, hasCommands, hasEvents, hasReadModels, hasScreens) {
+    // AUTOMATION: Must have a Processor (and typically ReadModel, Command, Event)
+    if (hasProcessors)
+        return 'AUTOMATION';
+    // STATE_CHANGE: Must have both Command and Event (typically with Screen)
+    if (hasCommands && hasEvents)
+        return 'STATE_CHANGE';
+    // STATE_VIEW: Must have at least one ReadModel
+    if (hasReadModels && !hasCommands && !hasEvents)
+        return 'STATE_VIEW';
+    // Invalid configurations:
+    // - Empty slice
+    // - Only Command (no Event)
+    // - Only Event (no Command)
+    // - Only Screen (no Command)
+    return null;
+}
+// Get element type for an ID
+function getElementType(model, id) {
+    if (model.commands.has(id))
+        return 'COMMAND';
+    if (model.events.has(id))
+        return 'EVENT';
+    if (model.readModels.has(id))
+        return 'READMODEL';
+    if (model.screens.has(id))
+        return 'SCREEN';
+    if (model.processors.has(id))
+        return 'PROCESSOR';
+    return null;
+}
+// Get element name for an ID
+function getElementName(model, id) {
+    return (model.commands.get(id)?.name ??
+        model.events.get(id)?.name ??
+        model.readModels.get(id)?.name ??
+        model.screens.get(id)?.name ??
+        model.processors.get(id)?.name ??
+        'Unknown');
+}
+// Get element fields for an ID
+function getElementFields(model, id) {
+    return (model.commands.get(id)?.fields ??
+        model.events.get(id)?.fields ??
+        model.readModels.get(id)?.fields ??
+        model.screens.get(id)?.fields ??
+        model.processors.get(id)?.fields ??
+        []);
+}
+// Find a field by ID within an element's fields
+function findFieldById(fields, fieldId) {
+    for (const field of fields) {
+        if (field.id === fieldId)
+            return field;
+        if (field.subfields) {
+            const found = findFieldById(field.subfields, fieldId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+// Get element reference (type, id, name)
+function getElementRef(model, id) {
+    return {
+        type: getElementType(model, id) ?? 'EVENT',
+        id,
+        name: getElementName(model, id),
+    };
+}
+// Get element with full schema
+function getElementWithSchema(model, id) {
+    const type = getElementType(model, id) ?? 'EVENT';
+    const name = getElementName(model, id);
+    const fields = getElementFields(model, id).map(fieldToJson);
+    const result = { type, id, name, fields };
+    // Add aggregate info for events
+    const event = model.events.get(id);
+    if (event) {
+        const aggregate = findAggregateForEvent(model, event);
+        if (aggregate)
+            result.aggregate = aggregate;
+        const originSlice = findSliceForNode(model, id);
+        if (originSlice)
+            result.originSlice = originSlice.name;
+    }
+    // Add actor info for screens
+    const screen = model.screens.get(id);
+    if (screen) {
+        const actor = findActorForScreen(model, screen);
+        if (actor)
+            result.actor = actor;
+    }
+    return result;
+}
+// Enrich field mappings with field names
+function enrichFieldMappings(model, flow) {
+    const sourceFields = getElementFields(model, flow.sourceId);
+    const targetFields = getElementFields(model, flow.targetId);
+    return flow.fieldMappings.map(mapping => {
+        const sourceField = findFieldById(sourceFields, mapping.sourceFieldId);
+        const targetField = findFieldById(targetFields, mapping.targetFieldId);
+        return {
+            sourceFieldId: mapping.sourceFieldId,
+            sourceFieldName: sourceField?.name ?? 'unknown',
+            targetFieldId: mapping.targetFieldId,
+            targetFieldName: targetField?.name ?? 'unknown',
+        };
+    });
+}
+// Get inbound dependencies (flows where target is in slice but source is not)
+function getInboundDependencies(model, componentIds) {
+    return [...model.flows.values()]
+        .filter(f => componentIds.has(f.targetId) && !componentIds.has(f.sourceId))
+        .map(flow => ({
+        flowId: flow.id,
+        flowType: flow.flowType,
+        source: getElementWithSchema(model, flow.sourceId),
+        target: getElementRef(model, flow.targetId),
+        fieldMappings: enrichFieldMappings(model, flow),
+    }));
+}
+// Get internal flows (both source and target are in slice)
+function getInternalFlows(model, componentIds) {
+    return [...model.flows.values()]
+        .filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId))
+        .map(flow => ({
+        flowId: flow.id,
+        flowType: flow.flowType,
+        source: getElementRef(model, flow.sourceId),
+        target: getElementRef(model, flow.targetId),
+        fieldMappings: enrichFieldMappings(model, flow),
+    }));
+}
+// Format scenario then clause
+function formatScenarioThen(model, then) {
+    if (then.type === 'error') {
+        return {
+            type: 'error',
+            errorType: then.errorType,
+            errorMessage: then.errorMessage,
+        };
+    }
+    if (then.type === 'events' && then.expectedEvents) {
+        return {
+            type: 'events',
+            expectedEvents: then.expectedEvents.map(expected => {
+                const event = model.events.get(expected.eventStickyId);
+                return {
+                    eventId: expected.eventStickyId,
+                    eventName: event?.name ?? 'UnknownEvent',
+                    eventSchema: { fields: event?.fields.map(fieldToJson) ?? [] },
+                    fieldValues: expected.fieldValues ?? {},
+                };
+            }),
+        };
+    }
+    if (then.type === 'readModelAssertion' && then.readModelAssertion) {
+        const rm = model.readModels.get(then.readModelAssertion.readModelStickyId);
+        return {
+            type: 'readModelAssertion',
+            readModelName: rm?.name ?? 'UnknownReadModel',
+            expectedFieldValues: then.readModelAssertion.expectedFieldValues,
+        };
+    }
+    // Default fallback
+    return { type: 'events', expectedEvents: [] };
+}
+// Format scenarios with resolved schemas
+function formatScenarios(model, scenarios) {
+    return scenarios.map(scenario => ({
+        id: scenario.id,
+        name: scenario.name,
+        description: scenario.description,
+        given: scenario.givenEvents.map(ref => {
+            const event = model.events.get(ref.eventStickyId);
+            const originSlice = findSliceForNode(model, ref.eventStickyId);
+            return {
+                eventId: ref.eventStickyId,
+                eventName: event?.name ?? 'UnknownEvent',
+                originSlice: originSlice?.name ?? null,
+                eventSchema: { fields: event?.fields.map(fieldToJson) ?? [] },
+                fieldValues: ref.fieldValues ?? {},
+            };
+        }),
+        when: scenario.whenCommand
+            ? {
+                commandId: scenario.whenCommand.commandStickyId,
+                commandName: model.commands.get(scenario.whenCommand.commandStickyId)?.name ?? 'UnknownCommand',
+                fieldValues: scenario.whenCommand.fieldValues ?? {},
+            }
+            : null,
+        then: formatScenarioThen(model, scenario.then),
+    }));
+}
+export function codegenSlice(model, sliceName) {
+    // 1. Find the slice
+    const slice = findElementOrExit(model.slices, sliceName, 'slice');
+    // 2. Get components inside slice
+    const components = getSliceComponents(model, slice);
+    // 3. Build component ID set
+    const componentIds = new Set();
+    components.commands.forEach(c => componentIds.add(c.id));
+    components.events.forEach(e => componentIds.add(e.id));
+    components.readModels.forEach(rm => componentIds.add(rm.id));
+    components.screens.forEach(s => componentIds.add(s.id));
+    components.processors.forEach(p => componentIds.add(p.id));
+    // 4. Determine slice type
+    const sliceType = determineSliceType(components.processors.length > 0, components.commands.length > 0, components.events.length > 0, components.readModels.length > 0, components.screens.length > 0);
+    // Validate slice type - exit with error for invalid configurations
+    if (sliceType === null) {
+        const hasAny = componentIds.size > 0;
+        if (!hasAny) {
+            console.error(`Error: Slice "${slice.name}" is empty - no elements found inside slice bounds`);
+        }
+        else {
+            const parts = [];
+            if (components.commands.length > 0)
+                parts.push(`${components.commands.length} command(s)`);
+            if (components.events.length > 0)
+                parts.push(`${components.events.length} event(s)`);
+            if (components.screens.length > 0)
+                parts.push(`${components.screens.length} screen(s)`);
+            if (components.readModels.length > 0)
+                parts.push(`${components.readModels.length} read model(s)`);
+            console.error(`Error: Slice "${slice.name}" has invalid configuration for codegen: ${parts.join(', ')}`);
+            console.error('Valid configurations:');
+            console.error('  AUTOMATION:   Processor + ReadModel + Command + Event');
+            console.error('  STATE_CHANGE: Screen + Command + Event');
+            console.error('  STATE_VIEW:   ReadModel only');
+        }
+        process.exit(1);
+    }
+    // 5. Get inbound dependencies with full schemas
+    const inboundDependencies = getInboundDependencies(model, componentIds);
+    // 6. Get internal flows with field mappings
+    const internalFlows = getInternalFlows(model, componentIds);
+    // 7. Get scenarios for this slice
+    const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
+    // 8. Build output
+    const output = {
+        sliceType,
+        slice: {
+            id: slice.id,
+            name: slice.name,
+        },
+        elements: {
+            readModels: components.readModels.map(rm => ({
+                id: rm.id,
+                name: rm.name,
+                fields: rm.fields.map(fieldToJson),
+            })),
+            processors: components.processors.map(p => ({
+                id: p.id,
+                name: p.name,
+            })),
+            commands: components.commands.map(cmd => ({
+                id: cmd.id,
+                name: cmd.name,
+                fields: cmd.fields.map(fieldToJson),
+            })),
+            events: components.events.map(evt => {
+                const result = {
+                    id: evt.id,
+                    name: evt.name,
+                    fields: evt.fields.map(fieldToJson),
+                };
+                const aggregate = findAggregateForEvent(model, evt);
+                if (aggregate)
+                    result.aggregate = aggregate;
+                return result;
+            }),
+            screens: components.screens.map(scr => {
+                const result = {
+                    id: scr.id,
+                    name: scr.name,
+                    fields: scr.fields.map(fieldToJson),
+                };
+                const actor = findActorForScreen(model, scr);
+                if (actor)
+                    result.actor = actor;
+                return result;
+            }),
+        },
+        inboundDependencies,
+        internalFlows,
+        scenarios: formatScenarios(model, scenarios),
+    };
+    // 9. Output JSON
+    outputJson(output);
+}

package/dist/slices/create-automation-slice/index.js

@@ -16,6 +16,16 @@ function parseXmlInput(xml) {
     }
     const after = getAttr(sliceMatch[1], 'after');
     const before = getAttr(sliceMatch[1], 'before');
+    // Parse read-model
+    const readModelMatch = xml.match(/<read-model([^>]*)>([\s\S]*?)<\/read-model>/);
+    if (!readModelMatch) {
+        throw new Error('Invalid XML: missing <read-model> element');
+    }
+    const readModelName = getAttr(readModelMatch[1], 'name');
+    if (!readModelName) {
+        throw new Error('Invalid XML: read-model must have a name attribute');
+    }
+    const readModelFields = parseFieldsFromXml(readModelMatch[2]);
     // Parse processor (no fields)
     const processorMatch = xml.match(/<processor([^>]*?)(?:\/>|>([\s\S]*?)<\/processor>)/);
     if (!processorMatch) {
@@ -49,6 +59,7 @@ function parseXmlInput(xml) {
         sliceName,
         after,
         before,
+        readModel: { name: readModelName, fields: readModelFields },
         processor: { name: processorName },
         command: { name: commandName, fields: commandFields },
         event: { name: eventName, fields: eventFields },
@@ -99,17 +110,25 @@ export function createAutomationSlice(model, filePath, xmlInput) {
     }
     // Generate IDs
     const sliceId = crypto.randomUUID();
+    const readModelId = crypto.randomUUID();
     const processorId = crypto.randomUUID();
     const commandId = crypto.randomUUID();
     const eventId = crypto.randomUUID();
+    const readModelToProcessorFlowId = crypto.randomUUID();
     const processorToCommandFlowId = crypto.randomUUID();
     const commandToEventFlowId = crypto.randomUUID();
     // Convert field inputs to fields with IDs
+    const readModelFields = input.readModel.fields.map(fieldInputToField);
     const commandFields = input.command.fields.map(fieldInputToField);
     const eventFields = input.event.fields.map(fieldInputToField);
-    // Infer field mappings (processor has no fields, so only command->event)
+    // Infer field mappings
+    const readModelToCommandMappings = inferFieldMappings(readModelFields, commandFields);
     const commandToEventMappings = inferFieldMappings(commandFields, eventFields);
     // Calculate absolute positions for components within the slice
+    const readModelPosition = {
+        x: slicePosition.x + AUTOMATION_SLICE.readModel.offsetX,
+        y: slicePosition.y + AUTOMATION_SLICE.readModel.offsetY,
+    };
     const processorPosition = {
         x: slicePosition.x + AUTOMATION_SLICE.processor.offsetX,
         y: slicePosition.y + AUTOMATION_SLICE.processor.offsetY,
@@ -132,7 +151,26 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         size: { width: AUTOMATION_SLICE.width, height: AUTOMATION_SLICE.height },
         timestamp: Date.now(),
     });
-    // 2. Create the processor
+    // 2. Create the read model
+    appendEvent(filePath, {
+        type: 'ReadModelStickyPlaced',
+        readModelStickyId: readModelId,
+        name: input.readModel.name,
+        position: readModelPosition,
+        width: AUTOMATION_SLICE.readModel.width,
+        height: AUTOMATION_SLICE.readModel.height,
+        timestamp: Date.now(),
+    });
+    // 3. Add read model fields
+    for (const field of readModelFields) {
+        appendEvent(filePath, {
+            type: 'ReadModelFieldAdded',
+            readModelStickyId: readModelId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 4. Create the processor
     appendEvent(filePath, {
         type: 'ProcessorPlaced',
         processorId,
@@ -142,7 +180,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         height: AUTOMATION_SLICE.processor.height,
         timestamp: Date.now(),
     });
-    // 3. Create the command
+    // 5. Create the command
     appendEvent(filePath, {
         type: 'CommandStickyPlaced',
         commandStickyId: commandId,
@@ -152,7 +190,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         height: AUTOMATION_SLICE.command.height,
         timestamp: Date.now(),
     });
-    // 4. Add command fields
+    // 6. Add command fields
     for (const field of commandFields) {
         appendEvent(filePath, {
             type: 'CommandFieldAdded',
@@ -161,7 +199,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
             timestamp: Date.now(),
         });
     }
-    // 5. Create the event
+    // 7. Create the event
     appendEvent(filePath, {
         type: 'EventStickyPlaced',
         eventStickyId: eventId,
@@ -171,7 +209,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         height: AUTOMATION_SLICE.event.height,
         timestamp: Date.now(),
     });
-    // 6. Add event fields
+    // 8. Add event fields
     for (const field of eventFields) {
         appendEvent(filePath, {
             type: 'EventFieldAdded',
@@ -180,7 +218,26 @@ export function createAutomationSlice(model, filePath, xmlInput) {
             timestamp: Date.now(),
         });
     }
-    // 7. Create processor -> command flow
+    // 9. Create read model -> processor flow
+    appendEvent(filePath, {
+        type: 'ReadModelToProcessorFlowSpecified',
+        flowId: readModelToProcessorFlowId,
+        readModelStickyId: readModelId,
+        processorId,
+        sourceHandle: 'top-source',
+        targetHandle: 'bottom-target',
+        timestamp: Date.now(),
+    });
+    // 10. Add read model -> command field mappings
+    if (readModelToCommandMappings.length > 0) {
+        appendEvent(filePath, {
+            type: 'FieldMappingSpecified',
+            flowId: readModelToProcessorFlowId,
+            mappings: readModelToCommandMappings,
+            timestamp: Date.now(),
+        });
+    }
+    // 11. Create processor -> command flow
     appendEvent(filePath, {
         type: 'ProcessorToCommandFlowSpecified',
         flowId: processorToCommandFlowId,
@@ -190,7 +247,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         targetHandle: 'top-target',
         timestamp: Date.now(),
     });
-    // 8. Create command -> event flow
+    // 12. Create command -> event flow
     appendEvent(filePath, {
         type: 'CommandToEventFlowSpecified',
         flowId: commandToEventFlowId,
@@ -200,7 +257,7 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         targetHandle: 'top-target',
         timestamp: Date.now(),
     });
-    // 9. Add command -> event field mappings
+    // 13. Add command -> event field mappings
     if (commandToEventMappings.length > 0) {
         appendEvent(filePath, {
             type: 'FieldMappingSpecified',
@@ -210,8 +267,10 @@ export function createAutomationSlice(model, filePath, xmlInput) {
         });
     }
     console.log(`Created automation slice "${input.sliceName}"`);
+    console.log(`  ReadModel: ${input.readModel.name} (${readModelFields.length} fields)`);
     console.log(`  Processor: ${input.processor.name}`);
     console.log(`  Command: ${input.command.name} (${commandFields.length} fields)`);
     console.log(`  Event: ${input.event.name} (${eventFields.length} fields)`);
+    console.log(`  ReadModel -> Command mappings: ${readModelToCommandMappings.length}`);
     console.log(`  Command -> Event mappings: ${commandToEventMappings.length}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eventmodeler",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "CLI tool for interacting with Event Model files - query, update, and export event models from the terminal",
   "type": "module",
   "bin": {