@pikku/inspector 0.9.4 → 0.9.6-next.0

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { inspect } from './inspector.js';
+export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export type { TypesMap } from './types-map.js';
 export type * from './types.js';
 export type { InspectorState } from './types.js';
+export type { FilesAndMethods, FilesAndMethodsErrors, } from './utils/get-files-and-methods.js';

package/dist/index.js

@@ -1 +1,2 @@
 export { inspect } from './inspector.js';
+export { getFilesAndMethods } from './utils/get-files-and-methods.js';

package/dist/inspector.d.ts

@@ -1,3 +1,2 @@
-import { InspectorState, InspectorHTTPState, InspectorFilters, InspectorLogger } from './types.js';
-export declare const normalizeHTTPTypes: (httpState: InspectorHTTPState) => InspectorHTTPState;
-export declare const inspect: (logger: InspectorLogger, routeFiles: string[], filters: InspectorFilters) => InspectorState;
+import { InspectorState, InspectorLogger, InspectorOptions } from './types.js';
+export declare const inspect: (logger: InspectorLogger, routeFiles: string[], options?: InspectorOptions) => InspectorState;

package/dist/inspector.js

@@ -1,10 +1,8 @@
 import * as ts from 'typescript';
 import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
-export const normalizeHTTPTypes = (httpState) => {
-    return httpState;
-};
-export const inspect = (logger, routeFiles, filters) => {
+import { getFilesAndMethods } from './utils/get-files-and-methods.js';
+export const inspect = (logger, routeFiles, options = {}) => {
     const program = ts.createProgram(routeFiles, {
         target: ts.ScriptTarget.ESNext,
         module: ts.ModuleKind.CommonJS,
@@ -15,12 +13,17 @@ export const inspect = (logger, routeFiles, filters) => {
         singletonServicesTypeImportMap: new Map(),
         sessionServicesTypeImportMap: new Map(),
         userSessionTypeImportMap: new Map(),
+        configTypeImportMap: new Map(),
         singletonServicesFactories: new Map(),
         sessionServicesFactories: new Map(),
         configFactories: new Map(),
+        filesAndMethods: {},
+        filesAndMethodsErrors: new Map(),
+        typesLookup: new Map(),
         functions: {
             typesMap: new TypesMap(),
             meta: {},
+            files: new Map(),
         },
         http: {
             metaInputTypes: new Map(),
@@ -34,6 +37,7 @@ export const inspect = (logger, routeFiles, filters) => {
                 options: {},
             },
             files: new Set(),
+            routeMiddleware: new Map(),
         },
         channels: {
             files: new Set(),
@@ -60,8 +64,13 @@ export const inspect = (logger, routeFiles, filters) => {
             promptsMeta: {},
             files: new Set(),
         },
+        cli: {
+            meta: {},
+            files: new Set(),
+        },
         middleware: {
             meta: {},
+            tagMiddleware: new Map(),
         },
         permissions: {
             meta: {},
@@ -69,13 +78,15 @@ export const inspect = (logger, routeFiles, filters) => {
     };
     // First sweep: add all functions
     for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visitSetup(checker, child, state, filters, logger));
+        ts.forEachChild(sourceFile, (child) => visitSetup(logger, checker, child, state, options));
     }
     // Second sweep: add all transports
     for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visitRoutes(checker, child, state, filters, logger));
+        ts.forEachChild(sourceFile, (child) => visitRoutes(logger, checker, child, state, options));
     }
-    // Normalise the typesMap
-    state.http = normalizeHTTPTypes(state.http);
+    // Populate filesAndMethods
+    const { result, errors } = getFilesAndMethods(state, options.types);
+    state.filesAndMethods = result;
+    state.filesAndMethodsErrors = errors;
     return state;
 };

package/dist/types.d.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';
 export type PathToNameAndType = Map<string, {
@@ -15,14 +17,27 @@ export type MetaInputTypes = Map<string, {
     params: string[] | undefined;
     body: string[] | undefined;
 }>;
+export interface MiddlewareGroupMeta {
+    exportName: string | null;
+    sourceFile: string;
+    position: number;
+    services: FunctionServicesMeta;
+    middlewareCount: number;
+    isFactory: boolean;
+}
 export interface InspectorHTTPState {
     metaInputTypes: MetaInputTypes;
     meta: HTTPWiringsMeta;
     files: Set<string>;
+    routeMiddleware: Map<string, MiddlewareGroupMeta>;
 }
 export interface InspectorFunctionState {
     typesMap: TypesMap;
     meta: FunctionsMeta;
+    files: Map<string, {
+        path: string;
+        exportedName: string;
+    }>;
 }
 export interface InspectorChannelState {
     meta: ChannelsMeta;
@@ -34,7 +49,9 @@ export interface InspectorMiddlewareState {
         sourceFile: string;
         position: number;
         exportedName: string | null;
+        factory?: boolean;
     }>;
+    tagMiddleware: Map<string, MiddlewareGroupMeta>;
 }
 export interface InspectorPermissionState {
     meta: Record<string, {
@@ -49,19 +66,77 @@ export type InspectorFilters = {
     types?: string[];
     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[]>;
     http: InspectorHTTPState;
     functions: InspectorFunctionState;
     channels: InspectorChannelState;
@@ -92,6 +167,10 @@ export interface InspectorState {
         promptsMeta: MCPPromptMeta;
         files: Set<string>;
     };
+    cli: {
+        meta: CLIMeta;
+        files: Set<string>;
+    };
     middleware: InspectorMiddlewareState;
     permissions: InspectorPermissionState;
 }

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

@@ -1,7 +1,5 @@
 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;
@@ -23,17 +21,11 @@ export declare function makeDeterministicAnonName(start: ts.Node, checker: ts.Ty
  * 3. Fallback to deterministic name
  */
 export declare function extractFunctionName(callExpr: ts.Node, checker: ts.TypeChecker): ExtractedFunctionName;
-export declare const extractTypeKeys: (type: ts.Type) => string[];
-export declare function getPropertyAssignmentInitializer(obj: ts.ObjectLiteralExpression, propName: string, followShorthand?: boolean, checker?: ts.TypeChecker): ts.Expression | undefined;
-export declare const matchesFilters: (filters: InspectorFilters, params: {
-    tags?: string[];
-}, meta: {
-    type: PikkuWiringTypes;
-    name: string;
-    filePath?: string;
-}, logger: InspectorLogger) => boolean;
 /**
- * Extract services from a function's first parameter destructuring pattern
+ * Helper function to populate the 'name' field based on priority
+ */
+export declare function populateNameByPriority(result: ExtractedFunctionName): void;
+/**
+ * Helper function to check if a variable declaration is a named export
  */
-export declare function extractServicesFromFunction(handlerNode: ts.FunctionExpression | ts.ArrowFunction): FunctionServicesMeta;
-export {};
+export declare function isNamedExport(declaration: ts.VariableDeclaration): boolean;

package/dist/{utils.js → utils/extract-function-name.js}

@@ -256,9 +256,8 @@ export function extractFunctionName(callExpr, checker) {
             }
         }
     }
-    // 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)) {
         const { expression, arguments: args } = callExpr;
@@ -284,7 +283,7 @@ export function extractFunctionName(callExpr, checker) {
                     const firstArg = args[0];
                     if (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
                     }
                 }
             }
@@ -321,7 +320,7 @@ export function extractFunctionName(callExpr, checker) {
                                             if (firstArg &&
                                                 (ts.isArrowFunction(firstArg) ||
                                                     ts.isFunctionExpression(firstArg))) {
-                                                mainFunc = firstArg;
+                                                // mainFunc = firstArg
                                                 // Check if the variable is exported
                                                 if (isNamedExport(funcDecl) &&
                                                     ts.isIdentifier(funcDecl.name)) {
@@ -336,7 +335,7 @@ export function extractFunctionName(callExpr, checker) {
                                         }
                                         else if (ts.isFunctionExpression(funcDecl.initializer) ||
                                             ts.isArrowFunction(funcDecl.initializer)) {
-                                            mainFunc = funcDecl.initializer;
+                                            // mainFunc = funcDecl.initializer
                                             // Check if the variable is exported
                                             if (isNamedExport(funcDecl) &&
                                                 ts.isIdentifier(funcDecl.name)) {
@@ -350,7 +349,7 @@ export function extractFunctionName(callExpr, checker) {
                                         }
                                     }
                                     else if (ts.isFunctionDeclaration(funcDecl)) {
-                                        mainFunc = funcDecl;
+                                        // mainFunc = funcDecl
                                         // Check if the function is exported
                                         if (funcDecl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
                                             funcDecl.name &&
@@ -368,14 +367,14 @@ export function extractFunctionName(callExpr, checker) {
                             }
                             else {
                                 // If we can't resolve the symbol, use the identifier itself
-                                mainFunc = prop.initializer;
+                                // mainFunc = prop.initializer
                             }
                             break;
                         }
                         else if (ts.isFunctionExpression(prop.initializer) ||
                             ts.isArrowFunction(prop.initializer)) {
                             // func: () => {} or func: function() {} - use directly
-                            mainFunc = prop.initializer;
+                            // mainFunc = prop.initializer
                             break;
                         }
                     }
@@ -401,7 +400,7 @@ export function extractFunctionName(callExpr, checker) {
                                     if (firstArg &&
                                         (ts.isArrowFunction(firstArg) ||
                                             ts.isFunctionExpression(firstArg))) {
-                                        mainFunc = firstArg;
+                                        // mainFunc = firstArg
                                         // Check if the variable is exported
                                         if (isNamedExport(shorthandDecl) &&
                                             ts.isIdentifier(shorthandDecl.name)) {
@@ -416,7 +415,7 @@ export function extractFunctionName(callExpr, checker) {
                                 }
                                 else if (ts.isFunctionExpression(shorthandDecl.initializer) ||
                                     ts.isArrowFunction(shorthandDecl.initializer)) {
-                                    mainFunc = shorthandDecl.initializer;
+                                    // mainFunc = shorthandDecl.initializer
                                     // Check if the variable is exported
                                     if (isNamedExport(shorthandDecl) &&
                                         ts.isIdentifier(shorthandDecl.name)) {
@@ -430,7 +429,7 @@ export function extractFunctionName(callExpr, checker) {
                                 }
                             }
                             else if (ts.isFunctionDeclaration(shorthandDecl)) {
-                                mainFunc = shorthandDecl;
+                                // mainFunc = shorthandDecl
                                 // Check if the function is exported
                                 if (shorthandDecl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
                                     shorthandDecl.name &&
@@ -468,6 +467,9 @@ export function extractFunctionName(callExpr, checker) {
                     if (ts.isCallExpression(decl.initializer) &&
                         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)) {
@@ -486,7 +488,7 @@ export function extractFunctionName(callExpr, checker) {
                             if (firstArg &&
                                 (ts.isArrowFunction(firstArg) ||
                                     ts.isFunctionExpression(firstArg))) {
-                                mainFunc = firstArg;
+                                // mainFunc = firstArg
                             }
                         }
                         // Check if the variable is exported
@@ -502,7 +504,7 @@ export function extractFunctionName(callExpr, checker) {
                     }
                     else if (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)) {
                             result.exportedName = decl.name.text;
@@ -513,7 +515,7 @@ export function extractFunctionName(callExpr, checker) {
                     }
                 }
                 else if (ts.isFunctionDeclaration(decl)) {
-                    mainFunc = decl;
+                    // mainFunc = decl
                     // Check if the function is exported
                     if (decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
                         decl.name &&
@@ -527,8 +529,10 @@ export function extractFunctionName(callExpr, checker) {
             }
         }
     }
-    // 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(...)
     if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
@@ -577,7 +581,7 @@ export function extractFunctionName(callExpr, checker) {
 /**
  * Helper function to populate the 'name' field based on priority
  */
-function populateNameByPriority(result) {
+export function populateNameByPriority(result) {
     // Priority 1: If we have an explict name, use that
     if (result.explicitName) {
         result.name = result.explicitName;
@@ -599,7 +603,7 @@ function populateNameByPriority(result) {
 /**
  * Helper function to check if a variable declaration is a named export
  */
-function isNamedExport(declaration) {
+export function isNamedExport(declaration) {
     let parent = declaration.parent;
     if (!parent)
         return false;
@@ -616,126 +620,3 @@ function isNamedExport(declaration) {
     }
     return false;
 }
-// Until here
-export const extractTypeKeys = (type) => {
-    return type.getProperties().map((symbol) => symbol.getName());
-};
-export function getPropertyAssignmentInitializer(obj, propName, followShorthand = false, checker) {
-    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;
-            }
-            // fallback – just give back the identifier
-            return prop.name;
-        }
-    }
-    return undefined;
-}
-export const matchesFilters = (filters, params, meta, logger) => {
-    // 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) {
-    const services = {
-        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/dist/utils/extract-services.d.ts

@@ -0,0 +1,6 @@
+import * as ts from 'typescript';
+import { FunctionServicesMeta } from '@pikku/core';
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export declare function extractServicesFromFunction(handlerNode: ts.FunctionExpression | ts.ArrowFunction): FunctionServicesMeta;

package/dist/utils/extract-services.js

@@ -0,0 +1,29 @@
+import * as ts from 'typescript';
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export function extractServicesFromFunction(handlerNode) {
+    const services = {
+        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/dist/utils/filter-utils.d.ts

@@ -0,0 +1,9 @@
+import { InspectorFilters, InspectorLogger } from '../types.js';
+import { PikkuWiringTypes } from '@pikku/core';
+export declare const matchesFilters: (filters: InspectorFilters, params: {
+    tags?: string[];
+}, meta: {
+    type: PikkuWiringTypes;
+    name: string;
+    filePath?: string;
+}, logger: InspectorLogger) => boolean;

package/dist/utils/filter-utils.js

@@ -0,0 +1,45 @@
+export const matchesFilters = (filters, params, meta, logger) => {
+    // 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;
+};

package/dist/utils/get-files-and-methods.d.ts

@@ -0,0 +1,21 @@
+import { PathToNameAndType, InspectorState, InspectorOptions } from '../types.js';
+interface Meta {
+    file: string;
+    variable: string;
+    type: string;
+    typePath: string;
+}
+export type FilesAndMethods = {
+    userSessionType: Meta;
+    sessionServicesType: Meta;
+    singletonServicesType: Meta;
+    pikkuConfigFactory: Meta;
+    singletonServicesFactory: Meta;
+    sessionServicesFactory: Meta;
+};
+export type FilesAndMethodsErrors = Map<string, PathToNameAndType>;
+export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, }?: InspectorOptions["types"]) => {
+    result: Partial<FilesAndMethods>;
+    errors: FilesAndMethodsErrors;
+};
+export {};