@pikku/inspector 0.12.3 → 0.12.4

package/src/inspector.ts

@@ -20,6 +20,7 @@ import {
   computePermissionsGroupsMeta,
   computeRequiredSchemas,
   computeDiagnostics,
+  validateSchemaWiringSeparation,
 } from './utils/post-process.js'
 import { generateOpenAPISpec } from './utils/serialize-openapi-json.js'
 import { pikkuState } from '@pikku/core/internal'
@@ -203,6 +204,7 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
     openAPISpec: null,
     diagnostics: [],
     addonFunctions: {},
+    program: null,
   }
 }
 
@@ -211,8 +213,7 @@ export const inspect = async (
   routeFiles: string[],
   options: InspectorOptions = {}
 ): Promise<InspectorState> => {
-  const startProgram = performance.now()
-  const program = ts.createProgram(routeFiles, {
+  const compilerOptions: ts.CompilerOptions = {
     target: ts.ScriptTarget.ESNext,
     module: ts.ModuleKind.Node16,
     skipLibCheck: true,
@@ -221,9 +222,16 @@ export const inspect = async (
     types: [],
     allowJs: false,
     checkJs: false,
-  })
+  }
+  const startProgram = performance.now()
+  const program = ts.createProgram(
+    routeFiles,
+    compilerOptions,
+    undefined, // host
+    options.oldProgram
+  )
   logger.debug(
-    `Created program in ${(performance.now() - startProgram).toFixed(2)}ms`
+    `Created program in ${(performance.now() - startProgram).toFixed(0)}ms (${routeFiles.length} files${options.oldProgram ? ', incremental' : ''})`
   )
 
   const startChecker = performance.now()
@@ -255,7 +263,7 @@ export const inspect = async (
     )
   }
   logger.debug(
-    `Visit setup phase completed in ${(performance.now() - startSetup).toFixed(2)}ms`
+    `Visit setup phase completed in ${(performance.now() - startSetup).toFixed(0)}ms`
   )
 
   // Load addon function metadata so wirings can reference addon functions
@@ -270,17 +278,21 @@ export const inspect = async (
       )
     }
     logger.debug(
-      `Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(2)}ms`
+      `Visit routes phase completed in ${(performance.now() - startRoutes).toFixed(0)}ms`
     )
 
     resolveLatestVersions(state, logger)
 
     if (options.schemaConfig) {
+      const startSchemas = performance.now()
       state.schemas = await generateAllSchemas(
         logger,
         options.schemaConfig,
         state
       )
+      logger.debug(
+        `generateAllSchemas took ${(performance.now() - startSchemas).toFixed(0)}ms`
+      )
       computeContractHashes(
         state.schemas,
         state.functions.typesMap,
@@ -323,6 +335,7 @@ export const inspect = async (
     computeMiddlewareGroupsMeta(state)
     computePermissionsGroupsMeta(state)
     computeDiagnostics(state)
+    validateSchemaWiringSeparation(logger, state)
 
     if (options.openAPI) {
       state.openAPISpec = await generateOpenAPISpec(
@@ -341,5 +354,7 @@ export const inspect = async (
     validateVariableOverrides(logger, state)
   }
 
+  state.program = program
+
   return state
 }

package/src/types.ts

@@ -225,6 +225,7 @@ export type InspectorOptions = Partial<{
   tags: string[]
   manifest: VersionManifest
   modelConfig: InspectorModelConfig
+  oldProgram: ts.Program | undefined
 }>
 
 export interface InspectorLogger {
@@ -420,4 +421,5 @@ export interface InspectorState {
   openAPISpec: Record<string, any> | null
   diagnostics: InspectorDiagnostic[]
   addonFunctions: Record<string, FunctionsMeta> // namespace -> addon's function metadata
+  program: ts.Program | null // Retained for incremental re-inspection
 }

package/src/utils/custom-types-generator.ts

@@ -16,6 +16,7 @@ export function generateCustomTypes(
   requiredTypes: Set<string>
 ) {
   const typeDeclarations = Array.from(typesMap.customTypes.entries())
+    .sort(([a], [b]) => a.localeCompare(b))
     .filter(([_name, { type }]) => {
       const hasUndefinedGeneric =
         /\b(Name|In|Out|Key)\b/.test(type) && /\[.*\]/.test(type)

package/src/utils/post-process.ts

@@ -492,6 +492,65 @@ export function validateAgentOverrides(
   }
 }
 
+/**
+ * Validates that Zod schemas and wiring side-effects (wireHTTPRoutes,
+ * addPermission, addHTTPMiddleware, etc.) do not coexist in the same file.
+ *
+ * The CLI uses tsImport to extract Zod schemas at runtime, which executes
+ * all top-level code in the file. Wiring calls crash during this process
+ * because the pikku state metadata doesn't exist in the CLI context.
+ */
+export function validateSchemaWiringSeparation(
+  logger: InspectorLogger,
+  state: InspectorState
+): void {
+  // Collect files that contain schemas
+  const schemaFiles = new Set<string>()
+  for (const ref of state.schemaLookup.values()) {
+    schemaFiles.add(ref.sourceFile)
+  }
+
+  // Collect files that contain wiring side-effects
+  const wiringFiles = new Set<string>()
+
+  // HTTP route wirings
+  for (const file of state.http.files) {
+    wiringFiles.add(file)
+  }
+
+  // Permission wirings (addPermission calls)
+  for (const meta of state.permissions.tagPermissions.values()) {
+    wiringFiles.add(meta.sourceFile)
+  }
+  for (const meta of state.http.routePermissions.values()) {
+    wiringFiles.add(meta.sourceFile)
+  }
+
+  // Middleware wirings (addHTTPMiddleware calls)
+  for (const meta of state.http.routeMiddleware.values()) {
+    wiringFiles.add(meta.sourceFile)
+  }
+  for (const meta of state.middleware.tagMiddleware.values()) {
+    wiringFiles.add(meta.sourceFile)
+  }
+
+  // Check for overlap
+  for (const file of schemaFiles) {
+    if (wiringFiles.has(file)) {
+      const schemas = Array.from(state.schemaLookup.entries())
+        .filter(([, ref]) => ref.sourceFile === file)
+        .map(([name]) => name)
+
+      logger.critical(
+        ErrorCode.SCHEMA_AND_WIRING_COLOCATED,
+        `File '${file}' contains both Zod schemas (${schemas.join(', ')}) and wiring calls (wireHTTPRoutes, addPermission, etc.). ` +
+          `These must be in separate files because the CLI imports schema files at runtime, which triggers wiring side-effects that crash without server context. ` +
+          `Move the route/wiring definitions to a dedicated wiring file.`
+      )
+    }
+  }
+}
+
 export function computeDiagnostics(state: InspectorState): void {
   const diagnostics: InspectorDiagnostic[] = []
 

package/src/utils/schema-generator.ts

@@ -63,24 +63,37 @@ function primitiveTypeToSchema(typeStr: string): JSONValue | null {
   return null
 }
 
+// Cached state for schema program reuse across inspect() calls
+let cachedSchemaProgram: ts.Program | undefined
+let cachedParsedConfig: ts.ParsedCommandLine | undefined
+let cachedTsconfigPath: string | undefined
+let cachedCustomTypesContent: string | undefined
+let cachedTSSchemas: Record<string, JSONValue> | undefined
+
 function createProgramWithVirtualFile(
   tsconfig: string,
   virtualFilePath: string,
   virtualFileContent: string
 ): ts.Program {
   const configPath = resolve(tsconfig)
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
-  const basePath = dirname(configPath)
-  const parsedConfig = ts.parseJsonConfigFileContent(
-    configFile.config,
-    ts.sys,
-    basePath
-  )
+
+  // Cache the parsed tsconfig — it doesn't change between runs
+  if (!cachedParsedConfig || cachedTsconfigPath !== configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
+    const basePath = dirname(configPath)
+    cachedParsedConfig = ts.parseJsonConfigFileContent(
+      configFile.config,
+      ts.sys,
+      basePath
+    )
+    cachedTsconfigPath = configPath
+    cachedSchemaProgram = undefined
+  }
 
   const resolvedVirtualPath = resolve(virtualFilePath)
-  const fileNames = [...parsedConfig.fileNames, resolvedVirtualPath]
+  const fileNames = [...cachedParsedConfig.fileNames, resolvedVirtualPath]
 
-  const defaultHost = ts.createCompilerHost(parsedConfig.options)
+  const defaultHost = ts.createCompilerHost(cachedParsedConfig.options)
   const customHost: ts.CompilerHost = {
     ...defaultHost,
     getSourceFile(
@@ -113,7 +126,14 @@ function createProgramWithVirtualFile(
     },
   }
 
-  return ts.createProgram(fileNames, parsedConfig.options, customHost)
+  const program = ts.createProgram(
+    fileNames,
+    cachedParsedConfig.options,
+    customHost,
+    cachedSchemaProgram // reuse previous program for incremental compilation
+  )
+  cachedSchemaProgram = program
+  return program
 }
 
 function generateTSSchemas(
@@ -313,6 +333,11 @@ export async function generateAllSchemas(
     requiredTypes
   )
 
+  if (cachedTSSchemas && cachedCustomTypesContent === customTypesContent) {
+    logger.debug('Reusing cached TS schemas (types unchanged)')
+    return { ...cachedTSSchemas, ...zodSchemas }
+  }
+
   const tsSchemas = generateTSSchemas(
     logger,
     config.tsconfig,
@@ -325,5 +350,8 @@ export async function generateAllSchemas(
     state.schemaLookup
   )
 
+  cachedCustomTypesContent = customTypesContent
+  cachedTSSchemas = tsSchemas
+
   return { ...tsSchemas, ...zodSchemas }
 }

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

@@ -596,5 +596,6 @@ export function deserializeInspectorState(
     openAPISpec: data.openAPISpec || null,
     diagnostics: data.diagnostics || [],
     addonFunctions: data.addonFunctions || {},
+    program: null,
   }
 }

package/src/utils/workflow/graph/convert-dsl-to-graph.ts

@@ -400,6 +400,7 @@ export function convertDslToGraph(
     source,
     description: meta.description,
     tags: meta.tags,
+    inline: meta.inline,
     context: meta.context,
     nodes: nodesRecord,
     entryNodeIds,

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

@@ -192,6 +192,8 @@ export interface SerializedWorkflowGraph {
   description?: string
   /** Tags for organization */
   tags?: string[]
+  /** If true, workflow always executes inline without queues */
+  inline?: boolean
   /** Workflow context/state variables (from Zod schema) */
   context?: WorkflowContext
   /** Serialized nodes */