eventmodeler 0.1.0 → 0.2.1

package/dist/index.js

@@ -15,7 +15,24 @@ import { openApp } from './slices/open-app/index.js';
 import { search } from './slices/search/index.js';
 import { listChapters } from './slices/list-chapters/index.js';
 import { showChapter } from './slices/show-chapter/index.js';
+import { addScenario } from './slices/add-scenario/index.js';
+import { addField } from './slices/add-field/index.js';
+import { removeScenario } from './slices/remove-scenario/index.js';
+import { removeField } from './slices/remove-field/index.js';
+import { showCompleteness } from './slices/show-completeness/index.js';
+import { mapFields } from './slices/map-fields/index.js';
+import { updateField } from './slices/update-field/index.js';
+import { showAggregateCompleteness, listAggregates } from './slices/show-aggregate-completeness/index.js';
+import { showActor, listActors } from './slices/show-actor/index.js';
 const args = process.argv.slice(2);
+function getNamedArg(argList, ...names) {
+    for (let i = 0; i < argList.length; i++) {
+        if (names.includes(argList[i]) && i + 1 < argList.length) {
+            return argList[i + 1];
+        }
+    }
+    return undefined;
+}
 function printHelp() {
     console.log(`
 eventmodeler - CLI tool for interacting with Event Model files
@@ -29,30 +46,57 @@ COMMANDS:
   list events                    List all events
   list commands                  List all commands
   list chapters                  List all chapters
+  list aggregates                List all aggregates
+  list actors                    List all actors
 
   show slice <name>              Show detailed XML view of a slice
   show event <name>              Show detailed XML view of an event
   show command <name>            Show detailed XML view of a command
   show chapter <name>            Show chapter with its slices
+  show completeness <read-model> Show field mapping completeness status
+  show aggregate-completeness <name>
+                                 Show if events in aggregate have the ID field
+  show actor <name>              Show actor with its screens
 
   search <term>                  Search for entities by name
 
   mark <slice-name> <status>     Mark a slice's status
                                  Status: created | in-progress | blocked | done
 
+  add scenario --slice <name> --json|--xml <data>
+                                 Add a scenario to a slice
+  add field --command|--event|--read-model <name> --json|--xml <data>
+                                 Add a field to an entity
+
+  remove scenario <name> [--slice <name>]
+                                 Remove a scenario by name
+  remove field --command|--event|--read-model <name> --field <name>
+                                 Remove a field from an entity
+
+  map fields --flow <source→target> --json|--xml <mappings>
+                                 Set field mappings on a flow
+
+  update field --command|--event|--read-model <name> --field <name> [--optional true|false] [--generated true|false]
+                                 Update field properties
+
   summary                        Show model summary statistics
 
   export json                    Export entire model as JSON
 
 OPTIONS:
-  -f, --file <path>              Path to .eventmodeler file (default: auto-detect)
+  -f, --file <path>              Path to .eventmodel file (default: auto-detect)
   -h, --help                     Show this help message
 
 EXAMPLES:
   eventmodeler list slices
   eventmodeler show slice "Place Order"
   eventmodeler mark "Place Order" done
-  eventmodeler summary -f ./my-model.eventmodeler
+  eventmodeler add scenario --slice "Place Order" --json '{"name": "Happy path", "then": {"type": "events", "events": []}}'
+  eventmodeler add field --event "OrderPlaced" --json '{"name": "orderId", "type": "UUID"}'
+  eventmodeler remove field --event "OrderPlaced" --field "orderId"
+  eventmodeler show completeness "OrderSummary"
+  eventmodeler map fields --flow "OrderPlaced→OrderSummary" --json '[{"from": "total", "to": "totalAmount"}]'
+  eventmodeler update field --read-model "OrderSummary" --field "notes" --optional true
 `);
 }
 async function main() {
@@ -79,8 +123,8 @@ async function main() {
     }
     const filePath = fileArg ?? await findEventModelFile();
     if (!filePath) {
-        console.error('Error: No .eventmodeler file found in current directory.');
-        console.error('Use -f <path> to specify a file or run in a directory with an .eventmodeler file.');
+        console.error('Error: No .eventmodel file found in current directory.');
+        console.error('Use -f <path> to specify a file or run in a directory with an .eventmodel file.');
         process.exit(1);
     }
     if (!fs.existsSync(filePath)) {
@@ -103,9 +147,15 @@ async function main() {
                 case 'chapters':
                     listChapters(model);
                     break;
+                case 'aggregates':
+                    listAggregates(model);
+                    break;
+                case 'actors':
+                    listActors(model);
+                    break;
                 default:
                     console.error(`Unknown list target: ${subcommand}`);
-                    console.error('Valid targets: slices, events, commands, chapters');
+                    console.error('Valid targets: slices, events, commands, chapters, aggregates, actors');
                     process.exit(1);
             }
             break;
@@ -139,9 +189,30 @@ async function main() {
                     }
                     showChapter(model, target);
                     break;
+                case 'completeness':
+                    if (!target) {
+                        console.error('Usage: eventmodeler show completeness <read-model-name>');
+                        process.exit(1);
+                    }
+                    showCompleteness(model, target);
+                    break;
+                case 'aggregate-completeness':
+                    if (!target) {
+                        console.error('Usage: eventmodeler show aggregate-completeness <aggregate-name>');
+                        process.exit(1);
+                    }
+                    showAggregateCompleteness(model, target);
+                    break;
+                case 'actor':
+                    if (!target) {
+                        console.error('Usage: eventmodeler show actor <actor-name>');
+                        process.exit(1);
+                    }
+                    showActor(model, target);
+                    break;
                 default:
                     console.error(`Unknown show target: ${subcommand}`);
-                    console.error('Valid targets: slice, event, command, chapter');
+                    console.error('Valid targets: slice, event, command, chapter, completeness, aggregate-completeness, actor');
                     process.exit(1);
             }
             break;
@@ -174,6 +245,142 @@ async function main() {
                     process.exit(1);
             }
             break;
+        case 'add':
+            switch (subcommand) {
+                case 'scenario': {
+                    const sliceArg = getNamedArg(filteredArgs, '--slice');
+                    const jsonArg = getNamedArg(filteredArgs, '--json');
+                    const xmlArg = getNamedArg(filteredArgs, '--xml');
+                    const inputData = jsonArg ?? xmlArg;
+                    if (!sliceArg) {
+                        console.error('Error: --slice is required');
+                        console.error('Usage: eventmodeler add scenario --slice <name> --json|--xml <data>');
+                        process.exit(1);
+                    }
+                    if (!inputData) {
+                        console.error('Error: --json or --xml is required');
+                        console.error('Usage: eventmodeler add scenario --slice <name> --json|--xml <data>');
+                        process.exit(1);
+                    }
+                    addScenario(model, filePath, sliceArg, inputData);
+                    break;
+                }
+                case 'field': {
+                    const commandArg = getNamedArg(filteredArgs, '--command');
+                    const eventArg = getNamedArg(filteredArgs, '--event');
+                    const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const jsonArg = getNamedArg(filteredArgs, '--json');
+                    const xmlArg = getNamedArg(filteredArgs, '--xml');
+                    const inputData = jsonArg ?? xmlArg;
+                    if (!inputData) {
+                        console.error('Error: --json or --xml is required');
+                        console.error('Usage: eventmodeler add field --command|--event|--read-model <name> --json|--xml <data>');
+                        process.exit(1);
+                    }
+                    addField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, inputData);
+                    break;
+                }
+                default:
+                    console.error(`Unknown add target: ${subcommand}`);
+                    console.error('Valid targets: scenario, field');
+                    process.exit(1);
+            }
+            break;
+        case 'remove':
+            switch (subcommand) {
+                case 'scenario': {
+                    const scenarioName = target;
+                    const sliceArg = getNamedArg(filteredArgs, '--slice');
+                    if (!scenarioName) {
+                        console.error('Usage: eventmodeler remove scenario <name> [--slice <slice-name>]');
+                        process.exit(1);
+                    }
+                    removeScenario(model, filePath, scenarioName, sliceArg);
+                    break;
+                }
+                case 'field': {
+                    const commandArg = getNamedArg(filteredArgs, '--command');
+                    const eventArg = getNamedArg(filteredArgs, '--event');
+                    const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const fieldArg = getNamedArg(filteredArgs, '--field');
+                    if (!fieldArg) {
+                        console.error('Error: --field is required');
+                        console.error('Usage: eventmodeler remove field --command|--event|--read-model <name> --field <field-name>');
+                        process.exit(1);
+                    }
+                    removeField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, fieldArg);
+                    break;
+                }
+                default:
+                    console.error(`Unknown remove target: ${subcommand}`);
+                    console.error('Valid targets: scenario, field');
+                    process.exit(1);
+            }
+            break;
+        case 'map':
+            switch (subcommand) {
+                case 'fields': {
+                    const flowArg = getNamedArg(filteredArgs, '--flow');
+                    const jsonArg = getNamedArg(filteredArgs, '--json');
+                    const xmlArg = getNamedArg(filteredArgs, '--xml');
+                    const inputData = jsonArg ?? xmlArg;
+                    if (!flowArg) {
+                        console.error('Error: --flow is required');
+                        console.error('Usage: eventmodeler map fields --flow <source→target> --json|--xml <mappings>');
+                        process.exit(1);
+                    }
+                    if (!inputData) {
+                        console.error('Error: --json or --xml is required');
+                        console.error('Usage: eventmodeler map fields --flow <source→target> --json|--xml <mappings>');
+                        process.exit(1);
+                    }
+                    mapFields(model, filePath, flowArg, inputData);
+                    break;
+                }
+                default:
+                    console.error(`Unknown map target: ${subcommand}`);
+                    console.error('Valid targets: fields');
+                    process.exit(1);
+            }
+            break;
+        case 'update':
+            switch (subcommand) {
+                case 'field': {
+                    const commandArg = getNamedArg(filteredArgs, '--command');
+                    const eventArg = getNamedArg(filteredArgs, '--event');
+                    const readModelArg = getNamedArg(filteredArgs, '--read-model');
+                    const fieldArg = getNamedArg(filteredArgs, '--field');
+                    const optionalArg = getNamedArg(filteredArgs, '--optional');
+                    const generatedArg = getNamedArg(filteredArgs, '--generated');
+                    const typeArg = getNamedArg(filteredArgs, '--type');
+                    if (!fieldArg) {
+                        console.error('Error: --field is required');
+                        console.error('Usage: eventmodeler update field --command|--event|--read-model <name> --field <field-name> [--optional true|false] [--generated true|false]');
+                        process.exit(1);
+                    }
+                    const updates = {};
+                    if (optionalArg !== undefined) {
+                        updates.optional = optionalArg === 'true';
+                    }
+                    if (generatedArg !== undefined) {
+                        updates.generated = generatedArg === 'true';
+                    }
+                    if (typeArg !== undefined) {
+                        updates.type = typeArg;
+                    }
+                    if (Object.keys(updates).length === 0) {
+                        console.error('Error: Must specify at least one update (--optional, --generated, or --type)');
+                        process.exit(1);
+                    }
+                    updateField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg }, fieldArg, updates);
+                    break;
+                }
+                default:
+                    console.error(`Unknown update target: ${subcommand}`);
+                    console.error('Valid targets: field');
+                    process.exit(1);
+            }
+            break;
         default:
             console.error(`Unknown command: ${command}`);
             printHelp();

