eventmodeler 0.4.4 → 0.4.5

package/dist/index.js

@@ -2,61 +2,20 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { findEventModelFile, loadModel } from './lib/file-loader.js';
 import { getDefaultFormat } from './lib/config.js';
 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;
-// Import slices
-import { listSlices } from './slices/list-slices/index.js';
-import { listEvents } from './slices/list-events/index.js';
-import { listCommands } from './slices/list-commands/index.js';
-import { showSlice } from './slices/show-slice/index.js';
-import { showEvent } from './slices/show-event/index.js';
-import { showCommand } from './slices/show-command/index.js';
-import { markSliceStatus } from './slices/mark-slice-status/index.js';
-import { showModelSummary } from './slices/show-model-summary/index.js';
-import { exportEventmodelToJson } from './slices/export-eventmodel-to-json/index.js';
+// Utilities
 import { openApp } from './slices/open-app/index.js';
-import { search } from './slices/search/index.js';
-import { listChapters } from './slices/list-chapters/index.js';
-import { showChapter } from './slices/show-chapter/index.js';
-import { addScenario, parseScenarioInput } from './slices/add-scenario/index.js';
-import { addField } from './slices/add-field/index.js';
-import { removeScenario } from './slices/remove-scenario/index.js';
-import { removeField } from './slices/remove-field/index.js';
-import { showCompleteness, showModelCompleteness } from './slices/show-completeness/index.js';
-import { mapFields } from './slices/map-fields/index.js';
-import { updateField } from './slices/update-field/index.js';
-import { showAggregateCompleteness, listAggregates } from './slices/show-aggregate-completeness/index.js';
-import { showActor, listActors } from './slices/show-actor/index.js';
-import { listReadModels } from './slices/list-readmodels/index.js';
-import { listScreens } from './slices/list-screens/index.js';
-import { listProcessors } from './slices/list-processors/index.js';
-import { listScenarios } from './slices/list-scenarios/index.js';
-import { showReadModel } from './slices/show-readmodel/index.js';
-import { showScreen } from './slices/show-screen/index.js';
-import { showProcessor } from './slices/show-processor/index.js';
-import { showAggregate } from './slices/show-aggregate/index.js';
-import { showScenario } from './slices/show-scenario/index.js';
-import { createStateChangeSlice } from './slices/create-state-change-slice/index.js';
-import { createAutomationSlice } from './slices/create-automation-slice/index.js';
-import { createStateViewSlice } from './slices/create-state-view-slice/index.js';
-import { createFlow } from './slices/create-flow/index.js';
-import { codegenSlice } from './slices/codegen-slice/index.js';
-import { codegenEvents } from './slices/codegen-chapter-events/index.js';
-import { diff } from './slices/diff/index.js';
-import { merge } from './slices/merge/index.js';
-import { gitSetup, gitStatus } from './slices/git/index.js';
-import { importModel } from './slices/import/index.js';
-// Auth and cloud commands
+import { parseScenarioInput } from './slices/add-scenario/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';
-// Cloud slices
-import * as cloudSlices from './cloud/slices/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) {
@@ -95,7 +54,7 @@ AUTHENTICATION:
   whoami                           Show authentication status
 
 PROJECT SETUP:
-  init                             Initialize project (link to cloud or local model)
+  init                             Initialize project (link to a model)
 
 COMMANDS:
   list slices [--chapter <name>] List all slices (optionally filtered by chapter)
@@ -115,8 +74,9 @@ COMMANDS:
   show command <name>            Show detailed XML view of a command
   show chapter <name>            Show chapter with slices, flow graph, and
                                  external dependencies
-  show completeness <name>       Show field mapping completeness for any element
-  show model-completeness        Show completeness of all flows in the model
+  show 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
@@ -133,18 +93,18 @@ COMMANDS:
 
   add scenario --slice <name> --json|--xml <data>
                                  Add a scenario to a slice
-  add field --command|--event|--read-model|--screen|--processor <name> --json|--xml <data>
+  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 --command|--event|--read-model|--screen|--processor <name> --field <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 --command|--event|--read-model|--screen|--processor <name> --field <name> [--optional true|false] [--generated true|false] [--user-input true|false (screen only)]
+  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>
@@ -164,27 +124,7 @@ COMMANDS:
 
   export json                    Export entire model as JSON
 
-IMPORT/EXPORT:
-  import <file> [--name <name>]  Import .eventmodel file to cloud (creates new model)
-
-GIT INTEGRATION:
-  git setup                      Configure git to use semantic diff/merge for .eventmodel files
-  git setup --global             Configure globally (for all repos)
-  git status                     Show git integration status
-
-  diff <file1> <file2>           Compare two event model files semantically
-  diff <file> [--ref <gitref>]   Compare working copy against git ref (default: HEAD)
-  diff ... --format text         Human-readable output (default for git)
-  diff ... --format xml|json     Structured output
-
-  merge --base <file> --ours <file> --theirs <file> --output <file>
-                                 Three-way merge of event model files
-  merge ... --strategy ours|theirs
-                                 Auto-resolve conflicts with given strategy
-  merge ... --dry-run            Show conflicts without writing output
-
 OPTIONS:
-  -f, --file <path>              Path to .eventmodel file (default: auto-detect)
   --format <xml|json>            Output format (default: xml, or from config)
   -h, --help                     Show this help message
   -v, --version                  Show version number
@@ -199,25 +139,21 @@ EXAMPLES:
   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 --event "OrderPlaced" --json '{"name": "orderId", "type": "UUID"}'
