@pikku/inspector 0.9.5 → 0.10.0

package/dist/{add-file-with-factory.js → add/add-file-with-factory.js}

@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
-export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName) => {
+import { extractServicesFromFunction } from '../utils/extract-services.js';
+export const addFileWithFactory = (node, checker, methods = new Map(), expectedTypeName, state) => {
     if (ts.isVariableDeclaration(node)) {
         const fileName = node.getSourceFile().fileName;
         const variableTypeNode = node.type;
@@ -16,13 +17,29 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                     const sourceFile = declaration.getSourceFile();
                     typeDeclarationPath = sourceFile.fileName; // Get the path of the file where the type was declared
                 }
-                const variables = methods[fileName] || [];
+                const variables = methods.get(fileName) || [];
                 variables.push({
                     variable: variableName,
                     type: typeNameNode.getText(),
                     typePath: typeDeclarationPath,
                 });
-                methods[fileName] = variables;
+                methods.set(fileName, variables);
+                // Extract singleton services for CreateSessionServices factories
+                if (expectedTypeName === 'CreateSessionServices' &&
+                    state &&
+                    node.initializer) {
+                    let functionNode;
+                    if (ts.isArrowFunction(node.initializer)) {
+                        functionNode = node.initializer;
+                    }
+                    else if (ts.isFunctionExpression(node.initializer)) {
+                        functionNode = node.initializer;
+                    }
+                    if (functionNode) {
+                        const servicesMeta = extractServicesFromFunction(functionNode);
+                        state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                    }
+                }
             }
             // Handle qualified type names if necessary
             else if (ts.isQualifiedName(typeNameNode)) {
@@ -34,13 +51,29 @@ export const addFileWithFactory = (node, checker, methods = new Map(), expectedT
                         const sourceFile = declaration.getSourceFile();
                         typeDeclarationPath = sourceFile.fileName; // Get the path of the file where the type was declared
                     }
-                    const variables = methods[fileName] || [];
+                    const variables = methods.get(fileName) || [];
                     variables.push({
                         variable: variableName,
                         type: typeNameNode.getText(),
                         typePath: typeDeclarationPath,
                     });
-                    methods[fileName] = variables;
+                    methods.set(fileName, variables);
+                    // Extract singleton services for CreateSessionServices factories
+                    if (expectedTypeName === 'CreateSessionServices' &&
+                        state &&
+                        node.initializer) {
+                        let functionNode;
+                        if (ts.isArrowFunction(node.initializer)) {
+                            functionNode = node.initializer;
+                        }
+                        else if (ts.isFunctionExpression(node.initializer)) {
+                            functionNode = node.initializer;
+                        }
+                        if (functionNode) {
+                            const servicesMeta = extractServicesFromFunction(functionNode);
+                            state.sessionServicesMeta.set(variableName, servicesMeta.services);
+                        }
+                    }
                 }
             }
         }

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

@@ -0,0 +1,6 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
+ * then push into state.functions.meta.
+ */
+export declare const addFunctions: AddWiring;

package/dist/{add-functions.js → add/add-functions.js}

@@ -1,6 +1,8 @@
 import * as ts from 'typescript';
