@pikku/inspector 0.9.5 → 0.9.6-next.0

package/src/types.ts

@@ -1,8 +1,10 @@
+import * as ts from 'typescript'
 import { ChannelsMeta } from '@pikku/core/channel'
 import { HTTPWiringsMeta } from '@pikku/core/http'
 import { ScheduledTasksMeta } from '@pikku/core/scheduler'
 import { queueWorkersMeta } from '@pikku/core/queue'
 import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core'
+import { CLIMeta } from '@pikku/core'
 import { TypesMap } from './types-map.js'
 import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core'
 
@@ -20,15 +22,29 @@ export type MetaInputTypes = Map<
   }
 >
 
+export interface MiddlewareGroupMeta {
+  exportName: string | null // null if not exported
+  sourceFile: string
+  position: number
+  services: FunctionServicesMeta
+  middlewareCount: number
+  isFactory: boolean // true if wrapped in () => add...()
+}
+
 export interface InspectorHTTPState {
   metaInputTypes: MetaInputTypes
   meta: HTTPWiringsMeta
   files: Set<string>
+  // HTTP middleware calls tracking - route pattern -> group metadata
+  // Pattern '*' matches all routes (from addHTTPMiddleware('*', [...]))
+  // Pattern '/api/*' matches specific routes (from addHTTPMiddleware('/api/*', [...]))
+  routeMiddleware: Map<string, MiddlewareGroupMeta>
 }
 
 export interface InspectorFunctionState {
   typesMap: TypesMap
   meta: FunctionsMeta
+  files: Map<string, { path: string; exportedName: string }>
 }
 
 export interface InspectorChannelState {
@@ -37,6 +53,7 @@ export interface InspectorChannelState {
 }
 
 export interface InspectorMiddlewareState {
+  // Individual middleware function metadata
   meta: Record<
     string,
     {
@@ -44,8 +61,12 @@ export interface InspectorMiddlewareState {
       sourceFile: string
       position: number
       exportedName: string | null
+      factory?: boolean // true if wrapped with pikkuMiddlewareFactory
     }
   >
+  // Tag-based middleware calls tracking - tag -> group metadata
+  // e.g., export const adminMiddleware = () => addMiddleware('admin', [...])
+  tagMiddleware: Map<string, MiddlewareGroupMeta>
 }
 
 export interface InspectorPermissionState {
@@ -66,19 +87,86 @@ export type InspectorFilters = {
   directories?: string[]
 }
 
+export type InspectorOptions = Partial<{
+  types: Partial<{
+    configFileType: string
+    userSessionType: string
+    singletonServicesFactoryType: string
+    sessionServicesFactoryType: string
+  }>
+  filters: InspectorFilters
+}>
+
 export interface InspectorLogger {
   info: (message: string) => void
   error: (message: string) => void
   warn: (message: string) => void
   debug: (message: string) => void
 }
+
+export type AddWiring = (
+  logger: InspectorLogger,
+  node: ts.Node,
+  checker: ts.TypeChecker,
+  state: InspectorState,
+  options: InspectorOptions
+) => void
+export interface InspectorFilesAndMethods {
+  userSessionType?: {
+    file: string
+    variable: string
+    type: string
+    typePath: string
+  }
+  sessionServicesType?: {
+    file: string
+    variable: string
+    type: string
+    typePath: string
+  }
+  singletonServicesType?: {
+    file: string
+    variable: string
+    type: string
+    typePath: string
+  }
+  pikkuConfigType?: {
+    file: string
+    variable: string
+    type: string
+    typePath: string
+  }
+  pikkuConfigFactory?: {
+    file: string
+    variable: string
+    type: string
+    typePath: string
+  }
+  singletonServicesFactory?: {
+    file: string
+    variable: string
+    type: string
+    typePath: string
+  }
+  sessionServicesFactory?: {
+    file: string
+    variable: string
+    type: string
+    typePath: string
+  }
+}
+
 export interface InspectorState {
   singletonServicesTypeImportMap: PathToNameAndType
   sessionServicesTypeImportMap: PathToNameAndType
   userSessionTypeImportMap: PathToNameAndType
+  configTypeImportMap: PathToNameAndType
   singletonServicesFactories: PathToNameAndType
   sessionServicesFactories: PathToNameAndType
   configFactories: PathToNameAndType
+  filesAndMethods: InspectorFilesAndMethods
+  filesAndMethodsErrors: Map<string, PathToNameAndType>
+  typesLookup: Map<string, ts.Type[]> // Lookup for types by name (e.g., function input types, Config type)
   http: InspectorHTTPState
   functions: InspectorFunctionState
   channels: InspectorChannelState
@@ -103,6 +191,10 @@ export interface InspectorState {
     promptsMeta: MCPPromptMeta
     files: Set<string>
   }
+  cli: {
+    meta: CLIMeta
+    files: Set<string>
+  }
   middleware: InspectorMiddlewareState
   permissions: InspectorPermissionState
 }

package/src/{utils.ts → utils/extract-function-name.ts}

@@ -1,8 +1,6 @@
 import * as ts from 'typescript'
-import { InspectorFilters, InspectorLogger } from './types.js'
-import { PikkuWiringTypes, FunctionServicesMeta } from '@pikku/core'
 
-type ExtractedFunctionName = {
+export type ExtractedFunctionName = {
   pikkuFuncName: string
   name: string
   explicitName: string | null
@@ -338,9 +336,8 @@ export function extractFunctionName(
     }
   }
 
-  // First, figure out what function we're really dealing with
-  let mainFunc = callExpr
-  let originalCallExpr = callExpr // Keep track of the original call expression for name extraction
+  // Keep track of the original call expression for position-based naming
+  let originalCallExpr = callExpr
 
   // For direct pikku function calls where callExpr is the call expression itself
   if (ts.isCallExpression(callExpr)) {
@@ -373,7 +370,7 @@ export function extractFunctionName(
             ts.isArrowFunction(firstArg) ||
             ts.isFunctionExpression(firstArg)
           ) {
-            mainFunc = firstArg // Use the arrow function directly instead of the call expression
+            // mainFunc = firstArg // Use the arrow function directly instead of the call expression
           }
         }
       }
@@ -420,7 +417,7 @@ export function extractFunctionName(
                         (ts.isArrowFunction(firstArg) ||
                           ts.isFunctionExpression(firstArg))
                       ) {
-                        mainFunc = firstArg
+                        // mainFunc = firstArg
 
                         // Check if the variable is exported
                         if (
@@ -439,7 +436,7 @@ export function extractFunctionName(
                       ts.isFunctionExpression(funcDecl.initializer) ||
                       ts.isArrowFunction(funcDecl.initializer)
                     ) {
-                      mainFunc = funcDecl.initializer
+                      // mainFunc = funcDecl.initializer
 
                       // Check if the variable is exported
                       if (
@@ -455,7 +452,7 @@ export function extractFunctionName(
                       break
                     }
                   } else if (ts.isFunctionDeclaration(funcDecl)) {
-                    mainFunc = funcDecl
+                    // mainFunc = funcDecl
 
                     // Check if the function is exported
                     if (
@@ -479,7 +476,7 @@ export function extractFunctionName(
                 }
               } else {
                 // If we can't resolve the symbol, use the identifier itself
-                mainFunc = prop.initializer
+                // mainFunc = prop.initializer
               }
               break
             } else if (
@@ -487,7 +484,7 @@ export function extractFunctionName(
               ts.isArrowFunction(prop.initializer)
             ) {
               // func: () => {} or func: function() {} - use directly
-              mainFunc = prop.initializer
+              // mainFunc = prop.initializer
               break
             }
           } else if (
@@ -522,7 +519,7 @@ export function extractFunctionName(
                     (ts.isArrowFunction(firstArg) ||
                       ts.isFunctionExpression(firstArg))
                   ) {
-                    mainFunc = firstArg
+                    // mainFunc = firstArg
 
                     // Check if the variable is exported
                     if (
@@ -541,7 +538,7 @@ export function extractFunctionName(
                   ts.isFunctionExpression(shorthandDecl.initializer) ||
                   ts.isArrowFunction(shorthandDecl.initializer)
                 ) {
-                  mainFunc = shorthandDecl.initializer
+                  // mainFunc = shorthandDecl.initializer
 
                   // Check if the variable is exported
                   if (
@@ -557,7 +554,7 @@ export function extractFunctionName(
                   break
                 }
               } else if (ts.isFunctionDeclaration(shorthandDecl)) {
-                mainFunc = shorthandDecl
+                // mainFunc = shorthandDecl
 
                 // Check if the function is exported
                 if (
@@ -605,6 +602,10 @@ export function extractFunctionName(
             ts.isIdentifier(decl.initializer.expression) &&
             decl.initializer.expression.text.startsWith('pikku')
           ) {
+            // Update originalCallExpr to use the call expression position
+            // instead of the variable declaration position
+            originalCallExpr = decl.initializer
+
             // Check for object with 'name' property in first argument
             const firstArg = decl.initializer.arguments[0]
             if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
@@ -628,7 +629,7 @@ export function extractFunctionName(
                 (ts.isArrowFunction(firstArg) ||
                   ts.isFunctionExpression(firstArg))
               ) {
-                mainFunc = firstArg
+                // mainFunc = firstArg
               }
             }
 
@@ -645,7 +646,7 @@ export function extractFunctionName(
             ts.isFunctionExpression(decl.initializer) ||
             ts.isArrowFunction(decl.initializer)
           ) {
-            mainFunc = decl.initializer
+            // mainFunc = decl.initializer
 
             // Check if the variable is exported
             if (isNamedExport(decl) && ts.isIdentifier(decl.name)) {
@@ -655,7 +656,7 @@ export function extractFunctionName(
             }
           }
         } else if (ts.isFunctionDeclaration(decl)) {
-          mainFunc = decl
+          // mainFunc = decl
 
           // Check if the function is exported
           if (
@@ -674,8 +675,10 @@ export function extractFunctionName(
     }
   }
 
-  // Now generate the deterministic function name based on the resolved function
-  result.pikkuFuncName = makeDeterministicAnonName(mainFunc, checker)
+  // Generate the deterministic function name based on the original call expression
+  // (the config), not the resolved inner function. This ensures the metadata key
+  // matches what will be looked up at runtime when referencing the config object.
+  result.pikkuFuncName = makeDeterministicAnonName(originalCallExpr, checker)
 
   // Continue with regular name extraction for remaining cases
   // 1) const foo = pikkuFunc(...)
@@ -731,7 +734,7 @@ export function extractFunctionName(
 /**
  * Helper function to populate the 'name' field based on priority
  */
-function populateNameByPriority(result: ExtractedFunctionName): void {
+export function populateNameByPriority(result: ExtractedFunctionName): void {
   // Priority 1: If we have an explict name, use that
   if (result.explicitName) {
     result.name = result.explicitName
@@ -754,7 +757,7 @@ function populateNameByPriority(result: ExtractedFunctionName): void {
 /**
  * Helper function to check if a variable declaration is a named export
  */
-function isNamedExport(declaration: ts.VariableDeclaration): boolean {
+export function isNamedExport(declaration: ts.VariableDeclaration): boolean {
   let parent: any = declaration.parent
   if (!parent) return false
 
@@ -774,180 +777,3 @@ function isNamedExport(declaration: ts.VariableDeclaration): boolean {
 
   return false
 }
-
-// Until here
-export const extractTypeKeys = (type: ts.Type): string[] => {
-  return type.getProperties().map((symbol) => symbol.getName())
-}
-
-export function getPropertyAssignmentInitializer(
-  obj: ts.ObjectLiteralExpression,
-  propName: string,
-  followShorthand = false,
-  checker?: ts.TypeChecker
-): ts.Expression | undefined {
-  for (const prop of obj.properties) {
-    // ①  foo: () => {}
-    if (
-      ts.isPropertyAssignment(prop) &&
-      ts.isIdentifier(prop.name) &&
-      prop.name.text === propName
-    ) {
-      return prop.initializer
-    }
-
-    // ②  foo() { … }
-    if (
-      ts.isMethodDeclaration(prop) &&
-      ts.isIdentifier(prop.name) &&
-      prop.name.text === propName
-    ) {
-      return prop.name // the method node *is* the function
-    }
-
-    // ③  { foo }  (shorthand)
-    if (
-      followShorthand &&
-      ts.isShorthandPropertyAssignment(prop) &&
-      prop.name.text === propName
-    ) {
-      if (!checker) return prop.name // best effort without a checker
-
-      let sym = checker.getSymbolAtLocation(prop.name)
-      if (sym && sym.flags & ts.SymbolFlags.Alias) {
-        sym = checker.getAliasedSymbol(sym)
-      }
-
-      const decl = sym?.declarations?.[0]
-
-      // const foo = () => {}
-      if (
-        decl &&
-        ts.isVariableDeclaration(decl) &&
-        decl.initializer &&
-        (ts.isArrowFunction(decl.initializer) ||
-          ts.isFunctionExpression(decl.initializer))
-      ) {
-        return decl.initializer
-      }
-
-      // function foo() {}
-      if (
-        decl &&
-        (ts.isFunctionDeclaration(decl) ||
-          ts.isArrowFunction(decl) ||
-          ts.isFunctionExpression(decl))
-      ) {
-        return decl as ts.Expression
-      }
-
-      // fallback – just give back the identifier
-      return prop.name
-    }
-  }
-
-  return undefined
-}
-
-export const matchesFilters = (
-  filters: InspectorFilters,
-  params: { tags?: string[] },
-  meta: {
-    type: PikkuWiringTypes
-    name: string
-    filePath?: string
-  },
-  logger: InspectorLogger
-) => {
-  // If no filters are provided, allow everything
-  if (Object.keys(filters).length === 0) {
-    return true
-  }
-
-  // If all filter arrays are empty, allow everything
-  if (
-    (!filters.tags || filters.tags.length === 0) &&
-    (!filters.types || filters.types.length === 0) &&
-    (!filters.directories || filters.directories.length === 0)
-  ) {
-    return true
-  }
-
-  // Check type filter
-  if (filters.types && filters.types.length > 0) {
-    if (!filters.types.includes(meta.type)) {
-      logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`)
-      return false
-    }
-  }
-
-  // Check directory filter
-  if (filters.directories && filters.directories.length > 0) {
-    if (!meta.filePath) {
-      logger.debug(
-        `⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`
-      )
-      return false
-    }
-
-    const matchesDirectory = filters.directories.some((dir) => {
-      // Normalize paths for comparison
-      const normalizedFilePath = meta.filePath!.replace(/\\/g, '/')
-      const normalizedDir = dir.replace(/\\/g, '/')
-      return normalizedFilePath.includes(normalizedDir)
-    })
-
-    if (!matchesDirectory) {
-      logger.debug(
-        `⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`
-      )
-      return false
-    }
-  }
-
-  // Check tag filter
-  if (filters.tags && filters.tags.length > 0) {
-    if (
-      !params.tags ||
-      !filters.tags.some((tag) => params.tags!.includes(tag))
-    ) {
-      logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`)
-      return false
-    }
-  }
-
-  return true
-}
-
-/**
- * Extract services from a function's first parameter destructuring pattern
- */
-export function extractServicesFromFunction(
-  handlerNode: ts.FunctionExpression | ts.ArrowFunction
-): FunctionServicesMeta {
-  const services: FunctionServicesMeta = {
-    optimized: true,
-    services: [],
-  }
-
-  const firstParam = handlerNode.parameters[0]
-  if (firstParam) {
-    if (ts.isObjectBindingPattern(firstParam.name)) {
-      for (const elem of firstParam.name.elements) {
-        const original =
-          elem.propertyName && ts.isIdentifier(elem.propertyName)
-            ? elem.propertyName.text
-            : ts.isIdentifier(elem.name)
-              ? elem.name.text
-              : undefined
-        if (original) {
-          services.services.push(original)
-        }
-      }
-    } else if (ts.isIdentifier(firstParam.name)) {
-      services.optimized = false
-    }
-  }
-
-  return services
-}

package/src/utils/extract-services.ts

@@ -0,0 +1,35 @@
+import * as ts from 'typescript'
+import { FunctionServicesMeta } from '@pikku/core'
+
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export function extractServicesFromFunction(
+  handlerNode: ts.FunctionExpression | ts.ArrowFunction
+): FunctionServicesMeta {
+  const services: FunctionServicesMeta = {
+    optimized: true,
+    services: [],
+  }
+
+  const firstParam = handlerNode.parameters[0]
+  if (firstParam) {
+    if (ts.isObjectBindingPattern(firstParam.name)) {
+      for (const elem of firstParam.name.elements) {
+        const original =
+          elem.propertyName && ts.isIdentifier(elem.propertyName)
+            ? elem.propertyName.text
+            : ts.isIdentifier(elem.name)
+              ? elem.name.text
+              : undefined
+        if (original) {
+          services.services.push(original)
+        }
+      }
+    } else if (ts.isIdentifier(firstParam.name)) {
+      services.optimized = false
+    }
+  }
+
+  return services
+}

package/src/{utils.test.ts → utils/filter-utils.test.ts}

@@ -1,8 +1,8 @@
 import { test, describe } from 'node:test'
 import { strict as assert } from 'node:assert'
-import { matchesFilters } from './utils.js'
-import { InspectorFilters } from './types.js'
 import { PikkuWiringTypes } from '@pikku/core'
+import { InspectorFilters } from '../types'
+import { matchesFilters } from './filter-utils'
 
 describe('matchesFilters', () => {
   // Mock logger for testing

package/src/utils/filter-utils.ts

@@ -0,0 +1,72 @@
+import { InspectorFilters, InspectorLogger } from '../types.js'
+import { PikkuWiringTypes } from '@pikku/core'
+
+export const matchesFilters = (
+  filters: InspectorFilters,
+  params: { tags?: string[] },
+  meta: {
+    type: PikkuWiringTypes
+    name: string
+    filePath?: string
+  },
+  logger: InspectorLogger
+) => {
+  // If no filters are provided, allow everything
+  if (Object.keys(filters).length === 0) {
+    return true
+  }
+
+  // If all filter arrays are empty, allow everything
+  if (
+    (!filters.tags || filters.tags.length === 0) &&
+    (!filters.types || filters.types.length === 0) &&
+    (!filters.directories || filters.directories.length === 0)
+  ) {
+    return true
+  }
+
+  // Check type filter
+  if (filters.types && filters.types.length > 0) {
+    if (!filters.types.includes(meta.type)) {
+      logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  // Check directory filter
+  if (filters.directories && filters.directories.length > 0) {
+    if (!meta.filePath) {
+      logger.debug(
+        `⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`
+      )
+      return false
+    }
+
+    const matchesDirectory = filters.directories.some((dir) => {
+      // Normalize paths for comparison
+      const normalizedFilePath = meta.filePath!.replace(/\\/g, '/')
+      const normalizedDir = dir.replace(/\\/g, '/')
+      return normalizedFilePath.includes(normalizedDir)
+    })
+
+    if (!matchesDirectory) {
+      logger.debug(
+        `⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`
+      )
+      return false
+    }
+  }
+
+  // Check tag filter
+  if (filters.tags && filters.tags.length > 0) {
+    if (
+      !params.tags ||
+      !filters.tags.some((tag) => params.tags!.includes(tag))
+    ) {
+      logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`)
+      return false
+    }
+  }
+
+  return true
+}