@pikku/inspector 0.11.2 → 0.12.1

package/src/add/add-keyed-wiring.ts

@@ -0,0 +1,151 @@
+import * as ts from 'typescript'
+import { getPropertyValue } from '../utils/get-property-value.js'
+import type { AddWiring, InspectorState } from '../types.js'
+import { ErrorCode } from '../error-codes.js'
+import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
+
+export interface KeyedWiringConfig {
+  functionName: string
+  idField: string
+  label: string
+  schemaPrefix: string
+  getState: (state: InspectorState) => {
+    definitions: any[]
+    files: Set<string>
+  }
+}
+
+export const createAddKeyedWiring = (config: KeyedWiringConfig): AddWiring => {
+  return (logger, node, checker, state, _options) => {
+    if (!ts.isCallExpression(node)) {
+      return
+    }
+
+    const args = node.arguments
+    const firstArg = args[0]
+    const expression = node.expression
+
+    if (
+      !ts.isIdentifier(expression) ||
+      expression.text !== config.functionName
+    ) {
+      return
+    }
+
+    if (!firstArg) {
+      return
+    }
+
+    if (ts.isObjectLiteralExpression(firstArg)) {
+      const obj = firstArg
+
+      const nameValue = getPropertyValue(obj, 'name') as string | null
+      const displayNameValue = getPropertyValue(obj, 'displayName') as
+        | string
+        | null
+      const descriptionValue = getPropertyValue(obj, 'description') as
+        | string
+        | null
+      const idValue = getPropertyValue(obj, config.idField) as string | null
+
+      let schemaVariableName: string | null = null
+      let schemaSourceFile: string | null = null
+      let schemaIdentifier: ts.Identifier | null = null
+      for (const prop of obj.properties) {
+        if (
+          ts.isPropertyAssignment(prop) &&
+          ts.isIdentifier(prop.name) &&
+          prop.name.text === 'schema'
+        ) {
+          if (ts.isIdentifier(prop.initializer)) {
+            schemaVariableName = prop.initializer.text
+            schemaIdentifier = prop.initializer
+
+            const symbol = checker.getSymbolAtLocation(prop.initializer)
+            if (symbol) {
+              const decl = symbol.valueDeclaration || symbol.declarations?.[0]
+              if (decl) {
+                if (ts.isImportSpecifier(decl)) {
+                  const aliasedSymbol = checker.getAliasedSymbol(symbol)
+                  if (aliasedSymbol) {
+                    const aliasedDecl =
+                      aliasedSymbol.valueDeclaration ||
+                      aliasedSymbol.declarations?.[0]
+                    if (aliasedDecl) {
+                      schemaSourceFile = aliasedDecl.getSourceFile().fileName
+                    }
+                  }
+                } else {
+                  schemaSourceFile = decl.getSourceFile().fileName
+                }
+              }
+            }
+          }
+          break
+        }
+      }
+
+      if (!nameValue) {
+        logger.critical(
+          ErrorCode.MISSING_NAME,
+          `${config.label} is missing the required 'name' property.`
+        )
+        return
+      }
+
+      if (!displayNameValue) {
+        logger.critical(
+          ErrorCode.MISSING_NAME,
+          `${config.label} '${nameValue}' is missing the required 'displayName' property.`
+        )
+        return
+      }
+
+      if (!idValue) {
+        logger.critical(
+          ErrorCode.MISSING_NAME,
+          `${config.label} '${nameValue}' is missing the required '${config.idField}' property.`
+        )
+        return
+      }
+
+      if (!schemaVariableName || !schemaSourceFile || !schemaIdentifier) {
+        logger.critical(
+          ErrorCode.MISSING_NAME,
+          `${config.label} '${nameValue}' is missing the required 'schema' property or schema is not a variable reference.`
+        )
+        return
+      }
+
+      const sourceFile = node.getSourceFile().fileName
+
+      const wiringState = config.getState(state)
+      wiringState.files.add(sourceFile)
+
+      const vendor = detectSchemaVendorOrError(
+        schemaIdentifier,
+        checker,
+        logger,
+        `${config.label} '${nameValue}'`,
+        schemaSourceFile
+      )
+      if (!vendor) return
+
+      const schemaLookupName = `${config.schemaPrefix}_${nameValue}`
+      state.schemaLookup.set(schemaLookupName, {
+        variableName: schemaVariableName,
+        sourceFile: schemaSourceFile,
+        vendor,
+      })
+
+      wiringState.definitions.push({
+        name: nameValue,
+        displayName: displayNameValue,
+        description: descriptionValue || undefined,
+        [config.idField]: idValue,
+        schema: schemaLookupName,
+        sourceFile,
+      })
+    }
+  }
+}

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

@@ -5,8 +5,11 @@ import {
 } 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 type { AddWiring } from '../types.js'
