@pikku/inspector 0.12.74 → 0.12.81

package/src/add/add-cli.ts

@@ -1,1006 +0,0 @@
-import type { TypeChecker } from 'typescript'
-import ts from 'typescript'
-import type {
-  AddWiring,
-  InspectorLogger,
-  InspectorOptions,
-  InspectorState,
-} from '../types.js'
-import type { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
-import {
-  extractFunctionName,
-  makeContextBasedId,
-} from '../utils/extract-function-name.js'
-import { resolveCoreType } from '../utils/resolve-core-type.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'
-import { extractServicesFromFunction } from '../utils/extract-services.js'
-import { getExportedVariableName } from '../utils/get-exported-variable-name.js'
-import { resolveRefContract } from '../utils/resolve-ref-contract.js'
-
-// Track if we've warned about missing Config type to avoid duplicate warnings
-const configTypeWarningShown = new Set<string>()
-
-/**
- * Adds CLI command metadata to the inspector state
- */
-export const addCLI: AddWiring = (
-  logger,
-  node,
-  typeChecker,
-  inspectorState,
-  options
-) => {
-  if (!ts.isCallExpression(node)) return
-  if (
-    ts.isIdentifier(node.expression) &&
-    node.expression.text === 'defineCLICommands'
-  ) {
-    const exportName = getExportedVariableName(node, options.sourceFile)
-    const [firstArg] = node.arguments
-    if (exportName && firstArg && ts.isObjectLiteralExpression(firstArg)) {
-      inspectorState.exportedContracts.cli[exportName] = processCommands(
-        logger,
-        firstArg,
-        node.getSourceFile(),
-        typeChecker,
-        exportName,
-        inspectorState,
-        options
-      )
-    }
-    return
-  }
-  // Check if this is a wireCLI call
-  if (!node || !node.expression) {
-    return
-  }
-  const expression = node.expression
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireCLI') {
-    return
-  }
-
-  // Get the argument (should be an object literal)
-  if (node.arguments.length !== 1) {
-    return
-  }
-
-  const arg = node.arguments[0]
-  if (!ts.isObjectLiteralExpression(arg)) {
-    return
-  }
-
-  const sourceFile = node.getSourceFile()
-
-  // Add to files set
-  inspectorState.cli.files.add(sourceFile.fileName)
-
-  // Process the CLI configuration
-  const cliConfig = processCLIConfig(
-    logger,
-    arg,
-    sourceFile,
-    typeChecker,
-    inspectorState,
-    options
-  )
-
-  if (!cliConfig) {
-    return
-  }
-
-  // Add this program to the CLI metadata
-  inspectorState.cli.meta.programs[cliConfig.programName] =
-    cliConfig.programMeta
-}
-
-/**
- * Processes a CLI configuration object
- */
-function processCLIConfig(
-  logger: InspectorLogger,
-  node: ts.ObjectLiteralExpression,
-  sourceFile: ts.SourceFile,
-  typeChecker: TypeChecker,
-  inspectorState: InspectorState,
-  options: InspectorOptions
-): { programName: string; programMeta: CLIProgramMeta } | null {
-  let programName = ''
-  let programTags: string[] | undefined
-  const programMeta: CLIProgramMeta = {
-    program: '',
-    commands: {},
-    options: {},
-  }
-
-  // First pass: extract program name and tags
-  for (const prop of node.properties) {
-    if (!ts.isPropertyAssignment(prop)) continue
-    if (!ts.isIdentifier(prop.name)) continue
-
-    const propName = prop.name.text
-
-    if (propName === 'program' && ts.isStringLiteral(prop.initializer)) {
-      programName = prop.initializer.text
-      programMeta.program = programName
-    } else if (propName === 'tags') {
-      programTags = (getPropertyValue(node, 'tags') as string[]) || undefined
-    }
-  }
-
-  if (!programName) {
-    return null
-  }
-
-  if (getPropertyValue(node, 'disabled') === true) {
-    return null
-  }
-
-  // Second pass: process other properties with program tags available
-  for (const prop of node.properties) {
-    if (!ts.isPropertyAssignment(prop)) continue
-    if (!ts.isIdentifier(prop.name)) continue
-
-    const propName = prop.name.text
-
-    switch (propName) {
-      case 'program':
-      case 'tags':
-        // Already handled in first pass
-        break
-
-      case 'auth': {
-        const value = getPropertyValue(node, 'auth')
-        if (typeof value === 'boolean') {
-          programMeta.auth = value
-        }
-        break
-      }
-
-      case 'commands':
-        if (ts.isObjectLiteralExpression(prop.initializer)) {
-          programMeta.commands = processCommands(
-            logger,
-            prop.initializer,
-            sourceFile,
-            typeChecker,
-            programName,
-            inspectorState,
-            options,
-            programTags
-          )
-        }
-        break
-
-      case 'options':
-        if (ts.isObjectLiteralExpression(prop.initializer)) {
-          programMeta.options = processOptions(
-            logger,
-            prop.initializer,
-            typeChecker,
-            inspectorState,
-            options
-          )
-        }
-        break
-
-      case 'render': {
-        let renderFuncId = extractFunctionName(
-          prop.initializer,
-          typeChecker,
-          inspectorState.rootDir
-        ).pikkuFuncId
-        if (renderFuncId.startsWith('__temp_')) {
-          renderFuncId = makeContextBasedId('cli-render', programName)
-        }
-        programMeta.defaultRenderName = renderFuncId
-        break
-      }
-    }
-  }
-
-  return { programName, programMeta }
-}
-
-/**
- * Processes the commands object
- */
-function processCommands(
-  logger: InspectorLogger,
-  node: ts.ObjectLiteralExpression,
-  sourceFile: ts.SourceFile,
-  typeChecker: TypeChecker,
-  programName: string,
-  inspectorState: InspectorState,
-  options: InspectorOptions,
-  programTags?: string[]
-): Record<string, CLICommandMeta> {
-  const commands: Record<string, CLICommandMeta> = {}
-  let defaultCommandName: string | null = null
-
-  for (const prop of node.properties) {
-    // Handle spread assignments: { ...externalCommands }
-    if (ts.isSpreadAssignment(prop)) {
-      let spreadTarget: ts.Node | undefined = prop.expression
-      if (ts.isIdentifier(prop.expression)) {
-        spreadTarget = resolveIdentifier(prop.expression, typeChecker, [
-          'defineCLICommands',
-        ])
-      }
-      if (spreadTarget && ts.isObjectLiteralExpression(spreadTarget)) {
-        const spreadCommands = processCommands(
-          logger,
-          spreadTarget,
-          sourceFile,
-          typeChecker,
-          programName,
-          inspectorState,
-          options,
-          programTags
-        )
-        Object.assign(commands, spreadCommands)
-      } else {
-        const refCommands = resolveRefContract(
-          prop.expression,
-          'refCLI',
-          inspectorState.exportedContracts.addonCli
-        )
-        if (refCommands) {
-          Object.assign(commands, refCommands.contract)
-        }
-      }
-      continue
-    }
-
-    if (!ts.isPropertyAssignment(prop)) continue
-
-    const commandName = getPropertyName(prop)
-    if (!commandName) continue
-
-    const commandMeta = processCommand(
-      logger,
-      inspectorState,
-      options,
-      commandName,
-      prop.initializer,
-      sourceFile,
-      typeChecker,
-      programName,
-      [],
-      programTags
-    )
-
-    if (commandMeta) {
-      commands[commandName] = commandMeta
-
-      // Validate only one default command
-      if (commandMeta.isDefault) {
-        if (defaultCommandName !== null) {
-          const position = prop.getStart(sourceFile)
-          const { line, character } =
-            sourceFile.getLineAndCharacterOfPosition(position)
-
-          throw new Error(
-            `Multiple default commands found in CLI program "${programName}" at ${sourceFile.fileName}:${line + 1}:${character + 1}.\n` +
-              `Commands "${defaultCommandName}" and "${commandName}" are both marked as default.\n` +
-              `Only one command can be marked as default per program.`
-          )
-        }
-        defaultCommandName = commandName
-      }
-    }
-  }
-
-  return commands
-}
-
-/**
- * Processes a single command
- */
-function processCommand(
-  logger: InspectorLogger,
-  inspectorState: InspectorState,
-  options: InspectorOptions,
-  name: string,
-  node: ts.Expression,
-  sourceFile: ts.SourceFile,
-  typeChecker: TypeChecker,
-  programName: string,
-  parentPath: string[] = [],
-  programTags?: string[]
-): CLICommandMeta | null {
-  const fullPath = [...parentPath, name]
-
-  // Handle shorthand (just a function)
-  if (
-    ts.isIdentifier(node) ||
-    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,
-      positionals: [],
-      options: {},
-    }
-  }
-
-  // Handle pikkuCLICommand calls
-  if (ts.isCallExpression(node)) {
-    // Check if it's a pikkuCLICommand call
-    if (
-      ts.isIdentifier(node.expression) &&
-      node.expression.text === 'pikkuCLICommand' &&
-      node.arguments.length > 0 &&
-      ts.isObjectLiteralExpression(node.arguments[0])
-    ) {
-      // Process the object literal argument
-      return processCommand(
-        logger,
-        inspectorState,
-        options,
-        name,
-        node.arguments[0],
-        sourceFile,
-        typeChecker,
-        programName,
-        parentPath,
-        programTags
-      )
-    }
-    return null
-  }
-
-  // Handle full command object
-  if (!ts.isObjectLiteralExpression(node)) {
-    return null
-  }
-
-  const meta: CLICommandMeta = {
-    pikkuFuncId: '',
-    positionals: [],
-    options: {},
-  }
-
-  // First pass: extract pikkuFuncId and tags so we can use them when processing options/middleware
-  let pikkuFuncId: string | undefined
-  let optionsNode: ts.ObjectLiteralExpression | undefined
-  let tags: string[] | undefined
-
-  for (const prop of node.properties) {
-    if (!ts.isPropertyAssignment(prop)) continue
-    if (!ts.isIdentifier(prop.name)) continue
-
-    const propName = prop.name.text
-
-    if (propName === 'func') {
-      if (
-        ts.isCallExpression(prop.initializer) &&
-        ts.isIdentifier(prop.initializer.expression) &&
-        prop.initializer.expression.text === 'ref'
-      ) {
-        const [firstArg] = prop.initializer.arguments
-        if (!firstArg || !ts.isStringLiteral(firstArg)) {
-          throw new Error(`ref() call requires a string literal argument`)
-        }
-        pikkuFuncId = firstArg.text
-        const addonNamespace = pikkuFuncId.includes(':')
-          ? pikkuFuncId.split(':')[0]
-          : null
-        if (addonNamespace) {
-          if (!inspectorState.rpc.wireAddonDeclarations.has(addonNamespace)) {
-            throw new Error(
-              `Unknown addon namespace "${addonNamespace}" in "${pikkuFuncId}": no matching wireAddonDeclarations entry found`
-            )
-          }
-        }
-        meta.pikkuFuncId = pikkuFuncId
-        if (addonNamespace) {
-          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)
-    ) {
-      optionsNode = prop.initializer
-    } else if (propName === 'tags') {
-      tags = (getPropertyValue(node, 'tags') as string[]) || undefined
-    }
-  }
-
-  // Merge program-level tags with command-level tags
-  const allTags = [...(programTags || []), ...(tags || [])]
-
-  // Resolve middleware
-  const middleware = resolveMiddleware(
-    inspectorState,
-    node,
-    allTags.length > 0 ? allTags : undefined,
-    typeChecker
-  )
-  if (middleware) {
-    meta.middleware = middleware
-  }
-
-  // Add merged tags to metadata
-  if (allTags.length > 0) {
-    meta.tags = allTags
-  }
-
-  // Second pass: process all properties
-  for (const prop of node.properties) {
-    if (!ts.isPropertyAssignment(prop)) continue
-    if (!ts.isIdentifier(prop.name)) continue
-
-    const propName = prop.name.text
-
-    switch (propName) {
-      case 'parameters':
-        if (ts.isStringLiteral(prop.initializer)) {
-          meta.parameters = prop.initializer.text
-          meta.positionals = parseCommandPattern(prop.initializer.text)
-        }
-        break
-
-      case 'description':
-        if (ts.isStringLiteral(prop.initializer)) {
-          meta.description = prop.initializer.text
-        }
-        break
-
-      case 'func':
-        // Already handled in first pass
-        break
-
-      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
-        if (optionsNode) {
-          meta.options = processOptions(
-            logger,
-            optionsNode,
-            typeChecker,
-            inspectorState,
-            options,
-            pikkuFuncId
-          )
-        }
-        break
-
-      case 'subcommands': {
-        let subcommandsNode: ts.Node | undefined = prop.initializer
-        if (ts.isIdentifier(prop.initializer)) {
-          subcommandsNode = resolveIdentifier(prop.initializer, typeChecker, [
-            'defineCLICommands',
-          ])
-        }
-        if (subcommandsNode && ts.isObjectLiteralExpression(subcommandsNode)) {
-          meta.subcommands = {}
-          for (const subProp of subcommandsNode.properties) {
-            if (!ts.isPropertyAssignment(subProp)) continue
-
-            const subName = getPropertyName(subProp)
-            if (!subName) continue
-
-            const subCommand = processCommand(
-              logger,
-              inspectorState,
-              options,
-              subName,
-              subProp.initializer,
-              sourceFile,
-              typeChecker,
-              programName,
-              fullPath,
-              programTags
-            )
-
-            if (subCommand) {
-              meta.subcommands[subName] = subCommand
-            }
-          }
-        }
-        break
-      }
-
-      case 'isDefault':
-        if (
-          prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
-          prop.initializer.kind === ts.SyntaxKind.FalseKeyword
-        ) {
-          meta.isDefault = prop.initializer.kind === ts.SyntaxKind.TrueKeyword
-        }
-        break
-    }
-  }
-
-  // --- validate auth/sessionless ---
-  if (
-    meta.pikkuFuncId &&
-    !validateAuthSessionless(
-      logger,
-      node,
-      inspectorState,
-      meta.pikkuFuncId,
-      `CLI command '${name}'`
-    )
-  ) {
-    return null
-  }
-
-  // --- track used functions/middleware for service aggregation ---
-  inspectorState.serviceAggregation.usedFunctions.add(meta.pikkuFuncId)
-  extractWireNames(meta.middleware).forEach((name) =>
-    inspectorState.serviceAggregation.usedMiddleware.add(name)
-  )
-
-  return meta
-}
-
-/**
- * Processes CLI options and extracts enum values from function input types
- */
-function processOptions(
-  logger: InspectorLogger,
-  node: ts.ObjectLiteralExpression,
-  typeChecker: TypeChecker,
-  inspectorState: InspectorState,
-  inspectorOptions: InspectorOptions,
-  pikkuFuncId?: string
-): Record<string, any> {
-  const options: Record<string, any> = {}
-
-  for (const prop of node.properties) {
-    if (!ts.isPropertyAssignment(prop)) continue
-
-    const optionName = getPropertyName(prop)
-    if (!optionName) continue
-
-    if (ts.isObjectLiteralExpression(prop.initializer)) {
-      const option: any = {}
-      let manualChoices: string[] | undefined
-
-      for (const optProp of prop.initializer.properties) {
-        if (!ts.isPropertyAssignment(optProp)) continue
-        if (!ts.isIdentifier(optProp.name)) continue
-
-        const optPropName = optProp.name.text
-
-        switch (optPropName) {
-          case 'description':
-            if (ts.isStringLiteral(optProp.initializer)) {
-              option.description = optProp.initializer.text
-            }
-            break
-
-          case 'short':
-            if (ts.isStringLiteral(optProp.initializer)) {
-              option.short = optProp.initializer.text
-            }
-            break
-
-          case 'type':
-            if (ts.isStringLiteral(optProp.initializer)) {
-              option.type = optProp.initializer.text
-            }
-            break
-
-          case 'default':
-            // Extract default value from expression
-            if (ts.isStringLiteral(optProp.initializer)) {
-              option.default = optProp.initializer.text
-            } else if (ts.isNumericLiteral(optProp.initializer)) {
-              option.default = parseFloat(optProp.initializer.text)
-            } else if (optProp.initializer.kind === ts.SyntaxKind.TrueKeyword) {
-              option.default = true
-            } else if (
-              optProp.initializer.kind === ts.SyntaxKind.FalseKeyword
-            ) {
-              option.default = false
-            }
-            break
-
-          case 'choices':
-            // Extract manually specified choices
-            if (ts.isArrayLiteralExpression(optProp.initializer)) {
-              manualChoices = []
-              for (const element of optProp.initializer.elements) {
-                if (ts.isStringLiteral(element)) {
-                  manualChoices.push(element.text)
-                }
-              }
-            }
-            break
-        }
-      }
-
-      // Extract enum values from the function input type if available
-      let derivedChoices: string[] | null = null
-
-      if (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
-          )
-        }
-
-        // 2. Fallback: try JSON schema (works for addon functions)
-        if (!derivedChoices) {
-          derivedChoices = extractEnumFromJsonSchema(
-            inspectorState,
-            pikkuFuncId,
-            optionName
-          )
-        }
-      }
-
-      // 3. Last resort: try Config type
-      if (!derivedChoices) {
-        derivedChoices = extractEnumFromConfigType(
-          logger,
-          optionName,
-          typeChecker,
-          inspectorState,
-          inspectorOptions
-        )
-      }
-
-      // Validate and set choices
-      if (manualChoices && derivedChoices) {
-        // Both manual and derived choices exist - validate manual is subset of derived
-        const invalidChoices = manualChoices.filter(
-          (choice) => !derivedChoices!.includes(choice)
-        )
-
-        if (invalidChoices.length > 0) {
-          const sourceFile = node.getSourceFile()
-          const position = prop.getStart(sourceFile)
-          const { line, character } =
-            sourceFile.getLineAndCharacterOfPosition(position)
-
-          throw new Error(
-            `Invalid choices for option "${optionName}" at ${sourceFile.fileName}:${line + 1}:${character + 1}.\n` +
-              `The following choices are not valid according to the type: ${invalidChoices.join(', ')}.\n` +
-              `Valid choices from type: ${derivedChoices.join(', ')}.`
-          )
-        }
-
-        // Manual choices are valid - use them
-        option.choices = manualChoices
-      } else if (manualChoices) {
-        // Only manual choices - use them
-        option.choices = manualChoices
-      } else if (derivedChoices) {
-        // Only derived choices - use them
-        option.choices = derivedChoices
-      }
-
-      options[optionName] = option
-    }
-  }
-
-  return options
-}
-
-/**
- * Extracts enum values from a property of a type
- * Handles both union types ('a' | 'b') and TypeScript enums
- */
-function extractEnumFromPropertyType(
-  type: ts.Type,
-  propertyName: string,
-  typeChecker: TypeChecker
-): string[] | null {
-  // Get the property from the type
-  const property = type.getProperty(propertyName)
-  if (!property) {
-    return null
-  }
-
-  // Get the type of the property
-  const propertyType = typeChecker.getTypeOfSymbolAtLocation(
-    property,
-    property.valueDeclaration!
-  )
-
-  const enumValues: string[] = []
-
-  // Check if it's a union type (e.g., 'debug' | 'info' | 'warn')
-  if (propertyType.isUnion()) {
-    for (const unionType of propertyType.types) {
-      // Check if it's a string literal type
-      if (unionType.flags & ts.TypeFlags.StringLiteral) {
-        const literalType = unionType as ts.StringLiteralType
-        enumValues.push(literalType.value)
-      }
-      // Check if it's an enum member (could be string or number enum)
-      else if (unionType.flags & ts.TypeFlags.EnumLiteral) {
-        const enumLiteralType = unionType as ts.LiteralType
-        // For string enums, use the value directly
-        if (typeof enumLiteralType.value === 'string') {
-          enumValues.push(enumLiteralType.value)
-        }
-        // For numeric enums, get the symbol name (e.g., "Debug", "Info")
-        else {
-          const symbol = (unionType as any).symbol
-          if (symbol && symbol.name) {
-            enumValues.push(symbol.name)
-          }
-        }
-      }
-    }
-  }
-  // Check if it's an enum type directly
-  else if (propertyType.flags & ts.TypeFlags.Enum) {
-    const symbol = propertyType.getSymbol()
-    if (symbol && symbol.exports) {
-      symbol.exports.forEach((member) => {
-        const memberType = typeChecker.getTypeOfSymbolAtLocation(
-          member,
-          member.valueDeclaration!
-        )
-        if (memberType.flags & ts.TypeFlags.StringLiteral) {
-          const literalType = memberType as ts.StringLiteralType
-          enumValues.push(literalType.value)
-        } else if (typeof (memberType as any).value === 'string') {
-          enumValues.push((memberType as any).value)
-        }
-      })
-    }
-  }
-  // Check if it's an enum literal type
-  else if (propertyType.flags & ts.TypeFlags.EnumLiteral) {
-    const enumLiteralType = propertyType as ts.LiteralType
-    if (typeof enumLiteralType.value === 'string') {
-      enumValues.push(enumLiteralType.value)
-    }
-  }
-
-  return enumValues.length > 0 ? enumValues : null
-}
-
-/**
- * Extracts enum values from the Config type
- */
-function extractEnumFromConfigType(
-  logger: InspectorLogger,
-  propertyName: string,
-  typeChecker: TypeChecker,
-  inspectorState: InspectorState,
-  _inspectorOptions: InspectorOptions
-): string[] | null {
-  // Look for Config type in typesLookup
-  const configType = resolveCoreType(
-    inspectorState.typesLookup,
-    inspectorState.configTypeImportMap
-  )
-  if (!configType) {
-    // Only warn once per CLI file to avoid spamming logs
-    if (!configTypeWarningShown.has('missing-config-type')) {
-      configTypeWarningShown.add('missing-config-type')
-      logger.warn(
-        `Could not find Config type in typesLookup. ` +
-          `Make sure you have a Config interface extending CoreConfig in your codebase.`
-      )
-    }
-    return null
-  }
-
-  // Extract enum from the property
-  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
- */
-function getPropertyName(prop: ts.PropertyAssignment): string | null {
-  if (ts.isIdentifier(prop.name)) {
-    return prop.name.text
-  }
-  if (ts.isStringLiteral(prop.name)) {
-    return prop.name.text
-  }
-  return null
-}
-
-/**
- * Parses a parameters string to extract positional arguments
- * Parameters format: "<env> [region] [files...]"
- */
-function parseCommandPattern(pattern: string): any[] {
-  const positionals: any[] = []
-
-  // Split by spaces to get all parameter definitions
-  const parts = pattern.split(' ').filter((p) => p.trim())
-
-  for (const part of parts) {
-    if (part.startsWith('<') && part.endsWith('>')) {
-      // Required positional
-      const name = part.slice(1, -1)
-      if (name.endsWith('...')) {
-        positionals.push({
-          name: name.slice(0, -3),
-          required: true,
-          variadic: true,
-        })
-      } else {
-        positionals.push({
-          name,
-          required: true,
-        })
-      }
-    } else if (part.startsWith('[') && part.endsWith(']')) {
-      // Optional positional
-      const name = part.slice(1, -1)
-      if (name.endsWith('...')) {
-        positionals.push({
-          name: name.slice(0, -3),
-          required: false,
-          variadic: true,
-        })
-      } else {
-        positionals.push({
-          name,
-          required: false,
-        })
-      }
-    } else if (part.trim()) {
-      // Found a literal word in the parameters pattern
-      throw new Error(
-        `Invalid parameters pattern '${pattern}': found literal word '${part}'. ` +
-          `Parameters should only contain <required> or [optional] arguments. ` +
-          `Example: "<env> [region]" or "<files...>"`
-      )
-    }
-  }
-
-  return positionals
-}
-
-/**
- * Adds CLI renderer metadata to the inspector state
- */
-export const addCLIRenderers: AddWiring = (
-  logger,
-  node,
-  typeChecker,
-  inspectorState,
-  options
-) => {
-  if (!ts.isCallExpression(node)) return
-
-  const { expression, arguments: args } = node
-
-  // Only handle pikkuCLIRender calls
-  if (!ts.isIdentifier(expression) || expression.text !== 'pikkuCLIRender') {
-    return
-  }
-
-  if (args.length === 0) return
-
-  // Extract renderer name
-  const { pikkuFuncId, exportedName } = extractFunctionName(
-    node,
-    typeChecker,
-    inspectorState.rootDir
-  )
-
-  // Get the source file path
-  const sourceFile = node.getSourceFile()
-  const filePath = sourceFile.fileName
-
-  // Renderer service usage is defined by the callback's first parameter shape,
-  // the same way function/auth service usage is tracked elsewhere in the inspector.
-  const renderFunc = args[0]
-  const services =
-    ts.isArrowFunction(renderFunc) || ts.isFunctionExpression(renderFunc)
-      ? extractServicesFromFunction(renderFunc)
-      : { optimized: true, services: [] }
-
-  // Store renderer metadata
-  inspectorState.cli.meta.renderers[pikkuFuncId] = {
-    name: pikkuFuncId,
-    exportedName: exportedName ?? undefined,
-    services,
-    filePath,
-  }
-
-  // Add to files map if exported
-  if (exportedName) {
-    inspectorState.cli.files.add(filePath)
-  }
-}