eventmodeler 0.3.10 → 0.4.1

package/dist/index.js

@@ -31,6 +31,15 @@ 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';
@@ -39,6 +48,15 @@ import { codegenSlice } from './slices/codegen-slice/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 { 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 { loadProjectConfig } from './lib/project-config.js';
 const args = process.argv.slice(2);
 function getNamedArg(argList, ...names) {
     for (let i = 0; i < argList.length; i++) {
@@ -59,6 +77,14 @@ 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 cloud or local model)
+
 COMMANDS:
   list slices [--chapter <name>] List all slices (optionally filtered by chapter)
   list events                    List all events
@@ -66,6 +92,10 @@ 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
@@ -78,6 +108,11 @@ COMMANDS:
   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
 
@@ -115,6 +150,9 @@ 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)
@@ -340,6 +378,136 @@ EXAMPLES:
         });
         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 cloud model
+  - Access cloud-hosted event models
+
+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.
+
+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)
+
+EXAMPLES:
+  cd my-project
+  eventmodeler init
+`);
+            process.exit(0);
+        }
+        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');
@@ -420,17 +588,33 @@ EXAMPLES:
                 process.exit(1);
         }
     }
-    const 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 in a directory with an .eventmodel file.');
-        process.exit(1);
-    }
-    if (!fs.existsSync(filePath)) {
-        console.error(`Error: File not found: ${filePath}`);
-        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);
     }
-    const model = loadModel(filePath);
     switch (command) {
         case 'list':
             if (helpRequested && !subcommand) {
@@ -447,6 +631,9 @@ TYPES:
   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)
@@ -487,7 +674,13 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    listSlices(model, format, chapterArg ?? undefined);
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listSlices(modelId, format, chapterArg ?? undefined);
+                        console.log(output);
+                    }
+                    else {
+                        listSlices(model, format, chapterArg ?? undefined);
+                    }
                     break;
                 case 'events':
                     if (helpRequested) {
@@ -512,7 +705,13 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    listEvents(model, format);
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listEvents(modelId, format);
+                        console.log(output);
+                    }
+                    else {
+                        listEvents(model, format);
+                    }
                     break;
                 case 'commands':
                     if (helpRequested) {
@@ -535,7 +734,13 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    listCommands(model, format);
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listCommands(modelId, format);
+                        console.log(output);
+                    }
+                    else {
+                        listCommands(model, format);
+                    }
                     break;
                 case 'chapters':
                     if (helpRequested) {
@@ -558,7 +763,13 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    listChapters(model, format);
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listChapters(modelId, format);
+                        console.log(output);
+                    }
+                    else {
+                        listChapters(model, format);
+                    }
                     break;
                 case 'aggregates':
                     if (helpRequested) {
@@ -582,7 +793,13 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    listAggregates(model, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.listAggregates(modelId, format);
+                        console.log(result);
+                    }
+                    else {
+                        listAggregates(model, format);
+                    }
                     break;
                 case 'actors':
                     if (helpRequested) {
@@ -605,11 +822,116 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listActors(modelId, format);
+                        console.log(output);
+                        break;
+                    }
                     listActors(model, format);
                     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);
+                    }
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listReadModels(modelId, format);
+                        console.log(output);
+                        break;
+                    }
+                    listReadModels(model, format);
+                    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);
+                    }
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listScreens(modelId, format);
+                        console.log(output);
+                        break;
+                    }
+                    listScreens(model, format);
+                    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);
+                    }
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listProcessors(modelId, format);
+                        console.log(output);
+                        break;
+                    }
+                    listProcessors(model, format);
+                    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);
+                    }
+                    if (isCloudMode) {
+                        const output = await cloudSlices.listScenarios(modelId, format);
+                        console.log(output);
+                        break;
+                    }
+                    listScenarios(model, format);
+                    break;
                 default:
                     console.error(`Unknown list target: ${subcommand}`);
-                    console.error('Valid targets: slices, events, commands, chapters, aggregates, actors');
+                    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);
             }
@@ -631,6 +953,11 @@ TYPES:
   model-completeness     Show completeness of all flows
   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)
@@ -677,7 +1004,13 @@ EXAMPLES:
                         console.error('Run "eventmodeler show slice --help" for more information.');
                         process.exit(1);
                     }
-                    showSlice(model, target, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showSlice(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showSlice(model, target, format);
+                    }
                     break;
                 case 'event':
                     if (helpRequested) {
@@ -719,7 +1052,13 @@ EXAMPLES:
                         console.error('Run "eventmodeler show event --help" for more information.');
                         process.exit(1);
                     }
-                    showEvent(model, target, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showEvent(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showEvent(model, target, format);
+                    }
                     break;
                 case 'command':
                     if (helpRequested) {
@@ -747,7 +1086,13 @@ EXAMPLES:
                         console.error('Run "eventmodeler show command --help" for more information.');
                         process.exit(1);
                     }
-                    showCommand(model, target, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showCommand(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showCommand(model, target, format);
+                    }
                     break;
                 case 'chapter':
                     if (helpRequested) {
@@ -776,7 +1121,13 @@ EXAMPLES:
                         console.error('Run "eventmodeler show chapter --help" for more information.');
                         process.exit(1);
                     }
-                    showChapter(model, target, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showChapter(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showChapter(model, target, format);
+                    }
                     break;
                 case 'completeness':
                     if (helpRequested) {
@@ -811,7 +1162,13 @@ EXAMPLES:
                         console.error('Run "eventmodeler show completeness --help" for more information.');
                         process.exit(1);
                     }
-                    showCompleteness(model, target, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showCompleteness(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showCompleteness(model, target, format);
+                    }
                     break;
                 case 'model-completeness':
                     if (helpRequested) {
@@ -834,7 +1191,13 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    showModelCompleteness(model, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showModelCompleteness(modelId, format);
+                        console.log(result);
+                    }
+                    else {
+                        showModelCompleteness(model, format);
+                    }
                     break;
                 case 'aggregate-completeness':
                     if (helpRequested) {
@@ -862,7 +1225,13 @@ EXAMPLES:
                         console.error('Run "eventmodeler show aggregate-completeness --help" for more information.');
                         process.exit(1);
                     }
-                    showAggregateCompleteness(model, target, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showAggregateCompleteness(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showAggregateCompleteness(model, target, format);
+                    }
                     break;
                 case 'actor':
                     if (helpRequested) {
@@ -890,11 +1259,196 @@ EXAMPLES:
                         console.error('Run "eventmodeler show actor --help" for more information.');
                         process.exit(1);
                     }
-                    showActor(model, target, format);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showActor(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showActor(model, target, format);
+                    }
+                    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);
+                    }
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showReadModel(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showReadModel(model, target, format);
+                    }
+                    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);
+                    }
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showScreen(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showScreen(model, target, format);
+                    }
+                    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);
+                    }
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showProcessor(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showProcessor(model, target, format);
+                    }
+                    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);
+                    }
+                    if (isCloudMode) {
+                        const result = await cloudSlices.showAggregate(modelId, target, format);
+                        console.log(result);
+                    }
+                    else {
+                        showAggregate(model, target, format);
+                    }
+                    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);
+                    }
+                    if (isCloudMode) {
+                        const result = await cloudSlices.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');
+                    console.error('Valid targets: slice, event, command, chapter, completeness, model-completeness, aggregate-completeness, actor, readmodel, screen, processor, aggregate, scenario');
                     console.error('Run "eventmodeler show --help" for more information.');
                     process.exit(1);
             }
@@ -935,7 +1489,24 @@ EXAMPLES:
                 console.error('Run "eventmodeler search --help" for more information.');
                 process.exit(1);
             }
-            search(model, subcommand, format);
+            if (isCloudMode) {
+                const response = await cloudSlices.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;');
+                    console.log(`<search-results query="${esc(subcommand)}" count="${response.results.length}">`);
+                    for (const r of response.results) {
+                        const tag = r.type === 'readmodel' ? 'read-model' : r.type;
+                        console.log(`  <${tag} name="${esc(r.name)}"/>`);
+                    }
+                    console.log('</search-results>');
+                }
+            }
+            else {
+                search(model, subcommand, format);
+            }
             break;
         case 'mark': {
             if (helpRequested) {
@@ -975,7 +1546,15 @@ EXAMPLES:
             }
             const sliceName = allArgs.slice(0, -1).join(' ');
             const status = lastArg;
-            markSliceStatus(model, filePath, sliceName, status);
+            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);
+            }
             break;
         }
         case 'summary':
@@ -1002,7 +1581,30 @@ EXAMPLES:
 `);
                 process.exit(0);
             }
-            showModelSummary(model, format);
+            if (isCloudMode) {
+                const summary = await cloudSlices.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>');
+                }
+            }
+            else {
+                showModelSummary(model, format);
+            }
             break;
         case 'export':
             if (helpRequested && !subcommand) {
@@ -1042,7 +1644,13 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    exportEventmodelToJson(model);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.exportJson(modelId);
+                        console.log(JSON.stringify(JSON.parse(result), null, 2));
+                    }
+                    else {
+                        exportEventmodelToJson(model);
+                    }
                     break;
                 default:
                     console.error(`Unknown export format: ${subcommand}`);
@@ -1134,7 +1742,98 @@ EXAMPLES:
                         console.error('Run "eventmodeler add scenario --help" for detailed format.');
                         process.exit(1);
                     }
-                    addScenario(model, filePath, sliceArg, inputData);
+                    if (isCloudMode) {
+                        // Parse scenario data
+                        let scenario;
+                        try {
+                            if (jsonArg) {
+                                const parsed = JSON.parse(inputData);
+                                scenario = {
+                                    name: parsed.name,
+                                    description: parsed.description,
+                                    given: parsed.given,
+                                    when: parsed.when,
+                                    then: parsed.then,
+                                };
+                            }
+                            else {
+                                // XML parsing - extract scenario attributes
+                                const nameMatch = inputData.match(/name="([^"]*)"/);
+                                const descMatch = inputData.match(/<description>([^<]*)<\/description>/);
+                                // Parse given events
+                                const givenMatch = inputData.match(/<given[^>]*type="events"[^>]*>([\s\S]*?)<\/given>/);
+                                let given;
+                                if (givenMatch) {
+                                    const eventMatches = givenMatch[1].match(/<event>([^<]*)<\/event>/g);
+                                    if (eventMatches) {
+                                        given = {
+                                            type: 'events',
+                                            events: eventMatches.map(m => m.replace(/<\/?event>/g, '')),
+                                        };
+                                    }
+                                }
+                                // Parse when
+                                const whenCommandMatch = inputData.match(/<when[^>]*type="command"[^>]*>[\s\S]*?<command>([^<]*)<\/command>[\s\S]*?<\/when>/);
+                                const whenEventsMatch = inputData.match(/<when[^>]*type="events"[^>]*>([\s\S]*?)<\/when>/);
+                                let when;
+                                if (whenCommandMatch) {
+                                    when = { type: 'command', command: whenCommandMatch[1] };
+                                }
+                                else if (whenEventsMatch) {
+                                    const eventMatches = whenEventsMatch[1].match(/<event>([^<]*)<\/event>/g);
+                                    if (eventMatches) {
+                                        when = {
+                                            type: 'events',
+                                            events: eventMatches.map(m => m.replace(/<\/?event>/g, '')),
+                                        };
+                                    }
+                                }
+                                // Parse then
+                                const thenEventsMatch = inputData.match(/<then[^>]*type="events"[^>]*>([\s\S]*?)<\/then>/);
+                                const thenErrorMatch = inputData.match(/<then[^>]*type="error"[^>]*>([\s\S]*?)<\/then>/);
+                                const thenCommandMatch = inputData.match(/<then[^>]*type="command"[^>]*>[\s\S]*?<command>([^<]*)<\/command>[\s\S]*?<\/then>/);
+                                let then;
+                                if (thenEventsMatch) {
+                                    const eventMatches = thenEventsMatch[1].match(/<event>([^<]*)<\/event>/g);
+                                    then = {
+                                        type: 'events',
+                                        events: eventMatches ? eventMatches.map(m => m.replace(/<\/?event>/g, '')) : [],
+                                    };
+                                }
+                                else if (thenErrorMatch) {
+                                    const msgMatch = thenErrorMatch[1].match(/<message>([^<]*)<\/message>/);
+                                    const typeMatch = thenErrorMatch[1].match(/<errorType>([^<]*)<\/errorType>/);
+                                    then = {
+                                        type: 'error',
+                                        errorMessage: msgMatch?.[1],
+                                        errorType: typeMatch?.[1],
+                                    };
+                                }
+                                else if (thenCommandMatch) {
+                                    then = { type: 'command', command: thenCommandMatch[1] };
+                                }
+                                else {
+                                    throw new Error('Could not parse <then> element');
+                                }
+                                scenario = {
+                                    name: nameMatch?.[1] ?? '',
+                                    description: descMatch?.[1],
+                                    given,
+                                    when,
+                                    then,
+                                };
+                            }
+                        }
+                        catch (err) {
+                            console.error(`Error parsing scenario data: ${err.message}`);
+                            process.exit(1);
+                        }
+                        await cloudSlices.createScenario(modelId, sliceArg, scenario);
+                        console.log(`Created scenario "${scenario.name}" in slice "${sliceArg}"`);
+                    }
+                    else {
+                        addScenario(model, filePath, sliceArg, inputData);
+                    }
                     break;
                 }
                 case 'field': {
@@ -1247,7 +1946,77 @@ EXAMPLES:
                         console.error('Run "eventmodeler add field --help" for detailed format documentation.');
                         process.exit(1);
                     }
