@pikku/inspector 0.11.2 → 0.12.1

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

@@ -0,0 +1,100 @@
+import type { FunctionsMeta } from '@pikku/core'
+import { isVersionedId, formatVersionedId, parseVersionedId } from '@pikku/core'
+import type { SerializedWorkflowGraph } from './workflow-graph.types.js'
+import { canonicalJSON, hashString } from '../../hash.js'
+import { convertDslToGraph } from './convert-dsl-to-graph.js'
+import type { InspectorState } from '../../../types.js'
+
+export function finalizeWorkflows(state: InspectorState): void {
+  const { workflows, functions } = state
+  const functionsMeta = functions.meta
+
+  for (const [name, meta] of Object.entries(workflows.meta)) {
+    const graph = convertDslToGraph(name, meta)
+    stampVersionsOnGraph(graph, functionsMeta)
+    computeStepHashes(graph, functionsMeta)
+    graph.graphHash = computeGraphHash(graph)
+    workflows.graphMeta[name] = graph
+  }
+
+  for (const graph of Object.values(workflows.graphMeta)) {
+    if (graph.graphHash) {
+      continue
+    }
+    stampVersionsOnGraph(graph, functionsMeta)
+    computeStepHashes(graph, functionsMeta)
+    graph.graphHash = computeGraphHash(graph)
+  }
+}
+
+function stampVersionsOnGraph(
+  graph: SerializedWorkflowGraph,
+  functionsMeta: FunctionsMeta
+): void {
+  for (const node of Object.values(graph.nodes)) {
+    if (!('rpcName' in node) || typeof node.rpcName !== 'string') {
+      continue
+    }
+
+    if (isVersionedId(node.rpcName)) {
+      continue
+    }
+
+    const meta = functionsMeta[node.rpcName]
+    if (meta?.version !== undefined) {
+      node.rpcName = formatVersionedId(node.rpcName, meta.version)
+    } else {
+      const latestVersion = findLatestVersion(node.rpcName, functionsMeta)
+      if (latestVersion > 0) {
+        node.rpcName = formatVersionedId(node.rpcName, latestVersion)
+      }
+    }
+  }
+}
+
+function findLatestVersion(
+  baseName: string,
+  functionsMeta: FunctionsMeta
+): number {
+  let max = 0
+  for (const id of Object.keys(functionsMeta)) {
+    const parsed = parseVersionedId(id)
+    if (parsed.baseName === baseName && parsed.version !== null) {
+      max = Math.max(max, parsed.version)
+    }
+  }
+  return max
+}
+
+function computeStepHashes(
+  graph: SerializedWorkflowGraph,
+  functionsMeta: FunctionsMeta
+): void {
+  for (const node of Object.values(graph.nodes)) {
+    if (!('rpcName' in node) || typeof node.rpcName !== 'string') {
+      continue
+    }
+    const rpcName: string = node.rpcName
+    let meta = functionsMeta[rpcName]
+    if (!meta) {
+      const { baseName } = parseVersionedId(rpcName)
+      meta = functionsMeta[baseName]
+    }
+    ;(node as Record<string, unknown>).stepHash = hashString(
+      `${node.nodeId}:${meta?.contractHash ?? ''}`,
+      12
+    )
+  }
+}
+
+function computeGraphHash(graph: SerializedWorkflowGraph): string {
+  return hashString(
+    canonicalJSON({
+      source: graph.source,
+      context: graph.context,
+      nodes: graph.nodes,
+      entryNodeIds: graph.entryNodeIds,
+    }),
+    12
+  )
+}

package/src/utils/workflow/graph/index.ts

@@ -4,3 +4,8 @@
 export * from './workflow-graph.types.js'
 export { serializeWorkflowGraph } from './serialize-workflow-graph.js'
 export { convertDslToGraph } from './convert-dsl-to-graph.js'
+export { finalizeWorkflows } from './finalize-workflows.js'
+export {
+  finalizeWorkflowHelperTypes,
+  finalizeWorkflowWires,
+} from './finalize-workflow-wires.js'

package/src/utils/workflow/graph/serialize-workflow-graph.ts

