@pikku/inspector 0.10.2 → 0.11.1

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 0.11.0
+
+## 0.11.1
+
+### Patch Changes
+
+- 4b811db: chore: updating all dependencies
+- 28aeb7f: breaking: extract docs in the wiring meta
+- ce902b1: feat: adding in pikkuSimpleWorkflowFunc
+- 06e1a31: breaking: change session services to wire services
+- Updated dependencies [4b811db]
+- Updated dependencies [e12a00c]
+- Updated dependencies [4579434]
+- Updated dependencies [28aeb7f]
+- Updated dependencies [ce902b1]
+- Updated dependencies [06e1a31]
+  - @pikku/core@0.11.1
+
+### Minor Changes
+
+- Add workflow inspection and analysis
+- Add enhanced type extraction utilities
+
 # @pikku/inspector
 
 ## 0.10.2

package/dist/add/add-channel.js

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { ErrorCode } from '../error-codes.js';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
@@ -143,7 +143,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                         if (fnMeta) {
                                             // Resolve middleware for this route
                                             const routeTags = ts.isObjectLiteralExpression(init)
-                                                ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                                 : undefined;
                                             const routeMiddleware = ts.isObjectLiteralExpression(init)
                                                 ? resolveMiddleware(state, init, routeTags, checker)
@@ -165,7 +165,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                     if (fnMeta) {
                                         // Resolve middleware for this route
                                         const routeTags = ts.isObjectLiteralExpression(init)
-                                            ? getPropertyTags(init, 'channel', channelKey, logger)
+                                            ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                             : undefined;
                                         const routeMiddleware = ts.isObjectLiteralExpression(init)
                                             ? resolveMiddleware(state, init, routeTags, checker)
@@ -198,7 +198,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 if (fnMeta) {
                                                     // Resolve middleware for this route
                                                     const routeTags = ts.isObjectLiteralExpression(init)
-                                                        ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                        ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                                         : undefined;
                                                     const routeMiddleware = ts.isObjectLiteralExpression(init)
                                                         ? resolveMiddleware(state, init, routeTags, checker)
@@ -217,7 +217,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                                                 if (fnMeta) {
                                                     // Resolve middleware for this route
                                                     const routeTags = ts.isObjectLiteralExpression(init)
-                                                        ? getPropertyTags(init, 'channel', channelKey, logger)
+                                                        ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                                         : undefined;
                                                     const routeMiddleware = ts.isObjectLiteralExpression(init)
                                                         ? resolveMiddleware(state, init, routeTags, checker)
@@ -281,7 +281,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
                             if (fnMeta) {
                                 // Resolve middleware for this route
                                 const routeTags = ts.isObjectLiteralExpression(init)
-                                    ? getPropertyTags(init, 'channel', channelKey, logger)
+                                    ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                                     : undefined;
                                 const routeMiddleware = ts.isObjectLiteralExpression(init)
                                     ? resolveMiddleware(state, init, routeTags, checker)
@@ -310,7 +310,7 @@ export function addMessagesRoutes(logger, obj, state, checker) {
             // Resolve middleware and permissions for this route
             // Check if the route config is an object literal with middleware/permissions
             const routeTags = ts.isObjectLiteralExpression(init)
-                ? getPropertyTags(init, 'channel', channelKey, logger)
+                ? getCommonWireMetaData(init, 'Channel message', routeKey, logger).tags
                 : undefined;
             const routeMiddleware = ts.isObjectLiteralExpression(init)
                 ? resolveMiddleware(state, init, routeTags, checker)
@@ -349,8 +349,7 @@ export const addChannel = (logger, node, checker, state, options) => {
             .keys.filter((k) => k.type === 'param')
             .map((k) => k.name)
         : [];
-    const docs = getPropertyValue(obj, 'docs');
-    const tags = getPropertyTags(obj, 'Channel', route, logger);
+    const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'Channel', name, logger);
     const query = getPropertyValue(obj, 'query');
     const connect = getPropertyAssignmentInitializer(obj, 'onConnect', true, checker);
     const disconnect = getPropertyAssignmentInitializer(obj, 'onDisconnect', true, checker);
@@ -421,7 +420,9 @@ export const addChannel = (logger, node, checker, state, options) => {
             : null,
         message,
         messageWirings,
-        docs: docs ?? undefined,
+        summary,
+        description,
+        errors,
         tags: tags ?? undefined,
         middleware,
     };

package/dist/add/add-file-with-factory.js

@@ -4,7 +4,7 @@ import { extractServicesFromFunction } from '../utils/extract-services.js';
 const wrapperFunctionMap = {
     pikkuConfig: 'CreateConfig',
     pikkuServices: 'CreateSingletonServices',
-    pikkuSessionServices: 'CreateSessionServices',
+    pikkuWireServices: 'CreateWireServices',
 };
 export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {
     if (ts.isVariableDeclaration(node)) {
@@ -37,8 +37,8 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         typePath: typeDeclarationPath,
                     });
                     methods.set(fileName, variables);
-                    // Extract singleton services for CreateSessionServices factories
-                    if (expectedTypeName === 'CreateSessionServices' &&
+                    // Extract singleton services for CreateWireServices factories
+                    if (expectedTypeName === 'CreateWireServices' &&
                         state &&
                         callExpression.arguments.length > 0) {
                         const firstArg = callExpression.arguments[0];
@@ -51,7 +51,7 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         }
                         if (functionNode) {
                             const servicesMeta = extractServicesFromFunction(functionNode);
-                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                            state.wireServicesMeta.set(variableName, servicesMeta.services);
                         }
                     }
                     return; // Early return since we found a match
@@ -77,8 +77,8 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                     typePath: typeDeclarationPath,
                 });
                 methods.set(fileName, variables);
-                // Extract singleton services for CreateSessionServices factories
-                if (expectedTypeName === 'CreateSessionServices' &&
+                // Extract singleton services for CreateWireServices factories
+                if (expectedTypeName === 'CreateWireServices' &&
                     state &&
                     node.initializer) {
                     let functionNode;
@@ -90,7 +90,7 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                     }
                     if (functionNode) {
                         const servicesMeta = extractServicesFromFunction(functionNode);
-                        state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                        state.wireServicesMeta.set(variableName, servicesMeta.services);
                     }
                 }
             }
@@ -111,8 +111,8 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         typePath: typeDeclarationPath,
                     });
                     methods.set(fileName, variables);
-                    // Extract singleton services for CreateSessionServices factories
-                    if (expectedTypeName === 'CreateSessionServices' &&
+                    // Extract singleton services for CreateWireServices factories
+                    if (expectedTypeName === 'CreateWireServices' &&
                         state &&
                         node.initializer) {
                         let functionNode;
@@ -124,7 +124,7 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         }
                         if (functionNode) {
                             const servicesMeta = extractServicesFromFunction(functionNode);
-                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                            state.wireServicesMeta.set(variableName, servicesMeta.services);
                         }
                     }
                 }