package/dist/projection.js

@@ -11,6 +11,8 @@ export function createEmptyModel() {
         chapters: new Map(),
         scenarios: new Map(),
         flows: new Map(),
+        aggregates: new Map(),
+        actors: new Map(),
     };
 }
 export function projectEvents(rawEvents) {
@@ -143,6 +145,7 @@ function applyEvent(model, event) {
                 width: event.width,
                 height: event.height,
                 canonicalId: event.canonicalId,
+                originalNodeId: event.sourceEventStickyId,
             });
             // Also set canonical on source if not already set
             if (source && !source.canonicalId) {
@@ -217,6 +220,7 @@ function applyEvent(model, event) {
                 width: event.width,
                 height: event.height,
                 canonicalId: event.canonicalId,
+                originalNodeId: event.sourceReadModelStickyId,
             });
             if (source && !source.canonicalId) {
                 source.canonicalId = event.canonicalId;
@@ -290,6 +294,7 @@ function applyEvent(model, event) {
                 width: event.width,
                 height: event.height,
                 canonicalId: event.canonicalId,
+                originalNodeId: event.sourceScreenId,
             });
             if (source && !source.canonicalId) {
                 source.canonicalId = event.canonicalId;
@@ -462,6 +467,102 @@ function applyEvent(model, event) {
                 nodeIds: [],
             });
             break;
