@pikku/inspector 0.12.21 → 0.12.23

package/src/utils/extract-node-value.ts

@@ -37,8 +37,8 @@ export function extractStringLiteral(
     node.operatorToken.kind === ts.SyntaxKind.PlusToken
   ) {
     return (
-      extractStringLiteral(node.left, checker) +
-      extractStringLiteral(node.right, checker)
+      extractConcatOperand(node.left, checker) +
+      extractConcatOperand(node.right, checker)
     )
   }
 
@@ -59,6 +59,23 @@ export function extractStringLiteral(
   throw new Error('Unable to extract string literal from node')
 }
 
+/**
+ * Resolve one operand of a `+` string concatenation.
+ *
+ * An operand that can't be statically resolved (e.g. `a ?? b`) becomes a
+ * `${...}` placeholder rather than throwing — mirroring the TemplateExpression
+ * branch above, so `'x ' + expr` and `` `x ${expr}` `` produce the same string.
+ * This keeps an unresolvable display name from aborting the whole extraction.
+ */
+function extractConcatOperand(node: ts.Node, checker: ts.TypeChecker): string {
+  try {
+    return extractStringLiteral(node, checker)
+  } catch {
+    const inner = ts.isParenthesizedExpression(node) ? node.expression : node
+    return '${' + inner.getText() + '}'
+  }
+}
+
 /**
  * Check if node is string-like (string literal or template expression)
  */

package/src/utils/filter-inspector-state.test.ts

@@ -344,6 +344,7 @@ const mockLogger = {
   error: () => {},
   warn: () => {},
   debug: () => {},
+  diagnostic: () => {},
   critical: () => {},
   hasCriticalErrors: () => false,
 }

package/src/utils/filter-utils.test.ts

