eventmodeler 0.2.3 → 0.2.5

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/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}"`);

package/dist/slices/add-scenario/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';
 function parseJsonInput(input) {
     return JSON.parse(input);
 }
@@ -144,27 +145,12 @@ export function addScenario(model, filePath, sliceName, input) {
         process.exit(1);
     }
     // Find slice by name
-    const slices = [...model.slices.values()];
-    const sliceNameLower = sliceName.toLowerCase();
-    const slice = slices.find(s => s.name.toLowerCase() === sliceNameLower || s.name.toLowerCase().includes(sliceNameLower));
-    if (!slice) {
-        console.error(`Error: Slice not found: ${sliceName}`);
-        console.error('Available slices:');
-        for (const s of slices) {
-            console.error(`  - ${s.name}`);
-        }
-        process.exit(1);
-    }
+    const slice = findElementOrExit(model.slices, sliceName, 'slice');
     // Resolve event references in given
     const givenEvents = [];
     if (scenarioInput.given) {
         for (const g of scenarioInput.given) {
-            const event = findEventByName(model, g.event);
-            if (!event) {
-                console.error(`Error: Event not found in "given": ${g.event}`);
-                listAvailableEvents(model);
-                process.exit(1);
-            }
+            const event = findElementOrExit(model.events, g.event, 'event');
             givenEvents.push({
                 eventStickyId: event.id,
                 fieldValues: g.fieldValues,
@@ -174,12 +160,7 @@ export function addScenario(model, filePath, sliceName, input) {
     // Resolve command reference in when
     let whenCommand = null;
     if (scenarioInput.when) {
-        const command = findCommandByName(model, scenarioInput.when.command);
-        if (!command) {
-            console.error(`Error: Command not found in "when": ${scenarioInput.when.command}`);
-            listAvailableCommands(model);
-            process.exit(1);
-        }
+        const command = findElementOrExit(model.commands, scenarioInput.when.command, 'command');
         whenCommand = {
             commandStickyId: command.id,
             fieldValues: scenarioInput.when.fieldValues,
@@ -195,12 +176,7 @@ export function addScenario(model, filePath, sliceName, input) {
         then.expectedEvents = [];
         if (scenarioInput.then.events) {
             for (const e of scenarioInput.then.events) {
-                const event = findEventByName(model, e.event);
-                if (!event) {
-                    console.error(`Error: Event not found in "then.events": ${e.event}`);
-                    listAvailableEvents(model);
-                    process.exit(1);
-                }
+                const event = findElementOrExit(model.events, e.event, 'event');
                 then.expectedEvents.push({
                     eventStickyId: event.id,
                     fieldValues: e.fieldValues,
@@ -213,21 +189,11 @@ export function addScenario(model, filePath, sliceName, input) {
             console.error('Error: readModelAssertion requires a readModel name');
             process.exit(1);
         }
-        const readModel = findReadModelByName(model, scenarioInput.then.readModel);
-        if (!readModel) {
-            console.error(`Error: Read model not found: ${scenarioInput.then.readModel}`);
-            listAvailableReadModels(model);
-            process.exit(1);
-        }
+        const readModel = findElementOrExit(model.readModels, scenarioInput.then.readModel, 'read model');
         const assertionGivenEvents = [];
         if (scenarioInput.then.givenEvents) {
             for (const g of scenarioInput.then.givenEvents) {
-                const event = findEventByName(model, g.event);
-                if (!event) {
-                    console.error(`Error: Event not found in "then.givenEvents": ${g.event}`);
-                    listAvailableEvents(model);
-                    process.exit(1);
-                }
+                const event = findElementOrExit(model.events, g.event, 'event');
                 assertionGivenEvents.push({
                     eventStickyId: event.id,
                     fieldValues: g.fieldValues,
@@ -241,15 +207,20 @@ export function addScenario(model, filePath, sliceName, input) {
         };
     }
     // Calculate position below slice
+    // Scenarios are tall (GWT rows with 100px stickies + labels + padding = ~400px+)
+    // so we need adequate spacing between them
+    const SCENARIO_GAP = 20; // Match slice gap
+    const SCENARIO_ESTIMATED_HEIGHT = 450; // Approximate rendered height for positioning
     const existingScenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
     const sliceBottom = slice.position.y + slice.size.height;
     let positionY;
     if (existingScenarios.length === 0) {
-        positionY = sliceBottom + 20;
+        positionY = sliceBottom + SCENARIO_GAP;
     }
     else {
-        const lowestY = Math.max(...existingScenarios.map(s => s.position.y + s.height));
-        positionY = lowestY + 10;
+        // Use estimated height since stored height (80px) doesn't reflect actual rendered size
+        const lowestY = Math.max(...existingScenarios.map(s => s.position.y + SCENARIO_ESTIMATED_HEIGHT));
+        positionY = lowestY + SCENARIO_GAP;
     }
     const position = {
         x: slice.position.x + 10,
@@ -304,36 +275,3 @@ export function addScenario(model, filePath, sliceName, input) {
     });
     console.log(`Added scenario "${scenarioInput.name}" to slice "${slice.name}"`);
 }
-function findEventByName(model, name) {
-    const nameLower = name.toLowerCase();
-    const events = [...model.events.values()];
-    return events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
-}
-function findCommandByName(model, name) {
-    const nameLower = name.toLowerCase();
-    const commands = [...model.commands.values()];
-    return commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
-}
-function findReadModelByName(model, name) {
-    const nameLower = name.toLowerCase();
-    const readModels = [...model.readModels.values()];
-    return readModels.find(rm => rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower));
-}
-function listAvailableEvents(model) {
-    console.error('Available events:');
-    for (const e of model.events.values()) {
-        console.error(`  - ${e.name}`);
-    }
-}
-function listAvailableCommands(model) {
-    console.error('Available commands:');
-    for (const c of model.commands.values()) {
-        console.error(`  - ${c.name}`);
-    }
-}
-function listAvailableReadModels(model) {
-    console.error('Available read models:');
-    for (const rm of model.readModels.values()) {
-        console.error(`  - ${rm.name}`);
-    }
-}

package/dist/slices/create-automation-slice/index.d.ts

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