eventmodeler 0.2.3 → 0.2.4

package/dist/index.js

@@ -31,6 +31,10 @@ 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';
+import { createStateChangeSlice } from './slices/create-state-change-slice/index.js';
+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';
 const args = process.argv.slice(2);
 function getNamedArg(argList, ...names) {
     for (let i = 0; i < argList.length; i++) {
@@ -87,6 +91,15 @@ COMMANDS:
   update field --command|--event|--read-model <name> --field <name> [--optional true|false] [--generated true|false]
                                  Update field properties
 
+  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 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)
+
   summary                        Show model summary statistics
 
   export json                    Export entire model as JSON
@@ -413,6 +426,56 @@ async function main() {
                     process.exit(1);
             }
             break;
+        case 'create':
+            switch (subcommand) {
+                case 'state-change-slice': {
+                    const xmlArg = getNamedArg(filteredArgs, '--xml');
+                    if (!xmlArg) {
+                        console.error('Error: --xml is required');
+                        console.error('Usage: eventmodeler create state-change-slice --xml \'<state-change-slice>...</state-change-slice>\'');
+                        process.exit(1);
+                    }
+                    createStateChangeSlice(model, filePath, xmlArg);
+                    break;
+                }
+                case 'automation-slice': {
+                    const xmlArg = getNamedArg(filteredArgs, '--xml');
+                    if (!xmlArg) {
+                        console.error('Error: --xml is required');
+                        console.error('Usage: eventmodeler create automation-slice --xml \'<automation-slice>...</automation-slice>\'');
+                        process.exit(1);
+                    }
+                    createAutomationSlice(model, filePath, xmlArg);
+                    break;
+                }
+                case 'state-view-slice': {
+                    const xmlArg = getNamedArg(filteredArgs, '--xml');
+                    if (!xmlArg) {
+                        console.error('Error: --xml is required');
+                        console.error('Usage: eventmodeler create state-view-slice --xml \'<state-view-slice>...</state-view-slice>\'');
+                        process.exit(1);
+                    }
+                    createStateViewSlice(model, filePath, xmlArg);
+                    break;
+                }
+                case 'flow': {
+                    const fromArg = getNamedArg(filteredArgs, '--from');
+                    const toArg = getNamedArg(filteredArgs, '--to');
+                    if (!fromArg || !toArg) {
+                        console.error('Error: --from and --to are required');
+                        console.error('Usage: eventmodeler create flow --from <source> --to <target>');
+                        console.error('Valid flows: Event→ReadModel, ReadModel→Screen, ReadModel→Processor');
+                        process.exit(1);
+                    }
+                    createFlow(model, filePath, fromArg, toArg);
+                    break;
+                }
+                default:
+                    console.error(`Unknown create target: ${subcommand}`);
+                    console.error('Valid targets: state-change-slice, automation-slice, state-view-slice, flow');
+                    process.exit(1);
+            }
+            break;
         default:
             console.error(`Unknown command: ${command}`);
             printHelp();

package/dist/lib/element-lookup.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Element lookup utilities for CLI commands.
+ * Provides exact-match lookup with UUID disambiguation for duplicate names.
+ */
+export type LookupResult<T> = {
+    success: true;
+    element: T;
+} | {
+    success: false;
+    error: 'not_found' | 'ambiguous';
+    matches: T[];
+};
+/**
+ * Find an element by exact name (case-insensitive) or UUID.
+ * - If search starts with "id:", treats rest as UUID/UUID prefix
+ * - Otherwise, performs case-insensitive exact name match
+ * - Returns error if multiple elements have the same name
+ */
+export declare function findElement<T extends {
+    id: string;
+    name: string;
+}>(elements: Map<string, T> | T[], search: string): LookupResult<T>;
+/**
+ * Format an element name with its ID for display
+ */
+export declare function formatElementWithId<T extends {
+    id: string;
+    name: string;
+}>(element: T, truncateId?: boolean): string;
+/**
+ * Print error message for lookup failures and exit
+ */
+export declare function handleLookupError<T extends {
+    id: string;
+    name: string;
+}>(search: string, elementType: string, result: {
+    success: false;
+    error: 'not_found' | 'ambiguous';
+    matches: T[];
+}, allElements: Map<string, T> | T[]): never;
+/**
+ * Convenience function: find element or exit with error
+ */
+export declare function findElementOrExit<T extends {
+    id: string;
+    name: string;
+}>(elements: Map<string, T> | T[], search: string, elementType: string): T;

package/dist/lib/element-lookup.js

@@ -0,0 +1,86 @@
+/**
+ * Element lookup utilities for CLI commands.
+ * Provides exact-match lookup with UUID disambiguation for duplicate names.
+ */
+/**
+ * Find an element by exact name (case-insensitive) or UUID.
+ * - If search starts with "id:", treats rest as UUID/UUID prefix
+ * - Otherwise, performs case-insensitive exact name match
+ * - Returns error if multiple elements have the same name
+ */
+export function findElement(elements, search) {
+    const elementArray = Array.isArray(elements) ? elements : [...elements.values()];
+    // Check for UUID lookup (id:prefix or full UUID format)
+    if (search.startsWith('id:')) {
+        const idSearch = search.slice(3).toLowerCase();
+        const match = elementArray.find(e => e.id.toLowerCase().startsWith(idSearch));
+        if (match) {
+            return { success: true, element: match };
+        }
+        return { success: false, error: 'not_found', matches: [] };
+    }
+    // Check if the search looks like a UUID (contains dashes in UUID pattern)
+    const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (uuidPattern.test(search)) {
+        const match = elementArray.find(e => e.id.toLowerCase() === search.toLowerCase());
+        if (match) {
+            return { success: true, element: match };
+        }
+        return { success: false, error: 'not_found', matches: [] };
+    }
+    // Case-insensitive exact name match
+    const searchLower = search.toLowerCase();
+    const matches = elementArray.filter(e => e.name.toLowerCase() === searchLower);
+    if (matches.length === 1) {
+        return { success: true, element: matches[0] };
+    }
+    if (matches.length > 1) {
+        return { success: false, error: 'ambiguous', matches };
+    }
+    return { success: false, error: 'not_found', matches: [] };
+}
+/**
+ * Format an element name with its ID for display
+ */
+export function formatElementWithId(element, truncateId = true) {
+    const id = truncateId ? element.id.slice(0, 8) : element.id;
+    return `"${element.name}" (id: ${id})`;
+}
+/**
+ * Print error message for lookup failures and exit
+ */
+export function handleLookupError(search, elementType, result, allElements) {
+    const elementArray = Array.isArray(allElements) ? allElements : [...allElements.values()];
+    if (result.error === 'ambiguous') {
+        console.error(`Error: Multiple ${elementType}s found with name "${search}"`);
+        console.error('Please specify using the element ID:');
+        for (const el of result.matches) {
+            console.error(`  - ${formatElementWithId(el, false)}`);
+        }
+        console.error('');
+        console.error(`Usage: eventmodeler <command> "id:${result.matches[0].id.slice(0, 8)}"`);
+    }
+    else {
+        console.error(`Error: ${elementType.charAt(0).toUpperCase() + elementType.slice(1)} not found: "${search}"`);
+        if (elementArray.length > 0) {
+            console.error(`Available ${elementType}s:`);
+            for (const el of elementArray) {
+                console.error(`  - ${formatElementWithId(el)}`);
+            }
+        }
+        else {
+            console.error(`No ${elementType}s exist in the model.`);
+        }
+    }
+    process.exit(1);
+}
+/**
+ * Convenience function: find element or exit with error
+ */
+export function findElementOrExit(elements, search, elementType) {
+    const result = findElement(elements, search);
+    if (!result.success) {
+        handleLookupError(search, elementType, result, elements);
+    }
+    return result.element;
+}

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

@@ -0,0 +1,83 @@
+import type { EventModel, Field, FieldMapping, Slice } from '../types.js';
+export declare const STATE_CHANGE_SLICE: {
+    width: number;
+    height: number;
+    screen: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    command: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    event: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+};
+export declare const AUTOMATION_SLICE: {
+    width: number;
+    height: number;
+    processor: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    command: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    event: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+};
+export declare const STATE_VIEW_SLICE: {
+    width: number;
+    height: number;
+    readModel: {
+        width: number;
+        height: number;
+        offsetX: number;
+        offsetY: number;
+    };
+};
+export declare const SLICE_GAP = 20;
+export interface PositionReference {
+    after?: string;
+    before?: string;
+}
+export declare function findSliceByName(model: EventModel, name: string): Slice | undefined;
+export declare function validateSliceNameUnique(model: EventModel, name: string): void;
+export declare function calculateSlicePosition(model: EventModel, sliceWidth: number, ref: PositionReference): {
+    x: number;
+    y: number;
+};
+export declare function getSlicesToShift(model: EventModel, insertX: number, shiftAmount: number): Array<{
+    sliceId: string;
+    newX: number;
+    currentY: number;
+}>;
+export declare function inferFieldMappings(sourceFields: Field[], targetFields: Field[]): FieldMapping[];
+export interface FieldInput {
+    name: string;
+    type: string;
+    isList?: boolean;
+    isGenerated?: boolean;
+    isOptional?: boolean;
+    isUserInput?: boolean;
+    subfields?: FieldInput[];
+}
+export declare function parseFieldsFromXml(xml: string): FieldInput[];
+export declare function fieldInputToField(input: FieldInput): Field;

package/dist/lib/slice-utils.js

@@ -0,0 +1,135 @@
+// Fixed dimensions from requirements
+export const STATE_CHANGE_SLICE = {
+    width: 560,
+    height: 1000,
+    screen: { width: 180, height: 120, offsetX: 40, offsetY: 120 },
+    command: { width: 160, height: 100, offsetX: 180, offsetY: 460 },
+    event: { width: 160, height: 100, offsetX: 360, offsetY: 860 },
+};
+export const AUTOMATION_SLICE = {
+    width: 560,
+    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 },
+};
+export const STATE_VIEW_SLICE = {
+    width: 380,
+    height: 1000,
+    readModel: { width: 160, height: 100, offsetX: 110, offsetY: 460 },
+};
+export const SLICE_GAP = 20;
+export function findSliceByName(model, name) {
+    const nameLower = name.toLowerCase();
+    return [...model.slices.values()].find(s => s.name.toLowerCase() === nameLower || s.name.toLowerCase().includes(nameLower));
+}
+export function validateSliceNameUnique(model, name) {
+    const existing = findSliceByName(model, name);
+    if (existing && existing.name.toLowerCase() === name.toLowerCase()) {
+        throw new Error(`Slice "${name}" already exists`);
+    }
+}
+export function calculateSlicePosition(model, sliceWidth, ref) {
+    const slices = [...model.slices.values()];
+    if (slices.length === 0) {
+        return { x: 0, y: 0 };
+    }
+    if (ref.after) {
+        const refSlice = findSliceByName(model, ref.after);
+        if (!refSlice) {
+            const available = slices.map(s => s.name).join(', ');
+            throw new Error(`Slice "${ref.after}" not found. Available: ${available}`);
+        }
+        return {
+            x: refSlice.position.x + refSlice.size.width + SLICE_GAP,
+            y: refSlice.position.y
+        };
+    }
+    if (ref.before) {
+        const refSlice = findSliceByName(model, ref.before);
+        if (!refSlice) {
+            const available = slices.map(s => s.name).join(', ');
+            throw new Error(`Slice "${ref.before}" not found. Available: ${available}`);
+        }
+        return {
+            x: refSlice.position.x,
+            y: refSlice.position.y
+        };
+    }
+    // Default: append to end (right of rightmost slice)
+    const rightmost = slices.reduce((max, s) => Math.max(max, s.position.x + s.size.width), 0);
+    const avgY = slices.reduce((sum, s) => sum + s.position.y, 0) / slices.length;
+    return {
+        x: rightmost + SLICE_GAP,
+        y: avgY
+    };
+}
+export function getSlicesToShift(model, insertX, shiftAmount) {
+    return [...model.slices.values()]
+        .filter(s => s.position.x >= insertX)
+        .map(s => ({
+        sliceId: s.id,
+        newX: s.position.x + shiftAmount,
+        currentY: s.position.y
+    }));
+}
+export function inferFieldMappings(sourceFields, targetFields) {
+    const mappings = [];
+    for (const targetField of targetFields) {
+        // Skip generated fields - they have no source
+        if (targetField.isGenerated)
+            continue;
+        // Find source field with matching name (case-insensitive)
+        const sourceField = sourceFields.find(sf => sf.name.toLowerCase() === targetField.name.toLowerCase());
+        if (sourceField) {
+            mappings.push({
+                sourceFieldId: sourceField.id,
+                targetFieldId: targetField.id
+            });
+        }
+    }
+    return mappings;
+}
+function getAttr(attrs, name) {
+    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+    return match ? match[1] : undefined;
+}
+export function parseFieldsFromXml(xml) {
+    const fields = [];
+    // Match top-level field elements only (not nested inside other fields)
+    const fieldMatches = xml.matchAll(/<field([^>]*?)(?:\/>|>([\s\S]*?)<\/field>)/g);
+    for (const match of fieldMatches) {
+        const attrs = match[1];
+        const content = match[2];
+        const name = getAttr(attrs, 'name');
+        const type = getAttr(attrs, 'type');
+        if (!name || !type)
+            continue;
+        const field = {
+            name,
+            type,
+            isList: getAttr(attrs, 'list') === 'true',
+            isGenerated: getAttr(attrs, 'generated') === 'true',
+            isOptional: getAttr(attrs, 'optional') === 'true',
+            isUserInput: getAttr(attrs, 'user-input') === 'true',
+        };
+        // Parse nested subfields for Custom type
+        if (type === 'Custom' && content) {
+            field.subfields = parseFieldsFromXml(content);
+        }
+        fields.push(field);
+    }
+    return fields;
+}
+export function fieldInputToField(input) {
+    return {
+        id: crypto.randomUUID(),
+        name: input.name,
+        fieldType: input.type,
+        isList: input.isList ?? false,
+        isGenerated: input.isGenerated ?? false,
+        isOptional: input.isOptional,
+        isUserInput: input.isUserInput,
+        subfields: input.subfields?.map(fieldInputToField),
+    };
+}

