@pikku/inspector 0.11.0 → 0.11.2

package/dist/add/add-functions.js

@@ -1,8 +1,10 @@
 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';
+import { resolvePermissions } from '../utils/permissions.js';
+import { ErrorCode } from '../error-codes.js';
 const isValidVariableName = (name) => {
     const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
     return regex.test(name);
@@ -109,7 +111,7 @@ const resolveUnionTypes = (checker, type) => {
     // Check if it's a union type AND not part of an intersection
     if (type.isUnion() && !(type.flags & ts.TypeFlags.Intersection)) {
         for (const t of type.types) {
-            const name = nullifyTypes(checker.typeToString(t));
+            const name = nullifyTypes(checker.typeToString(t, undefined, ts.TypeFormatFlags.NoTruncation));
             if (name) {
                 types.push(t);
                 names.push(name);
@@ -117,7 +119,7 @@ const resolveUnionTypes = (checker, type) => {
         }
     }
     else {
-        const name = nullifyTypes(checker.typeToString(type));
+        const name = nullifyTypes(checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation));
         if (name) {
             types.push(type);
             names.push(name);
@@ -231,44 +233,95 @@ export const addFunctions = (logger, node, checker, state) => {
     if (args.length === 0)
         return;
     const { pikkuFuncName, name, explicitName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+    let title;
     let tags;
+    let summary;
+    let description;
+    let errors;
     let expose;
     let internal;
-    let docs;
     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');
-        internal = getPropertyValue(handlerNode, 'internal');
-        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;
+    // Extract the function node using shared utility
+    const firstArg = args[0];
+    const { funcNode: handlerNode, resolvedFunc, isDirectFunction, } = extractFunctionNode(firstArg, checker);
+    // Variables to hold zod schema references if provided
+    let inputZodSchemaRef = null;
+    let outputZodSchemaRef = null;
+    // Helper to resolve schema identifier to its actual source file
+    const resolveSchemaSourceFile = (identifier) => {
+        const symbol = checker.getSymbolAtLocation(identifier);
+        if (!symbol)
+            return null;
+        const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+        if (!decl)
+            return null;
+        // If it's an import specifier, resolve the aliased symbol to get the actual source
+        if (ts.isImportSpecifier(decl)) {
+            const aliasedSymbol = checker.getAliasedSymbol(symbol);
+            if (aliasedSymbol) {
+                const aliasedDecl = aliasedSymbol.valueDeclaration || aliasedSymbol.declarations?.[0];
+                if (aliasedDecl) {
+                    return {
+                        variableName: identifier.text,
+                        sourceFile: aliasedDecl.getSourceFile().fileName,
+                    };
+                }
+            }
+        }
+        // Not an import - use the current source file
+        return {
+            variableName: identifier.text,
+            sourceFile: decl.getSourceFile().fileName,
+        };
+    };
+    // Extract config properties if using object form
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        objectNode = firstArg;
+        const metadata = getCommonWireMetaData(firstArg, 'Function', name, logger);
+        title = metadata.title;
+        tags = metadata.tags;
+        summary = metadata.summary;
+        description = metadata.description;
+        errors = metadata.errors;
+        expose = getPropertyValue(firstArg, 'expose');
+        internal = getPropertyValue(firstArg, 'internal');
+        // Extract zod schema variable names from input/output properties
+        for (const prop of firstArg.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                const propName = prop.name.text;
+                if (propName === 'input' || propName === 'output') {
+                    if (ts.isIdentifier(prop.initializer)) {
+                        // Good - it's a variable reference, resolve its actual source file
+                        const ref = resolveSchemaSourceFile(prop.initializer);
+                        if (ref) {
+                            if (propName === 'input') {
+                                inputZodSchemaRef = ref;
+                            }
+                            else {
+                                outputZodSchemaRef = ref;
+                            }
+                        }
+                    }
+                    else if (ts.isCallExpression(prop.initializer)) {
+                        // Bad - it's an inline expression
+                        const schemaName = `${name.charAt(0).toUpperCase() + name.slice(1)}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
+                        logger.critical(ErrorCode.INLINE_ZOD_SCHEMA, `Inline Zod schemas are not supported for '${propName}' in '${name}'.\n` +
+                            `  Extract to an exported variable:\n` +
+                            `    export const ${schemaName} = ${prop.initializer.getText()}\n` +
+                            `  Then use: ${propName}: ${schemaName}`);
+                    }
+                }
+            }
         }
-        handlerNode = fnProp;
     }
-    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,
@@ -286,7 +339,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) {
@@ -304,24 +357,64 @@ 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))
         .map((t) => unwrapPromise(checker, t));
+    const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
     // --- Input Extraction ---
-    let { names: inputNames, types: inputTypes } = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
-    // if (inputTypes.length === 0) {
-    //   logger.debug(
-    //     `\x1b[31m• Unknown input type for '${name}', assuming void.\x1b[0m`
-    //   )
-    // }
+    let inputNames = [];
+    let inputTypes = [];
+    if (inputZodSchemaRef) {
+        const schemaName = `${capitalizedName}Input`;
+        inputNames = [schemaName];
+        state.zodLookup.set(schemaName, inputZodSchemaRef);
+        state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
+    }
+    else if (genericTypes.length >= 1 && genericTypes[0]) {
+        // Fall back to extracting from generic type arguments
+        const result = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
+        inputNames = result.names;
+        inputTypes = result.types;
+    }
+    else {
+        // Fall back to extracting from the function's second parameter type
+        const secondParam = handler.parameters[1];
+        if (secondParam) {
+            const paramType = checker.getTypeAtLocation(secondParam);
+            const result = getNamesAndTypes(checker, state.functions.typesMap, 'Input', pikkuFuncName, paramType);
+            inputNames = result.names;
+            inputTypes = result.types;
+        }
+    }
     // --- Output Extraction ---
     let outputNames = [];
-    if (genericTypes.length >= 2) {
+    if (outputZodSchemaRef) {
+        const schemaName = `${capitalizedName}Output`;
+        outputNames = [schemaName];
+        state.zodLookup.set(schemaName, outputZodSchemaRef);
+        state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
+    }
+    else if (genericTypes.length >= 2) {
         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);
@@ -331,29 +424,38 @@ 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)
         : undefined;
+    // --- resolve permissions ---
+    const permissions = objectNode
+        ? resolvePermissions(state, objectNode, tags, checker)
+        : undefined;
     state.functions.meta[pikkuFuncName] = {
         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,
+        title,
         tags: tags || undefined,
-        docs: docs || undefined,
-        isDirectFunction,
+        summary,
+        description,
+        errors,
         middleware,
+        permissions,
+        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, {
@@ -361,6 +463,11 @@ 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.`);

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,9 +47,30 @@ 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 { title, tags, summary, description, errors } = getCommonWireMetaData(obj, 'HTTP route', route, logger);
     const query = getPropertyValue(obj, 'query') || [];
+    // Check if this is a workflow trigger (workflow: true)
+    const isWorkflowTrigger = getPropertyValue(obj, 'workflow') === true;
+    if (isWorkflowTrigger) {
+        // Workflow triggers don't need func - they're handled by workflow-utils
+        // Just record the route for HTTP meta but skip function processing
+        state.http.files.add(node.getSourceFile().fileName);
+        state.http.meta[method][route] = {
+            pikkuFuncName: '', // No function - workflow handles it
+            route,
+            method: method,
+            params: params.length > 0 ? params : undefined,
+            query: query.length > 0 ? query : undefined,
+            inputTypes: undefined,
+            title,
+            summary,
+            description,
+            errors,
+            tags,
+            workflow: true,
+        };
+        return;
+    }
     // --- find the referenced function name first for filtering ---
     const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
     if (!funcInitializer) {
@@ -85,7 +106,10 @@ export const addHTTPRoute = (logger, node, checker, state, options) => {
         params: params.length > 0 ? params : undefined,
         query: query.length > 0 ? query : undefined,
         inputTypes,
-        docs,
+        title,
+        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-rpc-invocations.d.ts

@@ -2,5 +2,8 @@ import * as ts from 'typescript';
 import { InspectorState, InspectorLogger } from '../types.js';
 /**
  * Scan for rpc.invoke() calls to track which functions are actually being invoked
+ * Also detects external package usage via:
+ * - Namespaced calls: rpc.invoke('namespace:function')
+ * - External helper: external('namespace:function')
  */
 export declare function addRPCInvocations(node: ts.Node, state: InspectorState, logger: InspectorLogger): void;

package/dist/add/add-rpc-invocations.js

@@ -1,35 +1,61 @@
 import * as ts from 'typescript';
+/**
+ * Helper to extract namespace from a namespaced function reference like 'ext:hello'
+ */
+function extractNamespace(functionRef) {
+    const colonIndex = functionRef.indexOf(':');
+    if (colonIndex !== -1) {
+        return functionRef.substring(0, colonIndex);
+    }
+    return null;
+}
 /**
  * Scan for rpc.invoke() calls to track which functions are actually being invoked
+ * Also detects external package usage via:
+ * - Namespaced calls: rpc.invoke('namespace:function')
+ * - External helper: external('namespace:function')
  */
 export function addRPCInvocations(node, state, logger) {
-    // Look for property access expressions: rpc.invoke
-    if (ts.isPropertyAccessExpression(node)) {
-        const { expression, name } = node;
-        // Check if this is accessing 'invoke' property
-        if (name.text === 'invoke') {
-            // Check if the object is 'rpc' (or a variable containing rpc)
-            if (ts.isIdentifier(expression) && expression.text === 'rpc') {
-                // This is rpc.invoke - now we need to find the parent call expression
-                const parent = node.parent;
-                if (ts.isCallExpression(parent) && parent.expression === node) {
-                    // This is rpc.invoke('function-name')
-                    const [firstArg] = parent.arguments;
-                    if (firstArg) {
-                        // Extract the function name from string literal
-                        if (ts.isStringLiteral(firstArg)) {
-                            const functionName = firstArg.text;
-                            logger.debug(`• Found RPC invocation: ${functionName}`);
-                            state.rpc.invokedFunctions.add(functionName);
-                        }
-                        // Handle template literals like `function-${name}`
-                        else if (ts.isTemplateExpression(firstArg) ||
-                            ts.isNoSubstitutionTemplateLiteral(firstArg)) {
-                            logger.warn(`• Found dynamic RPC invocation: ${firstArg.getText()}`);
-                            logger.warn(`\tYou can only use string literals for RPC function names, with ' or " and not \``);
-                        }
+    // Look for call expressions: external('ext:hello') or rpc.invoke('...')
+    if (ts.isCallExpression(node)) {
+        const { expression, arguments: args } = node;
+        // Check for external('namespace:function') calls
+        if (ts.isIdentifier(expression) && expression.text === 'external') {
+            const [firstArg] = args;
+            if (firstArg && ts.isStringLiteral(firstArg)) {
+                const functionRef = firstArg.text;
+                logger.debug(`• Found external() call: ${functionRef}`);
+                state.rpc.invokedFunctions.add(functionRef);
+                const namespace = extractNamespace(functionRef);
+                if (namespace) {
+                    logger.debug(`  → External package detected: ${namespace}`);
+                    state.rpc.usedExternalPackages.add(namespace);
+                }
+            }
+        }
+        // Check for rpc.invoke('...') calls
+        if (ts.isPropertyAccessExpression(expression) &&
+            expression.name.text === 'invoke' &&
+            ts.isIdentifier(expression.expression) &&
+            expression.expression.text === 'rpc') {
+            const [firstArg] = args;
+            if (firstArg) {
+                if (ts.isStringLiteral(firstArg)) {
+                    const functionRef = firstArg.text;
+                    logger.debug(`• Found RPC invocation: ${functionRef}`);
+                    state.rpc.invokedFunctions.add(functionRef);
+                    const namespace = extractNamespace(functionRef);
+                    if (namespace) {
+                        logger.debug(`  → External package detected: ${namespace}`);
+                        state.rpc.usedExternalPackages.add(namespace);
                     }
                 }
+                // Handle template literals like `function-${name}`
+                else if (ts.isTemplateExpression(firstArg) ||
+                    ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+                    logger.warn(`• Found dynamic RPC invocation: ${firstArg.getText()}`);
+                    logger.warn(`\tYou can only use string literals for RPC function names, with ' or " and not \``);
+                }
             }
         }
     }

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