-                    addField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, inputData);
+                    if (isCloudMode) {
+                        // Parse field data and determine element type
+                        let field;
+                        try {
+                            if (jsonArg) {
+                                const parsed = JSON.parse(inputData);
+                                field = {
+                                    name: parsed.name,
+                                    fieldType: parsed.type ?? parsed.fieldType ?? 'String',
+                                    isList: parsed.isList,
+                                    isOptional: parsed.isOptional,
+                                    isGenerated: parsed.isGenerated,
+                                    isUserInput: parsed.isUserInput,
+                                    subfields: parsed.subfields,
+                                };
+                            }
+                            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',
+                                };
+                            }
+                        }
+                        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);
+                    }
                     break;
                 }
                 default:
@@ -1293,14 +2062,28 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    const scenarioName = target;
                     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);
                     }
-                    removeScenario(model, filePath, scenarioName, sliceArg);
+                    if (isCloudMode) {
+                        await cloudSlices.removeScenario(modelId, scenarioName, sliceArg);
+                        console.log(`Removed scenario "${scenarioName}"${sliceArg ? ` from slice "${sliceArg}"` : ''}`);
+                    }
+                    else {
+                        removeScenario(model, filePath, scenarioName, sliceArg);
+                    }
                     break;
                 }
                 case 'field': {
@@ -1337,7 +2120,40 @@ EXAMPLES:
                         console.error('Run "eventmodeler remove field --help" for more information.');
                         process.exit(1);
                     }