@@ -82,10 +82,6 @@ function serializeNext(
 export function serializeWorkflowGraph(
   definition: {
     name: string
-    wires: {
-      http?: { route: string; method: string }
-      queue?: string
-    }
     graph: Record<
       string,
       {
@@ -163,11 +159,10 @@ export function serializeWorkflowGraph(
 
   return {
     name: definition.name,
-    pikkuFuncName: definition.name, // For graph workflows, pikkuFuncName is the workflow name
+    pikkuFuncId: definition.name, // For graph workflows, pikkuFuncId is the workflow name
     source: 'graph' as const,
     description: options?.description,
     tags: options?.tags,
-    wires: definition.wires as SerializedWorkflowGraph['wires'],
     nodes,
     entryNodeIds,
   }
@@ -179,7 +174,6 @@ export function serializeWorkflowGraph(
  */
 export function deserializeWorkflowGraph(serialized: SerializedWorkflowGraph): {
   name: string
-  wires: SerializedWorkflowGraph['wires']
   graph: Record<
     string,
     {
@@ -216,7 +210,6 @@ export function deserializeWorkflowGraph(serialized: SerializedWorkflowGraph): {
 
   return {
     name: serialized.name,
-    wires: serialized.wires,
     graph,
     entryNodeIds: serialized.entryNodeIds,
   }

package/src/utils/workflow/graph/workflow-graph.types.ts

@@ -1,7 +1,7 @@
 /**
  * Serialized types for workflow graphs
  * These are extracted by the inspector and stored as JSON
- * Can be created from code (wireWorkflow) or UI
+ * Can be created from code (pikkuWorkflowGraph) or UI
  */
 
 /**
@@ -138,6 +138,8 @@ export interface FunctionNode extends BaseNode {
   input?: Record<string, unknown | DataRef>
   /** Output variable name for storing result */
   outputVar?: string
+  /** Hash of nodeId + RPC input/output schemas for version detection */
+  stepHash?: string
 }
 
 /**
@@ -168,80 +170,6 @@ export const isFunctionNode = (
 export const isFlowNode = (node: SerializedGraphNode): node is FlowNode =>
   'flow' in node
 
-/**
- * HTTP wire configuration with startNode
- */
-export interface HttpWire {
-  route: string
-  method: 'get' | 'post' | 'put' | 'patch' | 'delete'
-  startNode: string
-}
-
-/**
- * Channel wire configuration
- */
-export interface ChannelWire {
-  name: string
-  onConnect?: string
-  onDisconnect?: string
-  onMessage?: string
-}
-
-/**
- * Queue wire configuration
- */
-export interface QueueWire {
-  name: string
-  startNode: string
-}
-
-/**
- * CLI wire configuration
- */
-export interface CliWire {
-  command: string
-  startNode: string
-}
-
-/**
- * MCP wire configurations
- */
-export interface McpWires {
-  tool?: Array<{ name: string; startNode: string }>
-  prompt?: Array<{ name: string; startNode: string }>
-  resource?: Array<{ uri: string; startNode: string }>
-}
-
-/**
- * Schedule wire configuration
- */
-export interface ScheduleWire {
-  cron?: string
-  interval?: string
-  startNode: string
-}
-
-/**
- * Trigger wire configuration
- */
-export interface TriggerWire {
-  name: string
-  startNode: string
-}
-
-/**
- * All wire configurations for workflows
- */
-export interface WorkflowWiresConfig {
-  http?: HttpWire[]
-  channel?: ChannelWire[]
-  queue?: QueueWire[]
-  cli?: CliWire[]
-  mcp?: McpWires
-  schedule?: ScheduleWire[]
-  trigger?: TriggerWire[]
-}
-
 /**
  * Workflow source type
  * - 'dsl': Pure DSL workflow (pikkuWorkflowFunc) - can be round-tripped to code
@@ -257,7 +185,7 @@ export interface SerializedWorkflowGraph {
   /** Workflow name */
   name: string
   /** Pikku function name (for runtime registration) */
-  pikkuFuncName: string
+  pikkuFuncId: string
   /** Source type: 'dsl' for pikkuWorkflowFunc, 'graph' for pikkuWorkflowGraph */
   source: WorkflowSourceType
   /** Optional description */
@@ -266,12 +194,35 @@ export interface SerializedWorkflowGraph {
   tags?: string[]
   /** Workflow context/state variables (from Zod schema) */
   context?: WorkflowContext
-  /** Wires - how the workflow is triggered */
-  wires: WorkflowWiresConfig
   /** Serialized nodes */
   nodes: Record<string, SerializedGraphNode>
   /** Entry node(s) - first nodes to execute */
   entryNodeIds: string[]
+  /** Hash of graph topology (nodes, edges, input mappings) */
+  graphHash?: string
+  /** Wire entry points (HTTP, channel, queue, etc.) that trigger this workflow */
+  wires?: WorkflowWires
+}
+
+export interface WorkflowWires {
+  http?: Array<{ route: string; method: string; startNode: string }>
+  channel?: Array<{
+    name: string
+    route: string
+    onConnect?: string
+    onMessage?: string
+    onDisconnect?: string
+    onMessageRoute?: Record<string, string>
+  }>
+  queue?: Array<{ name: string; startNode: string }>
+  cli?: Array<{ command: string; startNode: string }>
+  mcp?: {
+    tool?: Array<{ name: string; startNode: string }>
+    prompt?: Array<{ name: string; startNode: string }>
+    resource?: Array<{ uri: string; startNode: string }>
+  }
+  schedule?: Array<{ cron: string; startNode: string }>
+  trigger?: Array<{ name: string; startNode: string }>
 }
 
 /**

package/src/visit.ts

@@ -2,22 +2,29 @@ import * as ts from 'typescript'
 import { addFileWithFactory } from './add/add-file-with-factory.js'
 import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js'
 import { addHTTPRoute } from './add/add-http-route.js'
+import { addHTTPRoutes } from './add/add-http-routes.js'
 import { addSchedule } from './add/add-schedule.js'
+import { addTrigger } from './add/add-trigger.js'
 import { addQueueWorker } from './add/add-queue-worker.js'
 import { addWorkflow } from './add/add-workflow.js'
 import { addMCPResource } from './add/add-mcp-resource.js'
-import { addMCPTool } from './add/add-mcp-tool.js'
 import { addMCPPrompt } from './add/add-mcp-prompt.js'
-import { InspectorState, InspectorLogger, InspectorOptions } from './types.js'
+import type {
+  InspectorState,
+  InspectorLogger,
+  InspectorOptions,
+} from './types.js'
 import { addFunctions } from './add/add-functions.js'
 import { addChannel } from './add/add-channel.js'
 import { addRPCInvocations } from './add/add-rpc-invocations.js'
+import { addWireAddon } from './add/add-wire-addon.js'
 import { addMiddleware } from './add/add-middleware.js'
 import { addPermission } from './add/add-permission.js'
 import { addCLI, addCLIRenderers } from './add/add-cli.js'
-import { addForgeNode } from './add/add-forge-node.js'
-import { addForgeCredential } from './add/add-forge-credential.js'
+import { addSecret, addOAuth2Credential } from './add/add-secret.js'
+import { addVariable } from './add/add-variable.js'
 import { addWorkflowGraph } from './add/add-workflow-graph.js'
+import { addAIAgent } from './add/add-ai-agent.js'
 
 export const visitSetup = (
   logger: InspectorLogger,
@@ -76,6 +83,7 @@ export const visitSetup = (
   addFileWithFactory(node, checker, state.configFactories, 'CreateConfig')
 
   addRPCInvocations(node, state, logger)
+  addWireAddon(node, state, logger)
   addMiddleware(logger, node, checker, state, options)
   addPermission(logger, node, checker, state, options)
   addWorkflow(logger, node, checker, state, options)
@@ -93,18 +101,22 @@ export const visitRoutes = (
   options: InspectorOptions
 ) => {
   addFunctions(logger, node, checker, state, options)
+  addSecret(logger, node, checker, state, options)
+  addOAuth2Credential(logger, node, checker, state, options)
+  addVariable(logger, node, checker, state, options)
+
   addHTTPRoute(logger, node, checker, state, options)
+  addHTTPRoutes(logger, node, checker, state, options)
   addSchedule(logger, node, checker, state, options)
+  addTrigger(logger, node, checker, state, options)
   addQueueWorker(logger, node, checker, state, options)
   addChannel(logger, node, checker, state, options)
   addCLI(logger, node, checker, state, options)
   addCLIRenderers(logger, node, checker, state, options)
   addMCPResource(logger, node, checker, state, options)
-  addMCPTool(logger, node, checker, state, options)
   addMCPPrompt(logger, node, checker, state, options)
-  addForgeNode(logger, node, checker, state, options)
-  addForgeCredential(logger, node, checker, state, options)
   addWorkflowGraph(logger, node, checker, state, options)
+  addAIAgent(logger, node, checker, state, options)
 
   ts.forEachChild(node, (child) =>
     visitRoutes(logger, checker, child, state, options)