@pikku/inspector 0.9.5 → 0.10.0

package/src/{add-file-extends-core-type.ts → add/add-file-extends-core-type.ts}

@@ -1,11 +1,12 @@
 import * as ts from 'typescript'
-import { PathToNameAndType } from './types.js'
+import { PathToNameAndType, InspectorState } from '../types.js'
 
 export const addFileExtendsCoreType = (
   node: ts.Node,
   checker: ts.TypeChecker,
   methods: PathToNameAndType,
-  expectedTypeName: string
+  expectedTypeName: string,
+  state?: InspectorState
 ) => {
   if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
     const fileName = node.getSourceFile().fileName
@@ -32,13 +33,30 @@ export const addFileExtendsCoreType = (
                 extendedTypeDeclarationPath = sourceFile.fileName // Get the path of the file where the extended type was declared
               }
 
-              const variables = methods[fileName] || []
+              const variables = methods.get(fileName) || []
+
+              if (!typeName) {
+                throw new Error(
+                  `Found anonymous ${ts.isClassDeclaration(node) ? 'class' : 'interface'} extending ${expectedTypeName} in ${fileName}. ` +
+                    `Classes and interfaces that extend core types must have a name.`
+                )
+              }
               variables.push({
-                variable: undefined,
+                variable: typeName,
                 type: typeName,
                 typePath: extendedTypeDeclarationPath,
               })
-              methods[fileName] = variables
+              methods.set(fileName, variables)
+
+              // Store the type in typesLookup if state is provided
+              if (state && node.name) {
+                const symbol = checker.getSymbolAtLocation(node.name)
+                if (symbol) {
+                  const declaredType = checker.getDeclaredTypeOfSymbol(symbol)
+                  // Use the type name as the key in typesLookup
+                  state.typesLookup.set(typeName, [declaredType])
+                }
+              }
             }
           }
         }

package/src/{add-file-with-config.ts → add/add-file-with-config.ts}

@@ -1,6 +1,6 @@
 import * as ts from 'typescript'
-import { doesTypeExtendsCore } from './does-type-extend-core-type.js'
-import { PathToNameAndType } from './types.js'
+import { doesTypeExtendsCore } from '../utils/does-type-extend-core-type.js'
+import { PathToNameAndType } from '../types.js'
 
 export const addFileWithConfig = (
   node: ts.Node,

package/src/{add-file-with-factory.ts → add/add-file-with-factory.ts}

@@ -1,11 +1,13 @@
 import * as ts from 'typescript'
-import { PathToNameAndType } from './types.js'
+import { PathToNameAndType, InspectorState } from '../types.js'
+import { extractServicesFromFunction } from '../utils/extract-services.js'
 
 export const addFileWithFactory = (
   node: ts.Node,
   checker: ts.TypeChecker,
   methods: PathToNameAndType = new Map(),
-  expectedTypeName: string
+  expectedTypeName: string,
+  state?: InspectorState
 ) => {
   if (ts.isVariableDeclaration(node)) {
     const fileName = node.getSourceFile().fileName
@@ -30,13 +32,32 @@ export const addFileWithFactory = (
           typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
         }
 
-        const variables = methods[fileName] || []
+        const variables = methods.get(fileName) || []
         variables.push({
           variable: variableName,
           type: typeNameNode.getText(),
           typePath: typeDeclarationPath,
         })
-        methods[fileName] = variables
+        methods.set(fileName, variables)
+
+        // Extract singleton services for CreateSessionServices factories
+        if (
+          expectedTypeName === 'CreateSessionServices' &&
+          state &&
+          node.initializer
+        ) {
+          let functionNode: ts.ArrowFunction | ts.FunctionExpression | undefined
+          if (ts.isArrowFunction(node.initializer)) {
+            functionNode = node.initializer
+          } else if (ts.isFunctionExpression(node.initializer)) {
+            functionNode = node.initializer
+          }
+
+          if (functionNode) {
+            const servicesMeta = extractServicesFromFunction(functionNode)
+            state.sessionServicesMeta.set(variableName, servicesMeta.services)
+          }
+        }
       }
 
       // Handle qualified type names if necessary
@@ -51,13 +72,35 @@ export const addFileWithFactory = (
             typeDeclarationPath = sourceFile.fileName // Get the path of the file where the type was declared
           }
 
-          const variables = methods[fileName] || []
+          const variables = methods.get(fileName) || []
           variables.push({
             variable: variableName,
             type: typeNameNode.getText(),
             typePath: typeDeclarationPath,
           })
-          methods[fileName] = variables
+          methods.set(fileName, variables)
+
+          // Extract singleton services for CreateSessionServices factories
+          if (
+            expectedTypeName === 'CreateSessionServices' &&
+            state &&
+            node.initializer
+          ) {
+            let functionNode:
+              | ts.ArrowFunction
+              | ts.FunctionExpression
+              | undefined
+            if (ts.isArrowFunction(node.initializer)) {
+              functionNode = node.initializer
+            } else if (ts.isFunctionExpression(node.initializer)) {
+              functionNode = node.initializer
+            }
+
+            if (functionNode) {
+              const servicesMeta = extractServicesFromFunction(functionNode)
+              state.sessionServicesMeta.set(variableName, servicesMeta.services)
+            }
+          }
         }
       }
     }

package/src/{add-functions.ts → add/add-functions.ts}

@@ -1,12 +1,11 @@
 import * as ts from 'typescript'
-import { InspectorLogger, InspectorState } from './types.js'
-import { TypesMap } from './types-map.js'
-import {
-  extractFunctionName,
-  getPropertyAssignmentInitializer,
-} from './utils.js'
+import { AddWiring } from '../types.js'
+import { TypesMap } from '../types-map.js'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { FunctionServicesMeta, PikkuDocs } from '@pikku/core'
-import { getPropertyValue } from './get-property-value.js'
+import { getPropertyValue } from '../utils/get-property-value.js'
+import { resolveMiddleware } from '../utils/middleware.js'
 
 const isValidVariableName = (name: string) => {
   const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/
@@ -28,7 +27,8 @@ const nullifyTypes = (type: string | null) => {
 const resolveTypeImports = (
   type: ts.Type,
   resolvedTypes: TypesMap,
-  isCustom: boolean
+  isCustom: boolean,
+  checker: ts.TypeChecker
 ): string[] => {
   const types: string[] = []
 
@@ -43,10 +43,14 @@ const resolveTypeImports = (
         const path = sourceFile.fileName
 
         // Skip built-in utility types or TypeScript lib types
+        // Skip enum members (but not the enum type itself)
+        const isEnumMember = declaration && ts.isEnumMember(declaration)
+
         if (
           !path.includes('node_modules/typescript') &&
           symbol.getName() !== '__type' &&
-          !isPrimitiveType(currentType)
+          !isPrimitiveType(currentType) &&
+          !isEnumMember
         ) {
           const originalName = symbol.getName()
           // Check if the type is already in the map
@@ -103,6 +107,32 @@ const resolveTypeImports = (
       const typeRef = currentType as ts.TypeReference
       typeRef.typeArguments?.forEach(visitType)
     }
+
+    // Handle anonymous object types with enum properties (e.g., { userType: UserType })
+    // Only traverse into enum property types to avoid over-importing other named types
+    if (currentType.flags & ts.TypeFlags.Object) {
+      const objectType = currentType as ts.ObjectType
+      const typeSymbol = objectType.getSymbol()
+
+      // Only traverse properties for anonymous object types (no symbol or __type symbol)
+      // Skip named types, interfaces, and enums to avoid over-importing
+      const isAnonymousObject = !typeSymbol || typeSymbol.getName() === '__type'
+
+      if (isAnonymousObject) {
+        const properties = objectType.getProperties()
+        for (const prop of properties) {
+          if (prop.valueDeclaration) {
+            const propType = checker.getTypeOfSymbolAtLocation(
+              prop,
+              prop.valueDeclaration
+            )
+            if (propType) {
+              visitType(propType)
+            }
+          }
+        }
+      }
+    }
   }
 
   visitType(type)
@@ -171,7 +201,7 @@ const getNamesAndTypes = (
 
     // record the alias in your TypesMap
     const references = rawTypes
-      .map((t) => resolveTypeImports(t, typesMap, true))
+      .map((t) => resolveTypeImports(t, typesMap, true, checker))
       .flat()
 
     typesMap.addCustomType(aliasName, aliasType, references)
@@ -193,7 +223,7 @@ const getNamesAndTypes = (
         return name
       }
       // non-primitive: import/alias it inline
-      return resolveTypeImports(t, typesMap, false)
+      return resolveTypeImports(t, typesMap, false, checker)
     })
     .flat()
 
@@ -247,12 +277,7 @@ function unwrapPromise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
  */
-export function addFunctions(
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  logger: InspectorLogger
-) {
+export const addFunctions: AddWiring = (logger, node, checker, state) => {
   if (!ts.isCallExpression(node)) return
 
   const { expression, arguments: args, typeArguments } = node
@@ -276,11 +301,12 @@ export function addFunctions(
   if (args.length === 0) return
 
   const { pikkuFuncName, name, explicitName, exportedName } =
-    extractFunctionName(node, checker)
+    extractFunctionName(node, checker, state.rootDir)
 
   let tags: string[] | undefined
   let expose: boolean | undefined
   let docs: PikkuDocs | undefined
+  let objectNode: ts.ObjectLiteralExpression | undefined
 
   // determine the actual handler expression:
   // either the `func` prop or the first argument directly
@@ -289,6 +315,7 @@ export function addFunctions(
 
   if (ts.isObjectLiteralExpression(handlerNode)) {
     isDirectFunction = false // This is object format with func property
+    objectNode = handlerNode
     tags = (getPropertyValue(handlerNode, 'tags') as string[]) || undefined
     expose = getPropertyValue(handlerNode, 'expose') as boolean | undefined
     docs = getPropertyValue(handlerNode, 'docs') as PikkuDocs | undefined
@@ -304,6 +331,17 @@ export function addFunctions(
       (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))
     ) {
       logger.error(`• No valid 'func' property found for ${pikkuFuncName}.`)
+      // Create stub metadata to prevent "function not found" errors in wirings
+      state.functions.meta[pikkuFuncName] = {
+        pikkuFuncName,
+        name,
+        services: { optimized: false, services: [] },
+        inputSchemaName: null,
+        outputSchemaName: null,
+        inputs: [],
+        outputs: [],
+        middleware: undefined,
+      }
       return
     }
     handlerNode = fnProp
@@ -314,6 +352,17 @@ export function addFunctions(
     !ts.isFunctionExpression(handlerNode)
   ) {
     logger.error(`• Handler for ${name} is not a function.`)
+    // Create stub metadata to prevent "function not found" errors in wirings
+    state.functions.meta[pikkuFuncName] = {
+      pikkuFuncName,
+      name,
+      services: { optimized: false, services: [] },
+      inputSchemaName: null,
+      outputSchemaName: null,
+      inputs: [],
+      outputs: [],
+      middleware: undefined,
+    }
     return
   }
 
@@ -347,7 +396,7 @@ export function addFunctions(
     .map((t) => unwrapPromise(checker, t))
 
   // --- Input Extraction ---
-  let { names: inputNames } = getNamesAndTypes(
+  let { names: inputNames, types: inputTypes } = getNamesAndTypes(
     checker,
     state.functions.typesMap,
     'Input',
@@ -391,6 +440,11 @@ export function addFunctions(
     )
   }
 
+  // --- resolve middleware ---
+  const middleware = objectNode
+    ? resolveMiddleware(state, objectNode, tags, checker)
+    : undefined
+
   state.functions.meta[pikkuFuncName] = {
     pikkuFuncName,
     name,
@@ -403,6 +457,20 @@ export function addFunctions(
     tags: tags || undefined,
     docs: docs || undefined,
     isDirectFunction,
+    middleware,
+  }
+
+  // Store the input type for later use
+  if (inputTypes.length > 0) {
+    state.typesLookup.set(pikkuFuncName, inputTypes)
+  }
+
+  // Store function file location for wiring generation
+  if (exportedName) {
+    state.functions.files.set(pikkuFuncName, {
+      path: node.getSourceFile().fileName,
+      exportedName,
+    })
   }
 
   if (exportedName || explicitName) {
@@ -419,6 +487,8 @@ export function addFunctions(
         path: node.getSourceFile().fileName,
         exportedName,
       })
+      // Track exposed RPC function for service aggregation
+      state.serviceAggregation.usedFunctions.add(pikkuFuncName)
     }
 
     // We add it to internal meta to allow autocomplete for everything

package/src/{add-http-route.ts → add/add-http-route.ts}

@@ -1,14 +1,19 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from './get-property-value.js'
+import {
+  getPropertyValue,
+  getPropertyTags,
+} from '../utils/get-property-value.js'
 import { pathToRegexp } from 'path-to-regexp'
 import { HTTPMethod } from '@pikku/core/http'
-import { PikkuDocs, PikkuWiringTypes } from '@pikku/core'
-import {
-  extractFunctionName,
-  getPropertyAssignmentInitializer,
-  matchesFilters,
-} from './utils.js'
-import { InspectorState, InspectorFilters, InspectorLogger } from './types.js'
+import { PikkuDocs } from '@pikku/core'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
+import { AddWiring } from '../types.js'
+import { resolveHTTPMiddlewareFromObject } from '../utils/middleware.js'
+import { resolveHTTPPermissionsFromObject } from '../utils/permissions.js'
+import { extractWireNames } from '../utils/post-process.js'
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
+import { ErrorCode } from '../error-codes.js'
 
 /**
  * Populate metaInputTypes for a given route based on method, input type,
@@ -39,12 +44,12 @@ export const getInputTypes = (
  * Simplified wireHTTP: re-uses function metadata from state.functions.meta
  * instead of re-inferring types here.
  */
-export const addHTTPRoute = (
-  node: ts.Node,
-  checker: ts.TypeChecker,
-  state: InspectorState,
-  filters: InspectorFilters,
-  logger: InspectorLogger
+export const addHTTPRoute: AddWiring = (
+  logger,
+  node,
+  checker,
+  state,
+  options
 ) => {
   // only look at calls
   if (!ts.isCallExpression(node)) return
@@ -67,23 +72,10 @@ export const addHTTPRoute = (
   const method =
     (getPropertyValue(obj, 'method') as string)?.toLowerCase() || 'get'
   const docs = (getPropertyValue(obj, 'docs') as PikkuDocs) || undefined
-  const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+  const tags = getPropertyTags(obj, 'HTTP route', route, logger)
   const query = (getPropertyValue(obj, 'query') as string[]) || []
 
-  const filePath = node.getSourceFile().fileName
-
-  if (
-    !matchesFilters(
-      filters,
-      { tags },
-      { type: PikkuWiringTypes.http, name: route, filePath },
-      logger
-    )
-  ) {
-    return
-  }
-
-  // --- find the referenced function ---
+  // --- find the referenced function name first for filtering ---
   const funcInitializer = getPropertyAssignmentInitializer(
     obj,
     'func',
@@ -91,16 +83,29 @@ export const addHTTPRoute = (
     checker
   )
   if (!funcInitializer) {
-    console.error(`• No valid 'func' property for route '${route}'.`)
+    logger.critical(
+      ErrorCode.MISSING_FUNC,
+      `No valid 'func' property for route '${route}'.`
+    )
     return
   }
 
-  const funcName = extractFunctionName(funcInitializer, checker).pikkuFuncName
+  const funcName = extractFunctionName(
+    funcInitializer,
+    checker,
+    state.rootDir
+  ).pikkuFuncName
+
+  // Ensure function metadata exists (creates stub for inline functions)
+  ensureFunctionMetadata(state, funcName, route)
 
   // lookup existing function metadata
   const fnMeta = state.functions.meta[funcName]
   if (!fnMeta) {
-    console.error(`• No function metadata found for '${funcName}'.`)
+    logger.critical(
+      ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+      `No function metadata found for '${funcName}'.`
+    )
     return
   }
   const input = fnMeta.inputs?.[0] || null
@@ -114,6 +119,33 @@ export const addHTTPRoute = (
     params
   )
 
+  // --- resolve middleware ---
+  const middleware = resolveHTTPMiddlewareFromObject(
+    state,
+    route,
+    obj,
+    tags,
+    checker
+  )
+
+  // --- resolve permissions ---
+  const permissions = resolveHTTPPermissionsFromObject(
+    state,
+    route,
+    obj,
+    tags,
+    checker
+  )
+
+  // --- track used functions/middleware/permissions for service aggregation ---
+  state.serviceAggregation.usedFunctions.add(funcName)
+  extractWireNames(middleware).forEach((name) =>
+    state.serviceAggregation.usedMiddleware.add(name)
+  )
+  extractWireNames(permissions).forEach((name) =>
+    state.serviceAggregation.usedPermissions.add(name)
+  )
+
   // --- record route ---
   state.http.files.add(node.getSourceFile().fileName)
   state.http.meta[method][route] = {
@@ -125,5 +157,7 @@ export const addHTTPRoute = (
     inputTypes,
     docs,
     tags,
+    middleware,
+    permissions,
   }
 }

package/src/add/add-mcp-prompt.ts

@@ -0,0 +1,128 @@
+import * as ts from 'typescript'
+import {
+  getPropertyValue,
+  getPropertyTags,
+} from '../utils/get-property-value.js'
+import { extractWireNames } from '../utils/post-process.js'
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
+import { AddWiring } from '../types.js'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
+import { resolveMiddleware } from '../utils/middleware.js'
+import { resolvePermissions } from '../utils/permissions.js'
+import { ErrorCode } from '../error-codes.js'
+
+export const addMCPPrompt: AddWiring = (
+  logger,
+  node,
+  checker,
+  state,
+  options
+) => {
+  if (!ts.isCallExpression(node)) {
+    return
+  }
+
+  const args = node.arguments
+  const firstArg = args[0]
+  const expression = node.expression
+
+  // Check if the call is to wireMCPPrompt
+  if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPPrompt') {
+    return
+  }
+
+  if (!firstArg) {
+    return
+  }
+
+  if (ts.isObjectLiteralExpression(firstArg)) {
+    const obj = firstArg
+
+    const nameValue = getPropertyValue(obj, 'name') as string | null
+    const descriptionValue = getPropertyValue(obj, 'description') as
+      | string
+      | null
+    const tags = getPropertyTags(obj, 'MCP prompt', nameValue, logger)
+
+    const funcInitializer = getPropertyAssignmentInitializer(
+      obj,
+      'func',
+      true,
+      checker
+    )
+    if (!funcInitializer) {
+      logger.critical(
+        ErrorCode.MISSING_FUNC,
+        `No valid 'func' property for MCP prompt '${nameValue}'.`
+      )
+      return
+    }
+
+    const pikkuFuncName = extractFunctionName(
+      funcInitializer,
+      checker,
+      state.rootDir
+    ).pikkuFuncName
+
+    // Ensure function metadata exists (creates stub for inline functions)
+    ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined)
+
+    if (!nameValue) {
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        "MCP prompt is missing the required 'name' property."
+      )
+      return
+    }
+
+    if (!descriptionValue) {
+      logger.critical(
+        ErrorCode.MISSING_DESCRIPTION,
+        `MCP prompt '${nameValue}' is missing a description.`
+      )
+      return
+    }
+
+    // lookup existing function metadata
+    const fnMeta = state.functions.meta[pikkuFuncName]
+    if (!fnMeta) {
+      logger.critical(
+        ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+        `No function metadata found for '${pikkuFuncName}'.`
+      )
+      return
+    }
+    const inputSchema = fnMeta.inputs?.[0] || null
+    const outputSchema = fnMeta.outputs?.[0] || null
+
+    // --- resolve middleware ---
+    const middleware = resolveMiddleware(state, obj, tags, checker)
+
+    // --- resolve permissions ---
+    const permissions = resolvePermissions(state, obj, tags, checker)
+
+    // --- track used functions/middleware/permissions for service aggregation ---
+    state.serviceAggregation.usedFunctions.add(pikkuFuncName)
+    extractWireNames(middleware).forEach((name) =>
+      state.serviceAggregation.usedMiddleware.add(name)
+    )
+    extractWireNames(permissions).forEach((name) =>
+      state.serviceAggregation.usedPermissions.add(name)
+    )
+
+    state.mcpEndpoints.files.add(node.getSourceFile().fileName)
+
+    state.mcpEndpoints.promptsMeta[nameValue] = {
+      pikkuFuncName,
+      name: nameValue,
+      description: descriptionValue,
+      tags,
+      inputSchema,
+      outputSchema,
+      arguments: [], // Will be populated by CLI during serialization
+      middleware,
+      permissions,
+    }
+  }
+}