eventmodeler 0.4.7 → 0.6.0

package/dist/commands/init.js

@@ -0,0 +1,21 @@
+import { init } from '../slices/init/index';
+import { initLoop } from '../slices/init/loop';
+export function registerInitCommands(program) {
+    const cmd = program.command('init')
+        .description('Initialize project and link to an event model')
+        .action(() => init());
+    cmd.command('loop')
+        .description('Scaffold a loop config and sample generate.sh script')
+        .addHelpText('after', `
+Writes a default "loop" block to .eventmodeler.json:
+  { "loop": { "command": "./generate.sh", "interval": 30 } }
+
+And creates generate.sh — a script skeleton that marks the slice
+in-progress, exports it as JSON, runs your codegen, and marks
+done/blocked. Edit generate.sh to plug in your own logic.
+
+Run the loop with:
+  eventmodeler loop
+`)
+        .action(() => initLoop());
+}

package/dist/commands/list-schemas.js

@@ -0,0 +1,177 @@
+// Response shapes for list/summary/search commands, pulled from the backend ReadModels.
+// Attached to each command's --help so agents can consume without out-of-band docs.
+const envelope = (itemShape) => `Response (JSON on stdout):
+
+{
+  "items": [
+${itemShape.split('\n').map((l) => `    ${l}`).join('\n')}
+  ]
+}`;
+export const LIST_SLICES_HELP = `
+${envelope(`{
+  "sliceId":     "<uuid>",
+  "modelId":     "<uuid>",
+  "name":        "Place Order",
+  "status":      "created" | "planned" | "in-progress" | "blocked" | "done",
+  "chapterName": "User Onboarding" | null,
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+
+Filter locally with jq:
+  eventmodeler list slices | jq '[.items[] | select(.status=="planned")]'
+`;
+export const LIST_EVENTS_HELP = `
+${envelope(`{
+  "eventStickyId": "<uuid>",
+  "modelId":       "<uuid>",
+  "name":          "OrderPlaced",
+  "aggregateName": "Order" | null,
+  "fieldCount":    0,
+  "copyCount":     0,
+  "isLinkedCopy":  false,
+  "originalId":    "<uuid>" | null,
+  "originSlice":   "Place Order" | null,
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_COMMANDS_HELP = `
+${envelope(`{
+  "commandStickyId": "<uuid>",
+  "modelId":         "<uuid>",
+  "name":            "PlaceOrder",
+  "fieldCount":      0,
+  "x": 0, "y": 0
+}`)}
+`;
+export const LIST_READMODELS_HELP = `
+${envelope(`{
+  "readModelStickyId": "<uuid>",
+  "modelId":           "<uuid>",
+  "name":              "OrderSummary",
+  "fieldCount":        0,
+  "isLinkedCopy":      false,
+  "originalId":        "<uuid>" | null,
+  "x": 0, "y": 0
+}`)}
+`;
+export const LIST_SCREENS_HELP = `
+${envelope(`{
+  "screenId":   "<uuid>",
+  "modelId":    "<uuid>",
+  "name":       "OrderForm",
+  "actorId":    "<uuid>" | null,
+  "actorName":  "Customer" | null,
+  "fieldCount": 0,
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_PROCESSORS_HELP = `
+${envelope(`{
+  "processorId": "<uuid>",
+  "modelId":     "<uuid>",
+  "name":        "PaymentProcessor",
+  "fieldCount":  0,
+  "x": 0, "y": 0
+}`)}
+`;
+export const LIST_EXTERNAL_EVENTS_HELP = `
+${envelope(`{
+  "externalEventId": "<uuid>",
+  "modelId":         "<uuid>",
+  "name":            "StripeChargeSucceeded",
+  "fieldCount":      0,
+  "isLinkedCopy":    false,
+  "originalId":      "<uuid>" | null,
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_AGGREGATES_HELP = `
+${envelope(`{
+  "aggregateId": "<uuid>",
+  "modelId":     "<uuid>",
+  "name":        "Order",
+  "eventCount":  0,
+  "idFieldName": "orderId" | null,
+  "idFieldType": "UUID" | null,
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_ACTORS_HELP = `
+${envelope(`{
+  "actorId":     "<uuid>",
+  "modelId":     "<uuid>",
+  "name":        "Customer",
+  "screenCount": 0,
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_CHAPTERS_HELP = `
+${envelope(`{
+  "chapterId": "<uuid>",
+  "modelId":   "<uuid>",
+  "name":      "User Onboarding",
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_CONTEXTS_HELP = `
+${envelope(`{
+  "contextId": "<uuid>",
+  "modelId":   "<uuid>",
+  "name":      "Orders",
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_SWIMLANES_HELP = `
+${envelope(`{
+  "swimLaneId": "<uuid>",
+  "modelId":    "<uuid>",
+  "name":       "Finance",
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_NOTES_HELP = `
+${envelope(`{
+  "noteId":      "<uuid>",
+  "modelId":     "<uuid>",
+  "name":        "Reminder",
+  "description": "Handle retries",
+  "x": 0, "y": 0, "width": 0, "height": 0
+}`)}
+`;
+export const LIST_SCENARIOS_HELP = `
+${envelope(`{
+  "scenarioId": "<uuid>",
+  "modelId":    "<uuid>",
+  "name":       "happy path",
+  "sliceId":    "<uuid>" | null,
+  "sliceName":  "Place Order" | null
+}`)}
+`;
+export const SUMMARY_HELP = `
+Response (JSON on stdout):
+
+{
+  "modelId":         "<uuid>",
+  "actorCount":      0,
+  "aggregateCount":  0,
+  "chapterCount":    0,
+  "commandCount":    0,
+  "eventCount":      0,
+  "flowCount":       0,
+  "processorCount":  0,
+  "readModelCount":  0,
+  "scenarioCount":   0,
+  "screenCount":     0,
+  "sliceCount":      0
+}
+`;
+export const SEARCH_HELP = `
+${envelope(`{
+  "elementId":   "<uuid>",
+  "modelId":     "<uuid>",
+  "elementType": "event" | "command" | "readmodel" | "screen"
+               | "processor" | "external-event" | "slice"
+               | "chapter" | "context" | "aggregate" | "actor",
+  "name":        "OrderPlaced"
+}`)}
+`;

package/dist/commands/list.js

@@ -0,0 +1,39 @@
+import { requireModelId } from '../lib/model';
+import { unwrap, out } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+import { LIST_SLICES_HELP, LIST_EVENTS_HELP, LIST_COMMANDS_HELP, LIST_READMODELS_HELP, LIST_SCREENS_HELP, LIST_PROCESSORS_HELP, LIST_EXTERNAL_EVENTS_HELP, LIST_AGGREGATES_HELP, LIST_ACTORS_HELP, LIST_CHAPTERS_HELP, LIST_CONTEXTS_HELP, LIST_SWIMLANES_HELP, LIST_NOTES_HELP, LIST_SCENARIOS_HELP, } from './list-schemas';
+export function registerListCommands(program) {
+    const list = program.command('list').description('List entities in the model');
+    list.command('slices')
+        .description('List all slices')
+        .option('--chapter <name>', 'Filter by chapter')
+        .addHelpText('after', LIST_SLICES_HELP)
+        .action(async (opts) => {
+        const modelId = requireModelId();
+        out(unwrap(await sdk.listSlices({ path: { modelId }, query: { search: opts.chapter } })));
+    });
+    const entries = [
+        ['events', sdk.listEvents, LIST_EVENTS_HELP],
+        ['commands', sdk.listCommands, LIST_COMMANDS_HELP],
+        ['chapters', sdk.listChapters, LIST_CHAPTERS_HELP],
+        ['aggregates', sdk.listAggregates, LIST_AGGREGATES_HELP],
+        ['actors', sdk.listActors, LIST_ACTORS_HELP],
+        ['readmodels', sdk.listReadModels, LIST_READMODELS_HELP],
+        ['screens', sdk.listScreens, LIST_SCREENS_HELP],
+        ['processors', sdk.listProcessors, LIST_PROCESSORS_HELP],
+        ['scenarios', sdk.listScenarios, LIST_SCENARIOS_HELP],
+        ['contexts', sdk.listContexts, LIST_CONTEXTS_HELP],
+        ['swimlanes', sdk.listSwimLanes, LIST_SWIMLANES_HELP],
+        ['notes', sdk.listNotes, LIST_NOTES_HELP],
+        ['external-events', sdk.listExternalEvents, LIST_EXTERNAL_EVENTS_HELP],
+    ];
+    for (const [name, fn, help] of entries) {
+        list.command(name)
+            .description(`List all ${name}`)
+            .addHelpText('after', help)
+            .action(async () => {
+            const modelId = requireModelId();
+            out(unwrap(await fn({ path: { modelId } })));
+        });
+    }
+}

package/dist/commands/loop.js

@@ -0,0 +1,101 @@
+import { spawn } from 'node:child_process';
+import { requireModelId } from '../lib/model';
+import { loadLoopConfig } from '../lib/project-config';
+import { unwrap } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+export function registerLoopCommands(program) {
+    const loop = program.command('loop')
+        .description('Poll the model for planned slices and run a command against each')
+        .addHelpText('after', `
+Config (.eventmodeler.json):
+  {
+    "loop": {
+      "command": "./run-agent.sh",
+      "interval": 30
+    }
+  }
+
+How it works:
+  1. Every <interval> seconds, fetch all slices
+  2. For each slice with status "planned", run: <command> <sliceName>
+  3. Repeat
+
+Script contract:
+  Your script owns every status transition.
+    - Mark the slice "in-progress" at the start so the next poll skips it.
+    - Mark "done" on success or "blocked" on failure before exiting.
+    - If the script crashes without marking, the slice stays "planned"
+      and the next poll retries it (self-healing).
+
+Inside your script:
+  SLICE="$1"
+  eventmodeler mark "$SLICE" in-progress
+  eventmodeler show slice "$SLICE" > slice.json
+  # ... do codegen / call an AI / run tests ...
+  eventmodeler mark "$SLICE" done    # or: mark "$SLICE" blocked
+
+Other valid commands: any shell-runnable invocation (python run.py,
+node handler.js, claude -p '...'). The slice name is appended as the
+final argument.
+
+Stop the loop with Ctrl+C.
+`);
+    loop.action(async () => {
+        const modelId = requireModelId();
+        const config = loadLoopConfig();
+        if (!config) {
+            console.error('Error: No "loop" config in .eventmodeler.json.');
+            console.error('Add: { "loop": { "command": "./your-script.sh", "interval": 30 } }');
+            process.exit(1);
+        }
+        const { command, interval } = config;
+        console.log(`Loop started. Polling every ${interval}s. Command: ${command}`);
+        console.log('Press Ctrl+C to stop.');
+        let stopping = false;
+        process.on('SIGINT', () => {
+            if (stopping)
+                process.exit(1);
+            stopping = true;
+            console.log('\nStopping after current iteration...');
+        });
+        while (!stopping) {
+            await tick(modelId, command);
+            if (stopping)
+                break;
+            await sleep(interval * 1000);
+        }
+        process.exit(0);
+    });
+}
+async function tick(modelId, command) {
+    const stamp = new Date().toISOString();
+    try {
+        const result = unwrap(await sdk.listSlices({ path: { modelId }, query: {} }));
+        const planned = result.items.filter((s) => s.status === 'planned');
+        if (planned.length === 0) {
+            console.log(`[${stamp}] No planned slices.`);
+            return;
+        }
+        console.log(`[${stamp}] ${planned.length} planned slice(s).`);
+        for (const slice of planned) {
+            console.log(`  -> ${slice.name}`);
+            await runScript(command, slice.name);
+        }
+    }
+    catch (err) {
+        console.error(`[${stamp}] Poll error: ${err.message ?? err}`);
+    }
+}
+function runScript(command, sliceName) {
+    return new Promise((resolve) => {
+        const child = spawn(command, [sliceName], { stdio: 'inherit', shell: true });
+        child.on('close', () => resolve());
+        child.on('error', (err) => {
+            console.error(`Script error: ${err.message}`);
+            resolve();
+        });
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/map.js

@@ -0,0 +1,40 @@
+import { randomUUID } from 'node:crypto';
+import { requireModelId } from '../lib/model';
+import { resolveAnyElement, unwrap } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+export function registerMapCommands(program) {
+    program.command('map')
+        .description('Map fields between elements')
+        .command('fields <json>')
+        .description('Add field mappings to a flow')
+        .requiredOption('--from <source>', 'Source element name')
+        .requiredOption('--to <target>', 'Target element name')
+        .action(async (json, opts) => {
+        const modelId = requireModelId();
+        const { elementId: sourceId } = await resolveAnyElement(modelId, opts.from);
+        const { elementId: targetId } = await resolveAnyElement(modelId, opts.to);
+        const flowResult = unwrap(await sdk.resolveFlow({
+            query: { modelId, sourceId, targetId }
+        }));
+        const flowId = flowResult.flowId;
+        const mappings = JSON.parse(json);
+        for (const m of mappings) {
+            const sourceResolve = unwrap(await sdk.resolveField({
+                query: { modelId, elementId: sourceId, fieldName: m.source }
+            }));
+            const targetResolve = unwrap(await sdk.resolveField({
+                query: { modelId, elementId: targetId, fieldName: m.target }
+            }));
+            unwrap(await sdk.addFieldMapping({
+                body: {
+                    modelId,
+                    flowId,
+                    mappingId: randomUUID(),
+                    sourceFieldId: sourceResolve.fieldId,
+                    targetFieldId: targetResolve.fieldId,
+                }
+            }));
+        }
+        console.log(`Added ${mappings.length} field mapping(s).`);
+    });
+}

package/dist/commands/mark.js

@@ -0,0 +1,27 @@
+import { getGlobalId } from '../lib/globals';
+import { requireModelId } from '../lib/model';
+import { resolve, unwrap } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+const STATUS_MAP = {
+    planned: sdk.markSliceAsPlanned,
+    created: sdk.markSliceAsCreated,
+    'in-progress': sdk.markSliceAsInProgress,
+    blocked: sdk.markSliceAsBlocked,
+    done: sdk.markSliceAsDone,
+};
+export function registerMarkCommands(program) {
+    program.command('mark [sliceName] <status>')
+        .description('Mark a slice status (planned|created|in-progress|blocked|done)')
+        .action(async (sliceNameOrStatus, statusOrUndefined, cmd) => {
+        const modelId = requireModelId();
+        const hasId = getGlobalId();
+        const sliceName = statusOrUndefined ? sliceNameOrStatus : '';
+        const status = statusOrUndefined ?? sliceNameOrStatus;
+        const fn = STATUS_MAP[status];
+        if (!fn)
+            throw new Error(`Unknown status: ${status}. Valid: ${Object.keys(STATUS_MAP).join(', ')}`);
+        const sliceId = await resolve(modelId, 'slice', sliceName, hasId);
+        unwrap(await fn({ body: { modelId, sliceId } }));
+        console.log(`Marked slice as ${status}.`);
+    });
+}

package/dist/commands/move.js

@@ -0,0 +1,35 @@
+import { getGlobalId } from '../lib/globals';
+import { requireModelId } from '../lib/model';
+import { resolve, unwrap, elementIdKey } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+const MOVE_MAP = {
+    slice: sdk.moveSlice,
+    command: sdk.moveCommandSticky,
+    event: sdk.moveEventSticky,
+    readmodel: sdk.moveReadModelSticky,
+    screen: sdk.moveScreen,
+    processor: sdk.moveProcessor,
+    aggregate: sdk.moveAggregate,
+    actor: sdk.moveActor,
+    chapter: sdk.moveChapter,
+    context: sdk.moveContext,
+    'external-event': sdk.moveExternalEvent,
+    note: sdk.moveNote,
+    swimlane: sdk.moveSwimLane,
+};
+export function registerMoveCommands(program) {
+    program.command('move <type> [name]')
+        .description('Move an element to a new position')
+        .requiredOption('--x <n>', 'X coordinate', Number)
+        .requiredOption('--y <n>', 'Y coordinate', Number)
+        .action(async (type, name, opts, cmd) => {
+        const modelId = requireModelId();
+        const fn = MOVE_MAP[type];
+        if (!fn)
+            throw new Error(`Unknown type: ${type}. Valid types: ${Object.keys(MOVE_MAP).join(', ')}`);
+        const id = await resolve(modelId, type, name ?? '', getGlobalId());
+        const key = elementIdKey(type);
+        unwrap(await fn({ body: { modelId, [key]: id, x: opts.x, y: opts.y } }));
+        console.log(`Moved ${type} to (${opts.x}, ${opts.y}).`);
+    });
+}

package/dist/commands/remove.js

@@ -0,0 +1,170 @@
+import { getGlobalId } from '../lib/globals';
+import { requireModelId } from '../lib/model';
+import { resolve, resolveAnyElement, unwrap, elementIdKey } from '../lib/resolve';
+import { resolveScenarioId } from '../lib/scenario';
+import * as sdk from '../api/generated/sdk.gen';
+const REMOVE_MAP = {
+    slice: sdk.removeSlice,
+    command: sdk.removeCommandSticky,
+    event: sdk.removeEventSticky,
+    readmodel: sdk.removeReadModelSticky,
+    screen: sdk.removeScreen,
+    processor: sdk.removeProcessor,
+    aggregate: sdk.removeAggregate,
+    actor: sdk.removeActor,
+    chapter: sdk.removeChapter,
+    context: sdk.removeContext,
+    'external-event': sdk.removeExternalEvent,
+    note: sdk.removeNote,
+    swimlane: sdk.removeSwimLane,
+};
+const REMOVE_FIELD_MAP = {
+    command: sdk.removeCommandField,
+    event: sdk.removeEventField,
+    readmodel: sdk.removeReadModelField,
+    screen: sdk.removeScreenField,
+    processor: sdk.removeProcessorField,
+    'external-event': sdk.removeExternalEventField,
+};
+const REMOVE_SUBFIELD_MAP = {
+    command: sdk.removeCommandSubfield,
+    event: sdk.removeEventSubfield,
+    readmodel: sdk.removeReadModelSubfield,
+    screen: sdk.removeScreenSubfield,
+    processor: sdk.removeProcessorSubfield,
+    'external-event': sdk.removeExternalEventSubfield,
+};
+export function registerRemoveCommands(program) {
+    const remove = program.command('remove').description('Remove elements from the model');
+    // remove <type> [name] — generic element removal
+    for (const [type, fn] of Object.entries(REMOVE_MAP)) {
+        if (type === 'scenario')
+            continue; // handled separately below
+        remove.command(`${type} [name]`)
+            .description(`Remove a ${type}`)
+            .action(async (name, cmd) => {
+            const modelId = requireModelId();
+            const id = await resolve(modelId, type, name ?? '', getGlobalId());
+            const key = elementIdKey(type);
+            unwrap(await fn({ body: { modelId, [key]: id } }));
+            console.log(`Removed ${type}.`);
+        });
+    }
+    // remove scenario [name]
+    remove.command('scenario [name]')
+        .description('Remove a scenario')
+        .action(async (name) => {
+        const modelId = requireModelId();
+        const scenarioId = await resolveScenarioId(modelId, name ?? '', getGlobalId());
+        unwrap(await sdk.removeScenario({ body: { modelId, scenarioId } }));
+        console.log('Removed scenario.');
+    });
+    // remove field <elementName> --field <name>
+    remove.command('field [elementName]')
+        .description('Remove a field from an element')
+        .requiredOption('--field <name>', 'Field name to remove')
+        .action(async (elementName, opts, cmd) => {
+        const modelId = requireModelId();
+        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
+        const fn = REMOVE_FIELD_MAP[elementType];
+        if (!fn)
+            throw new Error(`Cannot remove fields from type: ${elementType}`);
+        const fieldResult = unwrap(await sdk.resolveField({
+            query: { modelId, elementId, fieldName: opts.field }
+        }));
+        const fieldId = fieldResult.fieldId;
+        const key = elementIdKey(elementType);
+        unwrap(await fn({ body: { modelId, [key]: elementId, fieldId } }));
+        console.log(`Removed field "${opts.field}".`);
+    });
+    // remove subfield [elementName] --subfield <subfieldId>
+    remove.command('subfield [elementName]')
+        .description('Remove a subfield from an element')
+        .requiredOption('--subfield <id>', 'Subfield ID (from show output)')
+        .action(async (elementName, opts, cmd) => {
+        const modelId = requireModelId();
+        const { elementId, elementType } = await resolveAnyElement(modelId, elementName ?? '', getGlobalId());
+        const fn = REMOVE_SUBFIELD_MAP[elementType];
+        if (!fn)
+            throw new Error(`Cannot remove subfields from type: ${elementType}`);
+        const key = elementIdKey(elementType);
+        unwrap(await fn({ body: { modelId, [key]: elementId, subfieldId: opts.subfield } }));
+        console.log('Removed subfield.');
+    });
+    // remove mapping --from <source> --to <target> --mapping <mappingId>
+    remove.command('mapping')
+        .description('Remove a field mapping from a flow')
+        .requiredOption('--from <source>', 'Source element name')
+        .requiredOption('--to <target>', 'Target element name')
+        .requiredOption('--mapping <id>', 'Mapping ID (from show output)')
+        .action(async (opts) => {
+        const modelId = requireModelId();
+        const { elementId: sourceId } = await resolveAnyElement(modelId, opts.from);
+        const { elementId: targetId } = await resolveAnyElement(modelId, opts.to);
+        const flowResult = unwrap(await sdk.resolveFlow({
+            query: { modelId, sourceId, targetId }
+        }));
+        const flowId = flowResult.flowId;
+        unwrap(await sdk.removeFieldMapping({ body: { modelId, flowId, mappingId: opts.mapping } }));
+        console.log('Removed field mapping.');
+    });
+    // remove entry --scenario <name> --section given|when|then --entry <entryId>
+    const REMOVE_ENTRY_MAP = {
+        given: sdk.removeScenarioGivenEntry,
+        when: sdk.removeScenarioWhenEntry,
+        then: sdk.removeScenarioThenEntry,
+    };
+    remove.command('entry')
+        .description('Remove a GWT entry from a scenario')
+        .requiredOption('--scenario <name>', 'Scenario name')
+        .requiredOption('--section <section>', 'Section: given, when, or then')
+        .requiredOption('--entry <entryId>', 'Entry ID (from show output)')
+        .action(async (opts) => {
+        const modelId = requireModelId();
+        const scenarioId = await resolveScenarioId(modelId, opts.scenario, getGlobalId());
+        const fn = REMOVE_ENTRY_MAP[opts.section];
+        if (!fn)
+            throw new Error(`Unknown section: ${opts.section}. Use given, when, or then.`);
+        unwrap(await fn({ body: { modelId, scenarioId, entryId: opts.entry } }));
+        console.log(`Removed ${opts.section} entry.`);
+    });
+    // remove example --scenario <name> --entry <entryId> --type event|command|readmodel --field <name>
+    const REMOVE_FIELD_VALUE_MAP = {
+        event: sdk.removeScenarioEventFieldValue,
+        command: sdk.removeScenarioCommandFieldValue,
+        readmodel: sdk.removeScenarioReadModelFieldValue,
+    };
+    remove.command('example')
+        .description('Remove a field example value from a scenario entry')
+        .requiredOption('--scenario <name>', 'Scenario name')
+        .requiredOption('--entry <entryId>', 'Entry ID (from show output)')
+        .requiredOption('--type <type>', 'Entry type: event, command, or readmodel')
+        .requiredOption('--field <name>', 'Field name to clear')
+        .action(async (opts) => {
+        const modelId = requireModelId();
+        const scenarioId = await resolveScenarioId(modelId, opts.scenario, getGlobalId());
+        const fn = REMOVE_FIELD_VALUE_MAP[opts.type];
+        if (!fn)
+            throw new Error(`Cannot remove examples from type: ${opts.type}. Use event, command, or readmodel.`);
+        unwrap(await fn({
+            body: { modelId, scenarioId, entryId: opts.entry, fieldName: opts.field }
+        }));
+        console.log(`Removed example "${opts.field}".`);
+    });
+    // remove flow --from <source> --to <target>
+    remove.command('flow')
+        .description('Remove a flow between two elements')
+        .requiredOption('--from <source>', 'Source element name')
+        .requiredOption('--to <target>', 'Target element name')
+        .action(async (opts) => {
+        const modelId = requireModelId();
+        const { elementId: sourceId } = await resolveAnyElement(modelId, opts.from);
+        const { elementId: targetId } = await resolveAnyElement(modelId, opts.to);
+        const flowResult = unwrap(await sdk.resolveFlow({
+            query: { modelId, sourceId, targetId }
+        }));
+        const flowId = flowResult.flowId;
+        unwrap(await sdk.removeFlow({ body: { modelId, flowId } }));
+        console.log('Removed flow.');
+    });
+}

package/dist/commands/rename.js

@@ -0,0 +1,53 @@
+import { getGlobalId } from '../lib/globals';
+import { requireModelId } from '../lib/model';
+import { resolve, unwrap, elementIdKey } from '../lib/resolve';
+import * as sdk from '../api/generated/sdk.gen';
+const RENAME_MAP = {
+    slice: sdk.renameSlice,
+    command: sdk.renameCommandSticky,
+    event: sdk.renameEventSticky,
+    readmodel: sdk.renameReadModelSticky,
+    screen: sdk.renameScreen,
+    processor: sdk.renameProcessor,
+    aggregate: sdk.renameAggregate,
+    actor: sdk.renameActor,
+    chapter: sdk.renameChapter,
+    context: sdk.renameContext,
+    scenario: sdk.renameScenario,
+    'external-event': sdk.renameExternalEvent,
+    note: sdk.renameNote,
+    swimlane: sdk.renameSwimLane,
+};
+export function registerRenameCommands(program) {
+    program.command('rename')
+        .description('Rename an element')
+        .argument('<type>', `Element type (${Object.keys(RENAME_MAP).join(', ')})`)
+        .argument('<names...>', 'Old name and new name (or just new name with --id)')
+        .action(async (type, names, _opts, cmd) => {
+        const modelId = requireModelId();
+        const fn = RENAME_MAP[type];
+        if (!fn)
+            throw new Error(`Unknown type: ${type}. Valid: ${Object.keys(RENAME_MAP).join(', ')}`);
+        const idOverride = getGlobalId();
+        let oldName;
+        let newName;
+        if (idOverride) {
+            // With --id, all positional args are the new name
+            newName = names.join(' ');
+            oldName = '';
+        }
+        else if (names.length >= 2) {
+            // Last arg is new name, rest is old name
+            newName = names[names.length - 1];
+            oldName = names.slice(0, -1).join(' ');
+        }
+        else {
+            console.error('Usage: eventmodeler rename <type> "Old Name" "New Name"');
+            console.error('  or:  eventmodeler --id <uuid> rename <type> "New Name"');
+            process.exit(1);
+        }
+        const id = await resolve(modelId, type, oldName, idOverride);
+        unwrap(await fn({ body: { modelId, [elementIdKey(type)]: id, name: newName } }));
+        console.log(`Renamed ${type} to "${newName}"`);
+    });
+}