@pikku/inspector 0.9.6-next.0 → 0.10.0

package/src/add/add-mcp-prompt.ts

@@ -1,11 +1,16 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from '../utils/get-property-value.js'
-import { PikkuWiringTypes } from '@pikku/core'
+import {
+  getPropertyValue,
+  getPropertyTags,
+} from '../utils/get-property-value.js'
+import { extractWireNames } from '../utils/post-process.js'
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
 import { AddWiring } from '../types.js'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
-import { matchesFilters } from '../utils/filter-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
+import { resolvePermissions } from '../utils/permissions.js'
+import { ErrorCode } from '../error-codes.js'
 
 export const addMCPPrompt: AddWiring = (
   logger,
@@ -38,7 +43,7 @@ export const addMCPPrompt: AddWiring = (
     const descriptionValue = getPropertyValue(obj, 'description') as
       | string
       | null
-    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+    const tags = getPropertyTags(obj, 'MCP prompt', nameValue, logger)
 
     const funcInitializer = getPropertyAssignmentInitializer(
       obj,
@@ -47,42 +52,45 @@ export const addMCPPrompt: AddWiring = (
       checker
     )
     if (!funcInitializer) {
-      console.error(`• No valid 'func' property for MCP prompt '${nameValue}'.`)
+      logger.critical(
+        ErrorCode.MISSING_FUNC,
+        `No valid 'func' property for MCP prompt '${nameValue}'.`
+      )
       return
     }
 
     const pikkuFuncName = extractFunctionName(
       funcInitializer,
-      checker
+      checker,
+      state.rootDir
     ).pikkuFuncName
 
+    // Ensure function metadata exists (creates stub for inline functions)
+    ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined)
+
     if (!nameValue) {
-      console.error(`• MCP prompt is missing the required 'name' property.`)
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        "MCP prompt is missing the required 'name' property."
+      )
       return
     }
 
     if (!descriptionValue) {
-      console.error(`• MCP prompt '${nameValue}' is missing a description.`)
-      return
-    }
-
-    const filePath = node.getSourceFile().fileName
-
-    if (
-      !matchesFilters(
-        options.filters || {},
-        { tags },
-        { type: PikkuWiringTypes.mcp, name: nameValue, filePath },
-        logger
+      logger.critical(
+        ErrorCode.MISSING_DESCRIPTION,
+        `MCP prompt '${nameValue}' is missing a description.`
       )
-    ) {
       return
     }
 
     // lookup existing function metadata
     const fnMeta = state.functions.meta[pikkuFuncName]
     if (!fnMeta) {
-      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
+      logger.critical(
+        ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+        `No function metadata found for '${pikkuFuncName}'.`
+      )
       return
     }
     const inputSchema = fnMeta.inputs?.[0] || null
@@ -91,6 +99,18 @@ export const addMCPPrompt: AddWiring = (
     // --- 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] = {
@@ -102,6 +122,7 @@ export const addMCPPrompt: AddWiring = (
       outputSchema,
       arguments: [], // Will be populated by CLI during serialization
       middleware,
+      permissions,
     }
   }
 }

package/src/add/add-mcp-resource.ts

@@ -1,11 +1,16 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from '../utils/get-property-value.js'
-import { PikkuWiringTypes } from '@pikku/core'
+import {
+  getPropertyValue,
+  getPropertyTags,
+} from '../utils/get-property-value.js'
+import { extractWireNames } from '../utils/post-process.js'
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
 import { AddWiring } from '../types.js'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
-import { matchesFilters } from '../utils/filter-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
+import { resolvePermissions } from '../utils/permissions.js'
+import { ErrorCode } from '../error-codes.js'
 
 export const addMCPResource: AddWiring = (
   logger,
@@ -40,7 +45,13 @@ export const addMCPResource: AddWiring = (
       | string
       | null
     const streamingValue = getPropertyValue(obj, 'streaming') as boolean | null
-    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+    const tags = getPropertyTags(obj, 'MCP resource', uriValue, logger)
+
+    if (streamingValue === true) {
+      logger.warn(
+        `MCP resource '${uriValue}' has streaming enabled, but streaming is not yet supported.`
+      )
+    }
 
     const funcInitializer = getPropertyAssignmentInitializer(
       obj,
@@ -49,51 +60,53 @@ export const addMCPResource: AddWiring = (
       checker
     )
     if (!funcInitializer) {
-      console.error(
-        `• No valid 'func' property for MCP resource '${uriValue}'.`
+      logger.critical(
+        ErrorCode.MISSING_FUNC,
+        `No valid 'func' property for MCP resource '${uriValue}'.`
       )
       return
     }
 
     const pikkuFuncName = extractFunctionName(
       funcInitializer,
-      checker
+      checker,
+      state.rootDir
     ).pikkuFuncName
 
+    // Ensure function metadata exists (creates stub for inline functions)
+    ensureFunctionMetadata(state, pikkuFuncName, uriValue || undefined)
+
     if (!uriValue) {
-      console.error(`• MCP resource is missing the required 'uri' property.`)
+      logger.critical(
+        ErrorCode.MISSING_URI,
+        "MCP resource is missing the required 'uri' property."
+      )
       return
     }
 
     if (!titleValue) {
-      console.error(
-        `• MCP resource '${uriValue}' is missing the required 'title' property.`
+      logger.critical(
+        ErrorCode.MISSING_TITLE,
+        `MCP resource '${uriValue}' is missing the required 'title' property.`
       )
       return
     }
 
     if (!descriptionValue) {
-      console.error(`• MCP resource '${uriValue}' is missing a description.`)
-      return
-    }
-
-    const filePath = node.getSourceFile().fileName
-
-    if (
-      !matchesFilters(
-        options.filters || {},
-        { tags },
-        { type: PikkuWiringTypes.mcp, name: uriValue, filePath },
-        logger
+      logger.critical(
+        ErrorCode.MISSING_DESCRIPTION,
+        `MCP resource '${uriValue}' is missing a description.`
       )
-    ) {
       return
     }
 
     // lookup existing function metadata
     const fnMeta = state.functions.meta[pikkuFuncName]
     if (!fnMeta) {
-      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
+      logger.critical(
+        ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+        `No function metadata found for '${pikkuFuncName}'.`
+      )
       return
     }
     const inputSchema = fnMeta.inputs?.[0] || null
@@ -102,6 +115,18 @@ export const addMCPResource: AddWiring = (
     // --- 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] = {
@@ -114,6 +139,7 @@ export const addMCPResource: AddWiring = (
       inputSchema,
       outputSchema,
       middleware,
+      permissions,
     }
   }
 }

package/src/add/add-mcp-tool.ts

@@ -1,11 +1,16 @@
 import * as ts from 'typescript'
-import { getPropertyValue } from '../utils/get-property-value.js'
-import { PikkuWiringTypes } from '@pikku/core'
+import {
+  getPropertyValue,
+  getPropertyTags,
+} from '../utils/get-property-value.js'
+import { extractWireNames } from '../utils/post-process.js'
+import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
 import { AddWiring } from '../types.js'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
-import { matchesFilters } from '../utils/filter-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
+import { resolvePermissions } from '../utils/permissions.js'
+import { ErrorCode } from '../error-codes.js'
 
 export const addMCPTool: AddWiring = (
   logger,
@@ -40,7 +45,13 @@ export const addMCPTool: AddWiring = (
       | string
       | null
     const streamingValue = getPropertyValue(obj, 'streaming') as boolean | null
-    const tags = (getPropertyValue(obj, 'tags') as string[]) || undefined
+    const tags = getPropertyTags(obj, 'MCP tool', nameValue, logger)
+
+    if (streamingValue === true) {
+      logger.warn(
+        `MCP tool '${nameValue}' has streaming enabled, but streaming is not yet supported.`
+      )
+    }
 
     const funcInitializer = getPropertyAssignmentInitializer(
       obj,
@@ -49,42 +60,45 @@ export const addMCPTool: AddWiring = (
       checker
     )
     if (!funcInitializer) {
-      console.error(`• No valid 'func' property for MCP tool '${nameValue}'.`)
+      logger.critical(
+        ErrorCode.MISSING_FUNC,
+        `No valid 'func' property for MCP tool '${nameValue}'.`
+      )
       return
     }
 
     const pikkuFuncName = extractFunctionName(
       funcInitializer,
-      checker
+      checker,
+      state.rootDir
     ).pikkuFuncName
 
+    // Ensure function metadata exists (creates stub for inline functions)
+    ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined)
+
     if (!nameValue) {
-      console.error(`• MCP tool is missing the required 'name' property.`)
+      logger.critical(
+        ErrorCode.MISSING_NAME,
+        "MCP tool is missing the required 'name' property."
+      )
       return
     }
 
     if (!descriptionValue) {
-      console.error(`• MCP tool '${nameValue}' is missing a description.`)
-      return
-    }
-
-    const filePath = node.getSourceFile().fileName
-
-    if (
-      !matchesFilters(
-        options.filters || {},
-        { tags },
-        { type: PikkuWiringTypes.mcp, name: nameValue, filePath },
-        logger
+      logger.critical(
+        ErrorCode.MISSING_DESCRIPTION,
+        `MCP tool '${nameValue}' is missing a description.`
       )
-    ) {
       return
     }
 
     // lookup existing function metadata
     const fnMeta = state.functions.meta[pikkuFuncName]
     if (!fnMeta) {
-      console.error(`• No function metadata found for '${pikkuFuncName}'.`)
+      logger.critical(
+        ErrorCode.FUNCTION_METADATA_NOT_FOUND,
+        `No function metadata found for '${pikkuFuncName}'.`
+      )
       return
     }
     const inputSchema = fnMeta.inputs?.[0] || null
@@ -93,6 +107,18 @@ export const addMCPTool: AddWiring = (
     // --- 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] = {
@@ -105,6 +131,7 @@ export const addMCPTool: AddWiring = (
       inputSchema,
       outputSchema,
       middleware,
+      permissions,
     }
   }
 }

package/src/add/add-middleware.ts

@@ -6,6 +6,8 @@ import {
 } from '../utils/extract-function-name.js'
 import { extractServicesFromFunction } from '../utils/extract-services.js'
 import { extractMiddlewarePikkuNames } from '../utils/middleware.js'
+import { getPropertyValue } from '../utils/get-property-value.js'
+import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 
 /**
  * Inspect pikkuMiddleware calls, addMiddleware calls, and addHTTPMiddleware calls
@@ -22,28 +24,62 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
 
   // Handle pikkuMiddleware(...) - individual middleware function definition
   if (expression.text === 'pikkuMiddleware') {
-    const handlerNode = args[0]
-    if (!handlerNode) return
-
-    if (
-      !ts.isArrowFunction(handlerNode) &&
-      !ts.isFunctionExpression(handlerNode)
-    ) {
+    const arg = args[0]
+    if (!arg) return
+
+    let actualHandler: ts.ArrowFunction | ts.FunctionExpression
+    let name: string | undefined
+    let description: string | undefined
+
+    // Check if using object syntax: pikkuMiddleware({ func: ..., name: '...', description: '...' })
+    if (ts.isObjectLiteralExpression(arg)) {
+      // Extract name and description metadata
+      const nameValue = getPropertyValue(arg, 'name')
+      const descValue = getPropertyValue(arg, 'description')
+      name = typeof nameValue === 'string' ? nameValue : undefined
+      description = typeof descValue === 'string' ? descValue : undefined
+
+      // Extract the func property
+      const fnProp = getPropertyAssignmentInitializer(
+        arg,
+        'func',
+        true,
+        checker
+      )
+      if (
+        !fnProp ||
+        (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))
+      ) {
+        logger.error(
+          `• pikkuMiddleware object missing required 'func' property.`
+        )
+        return
+      }
+      actualHandler = fnProp
+    } else if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+      actualHandler = arg
+    } else {
       logger.error(`• Handler for pikkuMiddleware is not a function.`)
       return
     }
 
-    const services = extractServicesFromFunction(handlerNode)
-    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker)
+    const services = extractServicesFromFunction(actualHandler)
+    const { pikkuFuncName, exportedName } = extractFunctionName(
+      node,
+      checker,
+      state.rootDir
+    )
     state.middleware.meta[pikkuFuncName] = {
       services,
       sourceFile: node.getSourceFile().fileName,
       position: node.getStart(),
       exportedName,
+      name,
+      description,
     }
 
     logger.debug(
-      `• Found middleware with services: ${services.services.join(', ')}`
+      `• Found middleware with services: ${services.services.join(', ')}${name ? ` (name: ${name})` : ''}${description ? ` (description: ${description})` : ''}`
     )
     return
   }
@@ -63,6 +99,7 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
 
     // Extract services by looking inside the factory function body
     // The factory should return pikkuMiddleware(...), so we need to find that call
+    // If no wrapper is found, extract from the factory's returned function directly
     let services = { optimized: false, services: [] as string[] }
 
     const findPikkuMiddlewareCall = (
@@ -86,9 +123,29 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
       ) {
         services = extractServicesFromFunction(middlewareHandler)
       }
+    } else {
+      // No pikkuMiddleware wrapper found - extract from factory's return value directly
+      // Factory pattern: (config) => (services, interaction, next) => { ... }
+      if (
+        ts.isArrowFunction(factoryNode) ||
+        ts.isFunctionExpression(factoryNode)
+      ) {
+        const factoryBody = factoryNode.body
+        // Check if the body is an arrow function (direct return)
+        if (
+          ts.isArrowFunction(factoryBody) ||
+          ts.isFunctionExpression(factoryBody)
+        ) {
+          services = extractServicesFromFunction(factoryBody)
+        }
+      }
     }
 
-    const { pikkuFuncName, exportedName } = extractFunctionName(node, checker)
+    const { pikkuFuncName, exportedName } = extractFunctionName(
+      node,
+      checker,
+      state.rootDir
+    )
     state.middleware.meta[pikkuFuncName] = {
       services,
       sourceFile: node.getSourceFile().fileName,
@@ -135,7 +192,8 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     // Extract middleware pikkuFuncNames from array
     const middlewareNames = extractMiddlewarePikkuNames(
       middlewareArrayArg,
-      checker
+      checker,
+      state.rootDir
     )
 
     if (middlewareNames.length === 0) {
@@ -182,7 +240,7 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
 
     // If not a factory, get export name from the call expression itself
     if (!isFactory) {
-      const extracted = extractFunctionName(node, checker)
+      const extracted = extractFunctionName(node, checker, state.rootDir)
       exportedName = extracted.exportedName
     }
 
@@ -245,7 +303,8 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     // Extract middleware pikkuFuncNames from array
     const middlewareNames = extractMiddlewarePikkuNames(
       middlewareArrayArg,
-      checker
+      checker,
+      state.rootDir
     )
 
     if (middlewareNames.length === 0) {
@@ -293,7 +352,7 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
 
     // If not a factory, get export name from the call expression itself
     if (!isFactory) {
-      const extracted = extractFunctionName(node, checker)
+      const extracted = extractFunctionName(node, checker, state.rootDir)
       exportedName = extracted.exportedName
     }