@pikku/inspector 0.11.2 → 0.12.1

package/src/add/add-workflow.ts

@@ -1,9 +1,9 @@
 import * as ts from 'typescript'
-import { AddWiring, InspectorState } from '../types.js'
+import type { AddWiring, InspectorState } from '../types.js'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import { extractFunctionNode } from '../utils/extract-function-node.js'
 import { ErrorCode } from '../error-codes.js'
-import { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow'
+import type { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow'
 import {
   extractStringLiteral,
   isStringLike,
@@ -182,7 +182,7 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
   }
 
   // Extract workflow name and metadata using same logic as add-functions
-  const { pikkuFuncName, name, exportedName } = extractFunctionName(
+  const { pikkuFuncId, name, exportedName } = extractFunctionName(
     node,
     checker,
     state.rootDir
@@ -214,6 +214,7 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
       workflowName,
       logger
     )
+    if (metadata.disabled) return
     tags = metadata.tags
     summary = metadata.summary
     description = metadata.description
@@ -242,7 +243,7 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
 
   // Track workflow file for wiring generation
   if (exportedName) {
-    state.workflows.files.set(pikkuFuncName, {
+    state.workflows.files.set(pikkuFuncId, {
       path: node.getSourceFile().fileName,
       exportedName,
     })
@@ -314,8 +315,8 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
   }
 
   state.workflows.meta[workflowName] = {
-    pikkuFuncName,
-    workflowName,
+    pikkuFuncId,
+    name: workflowName,
     steps,
     context,
     dsl,

package/src/error-codes.ts

@@ -30,12 +30,17 @@ export enum ErrorCode {
   SCHEMA_NO_ROOT = 'PKU431',
   SCHEMA_GENERATION_ERROR = 'PKU456',
   SCHEMA_LOAD_ERROR = 'PKU488',
-  INLINE_ZOD_SCHEMA = 'PKU489',
+  INLINE_SCHEMA = 'PKU489',
 
   // Function errors
   FUNCTION_METADATA_NOT_FOUND = 'PKU559',
   HANDLER_NOT_RESOLVED = 'PKU568',
 
+  // HTTP Route errors
+  ROUTE_PARAM_MISMATCH = 'PKU571',
+  ROUTE_QUERY_MISMATCH = 'PKU572',
+  AUTH_DISABLED_REQUIRES_SESSIONLESS = 'PKU573',
+
   // Middleware/Permission errors
   MIDDLEWARE_HANDLER_INVALID = 'PKU685',
   MIDDLEWARE_TAG_INVALID = 'PKU715',
@@ -46,6 +51,25 @@ export enum ErrorCode {
   PERMISSION_EMPTY_ARRAY = 'PKU937',
   PERMISSION_PATTERN_INVALID = 'PKU975',
 
+  // Versioning errors
+  DUPLICATE_FUNCTION_VERSION = 'PKU850',
+
+  // Contract versioning errors
+  MANIFEST_MISSING = 'PKU860',
+  FUNCTION_VERSION_MODIFIED = 'PKU861',
+  CONTRACT_CHANGED_REQUIRES_BUMP = 'PKU862',
+  VERSION_REGRESSION_OR_CONFLICT = 'PKU863',
+  VERSION_GAP_NOT_ALLOWED = 'PKU864',
+  MANIFEST_INTEGRITY_ERROR = 'PKU865',
+
+  // Model configuration errors
+  MISSING_MODEL = 'PKU145',
+  INVALID_MODEL = 'PKU146',
+
+  // Optimization diagnostics
+  SERVICES_NOT_DESTRUCTURED = 'PKU410',
+  WIRES_NOT_DESTRUCTURED = 'PKU411',
+
   // Feature Flag
   WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED = 'PKU901',
 }

package/src/index.ts

@@ -1,12 +1,7 @@
 export { inspect, getInitialInspectorState } from './inspector.js'
-export { getFilesAndMethods } from './utils/get-files-and-methods.js'
 export type { TypesMap } from './types-map.js'
 export type * from './types.js'
-export type { InspectorState } from './types.js'
-export type {
-  FilesAndMethods,
-  FilesAndMethodsErrors,
-} from './utils/get-files-and-methods.js'
+export type { FilesAndMethodsErrors } from './utils/get-files-and-methods.js'
 export { ErrorCode } from './error-codes.js'
 export {
   serializeInspectorState,
@@ -14,15 +9,30 @@ export {
 } from './utils/serialize-inspector-state.js'
 export type { SerializableInspectorState } from './utils/serialize-inspector-state.js'
 export { filterInspectorState } from './utils/filter-inspector-state.js'
-export { writeAllServiceMetadata } from './utils/write-service-metadata.js'
-export type { ServiceMetadata } from './utils/extract-service-metadata.js'
 export {
-  convertAllDslToGraphs,
-  convertDslToGraph,
-} from './utils/workflow/graph/convert-dsl-to-graph.js'
+  generateCustomTypes,
+  sanitizeTypeName,
+} from './utils/custom-types-generator.js'
+export {
+  createEmptyManifest,
+  serializeManifest,
+} from './utils/contract-hashes.js'
+export type {
+  ContractEntry,
+  VersionHashEntry,
+  VersionValidateError,
+  VersionManifest,
+  VersionManifestEntry,
+} from './utils/contract-hashes.js'
+export { serializeMCPJson } from './utils/serialize-mcp-json.js'
+export type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js'
 export {
   deserializeDslWorkflow,
   deserializeGraphWorkflow,
   deserializeAllDslWorkflows,
-} from './utils/workflow/dsl/deserialize-dsl-workflow.js'
-export type { SerializedWorkflowGraph } from './utils/workflow/graph/workflow-graph.types.js'
+} from './utils/workflow/dsl/index.js'
+export { getFilesAndMethods } from './utils/get-files-and-methods.js'
+export type {
+  SerializedWorkflowGraph,
+  SerializedWorkflowGraphs,
+} from './utils/workflow/graph/index.js'

package/src/inspector.ts

@@ -2,13 +2,41 @@ import * as ts from 'typescript'
 import { performance } from 'perf_hooks'
 import { visitSetup, visitRoutes } from './visit.js'
 import { TypesMap } from './types-map.js'
-import { InspectorState, InspectorLogger, InspectorOptions } from './types.js'
+import type {
+  InspectorState,
+  InspectorLogger,
+  InspectorOptions,
+} from './types.js'
 import { getFilesAndMethods } from './utils/get-files-and-methods.js'
 import { findCommonAncestor } from './utils/find-root-dir.js'
 import {
   aggregateRequiredServices,
-  extractServiceInterfaceMetadata,
+  validateAgentModels,
+  validateAgentOverrides,
+  validateSecretOverrides,
+  validateVariableOverrides,
+  computeResolvedIOTypes,
+  computeMiddlewareGroupsMeta,
+  computePermissionsGroupsMeta,
+  computeRequiredSchemas,
+  computeDiagnostics,
 } from './utils/post-process.js'
+import { generateOpenAPISpec } from './utils/serialize-openapi-json.js'
+import { pikkuState } from '@pikku/core/internal'
+import { resolveLatestVersions } from './utils/resolve-versions.js'
+import { finalizeWorkflows } from './utils/workflow/graph/finalize-workflows.js'
+import {
+  finalizeWorkflowHelperTypes,
+  finalizeWorkflowWires,
+} from './utils/workflow/graph/finalize-workflow-wires.js'
+import { generateAllSchemas } from './utils/schema-generator.js'
+import {
+  computeContractHashes,
+  extractContractsFromMeta,
+  updateManifest,
+  createEmptyManifest,
+  validateContracts,
+} from './utils/contract-hashes.js'
 
 /**
  * Creates an initial/empty inspector state with all required properties initialized
@@ -29,7 +57,8 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
     filesAndMethods: {},
     filesAndMethodsErrors: new Map(),
     typesLookup: new Map(),
-    zodLookup: new Map(),
+    schemaLookup: new Map(),
+    schemas: {},
     functions: {
       typesMap: new TypesMap(),
       meta: {},
@@ -54,6 +83,11 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       files: new Set(),
       meta: {},
     },
+    triggers: {
+      meta: {},
+      sourceMeta: {},
+      files: new Set(),
+    },
     scheduledTasks: {
       meta: {},
       files: new Set(),
@@ -67,6 +101,7 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       files: new Map(),
       graphMeta: {},
       graphFiles: new Map(),
+      invokedWorkflows: new Set(),
     },
     rpc: {
       internalMeta: {},
@@ -74,7 +109,9 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       exposedMeta: {},
       exposedFiles: new Map(),
       invokedFunctions: new Set(),
-      usedExternalPackages: new Set(),
+      usedAddons: new Set(),
+      wireAddonDeclarations: new Map(),
+      wireAddonFiles: new Set(),
     },
     mcpEndpoints: {
       resourcesMeta: {},
@@ -82,6 +119,10 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       promptsMeta: {},
       files: new Set(),
     },
+    agents: {
+      agentsMeta: {},
+      files: new Map(),
+    },
     cli: {
       meta: {
         programs: {},
@@ -89,20 +130,39 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       },
       files: new Set(),
     },
-    forgeNodes: {
+    nodes: {
       meta: {},
       files: new Set(),
     },
-    forgeCredentials: {
-      meta: {},
+    secrets: {
+      definitions: [],
       files: new Set(),
     },
+    variables: {
+      definitions: [],
+      files: new Set(),
+    },
+    manifest: {
+      initial: null,
+      current: null,
+      errors: [],
+    },
     middleware: {
-      meta: {},
+      definitions: {},
+      instances: {},
       tagMiddleware: new Map(),
     },
+    channelMiddleware: {
+      definitions: {},
+      instances: {},
+      tagMiddleware: new Map(),
+    },
+    aiMiddleware: {
+      definitions: {},
+    },
     permissions: {
-      meta: {},
+      definitions: {},
+      instances: {},
       tagPermissions: new Map(),
     },
     serviceAggregation: {
@@ -113,22 +173,41 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       allSingletonServices: [],
       allWireServices: [],
     },
-    serviceMetadata: [],
+    resolvedIOTypes: {},
+    middlewareGroupsMeta: {
+      definitions: {},
+      instances: {},
+      httpGroups: {},
+      tagGroups: {},
+      channelMiddleware: {
+        definitions: {},
+        instances: {},
+        tagGroups: {},
+      },
+    },
+    permissionsGroupsMeta: {
+      definitions: {},
+      httpGroups: {},
+      tagGroups: {},
+    },
+    requiredSchemas: new Set(),
+    openAPISpec: null,
+    diagnostics: [],
   }
 }
 
-export const inspect = (
+export const inspect = async (
   logger: InspectorLogger,
   routeFiles: string[],
   options: InspectorOptions = {}
-): InspectorState => {
+): Promise<InspectorState> => {
   const startProgram = performance.now()
   const program = ts.createProgram(routeFiles, {
     target: ts.ScriptTarget.ESNext,
-    module: ts.ModuleKind.CommonJS,
+    module: ts.ModuleKind.Node16,
     skipLibCheck: true,
     skipDefaultLibCheck: true,
-    moduleResolution: ts.ModuleResolutionKind.Node10,
+    moduleResolution: ts.ModuleResolutionKind.Node16,
     types: [],
     allowJs: false,
     checkJs: false,
@@ -180,6 +259,32 @@ export const inspect = (
     logger.debug(
       `Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(2)}ms`
     )
+
+    resolveLatestVersions(state, logger)
+
+    if (options.schemaConfig) {
+      state.schemas = await generateAllSchemas(
+        logger,
+        options.schemaConfig,
+        state
+      )
+      computeContractHashes(
+        state.schemas,
+        state.functions.typesMap,
+        state.functions.meta
+      )
+      computeRequiredSchemas(state, options)
+    }
+
+    state.manifest.initial = options.manifest ?? null
+    const contracts = extractContractsFromMeta(state.functions.meta)
+    const baseManifest = state.manifest.initial ?? createEmptyManifest()
+    state.manifest.current = updateManifest(baseManifest, contracts)
+    state.manifest.errors = validateContracts(baseManifest, contracts).errors
+
+    finalizeWorkflows(state)
+    finalizeWorkflowHelperTypes(state)
+    finalizeWorkflowWires(state)
   }
 
   // Populate filesAndMethods
@@ -198,11 +303,26 @@ export const inspect = (
       `Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`
     )
 
-    const startServiceMeta = performance.now()
-    extractServiceInterfaceMetadata(state, checker)
-    logger.debug(
-      `Extract service metadata completed in ${(performance.now() - startServiceMeta).toFixed(2)}ms`
-    )
+    computeResolvedIOTypes(state)
+    computeMiddlewareGroupsMeta(state)
+    computePermissionsGroupsMeta(state)
+    computeDiagnostics(state)
+
+    if (options.openAPI) {
+      state.openAPISpec = await generateOpenAPISpec(
+        logger,
+        state.functions.meta,
+        state.http.meta,
+        state.schemas,
+        options.openAPI.additionalInfo,
+        pikkuState(null, 'misc', 'errors')
+      )
+    }
+
+    validateAgentModels(logger, state, options.modelConfig)
+    validateAgentOverrides(logger, state, options.modelConfig)
+    validateSecretOverrides(logger, state)
+    validateVariableOverrides(logger, state)
   }
 
   return state

package/src/schema-generator.ts

@@ -0,0 +1 @@
+export { generateAllSchemas } from './utils/schema-generator.js'

package/src/types-map.ts

@@ -28,7 +28,18 @@ export class TypesMap {
     uniqueName: string
     path: string | null
   } {
-    if (['string', 'number', 'boolean', 'null'].includes(name)) {
+    if (
+      [
+        'string',
+        'number',
+        'boolean',
+        'null',
+        'undefined',
+        'void',
+        'unknown',
+        'never',
+      ].includes(name)
+    ) {
       return {
         originalName: name,
         uniqueName: name,