-import { extractFunctionName, getPropertyAssignmentInitializer, } from './utils.js';
-import { getPropertyValue } from './get-property-value.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js';
+import { getPropertyValue } from '../utils/get-property-value.js';
+import { resolveMiddleware } from '../utils/middleware.js';
 const isValidVariableName = (name) => {
     const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
     return regex.test(name);
@@ -14,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();
@@ -25,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);
@@ -74,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;
@@ -123,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 {
@@ -142,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 {
@@ -186,7 +211,7 @@ function unwrapPromise(checker, type) {
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
  */
-export function addFunctions(node, checker, state, logger) {
+export const addFunctions = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args, typeArguments } = node;
@@ -205,16 +230,18 @@ export function addFunctions(node, checker, state, logger) {
     }
     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;
+    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');
@@ -222,6 +249,17 @@ export function addFunctions(node, checker, state, logger) {
         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;
@@ -229,6 +267,17 @@ export function addFunctions(node, checker, state, logger) {
     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 = {
@@ -258,7 +307,7 @@ export function addFunctions(node, checker, state, logger) {
         .map((tn) => checker.getTypeFromTypeNode(tn))
         .map((t) => unwrapPromise(checker, t));
     // --- Input Extraction ---
-    let { names: inputNames } = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
+    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`
@@ -280,6 +329,10 @@ export function addFunctions(node, checker, state, logger) {
     if (inputNames.length > 1) {
         logger.warn('More than one input type detected, only the first one will be used as a schema.');
     }
+    // --- resolve middleware ---
+    const middleware = objectNode
+        ? resolveMiddleware(state, objectNode, tags, checker)
+        : undefined;
     state.functions.meta[pikkuFuncName] = {
         pikkuFuncName,
         name,
@@ -292,7 +345,19 @@ export function addFunctions(node, checker, state, logger) {
         tags: tags || undefined,
         docs: docs || undefined,
         isDirectFunction,
+        middleware,
     };
+    // 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, {
+            path: node.getSourceFile().fileName,
+            exportedName,
+        });
+    }
     if (exportedName || explicitName) {
         if (!exportedName) {
             logger.error(`• Function with explicit name '${name}' is not exported, this is not allowed.`);
@@ -304,6 +369,8 @@ export function addFunctions(node, checker, state, logger) {
                 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;
@@ -316,4 +383,4 @@ export function addFunctions(node, checker, state, logger) {
             });
         }
     }
-}
+};

package/dist/{add-http-route.d.ts → add/add-http-route.d.ts}

@@ -1,5 +1,4 @@
-import * as ts from 'typescript';
-import { InspectorState, InspectorFilters, InspectorLogger } from './types.js';
+import { AddWiring } from '../types.js';
 /**
  * Populate metaInputTypes for a given route based on method, input type,
  * query and params. Returns undefined (we only mutate metaTypes).
@@ -13,4 +12,4 @@ export declare const getInputTypes: (metaTypes: Map<string, {
  * Simplified wireHTTP: re-uses function metadata from state.functions.meta
  * instead of re-inferring types here.
  */
-export declare const addHTTPRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters, logger: InspectorLogger) => void;
+export declare const addHTTPRoute: AddWiring;

package/dist/{add-http-route.js → add/add-http-route.js}

@@ -1,8 +1,13 @@
 import * as ts from 'typescript';
-import { getPropertyValue } from './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, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+import { extractFunctionName } from '../utils/extract-function-name.js';
+import { getPropertyAssignmentInitializer } from '../utils/type-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).
@@ -23,7 +28,7 @@ export const getInputTypes = (metaTypes, methodType, inputType, queryValues, par
  * Simplified wireHTTP: re-uses function metadata from state.functions.meta
  * instead of re-inferring types here.
  */
-export const addHTTPRoute = (node, checker, state, filters, logger) => {
+export const addHTTPRoute = (logger, node, checker, state, options) => {
     // only look at calls
     if (!ts.isCallExpression(node))
         return;
@@ -43,28 +48,34 @@ export const addHTTPRoute = (node, checker, state, filters, logger) => {
     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(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;
     // --- compute inputTypes (body/query/params) ---
     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] = {
@@ -76,5 +87,7 @@ export const addHTTPRoute = (node, checker, state, filters, logger) => {
         inputTypes,
         docs,
         tags,
+        middleware,
+        permissions,
     };
 };

package/dist/add/add-mcp-prompt.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addMCPPrompt: AddWiring;

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

@@ -0,0 +1,74 @@
+import * as ts from 'typescript';
+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 { 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;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    // Check if the call is to wireMCPPrompt
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPPrompt') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    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 funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+        if (!funcInitializer) {
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP prompt '${nameValue}'.`);
+            return;
+        }
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined);
+        if (!nameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, "MCP prompt is missing the required 'name' property.");
+            return;
+        }
+        if (!descriptionValue) {
+            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) {
+            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,
+            name: nameValue,
+            description: descriptionValue,
+            tags,
+            inputSchema,
+            outputSchema,
+            arguments: [], // Will be populated by CLI during serialization
+            middleware,
+            permissions,
+        };
+    }
+};

package/dist/add/add-mcp-resource.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addMCPResource: AddWiring;

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

@@ -0,0 +1,84 @@
+import * as ts from 'typescript';
+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 { 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;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    // Check if the call is to wireMCPResource
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPResource') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const uriValue = getPropertyValue(obj, 'uri');
+        const titleValue = getPropertyValue(obj, 'title');
+        const descriptionValue = getPropertyValue(obj, 'description');
+        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.`);
+        }
+        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+        if (!funcInitializer) {
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP resource '${uriValue}'.`);
+            return;
+        }
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, uriValue || undefined);
+        if (!uriValue) {
+            logger.critical(ErrorCode.MISSING_URI, "MCP resource is missing the required 'uri' property.");
+            return;
+        }
+        if (!titleValue) {
+            logger.critical(ErrorCode.MISSING_TITLE, `MCP resource '${uriValue}' is missing the required 'title' property.`);
+            return;
+        }
+        if (!descriptionValue) {
+            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) {
+            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,
+            uri: uriValue,
+            title: titleValue,
+            description: descriptionValue,
+            ...(streamingValue !== null && { streaming: streamingValue }),
+            tags,
+            inputSchema,
+            outputSchema,
+            middleware,
+            permissions,
+        };
+    }
+};

package/dist/add/add-mcp-tool.d.ts

@@ -0,0 +1,2 @@
+import { AddWiring } from '../types.js';
+export declare const addMCPTool: AddWiring;

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

@@ -0,0 +1,80 @@
+import * as ts from 'typescript';
+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 { 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;
+    }
+    const args = node.arguments;
+    const firstArg = args[0];
+    const expression = node.expression;
+    // Check if the call is to wireMCPTool
+    if (!ts.isIdentifier(expression) || expression.text !== 'wireMCPTool') {
+        return;
+    }
+    if (!firstArg) {
+        return;
+    }
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        const obj = firstArg;
+        const nameValue = getPropertyValue(obj, 'name');
+        const titleValue = getPropertyValue(obj, 'title');
+        const descriptionValue = getPropertyValue(obj, 'description');
+        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.`);
+        }
+        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+        if (!funcInitializer) {
+            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for MCP tool '${nameValue}'.`);
+            return;
+        }
+        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
+        // Ensure function metadata exists (creates stub for inline functions)
+        ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined);
+        if (!nameValue) {
+            logger.critical(ErrorCode.MISSING_NAME, "MCP tool is missing the required 'name' property.");
+            return;
+        }
+        if (!descriptionValue) {
+            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) {
+            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,
+            name: nameValue,
+            title: titleValue || undefined,
+            description: descriptionValue,
+            ...(streamingValue !== null && { streaming: streamingValue }),
+            tags,
+            inputSchema,
+            outputSchema,
+            middleware,
+            permissions,
+        };
+    }
+};

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

@@ -0,0 +1,5 @@
+import { AddWiring } from '../types.js';
+/**
+ * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
+ */
+export declare const addMiddleware: AddWiring;