eventmodeler 0.6.0 → 0.6.2

package/dist/slices/help/topics/json-reference.js

@@ -1,188 +0,0 @@
-export const meta = {
-    name: 'json-reference',
-    keywords: ['json', 'shape', 'schema', 'reference', 'format', 'payload', 'body', 'all', 'commands', 'cheatsheet', 'syntax'],
-    description: 'All JSON shapes for every CLI command in one place',
-};
-export const content = `
-# JSON Reference
-
-WHEN TO USE: You need the exact JSON shape for a CLI command.
-
-## create slice '<json>'
-
-  eventmodeler create slice '<json>'
-
-  {
-    "sliceName": "Name",
-    "elements": [
-      {
-        "id": "<uuid>",
-        "type": "screen | command | event | readmodel | processor | external-event",
-        "name": "ElementName",
-        "fields": [
-          { "name": "fieldName", "type": "String" }
-        ]
-      }
-    ],
-    "flows": [
-      { "id": "<uuid>", "from": "SourceName", "to": "TargetName" }
-    ]
-  }
-
-## add field [elementName] '<json>'
-
-  eventmodeler add field "ElementName" '{"name": "fieldName", "type": "String"}'
-  eventmodeler --id <uuid> add field '{"name": "fieldName", "type": "String"}'
-
-  FIELD JSON: { "name": "fieldName", "type": "String" }
-
-  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)
-
-  Custom type with subfields:
-  {
-    "name": "address",
-    "type": "Custom",
-    "subfields": [
-      { "name": "street", "type": "String" },
-      { "name": "city", "type": "String" }
-    ]
-  }
-
-  List of custom objects:
-  {
-    "name": "lineItems",
-    "type": "Custom",
-    "isList": true,
-    "subfields": [
-      { "name": "productId", "type": "UUID" },
-      { "name": "quantity", "type": "Int" }
-    ]
-  }
-
-## add subfield [elementName] '<json>' --field <parentFieldName>
-
-  eventmodeler add subfield "ElementName" '{"name": "zip", "type": "String"}' --field "address"
-
-  SUBFIELD JSON: { "name": "subfieldName", "type": "String" }
-
-## update field [elementName] --field <name> [--name <new>] [--type <new>] [--optional true|false] [--generated true|false] [--list true|false] [--user-input true|false]
-
-  eventmodeler update field "OrderPlaced" --field "total" --type Decimal
-  eventmodeler update field "OrderPlaced" --field "promoCode" --optional true
-  eventmodeler update field "Checkout" --field "email" --user-input true
-
-  No JSON — uses flags directly.
-
-## update subfield [elementName] --subfield <id> [--name <new>] [--type <new>]
-
-  eventmodeler update subfield "OrderPlaced" --subfield <subfieldId> --name "zipCode"
-
-  No JSON — uses flags directly. Subfield ID from show output.
-
-## update reorder [elementName] --field <name> --position <n>
-
-  eventmodeler update reorder "OrderPlaced" --field "orderId" --position 0
-
-## map fields '<json>' --from <source> --to <target>
-
-  eventmodeler map fields '[{"source": "orderId", "target": "orderId"}]' --from "OrderPlaced" --to "OrderSummary"
-
-  MAPPINGS JSON: [
-    { "source": "sourceFieldName", "target": "targetFieldName" }
-  ]
-
-## add scenario '<json>' --slice <sliceName>
-
-  eventmodeler add scenario '<json>' --slice "Place Order"
-
-  SCENARIO JSON:
-  {
-    "name": "Scenario name",
-    "description": "Optional description",
-    "given": [
-      { "entryType": "event", "elementName": "EventName", "fieldValues": { "field": "value" } },
-      { "entryType": "readmodel", "elementName": "ReadModelName", "fieldValues": { "field": "value" } }
-    ],
-    "when": [
-      { "entryType": "command", "elementName": "CommandName", "fieldValues": { "field": "value" } },
-      { "entryType": "event", "elementName": "EventName", "fieldValues": { "field": "value" } }
-    ],
-    "then": [
-      { "entryType": "event", "elementName": "EventName", "fieldValues": { "field": "value" } },
-      { "entryType": "command", "elementName": "CommandName", "fieldValues": { "field": "value" } },
-      { "entryType": "readmodel", "elementName": "ReadModelName", "fieldValues": { "field": "value" } },
-      { "entryType": "error", "errorType": "ErrorType", "errorMessage": "Error description" }
-    ]
-  }
-
-  given/when/then are all optional — omit sections you don't need.
-  Given entry types: event, readmodel
-  When entry types: command, event
-  Then entry types: event, command, readmodel, error
-
-  fieldValues holds both scalar and list values. Pass an array for fields marked
-  isList=true; a string otherwise:
-    { "entryType": "command", "elementName": "PlaceBulkOrder",
-      "fieldValues": { "customerId": "cust-001", "productIds": ["p-1", "p-2"], "tags": ["urgent"] } }
-
-## create flow --from <source> --to <target>
-
-  eventmodeler create flow --from "PlaceOrder" --to "OrderPlaced"
-
-  No JSON. Valid flow pairs:
-    screen       -> command
-    command      -> event
-    command      -> external-event
-    event        -> readmodel
-    readmodel    -> screen
-    readmodel    -> processor
-    processor    -> command
-    external-event -> processor
-
-## create place <type> <name> --x <n> --y <n>
-
-  eventmodeler create place command "PlaceOrder" --x 2040 --y 460
-  eventmodeler create place slice "Place Order" --x 2000 --y 80
-
-  No JSON. Types: command, event, readmodel, screen, processor, external-event,
-                  aggregate, actor, chapter, context, note, swimlane, slice
-
-## create place-copy <type> [originalName] --x <n> --y <n>
-
-  eventmodeler create place-copy event "OrderPlaced" --x 3000 --y 860
-  eventmodeler --id <original-uuid> create place-copy event --x 3000 --y 860
-
-  No JSON. Types: event, readmodel, screen, external-event
-
-## The --id Flag
-
-  All name-based commands accept --id <uuid> as a GLOBAL flag (before the command):
-    eventmodeler --id <uuid> show event
-    eventmodeler --id <uuid> add field '{"name": "f", "type": "String"}'
-    eventmodeler --id <uuid> move event --x 100 --y 860
-    eventmodeler --id <uuid> remove event
-    eventmodeler --id <uuid> create place-copy event --x 3000 --y 860
-
-  Essential for linked copies which share names with originals.
-
-## Canvas Coordinates
-
-  Y Bands:
-    screen / processor:      y = 120
-    command / readmodel:     y = 460
-    event / external-event:  y = 860
-
-  Element dimensions are fixed by the CLI (not configurable):
-    command / event / readmodel / external-event:  160 x 100
-    screen:                                        180 x 120
-    processor:                                     120 x 120
-    slice / aggregate / actor / context / swimlane: 300 x 200
-    chapter: 800 x 1200, note: 200 x 150
-  X spacing between stickies: 200
-`;

