eventmodeler 0.1.0 → 0.2.0

package/dist/slices/map-fields/index.js

@@ -0,0 +1,216 @@
+import { appendEvent } from '../../lib/file-loader.js';
+function flattenFields(fields, prefix = '') {
+    const result = [];
+    for (const field of fields) {
+        const path = prefix ? `${prefix}.${field.name}` : field.name;
+        result.push({ id: field.id, path, field });
+        if (field.fieldType === 'Custom' && field.subfields) {
+            result.push(...flattenFields(field.subfields, path));
+        }
+    }
+    return result;
+}
+function parseJsonInput(input) {
+    const parsed = JSON.parse(input);
+    if (!Array.isArray(parsed)) {
+        return [parsed];
+    }
+    return parsed;
+}
+function parseXmlInput(input) {
+    const mappings = [];
+    const mappingMatches = input.matchAll(/<mapping[^>]*from="([^"]*)"[^>]*to="([^"]*)"[^>]*\/?>/g);
+    for (const match of mappingMatches) {
+        mappings.push({ from: match[1], to: match[2] });
+    }
+    // Also try alternate attribute order
+    const altMatches = input.matchAll(/<mapping[^>]*to="([^"]*)"[^>]*from="([^"]*)"[^>]*\/?>/g);
+    for (const match of altMatches) {
+        // Check if this mapping was already added
+        const exists = mappings.some(m => m.from === match[2] && m.to === match[1]);
+        if (!exists) {
+            mappings.push({ from: match[2], to: match[1] });
+        }
+    }
+    if (mappings.length === 0) {
+        throw new Error('No <mapping from="..." to="..."/> elements found in XML');
+    }
+    return mappings;
+}
+function parseInput(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith('<')) {
+        return parseXmlInput(trimmed);
+    }
+    return parseJsonInput(trimmed);
+}
+export function mapFields(model, filePath, flowIdentifier, input) {
+    // Parse the mapping input
+    let mappingInputs;
+    try {
+        mappingInputs = parseInput(input);
+    }
+    catch (err) {
+        console.error(`Error: Invalid input format: ${err.message}`);
+        process.exit(1);
+    }
+    // Find the flow - can be identified by:
+    // 1. Flow ID directly
+    // 2. "SourceName→TargetName" format (using → or ->)
+    let flow = model.flows.get(flowIdentifier);
+    if (!flow) {
+        // Try to parse as "Source→Target" or "Source->Target"
+        const arrowMatch = flowIdentifier.match(/^(.+?)(?:→|->)(.+)$/);
+        if (arrowMatch) {
+            const sourceName = arrowMatch[1].trim().toLowerCase();
+            const targetName = arrowMatch[2].trim().toLowerCase();
+            // Find matching flow
+            for (const f of model.flows.values()) {
+                let sourceEntityName = '';
+                let targetEntityName = '';
+                // Get source name
+                const sourceEvent = model.events.get(f.sourceId);
+                const sourceReadModel = model.readModels.get(f.sourceId);
+                const sourceScreen = model.screens.get(f.sourceId);
+                const sourceProcessor = model.processors.get(f.sourceId);
+                const sourceCommand = model.commands.get(f.sourceId);
+                if (sourceEvent)
+                    sourceEntityName = sourceEvent.name.toLowerCase();
+                else if (sourceReadModel)
+                    sourceEntityName = sourceReadModel.name.toLowerCase();
+                else if (sourceScreen)
+                    sourceEntityName = sourceScreen.name.toLowerCase();
+                else if (sourceProcessor)
+                    sourceEntityName = sourceProcessor.name.toLowerCase();
+                else if (sourceCommand)
+                    sourceEntityName = sourceCommand.name.toLowerCase();
+                // Get target name
+                const targetEvent = model.events.get(f.targetId);
+                const targetReadModel = model.readModels.get(f.targetId);
+                const targetScreen = model.screens.get(f.targetId);
+                const targetProcessor = model.processors.get(f.targetId);
+                const targetCommand = model.commands.get(f.targetId);
+                if (targetEvent)
+                    targetEntityName = targetEvent.name.toLowerCase();
+                else if (targetReadModel)
+                    targetEntityName = targetReadModel.name.toLowerCase();
+                else if (targetScreen)
+                    targetEntityName = targetScreen.name.toLowerCase();
+                else if (targetProcessor)
+                    targetEntityName = targetProcessor.name.toLowerCase();
+                else if (targetCommand)
+                    targetEntityName = targetCommand.name.toLowerCase();
+                // Check for match (exact or partial)
+                const sourceMatches = sourceEntityName === sourceName || sourceEntityName.includes(sourceName);
+                const targetMatches = targetEntityName === targetName || targetEntityName.includes(targetName);
+                if (sourceMatches && targetMatches) {
+                    flow = f;
+                    break;
+                }
+            }
+        }
+    }
+    if (!flow) {
+        console.error(`Error: Flow not found: ${flowIdentifier}`);
+        console.error('Available flows:');
+        for (const f of model.flows.values()) {
+            const source = getEntityName(model, f.sourceId);
+            const target = getEntityName(model, f.targetId);
+            console.error(`  - ${source}→${target} (${f.id})`);
+        }
+        process.exit(1);
+    }
+    // Get source and target fields
+    const sourceFields = getEntityFields(model, flow.sourceId);
+    const targetFields = getEntityFields(model, flow.targetId);
+    const flatSource = flattenFields(sourceFields);
+    const flatTarget = flattenFields(targetFields);
+    // Resolve mapping inputs to field IDs
+    const mappings = [];
+    for (const m of mappingInputs) {
+        // Find source field (by name/path or ID)
+        const sourceField = flatSource.find(sf => sf.id === m.from || sf.path.toLowerCase() === m.from.toLowerCase());
+        if (!sourceField) {
+            console.error(`Error: Source field not found: ${m.from}`);
+            console.error('Available source fields:');
+            for (const sf of flatSource) {
+                console.error(`  - ${sf.path} (${sf.id})`);
+            }
+            process.exit(1);
+        }
+        // Find target field (by name/path or ID)
+        const targetField = flatTarget.find(tf => tf.id === m.to || tf.path.toLowerCase() === m.to.toLowerCase());
+        if (!targetField) {
+            console.error(`Error: Target field not found: ${m.to}`);
+            console.error('Available target fields:');
+            for (const tf of flatTarget) {
+                console.error(`  - ${tf.path} (${tf.id})`);
+            }
+            process.exit(1);
+        }
+        mappings.push({
+            sourceFieldId: sourceField.id,
+            targetFieldId: targetField.id,
+        });
+    }
+    // Get existing mappings and merge
+    const existingMappings = flow.fieldMappings ?? [];
+    const mergedMappings = [...existingMappings];
+    for (const newMapping of mappings) {
+        // Remove any existing mapping for the same target field
+        const existingIndex = mergedMappings.findIndex(m => m.targetFieldId === newMapping.targetFieldId);
+        if (existingIndex >= 0) {
+            mergedMappings.splice(existingIndex, 1);
+        }
+        mergedMappings.push(newMapping);
+    }
+    // Append the event
+    appendEvent(filePath, {
+        type: 'FieldMappingSpecified',
+        flowId: flow.id,
+        mappings: mergedMappings,
+        timestamp: Date.now(),
+    });
+    const sourceName = getEntityName(model, flow.sourceId);
+    const targetName = getEntityName(model, flow.targetId);
+    console.log(`Mapped ${mappings.length} field(s) on flow ${sourceName}→${targetName}`);
+    for (const m of mappingInputs) {
+        console.log(`  ${m.from} → ${m.to}`);
+    }
+}
+function getEntityName(model, entityId) {
+    const event = model.events.get(entityId);
+    if (event)
+        return event.name;
+    const readModel = model.readModels.get(entityId);
+    if (readModel)
+        return readModel.name;
+    const command = model.commands.get(entityId);
+    if (command)
+        return command.name;
+    const screen = model.screens.get(entityId);
+    if (screen)
+        return screen.name;
+    const processor = model.processors.get(entityId);
+    if (processor)
+        return processor.name;
+    return entityId;
+}
+function getEntityFields(model, entityId) {
+    const event = model.events.get(entityId);
+    if (event)
+        return event.fields;
+    const readModel = model.readModels.get(entityId);
+    if (readModel)
+        return readModel.fields;
+    const command = model.commands.get(entityId);
+    if (command)
+        return command.fields;
+    const screen = model.screens.get(entityId);
+    if (screen)
+        return screen.fields;
+    const processor = model.processors.get(entityId);
+    if (processor)
+        return processor.fields;
+    return [];
+}

package/dist/slices/remove-field/index.d.ts

@@ -0,0 +1,6 @@
+import type { EventModel } from '../../types.js';
+export declare function removeField(model: EventModel, filePath: string, options: {
+    command?: string;
+    event?: string;
+    readModel?: string;
+}, fieldName: string): void;

package/dist/slices/remove-field/index.js

@@ -0,0 +1,127 @@
+import { appendEvent } from '../../lib/file-loader.js';
+export function removeField(model, filePath, options, fieldName) {
+    // Determine which entity type
+    const entityCount = [options.command, options.event, options.readModel].filter(Boolean).length;
+    if (entityCount === 0) {
+        console.error('Error: Must specify one of --command, --event, or --read-model');
+        process.exit(1);
+    }
+    if (entityCount > 1) {
+        console.error('Error: Can only specify one of --command, --event, or --read-model');
+        process.exit(1);
+    }
+    if (options.command) {
+        removeFieldFromCommand(model, filePath, options.command, fieldName);
+    }
+    else if (options.event) {
+        removeFieldFromEvent(model, filePath, options.event, fieldName);
+    }
+    else if (options.readModel) {
+        removeFieldFromReadModel(model, filePath, options.readModel, fieldName);
+    }
+}
+function removeFieldFromCommand(model, filePath, commandName, fieldName) {
+    const nameLower = commandName.toLowerCase();
+    const commands = [...model.commands.values()];
+    const command = commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
+    if (!command) {
+        console.error(`Error: Command not found: ${commandName}`);
+        console.error('Available commands:');
+        for (const c of commands) {
+            console.error(`  - ${c.name}`);
+        }
+        process.exit(1);
+    }
+    const fieldNameLower = fieldName.toLowerCase();
+    const field = command.fields.find(f => f.name.toLowerCase() === fieldNameLower);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on command "${command.name}"`);
+        if (command.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of command.fields) {
+                console.error(`  - ${f.name} (${f.fieldType})`);
+            }
+        }
+        else {
+            console.error('This command has no fields.');
+        }
+        process.exit(1);
+    }
+    appendEvent(filePath, {
+        type: 'CommandFieldRemoved',
+        commandStickyId: command.id,
+        fieldId: field.id,
+        timestamp: Date.now(),
+    });
+    console.log(`Removed field "${field.name}" from command "${command.name}"`);
+}
+function removeFieldFromEvent(model, filePath, eventName, fieldName) {
+    const nameLower = eventName.toLowerCase();
+    const events = [...model.events.values()];
+    const event = events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
+    if (!event) {
+        console.error(`Error: Event not found: ${eventName}`);
+        console.error('Available events:');
+        for (const e of events) {
+            console.error(`  - ${e.name}`);
+        }
+        process.exit(1);
+    }
+    const fieldNameLower = fieldName.toLowerCase();
+    const field = event.fields.find(f => f.name.toLowerCase() === fieldNameLower);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on event "${event.name}"`);
+        if (event.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of event.fields) {
+                console.error(`  - ${f.name} (${f.fieldType})`);
+            }
+        }
+        else {
+            console.error('This event has no fields.');
+        }
+        process.exit(1);
+    }
+    appendEvent(filePath, {
+        type: 'EventFieldRemoved',
+        eventStickyId: event.id,
+        fieldId: field.id,
+        timestamp: Date.now(),
+    });
+    console.log(`Removed field "${field.name}" from event "${event.name}"`);
+}
+function removeFieldFromReadModel(model, filePath, readModelName, fieldName) {
+    const nameLower = readModelName.toLowerCase();
+    const readModels = [...model.readModels.values()];
+    const readModel = readModels.find(rm => rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower));
+    if (!readModel) {
+        console.error(`Error: Read model not found: ${readModelName}`);
+        console.error('Available read models:');
+        for (const rm of readModels) {
+            console.error(`  - ${rm.name}`);
+        }
+        process.exit(1);
+    }
+    const fieldNameLower = fieldName.toLowerCase();
+    const field = readModel.fields.find(f => f.name.toLowerCase() === fieldNameLower);
+    if (!field) {
+        console.error(`Error: Field "${fieldName}" not found on read model "${readModel.name}"`);
+        if (readModel.fields.length > 0) {
+            console.error('Available fields:');
+            for (const f of readModel.fields) {
+                console.error(`  - ${f.name} (${f.fieldType})`);
+            }
+        }
+        else {
+            console.error('This read model has no fields.');
+        }
+        process.exit(1);
+    }
+    appendEvent(filePath, {
+        type: 'ReadModelFieldRemoved',
+        readModelStickyId: readModel.id,
+        fieldId: field.id,
+        timestamp: Date.now(),
+    });
+    console.log(`Removed field "${field.name}" from read model "${readModel.name}"`);
+}

package/dist/slices/remove-scenario/index.d.ts

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

package/dist/slices/remove-scenario/index.js

@@ -0,0 +1,39 @@
+import { appendEvent } from '../../lib/file-loader.js';
+export function removeScenario(model, filePath, scenarioName, sliceName) {
+    const scenarioNameLower = scenarioName.toLowerCase();
+    // Find scenarios matching the name
+    let matchingScenarios = [...model.scenarios.values()].filter(s => s.name.toLowerCase() === scenarioNameLower || s.name.toLowerCase().includes(scenarioNameLower));
+    // If slice name provided, filter to that slice
+    if (sliceName && matchingScenarios.length > 0) {
+        const sliceNameLower = sliceName.toLowerCase();
+        const slice = [...model.slices.values()].find(s => s.name.toLowerCase() === sliceNameLower || s.name.toLowerCase().includes(sliceNameLower));
+        if (slice) {
+            matchingScenarios = matchingScenarios.filter(s => s.sliceId === slice.id);
+        }
+    }
+    if (matchingScenarios.length === 0) {
+        console.error(`Error: Scenario not found: ${scenarioName}`);
+        console.error('Available scenarios:');
+        for (const s of model.scenarios.values()) {
+            const slice = model.slices.get(s.sliceId);
+            console.error(`  - "${s.name}" (in slice "${slice?.name ?? 'unknown'}")`);
+        }
+        process.exit(1);
+    }
+    if (matchingScenarios.length > 1) {
+        console.error(`Error: Multiple scenarios match "${scenarioName}". Use --slice to disambiguate:`);
+        for (const s of matchingScenarios) {
+            const slice = model.slices.get(s.sliceId);
+            console.error(`  - "${s.name}" in slice "${slice?.name ?? 'unknown'}"`);
+        }
+        process.exit(1);
+    }
+    const scenario = matchingScenarios[0];
+    const slice = model.slices.get(scenario.sliceId);
+    appendEvent(filePath, {
+        type: 'ScenarioRemoved',
+        scenarioId: scenario.id,
+        timestamp: Date.now(),
+    });
+    console.log(`Removed scenario "${scenario.name}" from slice "${slice?.name ?? 'unknown'}"`);
+}

package/dist/slices/show-actor/index.d.ts

@@ -0,0 +1,3 @@
+import type { EventModel } from '../../types.js';
+export declare function showActor(model: EventModel, actorName: string): void;
+export declare function listActors(model: EventModel): void;

package/dist/slices/show-actor/index.js

@@ -0,0 +1,89 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+// Get screens whose center point is inside the actor bounds
+function getScreensInActor(model, actor) {
+    const bounds = {
+        left: actor.position.x,
+        right: actor.position.x + actor.size.width,
+        top: actor.position.y,
+        bottom: actor.position.y + actor.size.height,
+    };
+    function isInActor(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 [...model.screens.values()].filter(s => isInActor(s.position, s.width, s.height));
+}
+// Find which slice contains a screen
+function findSliceForScreen(model, screen) {
+    for (const slice of model.slices.values()) {
+        const centerX = screen.position.x + screen.width / 2;
+        const centerY = screen.position.y + screen.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.name;
+        }
+    }
+    return null;
+}
+export function showActor(model, actorName) {
+    // Find the actor
+    const nameLower = actorName.toLowerCase();
+    const actors = [...model.actors.values()];
+    const actor = actors.find(a => a.name.toLowerCase() === nameLower || a.name.toLowerCase().includes(nameLower));
+    if (!actor) {
+        console.error(`Error: Actor not found: ${actorName}`);
+        console.error('Available actors:');
+        for (const a of actors) {
+            console.error(`  - ${a.name}`);
+        }
+        process.exit(1);
+    }
+    // Get screens dynamically based on position (center point inside actor bounds)
+    const screensInActor = getScreensInActor(model, actor);
+    console.log(`<actor id="${actor.id}" name="${escapeXml(actor.name)}">`);
+    console.log(`  <screens-count>${screensInActor.length}</screens-count>`);
+    if (screensInActor.length > 0) {
+        console.log('  <screens>');
+        for (const screen of screensInActor) {
+            const fieldCount = screen.fields.length;
+            if (screen.originalNodeId) {
+                // This is a linked copy - show origin info
+                const original = model.screens.get(screen.originalNodeId);
+                const originSlice = original ? findSliceForScreen(model, original) : null;
+                const originAttr = originSlice ? ` origin-slice="${escapeXml(originSlice)}"` : '';
+                console.log(`    <screen id="${screen.id}" name="${escapeXml(screen.name)}" fields="${fieldCount}" linked-copy="true"${originAttr}/>`);
+            }
+            else {
+                console.log(`    <screen id="${screen.id}" name="${escapeXml(screen.name)}" fields="${fieldCount}"/>`);
+            }
+        }
+        console.log('  </screens>');
+    }
+    console.log('</actor>');
+}
+export function listActors(model) {
+    const actors = [...model.actors.values()];
+    if (actors.length === 0) {
+        console.log('<actors/>');
+        return;
+    }
+    console.log('<actors>');
+    for (const actor of actors) {
+        // Calculate screens dynamically based on position
+        const screensInActor = getScreensInActor(model, actor);
+        const originalCount = screensInActor.filter(s => !s.originalNodeId).length;
+        const copyCount = screensInActor.filter(s => s.originalNodeId).length;
+        const copiesAttr = copyCount > 0 ? ` copies="${copyCount}"` : '';
+        console.log(`  <actor id="${actor.id}" name="${escapeXml(actor.name)}" screens="${originalCount}"${copiesAttr}/>`);
+    }
+    console.log('</actors>');
+}

package/dist/slices/show-aggregate-completeness/index.d.ts

@@ -0,0 +1,3 @@
+import type { EventModel } from '../../types.js';
+export declare function showAggregateCompleteness(model: EventModel, aggregateName: string): void;
+export declare function listAggregates(model: EventModel): void;

package/dist/slices/show-aggregate-completeness/index.js

@@ -0,0 +1,139 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function findMatchingField(fields, targetName, targetType) {
+    for (const field of fields) {
+        // Check if name and type match
+        if (field.name.toLowerCase() === targetName.toLowerCase() && field.fieldType === targetType) {
+            return field;
+        }
+        // Check nested subfields
+        if (field.fieldType === 'Custom' && field.subfields) {
+            const nested = findMatchingField(field.subfields, targetName, targetType);
+            if (nested)
+                return nested;
+        }
+    }
+    return undefined;
+}
+// Get events whose center point is inside the aggregate bounds
+// Only returns original events, not linked copies (linked copies have originalNodeId set)
+function getEventsInAggregate(model, aggregate) {
+    const bounds = {
+        left: aggregate.position.x,
+        right: aggregate.position.x + aggregate.size.width,
+        top: aggregate.position.y,
+        bottom: aggregate.position.y + aggregate.size.height,
+    };
+    function isInAggregate(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;
+    }
+    // Filter out linked copies - only return original events
+    // Linked copies have originalNodeId set, originals do not
+    return [...model.events.values()].filter(e => !e.originalNodeId && isInAggregate(e.position, e.width, e.height));
+}
+export function showAggregateCompleteness(model, aggregateName) {
+    // Find the aggregate
+    const nameLower = aggregateName.toLowerCase();
+    const aggregates = [...model.aggregates.values()];
+    const aggregate = aggregates.find(a => a.name.toLowerCase() === nameLower || a.name.toLowerCase().includes(nameLower));
+    if (!aggregate) {
+        console.error(`Error: Aggregate not found: ${aggregateName}`);
+        console.error('Available aggregates:');
+        for (const a of aggregates) {
+            console.error(`  - ${a.name}`);
+        }
+        process.exit(1);
+    }
+    // Get events dynamically based on position (center point inside aggregate bounds)
+    const eventsInAggregate = getEventsInAggregate(model, aggregate);
+    // Check if aggregate has ID field configured
+    if (!aggregate.aggregateIdFieldName || !aggregate.aggregateIdFieldType) {
+        console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="unconfigured">`);
+        console.log(`  <events-count>${eventsInAggregate.length}</events-count>`);
+        console.log('  <events>');
+        for (const event of eventsInAggregate) {
+            console.log(`    <event id="${event.id}" name="${escapeXml(event.name)}"/>`);
+        }
+        console.log('  </events>');
+        console.log('  <message>Aggregate ID field not configured. Set aggregateIdFieldName and aggregateIdFieldType.</message>');
+        console.log('</aggregate-completeness>');
+        return;
+    }
+    const idFieldName = aggregate.aggregateIdFieldName;
+    const idFieldType = aggregate.aggregateIdFieldType;
+    if (eventsInAggregate.length === 0) {
+        console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="empty">`);
+        console.log(`  <id-field name="${escapeXml(idFieldName)}" type="${idFieldType}"/>`);
+        console.log('  <message>No events in this aggregate.</message>');
+        console.log('</aggregate-completeness>');
+        return;
+    }
+    // Check each event for the ID field
+    const eventResults = [];
+    for (const event of eventsInAggregate) {
+        const matchingField = findMatchingField(event.fields, idFieldName, idFieldType);
+        eventResults.push({
+            eventId: event.id,
+            eventName: event.name,
+            hasIdField: !!matchingField,
+            matchingField: matchingField ? {
+                fieldId: matchingField.id,
+                fieldName: matchingField.name,
+                fieldType: matchingField.fieldType,
+            } : undefined,
+        });
+    }
+    const completeEvents = eventResults.filter(e => e.hasIdField);
+    const incompleteEvents = eventResults.filter(e => !e.hasIdField);
+    const isComplete = incompleteEvents.length === 0;
+    const overallStatus = isComplete ? 'complete' : 'incomplete';
+    const completionPercent = eventResults.length > 0
+        ? Math.round((completeEvents.length / eventResults.length) * 100)
+        : 100;
+    console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="${overallStatus}" completion="${completionPercent}%">`);
+    console.log(`  <id-field name="${escapeXml(idFieldName)}" type="${idFieldType}"/>`);
+    console.log(`  <summary total="${eventResults.length}" complete="${completeEvents.length}" incomplete="${incompleteEvents.length}"/>`);
+    if (incompleteEvents.length > 0) {
+        console.log('  <incomplete-events>');
+        for (const event of incompleteEvents) {
+            console.log(`    <event id="${event.eventId}" name="${escapeXml(event.eventName)}"/>`);
+        }
+        console.log('  </incomplete-events>');
+    }
+    if (completeEvents.length > 0) {
+        console.log('  <complete-events>');
+        for (const event of completeEvents) {
+            const fieldAttr = event.matchingField
+                ? ` field-id="${event.matchingField.fieldId}"`
+                : '';
+            console.log(`    <event id="${event.eventId}" name="${escapeXml(event.eventName)}"${fieldAttr}/>`);
+        }
+        console.log('  </complete-events>');
+    }
+    console.log('</aggregate-completeness>');
+}
+export function listAggregates(model) {
+    const aggregates = [...model.aggregates.values()];
+    if (aggregates.length === 0) {
+        console.log('<aggregates/>');
+        return;
+    }
+    console.log('<aggregates>');
+    for (const aggregate of aggregates) {
+        // Calculate events dynamically based on position
+        const eventsInAggregate = getEventsInAggregate(model, aggregate);
+        const eventCount = eventsInAggregate.length;
+        const idFieldAttr = aggregate.aggregateIdFieldName
+            ? ` idField="${escapeXml(aggregate.aggregateIdFieldName)}" idType="${aggregate.aggregateIdFieldType ?? 'Unknown'}"`
+            : '';
+        console.log(`  <aggregate id="${aggregate.id}" name="${escapeXml(aggregate.name)}" events="${eventCount}"${idFieldAttr}/>`);
+    }
+    console.log('</aggregates>');
+}

package/dist/slices/show-command/index.js

@@ -27,6 +27,23 @@ function formatFieldXml(field, indent) {
     }
     return `${indent}<field ${attrs.join(' ')}/>\n`;
 }
+// Find which aggregate an event belongs to (center point inside aggregate bounds)
+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()) {
+        const bounds = {
+            left: aggregate.position.x,
+            right: aggregate.position.x + aggregate.size.width,
+            top: aggregate.position.y,
+            bottom: aggregate.position.y + aggregate.size.height,
+        };
+        if (centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom) {
+            return aggregate;
+        }
+    }
+    return null;
+}
 function formatCommandXml(model, command) {
     let xml = `<command name="${escapeXml(command.name)}">\n`;
     if (command.fields.length > 0) {
@@ -54,8 +71,11 @@ function formatCommandXml(model, command) {
         xml += '  <produces>\n';
         for (const flow of outgoingFlows) {
             const target = model.events.get(flow.targetId);
-            if (target)
-                xml += `    <event name="${escapeXml(target.name)}"/>\n`;
+            if (target) {
+                const aggregate = findAggregateForEvent(model, target);
+                const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
+                xml += `    <event name="${escapeXml(target.name)}"${aggregateAttr}/>\n`;
+            }
         }
         xml += '  </produces>\n';
     }

package/dist/slices/show-completeness/index.d.ts

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