+import {
+  extractFunctionName,
+  makeContextBasedId,
+} 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'
@@ -40,12 +43,10 @@ export const addMCPPrompt: AddWiring = (
     const obj = firstArg
 
     const nameValue = getPropertyValue(obj, 'name') as string | null
-    const { tags, summary, description, errors } = getCommonWireMetaData(
-      obj,
-      'MCP prompt',
-      nameValue,
-      logger
-    )
+    const { disabled, tags, summary, description, errors } =
+      getCommonWireMetaData(obj, 'MCP prompt', nameValue, logger)
+
+    if (disabled) return
 
     const funcInitializer = getPropertyAssignmentInitializer(
       obj,
@@ -61,14 +62,24 @@ export const addMCPPrompt: AddWiring = (
       return
     }
 
-    const pikkuFuncName = extractFunctionName(
+    const extracted = extractFunctionName(
       funcInitializer,
       checker,
       state.rootDir
-    ).pikkuFuncName
+    )
+    let pikkuFuncId = extracted.pikkuFuncId
+    if (pikkuFuncId.startsWith('__temp_') && nameValue) {
+      pikkuFuncId = makeContextBasedId('mcp', 'prompt', nameValue)
+    }
 
-    // Ensure function metadata exists (creates stub for inline functions)
-    ensureFunctionMetadata(state, pikkuFuncName, nameValue || undefined)
+    ensureFunctionMetadata(
+      state,
+      pikkuFuncId,
+      nameValue || undefined,
+      funcInitializer,
+      checker,
+      extracted.isHelper
+    )
 
     if (!nameValue) {
       logger.critical(
@@ -87,11 +98,11 @@ export const addMCPPrompt: AddWiring = (
     }
 
     // lookup existing function metadata
-    const fnMeta = state.functions.meta[pikkuFuncName]
+    const fnMeta = state.functions.meta[pikkuFuncId]
     if (!fnMeta) {
       logger.critical(
         ErrorCode.FUNCTION_METADATA_NOT_FOUND,
-        `No function metadata found for '${pikkuFuncName}'.`
+        `No function metadata found for '${pikkuFuncId}'.`
       )
       return
     }
@@ -105,7 +116,7 @@ export const addMCPPrompt: AddWiring = (
     const permissions = resolvePermissions(state, obj, tags, checker)
 
     // --- track used functions/middleware/permissions for service aggregation ---
-    state.serviceAggregation.usedFunctions.add(pikkuFuncName)
+    state.serviceAggregation.usedFunctions.add(pikkuFuncId)
     extractWireNames(middleware).forEach((name) =>
       state.serviceAggregation.usedMiddleware.add(name)
     )
@@ -116,7 +127,7 @@ export const addMCPPrompt: AddWiring = (
     state.mcpEndpoints.files.add(node.getSourceFile().fileName)
 
     state.mcpEndpoints.promptsMeta[nameValue] = {
-      pikkuFuncName,
+      pikkuFuncId,
       name: nameValue,
       description,
       summary,

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

@@ -5,8 +5,11 @@ import {
 } 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 type { AddWiring } from '../types.js'
+import {
+  extractFunctionName,
+  makeContextBasedId,
+} 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'
@@ -41,12 +44,11 @@ export const addMCPResource: AddWiring = (
 
     const uriValue = getPropertyValue(obj, 'uri') as string | null
     const titleValue = getPropertyValue(obj, 'title') as string | null
-    const { tags, summary, description, errors } = getCommonWireMetaData(
-      obj,
-      'MCP resource',
-      uriValue,
-      logger
-    )
+    const { disabled, tags, summary, description, errors } =
+      getCommonWireMetaData(obj, 'MCP resource', uriValue, logger)
+
+    if (disabled) return
+
     const streamingValue = getPropertyValue(obj, 'streaming') as boolean | null
 
     if (streamingValue === true) {
@@ -69,14 +71,24 @@ export const addMCPResource: AddWiring = (
       return
     }
 
-    const pikkuFuncName = extractFunctionName(
+    const extracted = extractFunctionName(
       funcInitializer,
       checker,
       state.rootDir
-    ).pikkuFuncName
+    )
+    let pikkuFuncId = extracted.pikkuFuncId
+    if (pikkuFuncId.startsWith('__temp_') && uriValue) {
+      pikkuFuncId = makeContextBasedId('mcp', 'resource', uriValue)
+    }
 
-    // Ensure function metadata exists (creates stub for inline functions)
-    ensureFunctionMetadata(state, pikkuFuncName, uriValue || undefined)
+    ensureFunctionMetadata(
+      state,
+      pikkuFuncId,
+      uriValue || undefined,
+      funcInitializer,
+      checker,
+      extracted.isHelper
+    )
 
     if (!uriValue) {
       logger.critical(
@@ -103,11 +115,11 @@ export const addMCPResource: AddWiring = (
     }
 
     // lookup existing function metadata
-    const fnMeta = state.functions.meta[pikkuFuncName]
+    const fnMeta = state.functions.meta[pikkuFuncId]
     if (!fnMeta) {
       logger.critical(
         ErrorCode.FUNCTION_METADATA_NOT_FOUND,
-        `No function metadata found for '${pikkuFuncName}'.`
+        `No function metadata found for '${pikkuFuncId}'.`
       )
       return
     }
@@ -121,7 +133,7 @@ export const addMCPResource: AddWiring = (
     const permissions = resolvePermissions(state, obj, tags, checker)
 
     // --- track used functions/middleware/permissions for service aggregation ---
-    state.serviceAggregation.usedFunctions.add(pikkuFuncName)
+    state.serviceAggregation.usedFunctions.add(pikkuFuncId)
     extractWireNames(middleware).forEach((name) =>
       state.serviceAggregation.usedMiddleware.add(name)
     )
@@ -132,7 +144,7 @@ export const addMCPResource: AddWiring = (
     state.mcpEndpoints.files.add(node.getSourceFile().fileName)
 
     state.mcpEndpoints.resourcesMeta[uriValue] = {
-      pikkuFuncName,
+      pikkuFuncId,
       uri: uriValue,
       title: titleValue,
       description,