@pikku/inspector 0.9.6-next.0 → 0.10.1

package/dist/utils/serialize-inspector-state.js

@@ -0,0 +1,170 @@
+import { TypesMap } from '../types-map.js';
+/**
+ * Serializes InspectorState to a JSON-compatible format
+ * Omits typesLookup (not needed for filtering/generation) and converts Maps/Sets to arrays
+ */
+export function serializeInspectorState(state) {
+    // Helper to serialize TypesMap
+    const serializeTypesMap = (typesMap) => {
+        // Access private map via type assertion
+        const mapEntries = Array.from(typesMap.map.entries());
+        const customTypesEntries = Array.from(typesMap.customTypes.entries());
+        return {
+            map: mapEntries,
+            customTypes: customTypesEntries,
+        };
+    };
+    return {
+        rootDir: state.rootDir,
+        singletonServicesTypeImportMap: Array.from(state.singletonServicesTypeImportMap.entries()),
+        sessionServicesTypeImportMap: Array.from(state.sessionServicesTypeImportMap.entries()),
+        userSessionTypeImportMap: Array.from(state.userSessionTypeImportMap.entries()),
+        configTypeImportMap: Array.from(state.configTypeImportMap.entries()),
+        singletonServicesFactories: Array.from(state.singletonServicesFactories.entries()),
+        sessionServicesFactories: Array.from(state.sessionServicesFactories.entries()),
+        sessionServicesMeta: Array.from(state.sessionServicesMeta.entries()),
+        configFactories: Array.from(state.configFactories.entries()),
+        filesAndMethods: state.filesAndMethods,
+        filesAndMethodsErrors: Array.from(state.filesAndMethodsErrors.entries()).map(([key, mapValue]) => [key, Array.from(mapValue.entries())]),
+        functions: {
+            typesMap: serializeTypesMap(state.functions.typesMap),
+            meta: state.functions.meta,
+            files: Array.from(state.functions.files.entries()),
+        },
+        http: {
+            metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
+            meta: state.http.meta,
+            files: Array.from(state.http.files),
+            routeMiddleware: Array.from(state.http.routeMiddleware.entries()),
+            routePermissions: Array.from(state.http.routePermissions.entries()),
+        },
+        channels: {
+            files: Array.from(state.channels.files),
+            meta: state.channels.meta,
+        },
+        scheduledTasks: {
+            meta: state.scheduledTasks.meta,
+            files: Array.from(state.scheduledTasks.files),
+        },
+        queueWorkers: {
+            meta: state.queueWorkers.meta,
+            files: Array.from(state.queueWorkers.files),
+        },
+        rpc: {
+            internalMeta: state.rpc.internalMeta,
+            internalFiles: Array.from(state.rpc.internalFiles.entries()),
+            exposedMeta: state.rpc.exposedMeta,
+            exposedFiles: Array.from(state.rpc.exposedFiles.entries()),
+            invokedFunctions: Array.from(state.rpc.invokedFunctions),
+        },
+        mcpEndpoints: {
+            resourcesMeta: state.mcpEndpoints.resourcesMeta,
+            toolsMeta: state.mcpEndpoints.toolsMeta,
+            promptsMeta: state.mcpEndpoints.promptsMeta,
+            files: Array.from(state.mcpEndpoints.files),
+        },
+        cli: {
+            meta: state.cli.meta,
+            files: Array.from(state.cli.files),
+        },
+        middleware: {
+            meta: state.middleware.meta,
+            tagMiddleware: Array.from(state.middleware.tagMiddleware.entries()),
+        },
+        permissions: {
+            meta: state.permissions.meta,
+            tagPermissions: Array.from(state.permissions.tagPermissions.entries()),
+        },
+        serviceAggregation: {
+            requiredServices: Array.from(state.serviceAggregation.requiredServices),
+            usedFunctions: Array.from(state.serviceAggregation.usedFunctions),
+            usedMiddleware: Array.from(state.serviceAggregation.usedMiddleware),
+            usedPermissions: Array.from(state.serviceAggregation.usedPermissions),
+        },
+    };
+}
+/**
+ * Deserializes JSON data back to InspectorState
+ * Creates a partial state suitable for filtering/generation (without typesLookup)
+ */
+export function deserializeInspectorState(data) {
+    // Helper to deserialize TypesMap
+    const deserializeTypesMap = (serialized) => {
+        const typesMap = new TypesMap();
+        typesMap.map = new Map(serialized.map);
+        // Restore public customTypes
+        typesMap.customTypes = new Map(serialized.customTypes);
+        return typesMap;
+    };
+    return {
+        rootDir: data.rootDir,
+        singletonServicesTypeImportMap: new Map(data.singletonServicesTypeImportMap),
+        sessionServicesTypeImportMap: new Map(data.sessionServicesTypeImportMap),
+        userSessionTypeImportMap: new Map(data.userSessionTypeImportMap),
+        configTypeImportMap: new Map(data.configTypeImportMap),
+        singletonServicesFactories: new Map(data.singletonServicesFactories),
+        sessionServicesFactories: new Map(data.sessionServicesFactories),
+        sessionServicesMeta: new Map(data.sessionServicesMeta),
+        configFactories: new Map(data.configFactories),
+        filesAndMethods: data.filesAndMethods,
+        filesAndMethodsErrors: new Map(data.filesAndMethodsErrors.map(([key, entries]) => [
+            key,
+            new Map(entries),
+        ])),
+        functions: {
+            typesMap: deserializeTypesMap(data.functions.typesMap),
+            meta: data.functions.meta,
+            files: new Map(data.functions.files),
+        },
+        http: {
+            metaInputTypes: new Map(data.http.metaInputTypes),
+            meta: data.http.meta,
+            files: new Set(data.http.files),
+            routeMiddleware: new Map(data.http.routeMiddleware),
+            routePermissions: new Map(data.http.routePermissions),
+        },
+        channels: {
+            files: new Set(data.channels.files),
+            meta: data.channels.meta,
+        },
+        scheduledTasks: {
+            meta: data.scheduledTasks.meta,
+            files: new Set(data.scheduledTasks.files),
+        },
+        queueWorkers: {
+            meta: data.queueWorkers.meta,
+            files: new Set(data.queueWorkers.files),
+        },
+        rpc: {
+            internalMeta: data.rpc.internalMeta,
+            internalFiles: new Map(data.rpc.internalFiles),
+            exposedMeta: data.rpc.exposedMeta,
+            exposedFiles: new Map(data.rpc.exposedFiles),
+            invokedFunctions: new Set(data.rpc.invokedFunctions),
+        },
+        mcpEndpoints: {
+            resourcesMeta: data.mcpEndpoints.resourcesMeta,
+            toolsMeta: data.mcpEndpoints.toolsMeta,
+            promptsMeta: data.mcpEndpoints.promptsMeta,
+            files: new Set(data.mcpEndpoints.files),
+        },
+        cli: {
+            meta: data.cli.meta,
+            files: new Set(data.cli.files),
+        },
+        middleware: {
+            meta: data.middleware.meta,
+            tagMiddleware: new Map(data.middleware.tagMiddleware),
+        },
+        permissions: {
+            meta: data.permissions.meta,
+            tagPermissions: new Map(data.permissions.tagPermissions),
+        },
+        serviceAggregation: {
+            requiredServices: new Set(data.serviceAggregation.requiredServices),
+            usedFunctions: new Set(data.serviceAggregation.usedFunctions),
+            usedMiddleware: new Set(data.serviceAggregation.usedMiddleware),
+            usedPermissions: new Set(data.serviceAggregation.usedPermissions),
+        },
+    };
+}

