eventmodeler 0.2.3 → 0.2.4

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

@@ -1,4 +1,5 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function getSlicesUnderChapter(model, chapter) {
     // A slice is "under" a chapter if its horizontal center falls within the chapter's x range
     const chapterLeft = chapter.position.x;
@@ -9,33 +10,24 @@ function getSlicesUnderChapter(model, chapter) {
     }).sort((a, b) => a.position.x - b.position.x);
 }
 export function showChapter(model, name, format) {
-    const chapters = [...model.chapters.values()];
-    const nameLower = name.toLowerCase();
-    const chapter = chapters.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
-    if (!chapter) {
-        console.error(`Error: Chapter not found: ${name}`);
-        console.error('Available chapters:');
-        for (const c of chapters) {
-            console.error(`  - ${c.name}`);
-        }
-        process.exit(1);
-    }
+    const chapter = findElementOrExit(model.chapters, name, 'chapter');
     const slices = getSlicesUnderChapter(model, chapter);
     if (format === 'json') {
         outputJson({
+            id: chapter.id,
             name: chapter.name,
-            slices: slices.map(s => ({ name: s.name, status: s.status }))
+            slices: slices.map(s => ({ id: s.id, name: s.name, status: s.status }))
         });
         return;
     }
-    console.log(`<chapter name="${escapeXml(chapter.name)}">`);
+    console.log(`<chapter id="${chapter.id}" name="${escapeXml(chapter.name)}">`);
     if (slices.length === 0) {
         console.log('  <slices/>');
     }
     else {
         console.log('  <slices>');
         for (const slice of slices) {
-            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/show-command/index.js

@@ -1,4 +1,5 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function formatFieldXml(field, indent) {
     const attrs = [
         `name="${escapeXml(field.name)}"`,
@@ -54,7 +55,7 @@ function findAggregateForEvent(model, event) {
     return null;
 }
 function formatCommandXml(model, command) {
-    let xml = `<command name="${escapeXml(command.name)}">\n`;
+    let xml = `<command id="${command.id}" name="${escapeXml(command.name)}">\n`;
     if (command.fields.length > 0) {
         xml += '  <fields>\n';
         for (const field of command.fields) {
@@ -92,21 +93,12 @@ function formatCommandXml(model, command) {
     return xml;
 }
 export function showCommand(model, name, format) {
-    const commands = [...model.commands.values()];
-    const nameLower = name.toLowerCase();
-    const command = commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
-    if (!command) {
-        console.error(`Error: Command not found: ${name}`);
-        console.error('Available commands:');
-        for (const c of commands) {
-            console.error(`  - ${c.name}`);
-        }
-        process.exit(1);
-    }
+    const command = findElementOrExit(model.commands, name, 'command');
     if (format === 'json') {
         const incomingFlows = [...model.flows.values()].filter(f => f.targetId === command.id);
         const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === command.id);
         const result = {
+            id: command.id,
             name: command.name,
             fields: command.fields.map(fieldToJson)
         };

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

@@ -7,38 +7,92 @@ const INCOMING_FLOW_TYPES = {
     processor: ['ReadModelToProcessor'],
 };
 function findElementByName(model, name) {
+    // Check for UUID lookup (id:prefix or full UUID format)
+    if (name.startsWith('id:')) {
+        const idSearch = name.slice(3).toLowerCase();
+        // Search all element types by ID
+        for (const cmd of model.commands.values()) {
+            if (cmd.id.toLowerCase().startsWith(idSearch)) {
+                return { element: { id: cmd.id, name: cmd.name, fields: cmd.fields, type: 'command' }, ambiguous: [] };
+            }
+        }
+        for (const evt of model.events.values()) {
+            if (evt.id.toLowerCase().startsWith(idSearch)) {
+                return { element: { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' }, ambiguous: [] };
+            }
+        }
+        for (const rm of model.readModels.values()) {
+            if (rm.id.toLowerCase().startsWith(idSearch)) {
+                return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, ambiguous: [] };
+            }
+        }
+        for (const scr of model.screens.values()) {
+            if (scr.id.toLowerCase().startsWith(idSearch)) {
+                return { element: { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' }, ambiguous: [] };
+            }
+        }
+        for (const proc of model.processors.values()) {
+            if (proc.id.toLowerCase().startsWith(idSearch)) {
+                return { element: { id: proc.id, name: proc.name, fields: proc.fields, type: 'processor' }, ambiguous: [] };
+            }
+        }
+        return { element: null, ambiguous: [] };
+    }
+    // Check if it's a full UUID
+    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(name)) {
+        const cmd = model.commands.get(name);
+        if (cmd)
+            return { element: { id: cmd.id, name: cmd.name, fields: cmd.fields, type: 'command' }, ambiguous: [] };
+        const evt = model.events.get(name);
+        if (evt)
+            return { element: { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' }, ambiguous: [] };
+        const rm = model.readModels.get(name);
+        if (rm)
+            return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, ambiguous: [] };
+        const scr = model.screens.get(name);
+        if (scr)
+            return { element: { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' }, ambiguous: [] };
+        const proc = model.processors.get(name);
+        if (proc)
+            return { element: { id: proc.id, name: proc.name, fields: proc.fields, type: 'processor' }, ambiguous: [] };
+        return { element: null, ambiguous: [] };
+    }
+    // Case-insensitive exact name match across all types
     const nameLower = name.toLowerCase();
-    // Search commands
+    const matches = [];
     for (const cmd of model.commands.values()) {
-        if (cmd.name.toLowerCase() === nameLower || cmd.name.toLowerCase().includes(nameLower)) {
-            return { id: cmd.id, name: cmd.name, fields: cmd.fields, type: 'command' };
+        if (cmd.name.toLowerCase() === nameLower) {
+            matches.push({ element: { id: cmd.id, name: cmd.name, fields: cmd.fields, type: 'command' }, type: 'command' });
         }
     }
-    // Search events
     for (const evt of model.events.values()) {
-        if (evt.name.toLowerCase() === nameLower || evt.name.toLowerCase().includes(nameLower)) {
-            return { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' };
+        if (evt.name.toLowerCase() === nameLower) {
+            matches.push({ element: { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' }, type: 'event' });
         }
     }
-    // Search read models
     for (const rm of model.readModels.values()) {
-        if (rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower)) {
-            return { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' };
+        if (rm.name.toLowerCase() === nameLower) {
+            matches.push({ element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel' }, type: 'readModel' });
         }
     }
-    // Search screens
     for (const scr of model.screens.values()) {
-        if (scr.name.toLowerCase() === nameLower || scr.name.toLowerCase().includes(nameLower)) {
-            return { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' };
+        if (scr.name.toLowerCase() === nameLower) {
+            matches.push({ element: { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' }, type: 'screen' });
         }
     }
-    // Search processors
     for (const proc of model.processors.values()) {
-        if (proc.name.toLowerCase() === nameLower || proc.name.toLowerCase().includes(nameLower)) {
-            return { id: proc.id, name: proc.name, fields: proc.fields, type: 'processor' };
+        if (proc.name.toLowerCase() === nameLower) {
+            matches.push({ element: { id: proc.id, name: proc.name, fields: proc.fields, type: 'processor' }, type: 'processor' });
         }
     }
-    return null;
+    if (matches.length === 1) {
+        return { element: matches[0].element, ambiguous: [] };
+    }
+    if (matches.length > 1) {
+        return { element: null, ambiguous: matches };
+    }
+    return { element: null, ambiguous: [] };
 }
 function getSourceFields(model, sourceId) {
     const cmd = model.commands.get(sourceId);
@@ -159,10 +213,45 @@ function calculateFlowCompleteness(model, flow, targetFields, sourceFields) {
 }
 export function showCompleteness(model, elementName, format) {
     // Find the element by name (searches all element types)
-    const element = findElementByName(model, elementName);
+    const { element, ambiguous } = findElementByName(model, elementName);
+    if (ambiguous.length > 0) {
+        console.error(`Error: Multiple elements found with name "${elementName}"`);
+        console.error('Please specify using the element ID:');
+        for (const match of ambiguous) {
+            console.error(`  - "${match.element.name}" (${match.type}) (id: ${match.element.id})`);
+        }
+        console.error('');
+        console.error(`Usage: eventmodeler show completeness "id:${ambiguous[0].element.id.slice(0, 8)}"`);
+        process.exit(1);
+    }
     if (!element) {
-        console.error(`Error: Element not found: ${elementName}`);
-        console.error('Search looked in: commands, events, read models, screens, processors');
+        console.error(`Error: Element not found: "${elementName}"`);
+        // List all available elements with their IDs
+        const allElements = [];
+        for (const cmd of model.commands.values()) {
+            allElements.push({ name: cmd.name, type: 'command', id: cmd.id });
+        }
+        for (const evt of model.events.values()) {
+            allElements.push({ name: evt.name, type: 'event', id: evt.id });
+        }
+        for (const rm of model.readModels.values()) {
+            allElements.push({ name: rm.name, type: 'read model', id: rm.id });
+        }
+        for (const scr of model.screens.values()) {
+            allElements.push({ name: scr.name, type: 'screen', id: scr.id });
+        }
+        for (const proc of model.processors.values()) {
+            allElements.push({ name: proc.name, type: 'processor', id: proc.id });
+        }
+        if (allElements.length > 0) {
+            console.error('Available elements:');
+            for (const el of allElements) {
+                console.error(`  - "${el.name}" (${el.type}) (id: ${el.id.slice(0, 8)})`);
+            }
+        }
+        else {
+            console.error('No elements exist in the model.');
+        }
         process.exit(1);
     }
     // Find all incoming flows for this element type

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

@@ -1,4 +1,5 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function formatFieldXml(field, indent) {
     const attrs = [
         `name="${escapeXml(field.name)}"`,
@@ -56,7 +57,7 @@ function findAggregateForEvent(model, event) {
 function formatEventXml(model, event) {
     const aggregate = findAggregateForEvent(model, event);
     const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
-    let xml = `<event name="${escapeXml(event.name)}"${aggregateAttr}>\n`;
+    let xml = `<event id="${event.id}" name="${escapeXml(event.name)}"${aggregateAttr}>\n`;
     if (event.fields.length > 0) {
         xml += '  <fields>\n';
         for (const field of event.fields) {
@@ -88,22 +89,13 @@ function formatEventXml(model, event) {
     return xml;
 }
 export function showEvent(model, name, format) {
-    const events = [...model.events.values()];
-    const nameLower = name.toLowerCase();
-    const event = events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
-    if (!event) {
-        console.error(`Error: Event not found: ${name}`);
-        console.error('Available events:');
-        for (const e of events) {
-            console.error(`  - ${e.name}`);
-        }
-        process.exit(1);
-    }
+    const event = findElementOrExit(model.events, name, 'event');
     if (format === 'json') {
         const aggregate = findAggregateForEvent(model, event);
         const incomingFlows = [...model.flows.values()].filter(f => f.targetId === event.id);
         const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === event.id);
         const result = {
+            id: event.id,
             name: event.name,
             fields: event.fields.map(fieldToJson)
         };

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

@@ -1,4 +1,5 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function formatFieldValues(values) {
     if (!values || Object.keys(values).length === 0)
         return '';
@@ -120,7 +121,7 @@ function formatSliceXml(model, slice) {
             model.processors.get(id)?.name ??
             id);
     }
-    let xml = `<slice name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
+    let xml = `<slice id="${slice.id}" name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
     xml += '  <components>\n';
     for (const screen of components.screens) {
         // Check if this is a linked copy
@@ -135,7 +136,7 @@ function formatSliceXml(model, slice) {
         // Check which actor this screen belongs to
         const actor = findActorForScreen(model, screen);
         const actorAttr = actor ? ` actor="${escapeXml(actor.name)}"` : '';
-        xml += `    <screen name="${escapeXml(screen.name)}"${copyAttr}${originAttr}${actorAttr}>\n`;
+        xml += `    <screen id="${screen.id}" name="${escapeXml(screen.name)}"${copyAttr}${originAttr}${actorAttr}>\n`;
         if (screen.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of screen.fields) {
@@ -146,7 +147,7 @@ function formatSliceXml(model, slice) {
         xml += '    </screen>\n';
     }
     for (const command of components.commands) {
-        xml += `    <command name="${escapeXml(command.name)}">\n`;
+        xml += `    <command id="${command.id}" name="${escapeXml(command.name)}">\n`;
         if (command.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of command.fields) {
@@ -177,7 +178,7 @@ function formatSliceXml(model, slice) {
         // Check which aggregate this event belongs to
         const aggregate = findAggregateForEvent(model, event);
         const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
-        xml += `    <event name="${escapeXml(event.name)}"${copyAttr}${originAttr}${aggregateAttr}>\n`;
+        xml += `    <event id="${event.id}" name="${escapeXml(event.name)}"${copyAttr}${originAttr}${aggregateAttr}>\n`;
         if (event.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of event.fields) {
@@ -208,7 +209,7 @@ function formatSliceXml(model, slice) {
                 originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
             }
         }
-        xml += `    <read-model name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
+        xml += `    <read-model id="${readModel.id}" name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
         if (readModel.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of readModel.fields) {
@@ -219,7 +220,7 @@ function formatSliceXml(model, slice) {
         xml += '    </read-model>\n';
     }
     for (const processor of components.processors) {
-        xml += `    <processor name="${escapeXml(processor.name)}">\n`;
+        xml += `    <processor id="${processor.id}" name="${escapeXml(processor.name)}">\n`;
         if (processor.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of processor.fields) {
@@ -337,11 +338,13 @@ function formatSliceJson(model, slice) {
             id);
     }
     const result = {
+        id: slice.id,
         name: slice.name,
         status: slice.status,
         components: {
             screens: components.screens.map(screen => {
                 const screenObj = {
+                    id: screen.id,
                     name: screen.name,
                     fields: screen.fields.map(fieldToJson)
                 };
@@ -357,11 +360,13 @@ function formatSliceJson(model, slice) {
                 return screenObj;
             }),
             commands: components.commands.map(cmd => ({
+                id: cmd.id,
                 name: cmd.name,
                 fields: cmd.fields.map(fieldToJson)
             })),
             events: components.events.map(event => {
                 const eventObj = {
+                    id: event.id,
                     name: event.name,
                     fields: event.fields.map(fieldToJson)
                 };
@@ -378,6 +383,7 @@ function formatSliceJson(model, slice) {
             }),
             readModels: components.readModels.map(rm => {
                 const rmObj = {
+                    id: rm.id,
                     name: rm.name,
                     fields: rm.fields.map(fieldToJson)
                 };
@@ -390,6 +396,7 @@ function formatSliceJson(model, slice) {
                 return rmObj;
             }),
             processors: components.processors.map(proc => ({
+                id: proc.id,
                 name: proc.name,
                 fields: proc.fields.map(fieldToJson)
             }))
@@ -456,17 +463,7 @@ function formatSliceJson(model, slice) {
     return result;
 }
 export function showSlice(model, name, format) {
-    const slices = [...model.slices.values()];
-    const nameLower = name.toLowerCase();
-    const slice = slices.find(s => s.name.toLowerCase() === nameLower || s.name.toLowerCase().includes(nameLower));
-    if (!slice) {
-        console.error(`Error: Slice not found: ${name}`);
-        console.error('Available slices:');
-        for (const s of slices) {
-            console.error(`  - ${s.name}`);
-        }
-        process.exit(1);
-    }
+    const slice = findElementOrExit(model.slices, name, 'slice');
     if (format === 'json') {
         outputJson(formatSliceJson(model, slice));
         return;

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

@@ -1,4 +1,5 @@
 import { appendEvent } from '../../lib/file-loader.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 function findFieldByName(fields, fieldName) {
     const nameLower = fieldName.toLowerCase();
     for (const field of fields) {
@@ -52,17 +53,7 @@ export function updateField(model, filePath, options, fieldName, updates) {
     }
 }
 function updateCommandField(model, filePath, commandName, fieldName, updates) {
-    const nameLower = commandName.toLowerCase();
-    const commands = [...model.commands.values()];
-    const command = commands.find(c => c.name.toLowerCase() === nameLower || c.name.toLowerCase().includes(nameLower));
-    if (!command) {
-        console.error(`Error: Command not found: ${commandName}`);
-        console.error('Available commands:');
-        for (const c of commands) {
-            console.error(`  - ${c.name}`);
-        }
-        process.exit(1);
-    }
+    const command = findElementOrExit(model.commands, commandName, 'command');
     const field = findFieldByName(command.fields, fieldName);
     if (!field) {
         console.error(`Error: Field "${fieldName}" not found on command "${command.name}"`);
@@ -86,17 +77,7 @@ function updateCommandField(model, filePath, commandName, fieldName, updates) {
     logUpdates(updates);
 }
 function updateEventField(model, filePath, eventName, fieldName, updates) {
-    const nameLower = eventName.toLowerCase();
-    const events = [...model.events.values()];
-    const event = events.find(e => e.name.toLowerCase() === nameLower || e.name.toLowerCase().includes(nameLower));
-    if (!event) {
-        console.error(`Error: Event not found: ${eventName}`);
-        console.error('Available events:');
-        for (const e of events) {
-            console.error(`  - ${e.name}`);
-        }
-        process.exit(1);
-    }
+    const event = findElementOrExit(model.events, eventName, 'event');
     const field = findFieldByName(event.fields, fieldName);
     if (!field) {
         console.error(`Error: Field "${fieldName}" not found on event "${event.name}"`);
@@ -120,17 +101,7 @@ function updateEventField(model, filePath, eventName, fieldName, updates) {
     logUpdates(updates);
 }
 function updateReadModelField(model, filePath, readModelName, fieldName, updates) {
-    const nameLower = readModelName.toLowerCase();
-    const readModels = [...model.readModels.values()];
-    const readModel = readModels.find(rm => rm.name.toLowerCase() === nameLower || rm.name.toLowerCase().includes(nameLower));
-    if (!readModel) {
-        console.error(`Error: Read model not found: ${readModelName}`);
-        console.error('Available read models:');
-        for (const rm of readModels) {
-            console.error(`  - ${rm.name}`);
-        }
-        process.exit(1);
-    }
+    const readModel = findElementOrExit(model.readModels, readModelName, 'read model');
     const field = findFieldByName(readModel.fields, fieldName);
     if (!field) {
         console.error(`Error: Field "${fieldName}" not found on read model "${readModel.name}"`);

package/package.json

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