@pikku/inspector 0.9.6-next.0 → 0.10.1

package/dist/inspector.js

@@ -2,6 +2,8 @@ import * as ts from 'typescript';
 import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 import { getFilesAndMethods } from './utils/get-files-and-methods.js';
+import { findCommonAncestor } from './utils/find-root-dir.js';
+import { aggregateRequiredServices } from './utils/post-process.js';
 export const inspect = (logger, routeFiles, options = {}) => {
     const program = ts.createProgram(routeFiles, {
         target: ts.ScriptTarget.ESNext,
@@ -9,13 +11,17 @@ export const inspect = (logger, routeFiles, options = {}) => {
     });
     const checker = program.getTypeChecker();
     const sourceFiles = program.getSourceFiles();
+    // Infer root directory from source files
+    const rootDir = findCommonAncestor(routeFiles);
     const state = {
+        rootDir,
         singletonServicesTypeImportMap: new Map(),
         sessionServicesTypeImportMap: new Map(),
         userSessionTypeImportMap: new Map(),
         configTypeImportMap: new Map(),
         singletonServicesFactories: new Map(),
         sessionServicesFactories: new Map(),
+        sessionServicesMeta: new Map(),
         configFactories: new Map(),
         filesAndMethods: {},
         filesAndMethodsErrors: new Map(),
@@ -38,6 +44,7 @@ export const inspect = (logger, routeFiles, options = {}) => {
             },
             files: new Set(),
             routeMiddleware: new Map(),
+            routePermissions: new Map(),
         },
         channels: {
             files: new Set(),
@@ -65,7 +72,10 @@ export const inspect = (logger, routeFiles, options = {}) => {
             files: new Set(),
         },
         cli: {
-            meta: {},
+            meta: {
+                programs: {},
+                renderers: {},
+            },
             files: new Set(),
         },
         middleware: {
@@ -74,6 +84,13 @@ export const inspect = (logger, routeFiles, options = {}) => {
         },
         permissions: {
             meta: {},
+            tagPermissions: new Map(),
+        },
+        serviceAggregation: {
+            requiredServices: new Set(),
+            usedFunctions: new Set(),
+            usedMiddleware: new Set(),
+            usedPermissions: new Set(),
         },
     };
     // First sweep: add all functions
@@ -88,5 +105,7 @@ export const inspect = (logger, routeFiles, options = {}) => {
     const { result, errors } = getFilesAndMethods(state, options.types);
     state.filesAndMethods = result;
     state.filesAndMethodsErrors = errors;
+    // Post-processing: Aggregate required services from wired functions/middleware/permissions
+    aggregateRequiredServices(state);
     return state;
 };

package/dist/types.d.ts

@@ -3,10 +3,11 @@ 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 { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
+import { CLIMeta } from '@pikku/core/cli';
 import { TypesMap } from './types-map.js';
 import { FunctionsMeta, FunctionServicesMeta } from '@pikku/core';
+import { ErrorCode } from './error-codes.js';
 export type PathToNameAndType = Map<string, {
     variable: string;
     type: string | null;
@@ -25,11 +26,20 @@ export interface MiddlewareGroupMeta {
     middlewareCount: number;
     isFactory: boolean;
 }
+export interface PermissionGroupMeta {
+    exportName: string | null;
+    sourceFile: string;
+    position: number;
+    services: FunctionServicesMeta;
+    permissionCount: number;
+    isFactory: boolean;
+}
 export interface InspectorHTTPState {
     metaInputTypes: MetaInputTypes;
     meta: HTTPWiringsMeta;
     files: Set<string>;
     routeMiddleware: Map<string, MiddlewareGroupMeta>;
+    routePermissions: Map<string, PermissionGroupMeta>;
 }
 export interface InspectorFunctionState {
     typesMap: TypesMap;
@@ -50,6 +60,8 @@ export interface InspectorMiddlewareState {
         position: number;
         exportedName: string | null;
         factory?: boolean;
+        name?: string;
+        description?: string;
     }>;
     tagMiddleware: Map<string, MiddlewareGroupMeta>;
 }
@@ -59,12 +71,19 @@ export interface InspectorPermissionState {
         sourceFile: string;
         position: number;
         exportedName: string | null;
+        factory?: boolean;
+        name?: string;
+        description?: string;
     }>;
+    tagPermissions: Map<string, PermissionGroupMeta>;
 }
 export type InspectorFilters = {
+    names?: string[];
     tags?: string[];
     types?: string[];
     directories?: string[];
+    httpRoutes?: string[];
+    httpMethods?: string[];
 };
 export type InspectorOptions = Partial<{
     types: Partial<{
@@ -73,13 +92,14 @@ export type InspectorOptions = Partial<{
         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;
+    critical: (code: ErrorCode, message: string) => void;
+    hasCriticalErrors: () => boolean;
 }
 export type AddWiring = (logger: InspectorLogger, node: ts.Node, checker: ts.TypeChecker, state: InspectorState, options: InspectorOptions) => void;
 export interface InspectorFilesAndMethods {
@@ -127,12 +147,14 @@ export interface InspectorFilesAndMethods {
     };
 }
 export interface InspectorState {
+    rootDir: string;
     singletonServicesTypeImportMap: PathToNameAndType;
     sessionServicesTypeImportMap: PathToNameAndType;
     userSessionTypeImportMap: PathToNameAndType;
     configTypeImportMap: PathToNameAndType;
     singletonServicesFactories: PathToNameAndType;
     sessionServicesFactories: PathToNameAndType;
+    sessionServicesMeta: Map<string, string[]>;
     configFactories: PathToNameAndType;
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;
@@ -173,4 +195,10 @@ export interface InspectorState {
     };
     middleware: InspectorMiddlewareState;
     permissions: InspectorPermissionState;
+    serviceAggregation: {
+        requiredServices: Set<string>;
+        usedFunctions: Set<string>;
+        usedMiddleware: Set<string>;
+        usedPermissions: Set<string>;
+    };
 }

package/dist/utils/ensure-function-metadata.d.ts

@@ -0,0 +1,6 @@
+import { InspectorState } from '../types.js';
+/**
+ * Ensures that function metadata exists for a given pikkuFuncName.
+ * Creates stub metadata if it doesn't exist (useful for inline functions).
+ */
+export declare function ensureFunctionMetadata(state: InspectorState, pikkuFuncName: string, fallbackName?: string): void;

package/dist/utils/ensure-function-metadata.js

@@ -0,0 +1,18 @@
+/**
+ * Ensures that function metadata exists for a given pikkuFuncName.
+ * Creates stub metadata if it doesn't exist (useful for inline functions).
+ */
+export function ensureFunctionMetadata(state, pikkuFuncName, fallbackName) {
+    if (!state.functions.meta[pikkuFuncName]) {
+        state.functions.meta[pikkuFuncName] = {
+            pikkuFuncName,
+            name: fallbackName || pikkuFuncName,
+            services: { optimized: false, services: [] },
+            inputSchemaName: null,
+            outputSchemaName: null,
+            inputs: [],
+            outputs: [],
+            middleware: undefined,
+        };
+    }
+}

package/dist/utils/extract-function-name.d.ts

@@ -12,7 +12,7 @@ export type ExtractedFunctionName = {
  * but if it's an Identifier pointing to a function, resolve it back
  * to the function's declaration (so you get the true source location).
  */
-export declare function makeDeterministicAnonName(start: ts.Node, checker: ts.TypeChecker): string;
+export declare function makeDeterministicAnonName(start: ts.Node, checker: ts.TypeChecker, rootDir: string): string;
 /**
  * Updated function to extract and prioritize function names correctly
  * This function follows the priority:
@@ -20,7 +20,7 @@ export declare function makeDeterministicAnonName(start: ts.Node, checker: ts.Ty
  * 2. Exported name
  * 3. Fallback to deterministic name
  */
-export declare function extractFunctionName(callExpr: ts.Node, checker: ts.TypeChecker): ExtractedFunctionName;
+export declare function extractFunctionName(callExpr: ts.Node, checker: ts.TypeChecker, rootDir: string): ExtractedFunctionName;
 /**
  * Helper function to populate the 'name' field based on priority
  */

package/dist/utils/extract-function-name.js

@@ -1,10 +1,11 @@
 import * as ts from 'typescript';
+import { toRelativePath } from './find-root-dir.js';
 /**
  * Generate a deterministic "anonymous" name for any expression node,
  * but if it's an Identifier pointing to a function, resolve it back
  * to the function's declaration (so you get the true source location).
  */
-export function makeDeterministicAnonName(start, checker) {
+export function makeDeterministicAnonName(start, checker, rootDir) {
     let node = start;
     let target = start;
     // Handle the case where we're starting with an identifier directly
@@ -27,7 +28,8 @@ export function makeDeterministicAnonName(start, checker) {
                     target = decl.initializer;
                     // Return early - we found the function directly
                     const sf = target.getSourceFile();
-                    const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+                    const relativePath = toRelativePath(sf.fileName, rootDir);
+                    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
                     const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
                     return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
                 }
@@ -62,7 +64,8 @@ export function makeDeterministicAnonName(start, checker) {
                         target = decl.initializer;
                         // Return early - we found the function directly
                         const sf = target.getSourceFile();
-                        const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+                        const relativePath = toRelativePath(sf.fileName, rootDir);
+                        const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
                         const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
                         return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
                     }
@@ -72,7 +75,8 @@ export function makeDeterministicAnonName(start, checker) {
                     target = decl;
                     // Return early
                     const sf = target.getSourceFile();
-                    const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+                    const relativePath = toRelativePath(sf.fileName, rootDir);
+                    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
                     const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
                     return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
                 }
@@ -182,7 +186,8 @@ export function makeDeterministicAnonName(start, checker) {
             break;
     }
     const sf = target.getSourceFile();
-    const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+    const relativePath = toRelativePath(sf.fileName, rootDir);
+    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
     const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
     return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
 }
@@ -193,7 +198,7 @@ export function makeDeterministicAnonName(start, checker) {
  * 2. Exported name
  * 3. Fallback to deterministic name
  */
-export function extractFunctionName(callExpr, checker) {
+export function extractFunctionName(callExpr, checker, rootDir) {
     const parent = callExpr.parent;
     // Initialize the result
     const result = {
@@ -230,7 +235,7 @@ export function extractFunctionName(callExpr, checker) {
                             (ts.isArrowFunction(firstArg) ||
                                 ts.isFunctionExpression(firstArg))) {
                             // Use the function directly for position calculation
-                            result.pikkuFuncName = makeDeterministicAnonName(firstArg, checker);
+                            result.pikkuFuncName = makeDeterministicAnonName(firstArg, checker, rootDir);
                             // Continue with name extraction
                             if (ts.isIdentifier(parent.name)) {
                                 result.propertyName = parent.name.text;
@@ -532,7 +537,7 @@ export function extractFunctionName(callExpr, 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);
+    result.pikkuFuncName = makeDeterministicAnonName(originalCallExpr, checker, rootDir);
     // Continue with regular name extraction for remaining cases
     // 1) const foo = pikkuFunc(...)
     if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {

package/dist/utils/filter-inspector-state.d.ts

@@ -0,0 +1,6 @@
+import { InspectorState, InspectorFilters, InspectorLogger } from '../types.js';
+/**
+ * Filters inspector state based on provided filters
+ * This is applied post-inspection to support the inspect-once, filter-many pattern
+ */
+export declare function filterInspectorState(state: InspectorState | Omit<InspectorState, 'typesLookup'>, filters: InspectorFilters, logger: InspectorLogger): typeof state;