eventmodeler 0.2.1 → 0.2.4

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

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

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

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

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

@@ -1,22 +1,21 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-export function listChapters(model) {
+import { escapeXml, outputJson } from '../../lib/format.js';
+export function listChapters(model, format) {
     const chapters = [...model.chapters.values()];
+    // Sort by x position (left to right on timeline)
+    const sorted = [...chapters].sort((a, b) => a.position.x - b.position.x);
+    if (format === 'json') {
+        outputJson({
+            chapters: sorted.map(ch => ({ id: ch.id, name: ch.name }))
+        });
+        return;
+    }
     if (chapters.length === 0) {
         console.log('<chapters/>');
         return;
     }
-    // Sort by x position (left to right on timeline)
-    const sorted = [...chapters].sort((a, b) => a.position.x - b.position.x);
     console.log('<chapters>');
     for (const chapter of sorted) {
-        console.log(`  <chapter name="${escapeXml(chapter.name)}"/>`);
+        console.log(`  <chapter id="${chapter.id}" name="${escapeXml(chapter.name)}"/>`);
     }
     console.log('</chapters>');
 }

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

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

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

@@ -1,21 +1,20 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-export function listCommands(model) {
+import { escapeXml, outputJson } from '../../lib/format.js';
+export function listCommands(model, format) {
     const commands = [...model.commands.values()];
+    const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
+    if (format === 'json') {
+        outputJson({
+            commands: sorted.map(cmd => ({ id: cmd.id, name: cmd.name, fields: cmd.fields.length }))
+        });
+        return;
+    }
     if (commands.length === 0) {
         console.log('<commands/>');
         return;
     }
-    const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
     console.log('<commands>');
     for (const cmd of sorted) {
-        console.log(`  <command name="${escapeXml(cmd.name)}" fields="${cmd.fields.length}"/>`);
+        console.log(`  <command id="${cmd.id}" name="${escapeXml(cmd.name)}" fields="${cmd.fields.length}"/>`);
     }
     console.log('</commands>');
 }

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

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

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

@@ -1,11 +1,4 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
+import { escapeXml, outputJson } from '../../lib/format.js';
 // Find which aggregate an event belongs to (center point inside aggregate bounds)
 function findAggregateForEvent(model, event) {
     const centerX = event.position.x + event.width / 2;
@@ -37,12 +30,8 @@ function findSliceForEvent(model, event) {
     }
     return null;
 }
-export function listEvents(model) {
+export function listEvents(model, format) {
     const events = [...model.events.values()];
-    if (events.length === 0) {
-        console.log('<events/>');
-        return;
-    }
     // Sort: originals first, then copies; alphabetically within each group
     const sorted = [...events].sort((a, b) => {
         // Originals before copies
@@ -53,6 +42,38 @@ export function listEvents(model) {
         // Alphabetically by name
         return a.name.localeCompare(b.name);
     });
+    if (format === 'json') {
+        outputJson({
+            events: sorted.map(evt => {
+                const aggregate = findAggregateForEvent(model, evt);
+                const result = {
+                    id: evt.id,
+                    name: evt.name,
+                    fields: evt.fields.length,
+                };
+                if (aggregate)
+                    result.aggregate = aggregate.name;
+                if (evt.originalNodeId) {
+                    result.linkedCopy = true;
+                    const original = model.events.get(evt.originalNodeId);
+                    const originSlice = original ? findSliceForEvent(model, original) : null;
+                    if (originSlice)
+                        result.originSlice = originSlice;
+                }
+                else if (evt.canonicalId) {
+                    const copyCount = [...model.events.values()].filter(e => e.canonicalId === evt.canonicalId && e.originalNodeId).length;
+                    if (copyCount > 0)
+                        result.copies = copyCount;
+                }
+                return result;
+            })
+        });
+        return;
+    }
+    if (events.length === 0) {
+        console.log('<events/>');
+        return;
+    }
     console.log('<events>');
     for (const evt of sorted) {
         const aggregate = findAggregateForEvent(model, evt);
@@ -62,7 +83,7 @@ export function listEvents(model) {
             const original = model.events.get(evt.originalNodeId);
             const originSlice = original ? findSliceForEvent(model, original) : null;
             const originAttr = originSlice ? ` origin-slice="${escapeXml(originSlice)}"` : '';
-            console.log(`  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr} linked-copy="true"${originAttr}/>`);
+            console.log(`  <event id="${evt.id}" name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr} linked-copy="true"${originAttr}/>`);
         }
         else {
             // This is an original - show copy count
@@ -70,7 +91,7 @@ export function listEvents(model) {
                 ? [...model.events.values()].filter(e => e.canonicalId === evt.canonicalId && e.originalNodeId).length
                 : 0;
             const copiesAttr = copyCount > 0 ? ` copies="${copyCount}"` : '';
-            console.log(`  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr}${copiesAttr}/>`);
+            console.log(`  <event id="${evt.id}" name="${escapeXml(evt.name)}" fields="${evt.fields.length}"${aggregateAttr}${copiesAttr}/>`);
         }
     }
     console.log('</events>');

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

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

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

@@ -1,21 +1,20 @@
-function escapeXml(str) {
-    return str
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-export function listSlices(model) {
+import { escapeXml, outputJson } from '../../lib/format.js';
+export function listSlices(model, format) {
     const slices = [...model.slices.values()];
+    const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
+    if (format === 'json') {
+        outputJson({
+            slices: sorted.map(s => ({ id: s.id, name: s.name, status: s.status }))
+        });
+        return;
+    }
     if (slices.length === 0) {
         console.log('<slices/>');
         return;
     }
-    const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
     console.log('<slices>');
     for (const slice of sorted) {
-        console.log(`  <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
+        console.log(`  <slice id="${slice.id}" name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
     }
     console.log('</slices>');
 }

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

@@ -1,4 +1,5 @@
 import { appendEvent } from '../../lib/file-loader.js';
+import { findElementOrExit } from '../../lib/element-lookup.js';
 const validStatuses = ['created', 'in-progress', 'blocked', 'done'];
 const eventTypeMap = {
     'created': 'SliceMarkedAsCreated',
@@ -13,17 +14,7 @@ export function markSliceStatus(model, filePath, sliceName, status) {
         process.exit(1);
     }
     const newStatus = status;
-    const slices = [...model.slices.values()];
-    const sliceNameLower = sliceName.toLowerCase();
-    const slice = slices.find(s => s.name.toLowerCase() === sliceNameLower || s.name.toLowerCase().includes(sliceNameLower));
-    if (!slice) {
-        console.error(`Error: Slice not found: ${sliceName}`);
-        console.error('Available slices:');
-        for (const s of slices) {
-            console.error(`  - ${s.name}`);
-        }
-        process.exit(1);
-    }
+    const slice = findElementOrExit(model.slices, sliceName, 'slice');
     if (slice.status === newStatus) {
         console.log(`Slice "${slice.name}" is already marked as ${newStatus}`);
         return;

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

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

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

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

package/dist/slices/search/index.d.ts

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