@@ -10,6 +10,7 @@ describe('matchesFilters', () => {
     error: () => {},
     warn: () => {},
     debug: () => {},
+    diagnostic: () => {},
     critical: () => {},
     hasCriticalErrors: () => false,
   }

package/src/utils/get-exported-variable-name.ts

@@ -0,0 +1,48 @@
+import * as ts from 'typescript'
+
+const isExportedVariableStatement = (
+  statement: ts.Statement
+): statement is ts.VariableStatement =>
+  ts.isVariableStatement(statement) &&
+  (statement.modifiers?.some(
+    (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword
+  ) ??
+    false)
+
+export const getExportedVariableName = (
+  node: ts.Node,
+  sourceFile: ts.SourceFile | undefined
+): string | null => {
+  if (!sourceFile) {
+    return null
+  }
+
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+    for (const statement of sourceFile.statements) {
+      if (!isExportedVariableStatement(statement)) continue
+      for (const declaration of statement.declarationList.declarations) {
+        if (declaration === node) {
+          return node.name.text
+        }
+      }
+    }
+  }
+
+  if (!ts.isCallExpression(node)) {
+    return null
+  }
+
+  for (const statement of sourceFile.statements) {
+    if (!isExportedVariableStatement(statement)) continue
+    for (const declaration of statement.declarationList.declarations) {
+      if (
+        ts.isIdentifier(declaration.name) &&
+        declaration.initializer === node
+      ) {
+        return declaration.name.text
+      }
+    }
+  }
+
+  return null
+}

package/src/utils/load-addon-functions-meta.ts

@@ -2,6 +2,121 @@ import { readFile, readdir } from 'fs/promises'
 import { createRequire } from 'module'
 import { join, dirname } from 'path'
 import type { InspectorState, InspectorLogger } from '../types.js'
+import type {
+  ExportedChannelContractsMeta,
+  ExportedHTTPRouteConfigMeta,
+  ExportedHTTPRouteEntryMeta,
+  ExportedHTTPRoutesGroupMeta,
+  ExportedCLIContractsMeta,
+  ExportedHTTPContractsMeta,
+  ExportedHTTPRouteMapMeta,
+} from '../types.js'
+
+const isHTTPRouteConfig = (
+  value: ExportedHTTPRouteEntryMeta
+): value is ExportedHTTPRouteConfigMeta =>
+  typeof value === 'object' &&
+  value !== null &&
+  'method' in value &&
+  'func' in value &&
+  'route' in value
+
+const isHTTPRouteGroup = (
+  value: ExportedHTTPRouteEntryMeta
+): value is ExportedHTTPRoutesGroupMeta =>
+  typeof value === 'object' &&
+  value !== null &&
+  'routes' in value &&
+  !('method' in value)
+
+const applyPackageToHTTPRouteMap = (
+  routes: ExportedHTTPRouteMapMeta,
+  packageName: string,
+  namespace?: string
+) => {
+  for (const value of Object.values(routes)) {
+    if (!value || typeof value !== 'object') continue
+    if (isHTTPRouteConfig(value)) {
+      if (!value.func.packageName) {
+        value.func.packageName = packageName
+      }
+      if (namespace && !value.func.pikkuFuncId.includes(':')) {
+        value.func.pikkuFuncId = `${namespace}:${value.func.pikkuFuncId}`
+      }
+      continue
+    }
+    if (isHTTPRouteGroup(value)) {
+      applyPackageToHTTPRouteMap(value.routes, packageName, namespace)
+      continue
+    }
+    applyPackageToHTTPRouteMap(
+      value as ExportedHTTPRouteMapMeta,
+      packageName,
+      namespace
+    )
+  }
+}
+
+const applyPackageToHTTPContracts = (
+  contracts: ExportedHTTPContractsMeta,
+  packageName: string,
+  namespace: string
+) => {
+  for (const contract of Object.values(contracts)) {
+    applyPackageToHTTPRouteMap(contract.routes, packageName, namespace)
+  }
+}
+
+const applyPackageToCLICommands = (
+  commands: Record<string, any>,
+  packageName: string,
+  namespace?: string
+) => {
+  for (const command of Object.values(commands)) {
+    if (command && typeof command === 'object') {
+      if (!command.packageName && command.pikkuFuncId) {
+        command.packageName = packageName
+      }
+      if (
+        namespace &&
+        typeof command.pikkuFuncId === 'string' &&
+        !command.pikkuFuncId.includes(':')
+      ) {
+        command.pikkuFuncId = `${namespace}:${command.pikkuFuncId}`
+      }
+      if (command.subcommands) {
+        applyPackageToCLICommands(command.subcommands, packageName, namespace)
+      }
+    }
+  }
+}
+
+const applyPackageToCLIContracts = (
+  contracts: ExportedCLIContractsMeta,
+  packageName: string,
+  namespace: string
+) => {
+  for (const commands of Object.values(contracts)) {
+    applyPackageToCLICommands(commands, packageName, namespace)
+  }
+}
+
+const applyPackageToChannelContracts = (
+  contracts: ExportedChannelContractsMeta,
+  packageName: string,
+  namespace: string
+) => {
+  for (const routes of Object.values(contracts)) {
+    for (const route of Object.values(routes)) {
+      if (!route.packageName) {
+        route.packageName = packageName
+      }
+      if (!route.pikkuFuncId.includes(':')) {
+        route.pikkuFuncId = `${namespace}:${route.pikkuFuncId}`
+      }
+    }
+  }
+}
 
 /**
  * After the setup sweep discovers wireAddon() declarations, load each addon
@@ -104,6 +219,55 @@ export async function loadAddonFunctionsMeta(
       } catch {
         // No services gen — addon may not have requiredParentServices
       }
+
+      try {
+        const httpContractsPath = require.resolve(
+          `${decl.package}/.pikku/http/pikku-http-contracts-meta.gen.json`
+        )
+        const httpContractsRaw = await readFile(httpContractsPath, 'utf-8')
+        const httpContracts = JSON.parse(
+          httpContractsRaw
+        ) as ExportedHTTPContractsMeta
+        applyPackageToHTTPContracts(httpContracts, decl.package, namespace)
+        state.exportedContracts.addonHttp[namespace] = httpContracts
+      } catch {
+        // No addon HTTP contracts metadata
+      }
+
+      try {
+        const cliContractsPath = require.resolve(
+          `${decl.package}/.pikku/cli/pikku-cli-contracts-meta.gen.json`
+        )
+        const cliContractsRaw = await readFile(cliContractsPath, 'utf-8')
+        const cliContracts = JSON.parse(
+          cliContractsRaw
+        ) as ExportedCLIContractsMeta
+        applyPackageToCLIContracts(cliContracts, decl.package, namespace)
+        state.exportedContracts.addonCli[namespace] = cliContracts
+      } catch {
+        // No addon CLI contracts metadata
+      }
+
+      try {
+        const channelContractsPath = require.resolve(
+          `${decl.package}/.pikku/channel/pikku-channel-contracts-meta.gen.json`
+        )
+        const channelContractsRaw = await readFile(
+          channelContractsPath,
+          'utf-8'
+        )
+        const channelContracts = JSON.parse(
+          channelContractsRaw
+        ) as ExportedChannelContractsMeta
+        applyPackageToChannelContracts(
+          channelContracts,
+          decl.package,
+          namespace
+        )
+        state.exportedContracts.addonChannel[namespace] = channelContracts
+      } catch {
+        // No addon channel contracts metadata
+      }
     } catch (error: any) {
       logger.warn(
         `Failed to load addon function metadata for '${namespace}' (${decl.package}): ${error.message}`

package/src/utils/resolve-addon-package.ts

@@ -80,7 +80,12 @@ export const resolveAddonName = (
   // Bare package import path
   if (candidatePackage && !candidatePackage.startsWith('.')) {
     for (const addonDecl of wireAddonDeclarations.values()) {
-      if (addonDecl.package === candidatePackage) return addonDecl.package
+      if (
+        addonDecl.package === candidatePackage ||
+        candidatePackage.startsWith(`${addonDecl.package}/`)
+      ) {
+        return addonDecl.package
+      }
     }
   }
 

package/src/utils/resolve-ref-contract.ts

@@ -0,0 +1,71 @@
+import * as ts from 'typescript'
+
+export interface RefContractResolution<T> {
+  contract: T
+  /**
+   * Optional basePath override supplied by the consumer via the second
+   * argument, e.g. refHTTP('ns:routes', { basePath: '/ext' }). When undefined
+   * the addon contract's own basePath is preserved.
+   */
+  basePath?: string
+}
+
+const getStringProperty = (
+  obj: ts.ObjectLiteralExpression,
+  name: string
+): string | undefined => {
+  for (const prop of obj.properties) {
+    if (
+      ts.isPropertyAssignment(prop) &&
+      (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) &&
+      prop.name.text === name &&
+      ts.isStringLiteral(prop.initializer)
+    ) {
+      return prop.initializer.text
+    }
+  }
+  return undefined
+}
+
+/**
+ * Resolve a refHTTP / refChannel / refCLI call expression against the addon
+ * contracts already loaded (and namespaced) by loadAddonFunctionsMeta.
+ *
+ * The first string argument has the form 'namespace:contractName', mirroring
+ * how ref('namespace:fn') references an addon function. Detection is purely
+ * syntactic — no import resolution is required because the namespace and
+ * contract name are carried in the string literal. An optional second object
+ * argument may override mount details such as basePath.
+ */
+export const resolveRefContract = <T>(
+  node: ts.Node,
+  helperName: 'refHTTP' | 'refChannel' | 'refCLI',
+  addonContracts: Record<string, Record<string, T>>
+): RefContractResolution<T> | null => {
+  if (!ts.isCallExpression(node)) return null
+  if (
+    !ts.isIdentifier(node.expression) ||
+    node.expression.text !== helperName
+  ) {
+    return null
+  }
+
+  const [arg, optionsArg] = node.arguments
+  if (!arg || !ts.isStringLiteral(arg)) return null
+
+  const separator = arg.text.indexOf(':')
+  if (separator === -1) return null
+
+  const namespace = arg.text.slice(0, separator)
+  const contractName = arg.text.slice(separator + 1)
+
+  const contract = addonContracts[namespace]?.[contractName]
+  if (contract === undefined) return null
+
+  let basePath: string | undefined
+  if (optionsArg && ts.isObjectLiteralExpression(optionsArg)) {
+    basePath = getStringProperty(optionsArg, 'basePath')
+  }
+
+  return { contract, basePath }
+}