-  eventmodeler remove field --event "OrderPlaced" --field "orderId"
-  eventmodeler show completeness "OrderSummary"
-  eventmodeler show model-completeness
+  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 --read-model "OrderSummary" --field "notes" --optional true
+  eventmodeler update field "OrderSummary" --field "notes" --optional true
 `);
 }
 async function main() {
-    let fileArg = null;
     let formatArg = null;
     let chapterArg = null;
     const filteredArgs = [];
     let helpRequested = false;
     for (let i = 0; i < args.length; i++) {
-        if (args[i] === '-f' || args[i] === '--file') {
-            fileArg = args[++i];
-        }
-        else if (args[i] === '--format') {
+        if (args[i] === '--format') {
             formatArg = args[++i];
         }
         else if (args[i] === '--chapter') {
@@ -254,144 +190,6 @@ async function main() {
         openApp();
         return;
     }
-    // Handle diff and merge commands separately (they manage their own file loading)
-    if (command === 'diff') {
-        if (helpRequested) {
-            console.log(`
-eventmodeler diff - Compare event model files semantically
-
-USAGE:
-  eventmodeler diff <file1> <file2> [--format text|xml|json]
-  eventmodeler diff <file> [--ref <gitref>] [--format text|xml|json]
-  eventmodeler diff --base <file> --compare <file> [--format text|xml|json]
-
-ARGUMENTS:
-  <file1> <file2>   Two files to compare
-  <file>            Single file to compare against git ref
-
-OPTIONS:
-  --ref <gitref>      Git reference to compare against (default: HEAD)
-  --base <file>       Base file (alternative syntax)
-  --compare <file>    Compare file (alternative syntax)
-  --format <format>   Output format: text (default), xml, or json
-
-OUTPUT:
-  Semantic differences between models:
-  - Added/removed/modified entities
-  - Field changes (with flag changes like isGenerated)
-  - Flow changes
-  - Scenario changes
-
-Unlike line-based diff, this understands event model structure.
-
-EXAMPLES:
-  eventmodeler diff model-v1.eventmodel model-v2.eventmodel
-  eventmodeler diff mymodel.eventmodel --ref HEAD~1
-  eventmodeler diff mymodel.eventmodel --ref main
-  eventmodeler diff model.eventmodel --format json
-`);
-            process.exit(0);
-        }
-        const baseArg = getNamedArg(filteredArgs, '--base');
-        const compareArg = getNamedArg(filteredArgs, '--compare');
-        const refArg = getNamedArg(filteredArgs, '--ref');
-        // Diff supports 'text' format in addition to xml/json
-        const diffFormat = formatArg === 'json' ? 'json'
-            : formatArg === 'xml' ? 'xml'
-                : formatArg === 'text' ? 'text'
-                    : 'text'; // Default to text for human-readable output
-        // Two-file mode: diff file1 file2 OR diff --base file1 --compare file2
-        if (baseArg && compareArg) {
-            diff(baseArg, compareArg, diffFormat);
-            return;
-        }
-        // Positional args: diff file1 file2
-        const file1 = filteredArgs[1];
-        const file2 = filteredArgs[2];
-        if (file1 && file2 && !file1.startsWith('--') && !file2.startsWith('--')) {
-            diff(file1, file2, diffFormat);
-            return;
-        }
-        // Single file mode: diff file [--ref HEAD]
-        if (file1 && !file1.startsWith('--')) {
-            diff(file1, undefined, diffFormat, refArg);
-            return;
-        }
-        console.error('Usage: eventmodeler diff <file1> <file2>');
-        console.error('       eventmodeler diff <file> [--ref <gitref>]');
-        console.error('       eventmodeler diff --base <file> --compare <file>');
-        console.error('Run "eventmodeler diff --help" for more information.');
-        process.exit(1);
-    }
-    if (command === 'merge') {
-        if (helpRequested) {
-            console.log(`
-eventmodeler merge - Three-way merge of event model files
-
-USAGE:
-  eventmodeler merge --base <file> --ours <file> --theirs <file> --output <file>
-
-OPTIONS:
-  --base <file>       Common ancestor file (required)
-  --ours <file>       Our version file (required)
-  --theirs <file>     Their version file (required)
-  --output <file>     Output file path (required unless --dry-run)
-  --strategy <s>      Auto-resolve conflicts: ours or theirs
-  --dry-run           Show result without writing file
-  --format xml|json   Output format for conflict reporting
-
-HOW IT WORKS:
-  Performs semantic three-way merge:
-  1. Identifies changes in "ours" vs base
-  2. Identifies changes in "theirs" vs base
-  3. Auto-merges non-conflicting changes
-  4. Reports conflicts for manual resolution
-
-CONFLICT RESOLUTION:
-  --strategy ours     Keep our changes when conflicts occur
-  --strategy theirs   Keep their changes when conflicts occur
-
-EXAMPLES:
-  # Standard merge
-  eventmodeler merge --base base.eventmodel --ours mine.eventmodel --theirs theirs.eventmodel --output merged.eventmodel
-
-  # Auto-resolve with our changes taking precedence
-  eventmodeler merge --base base.eventmodel --ours mine.eventmodel --theirs theirs.eventmodel --output merged.eventmodel --strategy ours
-
-  # Preview merge without writing
-  eventmodeler merge --base base.eventmodel --ours mine.eventmodel --theirs theirs.eventmodel --dry-run
-`);
-            process.exit(0);
-        }
-        const baseArg = getNamedArg(filteredArgs, '--base');
-        const oursArg = getNamedArg(filteredArgs, '--ours');
-        const theirsArg = getNamedArg(filteredArgs, '--theirs');
-        const outputArg = getNamedArg(filteredArgs, '--output');
-        const strategyArg = getNamedArg(filteredArgs, '--strategy');
-        const dryRun = filteredArgs.includes('--dry-run');
-        if (!baseArg || !oursArg || !theirsArg) {
-            console.error('Usage: eventmodeler merge --base <file> --ours <file> --theirs <file> --output <file>');
-            console.error('Options:');
-            console.error('  --strategy ours|theirs    Auto-resolve conflicts');
-            console.error('  --dry-run                 Show result without writing');
-            console.error('Run "eventmodeler merge --help" for more information.');
-            process.exit(1);
-        }
-        if (!outputArg && !dryRun) {
-            console.error('Error: --output is required (or use --dry-run)');
-            process.exit(1);
-        }
-        merge({
-            basePath: baseArg,
-            oursPath: oursArg,
-            theirsPath: theirsArg,
-            outputPath: outputArg ?? '',
-            strategy: strategyArg === 'ours' || strategyArg === 'theirs' ? strategyArg : undefined,
-            dryRun,
-            format,
-        });
-        return;
-    }
     // Auth commands (no file needed)
     if (command === 'login') {
         if (helpRequested) {
@@ -405,8 +203,7 @@ 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 cloud model
-  - Access cloud-hosted event models
+  - Use "eventmodeler init" to connect a project to a model
 
 EXAMPLES:
   eventmodeler login
@@ -468,12 +265,8 @@ USAGE:
 Interactive setup to connect this directory to an event model.
 Creates a .eventmodeler.json config file in your project root.
 
-OPTIONS:
-  1. Cloud - Link to an event model on eventmodeler.app
-  2. Local - Use a local .eventmodel file
-
 PREREQUISITES:
-  - For cloud mode, you must be logged in (run "eventmodeler login" first)
+  - You must be logged in (run "eventmodeler login" first)
 
 EXAMPLES:
   cd my-project
@@ -484,151 +277,13 @@ EXAMPLES:
         await init();
         return;
     }
-    if (command === 'import') {
-        if (helpRequested) {
-            console.log(`
-eventmodeler import - Import .eventmodel file to cloud
-
-USAGE:
-  eventmodeler import <file> [--name <name>]
-
-ARGUMENTS:
-  <file>            Path to .eventmodel file to import
-
-OPTIONS:
-  --name <name>     Override model name (default: derived from file or EventModelCreated event)
-
-DESCRIPTION:
-  Imports a local .eventmodel file to the cloud backend, creating a new
-  cloud-hosted model. All events are preserved except EventModelCreated,
-  which is regenerated with a new modelId.
-
-PREREQUISITES:
-  - Must be logged in (run "eventmodeler login" first)
-
-EXAMPLES:
-  eventmodeler import mymodel.eventmodel
-  eventmodeler import ./models/order-system.eventmodel --name "Order System"
-`);
-            process.exit(0);
-        }
-        const importFilePath = subcommand;
-        if (!importFilePath) {
-            console.error('Usage: eventmodeler import <file> [--name <name>]');
-            console.error('Run "eventmodeler import --help" for more information.');
-            process.exit(1);
-        }
-        const importName = getNamedArg(filteredArgs, '--name', '-n');
-        await importModel(importFilePath, { name: importName });
-        return;
-    }
-    if (command === 'git') {
-        const gitCommand = filteredArgs[1];
-        const globalFlag = filteredArgs.includes('--global');
-        if (helpRequested && !gitCommand) {
-            console.log(`
-eventmodeler git - Git integration commands
-
-USAGE:
-  eventmodeler git <command> [options]
-
-COMMANDS:
-  setup    Configure git for semantic diff/merge of .eventmodel files
-  status   Show current git integration status
-
-Run "eventmodeler git <command> --help" for command-specific help.
-`);
-            process.exit(0);
-        }
-        switch (gitCommand) {
-            case 'setup':
-                if (helpRequested) {
-                    console.log(`
-eventmodeler git setup - Configure git for semantic diff/merge
-
-USAGE:
-  eventmodeler git setup [--global]
-
-OPTIONS:
-  --global   Configure globally (for all repositories)
-
-WHAT IT DOES:
-  1. Adds .gitattributes entry: *.eventmodel diff=eventmodel merge=eventmodel
-  2. Configures git diff driver for semantic comparison
-  3. Configures git merge driver for semantic merging
-
-After setup:
-  - "git diff" shows semantic differences for .eventmodel files
-  - "git merge" performs semantic merging
-  - Conflicts are reported at entity level, not line level
-
-LOCAL VS GLOBAL:
-  Without --global: Configures current repository only
-  With --global: Configures for all repositories (user-level)
-
-EXAMPLES:
-  eventmodeler git setup           # Configure current repo
-  eventmodeler git setup --global  # Configure globally
-`);
-                    process.exit(0);
-                }
-                gitSetup(globalFlag);
-                return;
-            case 'status':
-                if (helpRequested) {
-                    console.log(`
-eventmodeler git status - Show git integration status
-
-USAGE:
-  eventmodeler git status
-
-OUTPUT:
-  Shows current configuration:
-  - Whether git drivers are configured
-  - Local vs global configuration status
-  - .gitattributes configuration status
-
-EXAMPLES:
-  eventmodeler git status
-`);
-                    process.exit(0);
-                }
-                gitStatus();
-                return;
-            default:
-                console.error('Usage: eventmodeler git setup [--global]');
-                console.error('       eventmodeler git status');
-                console.error('Run "eventmodeler git --help" for more information.');
-                process.exit(1);
-        }
-    }
-    // Determine backend mode: cloud or local
     const projectConfig = loadProjectConfig();
-    const isCloudMode = projectConfig?.type === 'cloud' && !fileArg;
-    const modelId = isCloudMode ? projectConfig.modelId : null;
-    // For local mode, we need to load the model from file
-    // For cloud mode, we call backend endpoints directly (no model loading)
-    let model = null;
-    let filePath = null;
-    if (!isCloudMode) {
-        // Local mode - load model from file
-        if (projectConfig?.type === 'local') {
-            filePath = fileArg ?? projectConfig.file;
-        }
-        else {
-            filePath = fileArg ?? await findEventModelFile();
-        }
-        if (!filePath) {
-            console.error('Error: No .eventmodel file found in current directory.');
-            console.error('Use -f <path> to specify a file or run "eventmodeler init" to set up a project.');
-            process.exit(1);
-        }
-        if (!fs.existsSync(filePath)) {
-            console.error(`Error: File not found: ${filePath}`);
-            process.exit(1);
-        }
-        model = loadModel(filePath);
+    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) {
@@ -688,13 +343,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listSlices(modelId, format, chapterArg ?? undefined);
+                    {
+                        const output = await api.listSlices(modelId, format, chapterArg ?? undefined);
                         console.log(output);
                     }
-                    else {
-                        listSlices(model, format, chapterArg ?? undefined);
-                    }
                     break;
                 case 'events':
                     if (helpRequested) {
@@ -719,13 +371,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listEvents(modelId, format);
+                    {
+                        const output = await api.listEvents(modelId, format);
                         console.log(output);
                     }
-                    else {
-                        listEvents(model, format);
-                    }
                     break;
                 case 'commands':
                     if (helpRequested) {
@@ -748,13 +397,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listCommands(modelId, format);
+                    {
+                        const output = await api.listCommands(modelId, format);
                         console.log(output);
                     }
-                    else {
-                        listCommands(model, format);
-                    }
                     break;
                 case 'chapters':
                     if (helpRequested) {
@@ -777,13 +423,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listChapters(modelId, format);
+                    {
+                        const output = await api.listChapters(modelId, format);
                         console.log(output);
                     }
-                    else {
-                        listChapters(model, format);
-                    }
                     break;
                 case 'aggregates':
                     if (helpRequested) {
@@ -807,13 +450,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.listAggregates(modelId, format);
+                    {
+                        const result = await api.listAggregates(modelId, format);
                         console.log(result);
                     }
-                    else {
-                        listAggregates(model, format);
-                    }
                     break;
                 case 'actors':
                     if (helpRequested) {
@@ -836,12 +476,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listActors(modelId, format);
+                    {
+                        const output = await api.listActors(modelId, format);
                         console.log(output);
-                        break;
                     }
-                    listActors(model, format);
                     break;
                 case 'readmodels':
                     if (helpRequested) {
@@ -861,12 +499,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listReadModels(modelId, format);
+                    {
+                        const output = await api.listReadModels(modelId, format);
                         console.log(output);
-                        break;
                     }
-                    listReadModels(model, format);
                     break;
                 case 'screens':
                     if (helpRequested) {
@@ -886,12 +522,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listScreens(modelId, format);
+                    {
+                        const output = await api.listScreens(modelId, format);
                         console.log(output);
-                        break;
                     }
-                    listScreens(model, format);
                     break;
                 case 'processors':
                     if (helpRequested) {
@@ -910,12 +544,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listProcessors(modelId, format);
+                    {
+                        const output = await api.listProcessors(modelId, format);
                         console.log(output);
-                        break;
                     }
-                    listProcessors(model, format);
                     break;
                 case 'scenarios':
                     if (helpRequested) {
@@ -936,12 +568,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const output = await cloudSlices.listScenarios(modelId, format);
+                    {
+                        const output = await api.listScenarios(modelId, format);
                         console.log(output);
-                        break;
                     }
-                    listScenarios(model, format);
                     break;
                 default:
                     console.error(`Unknown list target: ${subcommand}`);
@@ -963,8 +593,8 @@ TYPES:
   event                  Show event with all fields
   command                Show command with all fields
   chapter                Show chapter with slices and dependencies
-  completeness           Show field mapping completeness for any element
-  model-completeness     Show completeness of all flows
+  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
@@ -979,7 +609,7 @@ OPTIONS:
 EXAMPLES:
   eventmodeler show slice "Place Order"
   eventmodeler show event OrderPlaced
-  eventmodeler show completeness OrderSummary
+  eventmodeler show information-completeness OrderSummary
 
 Run "eventmodeler show <type> --help" for type-specific help.
 `);