package/dist/visit.js

@@ -12,14 +12,14 @@ import { addChannel } from './add/add-channel.js';
 import { addRPCInvocations } from './add/add-rpc-invocations.js';
 import { addMiddleware } from './add/add-middleware.js';
 import { addPermission } from './add/add-permission.js';
-import { addCLI } from './add/add-cli.js';
+import { addCLI, addCLIRenderers } from './add/add-cli.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
     addFileExtendsCoreType(node, checker, state.sessionServicesTypeImportMap, 'CoreServices', state);
     addFileExtendsCoreType(node, checker, state.userSessionTypeImportMap, 'CoreUserSession', state);
     addFileExtendsCoreType(node, checker, state.configTypeImportMap, 'CoreConfig', state);
     addFileWithFactory(node, checker, state.singletonServicesFactories, 'CreateSingletonServices');
-    addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices');
+    addFileWithFactory(node, checker, state.sessionServicesFactories, 'CreateSessionServices', state);
     addFileWithFactory(node, checker, state.configFactories, 'CreateConfig');
     addRPCInvocations(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
@@ -33,6 +33,7 @@ export const visitRoutes = (logger, checker, node, state, options) => {
     addQueueWorker(logger, node, checker, state, options);
     addChannel(logger, node, checker, state, options);
     addCLI(logger, node, checker, state, options);
+    addCLIRenderers(logger, node, checker, state, options);
     addMCPResource(logger, node, checker, state, options);
     addMCPTool(logger, node, checker, state, options);
     addMCPPrompt(logger, node, checker, state, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.9.6-next.0",
+  "version": "0.10.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "type": "module",
@@ -16,12 +16,12 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@pikku/core": "^0.9.12-next.0",
-    "path-to-regexp": "^8.2.0",
+    "@pikku/core": "^0.10.1",
+    "path-to-regexp": "^8.3.0",
     "typescript": "^5.9"
   },
   "devDependencies": {
-    "@types/node": "^24.2.1"
+    "@types/node": "^24.9.1"
   },
   "engines": {
     "node": ">=18"

package/src/add/add-channel.ts

@@ -1,13 +1,17 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from '../utils/get-property-value.js'
+import { ErrorCode } from '../error-codes.js'
+import {
+  getPropertyValue,
+  getPropertyTags,
+} from '../utils/get-property-value.js'
 import { pathToRegexp } from 'path-to-regexp'
-import { PikkuDocs, PikkuWiringTypes } from '@pikku/core'
+import { PikkuDocs } from '@pikku/core'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
-import { matchesFilters } from '../utils/filter-utils.js'
 import type { ChannelMessageMeta, ChannelMeta } from '@pikku/core/channel'
 import type { InspectorState, AddWiring } from '../types.js'
 import { resolveMiddleware } from '../utils/middleware.js'
+import { extractWireNames } from '../utils/post-process.js'
 
 /**
  * Safely get the "initializer" expression of a property-like AST node:
@@ -33,7 +37,8 @@ function getInitializerOf(
  */
 function getHandlerNameFromExpression(
   expr: ts.Expression,
-  checker: ts.TypeChecker
+  checker: ts.TypeChecker,
+  rootDir: string
 ): string | null {
   // Handle direct identifier case (which includes shorthand properties)
   if (ts.isIdentifier(expr)) {
@@ -59,27 +64,28 @@ function getHandlerNameFromExpression(
             // Extract function name from the declaration's initializer
             const { pikkuFuncName } = extractFunctionName(
               decl.initializer,
-              checker
+              checker,
+              rootDir
             )
             return pikkuFuncName
           }
         }
         // For function declarations, use directly
         else if (ts.isFunctionDeclaration(decl)) {
-          const { pikkuFuncName } = extractFunctionName(decl, checker)
+          const { pikkuFuncName } = extractFunctionName(decl, checker, rootDir)
           return pikkuFuncName
         }
       }
     }
 
     // Fallback: try to extract directly from the identifier
-    const { pikkuFuncName } = extractFunctionName(expr, checker)
+    const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir)
     return pikkuFuncName
   }
 
   // Handle call expressions
   if (ts.isCallExpression(expr)) {
-    const { pikkuFuncName } = extractFunctionName(expr, checker)
+    const { pikkuFuncName } = extractFunctionName(expr, checker, rootDir)
     return pikkuFuncName
   }
 
