eventmodeler 0.2.9 → 0.2.10

package/dist/index.js

@@ -54,17 +54,19 @@ USAGE:
   eventmodeler <command> [options]   Run a CLI command
 
 COMMANDS:
-  list slices                    List all slices with their status
+  list slices [--chapter <name>] List all slices (optionally filtered by chapter)
   list events                    List all events
   list commands                  List all commands
   list chapters                  List all chapters
   list aggregates                List all aggregates
   list actors                    List all actors
 
-  show slice <name>              Show detailed XML view of a slice
+  show slice <name>              Show slice with components, flow annotations, and
+                                 inbound/outbound dependencies
   show event <name>              Show detailed XML view of an event
   show command <name>            Show detailed XML view of a command
-  show chapter <name>            Show chapter with its slices
+  show chapter <name>            Show chapter with slices, flow graph, and
+                                 external dependencies
   show completeness <name>       Show field mapping completeness for any element
   show model-completeness        Show completeness of all flows in the model
   show aggregate-completeness <name>
@@ -134,6 +136,7 @@ EXAMPLES:
 async function main() {
     let fileArg = null;
     let formatArg = null;
+    let chapterArg = null;
     const filteredArgs = [];
     for (let i = 0; i < args.length; i++) {
         if (args[i] === '-f' || args[i] === '--file') {
@@ -142,6 +145,9 @@ async function main() {
         else if (args[i] === '--format') {
             formatArg = args[++i];
         }
+        else if (args[i] === '--chapter') {
+            chapterArg = args[++i];
+        }
         else if (args[i] === '-h' || args[i] === '--help') {
             printHelp();
             process.exit(0);
@@ -183,7 +189,7 @@ async function main() {
         case 'list':
             switch (subcommand) {
                 case 'slices':
-                    listSlices(model, format);
+                    listSlices(model, format, chapterArg ?? undefined);
                     break;
                 case 'events':
                     listEvents(model, format);

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

@@ -0,0 +1,13 @@
+import type { Chapter, EventModel, Slice } from '../types.js';
+export interface ChapterWithHierarchy {
+    id: string;
+    name: string;
+    parent?: ChapterWithHierarchy;
+}
+export declare function findParentChapter(model: EventModel, chapter: Chapter): Chapter | null;
+export declare function getChapterHierarchy(model: EventModel, chapter: Chapter): ChapterWithHierarchy;
+export declare function hierarchyToArray(hierarchy: ChapterWithHierarchy): Array<{
+    id: string;
+    name: string;
+}>;
+export declare function findChapterForSlice(model: EventModel, slice: Slice): Chapter | null;

package/dist/lib/chapter-utils.js

@@ -0,0 +1,71 @@
+// Check if two chapters have X-overlap
+function hasXOverlap(parent, child) {
+    const parentLeft = parent.position.x;
+    const parentRight = parent.position.x + parent.size.width;
+    const childLeft = child.position.x;
+    const childRight = child.position.x + child.size.width;
+    return childLeft < parentRight && childRight > parentLeft;
+}
+// Find the immediate parent of a chapter (nearest chapter above with X-overlap)
+export function findParentChapter(model, chapter) {
+    let bestParent = null;
+    let bestParentY = -Infinity;
+    for (const candidate of model.chapters.values()) {
+        if (candidate.id === chapter.id)
+            continue;
+        // Parent must be above (lower y value)
+        if (candidate.position.y >= chapter.position.y)
+            continue;
+        // Must have X-overlap
+        if (!hasXOverlap(candidate, chapter))
+            continue;
+        // Take the closest parent (highest y value that's still above)
+        if (candidate.position.y > bestParentY) {
+            bestParent = candidate;
+            bestParentY = candidate.position.y;
+        }
+    }
+    return bestParent;
+}
+// Build full hierarchy for a chapter (from root to this chapter)
+export function getChapterHierarchy(model, chapter) {
+    const parent = findParentChapter(model, chapter);
+    const result = {
+        id: chapter.id,
+        name: chapter.name,
+    };
+    if (parent) {
+        result.parent = getChapterHierarchy(model, parent);
+    }
+    return result;
+}
+// Convert hierarchy to array (root first)
+export function hierarchyToArray(hierarchy) {
+    const result = [];
+    function collect(h) {
+        if (h.parent)
+            collect(h.parent);
+        result.push({ id: h.id, name: h.name });
+    }
+    collect(hierarchy);
+    return result;
+}
+// Find which chapter contains a slice (based on horizontal center)
+// Returns the deepest (highest y-value) chapter that contains the slice
+export function findChapterForSlice(model, slice) {
+    const sliceCenterX = slice.position.x + slice.size.width / 2;
+    let bestChapter = null;
+    let bestY = -Infinity;
+    for (const chapter of model.chapters.values()) {
+        const chapterLeft = chapter.position.x;
+        const chapterRight = chapter.position.x + chapter.size.width;
+        if (sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight) {
+            // Take the deepest (highest y) chapter
+            if (chapter.position.y > bestY) {
+                bestChapter = chapter;
+                bestY = chapter.position.y;
+            }
+        }
+    }
+    return bestChapter;
+}

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

@@ -0,0 +1,52 @@
+import type { EventModel, Slice } from '../types.js';
+export type ElementType = 'screen' | 'command' | 'event' | 'read-model' | 'processor';
+export interface ElementInfo {
+    id: string;
+    name: string;
+    type: ElementType;
+}
+export interface FieldMappingInfo {
+    from: string;
+    to: string;
+}
+export interface FlowInfo {
+    flowId: string;
+    flowType: string;
+    source: ElementInfo;
+    target: ElementInfo;
+    fieldMappings: FieldMappingInfo[];
+}
+export interface SliceFlowInfo extends FlowInfo {
+    sourceSlice?: {
+        id: string;
+        name: string;
+    };
+    targetSlice?: {
+        id: string;
+        name: 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;
+export declare function getInboundFlows(model: EventModel, slice: Slice): SliceFlowInfo[];
+export declare function getOutboundFlows(model: EventModel, slice: Slice): SliceFlowInfo[];
+export declare function getInternalFlows(model: EventModel, slice: Slice): FlowInfo[];
+export declare function getFlowsForElement(model: EventModel, elementId: string): {
+    incoming: FlowInfo[];
+    outgoing: FlowInfo[];
+};
+export interface SliceToSliceFlow {
+    fromSlice: {
+        id: string;
+        name: string;
+    };
+    toSlice: {
+        id: string;
+        name: string;
+    };
+    flows: SliceFlowInfo[];
+}
+export declare function findSliceToSliceFlows(model: EventModel, slices: Slice[]): SliceToSliceFlow[];
+export declare function findChapterInboundFlows(model: EventModel, slices: Slice[]): SliceFlowInfo[];
+export declare function findChapterOutboundFlows(model: EventModel, slices: Slice[]): SliceFlowInfo[];

package/dist/lib/flow-utils.js

@@ -0,0 +1,305 @@
+// Get element info (name and type) by ID
+export function getElementInfo(model, id) {
+    const screen = model.screens.get(id);
+    if (screen)
+        return { id, name: screen.name, type: 'screen' };
+    const command = model.commands.get(id);
+    if (command)
+        return { id, name: command.name, type: 'command' };
+    const event = model.events.get(id);
+    if (event)
+        return { id, name: event.name, type: 'event' };
+    const readModel = model.readModels.get(id);
+    if (readModel)
+        return { id, name: readModel.name, type: 'read-model' };
+    const processor = model.processors.get(id);
+    if (processor)
+        return { id, name: processor.name, type: 'processor' };
+    return null;
+}
+// Get fields for an element
+function getElementFields(model, id) {
+    return (model.screens.get(id)?.fields ??
+        model.commands.get(id)?.fields ??
+        model.events.get(id)?.fields ??
+        model.readModels.get(id)?.fields ??
+        model.processors.get(id)?.fields ??
+        []);
+}
+// Find a field by ID in a fields array (recursive for subfields)
+function findFieldById(fields, fieldId) {
+    for (const field of fields) {
+        if (field.id === fieldId)
+            return field;
+        if (field.subfields) {
+            const found = findFieldById(field.subfields, fieldId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+// Enrich field mappings with field names
+function enrichFieldMappings(model, flow) {
+    const sourceFields = getElementFields(model, flow.sourceId);
+    const targetFields = getElementFields(model, flow.targetId);
+    return flow.fieldMappings.map(mapping => {
+        const sourceField = findFieldById(sourceFields, mapping.sourceFieldId);
+        const targetField = findFieldById(targetFields, mapping.targetFieldId);
+        return {
+            from: sourceField?.name ?? 'unknown',
+            to: targetField?.name ?? 'unknown',
+        };
+    });
+}
+// Check if an element's center point is within a slice's bounds
+function isElementInSlice(slice, position, width, height) {
+    const centerX = position.x + width / 2;
+    const centerY = position.y + height / 2;
+    return (centerX >= slice.position.x &&
+        centerX <= slice.position.x + slice.size.width &&
+        centerY >= slice.position.y &&
+        centerY <= slice.position.y + slice.size.height);
+}
+// Get all component IDs in a slice
+export function getSliceComponentIds(model, slice) {
+    const ids = new Set();
+    for (const screen of model.screens.values()) {
+        if (isElementInSlice(slice, screen.position, screen.width, screen.height)) {
+            ids.add(screen.id);
+        }
+    }
+    for (const command of model.commands.values()) {
+        if (isElementInSlice(slice, command.position, command.width, command.height)) {
+            ids.add(command.id);
+        }
+    }
+    for (const event of model.events.values()) {
+        if (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)) {
+            ids.add(readModel.id);
+        }
+    }
+    for (const processor of model.processors.values()) {
+        if (isElementInSlice(slice, processor.position, processor.width, processor.height)) {
+            ids.add(processor.id);
+        }
+    }
+    return ids;
+}
+// Find which slice contains a component
+export function findSliceForComponent(model, componentId) {
+    // Get element position and size
+    let position = null;
+    let width = 0;
+    let height = 0;
+    const screen = model.screens.get(componentId);
+    if (screen) {
+        position = screen.position;
+        width = screen.width;
+        height = screen.height;
+    }
+    const command = model.commands.get(componentId);
+    if (command) {
+        position = command.position;
+        width = command.width;
+        height = command.height;
+    }
+    const event = model.events.get(componentId);
+    if (event) {
+        position = event.position;
+        width = event.width;
+        height = event.height;
+    }
+    const readModel = model.readModels.get(componentId);
+    if (readModel) {
+        position = readModel.position;
+        width = readModel.width;
+        height = readModel.height;
+    }
+    const processor = model.processors.get(componentId);
+    if (processor) {
+        position = processor.position;
+        width = processor.width;
+        height = processor.height;
+    }
+    if (!position)
+        return null;
+    for (const slice of model.slices.values()) {
+        if (isElementInSlice(slice, position, width, height)) {
+            return slice;
+        }
+    }
+    return null;
+}
+// Build FlowInfo from a Flow
+function buildFlowInfo(model, flow) {
+    const source = getElementInfo(model, flow.sourceId);
+    const target = getElementInfo(model, flow.targetId);
+    if (!source || !target)
+        return null;
+    return {
+        flowId: flow.id,
+        flowType: flow.flowType,
+        source,
+        target,
+        fieldMappings: enrichFieldMappings(model, flow),
+    };
+}
+// Build SliceFlowInfo from a Flow (includes slice info for source/target)
+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);
+    return {
+        ...base,
+        sourceSlice: sourceSlice ? { id: sourceSlice.id, name: sourceSlice.name } : undefined,
+        targetSlice: targetSlice ? { id: targetSlice.id, name: targetSlice.name } : undefined,
+    };
+}
+// Get flows entering a slice (target in slice, source outside)
+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)) {
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}
+// Get flows leaving a slice (source in slice, target outside)
+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)) {
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}
+// Get flows within a slice (both source and target in slice)
+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)) {
+            const flowInfo = buildFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}
+// Get all flows for a specific element (both directions)
+export function getFlowsForElement(model, elementId) {
+    const incoming = [];
+    const outgoing = [];
+    for (const flow of model.flows.values()) {
+        if (flow.targetId === elementId) {
+            const flowInfo = buildFlowInfo(model, flow);
+            if (flowInfo)
+                incoming.push(flowInfo);
+        }
+        if (flow.sourceId === elementId) {
+            const flowInfo = buildFlowInfo(model, flow);
+            if (flowInfo)
+                outgoing.push(flowInfo);
+        }
+    }
+    return { incoming, outgoing };
+}
+export function findSliceToSliceFlows(model, slices) {
+    const sliceMap = new Map(slices.map(s => [s.id, s]));
+    const sliceComponentMap = new Map();
+    // Build component ID sets for each slice
+    for (const slice of slices) {
+        sliceComponentMap.set(slice.id, getSliceComponentIds(model, slice));
+    }
+    // Group flows by slice pair
+    const flowsBySlicePair = new Map();
+    for (const flow of model.flows.values()) {
+        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))
+                sourceSliceId = sliceId;
+            if (componentIds.has(flow.targetId))
+                targetSliceId = sliceId;
+        }
+        // Only include flows between different slices in our set
+        if (sourceSliceId && targetSliceId && sourceSliceId !== targetSliceId) {
+            const key = `${sourceSliceId}:${targetSliceId}`;
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo) {
+                if (!flowsBySlicePair.has(key)) {
+                    flowsBySlicePair.set(key, []);
+                }
+                flowsBySlicePair.get(key).push(flowInfo);
+            }
+        }
+    }
+    // Convert to result format
+    const result = [];
+    for (const [key, flows] of flowsBySlicePair.entries()) {
+        const [fromId, toId] = key.split(':');
+        const fromSlice = sliceMap.get(fromId);
+        const toSlice = sliceMap.get(toId);
+        if (fromSlice && toSlice) {
+            result.push({
+                fromSlice: { id: fromSlice.id, name: fromSlice.name },
+                toSlice: { id: toSlice.id, name: toSlice.name },
+                flows,
+            });
+        }
+    }
+    return result;
+}
+// Find flows entering a chapter (target in chapter slices, source outside)
+export function findChapterInboundFlows(model, slices) {
+    const chapterComponentIds = new Set();
+    for (const slice of slices) {
+        for (const id of getSliceComponentIds(model, slice)) {
+            chapterComponentIds.add(id);
+        }
+    }
+    const flows = [];
+    for (const flow of model.flows.values()) {
+        if (chapterComponentIds.has(flow.targetId) && !chapterComponentIds.has(flow.sourceId)) {
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}
+// Find flows leaving a chapter (source in chapter slices, target outside)
+export function findChapterOutboundFlows(model, slices) {
+    const chapterComponentIds = new Set();
+    for (const slice of slices) {
+        for (const id of getSliceComponentIds(model, slice)) {
+            chapterComponentIds.add(id);
+        }
+    }
+    const flows = [];
+    for (const flow of model.flows.values()) {
+        if (chapterComponentIds.has(flow.sourceId) && !chapterComponentIds.has(flow.targetId)) {
+            const flowInfo = buildSliceFlowInfo(model, flow);
+            if (flowInfo)
+                flows.push(flowInfo);
+        }
+    }
+    return flows;
+}

package/dist/lib/slice-utils.js

@@ -91,6 +91,17 @@ export function inferFieldMappings(sourceFields, targetFields) {
     }
     return mappings;
 }
+const VALID_FIELD_TYPES = ['UUID', 'Boolean', 'Double', 'Decimal', 'Date', 'DateTime', 'Long', 'Int', 'String', 'Custom'];
+function validateFieldType(type, fieldName) {
+    if (!VALID_FIELD_TYPES.includes(type)) {
+        const typeLower = type.toLowerCase();
+        let hint = '';
+        if (typeLower === 'list' || typeLower === 'array') {
+            hint = `\n\nHint: To make a field a list/array, use isList="true" with a valid type:\n  <field name="${fieldName}" type="String" isList="true"/>`;
+        }
+        throw new Error(`Invalid field type "${type}" for field "${fieldName}". Valid types: ${VALID_FIELD_TYPES.join(', ')}${hint}`);
+    }
+}
 function getAttr(attrs, name) {
     const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
     return match ? match[1] : undefined;
@@ -106,13 +117,15 @@ export function parseFieldsFromXml(xml) {
         const type = getAttr(attrs, 'type');
         if (!name || !type)
             continue;
+        // Validate the field type
+        validateFieldType(type, name);
         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',
+            isList: getAttr(attrs, 'isList') === 'true',
+            isGenerated: getAttr(attrs, 'isGenerated') === 'true',
+            isOptional: getAttr(attrs, 'isOptional') === 'true',
+            isUserInput: getAttr(attrs, 'isUserInput') === 'true',
         };
         // Parse nested subfields for Custom type
         if (type === 'Custom' && content) {

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

@@ -90,6 +90,11 @@ export function addField(model, filePath, options, input) {
     if (!validFieldTypes.includes(fieldInput.type)) {
         console.error(`Error: Invalid field type: ${fieldInput.type}`);
         console.error(`Valid types: ${validFieldTypes.join(', ')}`);
+        const typeLower = fieldInput.type.toLowerCase();
+        if (typeLower === 'list' || typeLower === 'array') {
+            console.error(`\nHint: To make a field a list/array, use isList="true" with a valid type:`);
+            console.error(`  <field name="items" type="String" isList="true"/>`);
+        }
         process.exit(1);
     }
     // Find entity and add field

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

@@ -1,5 +1,6 @@
 import { outputJson } from '../../lib/format.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
+import { findChapterForSlice, getChapterHierarchy } from '../../lib/chapter-utils.js';
 // Get components inside a slice by checking if center point is within bounds
 function getSliceComponents(model, slice) {
     const bounds = {
@@ -71,18 +72,6 @@ function findActorForScreen(model, screen) {
     }
     return undefined;
 }
-// Find which chapter contains a slice (based on horizontal center)
-function findChapterForSlice(model, slice) {
-    const sliceCenterX = slice.position.x + slice.size.width / 2;
-    for (const chapter of model.chapters.values()) {
-        const chapterLeft = chapter.position.x;
-        const chapterRight = chapter.position.x + chapter.size.width;
-        if (sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight) {
-            return chapter;
-        }
-    }
-    return null;
-}
 // Convert Field to JSON-friendly format
 function fieldToJson(field) {
     const result = {
@@ -351,7 +340,7 @@ export function codegenSlice(model, sliceName) {
             id: slice.id,
             name: slice.name,
         },
-        ...(chapter && { chapter: { id: chapter.id, name: chapter.name } }),
+        ...(chapter && { chapter: getChapterHierarchy(model, chapter) }),
         elements: {
             readModels: components.readModels.map(rm => ({
                 id: rm.id,

package/dist/slices/list-slices/index.d.ts

@@ -1,3 +1,3 @@
 import type { EventModel } from '../../types.js';
 import { type OutputFormat } from '../../lib/format.js';
-export declare function listSlices(model: EventModel, format: OutputFormat): void;
+export declare function listSlices(model: EventModel, format: OutputFormat, chapterName?: string): void;

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

@@ -1,9 +1,24 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
-export function listSlices(model, format) {
-    const slices = [...model.slices.values()];
+import { findElementOrExit } from '../../lib/element-lookup.js';
+function getSlicesUnderChapter(model, chapter) {
+    const chapterLeft = chapter.position.x;
+    const chapterRight = chapter.position.x + chapter.size.width;
+    return [...model.slices.values()].filter(slice => {
+        const sliceCenterX = slice.position.x + slice.size.width / 2;
+        return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
+    });
+}
+export function listSlices(model, format, chapterName) {
+    let slices = [...model.slices.values()];
+    // Filter by chapter if specified
+    if (chapterName) {
+        const chapter = findElementOrExit(model.chapters, chapterName, 'chapter');
+        slices = getSlicesUnderChapter(model, chapter);
+    }
     const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
     if (format === 'json') {
         outputJson({
+            ...(chapterName && { chapter: chapterName }),
             slices: sorted.map(s => ({ id: s.id, name: s.name, status: s.status }))
         });
         return;

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

@@ -1,5 +1,7 @@
 import { escapeXml, outputJson } from '../../lib/format.js';
 import { findElementOrExit } from '../../lib/element-lookup.js';
+import { getChapterHierarchy, findChapterForSlice } from '../../lib/chapter-utils.js';
+import { findSliceToSliceFlows, findChapterInboundFlows, findChapterOutboundFlows, } from '../../lib/flow-utils.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,18 +11,149 @@ function getSlicesUnderChapter(model, chapter) {
         return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
     }).sort((a, b) => a.position.x - b.position.x);
 }
+function formatSliceFlowXml(sliceFlow) {
+    let xml = `    <slice-flow from="${escapeXml(sliceFlow.fromSlice.name)}" to="${escapeXml(sliceFlow.toSlice.name)}">\n`;
+    for (const flow of sliceFlow.flows) {
+        xml += `      <via type="${flow.flowType}">\n`;
+        xml += `        <source element="${escapeXml(flow.source.name)}" type="${flow.source.type}"/>\n`;
+        xml += `        <target element="${escapeXml(flow.target.name)}" type="${flow.target.type}"/>\n`;
+        if (flow.fieldMappings.length > 0) {
+            xml += '        <mappings>\n';
+            for (const mapping of flow.fieldMappings) {
+                xml += `          <map from="${escapeXml(mapping.from)}" to="${escapeXml(mapping.to)}"/>\n`;
+            }
+            xml += '        </mappings>\n';
+        }
+        xml += '      </via>\n';
+    }
+    xml += '    </slice-flow>\n';
+    return xml;
+}
+function formatExternalFlowXml(flow, direction, model) {
+    let xml = `      <flow ${direction === 'inbound' ? `to-slice="${escapeXml(flow.targetSlice?.name ?? 'unknown')}"` : `from-slice="${escapeXml(flow.sourceSlice?.name ?? 'unknown')}"`} type="${flow.flowType}">\n`;
+    // For inbound: source is external, for outbound: target is external
+    if (direction === 'inbound') {
+        // Find the chapter of the external source
+        const sourceSlice = flow.sourceSlice;
+        let chapterInfo = '';
+        if (sourceSlice) {
+            const sourceSliceObj = model.slices.get(sourceSlice.id);
+            if (sourceSliceObj) {
+                const sourceChapter = findChapterForSlice(model, sourceSliceObj);
+                if (sourceChapter) {
+                    chapterInfo = ` chapter="${escapeXml(sourceChapter.name)}"`;
+                }
+            }
+        }
+        xml += `        <from external="true"${chapterInfo}>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
+        xml += `        <to>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
+    }
+    else {
+        xml += `        <from>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
+        // Find the chapter of the external target
+        const targetSlice = flow.targetSlice;
+        let chapterInfo = '';
+        if (targetSlice) {
+            const targetSliceObj = model.slices.get(targetSlice.id);
+            if (targetSliceObj) {
+                const targetChapter = findChapterForSlice(model, targetSliceObj);
+                if (targetChapter) {
+                    chapterInfo = ` chapter="${escapeXml(targetChapter.name)}"`;
+                }
+            }
+        }
+        xml += `        <to external="true"${chapterInfo}>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
+    }
+    if (flow.fieldMappings.length > 0) {
+        xml += '        <mappings>\n';
+        for (const mapping of flow.fieldMappings) {
+            xml += `          <map from="${escapeXml(mapping.from)}" to="${escapeXml(mapping.to)}"/>\n`;
+        }
+        xml += '        </mappings>\n';
+    }
+    xml += '      </flow>\n';
+    return xml;
+}
 export function showChapter(model, name, format) {
     const chapter = findElementOrExit(model.chapters, name, 'chapter');
     const slices = getSlicesUnderChapter(model, chapter);
+    // Get flow information
+    const sliceToSliceFlows = findSliceToSliceFlows(model, slices);
+    const chapterInboundFlows = findChapterInboundFlows(model, slices);
+    const chapterOutboundFlows = findChapterOutboundFlows(model, slices);
     if (format === 'json') {
-        outputJson({
+        const result = {
             id: chapter.id,
             name: chapter.name,
+            parent: chapter ? getChapterHierarchy(model, chapter).parent : undefined,
             slices: slices.map(s => ({ id: s.id, name: s.name, status: s.status }))
-        });
+        };
+        // Add flow graph if there are slice-to-slice flows
+        if (sliceToSliceFlows.length > 0) {
+            result.flowGraph = sliceToSliceFlows.map(sf => ({
+                from: sf.fromSlice.name,
+                to: sf.toSlice.name,
+                flows: sf.flows.map(f => ({
+                    type: f.flowType,
+                    source: { element: f.source.name, type: f.source.type },
+                    target: { element: f.target.name, type: f.target.type },
+                    ...(f.fieldMappings.length > 0 && {
+                        mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+                    })
+                }))
+            }));
+        }
+        // Add external dependencies
+        if (chapterInboundFlows.length > 0 || chapterOutboundFlows.length > 0) {
+            result.externalDependencies = {
+                ...(chapterInboundFlows.length > 0 && {
+                    inbound: chapterInboundFlows.map(f => {
+                        const sourceSliceObj = f.sourceSlice ? model.slices.get(f.sourceSlice.id) : null;
+                        const sourceChapter = sourceSliceObj ? findChapterForSlice(model, sourceSliceObj) : null;
+                        return {
+                            toSlice: f.targetSlice?.name,
+                            type: f.flowType,
+                            from: {
+                                element: f.source.name,
+                                type: f.source.type,
+                                slice: f.sourceSlice?.name,
+                                chapter: sourceChapter?.name
+                            },
+                            to: { element: f.target.name, type: f.target.type },
+                            ...(f.fieldMappings.length > 0 && {
+                                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+                            })
+                        };
+                    })
+                }),
+                ...(chapterOutboundFlows.length > 0 && {
+                    outbound: chapterOutboundFlows.map(f => {
+                        const targetSliceObj = f.targetSlice ? model.slices.get(f.targetSlice.id) : null;
+                        const targetChapter = targetSliceObj ? findChapterForSlice(model, targetSliceObj) : null;
+                        return {
+                            fromSlice: f.sourceSlice?.name,
+                            type: f.flowType,
+                            from: { element: f.source.name, type: f.source.type },
+                            to: {
+                                element: f.target.name,
+                                type: f.target.type,
+                                slice: f.targetSlice?.name,
+                                chapter: targetChapter?.name
+                            },
+                            ...(f.fieldMappings.length > 0 && {
+                                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+                            })
+                        };
+                    })
+                })
+            };
+        }
+        outputJson(result);
         return;
     }
+    // XML format
     console.log(`<chapter id="${chapter.id}" name="${escapeXml(chapter.name)}">`);
+    // Slices section
     if (slices.length === 0) {
         console.log('  <slices/>');
     }
@@ -31,5 +164,32 @@ export function showChapter(model, name, format) {
         }
         console.log('  </slices>');
     }
+    // Flow graph section
+    if (sliceToSliceFlows.length > 0) {
+        console.log('  <flow-graph>');
+        for (const sliceFlow of sliceToSliceFlows) {
+            process.stdout.write(formatSliceFlowXml(sliceFlow));
+        }
+        console.log('  </flow-graph>');
+    }
+    // External dependencies section
+    if (chapterInboundFlows.length > 0 || chapterOutboundFlows.length > 0) {
+        console.log('  <external-dependencies>');
+        if (chapterInboundFlows.length > 0) {
+            console.log('    <inbound>');
+            for (const flow of chapterInboundFlows) {
+                process.stdout.write(formatExternalFlowXml(flow, 'inbound', model));
+            }
+            console.log('    </inbound>');
+        }
+        if (chapterOutboundFlows.length > 0) {
+            console.log('    <outbound>');
+            for (const flow of chapterOutboundFlows) {
+                process.stdout.write(formatExternalFlowXml(flow, 'outbound', model));
+            }
+            console.log('    </outbound>');
+        }
+        console.log('  </external-dependencies>');
+    }
     console.log('</chapter>');
 }

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

@@ -1,5 +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';
 function formatFieldValues(values) {
     if (!values || Object.keys(values).length === 0)
         return '';
@@ -102,9 +104,91 @@ function findActorForScreen(model, screen) {
     }
     return null;
 }
+function formatChapterXml(hierarchy, indent) {
+    let xml = `${indent}<chapter id="${hierarchy.id}" name="${escapeXml(hierarchy.name)}"`;
+    if (hierarchy.parent) {
+        xml += '>\n';
+        xml += formatChapterXml(hierarchy.parent, indent + '  ');
+        xml += `${indent}</chapter>\n`;
+    }
+    else {
+        xml += '/>\n';
+    }
+    return xml;
+}
+// Format inline flow annotations for a component
+function formatFlowAnnotationsXml(elementId, incoming, outgoing, componentIds, indent) {
+    let xml = '';
+    // Flows coming into this element
+    const flowsFrom = incoming.map(f => {
+        const external = !componentIds.has(f.source.id);
+        return external
+            ? `${escapeXml(f.source.name)} (${f.source.type}) [external]`
+            : `${escapeXml(f.source.name)} (${f.source.type})`;
+    });
+    if (flowsFrom.length > 0) {
+        xml += `${indent}<flows-from>${flowsFrom.join(', ')}</flows-from>\n`;
+    }
+    // Flows going out of this element
+    const flowsTo = outgoing.map(f => {
+        const external = !componentIds.has(f.target.id);
+        return external
+            ? `${escapeXml(f.target.name)} (${f.target.type}) [external]`
+            : `${escapeXml(f.target.name)} (${f.target.type})`;
+    });
+    if (flowsTo.length > 0) {
+        xml += `${indent}<flows-to>${flowsTo.join(', ')}</flows-to>\n`;
+    }
+    return xml;
+}
+// Format inbound flows section
+function formatInboundFlowsXml(flows) {
+    if (flows.length === 0)
+        return '';
+    let xml = '  <inbound-flows>\n';
+    for (const flow of flows) {
+        xml += `    <flow type="${flow.flowType}">\n`;
+        const sourceSliceInfo = flow.sourceSlice ? ` slice="${escapeXml(flow.sourceSlice.name)}"` : '';
+        xml += `      <from${sourceSliceInfo}>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
+        xml += `      <to>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
+        if (flow.fieldMappings.length > 0) {
+            xml += '      <mappings>\n';
+            for (const mapping of flow.fieldMappings) {
+                xml += `        <map from="${escapeXml(mapping.from)}" to="${escapeXml(mapping.to)}"/>\n`;
+            }
+            xml += '      </mappings>\n';
+        }
+        xml += '    </flow>\n';
+    }
+    xml += '  </inbound-flows>\n';
+    return xml;
+}
+// Format outbound flows section
+function formatOutboundFlowsXml(flows) {
+    if (flows.length === 0)
+        return '';
+    let xml = '  <outbound-flows>\n';
+    for (const flow of flows) {
+        xml += `    <flow type="${flow.flowType}">\n`;
+        xml += `      <from>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
+        const targetSliceInfo = flow.targetSlice ? ` slice="${escapeXml(flow.targetSlice.name)}"` : '';
+        xml += `      <to${targetSliceInfo}>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
+        if (flow.fieldMappings.length > 0) {
+            xml += '      <mappings>\n';
+            for (const mapping of flow.fieldMappings) {
+                xml += `        <map from="${escapeXml(mapping.from)}" to="${escapeXml(mapping.to)}"/>\n`;
+            }
+            xml += '      </mappings>\n';
+        }
+        xml += '    </flow>\n';
+    }
+    xml += '  </outbound-flows>\n';
+    return xml;
+}
 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));
@@ -113,6 +197,9 @@ function formatSliceXml(model, slice) {
     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));
+    // Get inbound and outbound flows for the slice
+    const inboundFlows = getInboundFlows(model, slice);
+    const outboundFlows = getOutboundFlows(model, slice);
     function getName(id) {
         return (model.commands.get(id)?.name ??
             model.events.get(id)?.name ??
@@ -122,6 +209,9 @@ function formatSliceXml(model, slice) {
             id);
     }
     let xml = `<slice id="${slice.id}" name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
+    if (chapter) {
+        xml += formatChapterXml(getChapterHierarchy(model, chapter), '  ');
+    }
     xml += '  <components>\n';
     for (const screen of components.screens) {
         // Check if this is a linked copy
@@ -137,6 +227,9 @@ function formatSliceXml(model, slice) {
         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`;
+        // Add flow annotations
+        const screenFlows = getFlowsForElement(model, screen.id);
+        xml += formatFlowAnnotationsXml(screen.id, screenFlows.incoming, screenFlows.outgoing, componentIds, '      ');
         if (screen.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of screen.fields) {
@@ -148,6 +241,9 @@ function formatSliceXml(model, slice) {
     }
     for (const command of components.commands) {
         xml += `    <command id="${command.id}" name="${escapeXml(command.name)}">\n`;
+        // Add flow annotations
+        const commandFlows = getFlowsForElement(model, command.id);
+        xml += formatFlowAnnotationsXml(command.id, commandFlows.incoming, commandFlows.outgoing, componentIds, '      ');
         if (command.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of command.fields) {
@@ -179,6 +275,9 @@ function formatSliceXml(model, slice) {
         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`;
+        // Add flow annotations
+        const eventFlows = getFlowsForElement(model, event.id);
+        xml += formatFlowAnnotationsXml(event.id, eventFlows.incoming, eventFlows.outgoing, componentIds, '      ');
         if (event.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of event.fields) {
@@ -210,6 +309,9 @@ function formatSliceXml(model, slice) {
             }
         }
         xml += `    <read-model id="${readModel.id}" name="${escapeXml(readModel.name)}"${copyAttr}${originAttr}>\n`;
+        // Add flow annotations
+        const rmFlows = getFlowsForElement(model, readModel.id);
+        xml += formatFlowAnnotationsXml(readModel.id, rmFlows.incoming, rmFlows.outgoing, componentIds, '      ');
         if (readModel.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of readModel.fields) {
@@ -221,6 +323,9 @@ function formatSliceXml(model, slice) {
     }
     for (const processor of components.processors) {
         xml += `    <processor id="${processor.id}" name="${escapeXml(processor.name)}">\n`;
+        // Add flow annotations
+        const procFlows = getFlowsForElement(model, processor.id);
+        xml += formatFlowAnnotationsXml(processor.id, procFlows.incoming, procFlows.outgoing, componentIds, '      ');
         if (processor.fields.length > 0) {
             xml += '      <fields>\n';
             for (const field of processor.fields) {
@@ -297,6 +402,9 @@ function formatSliceXml(model, slice) {
         }
         xml += '  </scenarios>\n';
     }
+    // Add inbound and outbound flows sections
+    xml += formatInboundFlowsXml(inboundFlows);
+    xml += formatOutboundFlowsXml(outboundFlows);
     xml += '</slice>';
     return xml;
 }
@@ -321,6 +429,7 @@ function fieldToJson(field) {
 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));
@@ -329,6 +438,9 @@ function formatSliceJson(model, slice) {
     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));
+    // Get inbound and outbound flows for the slice
+    const inboundFlows = getInboundFlows(model, slice);
+    const outboundFlows = getOutboundFlows(model, slice);
     function getName(id) {
         return (model.commands.get(id)?.name ??
             model.events.get(id)?.name ??
@@ -341,6 +453,7 @@ function formatSliceJson(model, slice) {
         id: slice.id,
         name: slice.name,
         status: slice.status,
+        ...(chapter && { chapter: getChapterHierarchy(model, chapter) }),
         components: {
             screens: components.screens.map(screen => {
                 const screenObj = {
@@ -357,13 +470,47 @@ function formatSliceJson(model, slice) {
                 const actor = findActorForScreen(model, screen);
                 if (actor)
                     screenObj.actor = actor.name;
+                // Add flow annotations
+                const screenFlows = getFlowsForElement(model, screen.id);
+                if (screenFlows.incoming.length > 0) {
+                    screenObj.flowsFrom = screenFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (screenFlows.outgoing.length > 0) {
+                    screenObj.flowsTo = screenFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
                 return screenObj;
             }),
-            commands: components.commands.map(cmd => ({
-                id: cmd.id,
-                name: cmd.name,
-                fields: cmd.fields.map(fieldToJson)
-            })),
+            commands: components.commands.map(cmd => {
+                const cmdObj = {
+                    id: cmd.id,
+                    name: cmd.name,
+                    fields: cmd.fields.map(fieldToJson)
+                };
+                const cmdFlows = getFlowsForElement(model, cmd.id);
+                if (cmdFlows.incoming.length > 0) {
+                    cmdObj.flowsFrom = cmdFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (cmdFlows.outgoing.length > 0) {
+                    cmdObj.flowsTo = cmdFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
+                return cmdObj;
+            }),
             events: components.events.map(event => {
                 const eventObj = {
                     id: event.id,
@@ -379,6 +526,22 @@ function formatSliceJson(model, slice) {
                 const aggregate = findAggregateForEvent(model, event);
                 if (aggregate)
                     eventObj.aggregate = aggregate.name;
+                // Add flow annotations
+                const eventFlows = getFlowsForElement(model, event.id);
+                if (eventFlows.incoming.length > 0) {
+                    eventObj.flowsFrom = eventFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (eventFlows.outgoing.length > 0) {
+                    eventObj.flowsTo = eventFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
                 return eventObj;
             }),
             readModels: components.readModels.map(rm => {
@@ -393,13 +556,47 @@ function formatSliceJson(model, slice) {
                     if (originSlice)
                         rmObj.originSlice = originSlice.name;
                 }
+                // Add flow annotations
+                const rmFlows = getFlowsForElement(model, rm.id);
+                if (rmFlows.incoming.length > 0) {
+                    rmObj.flowsFrom = rmFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (rmFlows.outgoing.length > 0) {
+                    rmObj.flowsTo = rmFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
                 return rmObj;
             }),
-            processors: components.processors.map(proc => ({
-                id: proc.id,
-                name: proc.name,
-                fields: proc.fields.map(fieldToJson)
-            }))
+            processors: components.processors.map(proc => {
+                const procObj = {
+                    id: proc.id,
+                    name: proc.name,
+                    fields: proc.fields.map(fieldToJson)
+                };
+                const procFlows = getFlowsForElement(model, proc.id);
+                if (procFlows.incoming.length > 0) {
+                    procObj.flowsFrom = procFlows.incoming.map(f => ({
+                        element: f.source.name,
+                        type: f.source.type,
+                        external: !componentIds.has(f.source.id)
+                    }));
+                }
+                if (procFlows.outgoing.length > 0) {
+                    procObj.flowsTo = procFlows.outgoing.map(f => ({
+                        element: f.target.name,
+                        type: f.target.type,
+                        external: !componentIds.has(f.target.id)
+                    }));
+                }
+                return procObj;
+            })
         }
     };
     if (internalFlows.length > 0) {
@@ -460,6 +657,41 @@ function formatSliceJson(model, slice) {
             return scenarioObj;
         });
     }
+    // Add inbound and outbound flows
+    if (inboundFlows.length > 0) {
+        result.inboundFlows = inboundFlows.map(f => ({
+            type: f.flowType,
+            from: {
+                element: f.source.name,
+                type: f.source.type,
+                ...(f.sourceSlice && { slice: f.sourceSlice.name })
+            },
+            to: {
+                element: f.target.name,
+                type: f.target.type
+            },
+            ...(f.fieldMappings.length > 0 && {
+                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+            })
+        }));
+    }
+    if (outboundFlows.length > 0) {
+        result.outboundFlows = outboundFlows.map(f => ({
+            type: f.flowType,
+            from: {
+                element: f.source.name,
+                type: f.source.type
+            },
+            to: {
+                element: f.target.name,
+                type: f.target.type,
+                ...(f.targetSlice && { slice: f.targetSlice.name })
+            },
+            ...(f.fieldMappings.length > 0 && {
+                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
+            })
+        }));
+    }
     return result;
 }
 export function showSlice(model, name, format) {

package/package.json

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