@pikku/inspector 0.9.6-next.0 → 0.10.0

package/dist/add/add-permission.js

@@ -1,36 +1,292 @@
 import * as ts from 'typescript';
-import { extractFunctionName } from '../utils/extract-function-name.js';
+import { extractFunctionName, isNamedExport, } from '../utils/extract-function-name.js';
 import { extractServicesFromFunction } from '../utils/extract-services.js';
+import { extractPermissionPikkuNames } from '../utils/permissions.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 /**
- * Inspect pikkuPermission calls and extract first-arg destructuring
- * for tree shaking optimization.
+ * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
  */
 export const addPermission = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args } = node;
-    // only handle calls like pikkuPermission(...)
+    // only handle specific function calls
     if (!ts.isIdentifier(expression)) {
         return;
     }
-    if (expression.text !== 'pikkuPermission') {
+    // Handle pikkuPermission(...) - individual permission function definition
+    if (expression.text === 'pikkuPermission') {
+        const arg = args[0];
+        if (!arg)
+            return;
+        let actualHandler;
+        let name;
+        let description;
+        // Check if using object syntax: pikkuPermission({ func: ..., name: '...', description: '...' })
+        if (ts.isObjectLiteralExpression(arg)) {
+            // Extract name and description metadata
+            const nameValue = getPropertyValue(arg, 'name');
+            const descValue = getPropertyValue(arg, 'description');
+            name = typeof nameValue === 'string' ? nameValue : undefined;
+            description = typeof descValue === 'string' ? descValue : undefined;
+            // Extract the func property
+            const fnProp = getPropertyAssignmentInitializer(arg, 'func', true, checker);
+            if (!fnProp ||
+                (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
+                logger.error(`• pikkuPermission object missing required 'func' property.`);
+                return;
+            }
+            actualHandler = fnProp;
+        }
+        else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            actualHandler = arg;
+        }
+        else {
+            logger.error(`• Handler for pikkuPermission is not a function.`);
+            return;
+        }
+        const services = extractServicesFromFunction(actualHandler);
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        state.permissions.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            name,
+            description,
+        };
+        logger.debug(`• Found permission with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
-    const handlerNode = args[0];
-    if (!handlerNode)
+    // Handle pikkuPermissionFactory(...) - permission factory function
+    if (expression.text === 'pikkuPermissionFactory') {
+        const factoryNode = args[0];
+        if (!factoryNode)
+            return;
+        if (!ts.isArrowFunction(factoryNode) &&
+            !ts.isFunctionExpression(factoryNode)) {
+            logger.error(`• Handler for pikkuPermissionFactory is not a function.`);
+            return;
+        }
+        // Extract services by looking inside the factory function body
+        // The factory should return pikkuPermission(...), so we need to find that call
+        // If no wrapper is found, extract from the factory's returned function directly
+        let services = { optimized: false, services: [] };
+        const findPikkuPermissionCall = (node) => {
+            if (ts.isCallExpression(node)) {
+                const expr = node.expression;
+                if (ts.isIdentifier(expr) && expr.text === 'pikkuPermission') {
+                    return node;
+                }
+            }
+            return ts.forEachChild(node, findPikkuPermissionCall);
+        };
+        const pikkuPermissionCall = findPikkuPermissionCall(factoryNode);
+        if (pikkuPermissionCall && pikkuPermissionCall.arguments[0]) {
+            const permissionHandler = pikkuPermissionCall.arguments[0];
+            if (ts.isArrowFunction(permissionHandler) ||
+                ts.isFunctionExpression(permissionHandler)) {
+                services = extractServicesFromFunction(permissionHandler);
+            }
+        }
+        else {
+            // No pikkuPermission wrapper found - extract from factory's return value directly
+            // Factory pattern: (config) => (services, data, session) => { ... }
+            if (ts.isArrowFunction(factoryNode) ||
+                ts.isFunctionExpression(factoryNode)) {
+                const factoryBody = factoryNode.body;
+                // Check if the body is an arrow function (direct return)
+                if (ts.isArrowFunction(factoryBody) ||
+                    ts.isFunctionExpression(factoryBody)) {
+                    services = extractServicesFromFunction(factoryBody);
+                }
+            }
+        }
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+        state.permissions.meta[pikkuFuncName] = {
+            services,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            exportedName,
+            factory: true,
+        };
+        logger.debug(`• Found permission factory with services: ${services.services.join(', ')}`);
         return;
-    if (!ts.isArrowFunction(handlerNode) &&
-        !ts.isFunctionExpression(handlerNode)) {
-        logger.error(`• Handler for pikkuPermission is not a function.`);
+    }
+    // Handle addPermission('tag', [permission1, permission2])
+    // Supports two patterns:
+    // 1. export const x = () => addPermission('tag', [...])  (factory - tree-shakeable)
+    // 2. export const x = addPermission('tag', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addPermission') {
+        const tagArg = args[0];
+        const permissionsArrayArg = args[1];
+        if (!tagArg || !permissionsArrayArg)
+            return;
+        // Extract tag name
+        let tag;
+        if (ts.isStringLiteral(tagArg)) {
+            tag = tagArg.text;
+        }
+        if (!tag) {
+            logger.warn(`• addPermission call without valid tag string`);
+            return;
+        }
+        // Check if permissions is a literal array or object
+        if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
+            !ts.isObjectLiteralExpression(permissionsArrayArg)) {
+            logger.error(`• addPermission('${tag}', ...) must have a literal array or object as second argument`);
+            return;
+        }
+        // Extract permission pikkuFuncNames from array
+        const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
+        if (permissionNames.length === 0) {
+            logger.warn(`• addPermission('${tag}', ...) has empty permissions array`);
+            return;
+        }
+        // Collect services from all permissions in the group
+        const allServices = new Set();
+        for (const permissionName of permissionNames) {
+            const permissionMeta = state.permissions.meta[permissionName];
+            if (permissionMeta && permissionMeta.services) {
+                for (const service of permissionMeta.services.services) {
+                    allServices.add(service);
+                }
+            }
+        }
+        // Check if this call is wrapped in a factory function
+        // We need to walk up the tree to see if the parent is: const x = () => addPermission(...)
+        let isFactory = false;
+        let exportedName = null;
+        let parent = node.parent;
+        // Check if parent is arrow function: () => addPermission(...)
+        if (parent && ts.isArrowFunction(parent)) {
+            // Check if arrow function has no parameters
+            if (parent.parameters.length === 0) {
+                isFactory = true;
+                // For factories, we need to check the arrow function's parent for the export name
+                // const apiTagPermissions = () => addPermission(...)
+                const arrowParent = parent.parent;
+                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+                    if (ts.isIdentifier(arrowParent.name)) {
+                        // Check if it's exported
+                        if (isNamedExport(arrowParent)) {
+                            exportedName = arrowParent.name.text;
+                        }
+                    }
+                }
+            }
+        }
+        // If not a factory, get export name from the call expression itself
+        if (!isFactory) {
+            const extracted = extractFunctionName(node, checker, state.rootDir);
+            exportedName = extracted.exportedName;
+        }
+        // Log warning if not using factory pattern
+        if (!isFactory && exportedName) {
+            logger.warn(`• Permission group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addPermission('${tag}', [...])`);
+        }
+        // Store group metadata
+        state.permissions.tagPermissions.set(tag, {
+            exportName: exportedName,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            permissionCount: permissionNames.length,
+            isFactory,
+        });
+        logger.debug(`• Found tag permission group: ${tag} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
+        return;
+    }
+    // Handle addHTTPPermission(pattern, [permission1, permission2])
+    // Supports two patterns:
+    // 1. export const x = () => addHTTPPermission('*', [...])  (factory - tree-shakeable)
+    // 2. export const x = addHTTPPermission('*', [...])  (direct - no tree-shaking)
+    if (expression.text === 'addHTTPPermission') {
+        const patternArg = args[0];
+        const permissionsArrayArg = args[1];
+        if (!patternArg || !permissionsArrayArg)
+            return;
+        // Extract route pattern
+        let pattern;
+        if (ts.isStringLiteral(patternArg)) {
+            pattern = patternArg.text;
+        }
+        if (!pattern) {
+            logger.warn(`• addHTTPPermission call without valid pattern string`);
+            return;
+        }
+        // Check if permissions is a literal array or object
+        if (!ts.isArrayLiteralExpression(permissionsArrayArg) &&
+            !ts.isObjectLiteralExpression(permissionsArrayArg)) {
+            logger.error(`• addHTTPPermission('${pattern}', ...) must have a literal array or object as second argument`);
+            return;
+        }
+        // Extract permission pikkuFuncNames from array
+        const permissionNames = extractPermissionPikkuNames(permissionsArrayArg, checker, state.rootDir);
+        if (permissionNames.length === 0) {
+            logger.warn(`• addHTTPPermission('${pattern}', ...) has empty permissions array`);
+            return;
+        }
+        // Collect services from all permissions in the group
+        const allServices = new Set();
+        for (const permissionName of permissionNames) {
+            const permissionMeta = state.permissions.meta[permissionName];
+            if (permissionMeta && permissionMeta.services) {
+                for (const service of permissionMeta.services.services) {
+                    allServices.add(service);
+                }
+            }
+        }
+        // Check if this call is wrapped in a factory function
+        let isFactory = false;
+        let exportedName = null;
+        let parent = node.parent;
+        // Check if parent is arrow function: () => addHTTPPermission(...)
+        if (parent && ts.isArrowFunction(parent)) {
+            // Check if arrow function has no parameters
+            if (parent.parameters.length === 0) {
+                isFactory = true;
+                // For factories, we need to check the arrow function's parent for the export name
+                // const apiRoutePermissions = () => addHTTPPermission(...)
+                const arrowParent = parent.parent;
+                if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
+                    if (ts.isIdentifier(arrowParent.name)) {
+                        // Check if it's exported
+                        if (isNamedExport(arrowParent)) {
+                            exportedName = arrowParent.name.text;
+                        }
+                    }
+                }
+            }
+        }
+        // If not a factory, get export name from the call expression itself
+        if (!isFactory) {
+            const extracted = extractFunctionName(node, checker, state.rootDir);
+            exportedName = extracted.exportedName;
+        }
+        // Log warning if not using factory pattern
+        if (!isFactory && exportedName) {
+            logger.warn(`• HTTP permission group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
+                `For tree-shaking, use: export const ${exportedName} = () => addHTTPPermission('${pattern}', [...])`);
+        }
+        // Store group metadata
+        state.http.routePermissions.set(pattern, {
+            exportName: exportedName,
+            sourceFile: node.getSourceFile().fileName,
+            position: node.getStart(),
+            services: {
+                optimized: false,
+                services: Array.from(allServices),
+            },
+            permissionCount: permissionNames.length,
+            isFactory,
+        });
+        logger.debug(`• Found HTTP route permission group: ${pattern} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`);
         return;
     }
-    const services = extractServicesFromFunction(handlerNode);
-    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
-    state.permissions.meta[pikkuFuncName] = {
-        services,
-        sourceFile: node.getSourceFile().fileName,
-        position: node.getStart(),
-        exportedName,
-    };
-    logger.debug(`• Found permission with services: ${services.services.join(', ')}`);
 };

package/dist/add/add-queue-worker.js

@@ -1,10 +1,10 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ErrorCode } from '../error-codes.js';
 export const addQueueWorker = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -23,25 +23,23 @@ export const addQueueWorker = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const queueName = getPropertyValue(obj, 'queueName');
         const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'Queue worker', queueName, logger);
         // --- find the referenced function ---
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for queue processor '${queueName}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for queue processor '${queueName}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
         if (!queueName) {
-            console.error(`• No 'queueName' provided for queue processor function '${pikkuFuncName}'.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.queue, name: queueName, filePath }, logger)) {
-            console.info(`• Skipping queue processor '${pikkuFuncName}' for queue '${queueName}' due to filter mismatch.`);
+            logger.critical(ErrorCode.MISSING_QUEUE_NAME, `No 'queueName' provided for queue processor function '${pikkuFuncName}'.`);
             return;
         }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- track used functions/middleware for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
         state.queueWorkers.files.add(node.getSourceFile().fileName);
         state.queueWorkers.meta[queueName] = {
             pikkuFuncName,

package/dist/add/add-schedule.js

@@ -1,10 +1,10 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
-import { PikkuWiringTypes } from '@pikku/core';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ErrorCode } from '../error-codes.js';
 export const addSchedule = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -24,22 +24,21 @@ export const addSchedule = (logger, node, checker, state, options) => {
         const nameValue = getPropertyValue(obj, 'name');
         const scheduleValue = getPropertyValue(obj, 'schedule');
         const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'Scheduler', nameValue, logger);
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for scheduled task '${nameValue}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for scheduled task '${nameValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
         if (!nameValue || !scheduleValue) {
             return;
         }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.scheduler, name: nameValue, filePath }, logger)) {
-            return;
-        }
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- track used functions/middleware for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
         state.scheduledTasks.files.add(node.getSourceFile().fileName);
         state.scheduledTasks.meta[nameValue] = {
             pikkuFuncName,

package/dist/error-codes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Error code system for Pikku CLI and Inspector
+ *
+ * Each error has a unique code and links to documentation at pikku.dev
+ *
+ * Error codes use random 3-digit numbers to avoid implying a sequential order.
+ * Each code links to detailed documentation and troubleshooting steps.
+ */
+export declare enum ErrorCode {
+    MISSING_NAME = "PKU111",
+    MISSING_DESCRIPTION = "PKU123",
+    MISSING_URI = "PKU220",
+    MISSING_FUNC = "PKU236",
+    INVALID_TAGS_TYPE = "PKU247",
+    INVALID_HANDLER = "PKU300",
+    MISSING_TITLE = "PKU370",
+    MISSING_QUEUE_NAME = "PKU384",
+    MISSING_CHANNEL_NAME = "PKU400",
+    CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = "PKU672",
+    CONFIG_TYPE_NOT_FOUND = "PKU426",
+    CONFIG_TYPE_UNDEFINED = "PKU427",
+    SCHEMA_NO_ROOT = "PKU431",
+    SCHEMA_GENERATION_ERROR = "PKU456",
+    SCHEMA_LOAD_ERROR = "PKU488",
+    FUNCTION_METADATA_NOT_FOUND = "PKU559",
+    HANDLER_NOT_RESOLVED = "PKU568",
+    MIDDLEWARE_HANDLER_INVALID = "PKU685",
+    MIDDLEWARE_TAG_INVALID = "PKU715",
+    MIDDLEWARE_EMPTY_ARRAY = "PKU736",
+    MIDDLEWARE_PATTERN_INVALID = "PKU787",
+    PERMISSION_HANDLER_INVALID = "PKU835",
+    PERMISSION_TAG_INVALID = "PKU836",
+    PERMISSION_EMPTY_ARRAY = "PKU937",
+    PERMISSION_PATTERN_INVALID = "PKU975"
+}

package/dist/error-codes.js

@@ -0,0 +1,40 @@
+/**
+ * Error code system for Pikku CLI and Inspector
+ *
+ * Each error has a unique code and links to documentation at pikku.dev
+ *
+ * Error codes use random 3-digit numbers to avoid implying a sequential order.
+ * Each code links to detailed documentation and troubleshooting steps.
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // Validation errors
+    ErrorCode["MISSING_NAME"] = "PKU111";
+    ErrorCode["MISSING_DESCRIPTION"] = "PKU123";
+    ErrorCode["MISSING_URI"] = "PKU220";
+    ErrorCode["MISSING_FUNC"] = "PKU236";
+    ErrorCode["INVALID_TAGS_TYPE"] = "PKU247";
+    ErrorCode["INVALID_HANDLER"] = "PKU300";
+    ErrorCode["MISSING_TITLE"] = "PKU370";
+    ErrorCode["MISSING_QUEUE_NAME"] = "PKU384";
+    ErrorCode["MISSING_CHANNEL_NAME"] = "PKU400";
+    ErrorCode["CLI_CLIENTSIDE_RENDERER_HAS_SERVICES"] = "PKU672";
+    // Configuration errors
+    ErrorCode["CONFIG_TYPE_NOT_FOUND"] = "PKU426";
+    ErrorCode["CONFIG_TYPE_UNDEFINED"] = "PKU427";
+    ErrorCode["SCHEMA_NO_ROOT"] = "PKU431";
+    ErrorCode["SCHEMA_GENERATION_ERROR"] = "PKU456";
+    ErrorCode["SCHEMA_LOAD_ERROR"] = "PKU488";
+    // Function errors
+    ErrorCode["FUNCTION_METADATA_NOT_FOUND"] = "PKU559";
+    ErrorCode["HANDLER_NOT_RESOLVED"] = "PKU568";
+    // Middleware/Permission errors
+    ErrorCode["MIDDLEWARE_HANDLER_INVALID"] = "PKU685";
+    ErrorCode["MIDDLEWARE_TAG_INVALID"] = "PKU715";
+    ErrorCode["MIDDLEWARE_EMPTY_ARRAY"] = "PKU736";
+    ErrorCode["MIDDLEWARE_PATTERN_INVALID"] = "PKU787";
+    ErrorCode["PERMISSION_HANDLER_INVALID"] = "PKU835";
+    ErrorCode["PERMISSION_TAG_INVALID"] = "PKU836";
+    ErrorCode["PERMISSION_EMPTY_ARRAY"] = "PKU937";
+    ErrorCode["PERMISSION_PATTERN_INVALID"] = "PKU975";
+})(ErrorCode || (ErrorCode = {}));

package/dist/index.d.ts

@@ -4,3 +4,7 @@ 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';
+export { ErrorCode } from './error-codes.js';
+export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
+export type { SerializableInspectorState } from './utils/serialize-inspector-state.js';
+export { filterInspectorState } from './utils/filter-inspector-state.js';

package/dist/index.js

@@ -1,2 +1,5 @@
 export { inspect } from './inspector.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
+export { ErrorCode } from './error-codes.js';
+export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
+export { filterInspectorState } from './utils/filter-inspector-state.js';

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>;
+    };
 }