eventmodeler 0.5.0 → 0.6.0

package/dist/index.js

@@ -2,2388 +2,55 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { getDefaultFormat } from './lib/config.js';
+import { Command } from 'commander';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
-const VERSION = packageJson.version;
-// Utilities
-import { openApp } from './slices/open-app/index.js';
-import { parseScenarioInput } from './slices/add-scenario/index.js';
-import { runGuide } from './slices/guide/index.js';
-import { login } from './slices/login/index.js';
-import { logout } from './slices/logout/index.js';
-import { whoami } from './slices/whoami/index.js';
-import { init } from './slices/init/index.js';
-import * as api from './api/index.js';
-import { XMLBuilder, XMLParser } from 'fast-xml-parser';
-import { loadProjectConfig } from './lib/project-config.js';
-const args = process.argv.slice(2);
-function getNamedArg(argList, ...names) {
-    for (let i = 0; i < argList.length; i++) {
-        if (names.includes(argList[i]) && i + 1 < argList.length) {
-            return argList[i + 1];
-        }
-    }
-    return undefined;
-}
-function hasHelpFlag(argList) {
-    return argList.includes('-h') || argList.includes('--help');
-}
-function toCompoundFields(fields) {
-    return fields.map(field => ({
-        name: field.name,
-        fieldType: field.type,
-        isList: field.isList,
-        isOptional: field.isOptional,
-        isGenerated: field.isGenerated,
-        isUserInput: field.isUserInput,
-        subfields: field.subfields ? toCompoundFields(field.subfields) : undefined,
-    }));
-}
-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
-
-AUTHENTICATION:
-  login                            Authenticate with eventmodeler.app
-  logout                           Sign out
-  whoami                           Show authentication status
-
-PROJECT SETUP:
-  init                             Initialize project (link to a model)
-
-COMMANDS:
-  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
-  list readmodels                List all read models
-  list screens                   List all screens
-  list processors                List all processors
-  list scenarios                 List all scenarios
-
-  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 slices, flow graph, and
-                                 external dependencies
-  show information-completeness  Show information completeness of all flows
-  show information-completeness <name>
-                                 Show field mapping completeness for an element
-  show aggregate-completeness <name>
-                                 Show if events in aggregate have the ID field
-  show actor <name>              Show actor with its screens
-  show readmodel <name>          Show read model with fields and flows
-  show screen <name>             Show screen with fields and connections
-  show processor <name>          Show processor with subscriptions and commands
-  show aggregate <name>          Show aggregate with events and ID field status
-  show scenario <name>           Show scenario with Given-When-Then details
-
-  search <term>                  Search for entities by name
-
-  mark <slice-name> <status>     Mark a slice's status
-                                 Status: created | in-progress | blocked | done
-
-  add scenario --slice <name> --json|--xml <data>
-                                 Add a scenario to a slice
-  add field <element-name> --json|--xml <data>
-                                 Add a field to an entity
-
-  remove scenario <name> [--slice <name>]
-                                 Remove a scenario by name
-  remove field <element-name> --field <name>
-                                 Remove a field from an entity
-
-  map fields --flow <source→target> --json|--xml <mappings>
-                                 Set field mappings on a flow
-
-  update field <element-name> --field <name> [--optional true|false] [--generated true|false] [--user-input true|false]
-                                 Update field properties
-
-  create state-change-slice --xml <data>
-                                 Create a state-change slice (Screen → Command → Event)
-  create automation-slice --xml <data>
-                                 Create an automation slice (ReadModel → Processor → Command → Event)
-  create state-view-slice --xml <data>
-                                 Create a state-view slice (Read Model)
-  create flow --from <source> --to <target>
-                                 Create a flow between elements (Event→ReadModel, ReadModel→Screen/Processor)
-
-  codegen slice <name>           Generate code-ready JSON for a slice (includes dependencies, mappings, scenarios)
-  codegen events [--chapter <name>]
-                                 Generate deduplicated events for a chapter or the whole model
-
-  summary                        Show model summary statistics
-
-  export json                    Export entire model as JSON
-
-GUIDES:
-  guide                          List available guides for AI agents and users
-  guide <name>                   Read a conceptual guide (no auth required)
-
-OPTIONS:
-  --format <xml|json>            Output format (default: xml, or from config)
-  -h, --help                     Show this help message
-  -v, --version                  Show version number
-
-CONFIGURATION:
-  Set default output format via:
-  - Environment variable: EVENTMODELER_FORMAT=json
-  - Config file: ~/.eventmodeler/config.json with {"format": "json"}
-
-EXAMPLES:
-  eventmodeler list slices
-  eventmodeler show slice "Place Order"
-  eventmodeler mark "Place Order" done
-  eventmodeler add scenario --slice "Place Order" --json '{"name": "Happy path", "then": {"type": "events", "events": []}}'
-  eventmodeler add field "OrderPlaced" --json '{"name": "orderId", "type": "UUID"}'
-  eventmodeler remove field "OrderPlaced" --field "orderId"
-  eventmodeler show information-completeness
-  eventmodeler show information-completeness "OrderSummary"
-  eventmodeler map fields --flow "OrderPlaced→OrderSummary" --json '[{"from": "total", "to": "totalAmount"}]'
-  eventmodeler update field "OrderSummary" --field "notes" --optional true
-`);
-}
-async function main() {
-    let formatArg = null;
-    let chapterArg = null;
-    const filteredArgs = [];
-    let helpRequested = false;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--format') {
-            formatArg = args[++i];
-        }
-        else if (args[i] === '--chapter') {
-            chapterArg = args[++i];
-        }
-        else if (args[i] === '-v' || args[i] === '--version') {
-            console.log(`eventmodeler ${VERSION}`);
-            process.exit(0);
-        }
-        else if (args[i] === '-h' || args[i] === '--help') {
-            helpRequested = true;
-        }
-        else {
-            filteredArgs.push(args[i]);
-        }
-    }
-    // Handle --help: if no command specified, show general help
-    // Otherwise let command-specific help handle it
-    if (helpRequested && filteredArgs.length === 0) {
-        printHelp();
-        process.exit(0);
-    }
-    // Determine output format
-    const format = formatArg === 'json' ? 'json'
-        : formatArg === 'xml' ? 'xml'
-            : getDefaultFormat();
-    const command = filteredArgs[0];
-    const subcommand = filteredArgs[1];
-    // Join remaining args as target (allows "show chapter Register Products" without quotes)
-    // For commands with named args (--flag), those are already extracted by getNamedArg
-    const remainingArgs = filteredArgs.slice(2);
-    const target = remainingArgs.length > 0 ? remainingArgs.join(' ') : undefined;
-    if (!command) {
-        openApp();
-        return;
-    }
-    // Auth commands (no file needed)
-    if (command === 'login') {
-        if (helpRequested) {
-            console.log(`
-eventmodeler login - Authenticate with eventmodeler.app
-
-USAGE:
-  eventmodeler login
-
-Opens your browser for authentication via Keycloak.
-Credentials are stored securely in ~/.eventmodeler/config.json
-
-After login, you can:
-  - Use "eventmodeler init" to connect a project to a model
-
-EXAMPLES:
-  eventmodeler login
-`);
-            process.exit(0);
-        }
-        await login();
-        return;
-    }
-    if (command === 'logout') {
-        if (helpRequested) {
-            console.log(`
-eventmodeler logout - Sign out of eventmodeler.app
-
-USAGE:
-  eventmodeler logout
-
-Clears stored credentials from ~/.eventmodeler/config.json
-
-EXAMPLES:
-  eventmodeler logout
-`);
-            process.exit(0);
-        }
-        logout();
-        return;
-    }
-    if (command === 'whoami') {
-        if (helpRequested) {
-            console.log(`
-eventmodeler whoami - Show current authentication status
-
-USAGE:
-  eventmodeler whoami [--format xml|json]
-
-OPTIONS:
-  --format <format>   Output format: xml (default) or json
-
-OUTPUT:
-  Shows whether you're logged in and your email address.
-
-EXAMPLES:
-  eventmodeler whoami
-  eventmodeler whoami --format json
-`);
-            process.exit(0);
-        }
-        whoami(format);
-        return;
-    }
-    if (command === 'init') {
-        if (helpRequested) {
-            console.log(`
-eventmodeler init - Initialize a project
-
-USAGE:
-  eventmodeler init
-
-Interactive setup to connect this directory to an event model.
-Creates a .eventmodeler.json config file in your project root.
-
-PREREQUISITES:
-  - You must be logged in (run "eventmodeler login" first)
-
-EXAMPLES:
-  cd my-project
-  eventmodeler init
-`);
-            process.exit(0);
-        }
-        await init();
-        return;
-    }
-    if (command === 'guide') {
-        runGuide(subcommand);
-        return;
-    }
-    const projectConfig = loadProjectConfig();
-    if (!projectConfig || projectConfig.type !== 'cloud') {
-        console.error('Error: No project configured.');
-        console.error('Run "eventmodeler init" to connect this directory to a model.');
-        process.exit(1);
-    }
-    const modelId = projectConfig.modelId;
-    switch (command) {
-        case 'list':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler list - List entities in the event model
-
-USAGE:
-  eventmodeler list <type> [options]
-
-TYPES:
-  slices      List all slices (with optional --chapter filter)
-  events      List all events
-  commands    List all commands
-  chapters    List all chapters
-  aggregates  List all aggregates
-  actors      List all actors
-  readmodels  List all read models
-  screens     List all screens
-  processors  List all processors
-
-OPTIONS:
-  --chapter <name>    Filter slices by chapter (slices only)
-  --format xml|json   Output format (default: xml)
-
-EXAMPLES:
-  eventmodeler list slices
-  eventmodeler list slices --chapter "Order Management"
-  eventmodeler list events --format json
-
-Run "eventmodeler list <type> --help" for type-specific help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'slices':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list slices - List all slices in the event model
-
-USAGE:
-  eventmodeler list slices [--chapter <name>] [--format xml|json]
-
-OPTIONS:
-  --chapter <name>    Filter by chapter name
-  --format <format>   Output format: xml (default) or json
-
-OUTPUT FIELDS:
-  name      Slice name
-  type      state-change | automation | state-view
-  status    created | in-progress | blocked | done
-  chapter   Parent chapter name
-
-EXAMPLES:
-  eventmodeler list slices
-  eventmodeler list slices --chapter "Order Management"
-  eventmodeler list slices --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listSlices(modelId, format, chapterArg ?? undefined);
-                        console.log(output);
-                    }
-                    break;
-                case 'events':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list events - List all events in the event model
-
-USAGE:
-  eventmodeler list events [--format xml|json]
-
-OPTIONS:
-  --format <format>   Output format: xml (default) or json
-
-OUTPUT FIELDS:
-  name        Event name
-  aggregate   Parent aggregate name
-
-NOTE: Linked copies (events referencing a canonical original) are excluded.
-
-EXAMPLES:
-  eventmodeler list events
-  eventmodeler list events --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listEvents(modelId, format);
-                        console.log(output);
-                    }
-                    break;
-                case 'commands':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list commands - List all commands in the event model
-
-USAGE:
-  eventmodeler list commands [--format xml|json]
-
-OPTIONS:
-  --format <format>   Output format: xml (default) or json
-
-OUTPUT FIELDS:
-  name        Command name
-  aggregate   Parent aggregate name
-
-EXAMPLES:
-  eventmodeler list commands
-  eventmodeler list commands --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listCommands(modelId, format);
-                        console.log(output);
-                    }
-                    break;
-                case 'chapters':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list chapters - List all chapters in the event model
-
-USAGE:
-  eventmodeler list chapters [--format xml|json]
-
-OPTIONS:
-  --format <format>   Output format: xml (default) or json
-
-OUTPUT FIELDS:
-  name         Chapter name
-  sliceCount   Number of slices in chapter
-
-EXAMPLES:
-  eventmodeler list chapters
-  eventmodeler list chapters --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listChapters(modelId, format);
-                        console.log(output);
-                    }
-                    break;
-                case 'aggregates':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list aggregates - List all aggregates in the event model
-
-USAGE:
-  eventmodeler list aggregates [--format xml|json]
-
-OPTIONS:
-  --format <format>   Output format: xml (default) or json
-
-OUTPUT FIELDS:
-  name          Aggregate name
-  eventCount    Number of events
-  commandCount  Number of commands
-
-EXAMPLES:
-  eventmodeler list aggregates
-  eventmodeler list aggregates --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const result = await api.listAggregates(modelId, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'actors':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list actors - List all actors in the event model
-
-USAGE:
-  eventmodeler list actors [--format xml|json]
-
-OPTIONS:
-  --format <format>   Output format: xml (default) or json
-
-OUTPUT FIELDS:
-  name          Actor name
-  screenCount   Number of screens
-
-EXAMPLES:
-  eventmodeler list actors
-  eventmodeler list actors --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listActors(modelId, format);
-                        console.log(output);
-                    }
-                    break;
-                case 'readmodels':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list readmodels - List all read models
-
-USAGE:
-  eventmodeler list readmodels [--format xml|json]
-
-OUTPUT:
-  Lists read models with id, name, and field count.
-  Excludes linked copies (shows only canonical read models).
-
-EXAMPLES:
-  eventmodeler list readmodels
-  eventmodeler list readmodels --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listReadModels(modelId, format);
-                        console.log(output);
-                    }
-                    break;
-                case 'screens':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list screens - List all screens
-
-USAGE:
-  eventmodeler list screens [--format xml|json]
-
-OUTPUT:
-  Lists screens with id, name, field count, and actor (if in one).
-  Excludes linked copies (shows only canonical screens).
-
-EXAMPLES:
-  eventmodeler list screens
-  eventmodeler list screens --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listScreens(modelId, format);
-                        console.log(output);
-                    }
-                    break;
-                case 'processors':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list processors - List all processors
-
-USAGE:
-  eventmodeler list processors [--format xml|json]
-
-OUTPUT:
-  Lists processors with id, name, and field count.
-
-EXAMPLES:
-  eventmodeler list processors
-  eventmodeler list processors --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listProcessors(modelId, format);
-                        console.log(output);
-                    }
-                    break;
-                case 'scenarios':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler list scenarios - List all scenarios
-
-USAGE:
-  eventmodeler list scenarios [--format xml|json]
-
-OUTPUT:
-  - Scenario name
-  - Parent slice
-  - Then type (events, error, command, etc.)
-
-EXAMPLES:
-  eventmodeler list scenarios
-  eventmodeler list scenarios --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const output = await api.listScenarios(modelId, format);
-                        console.log(output);
-                    }
-                    break;
-                default:
-                    console.error(`Unknown list target: ${subcommand}`);
-                    console.error('Valid targets: slices, events, commands, chapters, aggregates, actors, readmodels, screens, processors, scenarios');
-                    console.error('Run "eventmodeler list --help" for more information.');
-                    process.exit(1);
-            }
-            break;
-        case 'show':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler show - Show detailed information about entities
-
-USAGE:
-  eventmodeler show <type> <name> [options]
-
-TYPES:
-  slice                  Show slice with components and flows
-  event                  Show event with all fields
-  command                Show command with all fields
-  chapter                Show chapter with slices and dependencies
-  information-completeness     Show information completeness of all flows
-                               (with element name: show per-element completeness)
-  aggregate-completeness Show if events have aggregate ID field
-  actor                  Show actor with screens
-  readmodel              Show read model with fields and flows
-  screen                 Show screen with fields and connections
-  processor              Show processor with subscriptions and commands
-  aggregate              Show aggregate with events and ID field status
-  scenario               Show scenario with Given-When-Then details
-
-OPTIONS:
-  --format xml|json   Output format (default: xml)
-
-EXAMPLES:
-  eventmodeler show slice "Place Order"
-  eventmodeler show event OrderPlaced
-  eventmodeler show information-completeness OrderSummary
-
-Run "eventmodeler show <type> --help" for type-specific help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'slice':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show slice - Show detailed slice information
-
-USAGE:
-  eventmodeler show slice <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Slice name (spaces allowed without quotes)
-
-OUTPUT INCLUDES:
-  - Slice type (state-change, automation, state-view)
-  - Status (created, in-progress, blocked, done)
-  - Components: screens, commands, events, read models, processors
-  - Each component's fields with types and flags
-  - Flow annotations and swimlane positions
-  - Inbound/outbound dependencies
-  - Scenarios (Given-When-Then specifications)
-
-EXAMPLES:
-  eventmodeler show slice "Place Order"
-  eventmodeler show slice Place Order
-  eventmodeler show slice "Place Order" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show slice <name>');
-                        console.error('Run "eventmodeler show slice --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showSlice(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'event':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show event - Show detailed event information
-
-USAGE:
-  eventmodeler show event <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Event name (spaces allowed without quotes)
-
-OUTPUT INCLUDES:
-  - Event name and aggregate
-  - All fields with:
-    - name: Field name
-    - type: UUID, String, Int, Long, Double, Decimal, Boolean, Date, DateTime, Custom
-    - isList: Whether field is an array
-    - isOptional: Whether field can be null
-    - isGenerated: Whether field is computed (not mapped from source)
-    - subfields: Nested fields for Custom types (recursive, with all flags)
-
-FIELD OUTPUT FORMAT (XML):
-  <field name="orderId" type="UUID"/>
-  <field name="total" type="Decimal" isGenerated="true"/>
-  <field name="items" type="Custom" isList="true">
-    <field name="productId" type="UUID"/>
-    <field name="lineTotal" type="Decimal" isGenerated="true"/>
-  </field>
-
-EXAMPLES:
-  eventmodeler show event OrderPlaced
-  eventmodeler show event "Order Placed" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show event <name>');
-                        console.error('Run "eventmodeler show event --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showEvent(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'command':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show command - Show detailed command information
-
-USAGE:
-  eventmodeler show command <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Command name (spaces allowed without quotes)
-
-OUTPUT INCLUDES:
-  - Command name and aggregate
-  - All fields with types, flags, and nested subfields
-
-EXAMPLES:
-  eventmodeler show command PlaceOrder
-  eventmodeler show command "Place Order" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show command <name>');
-                        console.error('Run "eventmodeler show command --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showCommand(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'chapter':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show chapter - Show detailed chapter information
-
-USAGE:
-  eventmodeler show chapter <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Chapter name
-
-OUTPUT INCLUDES:
-  - All slices in the chapter
-  - Flow graph showing internal dependencies
-  - External dependencies (inbound/outbound)
-
-EXAMPLES:
-  eventmodeler show chapter "Order Management"
-  eventmodeler show chapter "Order Management" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show chapter <name>');
-                        console.error('Run "eventmodeler show chapter --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showChapter(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'information-completeness':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show information-completeness - Show information completeness
-
-USAGE:
-  eventmodeler show information-completeness [--format xml|json]
-  eventmodeler show information-completeness --slice "Place Order"
-  eventmodeler show information-completeness --chapter "Ordering"
-  eventmodeler show information-completeness <element-name> [--format xml|json]
-
-OUTPUT INCLUDES (model-wide):
-  - Summary of complete/incomplete flows across the whole model
-  - Incomplete flows grouped by slice, with untraceable fields
-  - Incomplete read models with untraceable fields and source events
-
-OUTPUT INCLUDES (per-element):
-  - Total fields vs mapped fields
-  - List of unmapped fields needing attention
-  - Mapping sources for mapped fields
-
-IMPORTANT - GENERATED FIELDS:
-  Fields with isGenerated=true are EXCLUDED from completeness checks.
-  Generated fields are computed/synthesized values that don't need
-  source mappings (e.g., calculated totals, timestamps, derived data).
-
-NOTE: Generated and user-input fields are excluded from checks.
-      Auto-matching uses field name AND type.
-
-EXAMPLES:
-  eventmodeler show information-completeness
-  eventmodeler show information-completeness --slice "Place Order"
-  eventmodeler show information-completeness --chapter "Ordering"
-  eventmodeler show information-completeness --format json
-  eventmodeler show information-completeness CreateOrder
-  eventmodeler show information-completeness "Order Summary" --format json
-`);
-                        process.exit(0);
-                    }
-                    {
-                        if (target) {
-                            // Per-element completeness
-                            const result = await api.showElementCompleteness(modelId, target, format);
-                            console.log(result);
-                        }
-                        else {
-                            // Model-wide information completeness
-                            const sliceFilter = getNamedArg(filteredArgs, '--slice');
-                            const result = await api.showInformationCompleteness(modelId, format, sliceFilter, chapterArg ?? undefined);
-                            console.log(result);
-                        }
-                    }
-                    break;
-                case 'aggregate-completeness':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show aggregate-completeness - Check aggregate ID field presence
-
-USAGE:
-  eventmodeler show aggregate-completeness <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Aggregate name
-
-OUTPUT:
-  Lists all events in the aggregate and whether each has the
-  aggregate ID field (e.g., "orderId" for "Order" aggregate).
-
-EXAMPLES:
-  eventmodeler show aggregate-completeness Order
-  eventmodeler show aggregate-completeness "Order" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show aggregate-completeness <aggregate-name>');
-                        console.error('Run "eventmodeler show aggregate-completeness --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showAggregateCompleteness(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'actor':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show actor - Show detailed actor information
-
-USAGE:
-  eventmodeler show actor <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Actor name
-
-OUTPUT INCLUDES:
-  - Actor name
-  - All associated screens
-
-EXAMPLES:
-  eventmodeler show actor Customer
-  eventmodeler show actor "Admin User" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show actor <actor-name>');
-                        console.error('Run "eventmodeler show actor --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showActor(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'readmodel':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show readmodel - Show detailed read model information
-
-USAGE:
-  eventmodeler show readmodel <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Read model name
-
-OUTPUT INCLUDES:
-  - Read model name and fields
-  - Events it consumes from (with field mappings)
-  - Screens/Processors it flows to
-
-EXAMPLES:
-  eventmodeler show readmodel OrderSummary
-  eventmodeler show readmodel "Customer Profile" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show readmodel <name>');
-                        console.error('Run "eventmodeler show readmodel --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showReadModel(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'screen':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show screen - Show detailed screen information
-
-USAGE:
-  eventmodeler show screen <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Screen name
-
-OUTPUT INCLUDES:
-  - Screen name and fields
-  - Actor (if contained in one)
-  - Read models it displays from
-  - Commands it triggers
-
-EXAMPLES:
-  eventmodeler show screen "Order Form"
-  eventmodeler show screen Dashboard --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show screen <name>');
-                        console.error('Run "eventmodeler show screen --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showScreen(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'processor':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show processor - Show detailed processor information
-
-USAGE:
-  eventmodeler show processor <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Processor name
-
-OUTPUT INCLUDES:
-  - Processor name and fields
-  - Read models it subscribes to
-  - Commands it triggers
-
-EXAMPLES:
-  eventmodeler show processor "Order Validator"
-  eventmodeler show processor NotificationSender --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show processor <name>');
-                        console.error('Run "eventmodeler show processor --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showProcessor(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'aggregate':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show aggregate - Show detailed aggregate information
-
-USAGE:
-  eventmodeler show aggregate <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Aggregate name
-
-OUTPUT INCLUDES:
-  - Aggregate name
-  - ID field configuration (if set)
-  - All contained events
-  - ID field completeness status
-
-EXAMPLES:
-  eventmodeler show aggregate Order
-  eventmodeler show aggregate "User Account" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show aggregate <name>');
-                        console.error('Run "eventmodeler show aggregate --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showAggregate(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                case 'scenario':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show scenario - Show detailed scenario information
-
-USAGE:
-  eventmodeler show scenario <name> [--format xml|json]
-
-ARGUMENTS:
-  <name>   Scenario name
-
-OUTPUT INCLUDES:
-  - Scenario name and description
-  - Parent slice
-  - Given events (with field values)
-  - When command or events (with field values)
-  - Then expectations (events, error, command, etc.)
-
-EXAMPLES:
-  eventmodeler show scenario "Happy path"
-  eventmodeler show scenario "Invalid input" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show scenario <name>');
-                        console.error('Run "eventmodeler show scenario --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.showScenario(modelId, target, format);
-                        console.log(result);
-                    }
-                    break;
-                default:
-                    console.error(`Unknown show target: ${subcommand}`);
-                    console.error('Valid targets: slice, event, command, chapter, information-completeness, aggregate-completeness, actor, readmodel, screen, processor, aggregate, scenario');
-                    console.error('Run "eventmodeler show --help" for more information.');
-                    process.exit(1);
-            }
-            break;
-        case 'search':
-            if (helpRequested) {
-                console.log(`
-eventmodeler search - Search for entities by name
-
-USAGE:
-  eventmodeler search <term> [--format xml|json]
-
-ARGUMENTS:
-  <term>   Search term (case-insensitive partial match)
-
-OPTIONS:
-  --format <format>   Output format: xml (default) or json
-
-SEARCHES ACROSS:
-  - Slices
-  - Events
-  - Commands
-  - Read Models
-  - Screens
-  - Processors
-  - Chapters
-  - Aggregates
-  - Actors
-
-EXAMPLES:
-  eventmodeler search order
-  eventmodeler search "payment" --format json
-`);
-                process.exit(0);
-            }
-            if (!subcommand) {
-                console.error('Usage: eventmodeler search <term>');
-                console.error('Run "eventmodeler search --help" for more information.');
-                process.exit(1);
-            }
-            {
-                const searchTerm = target ? `${subcommand} ${target}` : subcommand;
-                const response = await api.search(modelId, searchTerm);
-                if (format === 'json') {
-                    console.log(JSON.stringify(response, null, 2));
-                }
-                else {
-                    const xb = new XMLBuilder({ ignoreAttributes: false, attributeNamePrefix: '@_', suppressEmptyNode: true });
-                    const results = response.results.map(r => {
-                        const tag = r.type === 'readmodel' ? 'read-model' : r.type;
-                        const attrs = {};
-                        if (r.id)
-                            attrs['@_id'] = r.id;
-                        if (r.name)
-                            attrs['@_name'] = r.name;
-                        if (r.chapterId)
-                            attrs['@_chapter-id'] = r.chapterId;
-                        if (r.chapterName)
-                            attrs['@_chapter-name'] = r.chapterName;
-                        if (r.sliceId)
-                            attrs['@_slice-id'] = r.sliceId;
-                        if (r.sliceName)
-                            attrs['@_slice-name'] = r.sliceName;
-                        if (r.sliceStatus)
-                            attrs['@_slice-status'] = r.sliceStatus;
-                        if (r.parentChapterId)
-                            attrs['@_parent-chapter-id'] = r.parentChapterId;
-                        if (r.parentChapterName)
-                            attrs['@_parent-chapter-name'] = r.parentChapterName;
-                        return `  ${xb.build({ [tag]: attrs }).trim()}`;
-                    });
-                    const wrapper = xb.build({ 'search-results': { '@_query': searchTerm, '@_count': String(response.results.length) } });
-                    // Replace self-closing tag with children
-                    const open = wrapper.replace(/\/>$/, '>').trim();
-                    console.log([open, ...results, '</search-results>'].join('\n'));
-                }
-            }
-            break;
-        case 'mark': {
-            if (helpRequested) {
-                console.log(`
-eventmodeler mark - Mark a slice's status
-
-USAGE:
-  eventmodeler mark <slice-name> <status>
-
-ARGUMENTS:
-  <slice-name>   Slice name (can include spaces)
-  <status>       One of: created, in-progress, blocked, done
-
-STATUSES:
-  created      Initial state, not yet started
-  in-progress  Currently being worked on
-  blocked      Work paused due to dependency or issue
-  done         Completed
-
-EXAMPLES:
-  eventmodeler mark "Place Order" done
-  eventmodeler mark "Process Payment" in-progress
-  eventmodeler mark "Ship Order" blocked
-`);
-                process.exit(0);
-            }
-            // mark <slice-name> <status> - status is last arg, slice name is everything before
-            // Note: subcommand contains first part of slice name, remainingArgs has the rest
-            const validStatuses = ['created', 'in-progress', 'blocked', 'done'];
-            const allArgs = subcommand ? [subcommand, ...remainingArgs] : remainingArgs;
-            const lastArg = allArgs[allArgs.length - 1];
-            if (allArgs.length < 2 || !validStatuses.includes(lastArg)) {
-                console.error('Usage: eventmodeler mark <slice-name> <status>');
-                console.error('Valid statuses: created, in-progress, blocked, done');
-                console.error('Run "eventmodeler mark --help" for more information.');
-                process.exit(1);
-            }
-            const sliceName = allArgs.slice(0, -1).join(' ');
-            const status = lastArg;
-            await api.markSliceStatus(modelId, sliceName, status);
-            console.log(`Marked slice "${sliceName}" as ${status}`);
-            break;
-        }
-        case 'summary':
-            if (helpRequested) {
-                console.log(`
-eventmodeler summary - Show model summary statistics
-
-USAGE:
-  eventmodeler summary [--format xml|json]
-
-OPTIONS:
-  --format <format>   Output format: xml (default) or json
-
-OUTPUT:
-  Aggregate statistics including:
-  - Total counts (slices, events, commands, read models, screens, etc.)
-  - Slices by type (state-change, automation, state-view)
-  - Slices by status (created, in-progress, blocked, done)
-  - Chapter summary
-
-EXAMPLES:
-  eventmodeler summary
-  eventmodeler summary --format json
-`);
-                process.exit(0);
-            }
-            {
-                const summary = await api.getSummary(modelId);
-                if (format === 'json') {
-                    console.log(JSON.stringify(summary, null, 2));
-                }
-                else {
-                    const xb = new XMLBuilder({ ignoreAttributes: false, attributeNamePrefix: '@_', format: true, indentBy: '  ', suppressEmptyNode: true });
-                    console.log(xb.build({
-                        model: {
-                            '@_name': summary.modelName || '',
-                            slices: { '@_count': String(summary.slices.total) },
-                            commands: { '@_count': String(summary.commands) },
-                            events: { '@_count': String(summary.events) },
-                            'read-models': { '@_count': String(summary.readModels) },
-                            screens: { '@_count': String(summary.screens) },
-                            processors: { '@_count': String(summary.processors) },
-                            aggregates: { '@_count': String(summary.aggregates) },
-                            actors: { '@_count': String(summary.actors) },
-                            scenarios: { '@_count': String(summary.scenarios) },
-                            flows: { '@_count': String(summary.flows) },
-                        },
-                    }).trim());
-                }
-            }
-            break;
-        case 'export':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler export - Export the model
-
-USAGE:
-  eventmodeler export <format>
-
-FORMATS:
-  json   Export entire model as JSON
-
-Run "eventmodeler export json --help" for detailed help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'json':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler export json - Export entire model as JSON
-
-USAGE:
-  eventmodeler export json
-
-OUTPUT:
-  Complete event model as JSON to stdout, including:
-  - All entities (slices, events, commands, read models, screens, etc.)
-  - All flows and field mappings
-  - All scenarios
-  - Metadata (chapters, aggregates, actors)
-
-EXAMPLES:
-  eventmodeler export json
-  eventmodeler export json > model.json
-  eventmodeler export json | jq '.events'
-`);
-                        process.exit(0);
-                    }
-                    {
-                        const result = await api.exportJson(modelId);
-                        console.log(JSON.stringify(JSON.parse(result), null, 2));
-                    }
-                    break;
-                default:
-                    console.error(`Unknown export format: ${subcommand}`);
-                    console.error('Valid formats: json');
-                    console.error('Run "eventmodeler export --help" for more information.');
-                    process.exit(1);
-            }
-            break;
-        case 'add':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler add - Add entities to the model
-
-USAGE:
-  eventmodeler add <type> [options]
-
-TYPES:
-  scenario   Add Given-When-Then scenario to a slice
-  field      Add field to command, event, read model, screen, or processor
-
-Run "eventmodeler add <type> --help" for type-specific help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'scenario': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler add scenario - Add a scenario to a slice
-
-USAGE:
-  eventmodeler add scenario --slice <name> --json|--xml <data>
-
-OPTIONS:
-  --slice <name>   Target slice name (required)
-  --json <data>    Scenario in JSON format
-  --xml <data>     Scenario in XML format
-
-JSON FORMAT:
-  {
-    "name": "Scenario name",
-    "given": {                              // Optional: preconditions
-      "type": "events",
-      "events": ["EventName1", "EventName2"]
-    },
-    "when": {                               // Optional: trigger
-      "type": "command",
-      "command": "CommandName"
-    },
-    "then": {                               // Required: expected outcome
-      "type": "events",
-      "events": ["ExpectedEvent"]
-    }
-  }
-
-XML FORMAT:
-  <scenario name="Scenario name">
-    <given type="events">
-      <event>EventName1</event>
-    </given>
-    <when type="command">
-      <command>CommandName</command>
-    </when>
-    <then type="events">
-      <event>ExpectedEvent</event>
-    </then>
-  </scenario>
-
-EXAMPLES:
-  eventmodeler add scenario --slice "Place Order" --json '{"name": "Happy path", "then": {"type": "events", "events": ["OrderPlaced"]}}'
-
-  eventmodeler add scenario --slice "Place Order" --xml '<scenario name="Out of stock"><given type="events"><event>ProductOutOfStock</event></given><then type="events"><event>OrderRejected</event></then></scenario>'
-`);
-                        process.exit(0);
-                    }
-                    const sliceArg = getNamedArg(filteredArgs, '--slice');
-                    const jsonArg = getNamedArg(filteredArgs, '--json');
-                    const xmlArg = getNamedArg(filteredArgs, '--xml');
-                    const inputData = jsonArg ?? xmlArg;
-                    if (!sliceArg) {
-                        console.error('Error: --slice is required');
-                        console.error('Usage: eventmodeler add scenario --slice <name> --json|--xml <data>');
-                        console.error('Run "eventmodeler add scenario --help" for detailed format.');
-                        process.exit(1);
-                    }
-                    if (!inputData) {
-                        console.error('Error: --json or --xml is required');
-                        console.error('Usage: eventmodeler add scenario --slice <name> --json|--xml <data>');
-                        console.error('Run "eventmodeler add scenario --help" for detailed format.');
-                        process.exit(1);
-                    }
-                    {
-                        let parsedScenario;
-                        try {
-                            parsedScenario = parseScenarioInput(inputData);
-                        }
-                        catch (err) {
-                            console.error(`Error parsing scenario data: ${err.message}`);
-                            process.exit(1);
-                        }
-                        const scenario = {
-                            name: parsedScenario.name,
-                            description: parsedScenario.description,
-                            given: parsedScenario.given,
-                            when: parsedScenario.when
-                                ? {
-                                    command: parsedScenario.when.command
-                                        ? {
-                                            command: parsedScenario.when.command,
-                                            fieldValues: parsedScenario.when.commandFieldValues,
-                                        }
-                                        : undefined,
-                                    events: parsedScenario.when.events,
-                                }
-                                : undefined,
-                            then: {
-                                type: parsedScenario.then.type,
-                                events: parsedScenario.then.events,
-                                errorMessage: parsedScenario.then.errorMessage,
-                                errorType: parsedScenario.then.errorType,
-                                command: parsedScenario.then.command
-                                    ? {
-                                        command: parsedScenario.then.command,
-                                        fieldValues: parsedScenario.then.commandFieldValues,
-                                    }
-                                    : undefined,
-                                readModelAssertion: parsedScenario.then.readModel
-                                    ? {
-                                        readModel: parsedScenario.then.readModel,
-                                        givenEvents: parsedScenario.then.givenEvents,
-                                        expectedFieldValues: parsedScenario.then.expected,
-                                    }
-                                    : undefined,
-                            },
-                        };
-                        await api.createScenario(modelId, sliceArg, scenario);
-                        console.log(`Created scenario "${scenario.name}" in slice "${sliceArg}"`);
-                    }
-                    break;
-                }
-                case 'field': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler add field - Add a field to an entity
-
-USAGE:
-  eventmodeler add field <element-name> --json|--xml <data>
-
-OPTIONS:
-  <element-name>        Name of the command, event, read model, screen, or processor
-  --json <data>         Field definition in JSON format
-  --xml <data>          Field definition in XML format
-
-FIELD TYPES:
-  UUID, String, Int, Long, Double, Decimal, Boolean, Date, DateTime, Custom
-
-FIELD FLAGS (work on ALL fields including nested subfields):
-  isList       - Field contains multiple values (array)
-  isOptional   - Field may be null/missing
-  isGenerated  - Field is computed/synthesized, not mapped from source
-  isUserInput  - (Screen only) Field is entered by user
-
-JSON FORMAT:
-  Simple field:
-    {"name": "orderId", "type": "UUID"}
-
-  Field with flags:
-    {"name": "notes", "type": "String", "isOptional": true}
-    {"name": "tags", "type": "String", "isList": true}
-    {"name": "total", "type": "Decimal", "isGenerated": true}
-
-  Nested Custom field with subfields (ALL flags work on subfields):
-    {
-      "name": "lineItem",
-      "type": "Custom",
-      "subfields": [
-        {"name": "productId", "type": "UUID"},
-        {"name": "quantity", "type": "Int"},
-        {"name": "unitPrice", "type": "Decimal"},
-        {"name": "lineTotal", "type": "Decimal", "isGenerated": true}
-      ]
-    }
-
-  List of Custom with generated subfields:
-    {
-      "name": "items",
-      "type": "Custom",
-      "isList": true,
-      "subfields": [
-        {"name": "sku", "type": "String"},
-        {"name": "qty", "type": "Int"},
-        {"name": "calculatedPrice", "type": "Decimal", "isGenerated": true}
-      ]
-    }
-
-XML FORMAT:
-  Simple field:
-    <field name="orderId" type="UUID"/>
-
-  Field with flags:
-    <field name="notes" type="String" isOptional="true"/>
-    <field name="tags" type="String" isList="true"/>
-    <field name="total" type="Decimal" isGenerated="true"/>
-
-  Nested Custom field (ALL flags work on subfields):
-    <field name="lineItem" type="Custom">
-      <field name="productId" type="UUID"/>
-      <field name="quantity" type="Int"/>
-      <field name="unitPrice" type="Decimal"/>
-      <field name="lineTotal" type="Decimal" isGenerated="true"/>
-    </field>
-
-  List of Custom with flags on subfields:
-    <field name="items" type="Custom" isList="true">
-      <field name="sku" type="String"/>
-      <field name="qty" type="Int"/>
-      <field name="calculatedPrice" type="Decimal" isGenerated="true"/>
-      <field name="notes" type="String" isOptional="true"/>
-    </field>
-
-NOTES:
-  - Generated fields are excluded from completeness checks
-  - Custom type fields must have subfields defined
-  - Subfields support arbitrary nesting depth
-
-EXAMPLES:
-  eventmodeler add field OrderPlaced --json '{"name": "orderId", "type": "UUID"}'
-  eventmodeler add field OrderSummary --json '{"name": "totalWithTax", "type": "Decimal", "isGenerated": true}'
-  eventmodeler add field OrderPlaced --xml '<field name="item" type="Custom"><field name="price" type="Decimal"/><field name="tax" type="Decimal" isGenerated="true"/></field>'
-`);
-                        process.exit(0);
-                    }
-                    const jsonArg = getNamedArg(filteredArgs, '--json');
-                    const xmlArg = getNamedArg(filteredArgs, '--xml');
-                    const inputData = jsonArg ?? xmlArg;
-                    // Element name is the first positional arg after command+subcommand (not a flag or flag value)
-                    const elementName = remainingArgs.find((a, i) => !a.startsWith('-') && (i === 0 || !['--json', '--xml'].includes(remainingArgs[i - 1])));
-                    if (!elementName) {
-                        console.error('Error: Element name is required');
-                        console.error('Usage: eventmodeler add field <element-name> --json|--xml <data>');
-                        console.error('Run "eventmodeler add field --help" for detailed format documentation.');
-                        process.exit(1);
-                    }
-                    if (!inputData) {
-                        console.error('Error: --json or --xml is required');
-                        console.error('Usage: eventmodeler add field <element-name> --json|--xml <data>');
-                        console.error('Run "eventmodeler add field --help" for detailed format documentation.');
-                        process.exit(1);
-                    }
-                    {
-                        // Parse field data
-                        let field;
-                        const toApiFieldFromJson = (f) => ({
-                            name: f.name,
-                            fieldType: f.type ?? f.fieldType ?? 'String',
-                            isList: f.isList,
-                            isOptional: f.isOptional,
-                            isGenerated: f.isGenerated,
-                            isUserInput: f.isUserInput,
-                            subfields: f.subfields?.map(toApiFieldFromJson),
-                        });
-                        try {
-                            if (jsonArg) {
-                                const parsed = JSON.parse(inputData);
-                                field = toApiFieldFromJson(parsed);
-                            }
-                            else {
-                                const parser = await import('./lib/slice-utils.js');
-                                const parsed = parser.parseFieldsFromXml(inputData);
-                                if (parsed.length === 0) {
-                                    throw new Error('No <field> element found in XML');
-                                }
-                                const toApiField = (f) => ({
-                                    name: f.name,
-                                    fieldType: f.type,
-                                    isList: f.isList,
-                                    isOptional: f.isOptional,
-                                    isGenerated: f.isGenerated,
-                                    isUserInput: f.isUserInput,
-                                    subfields: f.subfields?.map(toApiField),
-                                });
-                                field = toApiField(parsed[0]);
-                            }
-                        }
-                        catch (err) {
-                            console.error(`Error parsing field data: ${err.message}`);
-                            process.exit(1);
-                        }
-                        await api.addField(modelId, elementName, field);
-                        console.log(`Added field "${field.name}" to "${elementName}"`);
-                    }
-                    break;
-                }
-                default:
-                    console.error(`Unknown add target: ${subcommand}`);
-                    console.error('Valid targets: scenario, field');
-                    process.exit(1);
-            }
-            break;
-        case 'remove':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler remove - Remove entities from the model
-
-USAGE:
-  eventmodeler remove <type> [options]
-
-TYPES:
-  scenario   Remove a scenario from a slice
-  field      Remove a field from an entity
-  flow       Remove a flow between elements
-
-Run "eventmodeler remove <type> --help" for type-specific help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'scenario': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler remove scenario - Remove a scenario from a slice
-
-USAGE:
-  eventmodeler remove scenario <name> [--slice <slice-name>]
-
-ARGUMENTS:
-  <name>   Scenario name to remove
-
-OPTIONS:
-  --slice <name>   Limit search to specific slice (optional)
-
-EXAMPLES:
-  eventmodeler remove scenario "Happy path"
-  eventmodeler remove scenario "Edge case" --slice "Place Order"
-`);
-                        process.exit(0);
-                    }
-                    const sliceArg = getNamedArg(filteredArgs, '--slice');
-                    // Filter out --slice and its value from remaining args to get scenario name
-                    const scenarioArgs = filteredArgs.slice(2).filter((arg, i, arr) => {
-                        if (arg === '--slice')
-                            return false;
-                        if (i > 0 && arr[i - 1] === '--slice')
-                            return false;
-                        return true;
-                    });
-                    const scenarioName = scenarioArgs.length > 0 ? scenarioArgs.join(' ') : undefined;
-                    if (!scenarioName) {
-                        console.error('Usage: eventmodeler remove scenario <name> [--slice <slice-name>]');
-                        console.error('Run "eventmodeler remove scenario --help" for more information.');
-                        process.exit(1);
-                    }
-                    await api.removeScenario(modelId, scenarioName, sliceArg);
-                    console.log(`Removed scenario "${scenarioName}"${sliceArg ? ` from slice "${sliceArg}"` : ''}`);
-                    break;
-                }
-                case 'field': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler remove field - Remove a field from an entity
-
-USAGE:
-  eventmodeler remove field <element-name> --field <field-name>
-
-OPTIONS:
-  <element-name>        Name of the command, event, read model, screen, or processor
-  --field <name>        Field name to remove (required)
-
-EXAMPLES:
-  eventmodeler remove field OrderPlaced --field orderId
-  eventmodeler remove field "Order Summary" --field notes
-`);
-                        process.exit(0);
-                    }
-                    const fieldArg = getNamedArg(filteredArgs, '--field');
-                    // Element name is the first positional arg after command+subcommand (not a flag or flag value)
-                    const elementName = remainingArgs.find((a, i) => !a.startsWith('-') && (i === 0 || !['--field'].includes(remainingArgs[i - 1])));
-                    if (!fieldArg) {
-                        console.error('Error: --field is required');
-                        console.error('Usage: eventmodeler remove field <element-name> --field <field-name>');
-                        console.error('Run "eventmodeler remove field --help" for more information.');
-                        process.exit(1);
-                    }
-                    if (!elementName) {
-                        console.error('Error: Element name is required');
-                        console.error('Usage: eventmodeler remove field <element-name> --field <field-name>');
-                        console.error('Run "eventmodeler remove field --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        await api.removeField(modelId, elementName, fieldArg);
-                        console.log(`Removed field "${fieldArg}" from "${elementName}"`);
-                    }
-                    break;
-                }
-                case 'flow': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler remove flow - Remove a flow between elements
-
-USAGE:
-  eventmodeler remove flow --from <source> --to <target>
-
-OPTIONS:
-  --from <name>   Source element name (required)
-  --to <name>     Target element name (required)
-
-EXAMPLES:
-  eventmodeler remove flow --from OrderPlaced --to OrderSummary
-  eventmodeler remove flow --from "Order Summary" --to "Order Dashboard Screen"
-`);
-                        process.exit(0);
-                    }
-                    const fromArg = getNamedArg(filteredArgs, '--from');
-                    const toArg = getNamedArg(filteredArgs, '--to');
-                    if (!fromArg || !toArg) {
-                        console.error('Error: --from and --to are required');
-                        console.error('Usage: eventmodeler remove flow --from <source> --to <target>');
-                        console.error('Run "eventmodeler remove flow --help" for more information.');
-                        process.exit(1);
-                    }
-                    await api.removeFlow(modelId, fromArg, toArg);
-                    console.log(`Removed flow from "${fromArg}" to "${toArg}"`);
-                    break;
-                }
-                default:
-                    console.error(`Unknown remove target: ${subcommand}`);
-                    console.error('Valid targets: scenario, field, flow');
-                    console.error('Run "eventmodeler remove --help" for more information.');
-                    process.exit(1);
-            }
-            break;
-        case 'map':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler map - Set field mappings
-
-USAGE:
-  eventmodeler map <type> [options]
-
-TYPES:
-  fields   Set field mappings on a flow
-
-Run "eventmodeler map fields --help" for detailed help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'fields': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler map fields - Set field mappings on a flow
-
-USAGE:
-  eventmodeler map fields --flow <source→target> --json|--xml <mappings>
-
-OPTIONS:
-  --flow <spec>   Flow as "SourceName→TargetName" (use → or ->)
-  --json <data>   Mappings in JSON format
-  --xml <data>    Mappings in XML format
-
-JSON FORMAT:
-  [
-    {"from": "sourceField", "to": "targetField"},
-    {"from": "amount", "to": "orderTotal"}
-  ]
-
-XML FORMAT:
-  <mappings>
-    <mapping from="sourceField" to="targetField"/>
-    <mapping from="amount" to="orderTotal"/>
-  </mappings>
-
-NOTES:
-  - Mappings define how fields flow from source to target
-  - Fields marked as isGenerated=true don't need mappings
-  - Use "show information-completeness <name>" to check mapping status
-
-EXAMPLES:
-  eventmodeler map fields --flow "OrderPlaced→OrderSummary" --json '[{"from": "total", "to": "totalAmount"}]'
-
-  eventmodeler map fields --flow "OrderPlaced->OrderSummary" --xml '<mappings><mapping from="total" to="totalAmount"/></mappings>'
-`);
-                        process.exit(0);
-                    }
-                    const flowArg = getNamedArg(filteredArgs, '--flow');
-                    const jsonArg = getNamedArg(filteredArgs, '--json');
-                    const xmlArg = getNamedArg(filteredArgs, '--xml');
-                    const inputData = jsonArg ?? xmlArg;
-                    if (!flowArg) {
-                        console.error('Error: --flow is required');
-                        console.error('Usage: eventmodeler map fields --flow <source→target> --json|--xml <mappings>');
-                        console.error('Run "eventmodeler map fields --help" for detailed format.');
-                        process.exit(1);
-                    }
-                    if (!inputData) {
-                        console.error('Error: --json or --xml is required');
-                        console.error('Usage: eventmodeler map fields --flow <source→target> --json|--xml <mappings>');
-                        console.error('Run "eventmodeler map fields --help" for detailed format.');
-                        process.exit(1);
-                    }
-                    {
-                        // Parse flow argument to extract source and target names
-                        const flowParts = flowArg.split(/→|->/).map(s => s.trim());
-                        if (flowParts.length !== 2) {
-                            console.error('Error: --flow must be in format "SourceName→TargetName" or "SourceName->TargetName"');
-                            process.exit(1);
-                        }
-                        const [sourceName, targetName] = flowParts;
-                        // Parse mappings from JSON or XML
-                        let mappings;
-                        try {
-                            if (jsonArg) {
-                                mappings = JSON.parse(inputData);
-                            }
-                            else {
-                                const xp = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_', isArray: (name) => name === 'mapping' });
-                                const parsed = xp.parse(inputData);
-                                const root = parsed['mappings'];
-                                const nodes = root ? (Array.isArray(root['mapping']) ? root['mapping'] : root['mapping'] ? [root['mapping']] : []) : [];
-                                mappings = nodes.map(m => ({
-                                    from: m['@_from'] ?? '',
-                                    to: m['@_to'] ?? '',
-                                }));
-                            }
-                        }
-                        catch (err) {
-                            console.error(`Error parsing mappings: ${err.message}`);
-                            process.exit(1);
-                        }
-                        await api.mapFields(modelId, sourceName, targetName, mappings);
-                        console.log(`Mapped ${mappings.length} field(s) from "${sourceName}" to "${targetName}"`);
-                    }
-                    break;
-                }
-                default:
-                    console.error(`Unknown map target: ${subcommand}`);
-                    console.error('Valid targets: fields');
-                    console.error('Run "eventmodeler map --help" for more information.');
-                    process.exit(1);
-            }
-            break;
-        case 'update':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler update - Update entities in the model
-
-USAGE:
-  eventmodeler update <type> [options]
-
-TYPES:
-  field   Update field properties
-
-Run "eventmodeler update field --help" for detailed help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'field': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler update field - Update field properties
-
-USAGE:
-  eventmodeler update field <element-name> --field <field-name> [updates]
-
-OPTIONS:
-  <element-name>           Name of the command, event, read model, screen, or processor
-
-REQUIRED:
-  --field <name>           Field to update (use dot-notation for nested subfields: "parent.child")
-
-UPDATE OPTIONS (at least one required):
-  --optional true|false    Set isOptional flag
-  --generated true|false   Set isGenerated flag
-  --user-input true|false  Set isUserInput flag
-  --type <type>            Change field type
-
-FIELD FLAGS EXPLAINED:
-  isOptional    Field may be null/missing
-  isGenerated   Field is computed, excluded from completeness checks
-  isUserInput   (Screen only) Field entered by user vs displayed
-
-EXAMPLES:
-  # Mark field as optional
-  eventmodeler update field OrderSummary --field notes --optional true
-
-  # Mark field as generated (computed value, no mapping needed)
-  eventmodeler update field OrderSummary --field totalWithTax --generated true
-
-  # Mark screen field as user input
-  eventmodeler update field "Order Form" --field quantity --user-input true
-
-  # Change field type
-  eventmodeler update field OrderPlaced --field amount --type Decimal
-
-  # Update a nested subfield using dot-notation
-  eventmodeler update field OrderPlaced --field "shippingAddress.zipCode" --optional true
-`);
-                        process.exit(0);
-                    }
-                    const fieldArg = getNamedArg(filteredArgs, '--field');
-                    const optionalArg = getNamedArg(filteredArgs, '--optional');
-                    const generatedArg = getNamedArg(filteredArgs, '--generated');
-                    const userInputArg = getNamedArg(filteredArgs, '--user-input');
-                    const typeArg = getNamedArg(filteredArgs, '--type');
-                    // Element name is the first positional arg after command+subcommand (not a flag or flag value)
-                    const flagsWithValues = ['--field', '--optional', '--generated', '--user-input', '--type'];
-                    const elementName = remainingArgs.find((a, i) => !a.startsWith('-') && (i === 0 || !flagsWithValues.includes(remainingArgs[i - 1])));
-                    if (!fieldArg) {
-                        console.error('Error: --field is required');
-                        console.error('Usage: eventmodeler update field <element-name> --field <field-name> [--optional true|false] [--generated true|false] [--user-input true|false]');
-                        console.error('Run "eventmodeler update field --help" for detailed options.');
-                        process.exit(1);
-                    }
-                    if (!elementName) {
-                        console.error('Error: Element name is required');
-                        console.error('Usage: eventmodeler update field <element-name> --field <field-name> [--optional true|false] [--generated true|false] [--user-input true|false]');
-                        console.error('Run "eventmodeler update field --help" for detailed options.');
-                        process.exit(1);
-                    }
-                    const updates = {};
-                    if (optionalArg !== undefined) {
-                        updates.optional = optionalArg === 'true';
-                    }
-                    if (generatedArg !== undefined) {
-                        updates.generated = generatedArg === 'true';
-                    }
-                    if (userInputArg !== undefined) {
-                        updates.userInput = userInputArg === 'true';
-                    }
-                    if (typeArg !== undefined) {
-                        updates.type = typeArg;
-                    }
-                    if (Object.keys(updates).length === 0) {
-                        console.error('Error: Must specify at least one update (--optional, --generated, --user-input, or --type)');
-                        console.error('Run "eventmodeler update field --help" for available options.');
-                        process.exit(1);
-                    }
-                    {
-                        // Convert updates to API format
-                        const fieldUpdates = {};
-                        if (updates.optional !== undefined)
-                            fieldUpdates.isOptional = updates.optional;
-                        if (updates.generated !== undefined)
-                            fieldUpdates.isGenerated = updates.generated;
-                        if (updates.userInput !== undefined)
-                            fieldUpdates.isUserInput = updates.userInput;
-                        if (updates.type !== undefined)
-                            fieldUpdates.fieldType = updates.type;
-                        await api.updateField(modelId, elementName, fieldArg, fieldUpdates);
-                        console.log(`Updated field "${fieldArg}" on "${elementName}"`);
-                    }
-                    break;
-                }
-                default:
-                    console.error(`Unknown update target: ${subcommand}`);
-                    console.error('Valid targets: field');
-                    console.error('Run "eventmodeler update --help" for more information.');
-                    process.exit(1);
-            }
-            break;
-        case 'create':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler create - Create new slices and flows
-
-USAGE:
-  eventmodeler create <type> [options]
-
-TYPES:
-  state-change-slice   Create Screen → Command → Event slice
-  automation-slice     Create ReadModel → Processor → Command → Event slice
-  state-view-slice     Create ReadModel-only slice
-  flow                 Create flow between elements
-
-Run "eventmodeler create <type> --help" for type-specific help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'state-change-slice': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler create state-change-slice - Create a state-change slice
-
-A state-change slice represents user action: Screen → Command → Event
-
-USAGE:
-  eventmodeler create state-change-slice --xml <data>
-
-XML FORMAT:
-  <state-change-slice name="Slice Name" [after="Slice Name"] [before="Slice Name"]>
-    <screen name="Screen Name" actor="Actor Name">
-      <field name="fieldName" type="Type" [flags]/>
-    </screen>
-    <command name="CommandName">
-      <field name="fieldName" type="Type" [flags]/>
-    </command>
-    <event name="EventName">
-      <field name="fieldName" type="Type" [flags]/>
-    </event>
-  </state-change-slice>
-
-POSITIONING (IMPORTANT):
-  after="Slice Name"   Place this slice immediately after the named slice
-  before="Slice Name"  Place this slice immediately before the named slice
-                       (shifts existing slices to the right)
-
-  If neither is specified, the slice is placed at the rightmost position.
-  Use "eventmodeler list slices" to see existing slice names for positioning.
-
-FIELD TYPES:
-  UUID, String, Int, Long, Double, Decimal, Boolean, Date, DateTime, Custom
-
-FIELD FLAGS (work on ALL fields and nested subfields):
-  isList="true"       Array/list of values
-  isOptional="true"   Nullable field
-  isGenerated="true"  Computed field (excluded from mapping completeness)
-  isUserInput="true"  User-entered field (screen fields only)
-
-NESTED CUSTOM FIELDS:
-  <field name="address" type="Custom">
-    <field name="street" type="String"/>
-    <field name="city" type="String"/>
-    <field name="formattedFull" type="String" isGenerated="true"/>
-  </field>
-
-EXAMPLES:
-  # Create slice at the end (default)
-  eventmodeler create state-change-slice --xml '
-    <state-change-slice name="Place Order">
-      <screen name="Order Form" actor="Customer">
-        <field name="productId" type="UUID" isUserInput="true"/>
-      </screen>
-      <command name="PlaceOrder">
-        <field name="productId" type="UUID"/>
-      </command>
-      <event name="OrderPlaced">
-        <field name="orderId" type="UUID"/>
-        <field name="productId" type="UUID"/>
-      </event>
-    </state-change-slice>'
-
-  # Create slice after an existing slice
-  eventmodeler create state-change-slice --xml '
-    <state-change-slice name="Confirm Order" after="Place Order">
-      ...
-    </state-change-slice>'
-
-  # Create slice before an existing slice (shifts others right)
-  eventmodeler create state-change-slice --xml '
-    <state-change-slice name="Review Cart" before="Place Order">
-      ...
-    </state-change-slice>'
-`);
-                        process.exit(0);
-                    }
-                    const xmlArg = getNamedArg(filteredArgs, '--xml');
-                    if (!xmlArg) {
-                        console.error('Error: --xml is required');
-                        console.error('Usage: eventmodeler create state-change-slice --xml \'<state-change-slice>...</state-change-slice>\'');
-                        console.error('Run "eventmodeler create state-change-slice --help" for detailed format.');
-                        process.exit(1);
-                    }
-                    {
-                        // Parse XML input to extract structured data
-                        const parser = await import('./lib/slice-utils.js');
-                        const parsed = parser.parseStateChangeSliceXml(xmlArg);
-                        const sliceInput = {
-                            sliceName: parsed.sliceName,
-                            after: parsed.after,
-                            before: parsed.before,
-                            screen: { name: parsed.screen.name, fields: toCompoundFields(parsed.screen.fields) },
-                            command: { name: parsed.command.name, fields: toCompoundFields(parsed.command.fields) },
-                            event: { name: parsed.event.name, fields: toCompoundFields(parsed.event.fields) },
-                        };
-                        const result = await api.createStateChangeSlice(modelId, sliceInput);
-                        console.log(`Created state-change slice "${parsed.sliceName}"`);
-                        console.log(`  Screen: ${parsed.screen.name} (${parsed.screen.fields.length} fields)`);
-                        console.log(`  Command: ${parsed.command.name} (${parsed.command.fields.length} fields)`);
-                        console.log(`  Event: ${parsed.event.name} (${parsed.event.fields.length} fields)`);
-                        console.log(`  Screen -> Command mappings: ${result.screenToCommandMappings}`);
-                        console.log(`  Command -> Event mappings: ${result.commandToEventMappings}`);
-                    }
-                    break;
-                }
-                case 'automation-slice': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler create automation-slice - Create an automation slice
-
-An automation slice represents system automation: ReadModel → Processor → Command → Event
-
-USAGE:
-  eventmodeler create automation-slice --xml <data>
-
-XML FORMAT:
-  <automation-slice name="Slice Name" [after="Slice Name"] [before="Slice Name"]>
-    <read-model name="ReadModelName">
-      <field name="fieldName" type="Type" [flags]/>
-    </read-model>
-    <processor name="ProcessorName">
-      <field name="fieldName" type="Type" [flags]/>
-    </processor>
-    <command name="CommandName">
-      <field name="fieldName" type="Type" [flags]/>
-    </command>
-    <event name="EventName">
-      <field name="fieldName" type="Type" [flags]/>
-    </event>
-  </automation-slice>
-
-POSITIONING (IMPORTANT):
-  after="Slice Name"   Place this slice immediately after the named slice
-  before="Slice Name"  Place this slice immediately before the named slice
-                       (shifts existing slices to the right)
-
-  If neither is specified, the slice is placed at the rightmost position.
-  Use "eventmodeler list slices" to see existing slice names for positioning.
-
-FIELD TYPES:
-  UUID, String, Int, Long, Double, Decimal, Boolean, Date, DateTime, Custom
-
-FIELD FLAGS (work on ALL fields and nested subfields):
-  isList="true"       Array/list of values
-  isOptional="true"   Nullable field
-  isGenerated="true"  Computed field (excluded from mapping completeness)
-
-EXAMPLES:
-  # Create automation slice after "Place Order" slice
-  eventmodeler create automation-slice --xml '
-    <automation-slice name="Auto-ship Order" after="Place Order">
-      <read-model name="OrderReadyForShipment">
-        <field name="orderId" type="UUID"/>
-        <field name="shippingAddress" type="String"/>
-      </read-model>
-      <processor name="ShipmentScheduler">
-        <field name="orderId" type="UUID"/>
-      </processor>
-      <command name="ScheduleShipment">
-        <field name="orderId" type="UUID"/>
-      </command>
-      <event name="ShipmentScheduled">
-        <field name="shipmentId" type="UUID" isGenerated="true"/>
-        <field name="orderId" type="UUID"/>
-        <field name="scheduledAt" type="DateTime" isGenerated="true"/>
-      </event>
-    </automation-slice>'
-
-  # Create automation slice before another slice
-  eventmodeler create automation-slice --xml '
-    <automation-slice name="Validate Inventory" before="Auto-ship Order">
-      ...
-    </automation-slice>'
-`);
-                        process.exit(0);
-                    }
-                    const xmlArg = getNamedArg(filteredArgs, '--xml');
-                    if (!xmlArg) {
-                        console.error('Error: --xml is required');
-                        console.error('Usage: eventmodeler create automation-slice --xml \'<automation-slice>...</automation-slice>\'');
-                        console.error('Run "eventmodeler create automation-slice --help" for detailed format.');
-                        process.exit(1);
-                    }
-                    {
-                        // Parse XML input to extract structured data
-                        const parser = await import('./lib/slice-utils.js');
-                        const parsed = parser.parseAutomationSliceXml(xmlArg);
-                        const sliceInput = {
-                            sliceName: parsed.sliceName,
-                            after: parsed.after,
-                            before: parsed.before,
-                            readModel: { name: parsed.readModel.name, fields: toCompoundFields(parsed.readModel.fields) },
-                            processor: { name: parsed.processor.name },
-                            command: { name: parsed.command.name, fields: toCompoundFields(parsed.command.fields) },
-                            event: { name: parsed.event.name, fields: toCompoundFields(parsed.event.fields) },
-                        };
-                        const result = await api.createAutomationSlice(modelId, sliceInput);
-                        console.log(`Created automation slice "${parsed.sliceName}"`);
-                        console.log(`  ReadModel: ${parsed.readModel.name} (${parsed.readModel.fields.length} fields)`);
-                        console.log(`  Processor: ${parsed.processor.name}`);
-                        console.log(`  Command: ${parsed.command.name} (${parsed.command.fields.length} fields)`);
-                        console.log(`  Event: ${parsed.event.name} (${parsed.event.fields.length} fields)`);
-                        console.log(`  ReadModel -> Command mappings: ${result.readModelToCommandMappings}`);
-                        console.log(`  Command -> Event mappings: ${result.commandToEventMappings}`);
-                    }
-                    break;
-                }
-                case 'state-view-slice': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler create state-view-slice - Create a state-view slice
-
-A state-view slice represents a read model for displaying data.
-
-USAGE:
-  eventmodeler create state-view-slice --xml <data>
-
-XML FORMAT:
-  <state-view-slice name="Slice Name" [after="Slice Name"] [before="Slice Name"]>
-    <read-model name="ReadModelName">
-      <field name="fieldName" type="Type" [flags]/>
-    </read-model>
-  </state-view-slice>
-
-POSITIONING (IMPORTANT):
-  after="Slice Name"   Place this slice immediately after the named slice
-  before="Slice Name"  Place this slice immediately before the named slice
-                       (shifts existing slices to the right)
-
-  If neither is specified, the slice is placed at the rightmost position.
-  Use "eventmodeler list slices" to see existing slice names for positioning.
-
-FIELD TYPES:
-  UUID, String, Int, Long, Double, Decimal, Boolean, Date, DateTime, Custom
-
-FIELD FLAGS (work on ALL fields and nested subfields):
-  isList="true"       Array/list of values
-  isOptional="true"   Nullable field
-  isGenerated="true"  Computed/aggregated field (common for dashboards)
-
-EXAMPLES:
-  # Create state-view slice after "Place Order" slice
-  eventmodeler create state-view-slice --xml '
-    <state-view-slice name="Order Dashboard" after="Place Order">
-      <read-model name="OrderDashboard">
-        <field name="totalOrders" type="Int" isGenerated="true"/>
-        <field name="totalRevenue" type="Decimal" isGenerated="true"/>
-        <field name="averageOrderValue" type="Decimal" isGenerated="true"/>
-        <field name="recentOrders" type="Custom" isList="true">
-          <field name="orderId" type="UUID"/>
-          <field name="total" type="Decimal"/>
-          <field name="status" type="String"/>
-        </field>
-      </read-model>
-    </state-view-slice>'
-
-  # Create state-view slice before another slice
-  eventmodeler create state-view-slice --xml '
-    <state-view-slice name="Customer Summary" before="Order Dashboard">
-      ...
-    </state-view-slice>'
-`);
-                        process.exit(0);
-                    }
-                    const xmlArg = getNamedArg(filteredArgs, '--xml');
-                    if (!xmlArg) {
-                        console.error('Error: --xml is required');
-                        console.error('Usage: eventmodeler create state-view-slice --xml \'<state-view-slice>...</state-view-slice>\'');
-                        console.error('Run "eventmodeler create state-view-slice --help" for detailed format.');
-                        process.exit(1);
-                    }
-                    {
-                        // Parse XML input to extract structured data
-                        const parser = await import('./lib/slice-utils.js');
-                        const parsed = parser.parseStateViewSliceXml(xmlArg);
-                        const sliceInput = {
-                            sliceName: parsed.sliceName,
-                            after: parsed.after,
-                            before: parsed.before,
-                            readModel: { name: parsed.readModel.name, fields: toCompoundFields(parsed.readModel.fields) },
-                        };
-                        const result = await api.createStateViewSlice(modelId, sliceInput);
-                        console.log(`Created state-view slice "${parsed.sliceName}"`);
-                        console.log(`  ReadModel: ${parsed.readModel.name} (${parsed.readModel.fields.length} fields)`);
-                    }
-                    break;
-                }
-                case 'flow': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler create flow - Create a flow between elements
-
-USAGE:
-  eventmodeler create flow --from <source> --to <target>
-
-OPTIONS:
-  --from <name>   Source element name (required)
-  --to <name>     Target element name (required)
-
-VALID FLOW TYPES:
-  Event → ReadModel       Event data projects into read model
-  ReadModel → Screen      Read model provides data to UI
-  ReadModel → Processor   Read model triggers automation
-
-EXAMPLES:
-  eventmodeler create flow --from OrderPlaced --to OrderSummary
-  eventmodeler create flow --from "Order Summary" --to "Order Dashboard Screen"
-  eventmodeler create flow --from OrderReadyForShipment --to ShipmentProcessor
-`);
-                        process.exit(0);
-                    }
-                    const fromArg = getNamedArg(filteredArgs, '--from');
-                    const toArg = getNamedArg(filteredArgs, '--to');
-                    if (!fromArg || !toArg) {
-                        console.error('Error: --from and --to are required');
-                        console.error('Usage: eventmodeler create flow --from <source> --to <target>');
-                        console.error('Run "eventmodeler create flow --help" for more information.');
-                        process.exit(1);
-                    }
-                    await api.createFlow(modelId, fromArg, toArg);
-                    console.log(`Created flow from "${fromArg}" to "${toArg}"`);
-                    break;
-                }
-                default:
-                    console.error(`Unknown create target: ${subcommand}`);
-                    console.error('Valid targets: state-change-slice, automation-slice, state-view-slice, flow');
-                    console.error('Run "eventmodeler create --help" for more information.');
-                    process.exit(1);
-            }
-            break;
-        case 'codegen':
-            if (helpRequested && !subcommand) {
-                console.log(`
-eventmodeler codegen - Generate code-ready output
-
-USAGE:
-  eventmodeler codegen <type> [options]
-
-TYPES:
-  slice           Generate comprehensive JSON for a slice
-  events          Generate deduplicated events for a chapter or entire model
-
-Run "eventmodeler codegen <type> --help" for detailed help.
-`);
-                process.exit(0);
-            }
-            switch (subcommand) {
-                case 'slice': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler codegen slice - Generate code-ready JSON for a slice
-
-USAGE:
-  eventmodeler codegen slice <name>
-
-ARGUMENTS:
-  <name>   Slice name
-
-OUTPUT:
-  Comprehensive JSON including:
-  - Slice metadata (name, type, chapter, aggregate)
-  - All components with full field definitions
-    - Fields include: name, type, isList, isOptional, isGenerated
-    - Nested subfields for Custom types (all flags preserved)
-  - Field mappings between components
-  - Scenarios (Given-When-Then specifications)
-  - Dependencies (inbound/outbound flows)
-
-This output is designed for code generation tools and includes
-all information needed to generate implementation code.
-
-EXAMPLES:
-  eventmodeler codegen slice "Place Order"
-  eventmodeler codegen slice PlaceOrder > slice.json
-`);
-                        process.exit(0);
-                    }
-                    const sliceName = target;
-                    if (!sliceName) {
-                        console.error('Error: slice name is required');
-                        console.error('Usage: eventmodeler codegen slice <name>');
-                        console.error('Run "eventmodeler codegen slice --help" for more information.');
-                        process.exit(1);
-                    }
-                    {
-                        const result = await api.codegenSlice(modelId, sliceName);
-                        console.log(JSON.stringify(JSON.parse(result), null, 2));
-                    }
-                    break;
-                }
-                case 'events': {
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler codegen events - Generate deduplicated events for scaffolding
-
-USAGE:
-  eventmodeler codegen events [--chapter <chapter-name>]
-  eventmodeler codegen events <chapter-name>
-
-ARGUMENTS:
-  <chapter-name>   Optional chapter name (if omitted, all model events are returned)
-
-OUTPUT:
-  JSON payload including:
-  - chapter hierarchy metadata (when chapter-scoped)
-  - all relevant slices
-  - deduplicated events across those slices
-  - sourceSlices per event (where each event appears)
-
-This is designed for event scaffolding flows (e.g. events.kt generation).
-
-EXAMPLES:
-  eventmodeler codegen events --chapter "Register Products"
-  eventmodeler codegen events "Register Products"
-  eventmodeler codegen events > model-events.json
-`);
-                        process.exit(0);
-                    }
-                    const chapterName = chapterArg ?? target;
-                    {
-                        const output = await api.codegenEvents(modelId, chapterName);
-                        console.log(JSON.stringify(output, null, 2));
-                    }
-                    break;
-                }
-                default:
-                    console.error(`Unknown codegen target: ${subcommand}`);
-                    console.error('Valid targets: slice, events');
-                    console.error('Run "eventmodeler codegen --help" for more information.');
-                    process.exit(1);
-            }
-            break;
-        default:
-            console.error(`Unknown command: ${command}`);
-            printHelp();
-            process.exit(1);
-    }
-}
-main().catch((err) => {
+import { setProgram } from './lib/globals';
+import { registerAuthCommands } from './commands/auth';
+import { registerInitCommands } from './commands/init';
+import { registerGuideCommands } from './commands/guide';
+import { registerListCommands } from './commands/list';
+import { registerShowCommands } from './commands/show';
+import { registerSearchCommands } from './commands/search';
+import { registerSummaryCommands } from './commands/summary';
+import { registerMarkCommands } from './commands/mark';
+import { registerAddCommands } from './commands/add';
+import { registerRemoveCommands } from './commands/remove';
+import { registerRenameCommands } from './commands/rename';
+import { registerMoveCommands } from './commands/move';
+import { registerCreateCommands } from './commands/create';
+import { registerUpdateCommands } from './commands/update';
+import { registerMapCommands } from './commands/map';
+import { registerDesignCommands } from './commands/design';
+import { registerSetCommands } from './commands/set';
+import { registerLoopCommands } from './commands/loop';
+const program = new Command()
+    .name('eventmodeler')
+    .version(packageJson.version)
+    .description('CLI tool for interacting with Event Model files')
+    .option('--id <uuid>', 'Skip name resolution, use UUID directly');
+setProgram(program);
+// Register all commands
+registerAuthCommands(program);
+registerInitCommands(program);
+registerGuideCommands(program);
+registerListCommands(program);
+registerShowCommands(program);
+registerSearchCommands(program);
+registerSummaryCommands(program);
+registerMarkCommands(program);
+registerAddCommands(program);
+registerRemoveCommands(program);
+registerRenameCommands(program);
+registerMoveCommands(program);
+registerCreateCommands(program);
+registerUpdateCommands(program);
+registerMapCommands(program);
+registerDesignCommands(program);
+registerSetCommands(program);
+registerLoopCommands(program);
+program.parseAsync(process.argv).catch((err) => {
     console.error('Error:', err.message);
     process.exit(1);
 });