@pikku/inspector 0.11.0 → 0.11.2

package/dist/add/add-workflow-graph.d.ts

@@ -0,0 +1,6 @@
+import type { AddWiring } from '../types.js';
+/**
+ * Inspector for wireWorkflow() calls with graph definitions
+ * Detects: wireWorkflow({ wires: {...}, graph: pikkuWorkflowGraphResult })
+ */
+export declare const addWorkflowGraph: AddWiring;

package/dist/add/add-workflow-graph.js

@@ -0,0 +1,659 @@
+import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
+import { extractStringLiteral } from '../utils/extract-node-value.js';
+/**
+ * Extract wire configuration from object literal
+ */
+function extractWiresConfig(wiresNode, checker) {
+    const wires = {};
+    for (const prop of wiresNode.properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+            continue;
+        const propName = prop.name.text;
+        if (propName === 'http' && ts.isArrayLiteralExpression(prop.initializer)) {
+            wires.http = [];
+            for (const elem of prop.initializer.elements) {
+                if (ts.isObjectLiteralExpression(elem)) {
+                    const httpWire = {};
+                    for (const httpProp of elem.properties) {
+                        if (!ts.isPropertyAssignment(httpProp) ||
+                            !ts.isIdentifier(httpProp.name))
+                            continue;
+                        const httpPropName = httpProp.name.text;
+                        if (httpPropName === 'route') {
+                            httpWire.route = extractStringLiteral(httpProp.initializer, checker);
+                        }
+                        else if (httpPropName === 'method') {
+                            httpWire.method = extractStringLiteral(httpProp.initializer, checker);
+                        }
+                        else if (httpPropName === 'startNode') {
+                            httpWire.startNode = extractStringLiteral(httpProp.initializer, checker);
+                        }
+                    }
+                    if (httpWire.route && httpWire.method && httpWire.startNode) {
+                        wires.http.push(httpWire);
+                    }
+                }
+            }
+        }
+        else if (propName === 'channel' &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
+            wires.channel = [];
+            for (const elem of prop.initializer.elements) {
+                if (ts.isObjectLiteralExpression(elem)) {
+                    const channelWire = {};
+                    for (const channelProp of elem.properties) {
+                        if (!ts.isPropertyAssignment(channelProp) ||
+                            !ts.isIdentifier(channelProp.name))
+                            continue;
+                        const channelPropName = channelProp.name.text;
+                        if (channelPropName === 'name') {
+                            channelWire.name = extractStringLiteral(channelProp.initializer, checker);
+                        }
+                        else if (channelPropName === 'onConnect') {
+                            channelWire.onConnect = extractStringLiteral(channelProp.initializer, checker);
+                        }
+                        else if (channelPropName === 'onDisconnect') {
+                            channelWire.onDisconnect = extractStringLiteral(channelProp.initializer, checker);
+                        }
+                        else if (channelPropName === 'onMessage') {
+                            channelWire.onMessage = extractStringLiteral(channelProp.initializer, checker);
+                        }
+                    }
+                    if (channelWire.name) {
+                        wires.channel.push(channelWire);
+                    }
+                }
+            }
+        }
+        else if (propName === 'queue' &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
+            wires.queue = [];
+            for (const elem of prop.initializer.elements) {
+                if (ts.isObjectLiteralExpression(elem)) {
+                    const queueWire = {};
+                    for (const queueProp of elem.properties) {
+                        if (!ts.isPropertyAssignment(queueProp) ||
+                            !ts.isIdentifier(queueProp.name))
+                            continue;
+                        const queuePropName = queueProp.name.text;
+                        if (queuePropName === 'name') {
+                            queueWire.name = extractStringLiteral(queueProp.initializer, checker);
+                        }
+                        else if (queuePropName === 'startNode') {
+                            queueWire.startNode = extractStringLiteral(queueProp.initializer, checker);
+                        }
+                    }
+                    if (queueWire.name && queueWire.startNode) {
+                        wires.queue.push(queueWire);
+                    }
+                }
+            }
+        }
+        else if (propName === 'cli' &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
+            wires.cli = [];
+            for (const elem of prop.initializer.elements) {
+                if (ts.isObjectLiteralExpression(elem)) {
+                    const cliWire = {};
+                    for (const cliProp of elem.properties) {
+                        if (!ts.isPropertyAssignment(cliProp) ||
+                            !ts.isIdentifier(cliProp.name))
+                            continue;
+                        const cliPropName = cliProp.name.text;
+                        if (cliPropName === 'command') {
+                            cliWire.command = extractStringLiteral(cliProp.initializer, checker);
+                        }
+                        else if (cliPropName === 'startNode') {
+                            cliWire.startNode = extractStringLiteral(cliProp.initializer, checker);
+                        }
+                    }
+                    if (cliWire.command && cliWire.startNode) {
+                        wires.cli.push(cliWire);
+                    }
+                }
+            }
+        }
+        else if (propName === 'mcp' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            const mcpWires = {};
+            for (const mcpProp of prop.initializer.properties) {
+                if (!ts.isPropertyAssignment(mcpProp) || !ts.isIdentifier(mcpProp.name))
+                    continue;
+                const mcpPropName = mcpProp.name.text;
+                if (mcpPropName === 'tool' &&
+                    ts.isArrayLiteralExpression(mcpProp.initializer)) {
+                    mcpWires.tool = extractMcpToolWireArray(mcpProp.initializer, checker);
+                }
+                else if (mcpPropName === 'prompt' &&
+                    ts.isArrayLiteralExpression(mcpProp.initializer)) {
+                    mcpWires.prompt = extractMcpToolWireArray(mcpProp.initializer, checker);
+                }
+                else if (mcpPropName === 'resource' &&
+                    ts.isArrayLiteralExpression(mcpProp.initializer)) {
+                    mcpWires.resource = extractMcpResourceWireArray(mcpProp.initializer, checker);
+                }
+            }
+            if (mcpWires.tool || mcpWires.prompt || mcpWires.resource) {
+                wires.mcp = mcpWires;
+            }
+        }
+        else if (propName === 'schedule' &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
+            wires.schedule = [];
+            for (const elem of prop.initializer.elements) {
+                if (ts.isObjectLiteralExpression(elem)) {
+                    const scheduleWire = {};
+                    for (const scheduleProp of elem.properties) {
+                        if (!ts.isPropertyAssignment(scheduleProp) ||
+                            !ts.isIdentifier(scheduleProp.name))
+                            continue;
+                        const schedulePropName = scheduleProp.name.text;
+                        if (schedulePropName === 'cron') {
+                            scheduleWire.cron = extractStringLiteral(scheduleProp.initializer, checker);
+                        }
+                        else if (schedulePropName === 'interval') {
+                            scheduleWire.interval = extractStringLiteral(scheduleProp.initializer, checker);
+                        }
+                        else if (schedulePropName === 'startNode') {
+                            scheduleWire.startNode = extractStringLiteral(scheduleProp.initializer, checker);
+                        }
+                    }
+                    if ((scheduleWire.cron || scheduleWire.interval) &&
+                        scheduleWire.startNode) {
+                        wires.schedule.push(scheduleWire);
+                    }
+                }
+            }
+        }
+        else if (propName === 'trigger' &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
+            wires.trigger = [];
+            for (const elem of prop.initializer.elements) {
+                if (ts.isObjectLiteralExpression(elem)) {
+                    const triggerWire = {};
+                    for (const triggerProp of elem.properties) {
+                        if (!ts.isPropertyAssignment(triggerProp) ||
+                            !ts.isIdentifier(triggerProp.name))
+                            continue;
+                        const triggerPropName = triggerProp.name.text;
+                        if (triggerPropName === 'name') {
+                            triggerWire.name = extractStringLiteral(triggerProp.initializer, checker);
+                        }
+                        else if (triggerPropName === 'startNode') {
+                            triggerWire.startNode = extractStringLiteral(triggerProp.initializer, checker);
+                        }
+                    }
+                    if (triggerWire.name && triggerWire.startNode) {
+                        wires.trigger.push(triggerWire);
+                    }
+                }
+            }
+        }
+    }
+    return wires;
+}
+/**
+ * Helper to extract MCP wire arrays for tool/prompt (name field)
+ */
+function extractMcpToolWireArray(arrayNode, checker) {
+    const result = [];
+    for (const elem of arrayNode.elements) {
+        if (ts.isObjectLiteralExpression(elem)) {
+            let name;
+            let startNode;
+            for (const prop of elem.properties) {
+                if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                    continue;
+                const propName = prop.name.text;
+                if (propName === 'name') {
+                    name = extractStringLiteral(prop.initializer, checker);
+                }
+                else if (propName === 'startNode') {
+                    startNode = extractStringLiteral(prop.initializer, checker);
+                }
+            }
+            if (name && startNode) {
+                result.push({ name, startNode });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Helper to extract MCP wire arrays for resource (uri field)
+ */
+function extractMcpResourceWireArray(arrayNode, checker) {
+    const result = [];
+    for (const elem of arrayNode.elements) {
+        if (ts.isObjectLiteralExpression(elem)) {
+            let uri;
+            let startNode;
+            for (const prop of elem.properties) {
+                if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                    continue;
+                const propName = prop.name.text;
+                if (propName === 'uri') {
+                    uri = extractStringLiteral(prop.initializer, checker);
+                }
+                else if (propName === 'startNode') {
+                    startNode = extractStringLiteral(prop.initializer, checker);
+                }
+            }
+            if (uri && startNode) {
+                result.push({ uri, startNode });
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Extract input mapping from an arrow function
+ * Parses: (ref) => ({ key: ref('nodeId', 'path'), key2: 'literal' })
+ */
+function extractInputMapping(node, _checker) {
+    if (!ts.isArrowFunction(node)) {
+        return {};
+    }
+    let bodyObj;
+    if (ts.isObjectLiteralExpression(node.body)) {
+        bodyObj = node.body;
+    }
+    else if (ts.isParenthesizedExpression(node.body)) {
+        if (ts.isObjectLiteralExpression(node.body.expression)) {
+            bodyObj = node.body.expression;
+        }
+    }
+    else if (ts.isBlock(node.body)) {
+        for (const stmt of node.body.statements) {
+            if (ts.isReturnStatement(stmt) && stmt.expression) {
+                if (ts.isObjectLiteralExpression(stmt.expression)) {
+                    bodyObj = stmt.expression;
+                }
+            }
+        }
+    }
+    if (!bodyObj) {
+        return {};
+    }
+    const refParamName = node.parameters.length > 0 && ts.isIdentifier(node.parameters[0].name)
+        ? node.parameters[0].name.text
+        : 'ref';
+    const input = {};
+    for (const prop of bodyObj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const key = ts.isIdentifier(prop.name)
+            ? prop.name.text
+            : ts.isStringLiteral(prop.name)
+                ? prop.name.text
+                : null;
+        if (!key)
+            continue;
+        if (ts.isCallExpression(prop.initializer)) {
+            const callExpr = prop.initializer.expression;
+            if (ts.isIdentifier(callExpr) && callExpr.text === refParamName) {
+                const args = prop.initializer.arguments;
+                const nodeIdArg = args[0];
+                const pathArg = args[1];
+                const nodeId = nodeIdArg && ts.isStringLiteral(nodeIdArg)
+                    ? nodeIdArg.text
+                    : 'unknown';
+                const path = pathArg && ts.isStringLiteral(pathArg) ? pathArg.text : undefined;
+                input[key] = { $ref: nodeId, path };
+                continue;
+            }
+        }
+        if (ts.isStringLiteral(prop.initializer)) {
+            input[key] = prop.initializer.text;
+        }
+        else if (ts.isNumericLiteral(prop.initializer)) {
+            input[key] = Number(prop.initializer.text);
+        }
+        else if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+            prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+            input[key] = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+        }
+        else if (prop.initializer.kind === ts.SyntaxKind.NullKeyword) {
+            input[key] = null;
+        }
+    }
+    return input;
+}
+/**
+ * Extract next config (string, array, or record)
+ */
+function extractNextConfig(node, _checker) {
+    if (ts.isStringLiteral(node)) {
+        return node.text;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return node.elements
+            .filter(ts.isStringLiteral)
+            .map((el) => el.text);
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const result = {};
+        for (const prop of node.properties) {
+            if (!ts.isPropertyAssignment(prop))
+                continue;
+            const key = ts.isIdentifier(prop.name)
+                ? prop.name.text
+                : ts.isStringLiteral(prop.name)
+                    ? prop.name.text
+                    : null;
+            if (!key)
+                continue;
+            if (ts.isStringLiteral(prop.initializer)) {
+                result[key] = prop.initializer.text;
+            }
+            else if (ts.isArrayLiteralExpression(prop.initializer)) {
+                result[key] = prop.initializer.elements
+                    .filter(ts.isStringLiteral)
+                    .map((el) => el.text);
+            }
+        }
+        return result;
+    }
+    return undefined;
+}
+/**
+ * Extract definition object from wireWorkflow call
+ */
+function extractDefinitionObject(firstArg) {
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        return firstArg;
+    }
+    if (ts.isArrowFunction(firstArg)) {
+        const body = firstArg.body;
+        if (ts.isObjectLiteralExpression(body)) {
+            return body;
+        }
+        if (ts.isParenthesizedExpression(body)) {
+            if (ts.isObjectLiteralExpression(body.expression)) {
+                return body.expression;
+            }
+        }
+        if (ts.isBlock(body)) {
+            for (const stmt of body.statements) {
+                if (ts.isReturnStatement(stmt) && stmt.expression) {
+                    if (ts.isObjectLiteralExpression(stmt.expression)) {
+                        return stmt.expression;
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Compute entry node IDs from graph nodes
+ */
+function computeEntryNodeIds(graphNodes) {
+    const hasIncomingEdge = new Set();
+    for (const node of Object.values(graphNodes)) {
+        const next = node.next;
+        if (!next)
+            continue;
+        if (typeof next === 'string') {
+            hasIncomingEdge.add(next);
+        }
+        else if (Array.isArray(next)) {
+            next.forEach((n) => hasIncomingEdge.add(n));
+        }
+        else if (typeof next === 'object') {
+            for (const targets of Object.values(next)) {
+                if (typeof targets === 'string') {
+                    hasIncomingEdge.add(targets);
+                }
+                else if (Array.isArray(targets)) {
+                    ;
+                    targets.forEach((n) => hasIncomingEdge.add(n));
+                }
+            }
+        }
+    }
+    return Object.keys(graphNodes).filter((nodeId) => !hasIncomingEdge.has(nodeId));
+}
+/**
+ * Extract pikkuWorkflowGraph config from a variable reference or call expression
+ * New format: pikkuWorkflowGraph({ nodes: {...}, wires: {...}, config: {...} })
+ */
+function extractPikkuWorkflowGraphConfig(node, checker) {
+    // If it's an identifier, resolve to the declaration
+    if (ts.isIdentifier(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        if (symbol) {
+            const declarations = symbol.getDeclarations();
+            if (declarations && declarations.length > 0) {
+                const decl = declarations[0];
+                if (ts.isVariableDeclaration(decl) && decl.initializer) {
+                    const result = extractPikkuWorkflowGraphConfig(decl.initializer, checker);
+                    if (result) {
+                        // Use the variable name as exportedName
+                        result.exportedName = ts.isIdentifier(decl.name)
+                            ? decl.name.text
+                            : undefined;
+                    }
+                    return result;
+                }
+            }
+        }
+        return undefined;
+    }
+    // If it's a call expression to pikkuWorkflowGraph
+    if (ts.isCallExpression(node)) {
+        const expr = node.expression;
+        if (ts.isIdentifier(expr) && expr.text === 'pikkuWorkflowGraph') {
+            const configArg = node.arguments[0];
+            if (configArg && ts.isObjectLiteralExpression(configArg)) {
+                let name;
+                let description;
+                let tags;
+                let wires;
+                let nodesNode;
+                let configNode;
+                for (const prop of configArg.properties) {
+                    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+                        continue;
+                    const propName = prop.name.text;
+                    if (propName === 'name') {
+                        name = extractStringLiteral(prop.initializer, checker);
+                    }
+                    else if (propName === 'description') {
+                        description = extractStringLiteral(prop.initializer, checker);
+                    }
+                    else if (propName === 'tags' &&
+                        ts.isArrayLiteralExpression(prop.initializer)) {
+                        tags = prop.initializer.elements
+                            .filter(ts.isStringLiteral)
+                            .map((el) => el.text);
+                    }
+                    else if (propName === 'wires' &&
+                        ts.isObjectLiteralExpression(prop.initializer)) {
+                        wires = extractWiresConfig(prop.initializer, checker);
+                    }
+                    else if (propName === 'nodes' &&
+                        ts.isObjectLiteralExpression(prop.initializer)) {
+                        nodesNode = prop.initializer;
+                    }
+                    else if (propName === 'config' &&
+                        ts.isObjectLiteralExpression(prop.initializer)) {
+                        configNode = prop.initializer;
+                    }
+                }
+                return { name, description, tags, wires, nodesNode, configNode };
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract graph nodes from the new pikkuWorkflowGraph format
+ * New format: { nodes: { entry: 'rpcName', ... }, config: { entry: { next: 'sendWelcome', ... }, ... } }
+ */
+function extractGraphFromNewFormat(nodesNode, configNode, checker, state) {
+    const nodes = {};
+    if (!nodesNode) {
+        return nodes;
+    }
+    // Extract node ID to RPC name mapping from 'nodes' property
+    const nodeRpcMap = {};
+    for (const prop of nodesNode.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const nodeId = ts.isIdentifier(prop.name)
+            ? prop.name.text
+            : ts.isStringLiteral(prop.name)
+                ? prop.name.text
+                : null;
+        if (!nodeId)
+            continue;
+        const rpcName = extractStringLiteral(prop.initializer, checker);
+        if (rpcName) {
+            nodeRpcMap[nodeId] = rpcName;
+            state.rpc.invokedFunctions.add(rpcName);
+        }
+    }
+    // Initialize nodes with their RPC names
+    for (const [nodeId, rpcName] of Object.entries(nodeRpcMap)) {
+        nodes[nodeId] = {
+            nodeId,
+            rpcName,
+            input: {},
+            next: undefined,
+            onError: undefined,
+        };
+    }
+    // Extract config for each node from 'config' property
+    if (configNode) {
+        for (const prop of configNode.properties) {
+            if (!ts.isPropertyAssignment(prop))
+                continue;
+            const nodeId = ts.isIdentifier(prop.name)
+                ? prop.name.text
+                : ts.isStringLiteral(prop.name)
+                    ? prop.name.text
+                    : null;
+            if (!nodeId || !nodes[nodeId])
+                continue;
+            if (ts.isObjectLiteralExpression(prop.initializer)) {
+                const nodeConfig = extractNodeConfigFromObject(prop.initializer, checker);
+                if (nodeConfig) {
+                    nodes[nodeId].next = nodeConfig.next;
+                    nodes[nodeId].onError = nodeConfig.onError;
+                    nodes[nodeId].input = nodeConfig.input;
+                }
+            }
+        }
+    }
+    return nodes;
+}
+/**
+ * Extract node config (next, onError, input) from object literal
+ */
+function extractNodeConfigFromObject(obj, checker) {
+    let next = undefined;
+    let onError = undefined;
+    let input = {};
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+            continue;
+        const propName = prop.name.text;
+        if (propName === 'next') {
+            next = extractNextConfig(prop.initializer, checker);
+        }
+        else if (propName === 'onError') {
+            onError = extractNextConfig(prop.initializer, checker);
+        }
+        else if (propName === 'input') {
+            input = extractInputMapping(prop.initializer, checker);
+        }
+    }
+    return { next, onError, input };
+}
+/**
+ * Inspector for wireWorkflow() calls with graph definitions
+ * Detects: wireWorkflow({ wires: {...}, graph: pikkuWorkflowGraphResult })
+ */
+export const addWorkflowGraph = (logger, node, checker, state) => {
+    if (!ts.isCallExpression(node)) {
+        return;
+    }
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireWorkflow') {
+        return;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    if (!firstArg) {
+        logger.critical(ErrorCode.MISSING_FUNC, 'wireWorkflow requires an argument');
+        return;
+    }
+    const definitionObj = extractDefinitionObject(firstArg);
+    if (!definitionObj) {
+        logger.critical(ErrorCode.MISSING_FUNC, 'wireWorkflow requires an object argument');
+        return;
+    }
+    // Check if this is a graph workflow (has 'graph' property)
+    let graphPropNode;
+    let enabled = true; // Default to true
+    for (const prop of definitionObj.properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name))
+            continue;
+        const propName = prop.name.text;
+        if (propName === 'graph') {
+            graphPropNode = prop.initializer;
+        }
+        else if (propName === 'enabled') {
+            // Check if enabled is explicitly set to false
+            if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                enabled = false;
+            }
+        }
+        // Note: We no longer extract wires from wireWorkflow - they come from pikkuWorkflowGraph
+    }
+    // If no graph property, this is a DSL workflow - skip (handled by add-workflow.ts)
+    if (!graphPropNode) {
+        return;
+    }
+    // Extract config from the pikkuWorkflowGraph result
+    const graphConfig = extractPikkuWorkflowGraphConfig(graphPropNode, checker);
+    if (!graphConfig) {
+        logger.critical(ErrorCode.MISSING_NAME, 'wireWorkflow with graph requires a pikkuWorkflowGraph');
+        return;
+    }
+    // Use explicit name or fall back to exported variable name
+    const workflowName = graphConfig.name || graphConfig.exportedName;
+    if (!workflowName) {
+        logger.critical(ErrorCode.MISSING_NAME, 'wireWorkflow with graph requires a pikkuWorkflowGraph with a name property or exported variable name');
+        return;
+    }
+    // Extract graph nodes from the new format (nodes + config properties)
+    let graphNodes = {};
+    if (graphConfig.nodesNode) {
+        graphNodes = extractGraphFromNewFormat(graphConfig.nodesNode, graphConfig.configNode, checker, state);
+    }
+    const entryNodeIds = computeEntryNodeIds(graphNodes);
+    // Use wires from pikkuWorkflowGraph (not from wireWorkflow)
+    const wires = graphConfig.wires || {};
+    const serialized = {
+        name: workflowName,
+        pikkuFuncName: workflowName,
+        source: 'graph',
+        description: graphConfig.description,
+        tags: graphConfig.tags,
+        wires,
+        nodes: graphNodes,
+        entryNodeIds,
+    };
+    // Only add if enabled (or not explicitly disabled)
+    if (enabled) {
+        state.workflows.graphMeta[workflowName] = serialized;
+        // Store file path and exported name for import generation
+        state.workflows.graphFiles.set(workflowName, {
+            path: node.getSourceFile().fileName,
+            exportedName: graphConfig.exportedName || workflowName,
+        });
+    }
+};

package/dist/add/add-workflow.d.ts

@@ -1,6 +1,6 @@
 import { AddWiring } from '../types.js';
 /**
- * Inspector for wireWorkflow() calls
+ * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
  * Detects workflow registration and extracts metadata
  */
 export declare const addWorkflow: AddWiring;