package/dist/slices/help/topics/linked-copies.js

@@ -1,89 +0,0 @@
-export const meta = {
-    name: 'linked-copies',
-    keywords: ['linked', 'copy', 'cross-slice', 'duplicate', 'reuse', 'shared', 'proxy', 'event', 'readmodel', 'screen', 'external-event', 'place-copy', 'move-copy', 'remove-copy', 'original'],
-    description: 'Create and work with cross-slice linked copies of elements',
-};
-export const content = `
-# Linked Copies
-
-WHEN TO USE: You need the same element to appear in multiple slices (e.g., an event produced in one slice consumed in another).
-
-## What are Linked Copies?
-
-A linked copy is a visual reference to an element that lives in another slice. The copy shares the original's name and fields but has its own UUID and position on the canvas. Changes to the original's fields propagate to all copies.
-
-LINKABLE TYPES:
-  event, readmodel, screen, external-event
-
-NON-LINKABLE (always unique to their slice):
-  command, processor
-
-## Task: Create a linked copy
-
-COMMAND:
-  eventmodeler create place-copy <type> [originalName] --x <n> --y <n> [--width <n>] [--height <n>]
-
-EXAMPLES:
-  eventmodeler create place-copy event "OrderPlaced" --x 3000 --y 860
-  eventmodeler create place-copy readmodel "OrderSummary" --x 3000 --y 460
-  eventmodeler create place-copy event --id <original-uuid> --x 3000 --y 860
-
-NOTES:
-  - The copy gets a new UUID but references the original
-  - Place the copy in the correct Y band for its type (see "help manipulate-canvas")
-  - Use --id when multiple elements share the same name
-
-## Task: Move a linked copy
-
-COMMAND:
-  eventmodeler create move-copy <type> [name] --x <n> --y <n>
-
-EXAMPLES:
-  eventmodeler create move-copy event --id <copy-uuid> --x 3200 --y 860
-
-NOTES:
-  - Use --id to target the specific copy (copies share names with their original)
-
-## Task: Remove a linked copy
-
-COMMAND:
-  eventmodeler create remove-copy <type> [name]
-
-EXAMPLES:
-  eventmodeler create remove-copy event --id <copy-uuid>
-
-NOTES:
-  - Removing a copy does NOT remove the original
-  - Use --id — name resolution may hit the original instead of the copy
-
-## Task: Identify copies in output
-
-The list and show commands distinguish copies from originals:
-
-COMMAND:
-  eventmodeler list events        (shows isLinkedCopy: true, originalId for copies)
-  eventmodeler show slice "<name>"  (copies marked with linkedCopy: true, originalId, originalSlice)
-
-## Common Pattern: Event Produced in Slice A, Consumed in Slice B
-
-1. Slice A produces "OrderPlaced" event (via create slice or create place)
-2. In Slice B, create a linked copy of the event:
-     eventmodeler create place-copy event "OrderPlaced" --x 3000 --y 860
-3. Find the copy's UUID from list output:
-     eventmodeler list events
-4. Create a flow from the copy to the consuming readmodel:
-     eventmodeler create flow --from "OrderPlaced" --to "OrderHistory"
-     (or use --id <copy-uuid> if ambiguous:)
-     eventmodeler --id <copy-uuid> create flow --from "OrderPlaced" --to "OrderHistory"
-5. Map fields on the flow:
-     eventmodeler map fields '[{"source": "orderId", "target": "orderId"}]' --from "OrderPlaced" --to "OrderHistory"
-
-## Why Linked Copies Exist
-
-In event modeling, the same event often feeds multiple read models across different slices. Instead of duplicating the event definition, you create linked copies:
-- The original event stays in its source slice
-- Copies appear in consuming slices as visual references
-- All copies share the same name and fields
-- Each copy can be independently positioned on the canvas
-- Flows connect from copies to local readmodels
-`;

package/dist/slices/help/topics/manipulate-canvas.js

@@ -1,150 +0,0 @@
-export const meta = {
-    name: 'manipulate-canvas',
-    keywords: ['canvas', 'place', 'move', 'remove', 'position', 'layout', 'coordinate', 'x', 'y', 'band', 'spacing', 'slice', 'aggregate', 'actor', 'chapter', 'context', 'swimlane', 'note', 'overlap', 'create'],
-    description: 'Place, move, and remove elements on the visual canvas',
-};
-export const content = `
-# Manipulating the Canvas
-
-WHEN TO USE: You need to position, move, or remove elements on the visual canvas.
-
-## Canvas Layout Constants
-
-ELEMENT DIMENSIONS (fixed — not configurable from the CLI):
-  command / event / readmodel / external-event:  160 x 100
-  screen:                                        180 x 120
-  processor:                                     120 x 120
-  slice / aggregate / actor / context / swimlane: 300 x 200
-  chapter:                                       800 x 1200
-  note:                                          200 x 150
-
-PADDING       = 40
-X_SPACING     = 200   (sticky width + padding)
-
-Y BANDS (vertical lanes — where element types live):
-  screen / processor:      y = 120
-  command / readmodel:     y = 460
-  event / external-event:  y = 860
-
-## Placing Elements in a Slice
-
-A typical slice at x=1000 would place elements like this:
-
-  Screen:     x=1040, y=120   (PADDING inside slice)
-  Command:    x=1040, y=460
-  Event:      x=1240, y=860   (offset by X_SPACING for second column)
-  ReadModel:  x=1440, y=460
-
-Pattern: elements flow left-to-right within the slice, staying in their Y band.
-Multiple elements of the same type space out by X_SPACING.
-
-EXAMPLE (placing a state-change slice at x=2000):
-  Slice container: x=2000, y=80
-  Screen "OrderForm":     x=2040, y=120   (PADDING offset from slice x)
-  Command "PlaceOrder":   x=2040, y=460
-  Event "OrderPlaced":    x=2040, y=860
-  ReadModel "OrderView":  x=2240, y=460   (next column)
-
-## Task: Place a new element on the canvas
-
-COMMAND:
-  eventmodeler create place <type> <name> --x <n> --y <n>
-
-TYPES: command, event, readmodel, screen, processor, external-event,
-       aggregate, actor, chapter, context, note, swimlane, slice
-
-EXAMPLES:
-  eventmodeler create place command "PlaceOrder" --x 2040 --y 460
-  eventmodeler create place event "OrderPlaced" --x 2040 --y 860
-  eventmodeler create place screen "OrderForm" --x 2040 --y 120
-  eventmodeler create place readmodel "OrderView" --x 2240 --y 460
-  eventmodeler create place slice "Place Order" --x 2000 --y 80
-  eventmodeler create place aggregate "Order" --x 2000 --y 780 --id-field-name orderId --id-field-type UUID
-
-NOTES:
-  - All element sizes are fixed by the CLI — you cannot specify width/height
-  - Use Y bands above to position element types correctly
-  - Aggregate also accepts --id-field-name and --id-field-type (default: id, UUID)
-  - Note uses "title" internally but you just pass the name as the positional arg
-
-## Task: Move an element to a new position
-
-COMMAND:
-  eventmodeler move <type> [name] --x <n> --y <n>
-
-EXAMPLES:
-  eventmodeler move command "PlaceOrder" --x 2200 --y 460
-  eventmodeler move slice "Place Order" --x 3000 --y 80
-  eventmodeler move event --id <uuid> --x 2400 --y 860
-
-NOTES:
-  - Sets new absolute position (not relative)
-  - Keep stickies in their correct Y band when moving horizontally
-  - Use --id to target specific element when names are ambiguous
-
-## Task: Remove an element
-
-COMMAND:
-  eventmodeler remove <type> [name]
-
-EXAMPLES:
-  eventmodeler remove event "OrderPlaced"
-  eventmodeler remove slice "Place Order"
-  eventmodeler remove command --id <uuid>
-
-NOTES:
-  - Removing an element also removes its flows
-  - Use --id to target a specific element when names collide
-  - All element types supported: command, event, readmodel, screen, processor,
-    external-event, slice, aggregate, actor, chapter, context, note, swimlane
-
-## Task: Rename an element
-
-COMMAND:
-  eventmodeler rename <type> <currentName> <newName>
-
-EXAMPLES:
-  eventmodeler rename event "OrderPlaced" "OrderCreated"
-  eventmodeler rename slice "Place Order" "Create Order"
-
-## Reading the Canvas (show output includes full bounding boxes)
-
-Every element in show output includes x, y, width, height:
-
-  eventmodeler show slice "Place Order"
-  → {
-      "x": 2000, "y": 80, "width": 300, "height": 200,
-      "elements": [
-        { "name": "PlaceOrder", "elementType": "command",
-          "x": 2040, "y": 460, "width": 160, "height": 100, ... }
-      ]
-    }
-
-Use these bounding boxes to:
-  - Find the next available x position (rightmost element x + width + PADDING)
-  - Check if a new element would overlap existing ones
-  - Verify containment (an element is "inside" a container if its center is within the container bounds)
-
-CONTAINMENT RULE:
-  An element is considered inside a container when its CENTER POINT is within the container's bounds:
-    centerX = element.x + element.width / 2
-    centerY = element.y + element.height / 2
-  The center must be between container.x..container.x+container.width
-  and container.y..container.y+container.height.
-
-  This means an element can have its top-left corner inside a container but NOT be contained
-  if most of its body extends outside. Always check center-point, not top-left.
-
-## Avoiding Overlaps
-
-RULES:
-  - Stickies in the same Y band must be >= X_SPACING (200px) apart horizontally
-  - Containers must not overlap other containers of the same type
-  - Before placing, check existing positions:
-    eventmodeler show slice "<name>"   (shows x, y, width, height of all elements)
-    eventmodeler list slices            (shows x, y, width, height of all slices)
-  - Place new elements at the next available x offset
-
-EXAMPLE (adding a second event to a slice that already has one at x=2040):
-  eventmodeler create place event "OrderCancelled" --x 2240 --y 860
-`;

