@auto-engineer/cli 0.19.1 → 0.21.0

package/CHANGELOG.md

@@ -1,13 +1,33 @@
 # @auto-engineer/cli
 
-## 0.19.1
+## 0.21.0
+
+### Minor Changes
+
+- Unifies ports on cli
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @auto-engineer/file-store@0.21.0
+  - @auto-engineer/narrative@0.21.0
+  - @auto-engineer/pipeline@0.21.0
+
+## 0.20.0
+
+### Minor Changes
+
+- Add dual-mode CLI with importable server module
+  - Export `startServer()` function from `@auto-engineer/cli/server` subpath
+  - Support middleware injection via `httpMiddleware` and `socketMiddleware` options
+  - Enable external packages to extend CLI server with custom auth/middleware
 
 ### Patch Changes
 
 - Updated dependencies []:
-  - @auto-engineer/narrative@0.19.1
-  - @auto-engineer/file-store@0.19.1
-  - @auto-engineer/pipeline@0.19.1
+  - @auto-engineer/file-store@0.20.0
+  - @auto-engineer/narrative@0.20.0
+  - @auto-engineer/pipeline@0.20.0
 
 ## 0.19.0
 

package/dist/src/__fixtures__/auto.config.d.ts

@@ -0,0 +1,7 @@
+export declare const pipeline: any;
+declare const _default: {
+    plugins: never[];
+    pipeline: any;
+};
+export default _default;
+//# sourceMappingURL=auto.config.d.ts.map

package/dist/src/__fixtures__/auto.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto.config.d.ts","sourceRoot":"","sources":["../../../src/__fixtures__/auto.config.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ,KAAkC,CAAC;;;;;AAExD,wBAGE"}

package/dist/src/__fixtures__/auto.config.js

@@ -0,0 +1,7 @@
+import { define } from '@auto-engineer/pipeline';
+export const pipeline = define('test-pipeline').build();
+export default {
+    plugins: [],
+    pipeline,
+};
+//# sourceMappingURL=auto.config.js.map

package/dist/src/__fixtures__/auto.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto.config.js","sourceRoot":"","sources":["../../../src/__fixtures__/auto.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC,KAAK,EAAE,CAAC;AAExD,eAAe;IACb,OAAO,EAAE,EAAE;IACX,QAAQ;CACT,CAAC"}

package/dist/src/dsl/index.d.ts

