@pikku/inspector 0.9.6-next.0 → 0.10.0

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;

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

@@ -0,0 +1,382 @@
+import { aggregateRequiredServices } from './post-process.js';
+/**
+ * Match a value against a pattern with wildcard support
+ * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")
+ */
+function matchesWildcard(value, pattern) {
+    if (pattern === '*')
+        return true;
+    const startsWithWildcard = pattern.startsWith('*');
+    const endsWithWildcard = pattern.endsWith('*');
+    if (startsWithWildcard && endsWithWildcard) {
+        const middle = pattern.slice(1, -1);
+        if (middle === '')
+            return true;
+        return value.includes(middle);
+    }
+    else if (startsWithWildcard) {
+        const suffix = pattern.slice(1);
+        return value.endsWith(suffix) && value.length > suffix.length;
+    }
+    else if (endsWithWildcard) {
+        const prefix = pattern.slice(0, -1);
+        return value.startsWith(prefix) && value.length > prefix.length;
+    }
+    return value === pattern;
+}
+/**
+ * Check if metadata matches the given filters
+ */
+function matchesFilters(filters, meta, logger) {
+    // If no filters, allow everything
+    if (Object.keys(filters).length === 0)
+        return true;
+    // If all filter arrays are empty, allow everything
+    if ((!filters.names || filters.names.length === 0) &&
+        (!filters.tags || filters.tags.length === 0) &&
+        (!filters.types || filters.types.length === 0) &&
+        (!filters.directories || filters.directories.length === 0) &&
+        (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
+        (!filters.httpMethods || filters.httpMethods.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 && meta.filePath) {
+        const matchesDirectory = filters.directories.some((dir) => {
+            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}`);
+            return false;
+        }
+    }
+    // Check tag filter
+    if (filters.tags && filters.tags.length > 0) {
+        if (!meta.tags || !filters.tags.some((tag) => meta.tags.includes(tag))) {
+            logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check name filter
+    if (filters.names && filters.names.length > 0) {
+        const nameMatches = filters.names.some((pattern) => matchesWildcard(meta.name, pattern));
+        if (!nameMatches) {
+            logger.debug(`⒡ Filtered by name: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check HTTP route filter
+    if (filters.httpRoutes && filters.httpRoutes.length > 0 && meta.httpRoute) {
+        const routeMatches = filters.httpRoutes.some((pattern) => matchesWildcard(meta.httpRoute, pattern));
+        if (!routeMatches) {
+            logger.debug(`⒡ Filtered by HTTP route: ${meta.httpRoute}`);
+            return false;
+        }
+    }
+    // Check HTTP method filter
+    if (filters.httpMethods &&
+        filters.httpMethods.length > 0 &&
+        meta.httpMethod) {
+        const normalizedMethod = meta.httpMethod.toUpperCase();
+        if (!filters.httpMethods.includes(normalizedMethod)) {
+            logger.debug(`⒡ Filtered by HTTP method: ${meta.httpMethod}`);
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Extract wire names from middleware/permissions metadata
+ */
+function extractWireNames(obj) {
+    if (!obj)
+        return [];
+    const names = [];
+    for (const key of Object.keys(obj)) {
+        if (obj[key] && typeof obj[key] === 'object' && 'name' in obj[key]) {
+            names.push(obj[key].name);
+        }
+    }
+    return names;
+}
+/**
+ * Filters inspector state based on provided filters
+ * This is applied post-inspection to support the inspect-once, filter-many pattern
+ */
+export function filterInspectorState(state, filters, logger) {
+    // If no filters, return original state
+    if (Object.keys(filters).length === 0 ||
+        ((!filters.names || filters.names.length === 0) &&
+            (!filters.tags || filters.tags.length === 0) &&
+            (!filters.types || filters.types.length === 0) &&
+            (!filters.directories || filters.directories.length === 0) &&
+            (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
+            (!filters.httpMethods || filters.httpMethods.length === 0))) {
+        return state;
+    }
+    // Create a shallow copy with new Maps/Sets to avoid mutating the original
+    const filteredState = {
+        ...state,
+        serviceAggregation: {
+            ...state.serviceAggregation,
+            requiredServices: new Set(), // Reset requiredServices - will be recalculated
+            usedFunctions: new Set(),
+            usedMiddleware: new Set(),
+            usedPermissions: new Set(),
+        },
+        http: {
+            ...state.http,
+            meta: JSON.parse(JSON.stringify(state.http.meta)), // Deep clone metadata
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        channels: {
+            ...state.channels,
+            meta: JSON.parse(JSON.stringify(state.channels.meta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        scheduledTasks: {
+            ...state.scheduledTasks,
+            meta: JSON.parse(JSON.stringify(state.scheduledTasks.meta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        queueWorkers: {
+            ...state.queueWorkers,
+            meta: JSON.parse(JSON.stringify(state.queueWorkers.meta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        mcpEndpoints: {
+            ...state.mcpEndpoints,
+            toolsMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.toolsMeta)),
+            resourcesMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.resourcesMeta)),
+            promptsMeta: JSON.parse(JSON.stringify(state.mcpEndpoints.promptsMeta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+        cli: {
+            ...state.cli,
+            meta: JSON.parse(JSON.stringify(state.cli.meta)),
+            files: new Set(), // Will be repopulated with filtered files
+        },
+    };
+    // Filter HTTP routes
+    for (const method of Object.keys(filteredState.http.meta)) {
+        const routes = filteredState.http.meta[method];
+        for (const route of Object.keys(routes)) {
+            const routeMeta = routes[route];
+            // Get function file path for directory filtering
+            const funcFile = filteredState.functions.files.get(routeMeta.pikkuFuncName);
+            const filePath = funcFile?.path;
+            const matches = matchesFilters(filters, {
+                type: 'http',
+                name: routeMeta.pikkuFuncName, // Use function name, not route
+                tags: routeMeta.tags,
+                filePath,
+                httpRoute: routeMeta.route,
+                httpMethod: routeMeta.method,
+            }, logger);
+            if (!matches) {
+                delete routes[route];
+            }
+            else {
+                // Track used functions/middleware/permissions
+                if (routeMeta.pikkuFuncName) {
+                    filteredState.serviceAggregation.usedFunctions.add(routeMeta.pikkuFuncName);
+                }
+                extractWireNames(routeMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+                extractWireNames(routeMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+            }
+        }
+    }
+    // Repopulate http.files if any routes remain
+    const hasHttpRoutes = Object.values(filteredState.http.meta).some((routes) => Object.keys(routes).length > 0);
+    if (hasHttpRoutes) {
+        filteredState.http.files = new Set(state.http.files);
+    }
+    // Filter channels
+    for (const name of Object.keys(filteredState.channels.meta)) {
+        const channelMeta = filteredState.channels.meta[name];
+        const matches = matchesFilters(filters, {
+            type: 'channel',
+            name,
+            tags: channelMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.channels.meta[name];
+        }
+        else {
+            if (channelMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(channelMeta.pikkuFuncName);
+            }
+            extractWireNames(channelMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(channelMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    // Repopulate channels.files if any channels remain
+    if (Object.keys(filteredState.channels.meta).length > 0) {
+        filteredState.channels.files = new Set(state.channels.files);
+    }
+    // Filter scheduled tasks
+    for (const name of Object.keys(filteredState.scheduledTasks.meta)) {
+        const taskMeta = filteredState.scheduledTasks.meta[name];
+        const matches = matchesFilters(filters, {
+            type: 'scheduler',
+            name,
+            tags: taskMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.scheduledTasks.meta[name];
+        }
+        else {
+            if (taskMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(taskMeta.pikkuFuncName);
+            }
+            extractWireNames(taskMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+        }
+    }
+    // Repopulate scheduledTasks.files if any tasks remain
+    if (Object.keys(filteredState.scheduledTasks.meta).length > 0) {
+        filteredState.scheduledTasks.files = new Set(state.scheduledTasks.files);
+    }
+    // Filter queue workers
+    for (const name of Object.keys(filteredState.queueWorkers.meta)) {
+        const workerMeta = filteredState.queueWorkers.meta[name];
+        const matches = matchesFilters(filters, {
+            type: 'queue',
+            name,
+            tags: workerMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.queueWorkers.meta[name];
+        }
+        else {
+            if (workerMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(workerMeta.pikkuFuncName);
+            }
+            extractWireNames(workerMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+        }
+    }
+    // Repopulate queueWorkers.files if any workers remain
+    if (Object.keys(filteredState.queueWorkers.meta).length > 0) {
+        filteredState.queueWorkers.files = new Set(state.queueWorkers.files);
+    }
+    // Filter MCP tools
+    for (const name of Object.keys(filteredState.mcpEndpoints.toolsMeta)) {
+        const toolMeta = filteredState.mcpEndpoints.toolsMeta[name];
+        const matches = matchesFilters(filters, {
+            type: 'mcp',
+            name,
+            tags: toolMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.mcpEndpoints.toolsMeta[name];
+        }
+        else {
+            if (toolMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(toolMeta.pikkuFuncName);
+            }
+            extractWireNames(toolMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(toolMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    // Filter MCP resources
+    for (const name of Object.keys(filteredState.mcpEndpoints.resourcesMeta)) {
+        const resourceMeta = filteredState.mcpEndpoints.resourcesMeta[name];
+        const matches = matchesFilters(filters, {
+            type: 'mcp',
+            name,
+            tags: resourceMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.mcpEndpoints.resourcesMeta[name];
+        }
+        else {
+            if (resourceMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(resourceMeta.pikkuFuncName);
+            }
+            extractWireNames(resourceMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(resourceMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    // Filter MCP prompts
+    for (const name of Object.keys(filteredState.mcpEndpoints.promptsMeta)) {
+        const promptMeta = filteredState.mcpEndpoints.promptsMeta[name];
+        const matches = matchesFilters(filters, {
+            type: 'mcp',
+            name,
+            tags: promptMeta.tags,
+        }, logger);
+        if (!matches) {
+            delete filteredState.mcpEndpoints.promptsMeta[name];
+        }
+        else {
+            if (promptMeta.pikkuFuncName) {
+                filteredState.serviceAggregation.usedFunctions.add(promptMeta.pikkuFuncName);
+            }
+            extractWireNames(promptMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+            extractWireNames(promptMeta.permissions).forEach((name) => filteredState.serviceAggregation.usedPermissions.add(name));
+        }
+    }
+    // Repopulate mcpEndpoints.files if any MCP endpoints remain
+    const hasMcpEndpoints = Object.keys(filteredState.mcpEndpoints.toolsMeta).length > 0 ||
+        Object.keys(filteredState.mcpEndpoints.resourcesMeta).length > 0 ||
+        Object.keys(filteredState.mcpEndpoints.promptsMeta).length > 0;
+    if (hasMcpEndpoints) {
+        filteredState.mcpEndpoints.files = new Set(state.mcpEndpoints.files);
+    }
+    // Filter CLI programs (note: CLI filtering might be more complex with nested commands)
+    const referencedRenderers = new Set();
+    for (const programName of Object.keys(filteredState.cli.meta.programs)) {
+        const programMeta = filteredState.cli.meta.programs[programName];
+        // Filter commands in the program
+        for (const commandName of Object.keys(programMeta.commands)) {
+            const commandMeta = programMeta.commands[commandName];
+            const matches = matchesFilters(filters, {
+                type: 'cli',
+                name: commandName,
+                tags: commandMeta.tags,
+            }, logger);
+            if (!matches) {
+                delete programMeta.commands[commandName];
+            }
+            else {
+                if (commandMeta.pikkuFuncName) {
+                    filteredState.serviceAggregation.usedFunctions.add(commandMeta.pikkuFuncName);
+                }
+                extractWireNames(commandMeta.middleware).forEach((name) => filteredState.serviceAggregation.usedMiddleware.add(name));
+                // Track referenced renderers
+                if (commandMeta.defaultRenderName) {
+                    referencedRenderers.add(commandMeta.defaultRenderName);
+                }
+            }
+        }
+        // Remove program if it has no commands left
+        if (Object.keys(programMeta.commands).length === 0) {
+            delete filteredState.cli.meta.programs[programName];
+        }
+    }
+    // Filter out renderers that aren't referenced by any remaining commands
+    for (const rendererName of Object.keys(filteredState.cli.meta.renderers || {})) {
+        if (!referencedRenderers.has(rendererName)) {
+            delete filteredState.cli.meta.renderers[rendererName];
+        }
+    }
+    // Repopulate cli.files if any CLI programs or referenced renderers remain
+    const hasCliPrograms = Object.keys(filteredState.cli.meta.programs).length > 0;
+    const hasCliRenderers = Object.keys(filteredState.cli.meta.renderers || {}).length > 0;
+    if (hasCliPrograms || hasCliRenderers) {
+        filteredState.cli.files = new Set(state.cli.files);
+    }
+    // Recalculate requiredServices based on filtered functions/middleware/permissions
+    // Need to cast to InspectorState temporarily for aggregateRequiredServices
+    const stateForAggregation = filteredState;
+    aggregateRequiredServices(stateForAggregation);
+    return filteredState;
+}

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

@@ -1,9 +1,19 @@
 import { InspectorFilters, InspectorLogger } from '../types.js';
 import { PikkuWiringTypes } from '@pikku/core';
+/**
+ * Match a value against a pattern with wildcard support
+ * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")
+ * @param value - The value to check
+ * @param pattern - The pattern with optional "*" wildcard(s)
+ */
+export declare function matchesWildcard(value: string, pattern: string): boolean;
 export declare const matchesFilters: (filters: InspectorFilters, params: {
     tags?: string[];
+    name?: string;
 }, meta: {
     type: PikkuWiringTypes;
     name: string;
     filePath?: string;
+    httpRoute?: string;
+    httpMethod?: string;
 }, logger: InspectorLogger) => boolean;

package/dist/utils/filter-utils.js

@@ -1,12 +1,49 @@
+/**
+ * Match a value against a pattern with wildcard support
+ * Supports "*" at the beginning, end, or both (e.g., "send*", "*Payment", "*process*")
+ * @param value - The value to check
+ * @param pattern - The pattern with optional "*" wildcard(s)
+ */
+export function matchesWildcard(value, pattern) {
+    // If pattern is just '*', match everything
+    if (pattern === '*') {
+        return true;
+    }
+    const startsWithWildcard = pattern.startsWith('*');
+    const endsWithWildcard = pattern.endsWith('*');
+    if (startsWithWildcard && endsWithWildcard) {
+        // Pattern like "*middle*" - check if value contains the middle part
+        const middle = pattern.slice(1, -1);
+        if (middle === '') {
+            return true; // Pattern is "**", match everything
+        }
+        return value.includes(middle);
+    }
+    else if (startsWithWildcard) {
+        // Pattern like "*suffix" - check if value ends with suffix and has content before
+        const suffix = pattern.slice(1);
+        return value.endsWith(suffix) && value.length > suffix.length;
+    }
+    else if (endsWithWildcard) {
+        // Pattern like "prefix*" - check if value starts with prefix and has content after
+        const prefix = pattern.slice(0, -1);
+        return value.startsWith(prefix) && value.length > prefix.length;
+    }
+    // No wildcard, exact match
+    return value === pattern;
+}
 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) &&
+    if ((!filters.names || filters.names.length === 0) &&
+        (!filters.tags || filters.tags.length === 0) &&
         (!filters.types || filters.types.length === 0) &&
-        (!filters.directories || filters.directories.length === 0)) {
+        (!filters.directories || filters.directories.length === 0) &&
+        (!filters.httpRoutes || filters.httpRoutes.length === 0) &&
+        (!filters.httpMethods || filters.httpMethods.length === 0)) {
         return true;
     }
     // Check type filter
@@ -41,5 +78,32 @@ export const matchesFilters = (filters, params, meta, logger) => {
             return false;
         }
     }
+    // Check name filter (with wildcard support)
+    if (filters.names && filters.names.length > 0) {
+        const nameToMatch = params.name || meta.name;
+        const nameMatches = filters.names.some((pattern) => matchesWildcard(nameToMatch, pattern));
+        if (!nameMatches) {
+            logger.debug(`⒡ Filtered by name: ${meta.type}:${meta.name}`);
+            return false;
+        }
+    }
+    // Check HTTP route filter (with wildcard support)
+    if (filters.httpRoutes && filters.httpRoutes.length > 0 && meta.httpRoute) {
+        const routeMatches = filters.httpRoutes.some((pattern) => matchesWildcard(meta.httpRoute, pattern));
+        if (!routeMatches) {
+            logger.debug(`⒡ Filtered by HTTP route: ${meta.httpRoute}`);
+            return false;
+        }
+    }
+    // Check HTTP method filter
+    if (filters.httpMethods &&
+        filters.httpMethods.length > 0 &&
+        meta.httpMethod) {
+        const normalizedMethod = meta.httpMethod.toUpperCase();
+        if (!filters.httpMethods.includes(normalizedMethod)) {
+            logger.debug(`⒡ Filtered by HTTP method: ${meta.httpMethod}`);
+            return false;
+        }
+    }
     return true;
 };

package/dist/utils/find-root-dir.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Finds the common ancestor directory of all the given file paths.
+ * This is used to determine the project root directory.
+ *
+ * @param filePaths - Array of absolute file paths
+ * @returns The common ancestor directory path
+ *
+ * @example
+ * findCommonAncestor([
+ *   '/Users/yasser/git/pikku/pikku/src/functions/a.ts',
+ *   '/Users/yasser/git/pikku/pikku/src/routes/b.ts'
+ * ])
+ * // Returns: '/Users/yasser/git/pikku/pikku'
+ */
+export declare function findCommonAncestor(filePaths: string[]): string;
+/**
+ * Converts an absolute file path to a relative path from the root directory.
+ *
+ * @param absolutePath - The absolute file path
+ * @param rootDir - The root directory to make the path relative to
+ * @returns A relative path from rootDir to the file
+ */
+export declare function toRelativePath(absolutePath: string, rootDir: string): string;