eventmodeler 0.3.1 → 0.3.3

package/dist/index.js

@@ -282,14 +282,16 @@ async function main() {
             break;
         case 'mark': {
             // mark <slice-name> <status> - status is last arg, slice name is everything before
+            // Note: subcommand contains first part of slice name, remainingArgs has the rest
             const validStatuses = ['created', 'in-progress', 'blocked', 'done'];
-            const lastArg = remainingArgs[remainingArgs.length - 1];
-            if (remainingArgs.length < 2 || !validStatuses.includes(lastArg)) {
+            const allArgs = subcommand ? [subcommand, ...remainingArgs] : remainingArgs;
+            const lastArg = allArgs[allArgs.length - 1];
+            if (allArgs.length < 2 || !validStatuses.includes(lastArg)) {
                 console.error('Usage: eventmodeler mark <slice-name> <status>');
                 console.error('Valid statuses: created, in-progress, blocked, done');
                 process.exit(1);
             }
-            const sliceName = remainingArgs.slice(0, -1).join(' ');
+            const sliceName = allArgs.slice(0, -1).join(' ');
             const status = lastArg;
             markSliceStatus(model, filePath, sliceName, status);
             break;

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

@@ -26,6 +26,7 @@ export interface SliceFlowInfo extends FlowInfo {
         name: string;
     };
 }
+export declare function resolveToCanonical(model: EventModel, id: string): string;
 export declare function getElementInfo(model: EventModel, id: string): ElementInfo | null;
 export declare function getSliceComponentIds(model: EventModel, slice: Slice): Set<string>;
 export declare function findSliceForComponent(model: EventModel, componentId: string): Slice | null;

package/dist/lib/flow-utils.js

@@ -1,3 +1,16 @@
+// Resolve a linked copy to its canonical original, or return the ID unchanged if not a copy
+export function resolveToCanonical(model, id) {
+    const screen = model.screens.get(id);
+    if (screen?.originalNodeId)
+        return screen.originalNodeId;
+    const event = model.events.get(id);
+    if (event?.originalNodeId)
+        return event.originalNodeId;
+    const readModel = model.readModels.get(id);
+    if (readModel?.originalNodeId)
+        return readModel.originalNodeId;
+    return id;
+}
 // Get element info (name and type) by ID
 export function getElementInfo(model, id) {
     const screen = model.screens.get(id);
@@ -61,11 +74,12 @@ function isElementInSlice(slice, position, width, height) {
         centerY >= slice.position.y &&
         centerY <= slice.position.y + slice.size.height);
 }
-// Get all component IDs in a slice
+// Get all component IDs in a slice (excludes linked copies - they are UI-only)
 export function getSliceComponentIds(model, slice) {
     const ids = new Set();
+    // Only include canonical elements (not linked copies) that are spatially in the slice
     for (const screen of model.screens.values()) {
-        if (isElementInSlice(slice, screen.position, screen.width, screen.height)) {
+        if (!screen.originalNodeId && isElementInSlice(slice, screen.position, screen.width, screen.height)) {
             ids.add(screen.id);
         }
     }
@@ -75,12 +89,12 @@ export function getSliceComponentIds(model, slice) {
         }
     }
     for (const event of model.events.values()) {
-        if (isElementInSlice(slice, event.position, event.width, event.height)) {
+        if (!event.originalNodeId && isElementInSlice(slice, event.position, event.width, event.height)) {
             ids.add(event.id);
         }
     }
     for (const readModel of model.readModels.values()) {
-        if (isElementInSlice(slice, readModel.position, readModel.width, readModel.height)) {
+        if (!readModel.originalNodeId && isElementInSlice(slice, readModel.position, readModel.width, readModel.height)) {
             ids.add(readModel.id);
         }
     }
@@ -136,10 +150,13 @@ export function findSliceForComponent(model, componentId) {
     }
     return null;
 }
-// Build FlowInfo from a Flow
+// Build FlowInfo from a Flow (resolves linked copies to their canonical originals)
 function buildFlowInfo(model, flow) {
-    const source = getElementInfo(model, flow.sourceId);
-    const target = getElementInfo(model, flow.targetId);
+    // Resolve linked copies to canonical originals
+    const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+    const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+    const source = getElementInfo(model, canonicalSourceId);
+    const target = getElementInfo(model, canonicalTargetId);
     if (!source || !target)
         return null;
     return {
@@ -150,13 +167,16 @@ function buildFlowInfo(model, flow) {
         fieldMappings: enrichFieldMappings(model, flow),
     };
 }
-// Build SliceFlowInfo from a Flow (includes slice info for source/target)
+// Build SliceFlowInfo from a Flow (includes slice info for source/target, resolves linked copies)
 function buildSliceFlowInfo(model, flow) {
     const base = buildFlowInfo(model, flow);
     if (!base)
         return null;
-    const sourceSlice = findSliceForComponent(model, flow.sourceId);
-    const targetSlice = findSliceForComponent(model, flow.targetId);
+    // Resolve linked copies to canonical originals for slice lookup
+    const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+    const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+    const sourceSlice = findSliceForComponent(model, canonicalSourceId);
+    const targetSlice = findSliceForComponent(model, canonicalTargetId);
     return {
         ...base,
         sourceSlice: sourceSlice ? { id: sourceSlice.id, name: sourceSlice.name } : undefined,
@@ -168,7 +188,10 @@ export function getInboundFlows(model, slice) {
     const componentIds = getSliceComponentIds(model, slice);
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (componentIds.has(flow.targetId) && !componentIds.has(flow.sourceId)) {
+        // Resolve linked copies to canonical originals for containment check
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (componentIds.has(canonicalTargetId) && !componentIds.has(canonicalSourceId)) {
             const flowInfo = buildSliceFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);
@@ -181,7 +204,10 @@ export function getOutboundFlows(model, slice) {
     const componentIds = getSliceComponentIds(model, slice);
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (componentIds.has(flow.sourceId) && !componentIds.has(flow.targetId)) {
+        // Resolve linked copies to canonical originals for containment check
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (componentIds.has(canonicalSourceId) && !componentIds.has(canonicalTargetId)) {
             const flowInfo = buildSliceFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);
@@ -194,7 +220,10 @@ export function getInternalFlows(model, slice) {
     const componentIds = getSliceComponentIds(model, slice);
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (componentIds.has(flow.sourceId) && componentIds.has(flow.targetId)) {
+        // Resolve linked copies to canonical originals for containment check
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (componentIds.has(canonicalSourceId) && componentIds.has(canonicalTargetId)) {
             const flowInfo = buildFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);
@@ -202,17 +231,22 @@ export function getInternalFlows(model, slice) {
     }
     return flows;
 }
-// Get all flows for a specific element (both directions)
+// Get all flows for a specific element (both directions, resolves linked copies)
 export function getFlowsForElement(model, elementId) {
     const incoming = [];
     const outgoing = [];
+    // Resolve element ID to canonical if it's a linked copy
+    const canonicalElementId = resolveToCanonical(model, elementId);
     for (const flow of model.flows.values()) {
-        if (flow.targetId === elementId) {
+        // Resolve flow endpoints to canonical originals
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        if (canonicalTargetId === canonicalElementId) {
             const flowInfo = buildFlowInfo(model, flow);
             if (flowInfo)
                 incoming.push(flowInfo);
         }
-        if (flow.sourceId === elementId) {
+        if (canonicalSourceId === canonicalElementId) {
             const flowInfo = buildFlowInfo(model, flow);
             if (flowInfo)
                 outgoing.push(flowInfo);
@@ -230,13 +264,16 @@ export function findSliceToSliceFlows(model, slices) {
     // Group flows by slice pair
     const flowsBySlicePair = new Map();
     for (const flow of model.flows.values()) {
+        // Resolve linked copies to canonical originals
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
         let sourceSliceId = null;
         let targetSliceId = null;
         // Find which slice contains source and target
         for (const [sliceId, componentIds] of sliceComponentMap.entries()) {
-            if (componentIds.has(flow.sourceId))
+            if (componentIds.has(canonicalSourceId))
                 sourceSliceId = sliceId;
-            if (componentIds.has(flow.targetId))
+            if (componentIds.has(canonicalTargetId))
                 targetSliceId = sliceId;
         }
         // Only include flows between different slices in our set
@@ -277,7 +314,10 @@ export function findChapterInboundFlows(model, slices) {
     }
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (chapterComponentIds.has(flow.targetId) && !chapterComponentIds.has(flow.sourceId)) {
+        // Resolve linked copies to canonical originals
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (chapterComponentIds.has(canonicalTargetId) && !chapterComponentIds.has(canonicalSourceId)) {
             const flowInfo = buildSliceFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);
@@ -295,7 +335,10 @@ export function findChapterOutboundFlows(model, slices) {
     }
     const flows = [];
     for (const flow of model.flows.values()) {
-        if (chapterComponentIds.has(flow.sourceId) && !chapterComponentIds.has(flow.targetId)) {
+        // Resolve linked copies to canonical originals
+        const canonicalSourceId = resolveToCanonical(model, flow.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, flow.targetId);
+        if (chapterComponentIds.has(canonicalSourceId) && !chapterComponentIds.has(canonicalTargetId)) {
             const flowInfo = buildSliceFlowInfo(model, flow);
             if (flowInfo)
                 flows.push(flowInfo);

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

@@ -292,12 +292,42 @@ export function codegenSlice(model, sliceName) {
     const slice = findElementOrExit(model.slices, sliceName, 'slice');
     // 2. Get components inside slice
     const components = getSliceComponents(model, slice);
-    // 3. Build component ID set
+    // 3. Build component ID set (including canonical group members for linked copies)
     const componentIds = new Set();
     components.commands.forEach(c => componentIds.add(c.id));
-    components.events.forEach(e => componentIds.add(e.id));
-    components.readModels.forEach(rm => componentIds.add(rm.id));
-    components.screens.forEach(s => componentIds.add(s.id));
+    components.events.forEach(e => {
+        componentIds.add(e.id);
+        // If this is a linked copy, also add all elements in the same canonical group
+        if (e.canonicalId) {
+            for (const evt of model.events.values()) {
+                if (evt.canonicalId === e.canonicalId) {
+                    componentIds.add(evt.id);
+                }
+            }
+        }
+    });
+    components.readModels.forEach(rm => {
+        componentIds.add(rm.id);
+        // If this is a linked copy, also add all elements in the same canonical group
+        if (rm.canonicalId) {
+            for (const r of model.readModels.values()) {
+                if (r.canonicalId === rm.canonicalId) {
+                    componentIds.add(r.id);
+                }
+            }
+        }
+    });
+    components.screens.forEach(s => {
+        componentIds.add(s.id);
+        // If this is a linked copy, also add all elements in the same canonical group
+        if (s.canonicalId) {
+            for (const scr of model.screens.values()) {
+                if (scr.canonicalId === s.canonicalId) {
+                    componentIds.add(scr.id);
+                }
+            }
+        }
+    });
     components.processors.forEach(p => componentIds.add(p.id));
     // 4. Determine slice type
     const sliceType = determineSliceType(components.processors.length > 0, components.commands.length > 0, components.events.length > 0, components.readModels.length > 0, components.screens.length > 0);

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

@@ -1,7 +1,7 @@
 import { escapeXml, escapeXmlText, outputJson } from '../../lib/format.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
 import { findChapterForSlice, getChapterHierarchy } from '../../lib/chapter-utils.js';
-import { getInboundFlows, getOutboundFlows, getFlowsForElement, } from '../../lib/flow-utils.js';
+import { getInboundFlows, getOutboundFlows, getFlowsForElement, getSliceComponentIds, resolveToCanonical, } from '../../lib/flow-utils.js';
 function formatFieldValues(values) {
     if (!values || Object.keys(values).length === 0)
         return '';
@@ -46,36 +46,16 @@ function getSliceComponents(model, slice) {
         const centerY = pos.y + height / 2;
         return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
     }
-    // Include all elements in the slice (including linked copies)
-    // Linked copies will be marked as such in the output
+    // Only include canonical elements - linked copies are UI-only conveniences
+    // and should not appear as slice contents in CLI output
     return {
         commands: [...model.commands.values()].filter(c => isInSlice(c.position, c.width, c.height)),
-        events: [...model.events.values()].filter(e => isInSlice(e.position, e.width, e.height)),
-        readModels: [...model.readModels.values()].filter(rm => isInSlice(rm.position, rm.width, rm.height)),
-        screens: [...model.screens.values()].filter(s => isInSlice(s.position, s.width, s.height)),
+        events: [...model.events.values()].filter(e => !e.originalNodeId && isInSlice(e.position, e.width, e.height)),
+        readModels: [...model.readModels.values()].filter(rm => !rm.originalNodeId && isInSlice(rm.position, rm.width, rm.height)),
+        screens: [...model.screens.values()].filter(s => !s.originalNodeId && isInSlice(s.position, s.width, s.height)),
         processors: [...model.processors.values()].filter(p => isInSlice(p.position, p.width, p.height)),
     };
 }
-// Find which slice contains the original of a linked copy
-function findSliceForNode(model, nodeId) {
-    const event = model.events.get(nodeId);
-    const readModel = model.readModels.get(nodeId);
-    const screen = model.screens.get(nodeId);
-    const node = event ?? readModel ?? screen;
-    if (!node)
-        return null;
-    for (const slice of model.slices.values()) {
-        const centerX = node.position.x + node.width / 2;
-        const centerY = node.position.y + node.height / 2;
-        if (centerX >= slice.position.x &&
-            centerX <= slice.position.x + slice.size.width &&
-            centerY >= slice.position.y &&
-            centerY <= slice.position.y + slice.size.height) {
-            return slice;
-        }
-    }
-    return null;
-}
 // Find which aggregate an event belongs to (center point inside aggregate bounds)
 function findAggregateForEvent(model, event) {
     const centerX = event.position.x + event.width / 2;
@@ -189,14 +169,19 @@ function formatSliceXml(model, slice) {
     const components = getSliceComponents(model, slice);
     const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
     const chapter = findChapterForSlice(model, slice);
-    const componentIds = new Set();
-    components.commands.forEach(c => componentIds.add(c.id));
-    components.events.forEach(e => componentIds.add(e.id));
-    components.readModels.forEach(rm => componentIds.add(rm.id));
-    components.screens.forEach(s => componentIds.add(s.id));
-    components.processors.forEach(p => componentIds.add(p.id));
-    const flows = [...model.flows.values()].filter(f => componentIds.has(f.sourceId) || componentIds.has(f.targetId));
-    const internalFlows = flows.filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId));
+    // Use shared function that handles canonical groups for linked copies
+    const componentIds = getSliceComponentIds(model, slice);
+    // Resolve linked copies to canonical originals when checking flow containment
+    const flows = [...model.flows.values()].filter(f => {
+        const canonicalSourceId = resolveToCanonical(model, f.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, f.targetId);
+        return componentIds.has(canonicalSourceId) || componentIds.has(canonicalTargetId);
+    });
+    const internalFlows = flows.filter(f => {
+        const canonicalSourceId = resolveToCanonical(model, f.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, f.targetId);
+        return componentIds.has(canonicalSourceId) && componentIds.has(canonicalTargetId);
+    });
     // Get inbound and outbound flows for the slice
     const inboundFlows = getInboundFlows(model, slice);
     const outboundFlows = getOutboundFlows(model, slice);
@@ -214,19 +199,10 @@ function formatSliceXml(model, slice) {
     }
     xml += '  <components>\n';
     for (const screen of components.screens) {
-        // Check if this is a linked copy
-        const copyAttr = screen.originalNodeId ? ' linked-copy="true"' : '';
-        let originAttr = '';
-        if (screen.originalNodeId) {
-            const originSlice = findSliceForNode(model, screen.originalNodeId);
-            if (originSlice) {
-                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
-            }
-        }
         // Check which actor this screen belongs to
         const actor = findActorForScreen(model, screen);
         const actorAttr = actor ? ` actor="${escapeXml(actor.name)}"` : '';
-        xml += `    <screen id="${screen.id}" name="${escapeXml(screen.name)}"${copyAttr}${originAttr}${actorAttr}>\n`;
+        xml += `    <screen id="${screen.id}" name="${escapeXml(screen.name)}"${actorAttr}>\n`;
         // Add flow annotations
         const screenFlows = getFlowsForElement(model, screen.id);
         xml += formatFlowAnnotationsXml(screen.id, screenFlows.incoming, screenFlows.outgoing, componentIds, '      ');
@@ -262,19 +238,10 @@ function formatSliceXml(model, slice) {
         xml += '    </command>\n';
     }
     for (const event of components.events) {
-        // Check if this is a linked copy
-        const copyAttr = event.originalNodeId ? ' linked-copy="true"' : '';
-        let originAttr = '';
-        if (event.originalNodeId) {
-            const originSlice = findSliceForNode(model, event.originalNodeId);
-            if (originSlice) {
-                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
-            }
-        }
         // Check which aggregate this event belongs to
         const aggregate = findAggregateForEvent(model, event);
         const aggregateAttr = aggregate ? ` aggregate="${escapeXml(aggregate.name)}"` : '';
-        xml += `    <event id="${event.id}" name="${escapeXml(event.name)}"${copyAttr}${originAttr}${aggregateAttr}>\n`;
+        xml += `    <event id="${event.id}" name="${escapeXml(event.name)}"${aggregateAttr}>\n`;
         // Add flow annotations
         const eventFlows = getFlowsForElement(model, event.id);
         xml += formatFlowAnnotationsXml(event.id, eventFlows.incoming, eventFlows.outgoing, componentIds, '      ');
@@ -299,16 +266,7 @@ function formatSliceXml(model, slice) {
         xml += '    </event>\n';
     }
     for (const readModel of components.readModels) {
-        // Check if this is a linked copy
-        const copyAttr = readModel.originalNodeId ? ' linked-copy="true"' : '';
-        let originAttr = '';
-        if (readModel.originalNodeId) {
-            const originSlice = findSliceForNode(model, readModel.originalNodeId);
-            if (originSlice) {
-                originAttr = ` origin-slice="${escapeXml(originSlice.name)}"`;
-            }
-        }
-        xml += `    <read-model id="${readModel.id}" name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
+        xml += `    <read-model id="${readModel.id}" name="${escapeXml(readModel.name)}">\n`;
         // Add flow annotations
         const rmFlows = getFlowsForElement(model, readModel.id);
         xml += formatFlowAnnotationsXml(readModel.id, rmFlows.incoming, rmFlows.outgoing, componentIds, '      ');
@@ -430,14 +388,19 @@ function formatSliceJson(model, slice) {
     const components = getSliceComponents(model, slice);
     const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
     const chapter = findChapterForSlice(model, slice);
-    const componentIds = new Set();
-    components.commands.forEach(c => componentIds.add(c.id));
-    components.events.forEach(e => componentIds.add(e.id));
-    components.readModels.forEach(rm => componentIds.add(rm.id));
-    components.screens.forEach(s => componentIds.add(s.id));
-    components.processors.forEach(p => componentIds.add(p.id));
-    const flows = [...model.flows.values()].filter(f => componentIds.has(f.sourceId) || componentIds.has(f.targetId));
-    const internalFlows = flows.filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId));
+    // Use shared function that handles canonical groups for linked copies
+    const componentIds = getSliceComponentIds(model, slice);
+    // Resolve linked copies to canonical originals when checking flow containment
+    const flows = [...model.flows.values()].filter(f => {
+        const canonicalSourceId = resolveToCanonical(model, f.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, f.targetId);
+        return componentIds.has(canonicalSourceId) || componentIds.has(canonicalTargetId);
+    });
+    const internalFlows = flows.filter(f => {
+        const canonicalSourceId = resolveToCanonical(model, f.sourceId);
+        const canonicalTargetId = resolveToCanonical(model, f.targetId);
+        return componentIds.has(canonicalSourceId) && componentIds.has(canonicalTargetId);
+    });
     // Get inbound and outbound flows for the slice
     const inboundFlows = getInboundFlows(model, slice);
     const outboundFlows = getOutboundFlows(model, slice);
@@ -461,12 +424,6 @@ function formatSliceJson(model, slice) {
                     name: screen.name,
                     fields: screen.fields.map(fieldToJson)
                 };
-                if (screen.originalNodeId) {
-                    screenObj.linkedCopy = true;
-                    const originSlice = findSliceForNode(model, screen.originalNodeId);
-                    if (originSlice)
-                        screenObj.originSlice = originSlice.name;
-                }
                 const actor = findActorForScreen(model, screen);
                 if (actor)
                     screenObj.actor = actor.name;
@@ -517,12 +474,6 @@ function formatSliceJson(model, slice) {
                     name: event.name,
                     fields: event.fields.map(fieldToJson)
                 };
-                if (event.originalNodeId) {
-                    eventObj.linkedCopy = true;
-                    const originSlice = findSliceForNode(model, event.originalNodeId);
-                    if (originSlice)
-                        eventObj.originSlice = originSlice.name;
-                }
                 const aggregate = findAggregateForEvent(model, event);
                 if (aggregate)
                     eventObj.aggregate = aggregate.name;
@@ -550,12 +501,6 @@ function formatSliceJson(model, slice) {
                     name: rm.name,
                     fields: rm.fields.map(fieldToJson)
                 };
-                if (rm.originalNodeId) {
-                    rmObj.linkedCopy = true;
-                    const originSlice = findSliceForNode(model, rm.originalNodeId);
-                    if (originSlice)
-                        rmObj.originSlice = originSlice.name;
-                }
                 // Add flow annotations
                 const rmFlows = getFlowsForElement(model, rm.id);
                 if (rmFlows.incoming.length > 0) {

package/package.json

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