@pikku/inspector 0.12.1 → 0.12.3

package/src/add/add-channel.ts

@@ -18,6 +18,8 @@ import {
 } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
 import { resolveIdentifier } from '../utils/resolve-identifier.js'
+import { resolveFunctionMeta } from '../utils/resolve-function-meta.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js'
 
 /**
@@ -92,6 +94,13 @@ function getHandlerNameFromExpression(
 
   // Handle call expressions
   if (ts.isCallExpression(expr)) {
+    // Handle addon('namespace:funcName') calls
+    if (ts.isIdentifier(expr.expression) && expr.expression.text === 'addon') {
+      const [firstArg] = expr.arguments
+      if (firstArg && ts.isStringLiteral(firstArg)) {
+        return firstArg.text
+      }
+    }
     const { pikkuFuncId } = extractFunctionName(expr, checker, rootDir)
     return pikkuFuncId
   }
@@ -460,11 +469,11 @@ export function addMessagesRoutes(
         continue
       }
 
-      const fnMeta = state.functions.meta[handlerName]
+      const fnMeta = resolveFunctionMeta(state, handlerName)
       if (!fnMeta) {
         logger.critical(
           ErrorCode.FUNCTION_METADATA_NOT_FOUND,
-          `No function metadata found for handler '${handlerName}'`
+          `No function metadata found for channel handler '${handlerName}' on route '${routeKey}'. If this is an inline function, it must be exported for the inspector to discover it.`
         )
         continue
       }
@@ -478,8 +487,17 @@ export function addMessagesRoutes(
         ? resolveMiddleware(state, init, routeTags, checker)
         : undefined
 
+      // Resolve package name for addon functions (e.g. 'swaggerPetstore:addPet')
+      const colonIdx = handlerName.indexOf(':')
+      const addonNs =
+        colonIdx !== -1 ? handlerName.substring(0, colonIdx) : null
+      const packageName = addonNs
+        ? state.rpc.wireAddonDeclarations.get(addonNs)?.package
+        : undefined
+
       result[channelKey]![routeKey] = {
         pikkuFuncId: handlerName,
+        packageName,
         middleware: routeMiddleware,
       }
     }
@@ -527,6 +545,7 @@ export const addChannel: AddWiring = (
   if (disabled) return
 
   const query = getPropertyValue(obj, 'query') as string[] | []
+  const binary = getPropertyValue(obj, 'binary') as boolean | undefined
 
   const connect = getPropertyAssignmentInitializer(
     obj,
@@ -563,8 +582,12 @@ export const addChannel: AddWiring = (
       )
       return
     }
+    const msgPackageName = ts.isIdentifier(onMsgProp)
+      ? resolveAddonName(onMsgProp, checker, state.rpc.wireAddonDeclarations)
+      : null
     message = {
       pikkuFuncId: msgFuncId,
+      ...(msgPackageName && { packageName: msgPackageName }),
     }
   }
 
@@ -578,15 +601,20 @@ export const addChannel: AddWiring = (
   // --- track used functions/middleware for service aggregation ---
   // Track connect/disconnect/message handlers
   let connectFuncId: string | undefined
+  let connectPackageName: string | null = null
   if (connect) {
     const extracted = extractFunctionName(connect, checker, state.rootDir)
     connectFuncId = extracted.pikkuFuncId.startsWith('__temp_')
       ? makeContextBasedId('channel', name, 'connect')
       : extracted.pikkuFuncId
+    connectPackageName = ts.isIdentifier(connect)
+      ? resolveAddonName(connect, checker, state.rpc.wireAddonDeclarations)
+      : null
     state.serviceAggregation.usedFunctions.add(connectFuncId)
   }
 
   let disconnectFuncId: string | undefined
+  let disconnectPackageName: string | null = null
   if (disconnect) {
     const extracted = extractFunctionName(
       disconnect as any,
@@ -596,6 +624,9 @@ export const addChannel: AddWiring = (
     disconnectFuncId = extracted.pikkuFuncId.startsWith('__temp_')
       ? makeContextBasedId('channel', name, 'disconnect')
       : extracted.pikkuFuncId
+    disconnectPackageName = ts.isIdentifier(disconnect)
+      ? resolveAddonName(disconnect, checker, state.rpc.wireAddonDeclarations)
+      : null
     state.serviceAggregation.usedFunctions.add(disconnectFuncId)
   }
 
@@ -620,13 +651,7 @@ export const addChannel: AddWiring = (
   ].filter(Boolean) as string[]
   for (const funcId of handlersToValidate) {
     if (
-      !validateAuthSessionless(
-        logger,
-        obj,
-        state,
-        funcId,
-        `Channel '${name}'`
-      )
+      !validateAuthSessionless(logger, obj, state, funcId, `Channel '${name}'`)
     ) {
       return
     }
@@ -639,10 +664,21 @@ export const addChannel: AddWiring = (
     input: null,
     params: params.length ? params : undefined,
     query: query?.length ? query : undefined,
-    connect: connectFuncId ? { pikkuFuncId: connectFuncId } : null,
-    disconnect: disconnectFuncId ? { pikkuFuncId: disconnectFuncId } : null,
+    connect: connectFuncId
+      ? {
+          pikkuFuncId: connectFuncId,
+          ...(connectPackageName && { packageName: connectPackageName }),
+        }
+      : null,
+    disconnect: disconnectFuncId
+      ? {
+          pikkuFuncId: disconnectFuncId,
+          ...(disconnectPackageName && { packageName: disconnectPackageName }),
+        }
+      : null,
     message,
     messageWirings,
+    binary: binary === undefined ? undefined : binary,
     summary,
     description,
     errors,

package/src/add/add-cli.ts

@@ -7,11 +7,16 @@ import type {
   InspectorState,
 } from '../types.js'
 import type { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
-import { extractFunctionName } from '../utils/extract-function-name.js'
+import {
+  extractFunctionName,
+  makeContextBasedId,
+} from '../utils/extract-function-name.js'
 import { resolveMiddleware } from '../utils/middleware.js'
+import { resolveFunctionMeta } from '../utils/resolve-function-meta.js'
 import { extractWireNames } from '../utils/post-process.js'
 import { getPropertyValue } from '../utils/get-property-value.js'
 import { resolveIdentifier } from '../utils/resolve-identifier.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js'
 
 // Track if we've warned about missing Config type to avoid duplicate warnings
@@ -153,14 +158,18 @@ function processCLIConfig(
         }
         break
 
-      case 'render':
-        // Extract the actual renderer function name
-        programMeta.defaultRenderName = extractFunctionName(
+      case 'render': {
+        let renderFuncId = extractFunctionName(
           prop.initializer,
           typeChecker,
           inspectorState.rootDir
         ).pikkuFuncId
+        if (renderFuncId.startsWith('__temp_')) {
+          renderFuncId = makeContextBasedId('cli-render', programName)
+        }
+        programMeta.defaultRenderName = renderFuncId
         break
+      }
     }
   }
 
@@ -273,12 +282,16 @@ function processCommand(
     ts.isArrowFunction(node) ||
     ts.isFunctionExpression(node)
   ) {
+    let pikkuFuncId = extractFunctionName(
+      node,
+      typeChecker,
+      inspectorState.rootDir
+    ).pikkuFuncId
+    if (pikkuFuncId.startsWith('__temp_')) {
+      pikkuFuncId = makeContextBasedId('cli', programName, ...fullPath)
+    }
     return {
-      pikkuFuncId: extractFunctionName(
-        node,
-        typeChecker,
-        inspectorState.rootDir
-      ).pikkuFuncId,
+      pikkuFuncId,
       positionals: [],
       options: {},
     }
@@ -333,12 +346,53 @@ function processCommand(
     const propName = prop.name.text
 
     if (propName === 'func') {
-      pikkuFuncId = extractFunctionName(
-        prop.initializer,
-        typeChecker,
-        inspectorState.rootDir
-      ).pikkuFuncId
-      meta.pikkuFuncId = pikkuFuncId
+      if (
+        ts.isCallExpression(prop.initializer) &&
+        ts.isIdentifier(prop.initializer.expression) &&
+        prop.initializer.expression.text === 'addon'
+      ) {
+        const [firstArg] = prop.initializer.arguments
+        if (!firstArg || !ts.isStringLiteral(firstArg)) {
+          throw new Error(
+            `addon() call requires a string literal argument in the form "namespace:funcName"`
+          )
+        }
+        pikkuFuncId = firstArg.text
+        const addonNamespace = pikkuFuncId.split(':')[0]
+        if (!addonNamespace || !pikkuFuncId.includes(':')) {
+          throw new Error(
+            `Malformed addon function ID "${pikkuFuncId}": expected "namespace:funcName" format`
+          )
+        }
+        if (!inspectorState.rpc.wireAddonDeclarations.has(addonNamespace)) {
+          throw new Error(
+            `Unknown addon namespace "${addonNamespace}" in "${pikkuFuncId}": no matching wireAddonDeclarations entry found`
+          )
+        }
+        meta.pikkuFuncId = pikkuFuncId
+        meta.packageName =
+          inspectorState.rpc.wireAddonDeclarations.get(addonNamespace)!.package
+      } else {
+        pikkuFuncId = extractFunctionName(
+          prop.initializer,
+          typeChecker,
+          inspectorState.rootDir
+        ).pikkuFuncId
+        if (pikkuFuncId.startsWith('__temp_')) {
+          pikkuFuncId = makeContextBasedId('cli', programName, ...fullPath)
+        }
+        meta.pikkuFuncId = pikkuFuncId
+        const cliPackageName = ts.isIdentifier(prop.initializer)
+          ? resolveAddonName(
+              prop.initializer,
+              typeChecker,
+              inspectorState.rpc.wireAddonDeclarations
+            )
+          : null
+        if (cliPackageName) {
+          meta.packageName = cliPackageName
+        }
+      }
     } else if (
       propName === 'options' &&
       ts.isObjectLiteralExpression(prop.initializer)
@@ -393,13 +447,22 @@ function processCommand(
         // Already handled in first pass
         break
 
-      case 'render':
-        meta.renderName = extractFunctionName(
+      case 'render': {
+        let renderFuncId = extractFunctionName(
           prop.initializer,
           typeChecker,
           inspectorState.rootDir
         ).pikkuFuncId
+        if (renderFuncId.startsWith('__temp_')) {
+          renderFuncId = makeContextBasedId(
+            'cli-render',
+            programName,
+            ...fullPath
+          )
+        }
+        meta.renderName = renderFuncId
         break
+      }
 
       case 'options':
         // Process with pikkuFuncId from first pass
@@ -550,22 +613,31 @@ function processOptions(
       }
 
       // Extract enum values from the function input type if available
-      // Get the input type if we have a pikkuFuncId
-      let inputTypes: ts.Type[] | undefined
+      let derivedChoices: string[] | null = null
+
       if (pikkuFuncId) {
-        inputTypes = inspectorState.typesLookup.get(pikkuFuncId)
-      }
+        // 1. Try TypeScript types first (most precise — handles unions, TS enums)
+        const inputTypes = inspectorState.typesLookup.get(pikkuFuncId)
+        if (inputTypes && inputTypes.length > 0) {
+          derivedChoices = extractEnumFromPropertyType(
+            inputTypes[0]!,
+            optionName,
+            typeChecker
+          )
+        }
 
-      let derivedChoices: string[] | null = null
+        // 2. Fallback: try JSON schema (works for addon functions)
+        if (!derivedChoices) {
+          derivedChoices = extractEnumFromJsonSchema(
+            inspectorState,
+            pikkuFuncId,
+            optionName
+          )
+        }
+      }
 
-      if (inputTypes && inputTypes.length > 0) {
-        derivedChoices = extractEnumFromPropertyType(
-          inputTypes[0]!,
-          optionName,
-          typeChecker
-        )
-      } else {
-        // Fallback: try to extract from Config type
+      // 3. Last resort: try Config type
+      if (!derivedChoices) {
         derivedChoices = extractEnumFromConfigType(
           logger,
           optionName,
@@ -727,6 +799,44 @@ function extractEnumFromConfigType(
   return extractEnumFromPropertyType(configType, propertyName, typeChecker)
 }
 
+/**
+ * Extracts enum values from the function's JSON schema.
+ * Works for addon functions whose schemas are generated from OpenAPI/Zod.
+ */
+function extractEnumFromJsonSchema(
+  inspectorState: InspectorState,
+  pikkuFuncId: string,
+  propertyName: string
+): string[] | null {
+  const fnMeta = resolveFunctionMeta(inspectorState, pikkuFuncId)
+  if (!fnMeta?.inputSchemaName) return null
+
+  const schema = inspectorState.schemas[fnMeta.inputSchemaName] as any
+  if (!schema?.properties?.[propertyName]) return null
+
+  const prop = schema.properties[propertyName]
+
+  // Direct enum on property
+  if (prop.enum && Array.isArray(prop.enum)) {
+    const strings = prop.enum.filter((v: unknown) => typeof v === 'string')
+    if (strings.length > 0) return strings
+  }
+
+  // Array with enum items (e.g. z.array(z.enum([...])))
+  if (
+    prop.type === 'array' &&
+    prop.items?.enum &&
+    Array.isArray(prop.items.enum)
+  ) {
+    const strings = prop.items.enum.filter(
+      (v: unknown) => typeof v === 'string'
+    )
+    if (strings.length > 0) return strings
+  }
+
+  return null
+}
+
 /**
  * Gets the property name from a property assignment
  */

