@pikku/inspector 0.11.2 → 0.12.0

package/src/utils/workflow/dsl/deserialize-dsl-workflow.ts

@@ -134,6 +134,15 @@ function valueToCode(value: unknown, itemVar?: string): string {
   if (isTemplateRef(value)) {
     return templateRefToCode(value, itemVar)
   }
+  if (Array.isArray(value)) {
+    const elements = value.map((v) => valueToCode(v, itemVar))
+    return `[${elements.join(', ')}]`
+  }
+  if (typeof value === 'object' && value !== null) {
+    const entries = Object.entries(value)
+    const props = entries.map(([k, v]) => `${k}: ${valueToCode(v, itemVar)}`)
+    return `{ ${props.join(', ')} }`
+  }
   return JSON.stringify(value)
 }
 
@@ -845,6 +854,35 @@ function templateRefToGraphCode(
   return `template('${templateStr}', [${refs.join(', ')}])`
 }
 
+function valueToGraphCode(
+  value: unknown,
+  outputVarToNodeId: Map<string, string>,
+  refTracker: { hasRefs: boolean }
+): string {
+  if (isDataRef(value)) {
+    refTracker.hasRefs = true
+    return dataRefToGraphRef(value, outputVarToNodeId)
+  }
+  if (isTemplateRef(value)) {
+    refTracker.hasRefs = true
+    return templateRefToGraphCode(value, outputVarToNodeId)
+  }
+  if (Array.isArray(value)) {
+    const elements = value.map((v) =>
+      valueToGraphCode(v, outputVarToNodeId, refTracker)
+    )
+    return `[${elements.join(', ')}]`
+  }
+  if (typeof value === 'object' && value !== null) {
+    const entries = Object.entries(value)
+    const props = entries.map(
+      ([k, v]) => `${k}: ${valueToGraphCode(v, outputVarToNodeId, refTracker)}`
+    )
+    return `{ ${props.join(', ')} }`
+  }
+  return JSON.stringify(value)
+}
+
 /**
  * Convert input object to graph input code using ref()
  * @param input - The input mapping
@@ -860,87 +898,17 @@ function inputToGraphCode(
   const entries = Object.entries(input)
   if (entries.length === 0) return { hasRefs: false, code: '{}' }
 
-  let hasRefs = false
+  const refTracker = { hasRefs: false }
   const lines = entries.map(([key, value]) => {
-    if (isDataRef(value)) {
-      hasRefs = true
-      return `        ${key}: ${dataRefToGraphRef(value, outputVarToNodeId)},`
-    }
-    if (isTemplateRef(value)) {
-      hasRefs = true
-      return `        ${key}: ${templateRefToGraphCode(value, outputVarToNodeId)},`
-    }
-    return `        ${key}: ${JSON.stringify(value)},`
+    return `        ${key}: ${valueToGraphCode(value, outputVarToNodeId, refTracker)},`
   })
 
   return {
-    hasRefs,
+    hasRefs: refTracker.hasRefs,
     code: `{\n${lines.join('\n')}\n      }`,
   }
 }
 
-/**
- * Serialize wires to code
- */
-function wiresToCode(wires: SerializedWorkflowGraph['wires']): string {
-  if (!wires || Object.keys(wires).length === 0) return '{}'
-
-  const parts: string[] = []
-
-  if (wires.http && wires.http.length > 0) {
-    const httpItems = wires.http.map(
-      (h) =>
-        `{ route: '${h.route}', method: '${h.method}', startNode: '${h.startNode}' }`
-    )
-    parts.push(`http: [${httpItems.join(', ')}]`)
-  }
-
-  if (wires.channel && wires.channel.length > 0) {
-    const channelItems = wires.channel.map((c) => {
-      const channelParts: string[] = [`name: '${c.name}'`]
-      if (c.onConnect) channelParts.push(`onConnect: '${c.onConnect}'`)
-      if (c.onDisconnect) channelParts.push(`onDisconnect: '${c.onDisconnect}'`)
-      if (c.onMessage) channelParts.push(`onMessage: '${c.onMessage}'`)
-      return `{ ${channelParts.join(', ')} }`
-    })
-    parts.push(`channel: [${channelItems.join(', ')}]`)
-  }
-
-  if (wires.queue && wires.queue.length > 0) {
-    const queueItems = wires.queue.map(
-      (q) => `{ name: '${q.name}', startNode: '${q.startNode}' }`
-    )
-    parts.push(`queue: [${queueItems.join(', ')}]`)
-  }
-
-  if (wires.cli && wires.cli.length > 0) {
-    const cliItems = wires.cli.map(
-      (c) => `{ command: '${c.command}', startNode: '${c.startNode}' }`
-    )
-    parts.push(`cli: [${cliItems.join(', ')}]`)
-  }
-
-  if (wires.schedule && wires.schedule.length > 0) {
-    const scheduleItems = wires.schedule.map((s) => {
-      const scheduleParts: string[] = []
-      if (s.cron) scheduleParts.push(`cron: '${s.cron}'`)
-      if (s.interval) scheduleParts.push(`interval: '${s.interval}'`)
-      scheduleParts.push(`startNode: '${s.startNode}'`)
-      return `{ ${scheduleParts.join(', ')} }`
-    })
-    parts.push(`schedule: [${scheduleItems.join(', ')}]`)
-  }
-
-  if (wires.trigger && wires.trigger.length > 0) {
-    const triggerItems = wires.trigger.map(
-      (t) => `{ name: '${t.name}', startNode: '${t.startNode}' }`
-    )
-    parts.push(`trigger: [${triggerItems.join(', ')}]`)
-  }
-
-  return `{ ${parts.join(', ')} }`
-}
-
 /**
  * Check if a node is a flow node (non-RPC control flow)
  */
