@pikku/inspector 0.11.2 → 0.12.0

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

@@ -1,256 +1,90 @@
 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);
-                }
+function extractAstValue(expr, refParamName, templateParamName) {
+    if (ts.isStringLiteral(expr)) {
+        return expr.text;
+    }
+    if (ts.isNumericLiteral(expr)) {
+        return Number(expr.text);
+    }
+    if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+        return true;
+    }
+    if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+        return false;
+    }
+    if (expr.kind === ts.SyntaxKind.NullKeyword) {
+        return null;
+    }
+    if (ts.isCallExpression(expr)) {
+        const callee = expr.expression;
+        if (ts.isIdentifier(callee)) {
+            if (callee.text === refParamName) {
+                const args = expr.arguments;
+                const nodeId = args[0] && ts.isStringLiteral(args[0]) ? args[0].text : 'unknown';
+                const path = args[1] && ts.isStringLiteral(args[1]) ? args[1].text : undefined;
+                return { $ref: nodeId, path };
             }
-            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);
+            if (templateParamName && callee.text === templateParamName) {
+                const templateStr = expr.arguments[0] && ts.isStringLiteral(expr.arguments[0])
+                    ? expr.arguments[0].text
+                    : '';
+                const refsArg = expr.arguments[1];
+                const refs = [];
+                if (refsArg && ts.isArrayLiteralExpression(refsArg)) {
+                    for (const el of refsArg.elements) {
+                        const resolved = extractAstValue(el, refParamName, templateParamName);
+                        if (typeof resolved === 'object' &&
+                            resolved !== null &&
+                            '$ref' in resolved) {
+                            refs.push(resolved);
                         }
-                        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);
-                    }
+                const parts = [];
+                const expressions = [];
+                const regex = /\$(\d+)/g;
+                let lastIndex = 0;
+                let match;
+                while ((match = regex.exec(templateStr)) !== null) {
+                    parts.push(templateStr.slice(lastIndex, match.index));
+                    const refIndex = parseInt(match[1], 10);
+                    expressions.push(refs[refIndex] ?? { $ref: 'unknown' });
+                    lastIndex = regex.lastIndex;
                 }
+                parts.push(templateStr.slice(lastIndex));
+                return { $template: { parts, expressions } };
             }
         }
     }
-    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 });
-            }
+    if (ts.isArrayLiteralExpression(expr)) {
+        return expr.elements.map((el) => extractAstValue(el, refParamName, templateParamName));
+    }
+    if (ts.isObjectLiteralExpression(expr)) {
+        const obj = {};
+        for (const prop of expr.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;
+            obj[key] = extractAstValue(prop.initializer, refParamName, templateParamName);
         }
+        return obj;
     }
-    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 });
-            }
+    if (ts.isPrefixUnaryExpression(expr)) {
+        if (expr.operator === ts.SyntaxKind.MinusToken &&
+            ts.isNumericLiteral(expr.operand)) {
+            return -Number(expr.operand.text);
         }
     }
-    return result;
+    return undefined;
 }
-/**
- * Extract input mapping from an arrow function
- * Parses: (ref) => ({ key: ref('nodeId', 'path'), key2: 'literal' })
- */
 function extractInputMapping(node, _checker) {
     if (!ts.isArrowFunction(node)) {
         return {};
@@ -279,6 +113,9 @@ function extractInputMapping(node, _checker) {
     const refParamName = node.parameters.length > 0 && ts.isIdentifier(node.parameters[0].name)
         ? node.parameters[0].name.text
         : 'ref';
+    const templateParamName = node.parameters.length > 1 && ts.isIdentifier(node.parameters[1].name)
+        ? node.parameters[1].name.text
+        : undefined;
     const input = {};
     for (const prop of bodyObj.properties) {
         if (!ts.isPropertyAssignment(prop))
@@ -290,32 +127,9 @@ function extractInputMapping(node, _checker) {
                 : 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;
+        const value = extractAstValue(prop.initializer, refParamName, templateParamName);
+        if (value !== undefined) {
+            input[key] = value;
         }
     }
     return input;
@@ -357,35 +171,6 @@ function extractNextConfig(node, _checker) {
     }
     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
  */
@@ -416,77 +201,46 @@ function computeEntryNodeIds(graphNodes) {
     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: {...} })
+ * Extract pikkuWorkflowGraph config from an object literal argument
  */
-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;
-                }
-            }
+function extractWorkflowGraphConfig(configArg, checker) {
+    let name;
+    let description;
+    let tags;
+    let disabled;
+    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);
         }