-                    removeField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg);
+                    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}"`);
+                    }
+                    else {
+                        removeField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg);
+                    }
                     break;
                 }
                 default:
@@ -1416,7 +2232,43 @@ EXAMPLES:
                         console.error('Run "eventmodeler map fields --help" for detailed format.');
                         process.exit(1);
                     }
-                    mapFields(model, filePath, flowArg, inputData);
+                    if (isCloudMode) {
+                        // 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 {
+                                // 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] ?? '',
+                                    };
+                                });
+                            }
+                        }
+                        catch (err) {
+                            console.error(`Error parsing mappings: ${err.message}`);
+                            process.exit(1);
+                        }
+                        await cloudSlices.mapFields(modelId, sourceName, targetName, mappings);
+                        console.log(`Mapped ${mappings.length} field(s) from "${sourceName}" to "${targetName}"`);
+                    }
+                    else {
+                        mapFields(model, filePath, flowArg, inputData);
+                    }
                     break;
                 }
                 default:
@@ -1525,7 +2377,50 @@ EXAMPLES:
                         console.error('Run "eventmodeler update field --help" for available options.');
                         process.exit(1);
                     }
-                    updateField(model, filePath, { command: commandArg, event: eventArg, readModel: readModelArg, screen: screenArg, processor: processorArg }, fieldArg, updates);
+                    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 = {};
+                        if (updates.optional !== undefined)
+                            cloudUpdates.isOptional = updates.optional;
+                        if (updates.generated !== undefined)
+                            cloudUpdates.isGenerated = updates.generated;
+                        if (updates.userInput !== undefined)
+                            cloudUpdates.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);
+                    }
                     break;
                 }
                 default:
@@ -1638,7 +2533,31 @@ EXAMPLES:
                         console.error('Run "eventmodeler create state-change-slice --help" for detailed format.');
                         process.exit(1);
                     }
-                    createStateChangeSlice(model, filePath, xmlArg);
+                    if (isCloudMode) {
+                        // Parse XML input to extract structured data
+                        const parser = await import('./lib/slice-utils.js');
+                        const parsed = parser.parseStateChangeSliceXml(xmlArg);
+                        // Convert FieldInput to CompoundFieldInput (rename 'type' to 'fieldType')
+                        const convertFields = (fields) => fields.map(f => ({ ...f, fieldType: f.type, type: undefined }));
+                        const cloudInput = {
+                            sliceName: parsed.sliceName,
+                            after: parsed.after,
+                            before: parsed.before,
+                            screen: { name: parsed.screen.name, fields: convertFields(parsed.screen.fields) },
+                            command: { name: parsed.command.name, fields: convertFields(parsed.command.fields) },
+                            event: { name: parsed.event.name, fields: convertFields(parsed.event.fields) },
+                        };
+                        const result = await cloudSlices.createStateChangeSlice(modelId, cloudInput);
+                        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}`);
+                    }
+                    else {
+                        createStateChangeSlice(model, filePath, xmlArg);
+                    }
                     break;
                 }
                 case 'automation-slice': {
@@ -1719,6 +2638,10 @@ EXAMPLES:
                         console.error('Run "eventmodeler create automation-slice --help" for detailed format.');
                         process.exit(1);
                     }
+                    if (isCloudMode) {
+                        console.error('Error: create automation-slice is not yet supported in cloud mode.');
+                        process.exit(1);
+                    }
                     createAutomationSlice(model, filePath, xmlArg);
                     break;
                 }
@@ -1786,7 +2709,25 @@ EXAMPLES:
                         console.error('Run "eventmodeler create state-view-slice --help" for detailed format.');
                         process.exit(1);
                     }
-                    createStateViewSlice(model, filePath, xmlArg);
+                    if (isCloudMode) {
+                        // Parse XML input to extract structured data
+                        const parser = await import('./lib/slice-utils.js');
+                        const parsed = parser.parseStateViewSliceXml(xmlArg);
+                        // Convert FieldInput to CompoundFieldInput (rename 'type' to 'fieldType')
+                        const convertFields = (fields) => fields.map(f => ({ ...f, fieldType: f.type, type: undefined }));
+                        const cloudInput = {
+                            sliceName: parsed.sliceName,
+                            after: parsed.after,
+                            before: parsed.before,
+                            readModel: { name: parsed.readModel.name, fields: convertFields(parsed.readModel.fields) },
+                        };
+                        const result = await cloudSlices.createStateViewSlice(modelId, cloudInput);
+                        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': {
@@ -1821,7 +2762,13 @@ EXAMPLES:
                         console.error('Run "eventmodeler create flow --help" for more information.');
                         process.exit(1);
                     }
-                    createFlow(model, filePath, fromArg, toArg);
+                    if (isCloudMode) {
+                        await cloudSlices.createFlow(modelId, fromArg, toArg);
+                        console.log(`Created flow from "${fromArg}" to "${toArg}"`);
+                    }
+                    else {
+                        createFlow(model, filePath, fromArg, toArg);
+                    }
                     break;
                 }
                 default:
@@ -1884,7 +2831,13 @@ EXAMPLES:
                         console.error('Run "eventmodeler codegen slice --help" for more information.');
                         process.exit(1);
                     }
-                    codegenSlice(model, sliceName);
+                    if (isCloudMode) {
+                        const result = await cloudSlices.codegenSlice(modelId, sliceName);
+                        console.log(JSON.stringify(JSON.parse(result), null, 2));
+                    }
+                    else {
+                        codegenSlice(model, sliceName);
+                    }
                     break;
                 }
                 default: