@pikku/inspector 0.9.6-next.0 → 0.10.0

package/dist/add/add-functions.js

@@ -16,7 +16,7 @@ const nullifyTypes = (type) => {
     }
     return type;
 };
-const resolveTypeImports = (type, resolvedTypes, isCustom) => {
+const resolveTypeImports = (type, resolvedTypes, isCustom, checker) => {
     const types = [];
     const visitType = (currentType) => {
         const symbol = currentType.aliasSymbol || currentType.getSymbol();
@@ -27,9 +27,12 @@ const resolveTypeImports = (type, resolvedTypes, isCustom) => {
                 const sourceFile = declaration.getSourceFile();
                 const path = sourceFile.fileName;
                 // Skip built-in utility types or TypeScript lib types
+                // Skip enum members (but not the enum type itself)
+                const isEnumMember = declaration && ts.isEnumMember(declaration);
                 if (!path.includes('node_modules/typescript') &&
                     symbol.getName() !== '__type' &&
-                    !isPrimitiveType(currentType)) {
+                    !isPrimitiveType(currentType) &&
+                    !isEnumMember) {
                     const originalName = symbol.getName();
                     // Check if the type is already in the map
                     let uniqueName = resolvedTypes.exists(originalName, path);
@@ -76,6 +79,26 @@ const resolveTypeImports = (type, resolvedTypes, isCustom) => {
             const typeRef = currentType;
             typeRef.typeArguments?.forEach(visitType);
         }
+        // Handle anonymous object types with enum properties (e.g., { userType: UserType })
+        // Only traverse into enum property types to avoid over-importing other named types
+        if (currentType.flags & ts.TypeFlags.Object) {
+            const objectType = currentType;
+            const typeSymbol = objectType.getSymbol();
+            // Only traverse properties for anonymous object types (no symbol or __type symbol)
+            // Skip named types, interfaces, and enums to avoid over-importing
+            const isAnonymousObject = !typeSymbol || typeSymbol.getName() === '__type';
+            if (isAnonymousObject) {
+                const properties = objectType.getProperties();
+                for (const prop of properties) {
+                    if (prop.valueDeclaration) {
+                        const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+                        if (propType) {
+                            visitType(propType);
+                        }
+                    }
+                }
+            }
+        }
     };
     visitType(type);
     return types;
@@ -125,7 +148,7 @@ const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
         const aliasName = funcName.charAt(0).toUpperCase() + funcName.slice(1) + direction;
         // record the alias in your TypesMap
         const references = rawTypes
-            .map((t) => resolveTypeImports(t, typesMap, true))
+            .map((t) => resolveTypeImports(t, typesMap, true, checker))
             .flat();
         typesMap.addCustomType(aliasName, aliasType, references);
         return {
@@ -144,7 +167,7 @@ const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
             return name;
         }
         // non-primitive: import/alias it inline
-        return resolveTypeImports(t, typesMap, false);
+        return resolveTypeImports(t, typesMap, false, checker);
     })
         .flat();
     return {
@@ -207,7 +230,7 @@ export const addFunctions = (logger, node, checker, state) => {
     }
     if (args.length === 0)
         return;
-    const { pikkuFuncName, name, explicitName, exportedName } = extractFunctionName(node, checker);
+    const { pikkuFuncName, name, explicitName, exportedName } = extractFunctionName(node, checker, state.rootDir);
     let tags;
     let expose;
     let docs;
@@ -226,6 +249,17 @@ export const addFunctions = (logger, node, checker, state) => {
         if (!fnProp ||
             (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
             logger.error(`• No valid 'func' property found for ${pikkuFuncName}.`);
+            // Create stub metadata to prevent "function not found" errors in wirings
+            state.functions.meta[pikkuFuncName] = {
+                pikkuFuncName,
+                name,
+                services: { optimized: false, services: [] },
+                inputSchemaName: null,
+                outputSchemaName: null,
+                inputs: [],
+                outputs: [],
+                middleware: undefined,
+            };
             return;
         }
         handlerNode = fnProp;
@@ -233,6 +267,17 @@ export const addFunctions = (logger, node, checker, state) => {
     if (!ts.isArrowFunction(handlerNode) &&
         !ts.isFunctionExpression(handlerNode)) {
         logger.error(`• Handler for ${name} is not a function.`);
+        // Create stub metadata to prevent "function not found" errors in wirings
+        state.functions.meta[pikkuFuncName] = {
+            pikkuFuncName,
+            name,
+            services: { optimized: false, services: [] },
+            inputSchemaName: null,
+            outputSchemaName: null,
+            inputs: [],
+            outputs: [],
+            middleware: undefined,
+        };
         return;
     }
     const services = {
@@ -324,6 +369,8 @@ export const addFunctions = (logger, node, checker, state) => {
                 path: node.getSourceFile().fileName,
                 exportedName,
             });
+            // Track exposed RPC function for service aggregation
+            state.serviceAggregation.usedFunctions.add(pikkuFuncName);
         }
         // We add it to internal meta to allow autocomplete for everything
         state.rpc.internalMeta[name] = pikkuFuncName;

package/dist/add/add-http-route.js

@@ -1,11 +1,13 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { PikkuWiringTypes } from '@pikku/core';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { matchesFilters } from '../utils/filter-utils.js';
 import { resolveHTTPMiddlewareFromObject } from '../utils/middleware.js';
+import { resolveHTTPPermissionsFromObject } from '../utils/permissions.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js';
+import { ErrorCode } from '../error-codes.js';
 /**
  * Populate metaInputTypes for a given route based on method, input type,
  * query and params. Returns undefined (we only mutate metaTypes).
@@ -46,23 +48,21 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
     const params = keys.filter((k) => k.type === 'param').map((k) => k.name);
     const method = getPropertyValue(obj, 'method')?.toLowerCase() || 'get';
     const docs = getPropertyValue(obj, 'docs') || undefined;
-    const tags = getPropertyValue(obj, 'tags') || undefined;
+    const tags = getPropertyTags(obj, 'HTTP route', route, logger);
     const query = getPropertyValue(obj, 'query') || [];
-    const filePath = node.getSourceFile().fileName;
-    if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.http, name: route, filePath }, logger)) {
-        return;
-    }
-    // --- find the referenced function ---
+    // --- find the referenced function name first for filtering ---
     const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
     if (!funcInitializer) {
-        console.error(`• No valid 'func' property for route '${route}'.`);
+        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for route '${route}'.`);
         return;
     }
-    const funcName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+    const funcName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+    // Ensure function metadata exists (creates stub for inline functions)
+    ensureFunctionMetadata(state, funcName, route);
     // lookup existing function metadata
     const fnMeta = state.functions.meta[funcName];
     if (!fnMeta) {
-        console.error(`• No function metadata found for '${funcName}'.`);
+        logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${funcName}'.`);
         return;
     }
     const input = fnMeta.inputs?.[0] || null;
@@ -70,6 +70,12 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
     const inputTypes = getInputTypes(state.http.metaInputTypes, method, input, query, params);
     // --- resolve middleware ---
     const middleware = resolveHTTPMiddlewareFromObject(state, route, obj, tags, checker);
+    // --- resolve permissions ---
+    const permissions = resolveHTTPPermissionsFromObject(state, route, obj, tags, checker);
+    // --- track used functions/middleware/permissions for service aggregation ---
+    state.serviceAggregation.usedFunctions.add(funcName);
+    extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+    extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
     // --- record route ---
     state.http.files.add(node.getSourceFile().fileName);
     state.http.meta[method][route] = {
@@ -82,5 +88,6 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
         docs,
         tags,
         middleware,
+        permissions,
     };
 };

package/dist/add/add-mcp-prompt.js

@@ -1,10 +1,12 @@
 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 { extractWireNames } from '../utils/post-process.js';
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.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 { resolvePermissions } from '../utils/permissions.js';
+import { ErrorCode } from '../error-codes.js';
 export const addMCPPrompt = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -23,35 +25,39 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const nameValue = getPropertyValue(obj, 'name');
         const descriptionValue = getPropertyValue(obj, 'description');
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'MCP prompt', nameValue, logger);
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for MCP prompt '${nameValue}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP prompt '${nameValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined);
         if (!nameValue) {
-            console.error(`• MCP prompt is missing the required 'name' property.`);
+            logger.critical(ErrorCode.MISSING_NAME, "MCP prompt is missing the required 'name' property.");
             return;
         }
         if (!descriptionValue) {
-            console.error(`• MCP prompt '${nameValue}' is missing a description.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
+            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP prompt '${nameValue}' is missing a description.`);
             return;
         }
         // lookup existing function metadata
         const fnMeta = state.functions.meta[pikkuFuncName];
         if (!fnMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}'.`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncName}'.`);
             return;
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- resolve permissions ---
+        const permissions = resolvePermissions(state, obj, tags, checker);
+        // --- track used functions/middleware/permissions for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.promptsMeta[nameValue] = {
             pikkuFuncName,
@@ -62,6 +68,7 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
             outputSchema,
             arguments: [], // Will be populated by CLI during serialization
             middleware,
+            permissions,
         };
     }
 };

package/dist/add/add-mcp-resource.js

@@ -1,10 +1,12 @@
 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 { extractWireNames } from '../utils/post-process.js';
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.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 { resolvePermissions } from '../utils/permissions.js';
+import { ErrorCode } from '../error-codes.js';
 export const addMCPResource = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -25,39 +27,46 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         const titleValue = getPropertyValue(obj, 'title');
         const descriptionValue = getPropertyValue(obj, 'description');
         const streamingValue = getPropertyValue(obj, 'streaming');
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'MCP resource', uriValue, logger);
+        if (streamingValue === true) {
+            logger.warn(`MCP resource '${uriValue}' has streaming enabled, but streaming is not yet supported.`);
+        }
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for MCP resource '${uriValue}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP resource '${uriValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, uriValue || undefined);
         if (!uriValue) {
-            console.error(`• MCP resource is missing the required 'uri' property.`);
+            logger.critical(ErrorCode.MISSING_URI, "MCP resource is missing the required 'uri' property.");
             return;
         }
         if (!titleValue) {
-            console.error(`• MCP resource '${uriValue}' is missing the required 'title' property.`);
+            logger.critical(ErrorCode.MISSING_TITLE, `MCP resource '${uriValue}' is missing the required 'title' property.`);
             return;
         }
         if (!descriptionValue) {
-            console.error(`• MCP resource '${uriValue}' is missing a description.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: uriValue, filePath }, logger)) {
+            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP resource '${uriValue}' is missing a description.`);
             return;
         }
         // lookup existing function metadata
         const fnMeta = state.functions.meta[pikkuFuncName];
         if (!fnMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}'.`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncName}'.`);
             return;
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- resolve permissions ---
+        const permissions = resolvePermissions(state, obj, tags, checker);
+        // --- track used functions/middleware/permissions for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.resourcesMeta[uriValue] = {
             pikkuFuncName,
@@ -69,6 +78,7 @@ export const addMCPResource = (logger, node, checker, state, options) => {
             inputSchema,
             outputSchema,
             middleware,
+            permissions,
         };
     }
 };

package/dist/add/add-mcp-tool.js

@@ -1,10 +1,12 @@
 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 { extractWireNames } from '../utils/post-process.js';
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.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 { resolvePermissions } from '../utils/permissions.js';
+import { ErrorCode } from '../error-codes.js';
 export const addMCPTool = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node)) {
         return;
@@ -25,35 +27,42 @@ export const addMCPTool = (logger, node, checker, state, options) => {
         const titleValue = getPropertyValue(obj, 'title');
         const descriptionValue = getPropertyValue(obj, 'description');
         const streamingValue = getPropertyValue(obj, 'streaming');
-        const tags = getPropertyValue(obj, 'tags') || undefined;
+        const tags = getPropertyTags(obj, 'MCP tool', nameValue, logger);
+        if (streamingValue === true) {
+            logger.warn(`MCP tool '${nameValue}' has streaming enabled, but streaming is not yet supported.`);
+        }
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
-            console.error(`• No valid 'func' property for MCP tool '${nameValue}'.`);
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP tool '${nameValue}'.`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined);
         if (!nameValue) {
-            console.error(`• MCP tool is missing the required 'name' property.`);
+            logger.critical(ErrorCode.MISSING_NAME, "MCP tool is missing the required 'name' property.");
             return;
         }
         if (!descriptionValue) {
-            console.error(`• MCP tool '${nameValue}' is missing a description.`);
-            return;
-        }
-        const filePath = node.getSourceFile().fileName;
-        if (!matchesFilters(options.filters || {}, { tags }, { type: PikkuWiringTypes.mcp, name: nameValue, filePath }, logger)) {
+            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP tool '${nameValue}' is missing a description.`);
             return;
         }
         // lookup existing function metadata
         const fnMeta = state.functions.meta[pikkuFuncName];
         if (!fnMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}'.`);
+            logger.critical(ErrorCode.FUNCTION_METADATA_NOT_FOUND, `No function metadata found for '${pikkuFuncName}'.`);
             return;
         }
         const inputSchema = fnMeta.inputs?.[0] || null;
         const outputSchema = fnMeta.outputs?.[0] || null;
         // --- resolve middleware ---
         const middleware = resolveMiddleware(state, obj, tags, checker);
+        // --- resolve permissions ---
+        const permissions = resolvePermissions(state, obj, tags, checker);
+        // --- track used functions/middleware/permissions for service aggregation ---
+        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
+        extractWireNames(permissions).forEach((name) => state.serviceAggregation.usedPermissions.add(name));
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
         state.mcpEndpoints.toolsMeta[nameValue] = {
             pikkuFuncName,
@@ -65,6 +74,7 @@ export const addMCPTool = (logger, node, checker, state, options) => {
             inputSchema,
             outputSchema,
             middleware,
+            permissions,
         };
     }
 };

package/dist/add/add-middleware.js

@@ -2,6 +2,8 @@ import * as ts from 'typescript';
 import { extractFunctionName, isNamedExport, } from '../utils/extract-function-name.js';
 import { extractServicesFromFunction } from '../utils/extract-services.js';
 import { extractMiddlewarePikkuNames } from '../utils/middleware.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 /**
  * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
  */
@@ -15,23 +17,46 @@ export const addMiddleware = (logger, node, checker, state) => {
     }
     // Handle pikkuMiddleware(...) - individual middleware function definition
     if (expression.text === 'pikkuMiddleware') {
-        const handlerNode = args[0];
-        if (!handlerNode)
+        const arg = args[0];
+        if (!arg)
             return;
-        if (!ts.isArrowFunction(handlerNode) &&
-            !ts.isFunctionExpression(handlerNode)) {
+        let actualHandler;
+        let name;
+        let description;
+        // Check if using object syntax: pikkuMiddleware({ 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(`• pikkuMiddleware object missing required 'func' property.`);
+                return;
+            }
+            actualHandler = fnProp;
+        }
+        else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+            actualHandler = arg;
+        }
+        else {
             logger.error(`• Handler for pikkuMiddleware is not a function.`);
             return;
         }
-        const services = extractServicesFromFunction(handlerNode);
-        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
+        const services = extractServicesFromFunction(actualHandler);
+        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker, state.rootDir);
         state.middleware.meta[pikkuFuncName] = {
             services,
             sourceFile: node.getSourceFile().fileName,
             position: node.getStart(),
             exportedName,
+            name,
+            description,
         };
-        logger.debug(`• Found middleware with services: ${services.services.join(', ')}`);
+        logger.debug(`• Found middleware with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`);
         return;
     }
     // Handle pikkuMiddlewareFactory(...) - middleware factory function
@@ -46,6 +71,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         }
         // Extract services by looking inside the factory function body
         // The factory should return pikkuMiddleware(...), 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 findPikkuMiddlewareCall = (node) => {
             if (ts.isCallExpression(node)) {
@@ -64,7 +90,20 @@ export const addMiddleware = (logger, node, checker, state) => {
                 services = extractServicesFromFunction(middlewareHandler);
             }
         }
-        const { pikkuFuncName, exportedName } = extractFunctionName(node, checker);
+        else {
+            // No pikkuMiddleware wrapper found - extract from factory's return value directly
+            // Factory pattern: (config) => (services, interaction, next) => { ... }
+            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.middleware.meta[pikkuFuncName] = {
             services,
             sourceFile: node.getSourceFile().fileName,
@@ -99,7 +138,7 @@ export const addMiddleware = (logger, node, checker, state) => {
             return;
         }
         // Extract middleware pikkuFuncNames from array
-        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker);
+        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker, state.rootDir);
         if (middlewareNames.length === 0) {
             logger.warn(`• addMiddleware('${tag}', ...) has empty middleware array`);
             return;
@@ -139,7 +178,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         }
         // If not a factory, get export name from the call expression itself
         if (!isFactory) {
-            const extracted = extractFunctionName(node, checker);
+            const extracted = extractFunctionName(node, checker, state.rootDir);
             exportedName = extracted.exportedName;
         }
         // Log warning if not using factory pattern
@@ -186,7 +225,7 @@ export const addMiddleware = (logger, node, checker, state) => {
             return;
         }
         // Extract middleware pikkuFuncNames from array
-        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker);
+        const middlewareNames = extractMiddlewarePikkuNames(middlewareArrayArg, checker, state.rootDir);
         if (middlewareNames.length === 0) {
             logger.warn(`• addHTTPMiddleware('${pattern}', ...) has empty middleware array`);
             return;
@@ -225,7 +264,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         }
         // If not a factory, get export name from the call expression itself
         if (!isFactory) {
-            const extracted = extractFunctionName(node, checker);
+            const extracted = extractFunctionName(node, checker, state.rootDir);
             exportedName = extracted.exportedName;
         }
         // Log warning if not using factory pattern

package/dist/add/add-permission.d.ts

@@ -1,6 +1,5 @@
 import { AddWiring } from '../types.js';
 /**
- * Inspect pikkuPermission calls and extract first-arg destructuring
- * for tree shaking optimization.
+ * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
  */
 export declare const addPermission: AddWiring;