@pikku/inspector 0.11.1 → 0.12.0

package/src/types.ts

@@ -2,13 +2,29 @@ import * as ts from 'typescript'
 import { ChannelsMeta } from '@pikku/core/channel'
 import { HTTPWiringsMeta } from '@pikku/core/http'
 import { ScheduledTasksMeta } from '@pikku/core/scheduler'
+import { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger'
 import { QueueWorkersMeta } from '@pikku/core/queue'
 import { WorkflowsMeta } from '@pikku/core/workflow'
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
+import { AIAgentMeta } from '@pikku/core/ai-agent'
 import { CLIMeta } from '@pikku/core/cli'
+import { NodesMeta } from '@pikku/core/node'
+import { SecretDefinitions } from '@pikku/core/secret'
+import { VariableDefinitions } from '@pikku/core/variable'
 import { TypesMap } from './types-map.js'
-import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core'
+import {
+  FunctionsMeta,
+  FunctionServicesMeta,
+  FunctionWiresMeta,
+  JSONValue,
+} from '@pikku/core'
+import type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js'
 import { ErrorCode } from './error-codes.js'
+import type {
+  VersionManifest,
+  VersionValidateError,
+} from './utils/contract-hashes.js'
+import type { SerializedWorkflowGraphs } from './utils/workflow/graph/workflow-graph.types.js'
 
 export type PathToNameAndType = Map<
   string,
@@ -29,7 +45,8 @@ export interface MiddlewareGroupMeta {
   sourceFile: string
   position: number
   services: FunctionServicesMeta
-  middlewareCount: number
+  count: number
+  instanceIds: string[]
   isFactory: boolean // true if wrapped in () => add...()
 }
 
@@ -38,7 +55,8 @@ export interface PermissionGroupMeta {
   sourceFile: string
   position: number
   services: FunctionServicesMeta
-  permissionCount: number
+  count: number
+  instanceIds: string[]
   isFactory: boolean // true if wrapped in () => add...()
 }
 
@@ -56,6 +74,21 @@ export interface InspectorHTTPState {
   routePermissions: Map<string, PermissionGroupMeta>
 }
 
+/**
+ * Schema vendor types for Standard Schema compliant validators
+ */
+export type SchemaVendor = 'zod' | 'valibot' | 'arktype' | 'effect' | 'unknown'
+
+/**
+ * Schema reference for deferred conversion to JSON Schema at build time.
+ * Supports Standard Schema compliant validators (Zod, Valibot, ArkType, Effect Schema).
+ */
+export interface SchemaRef {
+  variableName: string
+  sourceFile: string
+  vendor?: SchemaVendor
+}
+
 export interface InspectorFunctionState {
   typesMap: TypesMap
   meta: FunctionsMeta
@@ -67,41 +100,64 @@ export interface InspectorChannelState {
   files: Set<string>
 }
 
+export interface InspectorMiddlewareDefinition {
+  services: FunctionServicesMeta
+  wires?: FunctionWiresMeta
+  sourceFile: string
+  position: number
+  exportedName: string | null
+  factory?: boolean
+  name?: string
+  description?: string
+  package?: string
+}
+
+export interface InspectorMiddlewareInstance {
+  definitionId: string
+  sourceFile: string
+  position: number
+  isFactoryCall: boolean
+}
+
 export interface InspectorMiddlewareState {
-  // Individual middleware function metadata
-  meta: Record<
-    string,
-    {
-      services: FunctionServicesMeta
-      sourceFile: string
-      position: number
-      exportedName: string | null
-      factory?: boolean // true if wrapped with pikkuMiddlewareFactory
-      name?: string // optional name from pikkuMiddleware({ name: '...' })
-      description?: string // optional description from pikkuMiddleware({ description: '...' })
-    }
-  >
-  // Tag-based middleware calls tracking - tag -> group metadata
-  // e.g., export const adminMiddleware = () => addMiddleware('admin', [...])
+  definitions: Record<string, InspectorMiddlewareDefinition>
+  instances: Record<string, InspectorMiddlewareInstance>
   tagMiddleware: Map<string, MiddlewareGroupMeta>
 }
 
+export interface InspectorChannelMiddlewareState {
+  definitions: Record<string, InspectorMiddlewareDefinition>
+  instances: Record<string, InspectorMiddlewareInstance>
+  tagMiddleware: Map<string, MiddlewareGroupMeta>
+}
+
+export interface InspectorAIMiddlewareState {
+  definitions: Record<string, InspectorMiddlewareDefinition>
+}
+
+export interface InspectorPermissionDefinition {
+  services: FunctionServicesMeta
+  wires?: FunctionWiresMeta
+  sourceFile: string
+  position: number
+  exportedName: string | null
+  factory?: boolean
+  name?: string
+  description?: string
+  package?: string
+  requiresData?: boolean
+}
+
+export interface InspectorPermissionInstance {
+  definitionId: string
+  sourceFile: string
+  position: number
+  isFactoryCall: boolean
+}
+
 export interface InspectorPermissionState {
-  // Individual permission function metadata
-  meta: Record<
-    string,
-    {
-      services: FunctionServicesMeta
-      sourceFile: string
-      position: number
-      exportedName: string | null
-      factory?: boolean // true if wrapped with pikkuPermissionFactory
-      name?: string // optional name from pikkuPermission({ name: '...' })
-      description?: string // optional description from pikkuPermission({ description: '...' })
-    }
-  >
-  // Tag-based permission calls tracking - tag -> group metadata
-  // e.g., export const adminPermissions = () => addPermission('admin', [...])
+  definitions: Record<string, InspectorPermissionDefinition>
+  instances: Record<string, InspectorPermissionInstance>
   tagPermissions: Map<string, PermissionGroupMeta>
 }
 
@@ -114,14 +170,48 @@ export type InspectorFilters = {
   httpMethods?: string[] // HTTP methods: "GET", "POST", "DELETE", etc.
 }
 
+export type ExternalPackageConfig = {
+  package: string
+  rpcEndpoint?: string
+  secretOverrides?: Record<string, string>
+  forceInclude?: boolean
+}
+
+export type ModelConfigEntry =
+  | string
+  | { model: string; temperature?: number; maxSteps?: number }
+
+export type InspectorModelConfig = {
+  models?: Record<string, ModelConfigEntry>
+  agentDefaults?: { temperature?: number; maxSteps?: number }
+  agentOverrides?: Record<
+    string,
+    { model?: string; temperature?: number; maxSteps?: number }
+  >
+}
+
 export type InspectorOptions = Partial<{
   setupOnly: boolean
+  rootDir: string
+  isExternalPackage: boolean
   types: Partial<{
     configFileType: string
     userSessionType: string
     singletonServicesFactoryType: string
     wireServicesFactoryType: string
   }>
+  externalPackages: Record<string, ExternalPackageConfig>
+  schemaConfig: {
+    tsconfig: string
+    schemasFromTypes?: string[]
+    schema?: { additionalProperties?: boolean }
+  }
+  openAPI: {
+    additionalInfo: OpenAPISpecInfo
+  }
+  tags: string[]
+  manifest: VersionManifest
+  modelConfig: InspectorModelConfig
 }>
 
 export interface InspectorLogger {
@@ -185,6 +275,13 @@ export interface InspectorFilesAndMethods {
   }
 }
 
+export interface InspectorDiagnostic {
+  code: string
+  message: string
+  sourceFile: string
+  position: number
+}
+
 export interface InspectorState {
   rootDir: string // Root directory inferred from source files
   singletonServicesTypeImportMap: PathToNameAndType
@@ -198,9 +295,16 @@ export interface InspectorState {
   filesAndMethods: InspectorFilesAndMethods
   filesAndMethodsErrors: Map<string, PathToNameAndType>
   typesLookup: Map<string, ts.Type[]> // Lookup for types by name (e.g., function input types, Config type)
+  schemaLookup: Map<string, SchemaRef> // Lookup for schemas by name for deferred JSON Schema conversion (supports Standard Schema vendors)
+  schemas: Record<string, JSONValue>
   http: InspectorHTTPState
   functions: InspectorFunctionState
   channels: InspectorChannelState
+  triggers: {
+    meta: TriggerMeta
+    sourceMeta: TriggerSourceMeta
+    files: Set<string>
+  }
   scheduledTasks: {
     meta: ScheduledTasksMeta
     files: Set<string>
@@ -212,13 +316,17 @@ export interface InspectorState {
   workflows: {
     meta: WorkflowsMeta
     files: Map<string, { path: string; exportedName: string }>
+    graphMeta: SerializedWorkflowGraphs
+    graphFiles: Map<string, { path: string; exportedName: string }>
+    invokedWorkflows: Set<string>
   }
   rpc: {
     internalMeta: Record<string, string>
     internalFiles: Map<string, { path: string; exportedName: string }>
     exposedMeta: Record<string, string>
     exposedFiles: Map<string, { path: string; exportedName: string }>
-    invokedFunctions: Set<string> // Track functions called via rpc.invoke()
+    invokedFunctions: Set<string>
+    usedExternalPackages: Set<string>
   }
   mcpEndpoints: {
     resourcesMeta: MCPResourceMeta
@@ -226,28 +334,61 @@ export interface InspectorState {
     promptsMeta: MCPPromptMeta
     files: Set<string>
   }
+  agents: {
+    agentsMeta: AIAgentMeta
+    files: Map<string, { path: string; exportedName: string }>
+  }
   cli: {
     meta: CLIMeta
     files: Set<string>
   }
+  nodes: {
+    meta: NodesMeta
+    files: Set<string>
+  }
+  secrets: {
+    definitions: SecretDefinitions
+    files: Set<string>
+  }
+  variables: {
+    definitions: VariableDefinitions
+    files: Set<string>
+  }
+  manifest: {
+    initial: VersionManifest | null
+    current: VersionManifest | null
+    errors: VersionValidateError[]
+  }
   middleware: InspectorMiddlewareState
+  channelMiddleware: InspectorChannelMiddlewareState
+  aiMiddleware: InspectorAIMiddlewareState
   permissions: InspectorPermissionState
   serviceAggregation: {
-    requiredServices: Set<string> // All services needed across the app
-    usedFunctions: Set<string> // Function names actually wired/exposed
-    usedMiddleware: Set<string> // Middleware names used by wired functions
-    usedPermissions: Set<string> // Permission names used by wired functions
-    allSingletonServices: string[] // All services available in SingletonServices type
-    allWireServices: string[] // All services available in Services type (excluding SingletonServices)
-  }
-  serviceMetadata: Array<{
-    name: string
-    summary: string
-    description: string
-    package: string
-    path: string
-    version: string
-    interface: string
-    expandedProperties: Record<string, string>
-  }>
+    requiredServices: Set<string>
+    usedFunctions: Set<string>
+    usedMiddleware: Set<string>
+    usedPermissions: Set<string>
+    allSingletonServices: string[]
+    allWireServices: string[]
+  }
+  resolvedIOTypes: Record<string, { inputType: string; outputType: string }>
+  middlewareGroupsMeta: {
+    definitions: Record<string, InspectorMiddlewareDefinition>
+    instances: Record<string, InspectorMiddlewareInstance>
+    httpGroups: Record<string, MiddlewareGroupMeta>
+    tagGroups: Record<string, MiddlewareGroupMeta>
+    channelMiddleware: {
+      definitions: Record<string, InspectorMiddlewareDefinition>
+      instances: Record<string, InspectorMiddlewareInstance>
+      tagGroups: Record<string, MiddlewareGroupMeta>
+    }
+  }
+  permissionsGroupsMeta: {
+    definitions: Record<string, InspectorPermissionDefinition>
+    httpGroups: Record<string, PermissionGroupMeta>
+    tagGroups: Record<string, PermissionGroupMeta>
+  }
+  requiredSchemas: Set<string>
+  openAPISpec: Record<string, any> | null
+  diagnostics: InspectorDiagnostic[]
 }

package/src/utils/compute-required-schemas.ts

@@ -0,0 +1,49 @@
+import type { FunctionsMeta } from '@pikku/core'
+import type { TypesMap } from '../types-map.js'
+import type { SchemaRef } from '../types.js'
+
+const PRIMITIVE_TYPES = new Set([
+  'boolean',
+  'string',
+  'number',
+  'null',
+  'undefined',
+  'void',
+  'any',
+  'unknown',
+  'never',
+])
+
+export function computeRequiredSchemas(
+  functionsMeta: FunctionsMeta,
+  typesMap: TypesMap,
+  additionalTypes?: string[],
+  schemaLookup?: Map<string, SchemaRef>
+): Set<string> {
+  return new Set<string>([
+    ...Object.values(functionsMeta)
+      .map(({ inputs, outputs }) => {
+        const types: (string | undefined)[] = []
+        if (inputs?.[0]) {
+          try {
+            types.push(typesMap.getUniqueName(inputs[0]))
+          } catch {
+            types.push(inputs[0])
+          }
+        }
+        if (outputs?.[0]) {
+          try {
+            types.push(typesMap.getUniqueName(outputs[0]))
+          } catch {
+            types.push(outputs[0])
+          }
+        }
+        return types
+      })
+      .flat()
+      .filter((s): s is string => !!s && !PRIMITIVE_TYPES.has(s)),
+    ...typesMap.customTypes.keys(),
+    ...(additionalTypes || []),
+    ...(schemaLookup ? Array.from(schemaLookup.keys()) : []),
+  ])
+}