@@ -1018,13 +648,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show slice --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showSlice(modelId, target, format);
+                    {
+                        const result = await api.showSlice(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showSlice(model, target, format);
-                    }
                     break;
                 case 'event':
                     if (helpRequested) {
@@ -1066,13 +693,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show event --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showEvent(modelId, target, format);
+                    {
+                        const result = await api.showEvent(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showEvent(model, target, format);
-                    }
                     break;
                 case 'command':
                     if (helpRequested) {
@@ -1100,13 +724,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show command --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showCommand(modelId, target, format);
+                    {
+                        const result = await api.showCommand(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showCommand(model, target, format);
-                    }
                     break;
                 case 'chapter':
                     if (helpRequested) {
@@ -1135,26 +756,28 @@ EXAMPLES:
                         console.error('Run "eventmodeler show chapter --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showChapter(modelId, target, format);
+                    {
+                        const result = await api.showChapter(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showChapter(model, target, format);
-                    }
                     break;
-                case 'completeness':
+                case 'information-completeness':
                     if (helpRequested) {
                         console.log(`
-eventmodeler show completeness - Show field mapping completeness
+eventmodeler show information-completeness - Show information completeness
 
 USAGE:
-  eventmodeler show completeness <name> [--format xml|json]
+  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]
 
-ARGUMENTS:
-  <name>   Element name (command, event, read model, screen, or processor)
+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:
+OUTPUT INCLUDES (per-element):
   - Total fields vs mapped fields
   - List of unmapped fields needing attention
   - Mapping sources for mapped fields
@@ -1164,53 +787,31 @@ IMPORTANT - GENERATED FIELDS:
   Generated fields are computed/synthesized values that don't need
   source mappings (e.g., calculated totals, timestamps, derived data).
 
-EXAMPLES:
-  eventmodeler show completeness OrderSummary
-  eventmodeler show completeness "Order Summary" --format json
-`);
-                        process.exit(0);
-                    }
-                    if (!target) {
-                        console.error('Usage: eventmodeler show completeness <element-name>');
-                        console.error('Searches: commands, events, read models, screens, processors');
-                        console.error('Run "eventmodeler show completeness --help" for more information.');
-                        process.exit(1);
-                    }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showCompleteness(modelId, target, format);
-                        console.log(result);
-                    }
-                    else {
-                        showCompleteness(model, target, format);
-                    }
-                    break;
-                case 'model-completeness':
-                    if (helpRequested) {
-                        console.log(`
-eventmodeler show model-completeness - Show completeness of all flows
-
-USAGE:
-  eventmodeler show model-completeness [--format xml|json]
-
-OUTPUT INCLUDES:
-  - Complete flows (all required fields mapped)
-  - Incomplete flows with missing mappings
-  - Overall completeness percentage
-
-NOTE: Generated fields (isGenerated=true) are excluded from checks.
+NOTE: Generated and user-input fields are excluded from checks.
+      Auto-matching uses field name AND type.
 
 EXAMPLES:
-  eventmodeler show model-completeness
-  eventmodeler show model-completeness --format json
+  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 (isCloudMode) {
-                        const result = await cloudSlices.showModelCompleteness(modelId, format);
-                        console.log(result);
-                    }
-                    else {
-                        showModelCompleteness(model, format);
+                    {
+                        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':
@@ -1239,13 +840,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show aggregate-completeness --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showAggregateCompleteness(modelId, target, format);
+                    {
+                        const result = await api.showAggregateCompleteness(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showAggregateCompleteness(model, target, format);
-                    }
                     break;
                 case 'actor':
                     if (helpRequested) {
@@ -1273,13 +871,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show actor --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showActor(modelId, target, format);
+                    {
+                        const result = await api.showActor(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showActor(model, target, format);
-                    }
                     break;
                 case 'readmodel':
                     if (helpRequested) {
@@ -1308,13 +903,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show readmodel --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showReadModel(modelId, target, format);
+                    {
+                        const result = await api.showReadModel(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showReadModel(model, target, format);
-                    }
                     break;
                 case 'screen':
                     if (helpRequested) {
@@ -1344,13 +936,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show screen --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showScreen(modelId, target, format);
+                    {
+                        const result = await api.showScreen(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showScreen(model, target, format);
-                    }
                     break;
                 case 'processor':
                     if (helpRequested) {
@@ -1379,13 +968,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show processor --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showProcessor(modelId, target, format);
+                    {
+                        const result = await api.showProcessor(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showProcessor(model, target, format);
-                    }
                     break;
                 case 'aggregate':
                     if (helpRequested) {
@@ -1415,13 +1001,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler show aggregate --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showAggregate(modelId, target, format);
+                    {
+                        const result = await api.showAggregate(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showAggregate(model, target, format);
-                    }
                     break;
                 case 'scenario':
                     if (helpRequested) {
@@ -1452,17 +1035,14 @@ EXAMPLES:
                         console.error('Run "eventmodeler show scenario --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.showScenario(modelId, target, format);
+                    {
+                        const result = await api.showScenario(modelId, target, format);
                         console.log(result);
                     }
-                    else {
-                        showScenario(model, target, format);
-                    }
                     break;
                 default:
                     console.error(`Unknown show target: ${subcommand}`);
-                    console.error('Valid targets: slice, event, command, chapter, completeness, model-completeness, aggregate-completeness, actor, readmodel, screen, processor, aggregate, scenario');
+                    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);
             }
@@ -1503,35 +1083,42 @@ EXAMPLES:
                 console.error('Run "eventmodeler search --help" for more information.');
                 process.exit(1);
             }
-            if (isCloudMode) {
-                const response = await cloudSlices.search(modelId, subcommand);
+            {
+                const response = await api.search(modelId, subcommand);
                 if (format === 'json') {
                     console.log(JSON.stringify(response, null, 2));
                 }
                 else {
-                    const esc = (s) => s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-                    const attr = (name, value) => value ? ` ${name}="${esc(value)}"` : '';
-                    console.log(`<search-results query="${esc(subcommand)}" count="${response.results.length}">`);
-                    for (const r of response.results) {
+                    const xb = new XMLBuilder({ ignoreAttributes: false, attributeNamePrefix: '@_', suppressEmptyNode: true });
+                    const results = response.results.map(r => {
                         const tag = r.type === 'readmodel' ? 'read-model' : r.type;
-                        console.log(`  <${tag}` +
-                            `${attr('id', r.id)}` +
-                            `${attr('name', r.name)}` +
-                            `${attr('chapter-id', r.chapterId)}` +
-                            `${attr('chapter-name', r.chapterName)}` +
-                            `${attr('slice-id', r.sliceId)}` +
-                            `${attr('slice-name', r.sliceName)}` +
-                            `${attr('slice-status', r.sliceStatus)}` +
-                            `${attr('parent-chapter-id', r.parentChapterId)}` +
-                            `${attr('parent-chapter-name', r.parentChapterName)}` +
-                            '/>');
-                    }
-                    console.log('</search-results>');
+                        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': subcommand, '@_count': String(response.results.length) } });
+                    // Replace self-closing tag with children
+                    const open = wrapper.replace(/\/>$/, '>').trim();
+                    console.log([open, ...results, '</search-results>'].join('\n'));
                 }
             }
-            else {
-                search(model, subcommand, format);
-            }
             break;
         case 'mark': {
             if (helpRequested) {
@@ -1571,15 +1158,8 @@ EXAMPLES:
             }
             const sliceName = allArgs.slice(0, -1).join(' ');
             const status = lastArg;
-            if (isCloudMode) {
-                // Cloud mode - backend resolves name to ID
-                await cloudSlices.markSliceStatus(modelId, sliceName, status);
-                console.log(`Marked slice "${sliceName}" as ${status}`);
-            }
-            else {
-                // Local mode
-                markSliceStatus(model, filePath, sliceName, status);
-            }
+            await api.markSliceStatus(modelId, sliceName, status);
+            console.log(`Marked slice "${sliceName}" as ${status}`);
             break;
         }
         case 'summary':
@@ -1606,30 +1186,30 @@ EXAMPLES:
 `);
                 process.exit(0);
             }
-            if (isCloudMode) {
-                const summary = await cloudSlices.getSummary(modelId);
+            {
+                const summary = await api.getSummary(modelId);
                 if (format === 'json') {
                     console.log(JSON.stringify(summary, null, 2));
                 }
                 else {
-                    const name = summary.modelName || '';
-                    console.log(`<model name="${name}">`);
-                    console.log(`  <slices count="${summary.slices.total}"/>`);
-                    console.log(`  <commands count="${summary.commands}"/>`);
-                    console.log(`  <events count="${summary.events}"/>`);
-                    console.log(`  <read-models count="${summary.readModels}"/>`);
-                    console.log(`  <screens count="${summary.screens}"/>`);
-                    console.log(`  <processors count="${summary.processors}"/>`);
-                    console.log(`  <aggregates count="${summary.aggregates}"/>`);
-                    console.log(`  <actors count="${summary.actors}"/>`);
-                    console.log(`  <scenarios count="${summary.scenarios}"/>`);
-                    console.log(`  <flows count="${summary.flows}"/>`);
-                    console.log('</model>');
+                    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());
                 }
             }
-            else {
-                showModelSummary(model, format);
-            }
             break;
         case 'export':
             if (helpRequested && !subcommand) {
@@ -1669,13 +1249,10 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.exportJson(modelId);
+                    {
+                        const result = await api.exportJson(modelId);
                         console.log(JSON.stringify(JSON.parse(result), null, 2));
                     }
-                    else {
-                        exportEventmodelToJson(model);
-                    }
                     break;
                 default:
                     console.error(`Unknown export format: ${subcommand}`);
@@ -1767,7 +1344,7 @@ EXAMPLES:
                         console.error('Run "eventmodeler add scenario --help" for detailed format.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
+                    {
                         let parsedScenario;
                         try {
                             parsedScenario = parseScenarioInput(inputData);
@@ -1811,12 +1388,9 @@ EXAMPLES:
                                     : undefined,
                             },
                         };
-                        await cloudSlices.createScenario(modelId, sliceArg, scenario);
+                        await api.createScenario(modelId, sliceArg, scenario);
                         console.log(`Created scenario "${scenario.name}" in slice "${sliceArg}"`);
                     }
-                    else {
-                        addScenario(model, filePath, sliceArg, inputData);
-                    }
                     break;
                 }
                 case 'field': {
@@ -1825,14 +1399,10 @@ EXAMPLES:
 eventmodeler add field - Add a field to an entity
 
 USAGE:
-  eventmodeler add field --command|--event|--read-model|--screen|--processor <name> --json|--xml <data>
+  eventmodeler add field <element-name> --json|--xml <data>
 
 OPTIONS:
-  --command <name>      Target command name
-  --event <name>        Target event name
-  --read-model <name>   Target read model name
-  --screen <name>       Target screen name
-  --processor <name>    Target processor name
+  <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
 
@@ -1909,28 +1479,31 @@ NOTES:
   - Subfields support arbitrary nesting depth
 
 EXAMPLES:
-  eventmodeler add field --event OrderPlaced --json '{"name": "orderId", "type": "UUID"}'
-  eventmodeler add field --read-model OrderSummary --json '{"name": "totalWithTax", "type": "Decimal", "isGenerated": true}'
-  eventmodeler add field --event OrderPlaced --xml '<field name="item" type="Custom"><field name="price" type="Decimal"/><field name="tax" type="Decimal" isGenerated="true"/></field>'
+  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 commandArg = getNamedArg(filteredArgs, '--command');
-                    const eventArg = getNamedArg(filteredArgs, '--event');
-                    const readModelArg = getNamedArg(filteredArgs, '--read-model');
-                    const screenArg = getNamedArg(filteredArgs, '--screen');
-                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     const jsonArg = getNamedArg(filteredArgs, '--json');
                     const xmlArg = getNamedArg(filteredArgs, '--xml');
                     const inputData = jsonArg ?? xmlArg;
+                    // Element name is the first positional arg (not a flag or flag value)
+                    const elementName = filteredArgs.find((a, i) => !a.startsWith('-') && (i === 0 || !['--json', '--xml'].includes(filteredArgs[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 --command|--event|--read-model|--screen|--processor <name> --json|--xml <data>');
+                        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 (isCloudMode) {
-                        // Parse field data and determine element type
+                    {
+                        // Parse field data
                         let field;
                         try {
                             if (jsonArg) {
@@ -1946,59 +1519,29 @@ EXAMPLES:
                                 };
                             }
                             else {
-                                // XML parsing - extract field attributes
-                                const nameMatch = inputData.match(/name="([^"]*)"/);
-                                const typeMatch = inputData.match(/type="([^"]*)"/);
-                                const isListMatch = inputData.match(/isList="([^"]*)"/);
-                                const isOptionalMatch = inputData.match(/isOptional="([^"]*)"/);
-                                const isGeneratedMatch = inputData.match(/isGenerated="([^"]*)"/);
-                                const isUserInputMatch = inputData.match(/isUserInput="([^"]*)"/);
-                                field = {
-                                    name: nameMatch?.[1] ?? '',
-                                    fieldType: typeMatch?.[1] ?? 'String',
-                                    isList: isListMatch?.[1] === 'true',
-                                    isOptional: isOptionalMatch?.[1] === 'true',
-                                    isGenerated: isGeneratedMatch?.[1] === 'true',
-                                    isUserInput: isUserInputMatch?.[1] === 'true',
-                                };
+                                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);
                         }
-                        // Determine element type and name
-                        let elementType;
-                        let elementName;
-                        if (commandArg) {
-                            elementType = 'command';
-                            elementName = commandArg;
-                        }
-                        else if (eventArg) {
-                            elementType = 'event';
-                            elementName = eventArg;
-                        }
-                        else if (readModelArg) {
-                            elementType = 'readModel';
-                            elementName = readModelArg;
-                        }
-                        else if (screenArg) {
-                            elementType = 'screen';
-                            elementName = screenArg;
-                        }
-                        else if (processorArg) {
-                            elementType = 'processor';
-                            elementName = processorArg;
-                        }
-                        else {
-                            console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
-                            process.exit(1);
-                        }
-                        await cloudSlices.addField(modelId, elementType, elementName, field);
-                        console.log(`Added field "${field.name}" to ${elementType} "${elementName}"`);
-                    }
-                    else {
-                        addField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, inputData);
+                        await api.addField(modelId, elementName, field);
+                        console.log(`Added field "${field.name}" to "${elementName}"`);
                     }
                     break;
                 }
@@ -2060,13 +1603,8 @@ EXAMPLES:
                         console.error('Run "eventmodeler remove scenario --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        await cloudSlices.removeScenario(modelId, scenarioName, sliceArg);
-                        console.log(`Removed scenario "${scenarioName}"${sliceArg ? ` from slice "${sliceArg}"` : ''}`);
-                    }
-                    else {
-                        removeScenario(model, filePath, scenarioName, sliceArg);
-                    }
+                    await api.removeScenario(modelId, scenarioName, sliceArg);
+                    console.log(`Removed scenario "${scenarioName}"${sliceArg ? ` from slice "${sliceArg}"` : ''}`);
                     break;
                 }
                 case 'field': {
@@ -2075,67 +1613,36 @@ EXAMPLES:
 eventmodeler remove field - Remove a field from an entity
 
 USAGE:
-  eventmodeler remove field --command|--event|--read-model|--screen|--processor <name> --field <field-name>
+  eventmodeler remove field <element-name> --field <field-name>
 
 OPTIONS:
-  --command <name>      Target command name
-  --event <name>        Target event name
-  --read-model <name>   Target read model name
-  --screen <name>       Target screen name
-  --processor <name>    Target processor name
+  <element-name>        Name of the command, event, read model, screen, or processor
   --field <name>        Field name to remove (required)
 
 EXAMPLES:
-  eventmodeler remove field --event OrderPlaced --field orderId
-  eventmodeler remove field --read-model "Order Summary" --field notes
+  eventmodeler remove field OrderPlaced --field orderId
+  eventmodeler remove field "Order Summary" --field notes
 `);
                         process.exit(0);
                     }
-                    const commandArg = getNamedArg(filteredArgs, '--command');
-                    const eventArg = getNamedArg(filteredArgs, '--event');
-                    const readModelArg = getNamedArg(filteredArgs, '--read-model');
-                    const screenArg = getNamedArg(filteredArgs, '--screen');
-                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     const fieldArg = getNamedArg(filteredArgs, '--field');
+                    // Element name is the first positional arg (not a flag or flag value)
+                    const elementName = filteredArgs.find((a, i) => !a.startsWith('-') && (i === 0 || !['--field'].includes(filteredArgs[i - 1])));
                     if (!fieldArg) {
                         console.error('Error: --field is required');
-                        console.error('Usage: eventmodeler remove field --command|--event|--read-model|--screen|--processor <name> --field <field-name>');
+                        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 (isCloudMode) {
-                        // Determine element type and name
-                        let elementType;
-                        let elementName;
-                        if (commandArg) {
-                            elementType = 'command';
-                            elementName = commandArg;
-                        }
-                        else if (eventArg) {
-                            elementType = 'event';
-                            elementName = eventArg;
-                        }
-                        else if (readModelArg) {
-                            elementType = 'readModel';
-                            elementName = readModelArg;
-                        }
-                        else if (screenArg) {
-                            elementType = 'screen';
-                            elementName = screenArg;
-                        }
-                        else if (processorArg) {
-                            elementType = 'processor';
-                            elementName = processorArg;
-                        }
-                        else {
-                            console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
-                            process.exit(1);
-                        }
-                        await cloudSlices.removeField(modelId, elementType, elementName, fieldArg);
-                        console.log(`Removed field "${fieldArg}" from ${elementType} "${elementName}"`);
+                    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);
                     }
-                    else {
-                        removeField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg);
+                    {
+                        await api.removeField(modelId, elementName, fieldArg);
+                        console.log(`Removed field "${fieldArg}" from "${elementName}"`);
                     }
                     break;
                 }
@@ -2190,7 +1697,7 @@ XML FORMAT:
 NOTES:
   - Mappings define how fields flow from source to target
   - Fields marked as isGenerated=true don't need mappings
-  - Use "show completeness" to check mapping status
+  - Use "show information-completeness <name>" to check mapping status
 
 EXAMPLES:
   eventmodeler map fields --flow "OrderPlaced→OrderSummary" --json '[{"from": "total", "to": "totalAmount"}]'
@@ -2215,7 +1722,7 @@ EXAMPLES:
                         console.error('Run "eventmodeler map fields --help" for detailed format.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
+                    {
                         // Parse flow argument to extract source and target names
                         const flowParts = flowArg.split(/→|->/).map(s => s.trim());
                         if (flowParts.length !== 2) {
@@ -2230,28 +1737,23 @@ EXAMPLES:
                                 mappings = JSON.parse(inputData);
                             }
                             else {
-                                // XML parsing - extract mapping attributes
-                                const mappingMatches = inputData.match(/<mapping[^>]+>/g) || [];
-                                mappings = mappingMatches.map(m => {
-                                    const fromMatch = m.match(/from="([^"]*)"/);
-                                    const toMatch = m.match(/to="([^"]*)"/);
-                                    return {
-                                        from: fromMatch?.[1] ?? '',
-                                        to: toMatch?.[1] ?? '',
-                                    };
-                                });
+                                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 cloudSlices.mapFields(modelId, sourceName, targetName, mappings);
+                        await api.mapFields(modelId, sourceName, targetName, mappings);
                         console.log(`Mapped ${mappings.length} field(s) from "${sourceName}" to "${targetName}"`);
                     }
-                    else {
-                        mapFields(model, filePath, flowArg, inputData);
-                    }
                     break;
                 }
                 default:
@@ -2283,22 +1785,18 @@ Run "eventmodeler update field --help" for detailed help.
 eventmodeler update field - Update field properties
 
 USAGE:
-  eventmodeler update field --command|--event|--read-model|--screen|--processor <name> --field <field-name> [updates]
+  eventmodeler update field <element-name> --field <field-name> [updates]
 
-TARGET OPTIONS (one required):
-  --command <name>      Target command
-  --event <name>        Target event
-  --read-model <name>   Target read model
-  --screen <name>       Target screen
-  --processor <name>    Target processor
+OPTIONS:
+  <element-name>           Name of the command, event, read model, screen, or processor
 
 REQUIRED:
-  --field <name>        Field to update
+  --field <name>           Field to update
 
 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 (screen only)
+  --user-input true|false  Set isUserInput flag
   --type <type>            Change field type
 
 FIELD FLAGS EXPLAINED:
@@ -2308,38 +1806,37 @@ FIELD FLAGS EXPLAINED:
 
 EXAMPLES:
   # Mark field as optional
-  eventmodeler update field --read-model OrderSummary --field notes --optional true
+  eventmodeler update field OrderSummary --field notes --optional true
 
   # Mark field as generated (computed value, no mapping needed)
-  eventmodeler update field --read-model OrderSummary --field totalWithTax --generated true
+  eventmodeler update field OrderSummary --field totalWithTax --generated true
 
   # Mark screen field as user input
-  eventmodeler update field --screen "Order Form" --field quantity --user-input true
+  eventmodeler update field "Order Form" --field quantity --user-input true
 
   # Change field type
-  eventmodeler update field --event OrderPlaced --field amount --type Decimal
+  eventmodeler update field OrderPlaced --field amount --type Decimal
 `);
                         process.exit(0);
                     }
-                    const commandArg = getNamedArg(filteredArgs, '--command');
-                    const eventArg = getNamedArg(filteredArgs, '--event');
-                    const readModelArg = getNamedArg(filteredArgs, '--read-model');
-                    const screenArg = getNamedArg(filteredArgs, '--screen');
-                    const processorArg = getNamedArg(filteredArgs, '--processor');
                     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 (not a flag or flag value)
+                    const flagsWithValues = ['--field', '--optional', '--generated', '--user-input', '--type'];
+                    const elementName = filteredArgs.find((a, i) => !a.startsWith('-') && (i === 0 || !flagsWithValues.includes(filteredArgs[i - 1])));
                     if (!fieldArg) {
                         console.error('Error: --field is required');
-                        console.error('Usage: eventmodeler update field --command|--event|--read-model|--screen|--processor <name> --field <field-name> [--optional true|false] [--generated true|false] [--user-input true|false (screen only)]');
+                        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);
                     }
-                    // --user-input is only valid for screens
-                    if (userInputArg !== undefined && !screenArg) {
-                        console.error('Error: --user-input can only be used with --screen');
+                    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 = {};
@@ -2360,49 +1857,19 @@ EXAMPLES:
                         console.error('Run "eventmodeler update field --help" for available options.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        // Determine element type and name
-                        let elementType;
-                        let elementName;
-                        if (commandArg) {
-                            elementType = 'command';
-                            elementName = commandArg;
-                        }
-                        else if (eventArg) {
-                            elementType = 'event';
-                            elementName = eventArg;
-                        }
-                        else if (readModelArg) {
-                            elementType = 'readModel';
-                            elementName = readModelArg;
-                        }
-                        else if (screenArg) {
-                            elementType = 'screen';
-                            elementName = screenArg;
-                        }
-                        else if (processorArg) {
-                            elementType = 'processor';
-                            elementName = processorArg;
-                        }
-                        else {
-                            console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
-                            process.exit(1);
-                        }
-                        // Convert local updates format to cloud format
-                        const cloudUpdates = {};
+                    {
+                        // Convert updates to API format
+                        const fieldUpdates = {};
                         if (updates.optional !== undefined)
-                            cloudUpdates.isOptional = updates.optional;
+                            fieldUpdates.isOptional = updates.optional;
                         if (updates.generated !== undefined)
-                            cloudUpdates.isGenerated = updates.generated;
+                            fieldUpdates.isGenerated = updates.generated;
                         if (updates.userInput !== undefined)
-                            cloudUpdates.isUserInput = updates.userInput;
+                            fieldUpdates.isUserInput = updates.userInput;
                         if (updates.type !== undefined)
-                            cloudUpdates.fieldType = updates.type;
-                        await cloudSlices.updateField(modelId, elementType, elementName, fieldArg, cloudUpdates);
-                        console.log(`Updated field "${fieldArg}" on ${elementType} "${elementName}"`);
-                    }
-                    else {
-                        updateField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg, updates);
+                            fieldUpdates.fieldType = updates.type;
+                        await api.updateField(modelId, elementName, fieldArg, fieldUpdates);
+                        console.log(`Updated field "${fieldArg}" on "${elementName}"`);
                     }
                     break;
                 }
@@ -2516,11 +1983,11 @@ EXAMPLES:
                         console.error('Run "eventmodeler create state-change-slice --help" for detailed format.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
+                    {
                         // Parse XML input to extract structured data
                         const parser = await import('./lib/slice-utils.js');
                         const parsed = parser.parseStateChangeSliceXml(xmlArg);
-                        const cloudInput = {
+                        const sliceInput = {
                             sliceName: parsed.sliceName,
                             after: parsed.after,
                             before: parsed.before,
@@ -2528,7 +1995,7 @@ EXAMPLES:
                             command: { name: parsed.command.name, fields: toCompoundFields(parsed.command.fields) },
                             event: { name: parsed.event.name, fields: toCompoundFields(parsed.event.fields) },
                         };
-                        const result = await cloudSlices.createStateChangeSlice(modelId, cloudInput);
+                        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)`);
@@ -2536,9 +2003,6 @@ EXAMPLES:
                         console.log(`  Screen -> Command mappings: ${result.screenToCommandMappings}`);
                         console.log(`  Command -> Event mappings: ${result.commandToEventMappings}`);
                     }
-                    else {
-                        createStateChangeSlice(model, filePath, xmlArg);
-                    }
                     break;
                 }
                 case 'automation-slice': {
@@ -2619,11 +2083,11 @@ EXAMPLES:
                         console.error('Run "eventmodeler create automation-slice --help" for detailed format.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
+                    {
                         // Parse XML input to extract structured data
                         const parser = await import('./lib/slice-utils.js');
                         const parsed = parser.parseAutomationSliceXml(xmlArg);
-                        const cloudInput = {
+                        const sliceInput = {
                             sliceName: parsed.sliceName,
                             after: parsed.after,
                             before: parsed.before,
@@ -2632,7 +2096,7 @@ EXAMPLES:
                             command: { name: parsed.command.name, fields: toCompoundFields(parsed.command.fields) },
                             event: { name: parsed.event.name, fields: toCompoundFields(parsed.event.fields) },
                         };
-                        const result = await cloudSlices.createAutomationSlice(modelId, cloudInput);
+                        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}`);
@@ -2641,9 +2105,6 @@ EXAMPLES:
                         console.log(`  ReadModel -> Command mappings: ${result.readModelToCommandMappings}`);
                         console.log(`  Command -> Event mappings: ${result.commandToEventMappings}`);
                     }
-                    else {
-                        createAutomationSlice(model, filePath, xmlArg);
-                    }
                     break;
                 }
                 case 'state-view-slice': {
@@ -2710,23 +2171,20 @@ EXAMPLES:
                         console.error('Run "eventmodeler create state-view-slice --help" for detailed format.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
+                    {
                         // Parse XML input to extract structured data
                         const parser = await import('./lib/slice-utils.js');
                         const parsed = parser.parseStateViewSliceXml(xmlArg);
-                        const cloudInput = {
+                        const sliceInput = {
                             sliceName: parsed.sliceName,
                             after: parsed.after,
                             before: parsed.before,
                             readModel: { name: parsed.readModel.name, fields: toCompoundFields(parsed.readModel.fields) },
                         };
-                        const result = await cloudSlices.createStateViewSlice(modelId, cloudInput);
+                        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)`);
                     }
-                    else {
-                        createStateViewSlice(model, filePath, xmlArg);
-                    }
                     break;
                 }
                 case 'flow': {
@@ -2761,13 +2219,8 @@ EXAMPLES:
                         console.error('Run "eventmodeler create flow --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        await cloudSlices.createFlow(modelId, fromArg, toArg);
-                        console.log(`Created flow from "${fromArg}" to "${toArg}"`);
-                    }
-                    else {
-                        createFlow(model, filePath, fromArg, toArg);
-                    }
+                    await api.createFlow(modelId, fromArg, toArg);
+                    console.log(`Created flow from "${fromArg}" to "${toArg}"`);
                     break;
                 }
                 default:
@@ -2831,13 +2284,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler codegen slice --help" for more information.');
                         process.exit(1);
                     }
-                    if (isCloudMode) {
-                        const result = await cloudSlices.codegenSlice(modelId, sliceName);
+                    {
+                        const result = await api.codegenSlice(modelId, sliceName);
                         console.log(JSON.stringify(JSON.parse(result), null, 2));
                     }
-                    else {
-                        codegenSlice(model, sliceName);
-                    }
                     break;
                 }
                 case 'events': {
@@ -2869,13 +2319,10 @@ EXAMPLES:
                         process.exit(0);
                     }
                     const chapterName = chapterArg ?? target;
-                    if (isCloudMode) {
-                        const output = await cloudSlices.codegenEvents(modelId, chapterName);
+                    {
+                        const output = await api.codegenEvents(modelId, chapterName);
                         console.log(JSON.stringify(output, null, 2));
                     }
-                    else {
-                        codegenEvents(model, chapterName);
-                    }
                     break;
                 }
                 default: