@pikku/inspector 0.9.6-next.0 → 0.10.1

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;

package/dist/utils/find-root-dir.js

@@ -0,0 +1,55 @@
+import path from 'path';
+/**
+ * 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 function findCommonAncestor(filePaths) {
+    if (filePaths.length === 0) {
+        return process.cwd();
+    }
+    if (filePaths.length === 1) {
+        return path.dirname(filePaths[0]);
+    }
+    // Normalize all paths and get their directory parts
+    const normalizedPaths = filePaths.map((p) => path.dirname(path.normalize(p)).split(path.sep));
+    // Start with the first path's parts
+    const firstPath = normalizedPaths[0];
+    let commonParts = [];
+    // Check each part of the first path
+    for (let i = 0; i < firstPath.length; i++) {
+        const part = firstPath[i];
+        // Check if this part exists in all other paths at the same position
+        const existsInAll = normalizedPaths.every((pathParts) => pathParts[i] === part);
+        if (existsInAll) {
+            commonParts.push(part);
+        }
+        else {
+            break;
+        }
+    }
+    // If no common parts, return root
+    if (commonParts.length === 0) {
+        return path.sep;
+    }
+    return commonParts.join(path.sep);
+}
+/**
+ * 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 function toRelativePath(absolutePath, rootDir) {
+    return path.relative(rootDir, absolutePath);
+}

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

@@ -9,12 +9,13 @@ export type FilesAndMethods = {
     userSessionType: Meta;
     sessionServicesType: Meta;
     singletonServicesType: Meta;
+    pikkuConfigType: 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"]) => {
+export declare const getFilesAndMethods: ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, }?: InspectorOptions["types"]) => {
     result: Partial<FilesAndMethods>;
     errors: FilesAndMethodsErrors;
 };

package/dist/utils/get-files-and-methods.js

@@ -19,9 +19,9 @@ const getMetaTypes = (type, map, desiredType, errors) => {
     if (totalValues.length === 0) {
         const helpMessage = type === 'CoreConfig'
             ? `No ${type} found. Make sure you have exported a createConfig function in your codebase:\n\n` +
-                `export const createConfig: CreateConfig<Config> = async () => {\n` +
+                `export const createConfig = pikkuConfig(async () => {\n` +
                 `  return {}\n` +
-                `}\n\n` +
+                `})\n\n` +
                 `Possible issues:\n` +
                 `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
             : `No ${type} found`;
@@ -46,12 +46,13 @@ const getMetaTypes = (type, map, desiredType, errors) => {
     }
     return;
 };
-export const getFilesAndMethods = ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = {}) => {
+export const getFilesAndMethods = ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, configTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = {}) => {
     const errors = new Map();
     const result = {
         userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType, errors),
         singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap, undefined, errors),
         sessionServicesType: getMetaTypes('CoreServices', sessionServicesTypeImportMap, undefined, errors),
+        pikkuConfigType: getMetaTypes('CoreConfig', configTypeImportMap, undefined, errors),
         pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType, errors),
         singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType, errors),
         sessionServicesFactory: getMetaTypes('CreateSessionServices', sessionServicesFactories, sessionServicesFactoryType, errors),

package/dist/utils/get-property-value.d.ts

@@ -1,3 +1,12 @@
 import { PikkuDocs } from '@pikku/core';
 import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
 export declare const getPropertyValue: (obj: ts.ObjectLiteralExpression, propertyName: string) => string | string[] | null | PikkuDocs | boolean;
+/**
+ * Gets the 'tags' property from an object and validates it's an array.
+ * Logs a critical error if tags is not an array but still returns the value.
+ * @param logger - Optional logger instance; if not provided, uses console.error
+ */
+export declare const getPropertyTags: (obj: ts.ObjectLiteralExpression, wiringType: string, wiringName: string | null, logger?: {
+    critical: (code: ErrorCode, message: string) => void;
+}) => string[] | undefined;

package/dist/utils/get-property-value.js

@@ -1,4 +1,5 @@
 import * as ts from 'typescript';
+import { ErrorCode } from '../error-codes.js';
 export const getPropertyValue = (obj, propertyName) => {
     const property = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
         ts.isIdentifier(p.name) &&
@@ -64,3 +65,22 @@ export const getPropertyValue = (obj, propertyName) => {
     }
     return null;
 };
+/**
+ * Gets the 'tags' property from an object and validates it's an array.
+ * Logs a critical error if tags is not an array but still returns the value.
+ * @param logger - Optional logger instance; if not provided, uses console.error
+ */
+export const getPropertyTags = (obj, wiringType, wiringName, logger) => {
+    const tagsValue = getPropertyValue(obj, 'tags');
+    if (tagsValue !== null && !Array.isArray(tagsValue)) {
+        const errorMsg = `${wiringType} '${wiringName}' has invalid 'tags' property - must be an array of strings.`;
+        if (logger) {
+            logger.critical(ErrorCode.INVALID_TAGS_TYPE, errorMsg);
+        }
+        else {
+            console.error(errorMsg);
+        }
+        // Return undefined but don't stop processing - error will be caught by the exit handler
+    }
+    return Array.isArray(tagsValue) ? tagsValue : undefined;
+};

package/dist/utils/middleware.d.ts

@@ -6,7 +6,7 @@ import { InspectorState } from '../types.js';
  * Resolves each identifier to its pikkuFuncName using extractFunctionName
  * Also handles call expressions (like logCommandInfoAndTime({...}))
  */
-export declare function extractMiddlewarePikkuNames(arrayNode: ts.Expression, checker: ts.TypeChecker): string[];
+export declare function extractMiddlewarePikkuNames(arrayNode: ts.Expression, checker: ts.TypeChecker, rootDir: string): string[];
 /**
  * Get middleware array from an object literal expression property
  * Returns the initializer node for the 'middleware' property if it exists