+        // Aggregate events
+        case 'AggregatePlaced':
+            model.aggregates.set(event.aggregateId, {
+                id: event.aggregateId,
+                name: event.name,
+                position: event.position,
+                size: event.size,
+                eventIds: [],
+                aggregateIdFieldName: event.aggregateIdFieldName,
+                aggregateIdFieldType: event.aggregateIdFieldType,
+            });
+            break;
+        case 'EventsGroupedIntoAggregate':
+            model.aggregates.set(event.aggregateId, {
+                id: event.aggregateId,
+                name: event.name,
+                position: event.position,
+                size: event.size,
+                eventIds: event.eventIds,
+                aggregateIdFieldName: event.aggregateIdFieldName,
+                aggregateIdFieldType: event.aggregateIdFieldType,
+            });
+            break;
+        case 'AggregateMoved': {
+            const aggregate = model.aggregates.get(event.aggregateId);
+            if (aggregate)
+                aggregate.position = event.position;
+            break;
+        }
+        case 'AggregateResized': {
+            const aggregate = model.aggregates.get(event.aggregateId);
+            if (aggregate) {
+                aggregate.position = event.position;
+                aggregate.size = event.size;
+            }
+            break;
+        }
+        case 'AggregateRemoved':
+            model.aggregates.delete(event.aggregateId);
+            break;
+        case 'AggregateRenamed': {
+            const aggregate = model.aggregates.get(event.aggregateId);
+            if (aggregate)
+                aggregate.name = event.name;
+            break;
+        }
+        case 'AggregateIdFieldSet': {
+            const aggregate = model.aggregates.get(event.aggregateId);
+            if (aggregate) {
+                aggregate.aggregateIdFieldName = event.aggregateIdFieldName;
+                aggregate.aggregateIdFieldType = event.aggregateIdFieldType;
+            }
+            break;
+        }
+        // Actor events
+        case 'ActorPlaced':
+            model.actors.set(event.actorId, {
+                id: event.actorId,
+                name: event.name,
+                position: event.position,
+                size: event.size,
+                screenIds: [],
+            });
+            break;
+        case 'ScreensGroupedIntoActor':
+            model.actors.set(event.actorId, {
+                id: event.actorId,
+                name: event.name,
+                position: event.position,
+                size: event.size,
+                screenIds: event.screenIds,
+            });
+            break;
+        case 'ActorMoved': {
+            const actor = model.actors.get(event.actorId);
+            if (actor)
+                actor.position = event.position;
+            break;
+        }
+        case 'ActorResized': {
+            const actor = model.actors.get(event.actorId);
+            if (actor) {
+                actor.position = event.position;
+                actor.size = event.size;
+            }
+            break;
+        }
+        case 'ActorRemoved':
+            model.actors.delete(event.actorId);
+            break;
+        case 'ActorRenamed': {
+            const actor = model.actors.get(event.actorId);
+            if (actor)
+                actor.name = event.name;
+            break;
+        }
         // Chapter events
         case 'ChapterPlaced':
             model.chapters.set(event.chapterId, {

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

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

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

@@ -0,0 +1,182 @@
+import * as crypto from 'node:crypto';
+import { appendEvent } from '../../lib/file-loader.js';
+const validFieldTypes = ['UUID', 'Boolean', 'Double', 'Decimal', 'Date', 'DateTime', 'Long', 'Int', 'String', 'Custom'];
+function parseJsonInput(input) {
+    return JSON.parse(input);
+}
+function parseXmlInput(input) {
+    const getAttr = (tag, attr) => {
+        const match = tag.match(new RegExp(`${attr}="([^"]*)"`));
+        return match ? match[1] : undefined;
+    };
+    const getBoolAttr = (tag, attr) => {
+        const value = getAttr(tag, attr);
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        return undefined;
+    };
+    const fieldMatch = input.match(/<field([^>]*?)(?:\/>|>([\s\S]*?)<\/field>)/);
+    if (!fieldMatch) {
+        throw new Error('Invalid XML: missing <field> tag');
+    }
+    const name = getAttr(fieldMatch[1], 'name');
+    if (!name) {
+        throw new Error('Invalid XML: field must have a name attribute');
+    }
+    const type = getAttr(fieldMatch[1], 'type');
+    if (!type) {
+        throw new Error('Invalid XML: field must have a type attribute');
+    }
+    const fieldInput = {
+        name,
+        type,
+        isList: getBoolAttr(fieldMatch[1], 'isList'),
+        isGenerated: getBoolAttr(fieldMatch[1], 'isGenerated'),
+        isOptional: getBoolAttr(fieldMatch[1], 'isOptional'),
+    };
+    // Parse nested subfields for Custom type
+    if (type === 'Custom' && fieldMatch[2]) {
+        fieldInput.subfields = [];
+        const subfieldMatches = fieldMatch[2].matchAll(/<field([^>]*?)(?:\/>|>([\s\S]*?)<\/field>)/g);
+        for (const match of subfieldMatches) {
+            const subfieldXml = match[0];
+            fieldInput.subfields.push(parseXmlInput(subfieldXml));
+        }
+    }
+    return fieldInput;
+}
+function parseInput(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith('<')) {
+        return parseXmlInput(trimmed);
+    }
+    return parseJsonInput(trimmed);
+}
+function createFieldFromInput(input) {
+    return {
+        id: crypto.randomUUID(),
+        name: input.name,
+        fieldType: input.type,
+        isList: input.isList ?? false,
+        isGenerated: input.isGenerated ?? false,
+        isOptional: input.isOptional,
+        subfields: input.subfields?.map(createFieldFromInput),
+    };
+}
+export function addField(model, filePath, options, input) {
+    // 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);
+    }
+    // Parse input
+    let fieldInput;
+    try {
+        fieldInput = parseInput(input);
+    }
+    catch (err) {
+        console.error(`Error: Invalid input format: ${err.message}`);
+        process.exit(1);
+    }
+    // Validate field type
+    if (!validFieldTypes.includes(fieldInput.type)) {
+        console.error(`Error: Invalid field type: ${fieldInput.type}`);
+        console.error(`Valid types: ${validFieldTypes.join(', ')}`);
+        process.exit(1);
+    }
+    // Find entity and add field
+    if (options.command) {
+        addFieldToCommand(model, filePath, options.command, fieldInput);
+    }
+    else if (options.event) {
+        addFieldToEvent(model, filePath, options.event, fieldInput);
+    }
+    else if (options.readModel) {
+        addFieldToReadModel(model, filePath, options.readModel, fieldInput);
+    }
+}
+function addFieldToCommand(model, filePath, commandName, fieldInput) {
+    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);
+    }
+    // Check for duplicate field name
+    if (command.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
+        console.error(`Error: Field "${fieldInput.name}" already exists on command "${command.name}"`);
+        process.exit(1);
+    }
+    const field = createFieldFromInput(fieldInput);
+    appendEvent(filePath, {
+        type: 'CommandFieldAdded',
+        commandStickyId: command.id,
+        field,
+        timestamp: Date.now(),
+    });
+    console.log(`Added field "${field.name}" to command "${command.name}"`);
+}
+function addFieldToEvent(model, filePath, eventName, fieldInput) {
+    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);
+    }
+    // Check for duplicate field name
+    if (event.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
+        console.error(`Error: Field "${fieldInput.name}" already exists on event "${event.name}"`);
+        process.exit(1);
+    }
+    const field = createFieldFromInput(fieldInput);
+    appendEvent(filePath, {
+        type: 'EventFieldAdded',
+        eventStickyId: event.id,
+        field,
+        timestamp: Date.now(),
+    });
+    console.log(`Added field "${field.name}" to event "${event.name}"`);
+}
+function addFieldToReadModel(model, filePath, readModelName, fieldInput) {
+    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);
+    }
+    // Check for duplicate field name
+    if (readModel.fields.some(f => f.name.toLowerCase() === fieldInput.name.toLowerCase())) {
+        console.error(`Error: Field "${fieldInput.name}" already exists on read model "${readModel.name}"`);
+        process.exit(1);
+    }
+    const field = createFieldFromInput(fieldInput);
+    appendEvent(filePath, {
+        type: 'ReadModelFieldAdded',
+        readModelStickyId: readModel.id,
+        field,
+        timestamp: Date.now(),
+    });
+    console.log(`Added field "${field.name}" to read model "${readModel.name}"`);
+}

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

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