@pikku/inspector 0.11.2 → 0.12.1

package/src/add/add-workflow-graph.ts

@@ -5,347 +5,112 @@ import { extractStringLiteral } from '../utils/extract-node-value.js'
 import type {
   SerializedWorkflowGraph,
   DataRef,
-  WorkflowWiresConfig,
-  HttpWire,
-  ChannelWire,
-  QueueWire,
-  CliWire,
-  McpWires,
-  ScheduleWire,
-  TriggerWire,
 } from '../utils/workflow/graph/workflow-graph.types.js'
 
-/**
- * Extract wire configuration from object literal
- */
-function extractWiresConfig(
-  wiresNode: ts.ObjectLiteralExpression,
-  checker: ts.TypeChecker
-): WorkflowWiresConfig {
-  const wires: WorkflowWiresConfig = {}
-
-  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: Partial<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
-              ) as HttpWire['method']
-            } else if (httpPropName === 'startNode') {
-              httpWire.startNode = extractStringLiteral(
-                httpProp.initializer,
-                checker
-              )
-            }
-          }
-          if (httpWire.route && httpWire.method && httpWire.startNode) {
-            wires.http.push(httpWire as HttpWire)
-          }
-        }
+function extractAstValue(
+  expr: ts.Expression,
+  refParamName: string,
+  templateParamName: string | undefined
+): unknown {
+  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 } as DataRef
       }