package/src/add/add-file-with-factory.ts

@@ -9,6 +9,7 @@ const wrapperFunctionMap: Record<string, string> = {
   pikkuServices: 'CreateSingletonServices',
   pikkuAddonServices: 'CreateSingletonServices',
   pikkuWireServices: 'CreateWireServices',
+  pikkuAddonWireServices: 'CreateWireServices',
 }
 
 export const addFileWithFactory = (

package/src/add/add-functions.ts

@@ -339,7 +339,8 @@ export const addFunctions: AddWiring = (
   let remote: boolean | undefined
   let mcp: boolean | undefined
   let readonly_: boolean | undefined
-  let requiresApproval: boolean | undefined
+  let approvalRequired: boolean | undefined
+  let approvalDescription: string | undefined
   let version: number | undefined
   let objectNode: ts.ObjectLiteralExpression | undefined
   let nodeDisplayName: string | null = null
@@ -421,10 +422,33 @@ export const addFunctions: AddWiring = (
     remote = getPropertyValue(firstArg, 'remote') as boolean | undefined
     mcp = getPropertyValue(firstArg, 'mcp') as boolean | undefined
     readonly_ = getPropertyValue(firstArg, 'readonly') as boolean | undefined
-    requiresApproval = getPropertyValue(firstArg, 'requiresApproval') as
+    approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
 
+    // Extract approvalDescription identifier reference
+    for (const prop of firstArg.properties) {
+      if (
+        ts.isPropertyAssignment(prop) &&
+        ts.isIdentifier(prop.name) &&
+        prop.name.text === 'approvalDescription' &&
+        ts.isIdentifier(prop.initializer)
+      ) {
+        const { pikkuFuncId: descId } = extractFunctionName(
+          prop.initializer,
+          checker,
+          state.rootDir
+        )
+        if (descId && !descId.startsWith('__temp_')) {
+          approvalDescription = descId
+        } else {
+          // Try resolving the identifier directly
+          approvalDescription = prop.initializer.text
+        }
+        break
+      }
+    }
+
     const versionRaw = getPropertyValue(firstArg, 'version')
     if (versionRaw !== null && versionRaw !== undefined) {
       const parsed = Number(versionRaw)
@@ -759,7 +783,8 @@ export const addFunctions: AddWiring = (
     remote: remote || undefined,
     mcp: mcpEnabled || undefined,
     readonly: readonly_ || undefined,
-    requiresApproval: requiresApproval || undefined,
+    approvalRequired: approvalRequired || undefined,
+    approvalDescription: approvalDescription || undefined,
     version,
     title,
     tags: tags || undefined,

package/src/add/add-gateway.ts

@@ -0,0 +1,101 @@
+import * as ts from 'typescript'
+import {
+  getPropertyValue,
+  getCommonWireMetaData,
+} from '../utils/get-property-value.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 { extractWireNames } from '../utils/post-process.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
+import type { GatewayTransportType } from '@pikku/core/gateway'
+
+import { ErrorCode } from '../error-codes.js'
+
+export const addGateway: AddWiring = (
+  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 !== 'wireGateway') {
+    return
+  }
+
+  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) {
+    return
+  }
+
+  const obj = firstArg
+
+  const nameValue = getPropertyValue(obj, 'name') as string | null
+  const typeValue = getPropertyValue(obj, 'type') as GatewayTransportType | null
+  const routeValue = getPropertyValue(obj, 'route') as string | undefined
+  const { disabled, tags, summary, description, errors } =
+    getCommonWireMetaData(obj, 'Gateway', nameValue, logger)
+
+  if (disabled) return
+
+  const funcInitializer = getPropertyAssignmentInitializer(
+    obj,
+    'func',
+    true,
+    checker
+  )
+  if (!funcInitializer) {
+    logger.critical(
+      ErrorCode.MISSING_FUNC,
+      `No valid 'func' property for gateway '${nameValue}'.`
+    )
+    return
+  }
+
+  const extracted = extractFunctionName(funcInitializer, checker, state.rootDir)
+  let pikkuFuncId = extracted.pikkuFuncId
+  if (pikkuFuncId.startsWith('__temp_') && nameValue) {
+    pikkuFuncId = makeContextBasedId('gateway', nameValue)
+  }
+
+  const packageName = ts.isIdentifier(funcInitializer)
+    ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+    : null
+
+  if (!nameValue || !typeValue) {
+    return
+  }
+
+  const middleware = resolveMiddleware(state, obj, tags, checker)
+
+  state.serviceAggregation.usedFunctions.add(pikkuFuncId)
+  extractWireNames(middleware).forEach((name) =>
+    state.serviceAggregation.usedMiddleware.add(name)
+  )
+
+  state.gateways.files.add(node.getSourceFile().fileName)
+  state.gateways.meta[nameValue] = {
+    pikkuFuncId,
+    ...(packageName && { packageName }),
+    name: nameValue,
+    type: typeValue,
+    route: routeValue,
+    gateway: true,
+    summary,
+    description,
+    errors,
+    tags,
+    middleware,
+  }
+}

package/src/add/add-http-route.ts

@@ -21,6 +21,7 @@ import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
 import { ErrorCode } from '../error-codes.js'
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js'
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 
 import type { InspectorLogger } from '../types.js'
 
@@ -203,6 +204,10 @@ export function registerHTTPRoute({
     funcName = makeContextBasedId('http', method, fullRoute)
   }
 
+  const packageName = ts.isIdentifier(funcInitializer)
+    ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+    : null
+
   ensureFunctionMetadata(
     state,
     funcName,
@@ -320,6 +325,7 @@ export function registerHTTPRoute({
   state.http.files.add(sourceFile.fileName)
   state.http.meta[method][fullRoute] = {
     pikkuFuncId: funcName,
+    ...(packageName && { packageName }),
     route: fullRoute,
     method: method as HTTPMethod,
     params: params.length > 0 ? params : undefined,

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

@@ -13,6 +13,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { resolvePermissions } from '../utils/permissions.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { ErrorCode } from '../error-codes.js'
 
 export const addMCPPrompt: AddWiring = (
@@ -72,6 +73,10 @@ export const addMCPPrompt: AddWiring = (
       pikkuFuncId = makeContextBasedId('mcp', 'prompt', nameValue)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     ensureFunctionMetadata(
       state,
       pikkuFuncId,
@@ -128,6 +133,7 @@ export const addMCPPrompt: AddWiring = (
 
     state.mcpEndpoints.promptsMeta[nameValue] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       name: nameValue,
       description,
       summary,

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

@@ -13,6 +13,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { resolvePermissions } from '../utils/permissions.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { ErrorCode } from '../error-codes.js'
 
 export const addMCPResource: AddWiring = (
@@ -81,6 +82,10 @@ export const addMCPResource: AddWiring = (
       pikkuFuncId = makeContextBasedId('mcp', 'resource', uriValue)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     ensureFunctionMetadata(
       state,
       pikkuFuncId,
@@ -145,6 +150,7 @@ export const addMCPResource: AddWiring = (
 
     state.mcpEndpoints.resourcesMeta[uriValue] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       uri: uriValue,
       title: titleValue,
       description,

package/src/add/add-queue-worker.ts

@@ -11,6 +11,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { ErrorCode } from '../error-codes.js'
 
 export const addQueueWorker: AddWiring = (logger, node, checker, state) => {
@@ -65,6 +66,10 @@ export const addQueueWorker: AddWiring = (logger, node, checker, state) => {
       pikkuFuncId = makeContextBasedId('queue', name)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     if (!name) {
       logger.critical(
         ErrorCode.MISSING_QUEUE_NAME,
@@ -85,6 +90,7 @@ export const addQueueWorker: AddWiring = (logger, node, checker, state) => {
     state.queueWorkers.files.add(node.getSourceFile().fileName)
     state.queueWorkers.meta[name] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       name,
       summary,
       description,

package/src/add/add-schedule.ts

@@ -11,6 +11,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 
 import { ErrorCode } from '../error-codes.js'
 export const addSchedule: AddWiring = (
@@ -71,6 +72,10 @@ export const addSchedule: AddWiring = (
       pikkuFuncId = makeContextBasedId('scheduler', nameValue)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     if (!nameValue || !scheduleValue) {
       return
     }
@@ -87,6 +92,7 @@ export const addSchedule: AddWiring = (
     state.scheduledTasks.files.add(node.getSourceFile().fileName)
     state.scheduledTasks.meta[nameValue] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       name: nameValue,
       schedule: scheduleValue,
       summary,