-        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 };
+        else if (propName === 'description') {
+            description = extractStringLiteral(prop.initializer, checker);
+        }
+        else if (propName === 'disabled') {
+            if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                disabled = true;
             }
         }
+        else if (propName === 'tags' &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
+            tags = prop.initializer.elements
+                .filter(ts.isStringLiteral)
+                .map((el) => el.text);
+        }
+        else if (propName === 'nodes' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            nodesNode = prop.initializer;
+        }
+        else if (propName === 'config' &&
+            ts.isObjectLiteralExpression(prop.initializer)) {
+            configNode = prop.initializer;
+        }
     }
-    return undefined;
+    return { name, description, tags, disabled, nodesNode, configNode };
 }
 /**
  * Extract graph nodes from the new pikkuWorkflowGraph format
@@ -513,6 +267,10 @@ function extractGraphFromNewFormat(nodesNode, configNode, checker, state) {
         if (rpcName) {
             nodeRpcMap[nodeId] = rpcName;
             state.rpc.invokedFunctions.add(rpcName);
+            const funcFile = state.functions.files.get(rpcName);
+            if (funcFile && !state.rpc.internalFiles.has(rpcName)) {
+                state.rpc.internalFiles.set(rpcName, funcFile);
+            }
         }
     }
     // Initialize nodes with their RPC names
@@ -573,87 +331,66 @@ function extractNodeConfigFromObject(obj, checker) {
     return { next, onError, input };
 }
 /**
- * Inspector for wireWorkflow() calls with graph definitions
- * Detects: wireWorkflow({ wires: {...}, graph: pikkuWorkflowGraphResult })
+ * Inspector for pikkuWorkflowGraph() calls
+ * Detects: pikkuWorkflowGraph({ nodes: {...}, config: {...} })
+ * or: export const x = pikkuWorkflowGraph({...}) where the call is found via variable declaration
  */
 export const addWorkflowGraph = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
     const expression = node.expression;
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireWorkflow') {
+    if (!ts.isIdentifier(expression) ||
+        expression.text !== 'pikkuWorkflowGraph') {
         return;
     }
     const args = node.arguments;
     const firstArg = args[0];
     if (!firstArg) {
-        logger.critical(ErrorCode.MISSING_FUNC, 'wireWorkflow requires an argument');
+        logger.critical(ErrorCode.MISSING_FUNC, 'pikkuWorkflowGraph 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) {
+    if (!ts.isObjectLiteralExpression(firstArg)) {
+        logger.critical(ErrorCode.MISSING_FUNC, 'pikkuWorkflowGraph requires an object argument');
         return;
     }
-    // Extract config from the pikkuWorkflowGraph result
-    const graphConfig = extractPikkuWorkflowGraphConfig(graphPropNode, checker);
+    const graphConfig = extractWorkflowGraphConfig(firstArg, checker);
     if (!graphConfig) {
-        logger.critical(ErrorCode.MISSING_NAME, 'wireWorkflow with graph requires a pikkuWorkflowGraph');
+        logger.critical(ErrorCode.MISSING_NAME, 'pikkuWorkflowGraph: failed to extract config');
         return;
     }
-    // Use explicit name or fall back to exported variable name
+    // Resolve exportedName from variable declaration if this is `export const x = pikkuWorkflowGraph({...})`
+    const parent = node.parent;
+    if (!graphConfig.exportedName &&
+        parent &&
+        ts.isVariableDeclaration(parent) &&
+        ts.isIdentifier(parent.name)) {
+        graphConfig.exportedName = parent.name.text;
+    }
     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');
+        logger.critical(ErrorCode.MISSING_NAME, 'pikkuWorkflowGraph requires 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,
+        pikkuFuncId: 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,
-        });
-    }
+    if (graphConfig.disabled)
+        return;
+    state.workflows.graphMeta[workflowName] = serialized;
+    state.workflows.graphFiles.set(workflowName, {
+        path: node.getSourceFile().fileName,
+        exportedName: graphConfig.exportedName || workflowName,
+    });
 };