eventmodeler 0.1.0 → 0.2.0

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

@@ -0,0 +1,180 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+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 calculateFlowCompleteness(model, flow, targetFields, sourceFields) {
+    const flatSource = flattenFields(sourceFields);
+    const flatTarget = flattenFields(targetFields);
+    const manualMappings = flow.fieldMappings ?? [];
+    // Get source entity name
+    let sourceName = 'Unknown';
+    let sourceType = 'unknown';
+    const event = model.events.get(flow.sourceId);
+    const readModel = model.readModels.get(flow.sourceId);
+    const command = model.commands.get(flow.sourceId);
+    const screen = model.screens.get(flow.sourceId);
+    const processor = model.processors.get(flow.sourceId);
+    if (event) {
+        sourceName = event.name;
+        sourceType = 'event';
+    }
+    else if (readModel) {
+        sourceName = readModel.name;
+        sourceType = 'read-model';
+    }
+    else if (command) {
+        sourceName = command.name;
+        sourceType = 'command';
+    }
+    else if (screen) {
+        sourceName = screen.name;
+        sourceType = 'screen';
+    }
+    else if (processor) {
+        sourceName = processor.name;
+        sourceType = 'processor';
+    }
+    const fieldStatuses = flatTarget.map(({ id, path, field }) => {
+        // 1. Check if generated
+        if (field.isGenerated) {
+            return { fieldId: id, fieldName: path, status: 'generated' };
+        }
+        // 2. Check if user input
+        if (field.isUserInput) {
+            return { fieldId: id, fieldName: path, status: 'user-input' };
+        }
+        // 3. Check manual mapping
+        const manualMapping = manualMappings.find(m => m.targetFieldId === id);
+        if (manualMapping) {
+            const sourceField = flatSource.find(sf => sf.id === manualMapping.sourceFieldId);
+            return {
+                fieldId: id,
+                fieldName: path,
+                status: 'satisfied',
+                sourceFieldId: manualMapping.sourceFieldId,
+                sourceFieldName: sourceField?.path,
+            };
+        }
+        // 4. Check auto-mapping by path
+        const autoMatch = flatSource.find(sf => sf.path === path);
+        if (autoMatch) {
+            return {
+                fieldId: id,
+                fieldName: path,
+                status: 'satisfied',
+                sourceFieldId: autoMatch.id,
+                sourceFieldName: autoMatch.path,
+            };
+        }
+        // 5. Not satisfied - check if optional
+        if (field.isOptional) {
+            return { fieldId: id, fieldName: path, status: 'optional-missing' };
+        }
+        // 6. Unsatisfied required field
+        return { fieldId: id, fieldName: path, status: 'unsatisfied' };
+    });
+    const hasUnsatisfied = fieldStatuses.some(s => s.status === 'unsatisfied');
+    const hasOptionalMissing = fieldStatuses.some(s => s.status === 'optional-missing');
+    return {
+        flowId: flow.id,
+        sourceName,
+        sourceType,
+        isComplete: !hasUnsatisfied,
+        hasWarnings: hasOptionalMissing,
+        targetFields: fieldStatuses,
+        sourceFields: flatSource.map(sf => ({
+            id: sf.id,
+            name: sf.path,
+            type: sf.field.fieldType,
+            isList: sf.field.isList,
+        })),
+    };
+}
+export function showCompleteness(model, readModelName) {
+    // Find the read model
+    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);
+    }
+    // Find all flows into this read model (EventToReadModel flows)
+    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === readModel.id && f.flowType === 'EventToReadModel');
+    if (incomingFlows.length === 0) {
+        console.log(`<completeness readModel="${escapeXml(readModel.name)}">`);
+        console.log('  <no-flows>No events flow into this read model</no-flows>');
+        console.log('</completeness>');
+        return;
+    }
+    // Calculate completeness for each flow
+    const completenessResults = [];
+    for (const flow of incomingFlows) {
+        const sourceEvent = model.events.get(flow.sourceId);
+        if (!sourceEvent)
+            continue;
+        const result = calculateFlowCompleteness(model, flow, readModel.fields, sourceEvent.fields);
+        completenessResults.push(result);
+    }
+    // Output XML
+    const overallComplete = completenessResults.every(r => r.isComplete);
+    const overallStatus = overallComplete ? 'complete' : 'incomplete';
+    console.log(`<completeness readModel="${escapeXml(readModel.name)}" status="${overallStatus}">`);
+    for (const result of completenessResults) {
+        const flowStatus = result.isComplete ? 'complete' : 'incomplete';
+        const warningAttr = result.hasWarnings ? ' hasWarnings="true"' : '';
+        console.log(`  <flow id="${result.flowId}" from="${escapeXml(result.sourceName)}" type="${result.sourceType}" status="${flowStatus}"${warningAttr}>`);
+        // Target fields
+        console.log('    <target-fields>');
+        for (const field of result.targetFields) {
+            if (field.sourceFieldName) {
+                console.log(`      <field name="${escapeXml(field.fieldName)}" status="${field.status}" source="${escapeXml(field.sourceFieldName)}"/>`);
+            }
+            else {
+                console.log(`      <field name="${escapeXml(field.fieldName)}" status="${field.status}"/>`);
+            }
+        }
+        console.log('    </target-fields>');
+        // Available source fields (for AI to see what's available)
+        console.log('    <available-source-fields>');
+        for (const sf of result.sourceFields) {
+            const listAttr = sf.isList ? ' isList="true"' : '';
+            console.log(`      <field id="${sf.id}" name="${escapeXml(sf.name)}" type="${sf.type}"${listAttr}/>`);
+        }
+        console.log('    </available-source-fields>');
+        console.log('  </flow>');
+    }
+    // Also show the read model's fields with their IDs (needed for mapping)
+    console.log('  <read-model-fields>');
+    const flatTargetFields = flattenFields(readModel.fields);
+    for (const { id, path, field } of flatTargetFields) {
+        const attrs = [`id="${id}"`, `name="${escapeXml(path)}"`, `type="${field.fieldType}"`];
+        if (field.isList)
+            attrs.push('isList="true"');
+        if (field.isOptional)
+            attrs.push('isOptional="true"');
+        if (field.isGenerated)
+            attrs.push('isGenerated="true"');
+        console.log(`    <field ${attrs.join(' ')}/>`);
+    }
+    console.log('  </read-model-fields>');
+    console.log('</completeness>');
+}

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