package/dist/add/add-functions.js

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import { extractFunctionName } from '../utils/extract-function-name.js';
-import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
-import { getPropertyValue } from '../utils/get-property-value.js';
+import { extractFunctionNode } from '../utils/extract-function-node.js';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { resolveMiddleware } from '../utils/middleware.js';
 const isValidVariableName = (name) => {
     const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
@@ -232,41 +232,34 @@ export const addFunctions = (logger, node, checker, state) => {
         return;
     const { pikkuFuncName, name, explicitName, exportedName } = extractFunctionName(node, checker, state.rootDir);
     let tags;
+    let summary;
+    let description;
+    let errors;
     let expose;
-    let docs;
+    let internal;
     let objectNode;
-    // determine the actual handler expression:
-    // either the `func` prop or the first argument directly
-    let handlerNode = args[0];
-    let isDirectFunction = true; // Default to direct function format
-    if (ts.isObjectLiteralExpression(handlerNode)) {
-        isDirectFunction = false; // This is object format with func property
-        objectNode = handlerNode;
-        tags = getPropertyValue(handlerNode, 'tags') || undefined;
-        expose = getPropertyValue(handlerNode, 'expose');
-        docs = getPropertyValue(handlerNode, 'docs');
-        const fnProp = getPropertyAssignmentInitializer(handlerNode, 'func', true, checker);
-        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;
+    // Extract the function node using shared utility
+    const firstArg = args[0];
+    const { funcNode: handlerNode, resolvedFunc, isDirectFunction, } = extractFunctionNode(firstArg, checker);
+    // Extract config properties if using object form
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        objectNode = firstArg;
+        const metadata = getCommonWireMetaData(firstArg, 'Function', name, logger);
+        tags = metadata.tags;
+        summary = metadata.summary;
+        description = metadata.description;
+        errors = metadata.errors;
+        expose = getPropertyValue(firstArg, 'expose');
+        internal = getPropertyValue(firstArg, 'internal');
     }
-    if (!ts.isArrowFunction(handlerNode) &&
-        !ts.isFunctionExpression(handlerNode)) {
-        logger.error(`• Handler for ${name} is not a function.`);
+    // Pick the handler: use resolvedFunc when it exists and is a function, otherwise fall back to handlerNode
+    const handler = resolvedFunc &&
+        (ts.isArrowFunction(resolvedFunc) || ts.isFunctionExpression(resolvedFunc))
+        ? resolvedFunc
+        : handlerNode;
+    // Validate that we got a valid function
+    if (!ts.isArrowFunction(handler) && !ts.isFunctionExpression(handler)) {
+        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,
@@ -284,7 +277,7 @@ export const addFunctions = (logger, node, checker, state) => {
         optimized: true,
         services: [],
     };
-    const firstParam = handlerNode.parameters[0];
+    const firstParam = handler.parameters[0];
     if (firstParam) {
         if (ts.isObjectBindingPattern(firstParam.name)) {
             for (const elem of firstParam.name.elements) {
@@ -302,6 +295,21 @@ export const addFunctions = (logger, node, checker, state) => {
             services.optimized = false;
         }
     }
+    // --- Extract used wires from third parameter ---
+    const usedWires = [];
+    const thirdParam = handler.parameters[2];
+    if (thirdParam && ts.isObjectBindingPattern(thirdParam.name)) {
+        for (const elem of thirdParam.name.elements) {
+            const propertyName = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                ? elem.propertyName.text
+                : ts.isIdentifier(elem.name)
+                    ? elem.name.text
+                    : undefined;
+            if (propertyName) {
+                usedWires.push(propertyName);
+            }
+        }
+    }
     // --- Generics → ts.Type[], unwrapped from Promise ---
     const genericTypes = (typeArguments ?? [])
         .map((tn) => checker.getTypeFromTypeNode(tn))
@@ -319,7 +327,7 @@ export const addFunctions = (logger, node, checker, state) => {
         outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', name, genericTypes[1]).names;
     }
     else {
-        const sig = checker.getSignatureFromDeclaration(handlerNode);
+        const sig = checker.getSignatureFromDeclaration(handler);
         if (sig) {
             const rawRet = checker.getReturnTypeOfSignature(sig);
             const unwrapped = unwrapPromise(checker, rawRet);
@@ -329,6 +337,10 @@ export const addFunctions = (logger, node, checker, state) => {
     if (inputNames.length > 1) {
         logger.warn('More than one input type detected, only the first one will be used as a schema.');
     }
+    // Store the input type for later use
+    if (inputTypes.length > 0) {
+        state.typesLookup.set(pikkuFuncName, inputTypes);
+    }
     // --- resolve middleware ---
     const middleware = objectNode
         ? resolveMiddleware(state, objectNode, tags, checker)
@@ -337,20 +349,20 @@ export const addFunctions = (logger, node, checker, state) => {
         pikkuFuncName,
         name,
         services,
+        usedWires: usedWires.length > 0 ? usedWires : undefined,
         inputSchemaName: inputNames[0] ?? null,
         outputSchemaName: outputNames[0] ?? null,
         inputs: inputNames.filter((n) => n !== 'void') ?? null,
         outputs: outputNames.filter((n) => n !== 'void') ?? null,
         expose: expose || undefined,
+        internal: internal || undefined,
         tags: tags || undefined,
-        docs: docs || undefined,
-        isDirectFunction,
+        summary,
+        description,
+        errors,
         middleware,
+        isDirectFunction,
     };
-    // Store the input type for later use
-    if (inputTypes.length > 0) {
-        state.typesLookup.set(pikkuFuncName, inputTypes);
-    }
     // Store function file location for wiring generation
     if (exportedName) {
         state.functions.files.set(pikkuFuncName, {
@@ -358,11 +370,20 @@ export const addFunctions = (logger, node, checker, state) => {
             exportedName,
         });
     }
+    // Workflow functions don't get registered as RPC functions,
+    // they are their own type handled by add-workdflow
+    if (expression.text.includes('Workflow')) {
+        return;
+    }
     if (exportedName || explicitName) {
         if (!exportedName) {
             logger.error(`• Function with explicit name '${name}' is not exported, this is not allowed.`);
             return;
         }
+        // Mark internal functions as invoked to force bundling
+        if (internal) {
+            state.rpc.invokedFunctions.add(pikkuFuncName);
+        }
         if (expose) {
             state.rpc.exposedMeta[name] = pikkuFuncName;
             state.rpc.exposedFiles.set(name, {
@@ -376,8 +397,8 @@ export const addFunctions = (logger, node, checker, state) => {
         state.rpc.internalMeta[name] = pikkuFuncName;
         // But we only import the actual function if it's actually invoked to keep
         // bundle size down
-        if (state.rpc.invokedFunctions.has(pikkuFuncName) || expose) {
-            state.rpc.internalFiles.set(name, {
+        if (state.rpc.invokedFunctions.has(pikkuFuncName) || expose || internal) {
+            state.rpc.internalFiles.set(pikkuFuncName, {
                 path: node.getSourceFile().fileName,
                 exportedName,
             });

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
@@ -47,8 +47,7 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
     const keys = pathToRegexp(route).keys;
     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 = getPropertyTags(obj, 'HTTP route', route, logger);
+    const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'HTTP route', route, logger);
     const query = getPropertyValue(obj, 'query') || [];
     // --- find the referenced function name first for filtering ---
     const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
@@ -85,7 +84,9 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
         params: params.length > 0 ? params : undefined,
         query: query.length > 0 ? query : undefined,
         inputTypes,
-        docs,
+        summary,
+        description,
+        errors,
         tags,
         middleware,
         permissions,

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { getPropertyValue, getCommonWireMetaData, } 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';
@@ -24,8 +24,7 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
     if (ts.isObjectLiteralExpression(firstArg)) {
         const obj = firstArg;
         const nameValue = getPropertyValue(obj, 'name');
-        const descriptionValue = getPropertyValue(obj, 'description');
-        const tags = getPropertyTags(obj, 'MCP prompt', nameValue, logger);
+        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'MCP prompt', nameValue, logger);
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
             logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP prompt '${nameValue}'.`);
@@ -38,7 +37,7 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
             logger.critical(ErrorCode.MISSING_NAME, "MCP prompt is missing the required 'name' property.");
             return;
         }
-        if (!descriptionValue) {
+        if (!description) {
             logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP prompt '${nameValue}' is missing a description.`);
             return;
         }
@@ -62,7 +61,9 @@ export const addMCPPrompt = (logger, node, checker, state, options) => {
         state.mcpEndpoints.promptsMeta[nameValue] = {
             pikkuFuncName,
             name: nameValue,
-            description: descriptionValue,
+            description,
+            summary,
+            errors,
             tags,
             inputSchema,
             outputSchema,

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { getPropertyValue, getCommonWireMetaData, } 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';
@@ -25,9 +25,8 @@ export const addMCPResource = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const uriValue = getPropertyValue(obj, 'uri');
         const titleValue = getPropertyValue(obj, 'title');
-        const descriptionValue = getPropertyValue(obj, 'description');
+        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'MCP resource', uriValue, logger);
         const streamingValue = getPropertyValue(obj, 'streaming');
-        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.`);
         }
@@ -47,7 +46,7 @@ export const addMCPResource = (logger, node, checker, state, options) => {
             logger.critical(ErrorCode.MISSING_TITLE, `MCP resource '${uriValue}' is missing the required 'title' property.`);
             return;
         }
-        if (!descriptionValue) {
+        if (!description) {
             logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP resource '${uriValue}' is missing a description.`);
             return;
         }
@@ -72,7 +71,9 @@ export const addMCPResource = (logger, node, checker, state, options) => {
             pikkuFuncName,
             uri: uriValue,
             title: titleValue,
-            description: descriptionValue,
+            description,
+            summary,
+            errors,
             ...(streamingValue !== null && { streaming: streamingValue }),
             tags,
             inputSchema,

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

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { getPropertyValue, getCommonWireMetaData, } 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';
@@ -25,9 +25,8 @@ export const addMCPTool = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const nameValue = getPropertyValue(obj, 'name');
         const titleValue = getPropertyValue(obj, 'title');
-        const descriptionValue = getPropertyValue(obj, 'description');
+        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'MCP tool', nameValue, logger);
         const streamingValue = getPropertyValue(obj, 'streaming');
-        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.`);
         }
@@ -43,7 +42,7 @@ export const addMCPTool = (logger, node, checker, state, options) => {
             logger.critical(ErrorCode.MISSING_NAME, "MCP tool is missing the required 'name' property.");
             return;
         }
-        if (!descriptionValue) {
+        if (!description) {
             logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP tool '${nameValue}' is missing a description.`);
             return;
         }
@@ -68,7 +67,9 @@ export const addMCPTool = (logger, node, checker, state, options) => {
             pikkuFuncName,
             name: nameValue,
             title: titleValue || undefined,
-            description: descriptionValue,
+            description,
+            summary,
+            errors,
             ...(streamingValue !== null && { streaming: streamingValue }),
             tags,
             inputSchema,

package/dist/add/add-middleware.js

@@ -92,7 +92,7 @@ export const addMiddleware = (logger, node, checker, state) => {
         }
         else {
             // No pikkuMiddleware wrapper found - extract from factory's return value directly
-            // Factory pattern: (config) => (services, interaction, next) => { ... }
+            // Factory pattern: (config) => (services, wire, next) => { ... }
             if (ts.isArrowFunction(factoryNode) ||
                 ts.isFunctionExpression(factoryNode)) {
                 const factoryBody = factoryNode.body;

package/dist/add/add-permission.js

@@ -92,7 +92,7 @@ export const addPermission = (logger, node, checker, state) => {
         }
         else {
             // No pikkuPermission wrapper found - extract from factory's return value directly
-            // Factory pattern: (config) => (services, data, session) => { ... }
+            // Factory pattern: (config) => (services, data, wire) => { ... }
             if (ts.isArrowFunction(factoryNode) ||
                 ts.isFunctionExpression(factoryNode)) {
                 const factoryBody = factoryNode.body;

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

@@ -1,11 +1,11 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-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) => {
+export const addQueueWorker = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -22,8 +22,7 @@ export const addQueueWorker = (logger, node, checker, state, options) => {
     if (ts.isObjectLiteralExpression(firstArg)) {
         const obj = firstArg;
         const queueName = getPropertyValue(obj, 'queueName');
-        const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyTags(obj, 'Queue worker', queueName, logger);
+        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'Queue worker', queueName, logger);
         // --- find the referenced function ---
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
@@ -44,7 +43,9 @@ export const addQueueWorker = (logger, node, checker, state, options) => {
         state.queueWorkers.meta[queueName] = {
             pikkuFuncName,
             queueName,
-            docs,
+            summary,
+            description,
+            errors,
             tags,
             middleware,
         };

package/dist/add/add-schedule.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
+import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
 import { resolveMiddleware } from '../utils/middleware.js';
@@ -23,8 +23,7 @@ export const addSchedule = (logger, node, checker, state, options) => {
         const obj = firstArg;
         const nameValue = getPropertyValue(obj, 'name');
         const scheduleValue = getPropertyValue(obj, 'schedule');
-        const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyTags(obj, 'Scheduler', nameValue, logger);
+        const { tags, summary, description, errors } = getCommonWireMetaData(obj, 'Scheduler', nameValue, logger);
         const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
         if (!funcInitializer) {
             logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for scheduled task '${nameValue}'.`);
@@ -44,7 +43,9 @@ export const addSchedule = (logger, node, checker, state, options) => {
             pikkuFuncName,
             name: nameValue,
             schedule: scheduleValue,
-            docs,
+            summary,
+            description,
+            errors,
             tags,
             middleware,
         };

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

@@ -0,0 +1,6 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
+ * Detects workflow registration and extracts metadata
+ */
+export declare const addWorkflow: AddWiring;