@@ -995,9 +963,7 @@ export function deserializeGraphWorkflow(
   const lines: string[] = []
 
   // Import statement
-  lines.push(
-    `import { pikkuWorkflowGraph, wireWorkflow } from '${pikkuImportPath}'`
-  )
+  lines.push(`import { pikkuWorkflowGraph } from '${pikkuImportPath}'`)
   lines.push('')
 
   // Add description as comment if present
@@ -1082,28 +1048,7 @@ export function deserializeGraphWorkflow(
     }
   }
 
-  // Compute entry node (first node with no incoming edges from RPC nodes)
-  const rpcNodeIds = new Set(Object.keys(nodeRpcMap))
-  const nodesWithIncomingEdges = new Set<string>()
-  for (const [nodeId, node] of Object.entries(workflow.nodes)) {
-    if (!rpcNodeIds.has(nodeId)) continue
-    if ('next' in node && node.next) {
-      const nextId = node.next as string
-      // Follow through flow nodes to find the actual next RPC node
-      const actualNextId = flowNodeIds.has(nextId)
-        ? findNextRpcNode(nextId, workflow.nodes, flowNodeIds)
-        : nextId
-      if (actualNextId && rpcNodeIds.has(actualNextId)) {
-        nodesWithIncomingEdges.add(actualNextId)
-      }
-    }
-  }
-  // Entry node is the first RPC node with no incoming edges
-  const entryNode = Object.keys(nodeRpcMap).find(
-    (id) => !nodesWithIncomingEdges.has(id)
-  )
-
-  // Generate the pikkuWorkflowGraph call
+  // Generate the pikkuWorkflowGraph call (builds graph and registers with core)
   lines.push(`export const ${workflow.name} = pikkuWorkflowGraph({`)
   lines.push(`  name: '${workflow.name}',`)
   if (workflow.description) {
@@ -1125,13 +1070,6 @@ export function deserializeGraphWorkflow(
     lines.push(`  nodes: {},`)
   }
 
-  // Generate wires with api entry point
-  if (entryNode) {
-    lines.push(`  wires: {`)
-    lines.push(`    api: '${entryNode}',`)
-    lines.push(`  },`)
-  }
-
   // Generate config (node configurations)
   if (nodeConfigs.length > 0) {
     lines.push(`  config: {`)
@@ -1142,20 +1080,6 @@ export function deserializeGraphWorkflow(
   lines.push(`})`)
   lines.push('')
 
-  // Always generate wireWorkflow to register the graph workflow
-  // (needed for testing even without explicit wires)
-  if (workflow.wires && Object.keys(workflow.wires).length > 0) {
-    lines.push(`wireWorkflow({`)
-    lines.push(`  wires: ${wiresToCode(workflow.wires)},`)
-    lines.push(`  graph: ${workflow.name},`)
-    lines.push(`})`)
-  } else {
-    lines.push(`wireWorkflow({`)
-    lines.push(`  graph: ${workflow.name},`)
-    lines.push(`})`)
-  }
-  lines.push('')
-
   return lines.join('\n')
 }
 

package/src/utils/workflow/dsl/extract-dsl-workflow.ts

@@ -1426,6 +1426,26 @@ function extractInputSources(
   return Object.keys(inputs).length > 0 ? inputs : undefined
 }
 
+function inputSourceToInlineValue(source: InputSource): unknown {
+  switch (source.from) {
+    case 'literal':
+      return source.value
+    case 'input':
+      return { $ref: 'trigger', path: source.path }
+    case 'outputVar':
+      return { $ref: source.name, path: source.path }
+    case 'item':
+      return { $ref: '$item', path: source.path }
+    case 'template':
+      return {
+        $template: {
+          parts: source.parts,
+          expressions: source.expressions.map(inputSourceToInlineValue),
+        },
+      }
+  }
+}
+
 /**
  * Extract a single input source
  */
@@ -1498,8 +1518,8 @@ function extractInputSource(
       if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
         const propName = prop.name.text
         const propSource = extractInputSource(prop.initializer, context)
-        if (propSource && propSource.from === 'literal') {
-          obj[propName] = propSource.value
+        if (propSource) {
+          obj[propName] = inputSourceToInlineValue(propSource)
         }
       }
     }
@@ -1511,8 +1531,8 @@ function extractInputSource(
     const arr: unknown[] = []
     for (const elem of node.elements) {
       const elemSource = extractInputSource(elem, context)
-      if (elemSource && elemSource.from === 'literal') {
-        arr.push(elemSource.value)
+      if (elemSource) {
+        arr.push(inputSourceToInlineValue(elemSource))
       }
     }
     return { from: 'literal', value: arr }

package/src/utils/workflow/graph/convert-dsl-to-graph.ts

@@ -10,6 +10,17 @@ import type {
   DataRef,
 } from './workflow-graph.types.js'
 
+function makeNodeId(
+  step: WorkflowStepMeta,
+  index: number,
+  prefix: string
+): string {
+  if ('stepName' in step && step.stepName) {
+    return step.stepName
+  }
+  return `${prefix}_${index}`
+}
+
 /**
  * Check if a node is a terminal flow (no next step should follow)
  */
@@ -69,16 +80,17 @@ function convertStepToNode(
   steps: WorkflowStepMeta[],
   nodeIdPrefix: string = 'step'
 ): SerializedGraphNode[] {
-  const nodeId = `${nodeIdPrefix}_${index}`
+  const nodeId = makeNodeId(step, index, nodeIdPrefix)
   const nextNodeId =
-    index < steps.length - 1 ? `${nodeIdPrefix}_${index + 1}` : undefined
+    index < steps.length - 1
+      ? makeNodeId(steps[index + 1], index + 1, nodeIdPrefix)
+      : undefined
 
   switch (step.type) {
     case 'rpc': {
       const node: FunctionNode = {
         nodeId,
         rpcName: step.rpcName,
-        stepName: step.stepName,
         next: nextNodeId,
       }
       if (step.inputs) {
@@ -108,7 +120,6 @@ function convertStepToNode(
       const node: FlowNode = {
         nodeId,
         flow: 'sleep',
-        stepName: step.stepName,
         duration: step.duration,
         next: nextNodeId,
       }
@@ -119,7 +130,6 @@ function convertStepToNode(
       const node: FlowNode = {
         nodeId,
         flow: 'inline',
-        stepName: step.stepName,
         description: step.description,
         next: nextNodeId,
       }
@@ -274,7 +284,6 @@ function convertStepToNode(
       const node: FlowNode = {
         nodeId,
         flow: 'fanout',
-        stepName: step.stepName,
         sourceVar: step.sourceVar,
         itemVar: step.itemVar,
         mode: step.mode,
@@ -378,8 +387,7 @@ export function convertDslToGraph(
     nodesRecord[node.nodeId] = node
   }
 
-  // Find entry nodes (step_0 is always entry for sequential workflows)
-  const entryNodeIds = nodes.length > 0 ? ['step_0'] : []
+  const entryNodeIds = nodes.length > 0 ? [nodes[0].nodeId] : []
 
   // Determine source type based on dsl flag:
   // - dsl === true: pure DSL workflow, can be serialized
@@ -388,12 +396,11 @@ export function convertDslToGraph(
 
   return {
     name: workflowName,
-    pikkuFuncName: meta.pikkuFuncName,
+    pikkuFuncId: meta.pikkuFuncId,
     source,
     description: meta.description,
     tags: meta.tags,
     context: meta.context,
-    wires: {}, // DSL workflows don't have explicit wires in meta
     nodes: nodesRecord,
     entryNodeIds,
   }

package/src/utils/workflow/graph/finalize-workflow-wires.ts

@@ -0,0 +1,310 @@
+import type { InspectorState } from '../../../types.js'
+import type {
+  SerializedWorkflowGraph,
+  WorkflowWires,
+} from './workflow-graph.types.js'
+import type { CLICommandMeta } from '@pikku/core/cli'
+
+function parseWorkflowFuncId(
+  pikkuFuncId: string
+): { workflowName: string; startNode?: string } | null {
+  for (const prefix of ['workflowStart:', 'workflow:']) {
+    if (pikkuFuncId.startsWith(prefix)) {
+      return { workflowName: pikkuFuncId.slice(prefix.length) }
+    }
+  }
+  if (pikkuFuncId.startsWith('graphStart:')) {
+    const rest = pikkuFuncId.slice('graphStart:'.length)
+    const colonIdx = rest.indexOf(':')
+    if (colonIdx !== -1) {
+      return {
+        workflowName: rest.slice(0, colonIdx),
+        startNode: rest.slice(colonIdx + 1),
+      }
+    }
+  }
+  return null
+}
+
+function resolveStartNode(
+  parsed: { workflowName: string; startNode?: string },
+  graph: SerializedWorkflowGraph
+): string {
+  return parsed.startNode ?? graph.entryNodeIds[0]
+}
+
+function getOrCreateWires(graph: SerializedWorkflowGraph): WorkflowWires {
+  if (!graph.wires) {
+    graph.wires = {}
+  }
+  return graph.wires
+}
+
+export function finalizeWorkflowHelperTypes(state: InspectorState): void {
+  const { functions, workflows } = state
+  const graphMeta = workflows.graphMeta
+
+  for (const meta of Object.values(functions.meta)) {
+    if (meta.functionType !== 'helper') continue
+    if (meta.pikkuFuncId.startsWith('workflowStatus:')) continue
+
+    const parsed = parseWorkflowFuncId(meta.pikkuFuncId)
+    if (!parsed) continue
+
+    const graph = graphMeta[parsed.workflowName]
+    if (!graph) continue
+
+    const startNodeId = resolveStartNode(parsed, graph)
+    const startNode = graph.nodes[startNodeId]
+    if (!startNode || !('rpcName' in startNode)) continue
+
+    const rpcMeta = functions.meta[startNode.rpcName as string]
+    if (!rpcMeta) continue
+
+    if (rpcMeta.inputSchemaName) {
+      meta.inputSchemaName = rpcMeta.inputSchemaName
+    }
+    if (rpcMeta.inputs && rpcMeta.inputs.length > 0) {
+      meta.inputs = rpcMeta.inputs
+    }
+  }
+}
+
+export function finalizeWorkflowWires(state: InspectorState): void {
+  const { workflows } = state
+  const graphMeta = workflows.graphMeta
+
+  scanHTTP(state, graphMeta)
+  scanScheduledTasks(state, graphMeta)
+  scanTriggers(state, graphMeta)
+  scanQueueWorkers(state, graphMeta)
+  scanChannels(state, graphMeta)
+  scanMCPEndpoints(state, graphMeta)
+  scanCLI(state, graphMeta)
+}
+
+function scanHTTP(
+  state: InspectorState,
+  graphMeta: Record<string, SerializedWorkflowGraph>
+): void {
+  for (const [method, routes] of Object.entries(state.http.meta)) {
+    for (const [route, meta] of Object.entries(routes)) {
+      const parsed = parseWorkflowFuncId(meta.pikkuFuncId)
+      if (!parsed) continue
+      const graph = graphMeta[parsed.workflowName]
+      if (!graph) continue
+      const wires = getOrCreateWires(graph)
+      if (!wires.http) wires.http = []
+      wires.http.push({
+        route,
+        method,
+        startNode: resolveStartNode(parsed, graph),
+      })
+    }
+  }
+}
+
+function scanScheduledTasks(
+  state: InspectorState,
+  graphMeta: Record<string, SerializedWorkflowGraph>
+): void {
+  for (const meta of Object.values(state.scheduledTasks.meta)) {
+    const parsed = parseWorkflowFuncId(meta.pikkuFuncId)
+    if (!parsed) continue
+    const graph = graphMeta[parsed.workflowName]
+    if (!graph) continue
+    const wires = getOrCreateWires(graph)
+    if (!wires.schedule) wires.schedule = []
+    wires.schedule.push({
+      cron: meta.schedule,
+      startNode: resolveStartNode(parsed, graph),
+    })
+  }
+}
+
+function scanTriggers(
+  state: InspectorState,
+  graphMeta: Record<string, SerializedWorkflowGraph>
+): void {
+  for (const meta of Object.values(state.triggers.meta)) {
+    const parsed = parseWorkflowFuncId(meta.pikkuFuncId)
+    if (!parsed) continue
+    const graph = graphMeta[parsed.workflowName]
+    if (!graph) continue
+    const wires = getOrCreateWires(graph)
+    if (!wires.trigger) wires.trigger = []
+    wires.trigger.push({
+      name: meta.name,
+      startNode: resolveStartNode(parsed, graph),
+    })
+  }
+}
+
+function scanQueueWorkers(
+  state: InspectorState,
+  graphMeta: Record<string, SerializedWorkflowGraph>
+): void {
+  for (const meta of Object.values(state.queueWorkers.meta)) {
+    const parsed = parseWorkflowFuncId(meta.pikkuFuncId)
+    if (!parsed) continue
+    const graph = graphMeta[parsed.workflowName]
+    if (!graph) continue
+    const wires = getOrCreateWires(graph)
+    if (!wires.queue) wires.queue = []
+    wires.queue.push({
+      name: meta.name,
+      startNode: resolveStartNode(parsed, graph),
+    })
+  }
+}
+
+function scanChannels(
+  state: InspectorState,
+  graphMeta: Record<string, SerializedWorkflowGraph>
+): void {
+  for (const channelMeta of Object.values(state.channels.meta)) {
+    const wire: NonNullable<WorkflowWires['channel']>[number] = {
+      name: channelMeta.name,
+      route: channelMeta.route,
+    }
+    let targetWorkflow: SerializedWorkflowGraph | undefined
+
+    if (channelMeta.connect) {
+      const parsed = parseWorkflowFuncId(channelMeta.connect.pikkuFuncId)
+      if (parsed) {
+        const graph = graphMeta[parsed.workflowName]
+        if (graph) {
+          targetWorkflow = graph
+          wire.onConnect = resolveStartNode(parsed, graph)
+        }
+      }
+    }
+
+    if (channelMeta.disconnect) {
+      const parsed = parseWorkflowFuncId(channelMeta.disconnect.pikkuFuncId)
+      if (parsed) {
+        const graph = graphMeta[parsed.workflowName]
+        if (graph) {
+          targetWorkflow = targetWorkflow ?? graph
+          wire.onDisconnect = resolveStartNode(parsed, graph)
+        }
+      }
+    }
+
+    if (channelMeta.message) {
+      const parsed = parseWorkflowFuncId(channelMeta.message.pikkuFuncId)
+      if (parsed) {
+        const graph = graphMeta[parsed.workflowName]
+        if (graph) {
+          targetWorkflow = targetWorkflow ?? graph
+          wire.onMessage = resolveStartNode(parsed, graph)
+        }
+      }
+    }
+
+    for (const [routingProp, routeMap] of Object.entries(
+      channelMeta.messageWirings
+    )) {
+      for (const [routeValue, messageMeta] of Object.entries(routeMap)) {
+        const parsed = parseWorkflowFuncId(messageMeta.pikkuFuncId)
+        if (!parsed) continue
+        const graph = graphMeta[parsed.workflowName]
+        if (!graph) continue
+        targetWorkflow = targetWorkflow ?? graph
+        if (!wire.onMessageRoute) wire.onMessageRoute = {}
+        wire.onMessageRoute[`${routingProp}:${routeValue}`] = resolveStartNode(
+          parsed,
+          graph
+        )
+      }
+    }
+
+    if (targetWorkflow) {
+      const wires = getOrCreateWires(targetWorkflow)
+      if (!wires.channel) wires.channel = []
+      wires.channel.push(wire)
+    }
+  }
+}
+
+function scanMCPEndpoints(
+  state: InspectorState,
+  graphMeta: Record<string, SerializedWorkflowGraph>
+): void {
+  for (const meta of Object.values(state.mcpEndpoints.toolsMeta)) {
+    const parsed = parseWorkflowFuncId(meta.pikkuFuncId)
+    if (!parsed) continue
+    const graph = graphMeta[parsed.workflowName]
+    if (!graph) continue
+    const wires = getOrCreateWires(graph)
+    if (!wires.mcp) wires.mcp = {}
+    if (!wires.mcp.tool) wires.mcp.tool = []
+    wires.mcp.tool.push({
+      name: meta.name,
+      startNode: resolveStartNode(parsed, graph),
+    })
+  }
+
+  for (const meta of Object.values(state.mcpEndpoints.promptsMeta)) {
+    const parsed = parseWorkflowFuncId(meta.pikkuFuncId)
+    if (!parsed) continue
+    const graph = graphMeta[parsed.workflowName]
+    if (!graph) continue
+    const wires = getOrCreateWires(graph)
+    if (!wires.mcp) wires.mcp = {}
+    if (!wires.mcp.prompt) wires.mcp.prompt = []
+    wires.mcp.prompt.push({
+      name: meta.name,
+      startNode: resolveStartNode(parsed, graph),
+    })
+  }
+
+  for (const meta of Object.values(state.mcpEndpoints.resourcesMeta)) {
+    const parsed = parseWorkflowFuncId(meta.pikkuFuncId)
+    if (!parsed) continue
+    const graph = graphMeta[parsed.workflowName]
+    if (!graph) continue
+    const wires = getOrCreateWires(graph)
+    if (!wires.mcp) wires.mcp = {}
+    if (!wires.mcp.resource) wires.mcp.resource = []
+    wires.mcp.resource.push({
+      uri: meta.uri,
+      startNode: resolveStartNode(parsed, graph),
+    })
+  }
+}
+
+function visitCLICommands(
+  commands: Record<string, CLICommandMeta>,
+  programName: string,
+  path: string[],
+  graphMeta: Record<string, SerializedWorkflowGraph>
+): void {
+  for (const [name, command] of Object.entries(commands)) {
+    const currentPath = [...path, name]
+    const parsed = parseWorkflowFuncId(command.pikkuFuncId)
+    if (parsed) {
+      const graph = graphMeta[parsed.workflowName]
+      if (graph) {
+        const wires = getOrCreateWires(graph)
+        if (!wires.cli) wires.cli = []
+        wires.cli.push({
+          command: `${programName} ${currentPath.join(' ')}`,
+          startNode: resolveStartNode(parsed, graph),
+        })
+      }
+    }
+    if (command.subcommands) {
+      visitCLICommands(command.subcommands, programName, currentPath, graphMeta)
+    }
+  }
+}
+
+function scanCLI(
+  state: InspectorState,
+  graphMeta: Record<string, SerializedWorkflowGraph>
+): void {
+  for (const program of Object.values(state.cli.meta.programs)) {
+    visitCLICommands(program.commands, program.program, [], graphMeta)
+  }
+}