eventmodeler 0.6.2 → 0.6.3

package/README.md

@@ -1,8 +1,6 @@
 # eventmodeler
 
-CLI tool for interacting with [Event Model](https://eventmodeling.org) files. Query, update, and export event models from the terminal.
-
-Works with `.eventmodel` files created by the [Event Modeling App](https://www.eventmodeling.app).
+Command line client for Event Modeler cloud models. Use it to inspect a model, place elements on the canvas, maintain fields and scenarios, and drive code generation loops from a terminal or agent.
 
 ## Installation
 
@@ -10,166 +8,298 @@ Works with `.eventmodel` files created by the [Event Modeling App](https://www.e
 npm install -g eventmodeler
 ```
 
-## Quick Start
-
-```bash
-# Open Event Modeling app in browser
-eventmodeler
+Requires Node.js 18 or newer.
 
-# List all slices
-eventmodeler list slices
+## Setup
 
-# Show details of a slice
-eventmodeler show slice "Place Order"
+```bash
+# Authenticate in the browser
+eventmodeler login
 
-# Search for elements
-eventmodeler search "order"
+# Create a cloud model, or use an existing model id from the app
+eventmodeler create model "Ordering"
 
-# Get JSON output instead of XML
-eventmodeler list slices --format json
+# Link the current repo/directory to a model
+eventmodeler init
 ```
 
-## Commands
+`eventmodeler init` writes `.eventmodeler.json` in your project. Most commands read the model id from that file. You can also target an element directly with the global `--id <uuid>` option when a command accepts an optional name.
 
-### List Commands
+Useful auth commands:
 
 ```bash
-eventmodeler list slices              # List all slices with status
-eventmodeler list events              # List all events
-eventmodeler list commands            # List all commands
-eventmodeler list chapters            # List all chapters
-eventmodeler list aggregates          # List all aggregates
-eventmodeler list actors              # List all actors
+eventmodeler whoami
+eventmodeler logout
 ```
 
-### Show Commands
+## Common Workflow
 
 ```bash
-eventmodeler show slice <name>        # Show detailed view of a slice
-eventmodeler show event <name>        # Show detailed view of an event
-eventmodeler show command <name>      # Show detailed view of a command
-eventmodeler show chapter <name>      # Show chapter with its slices
-eventmodeler show actor <name>        # Show actor with its screens
+# Explore the model
+eventmodeler show model
+eventmodeler list slices
+eventmodeler show slice "Place Order"
+eventmodeler search order
+
+# Build out the canvas
+eventmodeler create place command PlaceOrder --x 120 --y 200
+eventmodeler create place event OrderPlaced --x 120 --y 360
+eventmodeler create flow --from PlaceOrder --to OrderPlaced
+
+# Add fields
+eventmodeler add field PlaceOrder '{"name":"orderId","type":"UUID"}'
+eventmodeler add subfield PlaceOrder --field customer '{"name":"email","type":"String"}'
+
+# Create a scenario atomically
+eventmodeler create scenario --slice "Place Order" '{
+  "name": "happy path",
+  "when": [
+    {
+      "entryType": "command",
+      "elementName": "PlaceOrder",
+      "fieldValues": { "orderId": "uuid-1" }
+    }
+  ],
+  "then": [
+    {
+      "entryType": "event",
+      "elementName": "OrderPlaced",
+      "fieldValues": { "orderId": "uuid-1" }
+    }
+  ]
+}'
 ```
 
-### Completeness Commands
+## Read Commands
 
 ```bash
-eventmodeler show completeness <name>       # Show field mapping completeness for any element
-eventmodeler show model-completeness        # Show completeness of all flows in the model
-eventmodeler show aggregate-completeness <name>  # Check if events have the aggregate ID field
+eventmodeler show model
+eventmodeler show context [name]
+eventmodeler show chapter [name]
+eventmodeler show slice [name]
+eventmodeler show event [name]
+eventmodeler show command [name]
+eventmodeler show readmodel [name]
+eventmodeler show screen [name]
+eventmodeler show processor [name]
+eventmodeler show external-event [name]
+eventmodeler show completeness
+eventmodeler summary
+eventmodeler search <term>
 ```
 
-### Search
+List commands:
 
 ```bash
-eventmodeler search <term>            # Search for entities by name
+eventmodeler list slices [--chapter <name>]
+eventmodeler list events
+eventmodeler list commands
+eventmodeler list readmodels
+eventmodeler list screens
+eventmodeler list processors
+eventmodeler list external-events
+eventmodeler list aggregates
+eventmodeler list actors
+eventmodeler list chapters
+eventmodeler list contexts
+eventmodeler list swimlanes
+eventmodeler list notes
+eventmodeler list scenarios
 ```
 
-### Modify Commands
+Output is JSON from the backend SDK. Use `eventmodeler help <topic>` or command-specific `--help` for schema examples.
+
+## Canvas And Model Editing
+
+Create models, slices, elements, flows, and linked copies:
 
 ```bash
-# Mark slice status
-eventmodeler mark "Place Order" done
-eventmodeler mark "Cancel Order" in-progress
+eventmodeler create model <name>
+eventmodeler create slice '<json>'
+eventmodeler create place <type> <name> --x <n> --y <n>
+eventmodeler create flow --from <source> --to <target>
+eventmodeler create place-copy <type> [originalName] --x <n> --y <n>
+eventmodeler create move-copy <type> [name] --x <n> --y <n>
+eventmodeler create remove-copy <type> [name]
+```
 
-# Add scenario to a slice
-eventmodeler add scenario --slice "Place Order" --json '{"name": "Happy path", ...}'
+Element types for `create place`:
 
-# Add field to an entity
-eventmodeler add field --event "OrderPlaced" --json '{"name": "orderId", "type": "UUID"}'
+```text
+command, event, readmodel, screen, processor, external-event,
+aggregate, actor, chapter, context, note, swimlane, slice
+```
 
-# Remove field
-eventmodeler remove field --event "OrderPlaced" --field "legacyId"
+Linked copies are supported for:
 
-# Update field properties
-eventmodeler update field --read-model "OrderSummary" --field "notes" --optional true
+```text
+event, readmodel, screen, external-event
+```
 
-# Map fields between elements
-eventmodeler map fields --flow "OrderPlaced→OrderSummary" --json '[{"from": "total", "to": "totalAmount"}]'
+Move, resize, rename, and remove existing elements:
+
+```bash
+eventmodeler move <type> [name] --x <n> --y <n>
+eventmodeler resize <type> [name] --width <n> --height <n>
+eventmodeler rename <type> <oldName> <newName>
+eventmodeler remove <type> [name]
+eventmodeler remove flow --from <source> --to <target>
 ```
 
-### Export
+Mark slice status:
 
 ```bash
-eventmodeler summary                  # Show model summary statistics
-eventmodeler export json              # Export entire model as JSON
+eventmodeler mark "Place Order" planned
+eventmodeler mark "Place Order" created
+eventmodeler mark "Place Order" in-progress
+eventmodeler mark "Place Order" blocked
+eventmodeler mark "Place Order" done
 ```
 
-## Output Format
+## Fields
+
+Fields are supported on commands, events, readmodels, screens, processors, and external events.
+
+```bash
+eventmodeler add field [elementName] '{"name":"customerId","type":"UUID"}'
+eventmodeler add subfield [elementName] --field <parentFieldName> '{"name":"email","type":"String"}'
+
+eventmodeler update field [elementName] --field <name> --name <newName>
+eventmodeler update field [elementName] --field <name> --type <newType>
+eventmodeler update field [elementName] --field <name> --optional true
+eventmodeler update field [elementName] --field <name> --generated false
+eventmodeler update field [elementName] --field <name> --list true
+eventmodeler update field [elementName] --field <name> --user-input true
+
+eventmodeler update subfield [elementName] --subfield <id> --name <newName>
+eventmodeler update subfield [elementName] --subfield <id> --type <newType>
+eventmodeler update reorder [elementName] --field <name> --position <n>
+eventmodeler update reorder-subfield [elementName] --subfield <id> --position <n>
+
+eventmodeler remove field [elementName] --field <name>
+eventmodeler remove subfield [elementName] --subfield <id>
+eventmodeler set aggregate-id [aggregateName] --field-name <name> --field-type UUID
+```
 
-By default, output is in XML format (optimized for AI agents). Use `--format json` for JSON output:
+For field mappings:
 
 ```bash
-eventmodeler list slices --format json
-eventmodeler show slice "Place Order" --format json
+eventmodeler map fields '[{"source":"orderId","target":"orderId"}]' --from PlaceOrder --to OrderPlaced
+eventmodeler remove mapping --from PlaceOrder --to OrderPlaced --mapping <mappingId>
 ```
 
-### Setting Default Format
+## Scenarios
 
-Set your preferred default format via:
+Create a full Given/When/Then scenario in one backend transaction:
 
-**Environment variable:**
 ```bash
-export EVENTMODELER_FORMAT=json
+eventmodeler add scenario --slice "Place Order" '<scenario-json>'
+eventmodeler create scenario --slice "Place Order" '<scenario-json>'
 ```
 
-**Config file** (`~/.eventmodeler/config.json`):
+Scenario JSON shape:
+
 ```json
 {
-  "format": "json"
+  "name": "happy path",
+  "description": "optional",
+  "given": [
+    { "entryType": "event", "elementName": "OrderPlaced" }
+  ],
+  "when": [
+    { "entryType": "command", "elementName": "PlaceOrder" }
+  ],
+  "then": [
+    { "entryType": "event", "elementName": "OrderPlaced" },
+    { "entryType": "error", "errorType": "Validation", "errorMessage": "Invalid order" }
+  ]
 }
 ```
 
-Priority: CLI flag > environment variable > config file > default (xml)
-
-## Options
+Allowed entry types:
 
-```
--f, --file <path>       Path to .eventmodel file (default: auto-detect)
---format <xml|json>     Output format (default: xml)
--h, --help              Show help message
--v, --version           Show version number
+```text
+given: event, readmodel
+when:  command, event
+then:  event, command, readmodel, error
 ```
 
-## Use Cases
+Example values can be provided in the scenario JSON via `fieldValues`, or edited later:
+
+```bash
+eventmodeler add entry --scenario "happy path" --section then --type event --element OrderPlaced
+eventmodeler set example --scenario "happy path" --entry <entryId> --type event --field orderId --value uuid-1
+eventmodeler set example --scenario "happy path" --entry <entryId> --type event --field tags --values vip,web
+eventmodeler set example --scenario "happy path" --entry <entryId> --type event --field address --json '{"city":"NYC"}'
+eventmodeler set description --scenario "happy path" --text "Updated description"
+eventmodeler set position --scenario "happy path" --section then --entry <entryId> --position 0
+eventmodeler remove example --scenario "happy path" --entry <entryId> --type event --field orderId
+eventmodeler remove entry --scenario "happy path" --section then --entry <entryId>
+eventmodeler remove scenario "happy path"
+```
 
-### For AI Agents
+Primitive example values are strings. Custom fields use JSON objects, and Custom list fields use arrays of objects.
 
-The CLI is designed to work well with AI coding assistants. The XML output format provides structured, readable data that AI agents can easily parse and understand:
+## Screen And Note Details
 
 ```bash
-eventmodeler show slice "Place Order"
+eventmodeler design <screenName> '<excalidraw-json-array>'
+eventmodeler set note-description [noteName] --text "Markdown or plain text"
 ```
 
-### For Code Generators
+## Automation Loop
 
-Use JSON output to build code generators that read your event model:
+The CLI can poll planned slices and run your generator command for each one.
 
 ```bash
-eventmodeler list events --format json | your-codegen-tool
-eventmodeler show slice "Place Order" --format json
+eventmodeler init loop
+eventmodeler loop
 ```
 
-### For CI/CD
+`eventmodeler init loop` adds a `loop` block to `.eventmodeler.json` and creates a sample `generate.sh`. The generated script marks a slice in progress, exports slice JSON, runs your codegen placeholder, and marks the slice done or blocked.
 
-Check model completeness in your pipeline:
+## Configuration
 
-```bash
-eventmodeler show model-completeness --format json
+Global config lives at:
+
+```text
+~/.eventmodeler/config.json
+```
+
+Project config lives at:
+
+```text
+.eventmodeler.json
+```
+
+The production backend is used by default:
+
+```text
+https://api.eventmodeler.com
 ```
 
-## Requirements
+Override endpoints when developing locally:
 
-- Node.js >= 18.0.0
-- A `.eventmodel` file in the current directory (or specify with `-f`)
+```bash
+export EVENTMODELER_BACKEND_URL=http://localhost:8080
+export EVENTMODELER_KEYCLOAK_URL=http://localhost:18180/realms/eventmodeler
+```
+
+## Help Topics
 
-## License
+Task-oriented help is built into the CLI:
 
-MIT
+```bash
+eventmodeler help
+eventmodeler help build-slice
+eventmodeler help write-scenarios
+eventmodeler help manipulate-canvas
+eventmodeler help linked-copies
+eventmodeler help check-completeness
+eventmodeler guide json-reference
+```
 
 ## Links
 
-- [Event Modeling App](https://www.eventmodeling.app)
-- [Event Modeling](https://eventmodeling.org)
-- [GitHub Repository](https://github.com/theoema/event-modeler)
+- Event Modeling: https://eventmodeling.org
+- GitHub: https://github.com/theoema/event-modeler

package/dist/index.js

@@ -4114,6 +4114,9 @@ EXAMPLE:
 NOTES:
   - The JSON is a positional argument (not a --json flag)
   - Every element and flow needs a unique UUID
+  - Field and subfield UUIDs are generated when omitted
+  - Field flags such as isGenerated, isList, isOptional, and isUserInput are not
+    applied by create slice; add or update them after creation
   - Valid flow pairs: screen->command, command->event, command->external-event,
     event->readmodel, readmodel->screen, readmodel->processor, processor->command,
     external-event->processor
@@ -4322,10 +4325,10 @@ WHEN TO USE: You need to specify slice behavior as Given-When-Then test cases.
 ## Task: Add a full scenario to a slice (compound command)
 
 COMMAND:
-  eventmodeler add scenario '<json>' --slice <sliceName>
+  eventmodeler create scenario '<json>' --slice <sliceName>
 
 EXAMPLE (happy path — state-change slice):
-  eventmodeler add scenario '{
+  eventmodeler create scenario '{
     "name": "Successfully place order",
     "given": [
       {"entryType": "event", "elementName": "CustomerRegistered", "fieldValues": {"customerId": "cust-001"}}
@@ -4339,7 +4342,7 @@ EXAMPLE (happy path — state-change slice):
   }' --slice "Place Order"
 
 EXAMPLE (error case):
-  eventmodeler add scenario '{
+  eventmodeler create scenario '{
     "name": "Reject order with no items",
     "when": [
       {"entryType": "command", "elementName": "PlaceOrder", "fieldValues": {"customerId": "cust-001"}}
@@ -4350,7 +4353,7 @@ EXAMPLE (error case):
   }' --slice "Place Order"
 
 EXAMPLE (readmodel assertion in then):
-  eventmodeler add scenario '{
+  eventmodeler create scenario '{
     "name": "Order appears in summary",
     "given": [
       {"entryType": "event", "elementName": "OrderPlaced", "fieldValues": {"orderId": "ord-001", "customerId": "cust-001"}}
@@ -4815,11 +4818,9 @@ WHEN TO USE: You need the exact JSON shape for a CLI command.
 
   Field types: UUID, String, Int, Long, Double, Decimal, Boolean, Date, DateTime, Custom
 
-  Optional attributes (add to same JSON object):
-    "isOptional": true
-    "isGenerated": true
-    "isList": true
-    "isUserInput": true   (screens only)
+  Note: create slice generates field/subfield IDs when omitted. Field metadata
+  flags such as isOptional, isGenerated, isList, and isUserInput are not applied
+  by create slice; add or update those flags after creation.
 
   Custom type with subfields:
   {
@@ -4874,9 +4875,9 @@ WHEN TO USE: You need the exact JSON shape for a CLI command.
     { "source": "sourceFieldName", "target": "targetFieldName" }
   ]
 
-## add scenario '<json>' --slice <sliceName>
+## create scenario '<json>' --slice <sliceName>
 
-  eventmodeler add scenario '<json>' --slice "Place Order"
+  eventmodeler create scenario '<json>' --slice "Place Order"
 
   SCENARIO JSON:
   {
@@ -5455,6 +5456,65 @@ function registerListCommands(program) {
   }
 }
 
+// src/lib/scenario-field-values.ts
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function toFieldValueWire(value, path4 = "fieldValues") {
+  if (Array.isArray(value)) {
+    const allObjects = value.length > 0 && value.every(isPlainObject);
+    const anyObject = value.some(isPlainObject);
+    if (allObjects) {
+      return { treeList: value.map((item, i) => toFieldValueWire(item, `${path4}[${i}]`)) };
+    }
+    if (anyObject) {
+      throw new Error(`${path4}: list mixes primitives and objects; use either all scalar values or all objects.`);
+    }
+    return { list: value.map(String) };
+  }
+  if (isPlainObject(value)) {
+    return {
+      tree: Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toFieldValueWire(child, `${path4}.${key}`)]))
+    };
+  }
+  return { scalar: String(value) };
+}
+function toFieldValuesWire(values) {
+  if (!values)
+    return {};
+  return Object.fromEntries(Object.entries(values).map(([fieldName, value]) => [fieldName, toFieldValueWire(value, `fieldValues.${fieldName}`)]));
+}
+function unwrapFieldValueWire(value) {
+  if (!isPlainObject(value))
+    return value;
+  if ("scalar" in value)
+    return value.scalar;
+  if ("list" in value)
+    return value.list;
+  if ("tree" in value && isPlainObject(value.tree)) {
+    return Object.fromEntries(Object.entries(value.tree).map(([fieldName, child]) => [fieldName, unwrapFieldValueWire(child)]));
+  }
+  if ("treeList" in value && Array.isArray(value.treeList)) {
+    return value.treeList.map((item) => unwrapFieldValueWire(item));
+  }
+  return value;
+}
+function unwrapFieldValuesWire(values) {
+  if (!isPlainObject(values))
+    return values;
+  return Object.fromEntries(Object.entries(values).map(([fieldName, value]) => [fieldName, unwrapFieldValueWire(value)]));
+}
+function unwrapScenarioFieldValuesInResponse(value) {
+  if (Array.isArray(value))
+    return value.map(unwrapScenarioFieldValuesInResponse);
+  if (!isPlainObject(value))
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+    key,
+    key === "fieldValues" ? unwrapFieldValuesWire(child) : unwrapScenarioFieldValuesInResponse(child)
+  ]));
+}
+
 // src/commands/show-schemas.ts
 var FIELD_VIEW = `FieldView:
   {
@@ -5713,22 +5773,22 @@ function registerShowCommands(program) {
   const show = program.command("show").description("Show detailed information");
   show.command("model").description("Show full model hierarchy").addHelpText("after", SHOW_MODEL_HELP).action(async () => {
     const modelId = requireModelId();
-    out(unwrap(await showModel({ path: { modelId } })));
+    out(unwrapScenarioFieldValuesInResponse(unwrap(await showModel({ path: { modelId } }))));
   });
   show.command("context [name]").description("Show context with contained chapters and slices").addHelpText("after", SHOW_CONTEXT_HELP).action(async (name, cmd) => {
     const modelId = requireModelId();
     const contextId = await resolve2(modelId, "context", name ?? "", getGlobalId());
-    out(unwrap(await showContext({ path: { modelId, contextId } })));
+    out(unwrapScenarioFieldValuesInResponse(unwrap(await showContext({ path: { modelId, contextId } }))));
   });
   show.command("chapter [name]").description("Show chapter with contained slices").addHelpText("after", SHOW_CHAPTER_HELP).action(async (name, cmd) => {
     const modelId = requireModelId();
     const chapterId = await resolve2(modelId, "chapter", name ?? "", getGlobalId());
-    out(unwrap(await showChapter({ path: { modelId, chapterId } })));
+    out(unwrapScenarioFieldValuesInResponse(unwrap(await showChapter({ path: { modelId, chapterId } }))));
   });
   show.command("slice [name]").description("Show slice with all elements, flows, and scenarios").addHelpText("after", SHOW_SLICE_HELP).action(async (name, cmd) => {
     const modelId = requireModelId();
     const sliceId = await resolve2(modelId, "slice", name ?? "", getGlobalId());
-    out(unwrap(await showSlice({ path: { modelId, sliceId } })));
+    out(unwrapScenarioFieldValuesInResponse(unwrap(await showSlice({ path: { modelId, sliceId } }))));
   });
   for (const type of ["event", "command", "readmodel", "screen", "processor", "external-event"]) {
     show.command(`${type} [name]`).description(`Show ${type} detail with fields and flows`).addHelpText("after", SHOW_ELEMENT_HELP).action(async (name, cmd) => {
@@ -5817,7 +5877,7 @@ var ADD_SUBFIELD_MAP = {
   processor: addProcessorSubfield,
   "external-event": addExternalEventSubfield
 };
-function isPlainObject(v) {
+function isPlainObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var ENTRY_DISPATCH = {
@@ -5871,8 +5931,8 @@ async function addEntries(modelId, scenarioId, section, entries, positionOffset
       if (entry.fieldValues) {
         for (const [fieldName, value] of Object.entries(entry.fieldValues)) {
           if (Array.isArray(value)) {
-            const allObjects = value.length > 0 && value.every(isPlainObject);
-            const anyObject = value.some((v) => isPlainObject(v));
+            const allObjects = value.length > 0 && value.every(isPlainObject2);
+            const anyObject = value.some((v) => isPlainObject2(v));
             if (allObjects) {
               if (!info.setFieldCustomListValues)
                 throw new Error(`Cannot set Custom list values on ${entry.entryType}`);
@@ -5888,7 +5948,7 @@ async function addEntries(modelId, scenarioId, section, entries, positionOffset
                 body: { modelId, scenarioId, entryId, fieldName, values: value.map(String) }
               }));
             }
-          } else if (isPlainObject(value)) {
+          } else if (isPlainObject2(value)) {
             if (!info.setFieldCustomValue)
               throw new Error(`Cannot set Custom value on ${entry.entryType}`);
             unwrap(await info.setFieldCustomValue({
@@ -5906,6 +5966,60 @@ async function addEntries(modelId, scenarioId, section, entries, positionOffset
     }
   }
 }
+async function createScenarioFromJson(json, sliceName) {
+  const modelId = requireModelId();
+  const sliceId = await resolve2(modelId, "slice", sliceName, getGlobalId());
+  const spec = JSON.parse(json);
+  const scenarioId = randomUUID();
+  const buildEntries = async (section, entries) => {
+    if (!entries)
+      return [];
+    const dispatch = ENTRY_DISPATCH[section];
+    const out2 = [];
+    for (const entry of entries) {
+      const info = dispatch[entry.entryType];
+      if (!info) {
+        throw new Error(`Unknown ${section} entry type: ${entry.entryType}`);
+      }
+      if (entry.entryType === "error") {
+        out2.push({
+          entryType: "error",
+          errorType: entry.errorType ?? "",
+          errorMessage: entry.errorMessage ?? "",
+          fieldValues: {}
+        });
+      } else {
+        if (!entry.elementName) {
+          throw new Error(`${section} ${entry.entryType} entry is missing elementName`);
+        }
+        const elementId = await resolve2(modelId, info.resolveType, entry.elementName);
+        out2.push({
+          entryType: entry.entryType,
+          elementId,
+          fieldValues: toFieldValuesWire(entry.fieldValues)
+        });
+      }
+    }
+    return out2;
+  };
+  const given = await buildEntries("given", spec.given);
+  const when = await buildEntries("when", spec.when);
+  const then = await buildEntries("then", spec.then);
+  unwrap(await createScenario({
+    body: {
+      modelId,
+      sliceId,
+      scenarioId,
+      name: spec.name,
+      ...spec.description ? { description: spec.description } : {},
+      given,
+      when,
+      then
+    }
+  }));
+  const entryCount = given.length + when.length + then.length;
+  return { name: spec.name, entryCount };
+}
 function registerAddCommands(program) {
   const add = program.command("add").description("Add fields or scenarios");
   add.command("field [elementName] <json>").description("Add a field to an element").action(async (elementNameOrJson, jsonOrUndefined, cmd) => {
@@ -5998,7 +6112,7 @@ element name doesn't resolve, the whole spec is rejected before hitting the
 backend.
 
 Example (primitives + Custom + list):
-  add scenario --slice "Place Order" '{
+  create scenario --slice "Place Order" '{
     "name": "happy path",
     "when":  [{ "entryType": "command", "elementName": "PlaceOrder",
                 "fieldValues": { "orderId": "uuid-1",
@@ -6009,58 +6123,8 @@ Example (primitives + Custom + list):
                                             { "sku": "sku-2", "qty": "1" } ] } }]
   }'
 `).action(async (json, opts, cmd) => {
-    const modelId = requireModelId();
-    const sliceId = await resolve2(modelId, "slice", opts.slice, getGlobalId());
-    const spec = JSON.parse(json);
-    const scenarioId = randomUUID();
-    const buildEntries = async (section, entries) => {
-      if (!entries)
-        return [];
-      const dispatch = ENTRY_DISPATCH[section];
-      const out2 = [];
-      for (const entry of entries) {
-        const info = dispatch[entry.entryType];
-        if (!info) {
-          throw new Error(`Unknown ${section} entry type: ${entry.entryType}`);
-        }
-        if (entry.entryType === "error") {
-          out2.push({
-            entryType: "error",
-            errorType: entry.errorType ?? "",
-            errorMessage: entry.errorMessage ?? "",
-            fieldValues: {}
-          });
-        } else {
-          if (!entry.elementName) {
-            throw new Error(`${section} ${entry.entryType} entry is missing elementName`);
-          }
-          const elementId = await resolve2(modelId, info.resolveType, entry.elementName);
-          out2.push({
-            entryType: entry.entryType,
-            elementId,
-            fieldValues: entry.fieldValues ?? {}
-          });
-        }
-      }
-      return out2;
-    };
-    const given = await buildEntries("given", spec.given);
-    const when = await buildEntries("when", spec.when);
-    const then = await buildEntries("then", spec.then);
-    unwrap(await createScenario({
-      body: {
-        modelId,
-        sliceId,
-        scenarioId,
-        name: spec.name,
-        ...spec.description ? { description: spec.description } : {},
-        given,
-        when,
-        then
-      }
-    }));
-    const entryCount = given.length + when.length + then.length;
-    console.log(`Added scenario "${spec.name}"${entryCount > 0 ? ` with ${entryCount} entries` : ""}.`);
+    const result = await createScenarioFromJson(json, opts.slice);
+    console.log(`Created scenario "${result.name}"${result.entryCount > 0 ? ` with ${result.entryCount} entries` : ""}.`);
   });
   add.command("entry").description("Add a GWT entry to a scenario").requiredOption("--scenario <name>", "Scenario name").requiredOption("--section <section>", "Section: given, when, or then").requiredOption("--type <type>", "Entry type: event, command, readmodel, or error").option("--element <name>", "Element name (required unless --type error)").option("--error-type <type>", "Error type (for --type error)").option("--error-message <msg>", "Error message (for --type error)").option("--position <n>", "Position within section (appends at end by default)", parseInt).action(async (opts) => {
     const modelId = requireModelId();
@@ -6317,6 +6381,23 @@ function registerResizeCommands(program) {
 
 // src/commands/create.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
+function normalizeSliceFields(fields) {
+  return (fields ?? []).map((field) => ({
+    ...field,
+    id: field.id ?? randomUUID2(),
+    type: field.type ?? field.fieldType,
+    subfields: normalizeSliceFields(field.subfields)
+  }));
+}
+function normalizeSliceSpec(spec) {
+  return {
+    ...spec,
+    elements: (spec.elements ?? []).map((element) => ({
+      ...element,
+      fields: normalizeSliceFields(element.fields)
+    }))
+  };
+}
 var FLOW_DISPATCH = {
   "screen->command": { fn: specifyScreenToCommandFlow, sourceHandle: "bottom-source", targetHandle: "top-target" },
   "command->event": { fn: specifyCommandToEventFlow, sourceHandle: "bottom-source", targetHandle: "top-target" },
@@ -6372,9 +6453,14 @@ function registerCreateCommands(program) {
   create.command("slice <json>").description("Create a full slice from JSON specification").action(async (json) => {
     const modelId = requireModelId();
     const spec = JSON.parse(json);
-    unwrap(await createSlice({ body: { modelId, sliceId: randomUUID2(), ...spec } }));
+    const body = { modelId, sliceId: randomUUID2(), ...normalizeSliceSpec(spec) };
+    unwrap(await createSlice({ body }));
     console.log("Created slice.");
   });
+  create.command("scenario <json>").description("Atomically create a full Given/When/Then scenario").requiredOption("--slice <name>", "Slice name").action(async (json, opts) => {
+    const result = await createScenarioFromJson(json, opts.slice);
+    console.log(`Created scenario "${result.name}"${result.entryCount > 0 ? ` with ${result.entryCount} entries` : ""}.`);
+  });
   create.command("flow").description("Create a flow between two elements").requiredOption("--from <source>", "Source element name").requiredOption("--to <target>", "Target element name").option("--source-handle <handle>", "Source handle ID (default: auto based on flow type)").option("--target-handle <handle>", "Target handle ID (default: auto based on flow type)").action(async (opts) => {
     const modelId = requireModelId();
     const source = await resolveAnyElement(modelId, opts.from);

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "eventmodeler",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "CLI tool for event modeling - explore, design, and generate code from your event models",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theoema/event-modeler.git"
+  },
   "bin": {
     "eventmodeler": "./dist/index.js"
   },