@pikku/inspector 0.11.2 → 0.12.1

package/dist/utils/workflow/graph/convert-dsl-to-graph.js

@@ -1,3 +1,9 @@
+function makeNodeId(step, index, prefix) {
+    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)
  */
@@ -41,14 +47,15 @@ function convertInputSource(source) {
  * Convert a single DSL step to graph node(s)
  */
 function convertStepToNode(step, index, steps, nodeIdPrefix = 'step') {
-    const nodeId = `${nodeIdPrefix}_${index}`;
-    const nextNodeId = index < steps.length - 1 ? `${nodeIdPrefix}_${index + 1}` : undefined;
+    const nodeId = makeNodeId(step, index, nodeIdPrefix);
+    const nextNodeId = index < steps.length - 1
+        ? makeNodeId(steps[index + 1], index + 1, nodeIdPrefix)
+        : undefined;
     switch (step.type) {
         case 'rpc': {
             const node = {
                 nodeId,
                 rpcName: step.rpcName,
-                stepName: step.stepName,
                 next: nextNodeId,
             };
             if (step.inputs) {
@@ -78,7 +85,6 @@ function convertStepToNode(step, index, steps, nodeIdPrefix = 'step') {
             const node = {
                 nodeId,
                 flow: 'sleep',
-                stepName: step.stepName,
                 duration: step.duration,
                 next: nextNodeId,
             };
@@ -88,7 +94,6 @@ function convertStepToNode(step, index, steps, nodeIdPrefix = 'step') {
             const node = {
                 nodeId,
                 flow: 'inline',
-                stepName: step.stepName,
                 description: step.description,
                 next: nextNodeId,
             };
@@ -201,7 +206,6 @@ function convertStepToNode(step, index, steps, nodeIdPrefix = 'step') {
             const node = {
                 nodeId,
                 flow: 'fanout',
-                stepName: step.stepName,
                 sourceVar: step.sourceVar,
                 itemVar: step.itemVar,
                 mode: step.mode,
@@ -286,20 +290,18 @@ export function convertDslToGraph(workflowName, meta) {
     for (const node of nodes) {
         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
     // - dsl === false: complex workflow with inline steps, not serializable
     const source = meta.dsl === false ? 'complex' : 'dsl';
     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/dist/utils/workflow/graph/finalize-workflow-wires.d.ts

@@ -0,0 +1,3 @@
+import type { InspectorState } from '../../../types.js';
+export declare function finalizeWorkflowHelperTypes(state: InspectorState): void;
+export declare function finalizeWorkflowWires(state: InspectorState): void;

package/dist/utils/workflow/graph/finalize-workflow-wires.js

@@ -0,0 +1,276 @@
+function parseWorkflowFuncId(pikkuFuncId) {
+    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, graph) {
+    return parsed.startNode ?? graph.entryNodeIds[0];
+}
+function getOrCreateWires(graph) {
+    if (!graph.wires) {
+        graph.wires = {};
+    }
+    return graph.wires;
+}
+export function finalizeWorkflowHelperTypes(state) {
+    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];
+        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) {
+    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, graphMeta) {
+    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, graphMeta) {
+    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, graphMeta) {
+    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, graphMeta) {
+    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, graphMeta) {
+    for (const channelMeta of Object.values(state.channels.meta)) {
+        const wire = {
+            name: channelMeta.name,
+            route: channelMeta.route,
+        };
+        let targetWorkflow;
+        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, graphMeta) {
+    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, programName, path, graphMeta) {
+    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, graphMeta) {
+    for (const program of Object.values(state.cli.meta.programs)) {
+        visitCLICommands(program.commands, program.program, [], graphMeta);
+    }
+}

package/dist/utils/workflow/graph/finalize-workflows.d.ts

@@ -0,0 +1,2 @@
+import type { InspectorState } from '../../../types.js';
+export declare function finalizeWorkflows(state: InspectorState): void;

package/dist/utils/workflow/graph/finalize-workflows.js

@@ -0,0 +1,75 @@
+import { isVersionedId, formatVersionedId, parseVersionedId } from '@pikku/core';
+import { canonicalJSON, hashString } from '../../hash.js';
+import { convertDslToGraph } from './convert-dsl-to-graph.js';
+export function finalizeWorkflows(state) {
+    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, functionsMeta) {
+    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, functionsMeta) {
+    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, functionsMeta) {
+    for (const node of Object.values(graph.nodes)) {
+        if (!('rpcName' in node) || typeof node.rpcName !== 'string') {
+            continue;
+        }
+        const rpcName = node.rpcName;
+        let meta = functionsMeta[rpcName];
+        if (!meta) {
+            const { baseName } = parseVersionedId(rpcName);
+            meta = functionsMeta[baseName];
+        }
+        ;
+        node.stepHash = hashString(`${node.nodeId}:${meta?.contractHash ?? ''}`, 12);
+    }
+}
+function computeGraphHash(graph) {
+    return hashString(canonicalJSON({
+        source: graph.source,
+        context: graph.context,
+        nodes: graph.nodes,
+        entryNodeIds: graph.entryNodeIds,
+    }), 12);
+}

package/dist/utils/workflow/graph/index.d.ts

@@ -4,3 +4,5 @@
 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/dist/utils/workflow/graph/index.js

@@ -4,3 +4,5 @@
 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/dist/utils/workflow/graph/serialize-workflow-graph.d.ts

@@ -7,13 +7,6 @@ import type { SerializedWorkflowGraph, DataRef, SerializedNext } from './workflo
  */
 export declare function serializeWorkflowGraph(definition: {
     name: string;
-    wires: {
-        http?: {
-            route: string;
-            method: string;
-        };
-        queue?: string;
-    };
     graph: Record<string, {
         func: {
             name?: string;
@@ -32,7 +25,6 @@ export declare function serializeWorkflowGraph(definition: {
  */
 export declare function deserializeWorkflowGraph(serialized: SerializedWorkflowGraph): {
     name: string;
-    wires: SerializedWorkflowGraph['wires'];
     graph: Record<string, {
         rpcName: string;
         input: Record<string, unknown | DataRef>;

package/dist/utils/workflow/graph/serialize-workflow-graph.js

@@ -116,11 +116,10 @@ export function serializeWorkflowGraph(definition, options) {
     }
     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',
         description: options?.description,
         tags: options?.tags,
-        wires: definition.wires,
         nodes,
         entryNodeIds,
     };
@@ -145,7 +144,6 @@ export function deserializeWorkflowGraph(serialized) {
     }
     return {
         name: serialized.name,
-        wires: serialized.wires,
         graph,
         entryNodeIds: serialized.entryNodeIds,
     };

package/dist/utils/workflow/graph/workflow-graph.types.d.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
  */
 /**
  * Reference to data from another node or trigger
@@ -96,6 +96,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;
 }
 /**
  * Flow node - control flow only, no RPC call
@@ -118,81 +120,6 @@ export declare const isFunctionNode: (node: SerializedGraphNode) => node is Func
  * Type guard for flow nodes
  */
 export declare const isFlowNode: (node: SerializedGraphNode) => node is FlowNode;
-/**
- * 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
@@ -207,7 +134,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 */
@@ -216,12 +143,59 @@ 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;
+    }>;
 }
 /**
  * All workflow graphs (serialized)

package/dist/utils/workflow/graph/workflow-graph.types.js

@@ -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
  */
 /**
  * Check if value is a DataRef

package/dist/visit.d.ts

@@ -1,4 +1,4 @@
 import * as ts from 'typescript';
-import { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
+import type { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
 export declare const visitSetup: (logger: InspectorLogger, checker: ts.TypeChecker, node: ts.Node, state: InspectorState, options: InspectorOptions) => void;
 export declare const visitRoutes: (logger: InspectorLogger, checker: ts.TypeChecker, node: ts.Node, state: InspectorState, options: InspectorOptions) => void;