package/dist/slices/help/topics/write-scenarios.js

@@ -1,162 +0,0 @@
-export const meta = {
-    name: 'write-scenarios',
-    keywords: ['scenario', 'test', 'given', 'when', 'then', 'GWT', 'behavior', 'error', 'assertion', 'add', 'remove', 'entry', 'example', 'field', 'value', 'description', 'reorder', 'position'],
-    description: 'Add Given-When-Then scenarios to slices',
-};
-export const content = `
-# Writing Scenarios
-
-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>
-
-EXAMPLE (happy path — state-change slice):
-  eventmodeler add scenario '{
-    "name": "Successfully place order",
-    "given": [
-      {"entryType": "event", "elementName": "CustomerRegistered", "fieldValues": {"customerId": "cust-001"}}
-    ],
-    "when": [
-      {"entryType": "command", "elementName": "PlaceOrder", "fieldValues": {"customerId": "cust-001", "productId": "prod-42"}}
-    ],
-    "then": [
-      {"entryType": "event", "elementName": "OrderPlaced", "fieldValues": {"orderId": "ord-001", "customerId": "cust-001"}}
-    ]
-  }' --slice "Place Order"
-
-EXAMPLE (error case):
-  eventmodeler add scenario '{
-    "name": "Reject order with no items",
-    "when": [
-      {"entryType": "command", "elementName": "PlaceOrder", "fieldValues": {"customerId": "cust-001"}}
-    ],
-    "then": [
-      {"entryType": "error", "errorType": "ValidationError", "errorMessage": "Order must contain at least one item"}
-    ]
-  }' --slice "Place Order"
-
-EXAMPLE (readmodel assertion in then):
-  eventmodeler add scenario '{
-    "name": "Order appears in summary",
-    "given": [
-      {"entryType": "event", "elementName": "OrderPlaced", "fieldValues": {"orderId": "ord-001", "customerId": "cust-001"}}
-    ],
-    "then": [
-      {"entryType": "readmodel", "elementName": "OrderSummary", "fieldValues": {"orderId": "ord-001", "status": "pending"}}
-    ]
-  }' --slice "View Orders"
-
-SCENARIO JSON:
-  {
-    "name": "Scenario name",
-    "description": "Optional description text",
-    "given": [ <entries> ],
-    "when": [ <entries> ],
-    "then": [ <entries> ]
-  }
-
-  All sections (given/when/then) are optional — omit what you don't need.
-  Scenario is auto-positioned below its slice.
-
-ENTRY TYPES BY SECTION:
-  given:  event, readmodel
-  when:   command, event
-  then:   event, command, readmodel, error
-
-ENTRY SHAPES:
-  {"entryType": "event",     "elementName": "EventName",     "fieldValues": {"field": "value", "tags": ["a", "b"]}}
-  {"entryType": "command",   "elementName": "CommandName",   "fieldValues": {"field": "value", "tags": ["a", "b"]}}
-  {"entryType": "readmodel", "elementName": "ReadModelName", "fieldValues": {"field": "value", "tags": ["a", "b"]}}
-  {"entryType": "error",     "errorType": "ErrorType",       "errorMessage": "Description"}
-
-  fieldValues holds both scalar and list values. Pass an array for fields marked
-  as list (isList=true); a string otherwise. Setting a list value replaces the
-  entire list. The backend rejects array vs scalar mismatches against isList.
-
-NOTES:
-  - "given" = preconditions (events that already happened, readmodel state)
-  - "when" = trigger (usually a command, sometimes an event for automation)
-  - "then" = expected outcome (produced events, readmodel assertions, or errors)
-  - Error entries have no elementName — just errorType and errorMessage
-  - Use realistic sample data, not placeholders like "string" or "value"
-
-## Task: Add a single entry to an existing scenario
-
-COMMAND:
-  eventmodeler add entry --scenario <name> --section given|when|then --type <entryType> --element <elementName>
-
-EXAMPLES:
-  eventmodeler add entry --scenario "Successfully place order" --section given --type event --element "CustomerRegistered"
-  eventmodeler add entry --scenario "Reject empty order" --section then --type error --error-type "ValidationError" --error-message "No items"
-
-NOTES:
-  - --element not needed for --type error (use --error-type and --error-message instead)
-  - --position <n> optional (appends to end by default)
-
-## Task: Set a field example value on a scenario entry (scalar or list)
-
-COMMAND:
-  Scalar:  eventmodeler set example --scenario <name> --entry <entryId> --type <entryType> --field <fieldName> --value <val>
-  List:    eventmodeler set example --scenario <name> --entry <entryId> --type <entryType> --field <fieldName> --value <v> --value <v> ...
-           eventmodeler set example --scenario <name> --entry <entryId> --type <entryType> --field <fieldName> --values "a,b,c"
-
-EXAMPLES:
-  eventmodeler set example --scenario "Successfully place order" --entry <entryId> --type event --field "orderId" --value "ord-001"
-  eventmodeler set example --scenario "Place bulk order" --entry <entryId> --type command --field "productIds" --value "p-1" --value "p-2"
-  eventmodeler set example --scenario "Place bulk order" --entry <entryId> --type command --field "tags" --values "urgent,paid"
-
-NOTES:
-  - Entry ID comes from "show slice" or "show scenario" output (entryId field)
-  - --type must match the entry's element type: event, command, or readmodel
-  - List mode is auto-detected when --values is given or --value is repeated
-  - List mode replaces the entire list (set-whole-list semantics) and requires the field to be marked isList=true
-
-## Task: Remove a field example value
-
-COMMAND:
-  eventmodeler remove example --scenario <name> --entry <entryId> --type <entryType> --field <fieldName>
-
-## Task: Remove an entry from a scenario
-
-COMMAND:
-  eventmodeler remove entry --scenario <name> --section given|when|then --entry <entryId>
-
-## Task: Reorder an entry within its section
-
-COMMAND:
-  eventmodeler set position --scenario <name> --section given|when|then --entry <entryId> --position <n>
-
-## Task: Set scenario description
-
-COMMAND:
-  eventmodeler set description --scenario <name> --text "Description text"
-
-## Task: Remove a scenario
-
-COMMAND:
-  eventmodeler remove scenario [name]
-
-## Task: Rename a scenario
-
-COMMAND:
-  eventmodeler rename scenario "Old Name" "New Name"
-
-## Scenario Patterns by Slice Type
-
-STATE-CHANGE (Screen -> Command -> Event):
-  given: events that establish preconditions
-  when: the command being tested
-  then: expected event(s) or error
-
-AUTOMATION (ReadModel -> Processor -> Command -> Event):
-  given: events that build up the processor's readmodel
-  when: (often empty — the processor triggers automatically)
-  then: command the processor should dispatch, or events produced
-
-STATE-VIEW (ReadModel fed by events):
-  given: events that project into the readmodel
-  then: readmodel assertion showing expected state
-`;

