eventmodeler 0.2.3 → 0.2.4

package/dist/slices/create-state-change-slice/index.js

@@ -0,0 +1,239 @@
+import { appendEvent } from '../../lib/file-loader.js';
+import { STATE_CHANGE_SLICE, SLICE_GAP, calculateSlicePosition, validateSliceNameUnique, inferFieldMappings, parseFieldsFromXml, getSlicesToShift, fieldInputToField, } from '../../lib/slice-utils.js';
+function getAttr(attrs, name) {
+    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+    return match ? match[1] : undefined;
+}
+function parseXmlInput(xml) {
+    // Parse <state-change-slice name="..." after="..." before="...">
+    const sliceMatch = xml.match(/<state-change-slice([^>]*)>/);
+    if (!sliceMatch) {
+        throw new Error('Invalid XML: missing <state-change-slice> tag');
+    }
+    const sliceName = getAttr(sliceMatch[1], 'name');
+    if (!sliceName) {
+        throw new Error('Invalid XML: state-change-slice must have a name attribute');
+    }
+    const after = getAttr(sliceMatch[1], 'after');
+    const before = getAttr(sliceMatch[1], 'before');
+    // Parse screen
+    const screenMatch = xml.match(/<screen([^>]*)>([\s\S]*?)<\/screen>/);
+    if (!screenMatch) {
+        throw new Error('Invalid XML: missing <screen> element');
+    }
+    const screenName = getAttr(screenMatch[1], 'name');
+    if (!screenName) {
+        throw new Error('Invalid XML: screen must have a name attribute');
+    }
+    const screenFields = parseFieldsFromXml(screenMatch[2]);
+    // Parse command
+    const commandMatch = xml.match(/<command([^>]*)>([\s\S]*?)<\/command>/);
+    if (!commandMatch) {
+        throw new Error('Invalid XML: missing <command> element');
+    }
+    const commandName = getAttr(commandMatch[1], 'name');
+    if (!commandName) {
+        throw new Error('Invalid XML: command must have a name attribute');
+    }
+    const commandFields = parseFieldsFromXml(commandMatch[2]);
+    // Parse event
+    const eventMatch = xml.match(/<event([^>]*)>([\s\S]*?)<\/event>/);
+    if (!eventMatch) {
+        throw new Error('Invalid XML: missing <event> element');
+    }
+    const eventName = getAttr(eventMatch[1], 'name');
+    if (!eventName) {
+        throw new Error('Invalid XML: event must have a name attribute');
+    }
+    const eventFields = parseFieldsFromXml(eventMatch[2]);
+    return {
+        sliceName,
+        after,
+        before,
+        screen: { name: screenName, fields: screenFields },
+        command: { name: commandName, fields: commandFields },
+        event: { name: eventName, fields: eventFields },
+    };
+}
+export function createStateChangeSlice(model, filePath, xmlInput) {
+    // Parse input
+    let input;
+    try {
+        input = parseXmlInput(xmlInput);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Validate slice name is unique
+    try {
+        validateSliceNameUnique(model, input.sliceName);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Calculate position
+    let slicePosition;
+    try {
+        slicePosition = calculateSlicePosition(model, STATE_CHANGE_SLICE.width, {
+            after: input.after,
+            before: input.before,
+        });
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Handle "before" positioning - shift existing slices
+    if (input.before) {
+        const shiftAmount = STATE_CHANGE_SLICE.width + SLICE_GAP;
+        const toShift = getSlicesToShift(model, slicePosition.x, shiftAmount);
+        for (const { sliceId, newX, currentY } of toShift) {
+            appendEvent(filePath, {
+                type: 'SliceMoved',
+                sliceId,
+                position: { x: newX, y: currentY },
+                timestamp: Date.now(),
+            });
+        }
+    }
+    // Generate IDs
+    const sliceId = crypto.randomUUID();
+    const screenId = crypto.randomUUID();
+    const commandId = crypto.randomUUID();
+    const eventId = crypto.randomUUID();
+    const screenToCommandFlowId = crypto.randomUUID();
+    const commandToEventFlowId = crypto.randomUUID();
+    // Convert field inputs to fields with IDs
+    const screenFields = input.screen.fields.map(fieldInputToField);
+    const commandFields = input.command.fields.map(fieldInputToField);
+    const eventFields = input.event.fields.map(fieldInputToField);
+    // Infer field mappings
+    const screenToCommandMappings = inferFieldMappings(screenFields, commandFields);
+    const commandToEventMappings = inferFieldMappings(commandFields, eventFields);
+    // Calculate absolute positions for components within the slice
+    const screenPosition = {
+        x: slicePosition.x + STATE_CHANGE_SLICE.screen.offsetX,
+        y: slicePosition.y + STATE_CHANGE_SLICE.screen.offsetY,
+    };
+    const commandPosition = {
+        x: slicePosition.x + STATE_CHANGE_SLICE.command.offsetX,
+        y: slicePosition.y + STATE_CHANGE_SLICE.command.offsetY,
+    };
+    const eventPosition = {
+        x: slicePosition.x + STATE_CHANGE_SLICE.event.offsetX,
+        y: slicePosition.y + STATE_CHANGE_SLICE.event.offsetY,
+    };
+    // Emit atomic events in sequence
+    // 1. Create the slice
+    appendEvent(filePath, {
+        type: 'SlicePlaced',
+        sliceId,
+        name: input.sliceName,
+        position: slicePosition,
+        size: { width: STATE_CHANGE_SLICE.width, height: STATE_CHANGE_SLICE.height },
+        timestamp: Date.now(),
+    });
+    // 2. Create the screen
+    appendEvent(filePath, {
+        type: 'ScreenPlaced',
+        screenId,
+        name: input.screen.name,
+        position: screenPosition,
+        width: STATE_CHANGE_SLICE.screen.width,
+        height: STATE_CHANGE_SLICE.screen.height,
+        timestamp: Date.now(),
+    });
+    // 3. Add screen fields
+    for (const field of screenFields) {
+        appendEvent(filePath, {
+            type: 'ScreenFieldAdded',
+            screenId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 4. Create the command
+    appendEvent(filePath, {
+        type: 'CommandStickyPlaced',
+        commandStickyId: commandId,
+        name: input.command.name,
+        position: commandPosition,
+        width: STATE_CHANGE_SLICE.command.width,
+        height: STATE_CHANGE_SLICE.command.height,
+        timestamp: Date.now(),
+    });
+    // 5. Add command fields
+    for (const field of commandFields) {
+        appendEvent(filePath, {
+            type: 'CommandFieldAdded',
+            commandStickyId: commandId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 6. Create the event
+    appendEvent(filePath, {
+        type: 'EventStickyPlaced',
+        eventStickyId: eventId,
+        name: input.event.name,
+        position: eventPosition,
+        width: STATE_CHANGE_SLICE.event.width,
+        height: STATE_CHANGE_SLICE.event.height,
+        timestamp: Date.now(),
+    });
+    // 7. Add event fields
+    for (const field of eventFields) {
+        appendEvent(filePath, {
+            type: 'EventFieldAdded',
+            eventStickyId: eventId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    // 8. Create screen -> command flow
+    appendEvent(filePath, {
+        type: 'ScreenToCommandFlowSpecified',
+        flowId: screenToCommandFlowId,
+        screenId,
+        commandStickyId: commandId,
+        sourceHandle: 'bottom-source',
+        targetHandle: 'top-target',
+        timestamp: Date.now(),
+    });
+    // 9. Add screen -> command field mappings
+    if (screenToCommandMappings.length > 0) {
+        appendEvent(filePath, {
+            type: 'FieldMappingSpecified',
+            flowId: screenToCommandFlowId,
+            mappings: screenToCommandMappings,
+            timestamp: Date.now(),
+        });
+    }
+    // 10. Create command -> event flow
+    appendEvent(filePath, {
+        type: 'CommandToEventFlowSpecified',
+        flowId: commandToEventFlowId,
+        commandStickyId: commandId,
+        eventStickyId: eventId,
+        sourceHandle: 'bottom-source',
+        targetHandle: 'top-target',
+        timestamp: Date.now(),
+    });
+    // 11. Add command -> event field mappings
+    if (commandToEventMappings.length > 0) {
+        appendEvent(filePath, {
+            type: 'FieldMappingSpecified',
+            flowId: commandToEventFlowId,
+            mappings: commandToEventMappings,
+            timestamp: Date.now(),
+        });
+    }
+    console.log(`Created state-change slice "${input.sliceName}"`);
+    console.log(`  Screen: ${input.screen.name} (${screenFields.length} fields)`);
+    console.log(`  Command: ${input.command.name} (${commandFields.length} fields)`);
+    console.log(`  Event: ${input.event.name} (${eventFields.length} fields)`);
+    console.log(`  Screen -> Command mappings: ${screenToCommandMappings.length}`);
+    console.log(`  Command -> Event mappings: ${commandToEventMappings.length}`);
+}

package/dist/slices/create-state-view-slice/index.d.ts

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

package/dist/slices/create-state-view-slice/index.js

@@ -0,0 +1,120 @@
+import { appendEvent } from '../../lib/file-loader.js';
+import { STATE_VIEW_SLICE, SLICE_GAP, calculateSlicePosition, validateSliceNameUnique, parseFieldsFromXml, getSlicesToShift, fieldInputToField, } from '../../lib/slice-utils.js';
+function getAttr(attrs, name) {
+    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
+    return match ? match[1] : undefined;
+}
+function parseXmlInput(xml) {
+    // Parse <state-view-slice name="..." after="..." before="...">
+    const sliceMatch = xml.match(/<state-view-slice([^>]*)>/);
+    if (!sliceMatch) {
+        throw new Error('Invalid XML: missing <state-view-slice> tag');
+    }
+    const sliceName = getAttr(sliceMatch[1], 'name');
+    if (!sliceName) {
+        throw new Error('Invalid XML: state-view-slice must have a name attribute');
+    }
+    const after = getAttr(sliceMatch[1], 'after');
+    const before = getAttr(sliceMatch[1], 'before');
+    // Parse read-model
+    const readModelMatch = xml.match(/<read-model([^>]*)>([\s\S]*?)<\/read-model>/);
+    if (!readModelMatch) {
+        throw new Error('Invalid XML: missing <read-model> element');
+    }
+    const readModelName = getAttr(readModelMatch[1], 'name');
+    if (!readModelName) {
+        throw new Error('Invalid XML: read-model must have a name attribute');
+    }
+    const readModelFields = parseFieldsFromXml(readModelMatch[2]);
+    return {
+        sliceName,
+        after,
+        before,
+        readModel: { name: readModelName, fields: readModelFields },
+    };
+}
+export function createStateViewSlice(model, filePath, xmlInput) {
+    // Parse input
+    let input;
+    try {
+        input = parseXmlInput(xmlInput);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Validate slice name is unique
+    try {
+        validateSliceNameUnique(model, input.sliceName);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Calculate position
+    let slicePosition;
+    try {
+        slicePosition = calculateSlicePosition(model, STATE_VIEW_SLICE.width, {
+            after: input.after,
+            before: input.before,
+        });
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Handle "before" positioning - shift existing slices
+    if (input.before) {
+        const shiftAmount = STATE_VIEW_SLICE.width + SLICE_GAP;
+        const toShift = getSlicesToShift(model, slicePosition.x, shiftAmount);
+        for (const { sliceId, newX, currentY } of toShift) {
+            appendEvent(filePath, {
+                type: 'SliceMoved',
+                sliceId,
+                position: { x: newX, y: currentY },
+                timestamp: Date.now(),
+            });
+        }
+    }
+    // Generate IDs
+    const sliceId = crypto.randomUUID();
+    const readModelId = crypto.randomUUID();
+    // Convert field inputs to fields with IDs
+    const readModelFields = input.readModel.fields.map(fieldInputToField);
+    // Calculate absolute position for read model within the slice
+    const readModelPosition = {
+        x: slicePosition.x + STATE_VIEW_SLICE.readModel.offsetX,
+        y: slicePosition.y + STATE_VIEW_SLICE.readModel.offsetY,
+    };
+    // Emit atomic events in sequence
+    // 1. Create the slice
+    appendEvent(filePath, {
+        type: 'SlicePlaced',
+        sliceId,
+        name: input.sliceName,
+        position: slicePosition,
+        size: { width: STATE_VIEW_SLICE.width, height: STATE_VIEW_SLICE.height },
+        timestamp: Date.now(),
+    });
+    // 2. Create the read model
+    appendEvent(filePath, {
+        type: 'ReadModelStickyPlaced',
+        readModelStickyId: readModelId,
+        name: input.readModel.name,
+        position: readModelPosition,
+        width: STATE_VIEW_SLICE.readModel.width,
+        height: STATE_VIEW_SLICE.readModel.height,
+        timestamp: Date.now(),
+    });
+    // 3. Add read model fields
+    for (const field of readModelFields) {
+        appendEvent(filePath, {
+            type: 'ReadModelFieldAdded',
+            readModelStickyId: readModelId,
+            field,
+            timestamp: Date.now(),
+        });
+    }
+    console.log(`Created state-view slice "${input.sliceName}"`);
+    console.log(`  ReadModel: ${input.readModel.name} (${readModelFields.length} fields)`);
+}

package/dist/slices/list-chapters/index.js

@@ -5,7 +5,7 @@ export function listChapters(model, format) {
     const sorted = [...chapters].sort((a, b) => a.position.x - b.position.x);
     if (format === 'json') {
         outputJson({
-            chapters: sorted.map(ch => ({ name: ch.name }))
+            chapters: sorted.map(ch => ({ id: ch.id, name: ch.name }))
         });
         return;
     }
@@ -15,7 +15,7 @@ export function listChapters(model, format) {
     }
     console.log('<chapters>');
     for (const chapter of sorted) {
-        console.log(`  <chapter name="${escapeXml(chapter.name)}"/>`);
+        console.log(`  <chapter id="${chapter.id}" name="${escapeXml(chapter.name)}"/>`);
     }
     console.log('</chapters>');
 }

package/dist/slices/list-commands/index.js

@@ -4,7 +4,7 @@ export function listCommands(model, format) {
     const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
     if (format === 'json') {
         outputJson({
-            commands: sorted.map(cmd => ({ name: cmd.name, fields: cmd.fields.length }))
+            commands: sorted.map(cmd => ({ id: cmd.id, name: cmd.name, fields: cmd.fields.length }))
         });
         return;
     }
@@ -14,7 +14,7 @@ export function listCommands(model, format) {
     }
     console.log('<commands>');
     for (const cmd of sorted) {
-        console.log(`  <command name="${escapeXml(cmd.name)}" fields="${cmd.fields.length}"/>`);
+        console.log(`  <command id="${cmd.id}" name="${escapeXml(cmd.name)}" fields="${cmd.fields.length}"/>`);
     }
     console.log('</commands>');
 }

package/dist/slices/list-events/index.js

@@ -47,6 +47,7 @@ export function listEvents(model, format) {
             events: sorted.map(evt => {
                 const aggregate = findAggregateForEvent(model, evt);
                 const result = {
+                    id: evt.id,
                     name: evt.name,
                     fields: evt.fields.length,
                 };
@@ -82,7 +83,7 @@ export function listEvents(model, format) {
             const original = model.events.get(evt.originalNodeId);
             const originSlice = original ? findSliceForEvent(model, original) : null;
             const originAttr = originSlice ? ` origin-slice="${escapeXml(originSlice)}"` : '';
-            console.log(`  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr} linked-copy="true"${originAttr}/>`);
+            console.log(`  <event id="${evt.id}" name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr} linked-copy="true"${originAttr}/>`);
         }
         else {
             // This is an original - show copy count
@@ -90,7 +91,7 @@ export function listEvents(model, format) {
                 ? [...model.events.values()].filter(e => e.canonicalId === evt.canonicalId && e.originalNodeId).length
                 : 0;
             const copiesAttr = copyCount > 0 ? ` copies="${copyCount}"` : '';
-            console.log(`  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr}${copiesAttr}/>`);
+            console.log(`  <event id="${evt.id}" name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr}${copiesAttr}/>`);
         }
     }
     console.log('</events>');

package/dist/slices/list-slices/index.js

@@ -4,7 +4,7 @@ export function listSlices(model, format) {
     const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
     if (format === 'json') {
         outputJson({
-            slices: sorted.map(s => ({ name: s.name, status: s.status }))
+            slices: sorted.map(s => ({ id: s.id, name: s.name, status: s.status }))
         });
         return;
     }
@@ -14,7 +14,7 @@ export function listSlices(model, format) {
     }
     console.log('<slices>');
     for (const slice of sorted) {
-        console.log(`  <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
+        console.log(`  <slice id="${slice.id}" name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
     }
     console.log('</slices>');
 }

package/dist/slices/mark-slice-status/index.js

@@ -1,4 +1,5 @@
 import { appendEvent } from '../../lib/file-loader.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 const validStatuses = ['created', 'in-progress', 'blocked', 'done'];
 const eventTypeMap = {
     'created': 'SliceMarkedAsCreated',
@@ -13,17 +14,7 @@ export function markSliceStatus(model, filePath, sliceName, status) {
         process.exit(1);
     }
     const newStatus = status;
-    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');
     if (slice.status === newStatus) {
         console.log(`Slice "${slice.name}" is already marked as ${newStatus}`);
         return;

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

@@ -1,4 +1,5 @@
 import { appendEvent } from '../../lib/file-loader.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 export function removeField(model, filePath, options, fieldName) {
     // Determine which entity type
     const entityCount = [options.command, options.event, options.readModel].filter(Boolean).length;
@@ -21,17 +22,7 @@ export function removeField(model, filePath, options, fieldName) {
     }
 }
 function removeFieldFromCommand(model, filePath, commandName, fieldName) {
-    const nameLower = commandName.toLowerCase();
-    const commands = [...model.commands.values()];
-    const command = commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
-    if (!command) {
-        console.error(`Error: Command not found: ${commandName}`);
-        console.error('Available commands:');
-        for (const c of commands) {
-            console.error(`  - ${c.name}`);
-        }
-        process.exit(1);
-    }
+    const command = findElementOrExit(model.commands, commandName, 'command');
     const fieldNameLower = fieldName.toLowerCase();
     const field = command.fields.find(f => f.name.toLowerCase() === fieldNameLower);
     if (!field) {
@@ -56,17 +47,7 @@ function removeFieldFromCommand(model, filePath, commandName, fieldName) {
     console.log(`Removed field "${field.name}" from command "${command.name}"`);
 }
 function removeFieldFromEvent(model, filePath, eventName, fieldName) {
-    const nameLower = eventName.toLowerCase();
-    const events = [...model.events.values()];
-    const event = events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
-    if (!event) {
-        console.error(`Error: Event not found: ${eventName}`);
-        console.error('Available events:');
-        for (const e of events) {
-            console.error(`  - ${e.name}`);
-        }
-        process.exit(1);
-    }
+    const event = findElementOrExit(model.events, eventName, 'event');
     const fieldNameLower = fieldName.toLowerCase();
     const field = event.fields.find(f => f.name.toLowerCase() === fieldNameLower);
     if (!field) {
@@ -91,17 +72,7 @@ function removeFieldFromEvent(model, filePath, eventName, fieldName) {
     console.log(`Removed field "${field.name}" from event "${event.name}"`);
 }
 function removeFieldFromReadModel(model, filePath, readModelName, fieldName) {
-    const nameLower = readModelName.toLowerCase();
-    const readModels = [...model.readModels.values()];
-    const readModel = readModels.find(rm => rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower));
-    if (!readModel) {
-        console.error(`Error: Read model not found: ${readModelName}`);
-        console.error('Available read models:');
-        for (const rm of readModels) {
-            console.error(`  - ${rm.name}`);
-        }
-        process.exit(1);
-    }
+    const readModel = findElementOrExit(model.readModels, readModelName, 'read model');
     const fieldNameLower = fieldName.toLowerCase();
     const field = readModel.fields.find(f => f.name.toLowerCase() === fieldNameLower);
     if (!field) {

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

@@ -1,31 +1,65 @@
 import { appendEvent } from '../../lib/file-loader.js';
+import { findElement, formatElementWithId } from '../../lib/element-lookup.js';
 export function removeScenario(model, filePath, scenarioName, sliceName) {
+    // Check for UUID lookup
+    if (scenarioName.startsWith('id:')) {
+        const idSearch = scenarioName.slice(3).toLowerCase();
+        const scenario = [...model.scenarios.values()].find(s => s.id.toLowerCase().startsWith(idSearch));
+        if (!scenario) {
+            console.error(`Error: Scenario not found with ID starting with: "${idSearch}"`);
+            console.error('Available scenarios:');
+            for (const s of model.scenarios.values()) {
+                const slice = model.slices.get(s.sliceId);
+                console.error(`  - "${s.name}" (id: ${s.id.slice(0, 8)}) (in slice "${slice?.name ?? 'unknown'}")`);
+            }
+            process.exit(1);
+        }
+        const slice = model.slices.get(scenario.sliceId);
+        appendEvent(filePath, {
+            type: 'ScenarioRemoved',
+            scenarioId: scenario.id,
+            timestamp: Date.now(),
+        });
+        console.log(`Removed scenario "${scenario.name}" from slice "${slice?.name ?? 'unknown'}"`);
+        return;
+    }
+    // Case-insensitive exact name match
     const scenarioNameLower = scenarioName.toLowerCase();
-    // Find scenarios matching the name
-    let matchingScenarios = [...model.scenarios.values()].filter(s => s.name.toLowerCase() === scenarioNameLower || s.name.toLowerCase().includes(scenarioNameLower));
-    // If slice name provided, filter to that slice
+    let matchingScenarios = [...model.scenarios.values()].filter(s => s.name.toLowerCase() === scenarioNameLower);
+    // If slice name provided, filter to that slice using exact match
     if (sliceName && matchingScenarios.length > 0) {
-        const sliceNameLower = sliceName.toLowerCase();
-        const slice = [...model.slices.values()].find(s => s.name.toLowerCase() === sliceNameLower || s.name.toLowerCase().includes(sliceNameLower));
-        if (slice) {
-            matchingScenarios = matchingScenarios.filter(s => s.sliceId === slice.id);
+        const sliceResult = findElement(model.slices, sliceName);
+        if (sliceResult.success) {
+            matchingScenarios = matchingScenarios.filter(s => s.sliceId === sliceResult.element.id);
+        }
+        else if (sliceResult.error === 'ambiguous') {
+            console.error(`Error: Multiple slices found with name "${sliceName}"`);
+            console.error('Please specify using the slice ID:');
+            for (const s of sliceResult.matches) {
+                console.error(`  - ${formatElementWithId(s, false)}`);
+            }
+            process.exit(1);
         }
+        // If slice not found, just proceed without filtering
     }
     if (matchingScenarios.length === 0) {
-        console.error(`Error: Scenario not found: ${scenarioName}`);
+        console.error(`Error: Scenario not found: "${scenarioName}"`);
         console.error('Available scenarios:');
         for (const s of model.scenarios.values()) {
             const slice = model.slices.get(s.sliceId);
-            console.error(`  - "${s.name}" (in slice "${slice?.name ?? 'unknown'}")`);
+            console.error(`  - "${s.name}" (id: ${s.id.slice(0, 8)}) (in slice "${slice?.name ?? 'unknown'}")`);
         }
         process.exit(1);
     }
     if (matchingScenarios.length > 1) {
-        console.error(`Error: Multiple scenarios match "${scenarioName}". Use --slice to disambiguate:`);
+        console.error(`Error: Multiple scenarios found with name "${scenarioName}"`);
+        console.error('Please specify using the scenario ID or --slice to disambiguate:');
         for (const s of matchingScenarios) {
             const slice = model.slices.get(s.sliceId);
-            console.error(`  - "${s.name}" in slice "${slice?.name ?? 'unknown'}"`);
+            console.error(`  - "${s.name}" (id: ${s.id.slice(0, 8)}) (in slice "${slice?.name ?? 'unknown'}")`);
         }
+        console.error('');
+        console.error(`Usage: eventmodeler remove scenario "id:${matchingScenarios[0].id.slice(0, 8)}"`);
         process.exit(1);
     }
     const scenario = matchingScenarios[0];

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

@@ -1,4 +1,5 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 // Get screens whose center point is inside the actor bounds
 function getScreensInActor(model, actor) {
     const bounds = {
@@ -30,17 +31,7 @@ function findSliceForScreen(model, screen) {
 }
 export function showActor(model, actorName, format) {
     // Find the actor
-    const nameLower = actorName.toLowerCase();
-    const actors = [...model.actors.values()];
-    const actor = actors.find(a => a.name.toLowerCase() === nameLower || a.name.toLowerCase().includes(nameLower));
-    if (!actor) {
-        console.error(`Error: Actor not found: ${actorName}`);
-        console.error('Available actors:');
-        for (const a of actors) {
-            console.error(`  - ${a.name}`);
-        }
-        process.exit(1);
-    }
+    const actor = findElementOrExit(model.actors, actorName, 'actor');
     // Get screens dynamically based on position (center point inside actor bounds)
     const screensInActor = getScreensInActor(model, actor);
     if (format === 'json') {

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

@@ -1,4 +1,5 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function findMatchingField(fields, targetName, targetType) {
     for (const field of fields) {
         // Check if name and type match
@@ -34,17 +35,7 @@ function getEventsInAggregate(model, aggregate) {
 }
 export function showAggregateCompleteness(model, aggregateName, format) {
     // Find the aggregate
-    const nameLower = aggregateName.toLowerCase();
-    const aggregates = [...model.aggregates.values()];
-    const aggregate = aggregates.find(a => a.name.toLowerCase() === nameLower || a.name.toLowerCase().includes(nameLower));
-    if (!aggregate) {
-        console.error(`Error: Aggregate not found: ${aggregateName}`);
-        console.error('Available aggregates:');
-        for (const a of aggregates) {
-            console.error(`  - ${a.name}`);
-        }
-        process.exit(1);
-    }
+    const aggregate = findElementOrExit(model.aggregates, aggregateName, 'aggregate');
     // Get events dynamically based on position (center point inside aggregate bounds)
     const eventsInAggregate = getEventsInAggregate(model, aggregate);
     // Check if aggregate has ID field configured