-    } else if (
-      propName === 'channel' &&
-      ts.isArrayLiteralExpression(prop.initializer)
-    ) {
-      wires.channel = []
-      for (const elem of prop.initializer.elements) {
-        if (ts.isObjectLiteralExpression(elem)) {
-          const channelWire: Partial<ChannelWire> = {}
-          for (const channelProp of elem.properties) {
-            if (
-              !ts.isPropertyAssignment(channelProp) ||
-              !ts.isIdentifier(channelProp.name)
+      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: Array<{ $ref: string; path?: string }> = []
+        if (refsArg && ts.isArrayLiteralExpression(refsArg)) {
+          for (const el of refsArg.elements) {
+            const resolved = extractAstValue(
+              el,
+              refParamName,
+              templateParamName
             )
-              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 as ChannelWire)
-          }
-        }
-      }
-    } else if (
-      propName === 'queue' &&
-      ts.isArrayLiteralExpression(prop.initializer)
-    ) {
-      wires.queue = []
-      for (const elem of prop.initializer.elements) {
-        if (ts.isObjectLiteralExpression(elem)) {
-          const queueWire: Partial<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
-              )
+              typeof resolved === 'object' &&
+              resolved !== null &&
+              '$ref' in resolved
+            ) {
+              refs.push(resolved as { $ref: string; path?: string })
             }
           }
-          if (queueWire.name && queueWire.startNode) {
-            wires.queue.push(queueWire as QueueWire)
-          }
         }
-      }
-    } else if (
-      propName === 'cli' &&
-      ts.isArrayLiteralExpression(prop.initializer)
-    ) {
-      wires.cli = []
-      for (const elem of prop.initializer.elements) {
-        if (ts.isObjectLiteralExpression(elem)) {
-          const cliWire: Partial<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 as CliWire)
-          }
-        }
-      }
-    } else if (
-      propName === 'mcp' &&
-      ts.isObjectLiteralExpression(prop.initializer)
-    ) {
-      const mcpWires: 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: Partial<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 as ScheduleWire)
-          }
-        }
-      }
-    } else if (
-      propName === 'trigger' &&
-      ts.isArrayLiteralExpression(prop.initializer)
-    ) {
-      wires.trigger = []
-      for (const elem of prop.initializer.elements) {
-        if (ts.isObjectLiteralExpression(elem)) {
-          const triggerWire: Partial<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 as TriggerWire)
-          }
+        const parts: string[] = []
+        const expressions: Array<{ $ref: string; path?: string }> = []
+        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: ts.ArrayLiteralExpression,
-  checker: ts.TypeChecker
-): Array<{ name: string; startNode: string }> {
-  const result: Array<{ name: string; startNode: string }> = []
-  for (const elem of arrayNode.elements) {
-    if (ts.isObjectLiteralExpression(elem)) {
-      let name: string | undefined
-      let startNode: string | undefined
-      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: Record<string, unknown> = {}
+    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: ts.ArrayLiteralExpression,
-  checker: ts.TypeChecker
-): Array<{ uri: string; startNode: string }> {
-  const result: Array<{ uri: string; startNode: string }> = []
-  for (const elem of arrayNode.elements) {
-    if (ts.isObjectLiteralExpression(elem)) {
-      let uri: string | undefined
-      let startNode: string | undefined
-      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: ts.Node,
   _checker: ts.TypeChecker
@@ -381,6 +146,11 @@ function extractInputMapping(
       ? 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: Record<string, unknown | DataRef> = {}
 
   for (const prop of bodyObj.properties) {
@@ -394,36 +164,13 @@ function extractInputMapping(
 
     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 } as DataRef
-        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
     }
   }
 
@@ -474,43 +221,6 @@ function extractNextConfig(
   return undefined
 }
 
-/**
- * Extract definition object from wireWorkflow call
- */
-function extractDefinitionObject(
-  firstArg: ts.Node
-): ts.ObjectLiteralExpression | undefined {
-  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
  */
@@ -544,98 +254,59 @@ interface PikkuWorkflowGraphExtract {
   name?: string
   description?: string
   tags?: string[]
-  wires?: WorkflowWiresConfig
-  nodesNode?: ts.ObjectLiteralExpression // The nodes: { entry: 'rpc1', ... } object
-  configNode?: ts.ObjectLiteralExpression // The config: { entry: { next: ... }, ... } object
+  disabled?: true
+  nodesNode?: ts.ObjectLiteralExpression
+  configNode?: ts.ObjectLiteralExpression
   exportedName?: string
 }
 
 /**
- * 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: ts.Node,
+function extractWorkflowGraphConfig(
+  configArg: ts.ObjectLiteralExpression,
   checker: ts.TypeChecker
 ): PikkuWorkflowGraphExtract | undefined {
-  // 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: string | undefined
-        let description: string | undefined
-        let tags: string[] | undefined
-        let wires: WorkflowWiresConfig | undefined
-        let nodesNode: ts.ObjectLiteralExpression | undefined
-        let configNode: ts.ObjectLiteralExpression | undefined
-
-        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 as ts.StringLiteral).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
-          }
-        }
+  let name: string | undefined
+  let description: string | undefined
+  let tags: string[] | undefined
+  let disabled: true | undefined
+  let nodesNode: ts.ObjectLiteralExpression | undefined
+  let configNode: ts.ObjectLiteralExpression | undefined
+
+  for (const prop of configArg.properties) {
+    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue
 
-        return { name, description, tags, wires, nodesNode, configNode }
+    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 === '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 as ts.StringLiteral).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 }
 }
 
 /**
@@ -671,6 +342,10 @@ function extractGraphFromNewFormat(
     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)
+      }
     }
   }
 
@@ -748,8 +423,9 @@ function extractNodeConfigFromObject(
 }
 
 /**
- * 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: AddWiring = (logger, node, checker, state) => {
   if (!ts.isCallExpression(node)) {
@@ -757,7 +433,10 @@ export const addWorkflowGraph: AddWiring = (logger, node, checker, state) => {
   }
 
   const expression = node.expression
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireWorkflow') {
+  if (
+    !ts.isIdentifier(expression) ||
+    expression.text !== 'pikkuWorkflowGraph'
+  ) {
     return
   }
 
@@ -765,67 +444,52 @@ export const addWorkflowGraph: AddWiring = (logger, node, checker, state) => {
   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'
+      'pikkuWorkflowGraph requires an argument'
     )
     return
   }
 
-  // Check if this is a graph workflow (has 'graph' property)
-  let graphPropNode: ts.Node | undefined
-  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'
+      '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'
+      'pikkuWorkflowGraph requires a name property or exported variable name'
     )
     return
   }
 
-  // Extract graph nodes from the new format (nodes + config properties)
   let graphNodes: Record<string, any> = {}
   if (graphConfig.nodesNode) {
     graphNodes = extractGraphFromNewFormat(
@@ -838,27 +502,21 @@ export const addWorkflowGraph: AddWiring = (logger, node, checker, state) => {
 
   const entryNodeIds = computeEntryNodeIds(graphNodes)
 
-  // Use wires from pikkuWorkflowGraph (not from wireWorkflow)
-  const wires = graphConfig.wires || {}
-
   const serialized: SerializedWorkflowGraph = {
     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,
+  })
 }