eventmodeler 0.1.0

package/dist/formatters.d.ts

@@ -0,0 +1,17 @@
+import type { EventModel, Slice, CommandSticky, EventSticky, ReadModelSticky, Screen, Processor, Scenario, Flow } from './types.js';
+export declare function getSliceComponents(model: EventModel, slice: Slice): {
+    commands: CommandSticky[];
+    events: EventSticky[];
+    readModels: ReadModelSticky[];
+    screens: Screen[];
+    processors: Processor[];
+};
+export declare function getSliceScenarios(model: EventModel, sliceId: string): Scenario[];
+export declare function getRelevantFlows(model: EventModel, componentIds: Set<string>): Flow[];
+export declare function formatSliceXml(model: EventModel, slice: Slice): string;
+export declare function formatSlicesTable(slices: Slice[]): string;
+export declare function formatEventsTable(events: EventSticky[]): string;
+export declare function formatCommandsTable(commands: CommandSticky[]): string;
+export declare function formatModelSummary(model: EventModel): string;
+export declare function formatEventXml(model: EventModel, event: EventSticky): string;
+export declare function formatCommandXml(model: EventModel, command: CommandSticky): string;

package/dist/formatters.js

@@ -0,0 +1,482 @@
+// Helper to escape XML special characters
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+// Helper to format field values for display
+function formatFieldValues(values) {
+    if (!values || Object.keys(values).length === 0)
+        return '';
+    return Object.entries(values)
+        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+        .join(', ');
+}
+// Format a single field as XML
+function formatFieldXml(field, indent, sourceInfo) {
+    const attrs = [
+        `name="${escapeXml(field.name)}"`,
+        `type="${field.fieldType}"`,
+    ];
+    if (field.isList)
+        attrs.push('list="true"');
+    if (field.isGenerated)
+        attrs.push('generated="true"');
+    if (field.isOptional)
+        attrs.push('optional="true"');
+    if (field.isUserInput)
+        attrs.push('user-input="true"');
+    if (sourceInfo)
+        attrs.push(`source="${escapeXml(sourceInfo)}"`);
+    if (field.subfields && field.subfields.length > 0) {
+        let xml = `${indent}<field ${attrs.join(' ')}>\n`;
+        for (const subfield of field.subfields) {
+            xml += formatFieldXml(subfield, indent + '  ');
+        }
+        xml += `${indent}</field>\n`;
+        return xml;
+    }
+    return `${indent}<field ${attrs.join(' ')}/>\n`;
+}
+// Get all components that belong to a slice (by position intersection)
+export function getSliceComponents(model, slice) {
+    const sliceBounds = {
+        left: slice.position.x,
+        right: slice.position.x + slice.size.width,
+        top: slice.position.y,
+        bottom: slice.position.y + slice.size.height,
+    };
+    function isInSlice(pos, width, height) {
+        const centerX = pos.x + width / 2;
+        const centerY = pos.y + height / 2;
+        return (centerX >= sliceBounds.left &&
+            centerX <= sliceBounds.right &&
+            centerY >= sliceBounds.top &&
+            centerY <= sliceBounds.bottom);
+    }
+    const commands = [];
+    const events = [];
+    const readModels = [];
+    const screens = [];
+    const processors = [];
+    for (const cmd of model.commands.values()) {
+        if (isInSlice(cmd.position, cmd.width, cmd.height)) {
+            commands.push(cmd);
+        }
+    }
+    for (const evt of model.events.values()) {
+        if (isInSlice(evt.position, evt.width, evt.height)) {
+            events.push(evt);
+        }
+    }
+    for (const rm of model.readModels.values()) {
+        if (isInSlice(rm.position, rm.width, rm.height)) {
+            readModels.push(rm);
+        }
+    }
+    for (const scr of model.screens.values()) {
+        if (isInSlice(scr.position, scr.width, scr.height)) {
+            screens.push(scr);
+        }
+    }
+    for (const proc of model.processors.values()) {
+        if (isInSlice(proc.position, proc.width, proc.height)) {
+            processors.push(proc);
+        }
+    }
+    return { commands, events, readModels, screens, processors };
+}
+// Get scenarios for a slice
+export function getSliceScenarios(model, sliceId) {
+    const scenarios = [];
+    for (const scenario of model.scenarios.values()) {
+        if (scenario.sliceId === sliceId) {
+            scenarios.push(scenario);
+        }
+    }
+    return scenarios;
+}
+// Get flows relevant to a set of components
+export function getRelevantFlows(model, componentIds) {
+    const flows = [];
+    for (const flow of model.flows.values()) {
+        if (componentIds.has(flow.sourceId) || componentIds.has(flow.targetId)) {
+            flows.push(flow);
+        }
+    }
+    return flows;
+}
+// Build information flow chains for a slice
+function buildInformationFlows(model, components, flows) {
+    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));
+    // Build adjacency for flows within the slice
+    const internalFlows = flows.filter(f => componentIds.has(f.sourceId) && componentIds.has(f.targetId));
+    // Get component name by ID
+    function getName(id) {
+        const cmd = model.commands.get(id);
+        if (cmd)
+            return cmd.name;
+        const evt = model.events.get(id);
+        if (evt)
+            return evt.name;
+        const rm = model.readModels.get(id);
+        if (rm)
+            return rm.name;
+        const scr = model.screens.get(id);
+        if (scr)
+            return scr.name;
+        const proc = model.processors.get(id);
+        if (proc)
+            return proc.name;
+        return id;
+    }
+    // Simple representation of flows
+    const flowStrings = [];
+    for (const flow of internalFlows) {
+        flowStrings.push(`${getName(flow.sourceId)} → ${getName(flow.targetId)}`);
+    }
+    return flowStrings;
+}
+// Format a slice as XML
+export function formatSliceXml(model, slice) {
+    const components = getSliceComponents(model, slice);
+    const scenarios = getSliceScenarios(model, slice.id);
+    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 = getRelevantFlows(model, componentIds);
+    const infoFlows = buildInformationFlows(model, components, flows);
+    let xml = `<slice name="${escapeXml(slice.name)}" status="${slice.status}">\n`;
+    // Components section
+    xml += '  <components>\n';
+    // Screens
+    for (const screen of components.screens) {
+        xml += `    <screen name="${escapeXml(screen.name)}">\n`;
+        if (screen.fields.length > 0) {
+            xml += '      <fields>\n';
+            for (const field of screen.fields) {
+                const sourceInfo = field.isUserInput ? 'user-input' : undefined;
+                xml += formatFieldXml(field, '        ', sourceInfo);
+            }
+            xml += '      </fields>\n';
+        }
+        xml += '    </screen>\n';
+    }
+    // Commands
+    for (const command of components.commands) {
+        xml += `    <command name="${escapeXml(command.name)}">\n`;
+        if (command.fields.length > 0) {
+            xml += '      <fields>\n';
+            for (const field of command.fields) {
+                // Try to find source from incoming flows
+                const incomingFlow = flows.find(f => f.targetId === command.id);
+                let sourceInfo;
+                if (incomingFlow) {
+                    const sourceScreen = model.screens.get(incomingFlow.sourceId);
+                    const sourceProcessor = model.processors.get(incomingFlow.sourceId);
+                    if (sourceScreen) {
+                        const sourceField = sourceScreen.fields.find(f => f.name === field.name);
+                        if (sourceField) {
+                            sourceInfo = `${sourceScreen.name}.${field.name}`;
+                        }
+                    }
+                    else if (sourceProcessor) {
+                        const sourceField = sourceProcessor.fields.find(f => f.name === field.name);
+                        if (sourceField) {
+                            sourceInfo = `${sourceProcessor.name}.${field.name}`;
+                        }
+                    }
+                }
+                xml += formatFieldXml(field, '        ', sourceInfo);
+            }
+            xml += '      </fields>\n';
+        }
+        xml += '    </command>\n';
+    }
+    // Events
+    for (const event of components.events) {
+        xml += `    <event name="${escapeXml(event.name)}">\n`;
+        if (event.fields.length > 0) {
+            xml += '      <fields>\n';
+            for (const field of event.fields) {
+                // Try to find source from incoming flows
+                const incomingFlow = flows.find(f => f.targetId === event.id);
+                let sourceInfo;
+                if (field.isGenerated) {
+                    sourceInfo = 'generated';
+                }
+                else if (incomingFlow) {
+                    const sourceCommand = model.commands.get(incomingFlow.sourceId);
+                    if (sourceCommand) {
+                        const sourceField = sourceCommand.fields.find(f => f.name === field.name);
+                        if (sourceField) {
+                            sourceInfo = `${sourceCommand.name}.${field.name}`;
+                        }
+                    }
+                }
+                xml += formatFieldXml(field, '        ', sourceInfo);
+            }
+            xml += '      </fields>\n';
+        }
+        xml += '    </event>\n';
+    }
+    // Read Models
+    for (const readModel of components.readModels) {
+        xml += `    <read-model name="${escapeXml(readModel.name)}">\n`;
+        if (readModel.fields.length > 0) {
+            xml += '      <fields>\n';
+            for (const field of readModel.fields) {
+                xml += formatFieldXml(field, '        ');
+            }
+            xml += '      </fields>\n';
+        }
+        xml += '    </read-model>\n';
+    }
+    // Processors
+    for (const processor of components.processors) {
+        xml += `    <processor name="${escapeXml(processor.name)}">\n`;
+        if (processor.fields.length > 0) {
+            xml += '      <fields>\n';
+            for (const field of processor.fields) {
+                xml += formatFieldXml(field, '        ');
+            }
+            xml += '      </fields>\n';
+        }
+        xml += '    </processor>\n';
+    }
+    xml += '  </components>\n';
+    // Information flow section
+    if (infoFlows.length > 0) {
+        xml += '  <information-flow>\n';
+        for (const flow of infoFlows) {
+            xml += `    ${escapeXml(flow)}\n`;
+        }
+        xml += '  </information-flow>\n';
+    }
+    // Scenarios section
+    if (scenarios.length > 0) {
+        xml += '  <scenarios>\n';
+        for (const scenario of scenarios) {
+            xml += `    <scenario name="${escapeXml(scenario.name)}">\n`;
+            if (scenario.description) {
+                xml += `      <description>${escapeXml(scenario.description)}</description>\n`;
+            }
+            // Given events
+            if (scenario.givenEvents.length > 0) {
+                xml += '      <given>\n';
+                for (const givenEvent of scenario.givenEvents) {
+                    const evt = model.events.get(givenEvent.eventStickyId);
+                    const evtName = evt?.name ?? 'UnknownEvent';
+                    const fieldValuesStr = formatFieldValues(givenEvent.fieldValues);
+                    if (fieldValuesStr) {
+                        xml += `        <event type="${escapeXml(evtName)}">${escapeXml(fieldValuesStr)}</event>\n`;
+                    }
+                    else {
+                        xml += `        <event type="${escapeXml(evtName)}"/>\n`;
+                    }
+                }
+                xml += '      </given>\n';
+            }
+            // When command
+            if (scenario.whenCommand) {
+                const cmd = model.commands.get(scenario.whenCommand.commandStickyId);
+                const cmdName = cmd?.name ?? 'UnknownCommand';
+                const fieldValuesStr = formatFieldValues(scenario.whenCommand.fieldValues);
+                if (fieldValuesStr) {
+                    xml += `      <when>\n        <command type="${escapeXml(cmdName)}">${escapeXml(fieldValuesStr)}</command>\n      </when>\n`;
+                }
+                else {
+                    xml += `      <when>\n        <command type="${escapeXml(cmdName)}"/>\n      </when>\n`;
+                }
+            }
+            // Then
+            xml += '      <then>\n';
+            if (scenario.then.type === 'error') {
+                xml += `        <error`;
+                if (scenario.then.errorType) {
+                    xml += ` type="${escapeXml(scenario.then.errorType)}"`;
+                }
+                xml += `>${escapeXml(scenario.then.errorMessage ?? '')}</error>\n`;
+            }
+            else if (scenario.then.type === 'events' && scenario.then.expectedEvents) {
+                for (const expectedEvent of scenario.then.expectedEvents) {
+                    const evt = model.events.get(expectedEvent.eventStickyId);
+                    const evtName = evt?.name ?? 'UnknownEvent';
+                    const fieldValuesStr = formatFieldValues(expectedEvent.fieldValues);
+                    if (fieldValuesStr) {
+                        xml += `        <event type="${escapeXml(evtName)}">${escapeXml(fieldValuesStr)}</event>\n`;
+                    }
+                    else {
+                        xml += `        <event type="${escapeXml(evtName)}"/>\n`;
+                    }
+                }
+            }
+            else if (scenario.then.type === 'readModelAssertion' && scenario.then.readModelAssertion) {
+                const assertion = scenario.then.readModelAssertion;
+                const rm = model.readModels.get(assertion.readModelStickyId);
+                const rmName = rm?.name ?? 'UnknownReadModel';
+                xml += `        <read-model-assertion type="${escapeXml(rmName)}">\n`;
+                xml += `          <expected>${escapeXml(formatFieldValues(assertion.expectedFieldValues))}</expected>\n`;
+                xml += '        </read-model-assertion>\n';
+            }
+            xml += '      </then>\n';
+            xml += '    </scenario>\n';
+        }
+        xml += '  </scenarios>\n';
+    }
+    xml += '</slice>';
+    return xml;
+}
+// Format slices list as table
+export function formatSlicesTable(slices) {
+    if (slices.length === 0) {
+        return 'No slices found.';
+    }
+    // Sort by position (left to right)
+    const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
+    // Calculate column widths
+    const nameWidth = Math.max(4, ...sorted.map(s => s.name.length));
+    const statusWidth = 11; // 'in-progress' is longest
+    let output = '';
+    output += `${'NAME'.padEnd(nameWidth)}  ${'STATUS'.padEnd(statusWidth)}\n`;
+    output += `${'-'.repeat(nameWidth)}  ${'-'.repeat(statusWidth)}\n`;
+    for (const slice of sorted) {
+        const statusDisplay = slice.status === 'in-progress' ? 'in-progress' : slice.status;
+        output += `${slice.name.padEnd(nameWidth)}  ${statusDisplay.padEnd(statusWidth)}\n`;
+    }
+    return output;
+}
+// Format events list as table
+export function formatEventsTable(events) {
+    if (events.length === 0) {
+        return 'No events found.';
+    }
+    const sorted = [...events].sort((a, b) => a.name.localeCompare(b.name));
+    const nameWidth = Math.max(4, ...sorted.map(e => e.name.length));
+    const fieldsWidth = 6;
+    let output = '';
+    output += `${'NAME'.padEnd(nameWidth)}  ${'FIELDS'.padEnd(fieldsWidth)}\n`;
+    output += `${'-'.repeat(nameWidth)}  ${'-'.repeat(fieldsWidth)}\n`;
+    for (const evt of sorted) {
+        output += `${evt.name.padEnd(nameWidth)}  ${String(evt.fields.length).padEnd(fieldsWidth)}\n`;
+    }
+    return output;
+}
+// Format commands list as table
+export function formatCommandsTable(commands) {
+    if (commands.length === 0) {
+        return 'No commands found.';
+    }
+    const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
+    const nameWidth = Math.max(4, ...sorted.map(c => c.name.length));
+    const fieldsWidth = 6;
+    let output = '';
+    output += `${'NAME'.padEnd(nameWidth)}  ${'FIELDS'.padEnd(fieldsWidth)}\n`;
+    output += `${'-'.repeat(nameWidth)}  ${'-'.repeat(fieldsWidth)}\n`;
+    for (const cmd of sorted) {
+        output += `${cmd.name.padEnd(nameWidth)}  ${String(cmd.fields.length).padEnd(fieldsWidth)}\n`;
+    }
+    return output;
+}
+// Format model summary
+export function formatModelSummary(model) {
+    let output = `Event Model: ${model.name}\n`;
+    output += `${'='.repeat(model.name.length + 13)}\n\n`;
+    output += `Slices:      ${model.slices.size}\n`;
+    output += `Commands:    ${model.commands.size}\n`;
+    output += `Events:      ${model.events.size}\n`;
+    output += `Read Models: ${model.readModels.size}\n`;
+    output += `Screens:     ${model.screens.size}\n`;
+    output += `Processors:  ${model.processors.size}\n`;
+    output += `Scenarios:   ${model.scenarios.size}\n`;
+    output += `Flows:       ${model.flows.size}\n`;
+    return output;
+}
+// Format entity details as XML
+export function formatEventXml(model, event) {
+    let xml = `<event name="${escapeXml(event.name)}">\n`;
+    if (event.fields.length > 0) {
+        xml += '  <fields>\n';
+        for (const field of event.fields) {
+            xml += formatFieldXml(field, '    ');
+        }
+        xml += '  </fields>\n';
+    }
+    // Find incoming flows (what produces this event)
+    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === event.id);
+    // Find outgoing flows (what consumes this event)
+    const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === event.id);
+    if (incomingFlows.length > 0) {
+        xml += '  <produced-by>\n';
+        for (const flow of incomingFlows) {
+            const source = model.commands.get(flow.sourceId);
+            if (source) {
+                xml += `    <command name="${escapeXml(source.name)}"/>\n`;
+            }
+        }
+        xml += '  </produced-by>\n';
+    }
+    if (outgoingFlows.length > 0) {
+        xml += '  <consumed-by>\n';
+        for (const flow of outgoingFlows) {
+            const target = model.readModels.get(flow.targetId);
+            if (target) {
+                xml += `    <read-model name="${escapeXml(target.name)}"/>\n`;
+            }
+        }
+        xml += '  </consumed-by>\n';
+    }
+    xml += '</event>';
+    return xml;
+}
+export function formatCommandXml(model, command) {
+    let xml = `<command name="${escapeXml(command.name)}">\n`;
+    if (command.fields.length > 0) {
+        xml += '  <fields>\n';
+        for (const field of command.fields) {
+            xml += formatFieldXml(field, '    ');
+        }
+        xml += '  </fields>\n';
+    }
+    // Find incoming flows (what triggers this command)
+    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === command.id);
+    // Find outgoing flows (what events this command produces)
+    const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === command.id);
+    if (incomingFlows.length > 0) {
+        xml += '  <triggered-by>\n';
+        for (const flow of incomingFlows) {
+            const sourceScreen = model.screens.get(flow.sourceId);
+            const sourceProcessor = model.processors.get(flow.sourceId);
+            if (sourceScreen) {
+                xml += `    <screen name="${escapeXml(sourceScreen.name)}"/>\n`;
+            }
+            else if (sourceProcessor) {
+                xml += `    <processor name="${escapeXml(sourceProcessor.name)}"/>\n`;
+            }
+        }
+        xml += '  </triggered-by>\n';
+    }
+    if (outgoingFlows.length > 0) {
+        xml += '  <produces>\n';
+        for (const flow of outgoingFlows) {
+            const target = model.events.get(flow.targetId);
+            if (target) {
+                xml += `    <event name="${escapeXml(target.name)}"/>\n`;
+            }
+        }
+        xml += '  </produces>\n';
+    }
+    xml += '</command>';
+    return xml;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import * as fs from 'node:fs';
+import { findEventModelFile, loadModel } from './lib/file-loader.js';
+// Import slices
+import { listSlices } from './slices/list-slices/index.js';
+import { listEvents } from './slices/list-events/index.js';
+import { listCommands } from './slices/list-commands/index.js';
+import { showSlice } from './slices/show-slice/index.js';
+import { showEvent } from './slices/show-event/index.js';
+import { showCommand } from './slices/show-command/index.js';
+import { markSliceStatus } from './slices/mark-slice-status/index.js';
+import { showModelSummary } from './slices/show-model-summary/index.js';
+import { exportEventmodelToJson } from './slices/export-eventmodel-to-json/index.js';
+import { openApp } from './slices/open-app/index.js';
+import { search } from './slices/search/index.js';
+import { listChapters } from './slices/list-chapters/index.js';
+import { showChapter } from './slices/show-chapter/index.js';
+const args = process.argv.slice(2);
+function printHelp() {
+    console.log(`
+eventmodeler - CLI tool for interacting with Event Model files
+
+USAGE:
+  eventmodeler                       Open the Event Modeling app in browser
+  eventmodeler <command> [options]   Run a CLI command
+
+COMMANDS:
+  list slices                    List all slices with their status
+  list events                    List all events
+  list commands                  List all commands
+  list chapters                  List all chapters
+
+  show slice <name>              Show detailed XML view of a slice
+  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
+
+  search <term>                  Search for entities by name
+
+  mark <slice-name> <status>     Mark a slice's status
+                                 Status: created | in-progress | blocked | done
+
+  summary                        Show model summary statistics
+
+  export json                    Export entire model as JSON
+
+OPTIONS:
+  -f, --file <path>              Path to .eventmodeler file (default: auto-detect)
+  -h, --help                     Show this help message
+
+EXAMPLES:
+  eventmodeler list slices
+  eventmodeler show slice "Place Order"
+  eventmodeler mark "Place Order" done
+  eventmodeler summary -f ./my-model.eventmodeler
+`);
+}
+async function main() {
+    let fileArg = null;
+    const filteredArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-f' || args[i] === '--file') {
+            fileArg = args[++i];
+        }
+        else if (args[i] === '-h' || args[i] === '--help') {
+            printHelp();
+            process.exit(0);
+        }
+        else {
+            filteredArgs.push(args[i]);
+        }
+    }
+    const command = filteredArgs[0];
+    const subcommand = filteredArgs[1];
+    const target = filteredArgs[2];
+    if (!command) {
+        openApp();
+        return;
+    }
+    const filePath = fileArg ?? await findEventModelFile();
+    if (!filePath) {
+        console.error('Error: No .eventmodeler file found in current directory.');
+        console.error('Use -f <path> to specify a file or run in a directory with an .eventmodeler file.');
+        process.exit(1);
+    }
+    if (!fs.existsSync(filePath)) {
+        console.error(`Error: File not found: ${filePath}`);
+        process.exit(1);
+    }
+    const model = loadModel(filePath);
+    switch (command) {
+        case 'list':
+            switch (subcommand) {
+                case 'slices':
+                    listSlices(model);
+                    break;
+                case 'events':
+                    listEvents(model);
+                    break;
+                case 'commands':
+                    listCommands(model);
+                    break;
+                case 'chapters':
+                    listChapters(model);
+                    break;
+                default:
+                    console.error(`Unknown list target: ${subcommand}`);
+                    console.error('Valid targets: slices, events, commands, chapters');
+                    process.exit(1);
+            }
+            break;
+        case 'show':
+            switch (subcommand) {
+                case 'slice':
+                    if (!target) {
+                        console.error('Usage: eventmodeler show slice <name>');
+                        process.exit(1);
+                    }
+                    showSlice(model, target);
+                    break;
+                case 'event':
+                    if (!target) {
+                        console.error('Usage: eventmodeler show event <name>');
+                        process.exit(1);
+                    }
+                    showEvent(model, target);
+                    break;
+                case 'command':
+                    if (!target) {
+                        console.error('Usage: eventmodeler show command <name>');
+                        process.exit(1);
+                    }
+                    showCommand(model, target);
+                    break;
+                case 'chapter':
+                    if (!target) {
+                        console.error('Usage: eventmodeler show chapter <name>');
+                        process.exit(1);
+                    }
+                    showChapter(model, target);
+                    break;
+                default:
+                    console.error(`Unknown show target: ${subcommand}`);
+                    console.error('Valid targets: slice, event, command, chapter');
+                    process.exit(1);
+            }
+            break;
+        case 'search':
+            if (!subcommand) {
+                console.error('Usage: eventmodeler search <term>');
+                process.exit(1);
+            }
+            search(model, subcommand);
+            break;
+        case 'mark':
+            if (!subcommand || !target) {
+                console.error('Usage: eventmodeler mark <slice-name> <status>');
+                console.error('Valid statuses: created, in-progress, blocked, done');
+                process.exit(1);
+            }
+            markSliceStatus(model, filePath, subcommand, target);
+            break;
+        case 'summary':
+            showModelSummary(model);
+            break;
+        case 'export':
+            switch (subcommand) {
+                case 'json':
+                    exportEventmodelToJson(model);
+                    break;
+                default:
+                    console.error(`Unknown export format: ${subcommand}`);
+                    console.error('Valid formats: json');
+                    process.exit(1);
+            }
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            printHelp();
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error('Error:', err.message);
+    process.exit(1);
+});