package/dist/projection.js

@@ -824,6 +824,138 @@ function applyEvent(model, event) {
         case 'ScreenDesignUpdated':
             // Screen designs are visual-only, not relevant for CLI
             break;
+        // Compound slice placement events - place entire slices atomically
+        case 'StateChangeSlicePlaced': {
+            // Create slice
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.sliceName,
+                status: 'created',
+                position: event.slicePosition,
+                size: event.sliceSize,
+                nodeIds: [event.screenId, event.commandId, event.eventId],
+            });
+            // Create screen
+            model.screens.set(event.screenId, {
+                id: event.screenId,
+                name: event.screenName,
+                fields: event.screenFields,
+                position: event.screenPosition,
+                width: event.screenSize.width,
+                height: event.screenSize.height,
+            });
+            // Create command
+            model.commands.set(event.commandId, {
+                id: event.commandId,
+                name: event.commandName,
+                fields: event.commandFields,
+                position: event.commandPosition,
+                width: event.commandSize.width,
+                height: event.commandSize.height,
+            });
+            // Create event
+            model.events.set(event.eventId, {
+                id: event.eventId,
+                name: event.eventName,
+                fields: event.eventFields,
+                position: event.eventPosition,
+                width: event.eventSize.width,
+                height: event.eventSize.height,
+            });
+            // Create screen->command flow
+            model.flows.set(event.screenToCommandFlowId, {
+                id: event.screenToCommandFlowId,
+                flowType: 'ScreenToCommand',
+                sourceId: event.screenId,
+                targetId: event.commandId,
+                fieldMappings: event.screenToCommandMappings,
+            });
+            // Create command->event flow
+            model.flows.set(event.commandToEventFlowId, {
+                id: event.commandToEventFlowId,
+                flowType: 'CommandToEvent',
+                sourceId: event.commandId,
+                targetId: event.eventId,
+                fieldMappings: event.commandToEventMappings,
+            });
+            break;
+        }
+        case 'AutomationSlicePlaced': {
+            // Create slice
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.sliceName,
+                status: 'created',
+                position: event.slicePosition,
+                size: event.sliceSize,
+                nodeIds: [event.processorId, event.commandId, event.eventId],
+            });
+            // Create processor
+            model.processors.set(event.processorId, {
+                id: event.processorId,
+                name: event.processorName,
+                fields: [],
+                position: event.processorPosition,
+                width: event.processorSize.width,
+                height: event.processorSize.height,
+            });
+            // Create command
+            model.commands.set(event.commandId, {
+                id: event.commandId,
+                name: event.commandName,
+                fields: event.commandFields,
+                position: event.commandPosition,
+                width: event.commandSize.width,
+                height: event.commandSize.height,
+            });
+            // Create event
+            model.events.set(event.eventId, {
+                id: event.eventId,
+                name: event.eventName,
+                fields: event.eventFields,
+                position: event.eventPosition,
+                width: event.eventSize.width,
+                height: event.eventSize.height,
+            });
+            // Create processor->command flow
+            model.flows.set(event.processorToCommandFlowId, {
+                id: event.processorToCommandFlowId,
+                flowType: 'ProcessorToCommand',
+                sourceId: event.processorId,
+                targetId: event.commandId,
+                fieldMappings: [],
+            });
+            // Create command->event flow
+            model.flows.set(event.commandToEventFlowId, {
+                id: event.commandToEventFlowId,
+                flowType: 'CommandToEvent',
+                sourceId: event.commandId,
+                targetId: event.eventId,
+                fieldMappings: event.commandToEventMappings,
+            });
+            break;
+        }
+        case 'StateViewSlicePlaced': {
+            // Create slice
+            model.slices.set(event.sliceId, {
+                id: event.sliceId,
+                name: event.sliceName,
+                status: 'created',
+                position: event.slicePosition,
+                size: event.sliceSize,
+                nodeIds: [event.readModelId],
+            });
+            // Create read model
+            model.readModels.set(event.readModelId, {
+                id: event.readModelId,
+                name: event.readModelName,
+                fields: event.readModelFields,
+                position: event.readModelPosition,
+                width: event.readModelSize.width,
+                height: event.readModelSize.height,
+            });
+            break;
+        }
     }
 }
 // Merge propagated fields with existing fields:

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

@@ -1,5 +1,6 @@
 import * as crypto from 'node:crypto';
 import { appendEvent } from '../../lib/file-loader.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 const validFieldTypes = ['UUID', 'Boolean', 'Double', 'Decimal', 'Date', 'DateTime', 'Long', 'Int', 'String', 'Custom'];
 function parseJsonInput(input) {
     return JSON.parse(input);
@@ -103,17 +104,7 @@ export function addField(model, filePath, options, input) {
     }
 }
 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);
-    }
+    const command = findElementOrExit(model.commands, commandName, 'command');
     // 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}"`);
@@ -129,17 +120,7 @@ function addFieldToCommand(model, filePath, commandName, fieldInput) {
     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);
-    }
+    const event = findElementOrExit(model.events, eventName, 'event');
     // 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}"`);
@@ -155,17 +136,7 @@ function addFieldToEvent(model, filePath, eventName, fieldInput) {
     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);
-    }
+    const readModel = findElementOrExit(model.readModels, readModelName, 'read model');
     // 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}"`);