eventmodeler 0.4.1 → 0.4.2

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

@@ -84,21 +84,40 @@ export declare function mapFields(modelId: string, sourceName: string, targetNam
 export interface ScenarioInput {
     name: string;
     description?: string;
-    given?: {
-        type: 'events';
-        events: string[];
-    };
+    given?: Array<{
+        event: string;
+        fieldValues?: Record<string, unknown>;
+    }>;
     when?: {
-        type: 'command' | 'events';
-        command?: string;
-        events?: string[];
+        command?: {
+            command: string;
+            fieldValues?: Record<string, unknown>;
+        };
+        events?: Array<{
+            event: string;
+            fieldValues?: Record<string, unknown>;
+        }>;
     };
     then: {
-        type: 'events' | 'error' | 'command';
-        events?: string[];
+        type: 'events' | 'error' | 'command' | 'readModelAssertion' | 'noCommand';
+        events?: Array<{
+            event: string;
+            fieldValues?: Record<string, unknown>;
+        }>;
         errorMessage?: string;
         errorType?: string;
-        command?: string;
+        command?: {
+            command: string;
+            fieldValues?: Record<string, unknown>;
+        };
+        readModelAssertion?: {
+            readModel: string;
+            givenEvents?: Array<{
+                event: string;
+                fieldValues?: Record<string, unknown>;
+            }>;
+            expectedFieldValues?: Record<string, unknown>;
+        };
     };
 }
 export declare function createScenario(modelId: string, sliceName: string, scenario: ScenarioInput): Promise<{
@@ -118,6 +137,7 @@ export interface CompoundFieldInput {
     isOptional?: boolean;
     isGenerated?: boolean;
     isUserInput?: boolean;
+    subfields?: CompoundFieldInput[];
 }
 export interface StateChangeSliceInput {
     sliceName: string;
@@ -200,6 +220,40 @@ export declare function showChapter(modelId: string, chapterName: string, format
 export declare function showActor(modelId: string, actorName: string, format?: OutputFormat): Promise<string>;
 export declare function exportJson(modelId: string): Promise<string>;
 export declare function codegenSlice(modelId: string, sliceName: string): Promise<string>;
+export interface CodegenChapterEventsField {
+    name: string;
+    type: string;
+    list?: boolean;
+    generated?: boolean;
+    optional?: boolean;
+    userInput?: boolean;
+    subfields?: CodegenChapterEventsField[];
+}
+export interface CodegenChapterEventsChapter {
+    id: string;
+    name: string;
+    parent?: CodegenChapterEventsChapter | null;
+}
+export interface CodegenChapterEventsSlice {
+    id: string;
+    name: string;
+    sliceType: string;
+}
+export interface CodegenChapterEventsEvent {
+    id: string;
+    name: string;
+    fields: CodegenChapterEventsField[];
+    aggregate?: string;
+    sourceSlices: string[];
+}
+export interface CodegenChapterEventsResponse {
+    chapter: CodegenChapterEventsChapter | null;
+    sliceCount: number;
+    eventCount: number;
+    slices: CodegenChapterEventsSlice[];
+    events: CodegenChapterEventsEvent[];
+}
+export declare function codegenEvents(modelId: string, chapterName?: string): Promise<CodegenChapterEventsResponse>;
 export declare function listAggregates(modelId: string, format?: OutputFormat): Promise<string>;
 export declare function listReadModels(modelId: string, format?: OutputFormat): Promise<string>;
 export declare function listScreens(modelId: string, format?: OutputFormat): Promise<string>;

package/dist/cloud/slices/index.js

@@ -37,13 +37,13 @@ async function handleHttpError(response, path) {
 async function cliGet(path, params) {
     const backendUrl = getBackendUrl();
     const accessToken = await getValidAccessToken();
-    const url = new URL(`${backendUrl}${path}`);
-    for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined) {
-            url.searchParams.set(key, value);
-        }
-    }
-    const response = await fetch(url.toString(), {
+    // Build query string manually using encodeURIComponent (uses %20 for spaces, not +)
+    const queryParts = Object.entries(params)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    const queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
+    const fullUrl = `${backendUrl}${path}${queryString}`;
+    const response = await fetch(fullUrl, {
         method: 'GET',
         headers: {
             Accept: 'application/json',
@@ -166,13 +166,14 @@ function formatToMediaType(format) {
 async function cliGetText(path, params, format) {
     const backendUrl = getBackendUrl();
     const accessToken = await getValidAccessToken();
-    const url = new URL(`${backendUrl}${path}`);
-    for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined) {
-            url.searchParams.set(key, value);
-        }
-    }
-    const response = await fetch(url.toString(), {
+    // Build query string manually using encodeURIComponent (uses %20 for spaces, not +)
+    // Some servers don't decode + as space in query parameters
+    const queryParts = Object.entries(params)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    const queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
+    const fullUrl = `${backendUrl}${path}${queryString}`;
+    const response = await fetch(fullUrl, {
         method: 'GET',
         headers: {
             Accept: formatToMediaType(format),
@@ -206,6 +207,106 @@ export async function exportJson(modelId) {
 export async function codegenSlice(modelId, sliceName) {
     return cliGetText('/cli/codegen-slice', { modelId, name: sliceName });
 }
+function countFieldsDeep(fields) {
+    if (!fields || fields.length === 0) {
+        return 0;
+    }
+    return fields.reduce((count, field) => count + 1 + countFieldsDeep(field.subfields), 0);
+}
+function normalizeName(name) {
+    return (name ?? '').trim().toLowerCase();
+}
+export async function codegenEvents(modelId, chapterName) {
+    const slicesOutput = await listSlices(modelId, 'json', chapterName);
+    let slicesPayload;
+    try {
+        slicesPayload = JSON.parse(slicesOutput);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON from /cli/list-slices: ${message}`);
+    }
+    const slices = (slicesPayload.slices ?? [])
+        .filter((slice) => typeof slice.id === 'string' && typeof slice.name === 'string');
+    if (slices.length === 0) {
+        return {
+            chapter: null,
+            sliceCount: 0,
+            eventCount: 0,
+            slices: [],
+            events: [],
+        };
+    }
+    const codegenOutputs = await Promise.all(slices.map(async (slice) => {
+        const raw = await codegenSlice(modelId, slice.name);
+        try {
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid JSON from /cli/codegen-slice for "${slice.name}": ${message}`);
+        }
+    }));
+    const aggregatedSlices = [];
+    const eventsByName = new Map();
+    let chapter = null;
+    for (let i = 0; i < codegenOutputs.length; i++) {
+        const codegenOutput = codegenOutputs[i];
+        const fallbackSlice = slices[i];
+        const sliceName = codegenOutput.slice?.name ?? fallbackSlice.name;
+        aggregatedSlices.push({
+            id: codegenOutput.slice?.id ?? fallbackSlice.id,
+            name: sliceName,
+            sliceType: codegenOutput.sliceType ?? 'STATE_CHANGE',
+        });
+        if (chapterName && !chapter && codegenOutput.chapter) {
+            chapter = codegenOutput.chapter;
+        }
+        for (const event of codegenOutput.elements?.events ?? []) {
+            if (!event.name) {
+                continue;
+            }
+            const key = normalizeName(event.name);
+            if (!key) {
+                continue;
+            }
+            const existing = eventsByName.get(key);
+            if (!existing) {
+                eventsByName.set(key, {
+                    id: event.id ?? '',
+                    name: event.name,
+                    fields: event.fields ?? [],
+                    aggregate: event.aggregate,
+                    sourceSlices: [sliceName],
+                });
+                continue;
+            }
+            if (!existing.sourceSlices.includes(sliceName)) {
+                existing.sourceSlices.push(sliceName);
+            }
+            if (!existing.aggregate && event.aggregate) {
+                existing.aggregate = event.aggregate;
+            }
+            if (countFieldsDeep(event.fields) > countFieldsDeep(existing.fields)) {
+                existing.fields = event.fields ?? [];
+            }
+            if (!existing.id && event.id) {
+                existing.id = event.id;
+            }
+        }
+    }
+    const events = [...eventsByName.values()]
+        .map(event => ({ ...event, sourceSlices: [...event.sourceSlices].sort((a, b) => a.localeCompare(b)) }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const sortedSlices = [...aggregatedSlices].sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        chapter,
+        sliceCount: sortedSlices.length,
+        eventCount: events.length,
+        slices: sortedSlices,
+        events,
+    };
+}
 export async function listAggregates(modelId, format = 'xml') {
     return cliGetText('/cli/list-aggregates', { modelId }, format);
 }

package/dist/index.js

@@ -22,7 +22,7 @@ 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 } from './slices/add-scenario/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';
@@ -45,6 +45,7 @@ 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';
@@ -69,6 +70,17 @@ function getNamedArg(argList, ...names) {
 function hasHelpFlag(argList) {
     return argList.includes('-h') || argList.includes('--help');
 }
+function toCompoundFields(fields) {
+    return fields.map(field => ({
+        name: field.name,
+        fieldType: field.type,
+        isList: field.isList,
+        isOptional: field.isOptional,
+        isGenerated: field.isGenerated,
+        isUserInput: field.isUserInput,
+        subfields: field.subfields ? toCompoundFields(field.subfields) : undefined,
+    }));
+}
 function printHelp() {
     console.log(`
 eventmodeler - CLI tool for interacting with Event Model files
@@ -145,6 +157,8 @@ COMMANDS:
                                  Create a flow between elements (Event→ReadModel, ReadModel→Screen/Processor)
 
   codegen slice <name>           Generate code-ready JSON for a slice (includes dependencies, mappings, scenarios)
+  codegen events [--chapter <name>]
+                                 Generate deduplicated events for a chapter or the whole model
 
   summary                        Show model summary statistics
 
@@ -1743,91 +1757,49 @@ EXAMPLES:
                         process.exit(1);
                     }
                     if (isCloudMode) {
-                        // Parse scenario data
-                        let scenario;
+                        let parsedScenario;
                         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,
-                                };
-                            }
+                            parsedScenario = parseScenarioInput(inputData);
                         }
                         catch (err) {
                             console.error(`Error parsing scenario data: ${err.message}`);
                             process.exit(1);
                         }
+                        const scenario = {
+                            name: parsedScenario.name,
+                            description: parsedScenario.description,
+                            given: parsedScenario.given,
+                            when: parsedScenario.when
+                                ? {
+                                    command: parsedScenario.when.command
+                                        ? {
+                                            command: parsedScenario.when.command,
+                                            fieldValues: parsedScenario.when.commandFieldValues,
+                                        }
+                                        : undefined,
+                                    events: parsedScenario.when.events,
+                                }
+                                : undefined,
+                            then: {
+                                type: parsedScenario.then.type,
+                                events: parsedScenario.then.events,
+                                errorMessage: parsedScenario.then.errorMessage,
+                                errorType: parsedScenario.then.errorType,
+                                command: parsedScenario.then.command
+                                    ? {
+                                        command: parsedScenario.then.command,
+                                        fieldValues: parsedScenario.then.commandFieldValues,
+                                    }
+                                    : undefined,
+                                readModelAssertion: parsedScenario.then.readModel
+                                    ? {
+                                        readModel: parsedScenario.then.readModel,
+                                        givenEvents: parsedScenario.then.givenEvents,
+                                        expectedFieldValues: parsedScenario.then.expected,
+                                    }
+                                    : undefined,
+                            },
+                        };
                         await cloudSlices.createScenario(modelId, sliceArg, scenario);
                         console.log(`Created scenario "${scenario.name}" in slice "${sliceArg}"`);
                     }
@@ -2537,15 +2509,13 @@ EXAMPLES:
                         // 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) },
+                            screen: { name: parsed.screen.name, fields: toCompoundFields(parsed.screen.fields) },
+                            command: { name: parsed.command.name, fields: toCompoundFields(parsed.command.fields) },
+                            event: { name: parsed.event.name, fields: toCompoundFields(parsed.event.fields) },
                         };
                         const result = await cloudSlices.createStateChangeSlice(modelId, cloudInput);
                         console.log(`Created state-change slice "${parsed.sliceName}"`);
@@ -2639,10 +2609,30 @@ EXAMPLES:
                         process.exit(1);
                     }
                     if (isCloudMode) {
-                        console.error('Error: create automation-slice is not yet supported in cloud mode.');
-                        process.exit(1);
+                        // Parse XML input to extract structured data
+                        const parser = await import('./lib/slice-utils.js');
+                        const parsed = parser.parseAutomationSliceXml(xmlArg);
+                        const cloudInput = {
+                            sliceName: parsed.sliceName,
+                            after: parsed.after,
+                            before: parsed.before,
+                            readModel: { name: parsed.readModel.name, fields: toCompoundFields(parsed.readModel.fields) },
+                            processor: { name: parsed.processor.name },
+                            command: { name: parsed.command.name, fields: toCompoundFields(parsed.command.fields) },
+                            event: { name: parsed.event.name, fields: toCompoundFields(parsed.event.fields) },
+                        };
+                        const result = await cloudSlices.createAutomationSlice(modelId, cloudInput);
+                        console.log(`Created automation slice "${parsed.sliceName}"`);
+                        console.log(`  ReadModel: ${parsed.readModel.name} (${parsed.readModel.fields.length} fields)`);
+                        console.log(`  Processor: ${parsed.processor.name}`);
+                        console.log(`  Command: ${parsed.command.name} (${parsed.command.fields.length} fields)`);
+                        console.log(`  Event: ${parsed.event.name} (${parsed.event.fields.length} fields)`);
+                        console.log(`  ReadModel -> Command mappings: ${result.readModelToCommandMappings}`);
+                        console.log(`  Command -> Event mappings: ${result.commandToEventMappings}`);
+                    }
+                    else {
+                        createAutomationSlice(model, filePath, xmlArg);
                     }
-                    createAutomationSlice(model, filePath, xmlArg);
                     break;
                 }
                 case 'state-view-slice': {
@@ -2713,13 +2703,11 @@ EXAMPLES:
                         // 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) },
+                            readModel: { name: parsed.readModel.name, fields: toCompoundFields(parsed.readModel.fields) },
                         };
                         const result = await cloudSlices.createStateViewSlice(modelId, cloudInput);
                         console.log(`Created state-view slice "${parsed.sliceName}"`);
@@ -2787,9 +2775,10 @@ USAGE:
   eventmodeler codegen <type> [options]
 
 TYPES:
-  slice   Generate comprehensive JSON for a slice
+  slice           Generate comprehensive JSON for a slice
+  events          Generate deduplicated events for a chapter or entire model
 
-Run "eventmodeler codegen slice --help" for detailed help.
+Run "eventmodeler codegen <type> --help" for detailed help.
 `);
                 process.exit(0);
             }
@@ -2824,7 +2813,7 @@ EXAMPLES:
 `);
                         process.exit(0);
                     }
-                    const sliceName = filteredArgs[2];
+                    const sliceName = target;
                     if (!sliceName) {
                         console.error('Error: slice name is required');
                         console.error('Usage: eventmodeler codegen slice <name>');
@@ -2840,9 +2829,47 @@ EXAMPLES:
                     }
                     break;
                 }
+                case 'events': {
+                    if (helpRequested) {
+                        console.log(`
+eventmodeler codegen events - Generate deduplicated events for scaffolding
+
+USAGE:
+  eventmodeler codegen events [--chapter <chapter-name>]
+  eventmodeler codegen events <chapter-name>
+
+ARGUMENTS:
+  <chapter-name>   Optional chapter name (if omitted, all model events are returned)
+
+OUTPUT:
+  JSON payload including:
+  - chapter hierarchy metadata (when chapter-scoped)
+  - all relevant slices
+  - deduplicated events across those slices
+  - sourceSlices per event (where each event appears)
+
+This is designed for event scaffolding flows (e.g. events.kt generation).
+
+EXAMPLES:
+  eventmodeler codegen events --chapter "Register Products"
+  eventmodeler codegen events "Register Products"
+  eventmodeler codegen events > model-events.json
+`);
+                        process.exit(0);
+                    }
+                    const chapterName = chapterArg ?? target;
+                    if (isCloudMode) {
+                        const output = await cloudSlices.codegenEvents(modelId, chapterName);
+                        console.log(JSON.stringify(output, null, 2));
+                    }
+                    else {
+                        codegenEvents(model, chapterName);
+                    }
+                    break;
+                }
                 default:
                     console.error(`Unknown codegen target: ${subcommand}`);
-                    console.error('Valid targets: slice');
+                    console.error('Valid targets: slice, events');
                     console.error('Run "eventmodeler codegen --help" for more information.');
                     process.exit(1);
             }

package/dist/lib/auth.js

@@ -130,7 +130,6 @@ export async function startAuthFlow() {
             });
             const authorizationUrl = `${keycloakUrl}/protocol/openid-connect/auth?${params}`;
             console.log('\nOpening browser for authentication...');
-            console.log(`\nIf the browser doesn't open, visit:\n${authorizationUrl}\n`);
             // Open the browser
             openBrowser(authorizationUrl);
         });

package/dist/lib/backend.d.ts

@@ -1,5 +1,4 @@
 import type { EventModel } from '../types.js';
-import { type CloudClient } from './cloud-client.js';
 import { type ProjectConfig } from './project-config.js';
 /**
  * Backend abstraction for CLI operations.
@@ -21,10 +20,6 @@ export interface CliBackend {
  * Create a local file-based backend.
  */
 export declare function createLocalBackend(filePath: string): CliBackend;
-/**
- * Create a cloud backend using the Axon backend.
- */
-export declare function createCloudBackendFromClient(client: CloudClient, modelId: string, modelName: string): CliBackend;
 export interface ResolveBackendOptions {
     /** Explicit file path (overrides auto-detection) */
     filePath?: string;

package/dist/lib/backend.js

@@ -1,8 +1,6 @@
 import { loadModel, appendEvent as appendEventToFile } from './file-loader.js';
-import { createCloudClient } from './cloud-client.js';
 import { loadProjectConfig } from './project-config.js';
 import { findEventModelFile } from './file-loader.js';
-import { isAuthenticated } from './config.js';
 /**
  * Create a local file-based backend.
  */
@@ -26,32 +24,6 @@ export function createLocalBackend(filePath) {
         },
     };
 }
-/**
- * Create a cloud backend using the Axon backend.
- */
-export function createCloudBackendFromClient(client, modelId, modelName) {
-    return {
-        async getModel() {
-            const model = await client.getModel(modelId);
-            if (!model) {
-                throw new Error(`Event model not found: ${modelId}`);
-            }
-            return model;
-        },
-        async dispatch(command) {
-            const result = await client.dispatch(modelId, command);
-            if (!result.success) {
-                throw new Error('Command dispatch failed');
-            }
-        },
-        isCloud() {
-            return true;
-        },
-        getModelIdentifier() {
-            return `${modelName} (${modelId})`;
-        },
-    };
-}
 /**
  * Resolve which backend to use based on:
  * 1. Explicit -f <file> flag
@@ -70,11 +42,9 @@ export async function resolveBackend(options = {}) {
             return createLocalBackend(projectConfig.file);
         }
         if (projectConfig.type === 'cloud') {
-            if (!isAuthenticated()) {
-                throw new Error('Not authenticated. Run "eventmodeler login" first.');
-            }
-            const client = await createCloudClient();
-            return createCloudBackendFromClient(client, projectConfig.modelId, projectConfig.modelName);
+            // Cloud mode uses cloud slices directly, not the CliBackend abstraction
+            throw new Error('Cloud mode detected but CliBackend abstraction is not supported for cloud.\n' +
+                'Use cloud slices directly for cloud operations.');
         }
     }
     // 3. Legacy: look for .eventmodel file in current directory

package/dist/lib/cloud-client.d.ts

@@ -1,4 +1,4 @@
-import type { EventModel, RawEvent } from '../types.js';
+import type { RawEvent } from '../types.js';
 export interface ImportResult {
     success: boolean;
     modelId: string;
@@ -6,7 +6,6 @@ export interface ImportResult {
 }
 export interface CloudClient {
     listModels(): Promise<CloudModelInfo[]>;
-    getModel(modelId: string): Promise<EventModel | null>;
     dispatch(modelId: string, command: unknown): Promise<{
         success: boolean;
         events: unknown[];