@@ -27,8 +27,27 @@ 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 formatEventXml(model, event) {
-    let xml = `<event name="${escapeXml(event.name)}">\n`;
+    const aggregate = findAggregateForEvent(model, event);
+    const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
+    let xml = `<event name="${escapeXml(event.name)}"${aggregateAttr}>\n`;
     if (event.fields.length > 0) {
         xml += '  <fields>\n';
         for (const field of event.fields) {

package/dist/slices/show-model-summary/index.js

@@ -14,6 +14,8 @@ export function showModelSummary(model) {
     console.log(`  <read-models count="${model.readModels.size}"/>`);
     console.log(`  <screens count="${model.screens.size}"/>`);
     console.log(`  <processors count="${model.processors.size}"/>`);
+    console.log(`  <aggregates count="${model.aggregates.size}"/>`);
+    console.log(`  <actors count="${model.actors.size}"/>`);
     console.log(`  <scenarios count="${model.scenarios.size}"/>`);
     console.log(`  <flows count="${model.flows.size}"/>`);
     console.log('</model>');

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

@@ -50,6 +50,8 @@ function getSliceComponents(model, slice) {
         const centerY = pos.y + height / 2;
         return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
     }
+    // Include all elements in the slice (including linked copies)
+    // Linked copies will be marked as such in the output
     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)),
@@ -58,9 +60,100 @@ function getSliceComponents(model, slice) {
         processors: [...model.processors.values()].filter(p => isInSlice(p.position, p.width, p.height)),
     };
 }
+// Find which slice contains the original of a linked copy
+function findSliceForNode(model, nodeId) {
+    const event = model.events.get(nodeId);
+    const readModel = model.readModels.get(nodeId);
+    const screen = model.screens.get(nodeId);
+    const node = event ?? readModel ?? screen;
+    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 (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()) {
+        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;
+        }
+    }
+    return null;
+}
+// Find which actor a screen belongs to (center point inside actor bounds)
+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;
+        }
+    }
+    return null;
+}
+// Check if two rectangles overlap
+function rectanglesOverlap(r1, r2) {
+    return (r1.x < r2.x + r2.width &&
+        r1.x + r1.width > r2.x &&
+        r1.y < r2.y + r2.height &&
+        r1.y + r1.height > r2.y);
+}
+function getAggregatesForSlice(model, slice) {
+    const sliceRect = {
+        x: slice.position.x,
+        y: slice.position.y,
+        width: slice.size.width,
+        height: slice.size.height,
+    };
+    return [...model.aggregates.values()].filter(aggregate => {
+        const aggRect = {
+            x: aggregate.position.x,
+            y: aggregate.position.y,
+            width: aggregate.size.width,
+            height: aggregate.size.height,
+        };
+        return rectanglesOverlap(sliceRect, aggRect);
+    });
+}
+function getActorsForSlice(model, slice) {
+    const sliceRect = {
+        x: slice.position.x,
+        y: slice.position.y,
+        width: slice.size.width,
+        height: slice.size.height,
+    };
+    return [...model.actors.values()].filter(actor => {
+        const actorRect = {
+            x: actor.position.x,
+            y: actor.position.y,
+            width: actor.size.width,
+            height: actor.size.height,
+        };
+        return rectanglesOverlap(sliceRect, actorRect);
+    });
+}
 function formatSliceXml(model, slice) {
     const components = getSliceComponents(model, slice);
     const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
+    const aggregates = getAggregatesForSlice(model, slice);
+    const actors = getActorsForSlice(model, slice);
     const componentIds = new Set();
     components.commands.forEach(c => componentIds.add(c.id));
     components.events.forEach(e => componentIds.add(e.id));
@@ -80,7 +173,19 @@ function formatSliceXml(model, slice) {
     let xml = `<slice name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
     xml += '  <components>\n';
     for (const screen of components.screens) {
-        xml += `    <screen name="${escapeXml(screen.name)}">\n`;
+        // Check if this is a linked copy
+        const copyAttr = screen.originalNodeId ? ' linked-copy="true"' : '';
+        let originAttr = '';
+        if (screen.originalNodeId) {
+            const originSlice = findSliceForNode(model, screen.originalNodeId);
+            if (originSlice) {
+                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
+            }
+        }
+        // Check which actor this screen belongs to
+        const actor = findActorForScreen(model, screen);
+        const actorAttr = actor ? ` actor="${escapeXml(actor.name)}"` : '';
+        xml += `    <screen name="${escapeXml(screen.name)}"${copyAttr}${originAttr}${actorAttr}>\n`;
         if (screen.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of screen.fields) {
@@ -110,7 +215,19 @@ function formatSliceXml(model, slice) {
         xml += '    </command>\n';
     }
     for (const event of components.events) {
-        xml += `    <event name="${escapeXml(event.name)}">\n`;
+        // Check if this is a linked copy
+        const copyAttr = event.originalNodeId ? ' linked-copy="true"' : '';
+        let originAttr = '';
+        if (event.originalNodeId) {
+            const originSlice = findSliceForNode(model, event.originalNodeId);
+            if (originSlice) {
+                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
+            }
+        }
+        // Check which aggregate this event belongs to
+        const aggregate = findAggregateForEvent(model, event);
+        const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
+        xml += `    <event name="${escapeXml(event.name)}"${copyAttr}${originAttr}${aggregateAttr}>\n`;
         if (event.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of event.fields) {
@@ -132,7 +249,16 @@ function formatSliceXml(model, slice) {
         xml += '    </event>\n';
     }
     for (const readModel of components.readModels) {
-        xml += `    <read-model name="${escapeXml(readModel.name)}">\n`;
+        // Check if this is a linked copy
+        const copyAttr = readModel.originalNodeId ? ' linked-copy="true"' : '';
+        let originAttr = '';
+        if (readModel.originalNodeId) {
+            const originSlice = findSliceForNode(model, readModel.originalNodeId);
+            if (originSlice) {
+                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
+            }
+        }
+        xml += `    <read-model name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
         if (readModel.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of readModel.fields) {
@@ -154,6 +280,21 @@ function formatSliceXml(model, slice) {
         xml += '    </processor>\n';
     }
     xml += '  </components>\n';
+    if (aggregates.length > 0) {
+        xml += '  <aggregates>\n';
+        for (const agg of aggregates) {
+            const idField = agg.aggregateIdFieldName ? ` id-field="${escapeXml(agg.aggregateIdFieldName)}"` : '';
+            xml += `    <aggregate name="${escapeXml(agg.name)}"${idField}/>\n`;
+        }
+        xml += '  </aggregates>\n';
+    }
+    if (actors.length > 0) {
+        xml += '  <actors>\n';
+        for (const actor of actors) {
+            xml += `    <actor name="${escapeXml(actor.name)}"/>\n`;
+        }
+        xml += '  </actors>\n';
+    }
     if (internalFlows.length > 0) {
         xml += '  <information-flow>\n';
         for (const flow of internalFlows) {

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

@@ -0,0 +1,12 @@
+import type { EventModel } from '../../types.js';
+interface UpdateOptions {
+    optional?: boolean;
+    generated?: boolean;
+    type?: string;
+}
+export declare function updateField(model: EventModel, filePath: string, options: {
+    command?: string;
+    event?: string;
+    readModel?: string;
+}, fieldName: string, updates: UpdateOptions): void;
+export {};

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

@@ -0,0 +1,166 @@
+import { appendEvent } from '../../lib/file-loader.js';
+function findFieldByName(fields, fieldName) {
+    const nameLower = fieldName.toLowerCase();
+    for (const field of fields) {
+        if (field.name.toLowerCase() === nameLower) {
+            return field;
+        }
+        // Check subfields for Custom types
+        if (field.fieldType === 'Custom' && field.subfields) {
+            // Check for dot notation path (e.g., "address.street")
+            if (fieldName.toLowerCase().startsWith(field.name.toLowerCase() + '.')) {
+                const subPath = fieldName.slice(field.name.length + 1);
+                const subField = findFieldByName(field.subfields, subPath);
+                if (subField)
+                    return subField;
+            }
+            // Also check direct match in subfields
+            const subField = findFieldByName(field.subfields, fieldName);
+            if (subField)
+                return subField;
+        }
+    }
+    return undefined;
+}
+function createUpdatedField(original, updates) {
+    return {
+        ...original,
+        isOptional: updates.optional !== undefined ? updates.optional : original.isOptional,
+        isGenerated: updates.generated !== undefined ? updates.generated : original.isGenerated,
+        fieldType: updates.type !== undefined ? updates.type : original.fieldType,
+    };
+}
+export function updateField(model, filePath, options, fieldName, updates) {
+    // 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) {
+        updateCommandField(model, filePath, options.command, fieldName, updates);
+    }
+    else if (options.event) {
+        updateEventField(model, filePath, options.event, fieldName, updates);
+    }
+    else if (options.readModel) {
+        updateReadModelField(model, filePath, options.readModel, fieldName, updates);
+    }
+}
+function updateCommandField(model, filePath, commandName, fieldName, updates) {
+    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 field = findFieldByName(command.fields, fieldName);
+    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}`);
+            }
+        }
+        process.exit(1);
+    }
+    const updatedField = createUpdatedField(field, updates);
+    appendEvent(filePath, {
+        type: 'CommandFieldAdjusted',
+        commandStickyId: command.id,
+        fieldId: field.id,
+        field: updatedField,
+        timestamp: Date.now(),
+    });
+    console.log(`Updated field "${field.name}" on command "${command.name}"`);
+    logUpdates(updates);
+}
+function updateEventField(model, filePath, eventName, fieldName, updates) {
+    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 field = findFieldByName(event.fields, fieldName);
+    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}`);
+            }
+        }
+        process.exit(1);
+    }
+    const updatedField = createUpdatedField(field, updates);
+    appendEvent(filePath, {
+        type: 'EventFieldAdjusted',
+        eventStickyId: event.id,
+        fieldId: field.id,
+        field: updatedField,
+        timestamp: Date.now(),
+    });
+    console.log(`Updated field "${field.name}" on event "${event.name}"`);
+    logUpdates(updates);
+}
+function updateReadModelField(model, filePath, readModelName, fieldName, updates) {
+    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 field = findFieldByName(readModel.fields, fieldName);
+    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}`);
+            }
+        }
+        process.exit(1);
+    }
+    const updatedField = createUpdatedField(field, updates);
+    appendEvent(filePath, {
+        type: 'ReadModelFieldAdjusted',
+        readModelStickyId: readModel.id,
+        fieldId: field.id,
+        field: updatedField,
+        timestamp: Date.now(),
+    });
+    console.log(`Updated field "${field.name}" on read model "${readModel.name}"`);
+    logUpdates(updates);
+}
+function logUpdates(updates) {
+    if (updates.optional !== undefined) {
+        console.log(`  isOptional: ${updates.optional}`);
+    }
+    if (updates.generated !== undefined) {
+        console.log(`  isGenerated: ${updates.generated}`);
+    }
+    if (updates.type !== undefined) {
+        console.log(`  fieldType: ${updates.type}`);
+    }
+}

package/dist/types.d.ts

@@ -56,6 +56,7 @@ export interface EventSticky {
     width: number;
     height: number;
     canonicalId?: string;
+    originalNodeId?: string;
 }
 export interface ReadModelSticky {
     id: string;
@@ -68,6 +69,7 @@ export interface ReadModelSticky {
     width: number;
     height: number;
     canonicalId?: string;
+    originalNodeId?: string;
 }
 export interface Screen {
     id: string;
@@ -80,6 +82,7 @@ export interface Screen {
     width: number;
     height: number;
     canonicalId?: string;
+    originalNodeId?: string;
 }
 export interface Processor {
     id: string;
@@ -118,6 +121,34 @@ export interface Chapter {
         height: number;
     };
 }
+export interface Aggregate {
+    id: string;
+    name: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    eventIds: string[];
+    aggregateIdFieldName?: string;
+    aggregateIdFieldType?: Field['fieldType'];
+}
+export interface Actor {
+    id: string;
+    name: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    screenIds: string[];
+}
 export interface Scenario {
     id: string;
     sliceId: string;
@@ -151,6 +182,8 @@ export interface EventModel {
     processors: Map<string, Processor>;
     slices: Map<string, Slice>;
     chapters: Map<string, Chapter>;
+    aggregates: Map<string, Aggregate>;
+    actors: Map<string, Actor>;
     scenarios: Map<string, Scenario>;
     flows: Map<string, Flow>;
 }

package/package.json

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