eventmodeler 0.6.0 → 0.6.2

package/dist/commands/init.js

@@ -1,21 +0,0 @@
-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

@@ -1,177 +0,0 @@
-// 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

@@ -1,39 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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}"`);
-    });
-}