package/dist/slices/init/index.js

@@ -1,86 +0,0 @@
-import * as readline from 'node:readline';
-import { isAuthenticated } from '../../lib/config';
-import { listModels } from '../../api/generated/sdk.gen';
-import { saveProjectConfig, getProjectRoot, isInProject } from '../../lib/project-config';
-/**
- * Interactive init command to set up a project.
- * Connects the current directory to an event model.
- */
-export async function init() {
-    if (isInProject()) {
-        console.log('This project is already initialized.');
-        console.log('To reconfigure, delete .eventmodeler.json and run init again.');
-        return;
-    }
-    const projectRoot = getProjectRoot();
-    console.log(`Initializing event model project in: ${projectRoot}\n`);
-    if (!isAuthenticated()) {
-        console.log('You need to be logged in first.');
-        console.log('Run "eventmodeler login" first, then try init again.');
-        return;
-    }
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const question = (prompt) => {
-        return new Promise((resolve) => {
-            rl.question(prompt, (answer) => {
-                resolve(answer.trim());
-            });
-        });
-    };
-    try {
-        console.log('Fetching your event models...\n');
-        const result = await listModels();
-        if (result.error || !result.data) {
-            console.log('Failed to fetch models. Are you logged in?');
-            rl.close();
-            return;
-        }
-        const models = result.data.items;
-        if (models.length === 0) {
-            console.log('You don\'t have any event models yet.');
-            console.log('Create one at https://eventmodeler.app first, then run init again.');
-            rl.close();
-            return;
-        }
-        console.log('Your event models:\n');
-        models.forEach((model, index) => {
-            console.log(`  ${index + 1}. ${model.name} (${model.modelId})`);
-        });
-        console.log(`  ${models.length + 1}. Create a new model\n`);
-        const modelChoice = await question(`Select a model (1-${models.length + 1}): `);
-        const modelIndex = parseInt(modelChoice, 10) - 1;
-        let selectedModel;
-        if (modelIndex === models.length) {
-            console.log('\nTo create a new model, visit https://eventmodeler.app');
-            console.log('After creating it, run init again to link it to this project.');
-            rl.close();
-            return;
-        }
-        else if (modelIndex >= 0 && modelIndex < models.length) {
-            selectedModel = models[modelIndex];
-        }
-        else {
-            console.log('\nInvalid choice. Please run init again.');
-            rl.close();
-            return;
-        }
-        const config = {
-            type: 'cloud',
-            modelId: selectedModel.modelId,
-            modelName: selectedModel.name,
-        };
-        const configPath = saveProjectConfig(config, projectRoot);
-        console.log(`\nProject initialized successfully!`);
-        console.log(`Config saved to: ${configPath}`);
-        console.log(`\nLinked to model: ${selectedModel.name}`);
-        console.log('\nYou can now use eventmodeler commands in this directory.');
-        rl.close();
-    }
-    catch (err) {
-        rl.close();
-        throw err;
-    }
-}