@@ -87,7 +93,7 @@ function getHandlerNameFromExpression(
   if (ts.isObjectLiteralExpression(expr)) {
     const fnProp = getPropertyAssignmentInitializer(expr, 'func', true, checker)
     if (fnProp) {
-      return getHandlerNameFromExpression(fnProp, checker)
+      return getHandlerNameFromExpression(fnProp, checker, rootDir)
     }
   }
 
@@ -99,6 +105,10 @@ function getHandlerNameFromExpression(
  * in state.functions.meta instead of re-inferring it here.
  */
 export function addMessagesRoutes(
+  logger: {
+    error: (msg: string) => void
+    critical: (code: ErrorCode, msg: string) => void
+  },
   obj: ts.ObjectLiteralExpression,
   state: InspectorState,
   checker: ts.TypeChecker
@@ -178,7 +188,8 @@ export function addMessagesRoutes(
                   ) {
                     const { pikkuFuncName } = extractFunctionName(
                       importDecl.initializer,
-                      checker
+                      checker,
+                      state.rootDir
                     )
                     const handlerName = pikkuFuncName
 
@@ -195,7 +206,8 @@ export function addMessagesRoutes(
                   // Extract from the function declaration
                   const { pikkuFuncName } = extractFunctionName(
                     importDecl,
-                    checker
+                    checker,
+                    state.rootDir
                   )
                   const handlerName = pikkuFuncName
 
@@ -230,7 +242,8 @@ export function addMessagesRoutes(
                       ) {
                         const { pikkuFuncName } = extractFunctionName(
                           exportDecl.initializer,
-                          checker
+                          checker,
+                          state.rootDir
                         )
                         const handlerName = pikkuFuncName
 
@@ -244,7 +257,8 @@ export function addMessagesRoutes(
                       } else if (ts.isFunctionDeclaration(exportDecl)) {
                         const { pikkuFuncName } = extractFunctionName(
                           exportDecl,
-                          checker
+                          checker,
+                          state.rootDir
                         )
                         const handlerName = pikkuFuncName
 
@@ -277,7 +291,8 @@ export function addMessagesRoutes(
             if (possibleMatch) {
               const fnMeta = state.functions.meta[possibleMatch]
               if (!fnMeta) {
-                console.error(
+                logger.critical(
+                  ErrorCode.FUNCTION_METADATA_NOT_FOUND,
                   `No function metadata found for handler '${possibleMatch}'`
                 )
                 continue
@@ -312,7 +327,8 @@ export function addMessagesRoutes(
               // Extract the function name directly from the actual function
               const { pikkuFuncName } = extractFunctionName(
                 actualFunction,
-                checker
+                checker,
+                state.rootDir
               )
               const handlerName = pikkuFuncName
 
@@ -331,9 +347,13 @@ export function addMessagesRoutes(
       }
 
       // Normal processing for non-shorthand properties
-      const handlerName = getHandlerNameFromExpression(init, checker)
+      const handlerName = getHandlerNameFromExpression(
+        init,
+        checker,
+        state.rootDir
+      )
       if (!handlerName) {
-        console.error(
+        logger.error(
           `Could not resolve handler for message route '${routeKey}'`
         )
         continue
@@ -341,7 +361,10 @@ export function addMessagesRoutes(
 
       const fnMeta = state.functions.meta[handlerName]
       if (!fnMeta) {
-        console.error(`No function metadata found for handler '${handlerName}'`)
+        logger.critical(
+          ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+          `No function metadata found for handler '${handlerName}'`
+        )
         continue
       }
 
@@ -365,7 +388,6 @@ export const addChannel: AddWiring = (
   state,
   options
 ) => {
-  const filters = options.filters || {}
   if (!ts.isCallExpression(node)) return
   const { expression, arguments: args } = node
   if (!ts.isIdentifier(expression) || expression.text !== 'wireChannel') return
@@ -377,7 +399,7 @@ export const addChannel: AddWiring = (
   const route = (getPropertyValue(obj, 'route') as string) ?? ''
 
   if (!name) {
-    console.error('Channel name is required')
+    logger.critical(ErrorCode.MISSING_CHANNEL_NAME, 'Channel name is required')
     return
   }
 
@@ -389,21 +411,9 @@ export const addChannel: AddWiring = (
     : []
 
   const docs = getPropertyValue(obj, 'docs') as PikkuDocs | undefined
-  const tags = getPropertyValue(obj, 'tags') as string[] | undefined
+  const tags = getPropertyTags(obj, 'Channel', route, logger)
   const query = getPropertyValue(obj, 'query') as string[] | []
 
-  const filePath = node.getSourceFile().fileName
-
-  if (
-    !matchesFilters(
-      filters,
-      { tags },
-      { type: PikkuWiringTypes.channel, name, filePath },
-      logger
-    )
-  )
-    return
-
   const connect = getPropertyAssignmentInitializer(
     obj,
     'onConnect',
@@ -428,7 +438,8 @@ export const addChannel: AddWiring = (
 
   if (onMsgProp) {
     const handlerName =
-      onMsgProp && getHandlerNameFromExpression(onMsgProp, checker)
+      onMsgProp &&
+      getHandlerNameFromExpression(onMsgProp, checker, state.rootDir)
     const fnMeta = handlerName && state.functions.meta[handlerName]
     if (!fnMeta) {
       console.error(
@@ -437,18 +448,53 @@ export const addChannel: AddWiring = (
       throw new Error()
     } else {
       message = {
-        pikkuFuncName: extractFunctionName(onMsgProp as any, checker)
-          .pikkuFuncName,
+        pikkuFuncName: extractFunctionName(
+          onMsgProp as any,
+          checker,
+          state.rootDir
+        ).pikkuFuncName,
       }
     }
   }
 
   // nested message-routes
-  const messageWirings = addMessagesRoutes(obj, state, checker)
+  const messageWirings = addMessagesRoutes(logger, obj, state, checker)
 
   // --- resolve middleware ---
   const middleware = resolveMiddleware(state, obj, tags, checker)
 
+  // --- track used functions/middleware for service aggregation ---
+  // Track connect/disconnect/message handlers
+  if (connect) {
+    const connectFuncName = extractFunctionName(
+      connect,
+      checker,
+      state.rootDir
+    ).pikkuFuncName
+    state.serviceAggregation.usedFunctions.add(connectFuncName)
+  }
+  if (disconnect) {
+    const disconnectFuncName = extractFunctionName(
+      disconnect as any,
+      checker,
+      state.rootDir
+    ).pikkuFuncName
+    state.serviceAggregation.usedFunctions.add(disconnectFuncName)
+  }
+  if (message) {
+    state.serviceAggregation.usedFunctions.add(message.pikkuFuncName)
+  }
+  // Track message wiring handlers
+  for (const channelHandlers of Object.values(messageWirings)) {
+    for (const handler of Object.values(channelHandlers)) {
+      state.serviceAggregation.usedFunctions.add(handler.pikkuFuncName)
+    }
+  }
+  // Track middleware
+  extractWireNames(middleware).forEach((name) =>
+    state.serviceAggregation.usedMiddleware.add(name)
+  )
+
   // record into state
   state.channels.files.add(node.getSourceFile().fileName)
   state.channels.meta[name] = {
@@ -465,12 +511,18 @@ export const addChannel: AddWiring = (
     //   params
     // ),
     connect: connect
-      ? { pikkuFuncName: extractFunctionName(connect, checker).pikkuFuncName }
+      ? {
+          pikkuFuncName: extractFunctionName(connect, checker, state.rootDir)
+            .pikkuFuncName,
+        }
       : null,
     disconnect: disconnect
       ? {
-          pikkuFuncName: extractFunctionName(disconnect as any, checker)
-            .pikkuFuncName,
+          pikkuFuncName: extractFunctionName(
+            disconnect as any,
+            checker,
+            state.rootDir
+          ).pikkuFuncName,
         }
       : null,
     message,