package/src/utils/resolve-versions.test.ts

@@ -43,6 +43,7 @@ function makeLogger() {
       info: () => {},
       warn: () => {},
       error: (msg: string) => errors.push(msg),
+      diagnostic: ({ message }: { message: string }) => errors.push(message),
       critical: (_code: string, msg: string) => errors.push(msg),
     },
     errors,

package/src/utils/serialize-inspector-state.ts

@@ -263,6 +263,7 @@ export interface SerializableInspectorState {
   openAPISpec: Record<string, any> | null
   diagnostics: InspectorDiagnostic[]
   addonFunctions: InspectorState['addonFunctions']
+  exportedContracts: InspectorState['exportedContracts']
 }
 
 /**
@@ -443,6 +444,7 @@ export function serializeInspectorState(
     openAPISpec: state.openAPISpec,
     diagnostics: state.diagnostics,
     addonFunctions: state.addonFunctions,
+    exportedContracts: state.exportedContracts,
   }
 }
 
@@ -630,6 +632,14 @@ export function deserializeInspectorState(
     openAPISpec: data.openAPISpec || null,
     diagnostics: data.diagnostics || [],
     addonFunctions: data.addonFunctions || {},
+    exportedContracts: data.exportedContracts || {
+      http: {},
+      cli: {},
+      channel: {},
+      addonHttp: {},
+      addonCli: {},
+      addonChannel: {},
+    },
     program: null,
   }
 }

package/src/utils/workflow/dsl/extract-dsl-workflow.ts

@@ -386,6 +386,22 @@ function extractVariableDeclaration(
         return step
       }
     }
+
+    // Promise.all fanout/group captured into a variable
+    // (const results = await Promise.all(array.map(...)))
+    if (isParallelFanout(call) || isParallelGroup(call)) {
+      const step = isParallelFanout(call)
+        ? extractParallelFanout(call, context)
+        : extractParallelGroup(call, context)
+      if (step) {
+        const type = context.checker.getTypeAtLocation(decl)
+        context.outputVars.set(varName, { type, node: decl })
+        if (isArrayType(type, context.checker)) {
+          context.arrayVars.add(varName)
+        }
+        return step
+      }
+    }
   }
 
   // Check for array.filter(...)

package/src/visit.ts

@@ -3,6 +3,7 @@ import { addFileWithFactory } from './add/add-file-with-factory.js'
 import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js'
 import { addHTTPRoute } from './add/add-http-route.js'
 import { addHTTPRoutes } from './add/add-http-routes.js'
+import { checkAddonBans } from './add/add-addon-bans.js'
 import { addSchedule } from './add/add-schedule.js'
 import { addTrigger } from './add/add-trigger.js'
 import { addQueueWorker } from './add/add-queue-worker.js'
@@ -106,27 +107,33 @@ export const visitRoutes = (
   state: InspectorState,
   options: InspectorOptions
 ) => {
-  addFunctions(logger, node, checker, state, options)
-  addAuth(logger, node, checker, state, options)
-  addSecret(logger, node, checker, state, options)
-  addCredential(logger, node, checker, state, options)
-  addVariable(logger, node, checker, state, options)
+  const nextOptions = ts.isSourceFile(node)
+    ? { ...options, sourceFile: node }
+    : options
 
-  addHTTPRoute(logger, node, checker, state, options)
-  addHTTPRoutes(logger, node, checker, state, options)
-  addSchedule(logger, node, checker, state, options)
-  addTrigger(logger, node, checker, state, options)
-  addQueueWorker(logger, node, checker, state, options)
-  addChannel(logger, node, checker, state, options)
-  addGateway(logger, node, checker, state, options)
-  addCLI(logger, node, checker, state, options)
-  addCLIRenderers(logger, node, checker, state, options)
-  addMCPResource(logger, node, checker, state, options)
-  addMCPPrompt(logger, node, checker, state, options)
-  addWorkflowGraph(logger, node, checker, state, options)
-  addAIAgent(logger, node, checker, state, options)
+  checkAddonBans(logger, node, checker, state, nextOptions)
+
+  addFunctions(logger, node, checker, state, nextOptions)
+  addAuth(logger, node, checker, state, nextOptions)
+  addSecret(logger, node, checker, state, nextOptions)
+  addCredential(logger, node, checker, state, nextOptions)
+  addVariable(logger, node, checker, state, nextOptions)
+
+  addHTTPRoute(logger, node, checker, state, nextOptions)
+  addHTTPRoutes(logger, node, checker, state, nextOptions)
+  addSchedule(logger, node, checker, state, nextOptions)
+  addTrigger(logger, node, checker, state, nextOptions)
+  addQueueWorker(logger, node, checker, state, nextOptions)
+  addChannel(logger, node, checker, state, nextOptions)
+  addGateway(logger, node, checker, state, nextOptions)
+  addCLI(logger, node, checker, state, nextOptions)
+  addCLIRenderers(logger, node, checker, state, nextOptions)
+  addMCPResource(logger, node, checker, state, nextOptions)
+  addMCPPrompt(logger, node, checker, state, nextOptions)
+  addWorkflowGraph(logger, node, checker, state, nextOptions)
+  addAIAgent(logger, node, checker, state, nextOptions)
 
   ts.forEachChild(node, (child) =>
-    visitRoutes(logger, checker, child, state, options)
+    visitRoutes(logger, checker, child, state, nextOptions)
   )
 }