@@ -0,0 +1,71 @@
+import type { Command, Event } from '@auto-engineer/message-bus';
+import type { EventRegistration, DispatchAction, FoldRegistration, DslRegistration, ConfigDefinition, SettledRegistration, SettledHandlerConfig } from './types';
+import type { CommandMetadataService } from '../server/command-metadata-service';
+import type { ILocalMessageStore } from '@auto-engineer/message-store';
+export type NodeStatus = 'None' | 'idle' | 'running' | 'pass' | 'fail';
+export interface PipelineGraphConfig {
+    metadataService?: CommandMetadataService;
+    eventHandlers?: Map<string, Array<(event: Event) => void>>;
+    messageStore?: ILocalMessageStore;
+    dslRegistrations?: DslRegistration[];
+}
+export declare function on<T extends Event>(eventType: string | ((event: T) => void), handler?: (event: T) => Command | Command[] | DispatchAction | void): EventRegistration | void;
+export declare namespace on {
+    var settled: <T extends Command, U extends Command = never, V extends Command = never, W extends Command = never, X extends Command = never>(commandTypes: [T, U, V, W, X] extends [Command, never, never, never, never] ? [T["type"]] : [T, U, V, W, X] extends [Command, Command, never, never, never] ? [T["type"], U["type"]] : [T, U, V, W, X] extends [Command, Command, Command, never, never] ? [T["type"], U["type"], V["type"]] : [T, U, V, W, X] extends [Command, Command, Command, Command, never] ? [T["type"], U["type"], V["type"], W["type"]] : [T, U, V, W, X] extends [Command, Command, Command, Command, Command] ? [T["type"], U["type"], V["type"], W["type"], X["type"]] : never, callbackOrConfig: ((events: [T, U, V, W, X] extends [Command, never, never, never, never] ? { [K in T["type"]]: Event[]; } : [T, U, V, W, X] extends [Command, Command, never, never, never] ? { [K in T["type"] | U["type"]]: Event[]; } : [T, U, V, W, X] extends [Command, Command, Command, never, never] ? { [K in T["type"] | U["type"] | V["type"]]: Event[]; } : [T, U, V, W, X] extends [Command, Command, Command, Command, never] ? { [K in T["type"] | U["type"] | V["type"] | W["type"]]: Event[]; } : [T, U, V, W, X] extends [Command, Command, Command, Command, Command] ? { [K in T["type"] | U["type"] | V["type"] | W["type"] | X["type"]]: Event[]; } : never) => void) | SettledHandlerConfig) => SettledRegistration;
+}
+/**
+ * Dispatch a command to the message bus
+ */
+export declare function dispatch<T extends Command>(command: T): DispatchAction;
+export declare function dispatch<T extends Command>(commandType: T['type'], data: T['data']): Command;
+export declare function dispatch<TDispatchCommands extends Command>(commandTypes: readonly TDispatchCommands['type'][], handler: (events: Record<string, Event[]>, send: <TCommand extends TDispatchCommands>(command: TCommand) => void) => void): SettledHandlerConfig<TDispatchCommands>;
+export declare namespace dispatch {
+    var parallel: <T extends Command>(commands: T[]) => DispatchAction;
+    var sequence: <T extends Command>(commands: T[]) => DispatchAction;
+    var custom: <T extends Command>(commandFactory: () => T | T[]) => DispatchAction;
+}
+/**
+ * Register a fold function to update state when an event occurs
+ */
+export declare function fold<S, E extends Event>(eventType: string | ((state: S, event: E) => S), reducer?: (state: S, event: E) => S): FoldRegistration<S, E> | void;
+/**
+ * Get all registrations and clear the list
+ */
+export declare function getRegistrations(): DslRegistration[];
+/**
+ * Peek at registrations without clearing them
+ */
+export declare function peekRegistrations(): DslRegistration[];
+/**
+ * Get all pending dispatches and clear the list
+ */
+export declare function getPendingDispatches(): DispatchAction[];
+/**
+ * Create an Auto configuration with plugins and pipeline
+ */
+export declare function autoConfig(config: ConfigDefinition): ConfigDefinition;
+export declare function buildEventToCommandMapping(metadataService?: CommandMetadataService): Record<string, string>;
+/**
+ * Generate pipeline graph from current registrations
+ */
+export declare function getPipelineGraph(config?: PipelineGraphConfig): Promise<{
+    commandToEvents: Record<string, string[]>;
+    eventToCommand: Record<string, string>;
+    nodes: Array<{
+        id: string;
+        name: string;
+        title: string;
+        alias?: string;
+        description?: string;
+        package?: string;
+        version?: string;
+        category?: string;
+        icon?: string;
+        status: NodeStatus;
+    }>;
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/dsl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dsl/index.ts"],"names":[],"mappings":"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"}

package/dist/src/dsl/index.js

@@ -0,0 +1,504 @@
+import createDebug from 'debug';
+const debug = createDebug('auto:cli:dsl:pipeline-graph');
+let registrations = [];
+let pendingDispatches = [];
+function buildCommandEventMappings(metadataService) {
+    const mappings = {};
+    if (!metadataService) {
+        return mappings;
+    }
+    const commands = metadataService.getAllCommandsMetadata();
+    for (const command of commands) {
+        const commandName = command.name;
+        if (!commandName || typeof commandName !== 'string') {
+            continue;
+        }
+        if (!command.events || command.events.length === 0) {
+            continue;
+        }
+        mappings[commandName] = command.events;
+    }
+    return mappings;
+}
+export function on(eventType, handler) {
+    if (typeof eventType === 'function') {
+        const registration = {
+            type: 'on',
+            eventType: '',
+            handler: eventType,
+        };
+        registrations.push(registration);
+        return registration;
+    }
+    if (handler) {
+        const registration = {
+            type: 'on',
+            eventType,
+            handler: handler,
+        };
+        registrations.push(registration);
+        return registration;
+    }
+}
+function settled(commandTypes, callbackOrConfig) {
+    const commandTypesArray = commandTypes;
+    if (typeof callbackOrConfig === 'function') {
+        const registration = {
+            type: 'on-settled',
+            commandTypes: commandTypesArray,
+            handler: callbackOrConfig,
+        };
+        registrations.push(registration);
+        return registration;
+    }
+    else {
+        const { dispatches, handler } = callbackOrConfig;
+        const wrappedHandler = (events) => {
+            const validatedDispatch = (command) => {
+                if (!dispatches.includes(command.type)) {
+                    throw new Error(`Command type "${command.type}" is not declared in dispatches list`);
+                }
+                const action = {
+                    type: 'dispatch',
+                    command,
+                };
+                pendingDispatches.push(action);
+            };
+            return handler(events, validatedDispatch);
+        };
+        const registration = {
+            type: 'on-settled',
+            commandTypes: commandTypesArray,
+            handler: wrappedHandler,
+            dispatches,
+        };
+        registrations.push(registration);
+        return registration;
+    }
+}
+on.settled = settled;
+export function dispatch(commandOrTypeOrTypes, dataOrHandler) {
+    // Array pattern for on.settled
+    if (Array.isArray(commandOrTypeOrTypes)) {
+        const commandTypes = commandOrTypeOrTypes;
+        const handler = dataOrHandler;
+        return {
+            dispatches: commandTypes,
+            handler,
+        };
+    }
+    // Object pattern for full command
+    if (typeof commandOrTypeOrTypes === 'object' &&
+        commandOrTypeOrTypes !== null &&
+        !Array.isArray(commandOrTypeOrTypes)) {
+        const command = commandOrTypeOrTypes;
+        const action = {
+            type: 'dispatch',
+            command,
+        };
+        pendingDispatches.push(action);
+        return action;
+    }
+    // String pattern for command type + data - return the command object for event handlers
+    const commandType = commandOrTypeOrTypes;
+    const data = dataOrHandler;
+    const command = {
+        type: commandType,
+        data,
+    };
+    // Return the command directly for event handlers to process
+    return command;
+}
+/**
+ * Dispatch multiple commands in parallel
+ */
+dispatch.parallel = (commands) => {
+    const action = {
+        type: 'dispatch-parallel',
+        commands: commands,
+    };
+    pendingDispatches.push(action);
+    return action;
+};
+/**
+ * Dispatch multiple commands in sequence
+ */
+dispatch.sequence = (commands) => {
+    const action = {
+        type: 'dispatch-sequence',
+        commands: commands,
+    };
+    pendingDispatches.push(action);
+    return action;
+};
+/**
+ * Dispatch a command based on custom logic
+ */
+dispatch.custom = (commandFactory) => {
+    const action = {
+        type: 'dispatch-custom',
+        commandFactory: commandFactory,
+    };
+    pendingDispatches.push(action);
+    return action;
+};
+/**
+ * Register a fold function to update state when an event occurs
+ */
+export function fold(eventType, reducer) {
+    // Support both forms: fold('EventName', reducer) and fold<State, Event>((state, event) => ...)
+    if (typeof eventType === 'function') {
+        const registration = {
+            type: 'fold',
+            eventType: '', // Will be inferred from type
+            reducer: eventType,
+        };
+        registrations.push(registration);
+        return registration;
+    }
+    if (reducer) {
+        const registration = {
+            type: 'fold',
+            eventType,
+            reducer,
+        };
+        registrations.push(registration);
+        return registration;
+    }
+}
+/**
+ * Get all registrations and clear the list
+ */
+export function getRegistrations() {
+    const result = [...registrations];
+    registrations = [];
+    return result;
+}
+/**
+ * Peek at registrations without clearing them
+ */
+export function peekRegistrations() {
+    return [...registrations];
+}
+/**
+ * Get all pending dispatches and clear the list
+ */
+export function getPendingDispatches() {
+    const result = [...pendingDispatches];
+    pendingDispatches = [];
+    return result;
+}
+/**
+ * Create an Auto configuration with plugins and pipeline
+ */
+export function autoConfig(config) {
+    return config;
+}
+/**
+ * Convert camelCase/PascalCase to title case with spaces
+ * E.g., "GenerateServer" -> "Generate Server", "checkTypes" -> "Check Types", "GenerateHTML" -> "Generate HTML"
+ */
+function camelCaseToTitleCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2')
+        .replace(/[_-]/g, ' ')
+        .replace(/^./, (match) => match.toUpperCase())
+        .trim();
+}
+export function buildEventToCommandMapping(metadataService) {
+    if (!metadataService) {
+        return {};
+    }
+    const eventToCommandMap = metadataService.getEventToCommandMapping?.();
+    const result = {};
+    if (eventToCommandMap instanceof Map) {
+        for (const [eventType, commandName] of eventToCommandMap.entries()) {
+            result[eventType] = commandName;
+        }
+    }
+    return result;
+}
+function hasEventError(event) {
+    const data = event.message.data;
+    return data !== null && typeof data === 'object' && ('error' in data || 'errors' in data);
+}
+function extractTargetIdentifier(commandData) {
+    if (commandData === null || typeof commandData !== 'object') {
+        return JSON.stringify(commandData);
+    }
+    const data = commandData;
+    const targetFields = ['targetDirectory', 'slicePath', 'filePath', 'componentName', 'path'];
+    for (const field of targetFields) {
+        if (field in data && typeof data[field] === 'string') {
+            return String(data[field]);
+        }
+    }
+    return JSON.stringify(commandData);
+}
+function traceCorrelationChain(requestId, allMessages) {
+    const chain = [requestId];
+    let currentId = requestId;
+    let commandMessage = allMessages.find((msg) => msg.messageType === 'command' && msg.message.requestId === currentId);
+    while (commandMessage !== undefined &&
+        commandMessage.message.correlationId !== undefined &&
+        commandMessage.message.correlationId !== null &&
+        commandMessage.message.correlationId !== '') {
+        const correlationId = commandMessage.message.correlationId;
+        chain.push(correlationId);
+        const parentCommand = allMessages.find((msg) => msg.messageType === 'command' && msg.message.requestId === correlationId);
+        if (parentCommand === undefined ||
+            parentCommand.message.correlationId === undefined ||
+            parentCommand.message.correlationId === null ||
+            parentCommand.message.correlationId === '') {
+            break;
+        }
+        currentId = correlationId;
+        commandMessage = parentCommand;
+    }
+    return chain;
+}
+function getWorkflowRoot(requestId, allMessages) {
+    const chain = traceCorrelationChain(requestId, allMessages);
+    const rootRequestId = chain[chain.length - 1];
+    const rootCommand = allMessages.find((msg) => msg.messageType === 'command' && msg.message.requestId === rootRequestId);
+    return rootCommand?.message.type ?? null;
+}
+function isServerWorkflowCommand(workflowRoot) {
+    const serverWorkflowCommands = ['ImplementSlice', 'SliceGenerated', 'GenerateServer'];
+    return workflowRoot !== null && workflowRoot !== '' && serverWorkflowCommands.includes(workflowRoot);
+}
+function isClientWorkflowCommand(workflowRoot) {
+    const clientWorkflowCommands = ['ImplementComponent', 'ClientGenerated', 'GenerateClient'];
+    return workflowRoot !== null && workflowRoot !== '' && clientWorkflowCommands.includes(workflowRoot);
+}
+function shouldIncludeCommandInNodeStatus(command, commandType, allMessages) {
+    const sharedCheckCommands = ['CheckTypes', 'CheckTests', 'CheckLint'];
+    if (!sharedCheckCommands.includes(commandType)) {
+        return true;
+    }
+    const requestId = command.message.requestId;
+    if (requestId === undefined || requestId === null || requestId === '') {
+        return true;
+    }
+    const workflowRoot = getWorkflowRoot(requestId, allMessages);
+    if (isServerWorkflowCommand(workflowRoot)) {
+        return true;
+    }
+    return !isClientWorkflowCommand(workflowRoot);
+}
+function groupCommandsByTarget(commands) {
+    const commandsByTarget = new Map();
+    for (const command of commands) {
+        const targetId = extractTargetIdentifier(command.message.data);
+        commandsByTarget.set(targetId, command);
+    }
+    return commandsByTarget;
+}
+function checkCommandStatus(command, allMessages, commandEvents) {
+    const requestId = command.message.requestId;
+    if (requestId === undefined || requestId === null || requestId === '') {
+        return { hasCompletion: false, hasFailed: false };
+    }
+    const relatedEvents = allMessages.filter((msg) => msg.messageType === 'event' && msg.message.requestId === requestId);
+    const hasCompletion = relatedEvents.some((event) => commandEvents.includes(event.message.type));
+    const hasFailed = relatedEvents.some(hasEventError);
+    return { hasCompletion, hasFailed };
+}
+function determineStatusFromCommands(commandsByTarget, allMessages, commandEvents) {
+    let hasAnyRunning = false;
+    let hasAnyFailure = false;
+    let allCompleted = true;
+    for (const command of commandsByTarget.values()) {
+        const { hasCompletion, hasFailed } = checkCommandStatus(command, allMessages, commandEvents);
+        if (!hasCompletion) {
+            hasAnyRunning = true;
+            allCompleted = false;
+            continue;
+        }
+        if (hasFailed) {
+            hasAnyFailure = true;
+        }
+    }
+    if (hasAnyFailure) {
+        return 'fail';
+    }
+    if (hasAnyRunning) {
+        return 'running';
+    }
+    if (allCompleted) {
+        return 'pass';
+    }
+    return 'running';
+}
+/**
+ * Calculate status for a pipeline node based on message store
+ */
+async function calculateNodeStatus(commandType, messageStore, metadataService) {
+    try {
+        const allMessages = await messageStore.getAllMessages();
+        const allCommands = allMessages
+            .filter((msg) => msg.messageType === 'command' && msg.message.type === commandType)
+            .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        if (allCommands.length === 0) {
+            return 'idle';
+        }
+        const commandEventMappings = buildCommandEventMappings(metadataService);
+        const commandEvents = commandEventMappings[commandType];
+        if (commandEvents === undefined) {
+            return 'None';
+        }
+        const commands = allCommands.filter((cmd) => shouldIncludeCommandInNodeStatus(cmd, commandType, allMessages));
+        if (commands.length === 0) {
+            return 'idle';
+        }
+        const commandsByTarget = groupCommandsByTarget(commands);
+        return determineStatusFromCommands(commandsByTarget, allMessages, commandEvents);
+    }
+    catch (error) {
+        debug('Error calculating node status for %s: %O', commandType, error);
+        throw error;
+    }
+}
+function processEventHandlers(eventHandlers, commandNodes, eventToCommandMap) {
+    debug('Using event handlers, found %d handlers', eventHandlers.size);
+    for (const [eventType, handlers] of eventHandlers) {
+        debug('Processing event type %s with %d handlers', eventType, handlers.length);
+        const sourceCommand = eventToCommandMap[eventType] || null;
+        debug('Source command for %s = %s', eventType, sourceCommand);
+        if (sourceCommand !== null && sourceCommand !== '') {
+            commandNodes.add(sourceCommand);
+            debug('Warning: eventHandlers path cannot determine target commands - skipping edge creation');
+        }
+    }
+    debug('Final nodes: %o', Array.from(commandNodes));
+}
+function processDslRegistrations(dslRegistrations, commandNodes, edges, metadataService, eventToCommandMap) {
+    const regsToProcess = dslRegistrations || registrations;
+    debug('Using DSL registrations, found %d registrations', regsToProcess.length);
+    regsToProcess.forEach((registration) => {
+        if (registration.type === 'on') {
+            processEventRegistration(registration, commandNodes, edges, metadataService, eventToCommandMap);
+        }
+        if (registration.type === 'on-settled') {
+            processSettledRegistration(registration, commandNodes, edges, metadataService);
+        }
+    });
+}
+/**
+ * Generate pipeline graph from current registrations
+ */
+export async function getPipelineGraph(config = {}) {
+    const { metadataService, eventHandlers, messageStore, dslRegistrations } = config;
+    const commandNodes = new Set();
+    const edges = [];
+    debug('Called with metadataService=%s eventHandlers=%s eventHandlers size=%s messageStore=%s dslRegistrations=%s', !!metadataService, !!eventHandlers, eventHandlers?.size, !!messageStore, dslRegistrations?.length ?? 0);
+    const eventToCommandMap = buildEventToCommandMapping(metadataService);
+    debug('Built %d dynamic event-to-command mappings from metadata service', Object.keys(eventToCommandMap).length);
+    if (eventHandlers) {
+        processEventHandlers(eventHandlers, commandNodes, eventToCommandMap);
+    }
+    else {
+        processDslRegistrations(dslRegistrations, commandNodes, edges, metadataService, eventToCommandMap);
+    }
+    const nodes = await Promise.all(Array.from(commandNodes).map(async (commandType) => {
+        const baseNode = {
+            id: commandType,
+            name: commandType,
+            title: camelCaseToTitleCase(commandType),
+        };
+        let status = 'None';
+        if (messageStore) {
+            status = await calculateNodeStatus(commandType, messageStore, metadataService);
+        }
+        if (metadataService) {
+            const metadata = metadataService.getCommandMetadata(commandType);
+            if (metadata) {
+                return {
+                    ...baseNode,
+                    id: `${metadata.package}/${metadata.alias}`,
+                    title: camelCaseToTitleCase(commandType),
+                    alias: metadata.alias,
+                    description: metadata.description,
+                    package: metadata.package,
+                    version: metadata.version,
+                    category: metadata.category,
+                    icon: metadata.icon ?? 'terminal',
+                    status,
+                };
+            }
+        }
+        return {
+            ...baseNode,
+            icon: 'terminal',
+            status,
+        };
+    }));
+    const commandToEvents = buildCommandEventMappings(metadataService);
+    return { nodes, edges, commandToEvents, eventToCommand: eventToCommandMap };
+}
+function processEventRegistration(registration, commandNodes, edges, metadataService, eventToCommandMap) {
+    try {
+        const mockEvent = { type: registration.eventType, data: {} };
+        const result = registration.handler(mockEvent);
+        if (result && typeof result === 'object' && 'type' in result) {
+            addCommandAndEdge(result, registration.eventType, commandNodes, edges, metadataService, eventToCommandMap);
+        }
+        else if (Array.isArray(result)) {
+            result.forEach((command) => {
+                if (command !== null && typeof command === 'object' && 'type' in command && typeof command.type === 'string') {
+                    addCommandAndEdge(command, registration.eventType, commandNodes, edges, metadataService, eventToCommandMap);
+                }
+            });
+        }
+    }
+    catch {
+        // Handler might require specific event data, skip if it fails
+    }
+}
+function processSettledRegistration(registration, commandNodes, edges, metadataService) {
+    function getNodeId(commandType) {
+        if (metadataService) {
+            const metadata = metadataService.getCommandMetadata(commandType);
+            if (metadata) {
+                return `${metadata.package}/${metadata.alias}`;
+            }
+        }
+        return commandType;
+    }
+    registration.commandTypes.forEach((commandType) => {
+        commandNodes.add(commandType);
+    });
+    if (registration.dispatches && registration.dispatches.length > 0) {
+        registration.dispatches.forEach((commandType) => {
+            commandNodes.add(commandType);
+            registration.commandTypes.forEach((settledCommand) => {
+                edges.push({
+                    from: getNodeId(settledCommand),
+                    to: getNodeId(commandType),
+                });
+            });
+        });
+    }
+}
+function addCommandAndEdge(command, eventType, commandNodes, edges, metadataService, eventToCommandMap) {
+    function getNodeId(commandType) {
+        if (metadataService) {
+            const metadata = metadataService.getCommandMetadata(commandType);
+            if (metadata) {
+                return `${metadata.package}/${metadata.alias}`;
+            }
+        }
+        return commandType;
+    }
+    commandNodes.add(command.type);
+    const sourceCommand = eventToCommandMap?.[eventType];
+    if (sourceCommand !== undefined) {
+        commandNodes.add(sourceCommand);
+        edges.push({
+            from: getNodeId(sourceCommand),
+            to: getNodeId(command.type),
+        });
+    }
+}
+//# sourceMappingURL=index.js.map