@pikku/inspector 0.11.2 → 0.12.1

package/src/utils/serialize-inspector-state.ts

@@ -1,4 +1,5 @@
-import { InspectorState } from '../types.js'
+import type { JSONValue } from '@pikku/core'
+import type { InspectorDiagnostic, InspectorState } from '../types.js'
 import { TypesMap } from '../types-map.js'
 
 /**
@@ -62,7 +63,17 @@ export interface SerializableInspectorState {
       >,
     ]
   >
-  zodLookup: Array<[string, { variableName: string; sourceFile: string }]>
+  schemaLookup: Array<
+    [
+      string,
+      {
+        variableName: string
+        sourceFile: string
+        vendor?: 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown'
+      },
+    ]
+  >
+  schemas: Record<string, JSONValue>
   functions: {
     typesMap: {
       map: Array<[string, { originalName: string; path: string | null }]>
@@ -105,6 +116,11 @@ export interface SerializableInspectorState {
     files: string[]
     meta: InspectorState['channels']['meta']
   }
+  triggers: {
+    meta: InspectorState['triggers']['meta']
+    sourceMeta: InspectorState['triggers']['sourceMeta']
+    files: string[]
+  }
   scheduledTasks: {
     meta: InspectorState['scheduledTasks']['meta']
     files: string[]
@@ -118,6 +134,7 @@ export interface SerializableInspectorState {
     files: Array<[string, { path: string; exportedName: string }]>
     graphMeta: InspectorState['workflows']['graphMeta']
     graphFiles: Array<[string, { path: string; exportedName: string }]>
+    invokedWorkflows: string[]
   }
   rpc: {
     internalMeta: InspectorState['rpc']['internalMeta']
@@ -125,7 +142,19 @@ export interface SerializableInspectorState {
     exposedMeta: InspectorState['rpc']['exposedMeta']
     exposedFiles: Array<[string, { path: string; exportedName: string }]>
     invokedFunctions: string[]
-    usedExternalPackages: string[]
+    usedAddons: string[]
+    wireAddonDeclarations: Array<
+      [
+        string,
+        {
+          package: string
+          rpcEndpoint?: string
+          secretOverrides?: Record<string, string>
+          variableOverrides?: Record<string, string>
+        },
+      ]
+    >
+    wireAddonFiles: string[]
   }
   mcpEndpoints: {
     resourcesMeta: InspectorState['mcpEndpoints']['resourcesMeta']
@@ -133,20 +162,30 @@ export interface SerializableInspectorState {
     promptsMeta: InspectorState['mcpEndpoints']['promptsMeta']
     files: string[]
   }
+  agents: {
+    agentsMeta: InspectorState['agents']['agentsMeta']
+    files: [string, { path: string; exportedName: string }][]
+  }
   cli: {
     meta: InspectorState['cli']['meta']
     files: string[]
   }
-  forgeNodes: {
-    meta: InspectorState['forgeNodes']['meta']
+  nodes: {
+    meta: InspectorState['nodes']['meta']
     files: string[]
   }
-  forgeCredentials: {
-    meta: InspectorState['forgeCredentials']['meta']
+  secrets: {
+    definitions: InspectorState['secrets']['definitions']
     files: string[]
   }
+  variables: {
+    definitions: InspectorState['variables']['definitions']
+    files: string[]
+  }
+  manifest: InspectorState['manifest']
   middleware: {
-    meta: InspectorState['middleware']['meta']
+    definitions: InspectorState['middleware']['definitions']
+    instances: InspectorState['middleware']['instances']
     tagMiddleware: Array<
       [
         string,
@@ -159,8 +198,27 @@ export interface SerializableInspectorState {
       ]
     >
   }
+  channelMiddleware: {
+    definitions: InspectorState['channelMiddleware']['definitions']
+    instances: InspectorState['channelMiddleware']['instances']
+    tagMiddleware: Array<
+      [
+        string,
+        InspectorState['channelMiddleware']['tagMiddleware'] extends Map<
+          string,
+          infer V
+        >
+          ? V
+          : never,
+      ]
+    >
+  }
+  aiMiddleware: {
+    definitions: InspectorState['aiMiddleware']['definitions']
+  }
   permissions: {
-    meta: InspectorState['permissions']['meta']
+    definitions: InspectorState['permissions']['definitions']
+    instances: InspectorState['permissions']['instances']
     tagPermissions: Array<
       [
         string,
@@ -181,16 +239,12 @@ export interface SerializableInspectorState {
     allSingletonServices: string[]
     allWireServices: string[]
   }
-  serviceMetadata: Array<{
-    name: string
-    summary: string
-    description: string
-    package: string
-    path: string
-    version: string
-    interface: string
-    expandedProperties: Record<string, string>
-  }>
+  resolvedIOTypes: Record<string, { inputType: string; outputType: string }>
+  middlewareGroupsMeta: InspectorState['middlewareGroupsMeta']
+  permissionsGroupsMeta: InspectorState['permissionsGroupsMeta']
+  requiredSchemas: string[]
+  openAPISpec: Record<string, any> | null
+  diagnostics: InspectorDiagnostic[]
 }
 
 /**
@@ -243,7 +297,8 @@ export function serializeInspectorState(
     filesAndMethodsErrors: Array.from(
       state.filesAndMethodsErrors.entries()
     ).map(([key, mapValue]) => [key, Array.from(mapValue.entries())] as const),
-    zodLookup: Array.from(state.zodLookup.entries()),
+    schemaLookup: Array.from(state.schemaLookup.entries()),
+    schemas: state.schemas,
     functions: {
       typesMap: serializeTypesMap(state.functions.typesMap),
       meta: state.functions.meta,
@@ -260,6 +315,11 @@ export function serializeInspectorState(
       files: Array.from(state.channels.files),
       meta: state.channels.meta,
     },
+    triggers: {
+      meta: state.triggers.meta,
+      sourceMeta: state.triggers.sourceMeta,
+      files: Array.from(state.triggers.files),
+    },
     scheduledTasks: {
       meta: state.scheduledTasks.meta,
       files: Array.from(state.scheduledTasks.files),
@@ -273,6 +333,7 @@ export function serializeInspectorState(
       files: Array.from(state.workflows.files.entries()),
       graphMeta: state.workflows.graphMeta,
       graphFiles: Array.from(state.workflows.graphFiles.entries()),
+      invokedWorkflows: Array.from(state.workflows.invokedWorkflows),
     },
     rpc: {
       internalMeta: state.rpc.internalMeta,
@@ -280,7 +341,11 @@ export function serializeInspectorState(
       exposedMeta: state.rpc.exposedMeta,
       exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
       invokedFunctions: Array.from(state.rpc.invokedFunctions),
-      usedExternalPackages: Array.from(state.rpc.usedExternalPackages),
+      usedAddons: Array.from(state.rpc.usedAddons),
+      wireAddonDeclarations: Array.from(
+        state.rpc.wireAddonDeclarations.entries()
+      ),
+      wireAddonFiles: Array.from(state.rpc.wireAddonFiles),
     },
     mcpEndpoints: {
       resourcesMeta: state.mcpEndpoints.resourcesMeta,
@@ -288,24 +353,45 @@ export function serializeInspectorState(
       promptsMeta: state.mcpEndpoints.promptsMeta,
       files: Array.from(state.mcpEndpoints.files),
     },
+    agents: {
+      agentsMeta: state.agents?.agentsMeta ?? {},
+      files: Array.from(state.agents?.files?.entries() ?? []),
+    },
     cli: {
       meta: state.cli.meta,
       files: Array.from(state.cli.files),
     },
-    forgeNodes: {
-      meta: state.forgeNodes.meta,
-      files: Array.from(state.forgeNodes.files),
+    nodes: {
+      meta: state.nodes.meta,
+      files: Array.from(state.nodes.files),
     },
-    forgeCredentials: {
-      meta: state.forgeCredentials.meta,
-      files: Array.from(state.forgeCredentials.files),
+    secrets: {
+      definitions: state.secrets.definitions,
+      files: Array.from(state.secrets.files),
     },
+    variables: {
+      definitions: state.variables.definitions,
+      files: Array.from(state.variables.files),
+    },
+    manifest: state.manifest,
     middleware: {
-      meta: state.middleware.meta,
+      definitions: state.middleware.definitions,
+      instances: state.middleware.instances,
       tagMiddleware: Array.from(state.middleware.tagMiddleware.entries()),
     },
+    channelMiddleware: {
+      definitions: state.channelMiddleware.definitions,
+      instances: state.channelMiddleware.instances,
+      tagMiddleware: Array.from(
+        state.channelMiddleware.tagMiddleware.entries()
+      ),
+    },
+    aiMiddleware: {
+      definitions: state.aiMiddleware.definitions,
+    },
     permissions: {
-      meta: state.permissions.meta,
+      definitions: state.permissions.definitions,
+      instances: state.permissions.instances,
       tagPermissions: Array.from(state.permissions.tagPermissions.entries()),
     },
     serviceAggregation: {
@@ -316,7 +402,12 @@ export function serializeInspectorState(
       allSingletonServices: state.serviceAggregation.allSingletonServices,
       allWireServices: state.serviceAggregation.allWireServices,
     },
-    serviceMetadata: state.serviceMetadata,
+    resolvedIOTypes: state.resolvedIOTypes,
+    middlewareGroupsMeta: state.middlewareGroupsMeta,
+    permissionsGroupsMeta: state.permissionsGroupsMeta,
+    requiredSchemas: Array.from(state.requiredSchemas),
+    openAPISpec: state.openAPISpec,
+    diagnostics: state.diagnostics,
   }
 }
 
@@ -326,8 +417,15 @@ export function serializeInspectorState(
  */
 export function deserializeInspectorState(
   data: SerializableInspectorState
-): Omit<InspectorState, 'typesLookup' | 'zodLookup'> & {
-  zodLookup: Map<string, { variableName: string; sourceFile: string }>
+): Omit<InspectorState, 'typesLookup' | 'schemaLookup'> & {
+  schemaLookup: Map<
+    string,
+    {
+      variableName: string
+      sourceFile: string
+      vendor?: 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown'
+    }
+  >
 } {
   // Helper to deserialize TypesMap
   const deserializeTypesMap = (
@@ -363,7 +461,8 @@ export function deserializeInspectorState(
         new Map(entries),
       ])
     ),
-    zodLookup: new Map(data.zodLookup || []),
+    schemaLookup: new Map(data.schemaLookup || []),
+    schemas: data.schemas || {},
     functions: {
       typesMap: deserializeTypesMap(data.functions.typesMap),
       meta: data.functions.meta,
@@ -380,6 +479,11 @@ export function deserializeInspectorState(
       files: new Set(data.channels.files),
       meta: data.channels.meta,
     },
+    triggers: {
+      meta: data.triggers?.meta ?? {},
+      sourceMeta: data.triggers?.sourceMeta ?? {},
+      files: new Set(data.triggers?.files ?? []),
+    },
     scheduledTasks: {
       meta: data.scheduledTasks.meta,
       files: new Set(data.scheduledTasks.files),
@@ -393,6 +497,7 @@ export function deserializeInspectorState(
       files: new Map(data.workflows.files),
       graphMeta: data.workflows.graphMeta || {},
       graphFiles: new Map(data.workflows.graphFiles || []),
+      invokedWorkflows: new Set(data.workflows.invokedWorkflows || []),
     },
     rpc: {
       internalMeta: data.rpc.internalMeta,
@@ -400,7 +505,9 @@ export function deserializeInspectorState(
       exposedMeta: data.rpc.exposedMeta,
       exposedFiles: new Map(data.rpc.exposedFiles),
       invokedFunctions: new Set(data.rpc.invokedFunctions),
-      usedExternalPackages: new Set(data.rpc.usedExternalPackages || []),
+      usedAddons: new Set(data.rpc.usedAddons || []),
+      wireAddonDeclarations: new Map(data.rpc.wireAddonDeclarations || []),
+      wireAddonFiles: new Set(data.rpc.wireAddonFiles || []),
     },
     mcpEndpoints: {
       resourcesMeta: data.mcpEndpoints.resourcesMeta,
@@ -408,24 +515,43 @@ export function deserializeInspectorState(
       promptsMeta: data.mcpEndpoints.promptsMeta,
       files: new Set(data.mcpEndpoints.files),
     },
+    agents: {
+      agentsMeta: data.agents?.agentsMeta || {},
+      files: new Map(data.agents?.files || []),
+    },
     cli: {
       meta: data.cli.meta,
       files: new Set(data.cli.files),
     },
-    forgeNodes: {
-      meta: data.forgeNodes?.meta || {},
-      files: new Set(data.forgeNodes?.files || []),
+    nodes: {
+      meta: data.nodes?.meta || {},
+      files: new Set(data.nodes?.files || []),
     },
-    forgeCredentials: {
-      meta: data.forgeCredentials?.meta || {},
-      files: new Set(data.forgeCredentials?.files || []),
+    secrets: {
+      definitions: data.secrets?.definitions || [],
+      files: new Set(data.secrets?.files || []),
     },
+    variables: {
+      definitions: data.variables?.definitions || [],
+      files: new Set(data.variables?.files || []),
+    },
+    manifest: data.manifest || { initial: null, current: null, errors: [] },
     middleware: {
-      meta: data.middleware.meta,
+      definitions: data.middleware.definitions,
+      instances: data.middleware.instances || {},
       tagMiddleware: new Map(data.middleware.tagMiddleware),
     },
+    channelMiddleware: {
+      definitions: data.channelMiddleware?.definitions || {},
+      instances: data.channelMiddleware?.instances || {},
+      tagMiddleware: new Map(data.channelMiddleware?.tagMiddleware || []),
+    },
+    aiMiddleware: {
+      definitions: data.aiMiddleware?.definitions || {},
+    },
     permissions: {
-      meta: data.permissions.meta,
+      definitions: data.permissions.definitions,
+      instances: data.permissions.instances || {},
       tagPermissions: new Map(data.permissions.tagPermissions),
     },
     serviceAggregation: {
@@ -436,6 +562,21 @@ export function deserializeInspectorState(
       allSingletonServices: data.serviceAggregation.allSingletonServices,
       allWireServices: data.serviceAggregation.allWireServices,
     },
-    serviceMetadata: data.serviceMetadata || [],
+    resolvedIOTypes: data.resolvedIOTypes || {},
+    middlewareGroupsMeta: data.middlewareGroupsMeta || {
+      definitions: {},
+      instances: {},
+      httpGroups: {},
+      tagGroups: {},
+      channelMiddleware: { definitions: {}, instances: {}, tagGroups: {} },
+    },
+    permissionsGroupsMeta: data.permissionsGroupsMeta || {
+      definitions: {},
+      httpGroups: {},
+      tagGroups: {},
+    },
+    requiredSchemas: new Set(data.requiredSchemas || []),
+    openAPISpec: data.openAPISpec || null,
+    diagnostics: data.diagnostics || [],
   }
 }

package/src/utils/serialize-mcp-json.ts

@@ -0,0 +1,145 @@
+import type { InspectorLogger, InspectorState } from '../types.js'
+import type { JSONValue } from '@pikku/core'
+
+interface MCPEndpoint {
+  uri?: string
+  name: string
+  description?: string
+  parameters?: JSONValue
+  returns?: JSONValue
+  streaming?: boolean
+}
+
+export const serializeMCPJson = (
+  logger: InspectorLogger,
+  state: InspectorState
+): string => {
+  const { mcpEndpoints, functions, schemas } = state
+  const { meta: functionsMeta, typesMap } = functions
+  const { resourcesMeta, toolsMeta, promptsMeta } = mcpEndpoints
+
+  const tools: MCPEndpoint[] = []
+  const resources: MCPEndpoint[] = []
+  const prompts: any[] = []
+
+  const loadSchema = (typeName: string | undefined): JSONValue | undefined => {
+    if (
+      !typeName ||
+      [
+        'boolean',
+        'string',
+        'number',
+        'null',
+        'undefined',
+        'void',
+        'unknown',
+        'never',
+      ].includes(typeName)
+    ) {
+      return undefined
+    }
+
+    const uniqueName = typesMap.getUniqueName(typeName)
+    if (!uniqueName) {
+      return undefined
+    }
+
+    const schema = schemas[uniqueName]
+    if (!schema) {
+      logger.warn(
+        `Serialize MCP: Could not find schema for type: ${uniqueName}`
+      )
+      return undefined
+    }
+
+    return schema
+  }
+
+  for (const [name, endpointMeta] of Object.entries(resourcesMeta)) {
+    const functionMeta = functionsMeta[endpointMeta.pikkuFuncId]
+    if (!functionMeta) {
+      logger.warn(
+        `Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping resource ${name}.`
+      )
+      continue
+    }
+
+    const inputType = functionMeta.inputs?.[0]
+    const outputType = functionMeta.outputs?.[0]
+
+    const parameters = loadSchema(inputType)
+    const returns = loadSchema(outputType)
+
+    resources.push({
+      uri: name,
+      name,
+      description: endpointMeta.description,
+      ...(parameters && { parameters }),
+      ...(returns && { returns }),
+      ...(endpointMeta.streaming && { streaming: true }),
+    })
+  }
+
+  for (const [name, endpointMeta] of Object.entries(toolsMeta)) {
+    const functionMeta = functionsMeta[endpointMeta.pikkuFuncId]
+    if (!functionMeta) {
+      logger.warn(
+        `Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping tool ${name}.`
+      )
+      continue
+    }
+
+    const inputType = functionMeta.inputs?.[0]
+    const outputType = functionMeta.outputs?.[0]
+
+    const parameters = loadSchema(inputType)
+    const returns = loadSchema(outputType)
+
+    tools.push({
+      name,
+      description: endpointMeta.description,
+      ...(parameters && { parameters }),
+      ...(returns && { returns }),
+      ...(endpointMeta.streaming && { streaming: true }),
+    })
+  }
+
+  for (const [name, endpointMeta] of Object.entries(promptsMeta)) {
+    const functionMeta = functionsMeta[endpointMeta.pikkuFuncId]
+    if (!functionMeta) {
+      logger.warn(
+        `Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping prompt ${name}.`
+      )
+      continue
+    }
+
+    const inputType = functionMeta.inputs?.[0]
+    const inputSchema = loadSchema(inputType)
+
+    const argumentsArray: any[] = []
+    if (
+      inputSchema &&
+      typeof inputSchema === 'object' &&
+      !(inputSchema instanceof Array)
+    ) {
+      const properties = inputSchema.properties as Record<string, any>
+      const required = (inputSchema.required as string[]) || []
+
+      for (const [propName, propSchema] of Object.entries(properties)) {
+        argumentsArray.push({
+          name: propName,
+          description: propSchema.description || `${propName} parameter`,
+          required: required.includes(propName),
+        })
+      }
+    }
+
+    prompts.push({
+      name,
+      description: endpointMeta.description,
+      arguments: argumentsArray,
+    })
+  }
+
+  return JSON.stringify({ tools, resources, prompts }, null, 2)
+}

package/src/utils/serialize-middleware-groups-meta.ts

@@ -0,0 +1,33 @@
+import type { InspectorState, MiddlewareGroupMeta } from '../types.js'
+
+const serializeGroupMap = (
+  groupMap: Map<string, MiddlewareGroupMeta>
+): Record<string, any> => {
+  const result: Record<string, any> = {}
+  for (const [key, meta] of groupMap.entries()) {
+    result[key] = {
+      exportName: meta.exportName,
+      sourceFile: meta.sourceFile,
+      position: meta.position,
+      services: meta.services,
+      count: meta.count,
+      instanceIds: meta.instanceIds,
+      isFactory: meta.isFactory,
+    }
+  }
+  return result
+}
+
+export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
+  return {
+    definitions: state.middleware.definitions,
+    instances: state.middleware.instances,
+    httpGroups: serializeGroupMap(state.http.routeMiddleware),
+    tagGroups: serializeGroupMap(state.middleware.tagMiddleware),
+    channelMiddleware: {
+      definitions: state.channelMiddleware.definitions,
+      instances: state.channelMiddleware.instances,
+      tagGroups: serializeGroupMap(state.channelMiddleware.tagMiddleware),
+    },
+  }
+}