@pikku/inspector 0.9.6-next.0 → 0.10.1

package/src/add/add-cli.ts

@@ -5,11 +5,15 @@ import {
   InspectorOptions,
   InspectorState,
 } from '../types.js'
-import { CLIProgramMeta, CLICommandMeta } from '@pikku/core'
+import { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import { resolveMiddleware } from '../utils/middleware.js'
+import { extractWireNames } from '../utils/post-process.js'
 import { getPropertyValue } from '../utils/get-property-value.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
  */
@@ -60,7 +64,8 @@ export const addCLI: AddWiring = (
   }
 
   // Add this program to the CLI metadata
-  inspectorState.cli.meta[cliConfig.programName] = cliConfig.programMeta
+  inspectorState.cli.meta.programs[cliConfig.programName] =
+    cliConfig.programMeta
 }
 
 /**
@@ -75,12 +80,33 @@ function processCLIConfig(
   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
+  }
+
+  // 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
@@ -89,10 +115,8 @@ function processCLIConfig(
 
     switch (propName) {
       case 'program':
-        if (ts.isStringLiteral(prop.initializer)) {
-          programName = prop.initializer.text
-          programMeta.program = programName
-        }
+      case 'tags':
+        // Already handled in first pass
         break
 
       case 'commands':
@@ -104,7 +128,8 @@ function processCLIConfig(
             typeChecker,
             programName,
             inspectorState,
-            options
+            options,
+            programTags
           )
         }
         break
@@ -122,16 +147,16 @@ function processCLIConfig(
         break
 
       case 'render':
-        // Track that a default renderer exists
-        programMeta.defaultRenderName = 'defaultRenderer'
+        // Extract the actual renderer function name
+        programMeta.defaultRenderName = extractFunctionName(
+          prop.initializer,
+          typeChecker,
+          inspectorState.rootDir
+        ).pikkuFuncName
         break
     }
   }
 
-  if (!programName) {
-    return null
-  }
-
   return { programName, programMeta }
 }
 
@@ -145,9 +170,11 @@ function processCommands(
   typeChecker: TypeChecker,
   programName: string,
   inspectorState: InspectorState,
-  options: InspectorOptions
+  options: InspectorOptions,
+  programTags?: string[]
 ): Record<string, CLICommandMeta> {
   const commands: Record<string, CLICommandMeta> = {}
+  let defaultCommandName: string | null = null
 
   for (const prop of node.properties) {
     if (!ts.isPropertyAssignment(prop)) continue
@@ -163,11 +190,29 @@ function processCommands(
       prop.initializer,
       sourceFile,
       typeChecker,
-      programName
+      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
+      }
     }
   }
 
@@ -186,7 +231,8 @@ function processCommand(
   sourceFile: ts.SourceFile,
   typeChecker: TypeChecker,
   programName: string,
-  parentPath: string[] = []
+  parentPath: string[] = [],
+  programTags?: string[]
 ): CLICommandMeta | null {
   const fullPath = [...parentPath, name]
 
@@ -197,7 +243,11 @@ function processCommand(
     ts.isFunctionExpression(node)
   ) {
     return {
-      pikkuFuncName: extractFunctionName(node, typeChecker).pikkuFuncName,
+      pikkuFuncName: extractFunctionName(
+        node,
+        typeChecker,
+        inspectorState.rootDir
+      ).pikkuFuncName,
       positionals: [],
       options: {},
     }
@@ -222,7 +272,8 @@ function processCommand(
         sourceFile,
         typeChecker,
         programName,
-        parentPath
+        parentPath,
+        programTags
       )
     }
     return null
@@ -253,7 +304,8 @@ function processCommand(
     if (propName === 'func') {
       pikkuFuncName = extractFunctionName(
         prop.initializer,
-        typeChecker
+        typeChecker,
+        inspectorState.rootDir
       ).pikkuFuncName
       meta.pikkuFuncName = pikkuFuncName
     } else if (
@@ -266,12 +318,25 @@ function processCommand(
     }
   }
 
+  // Merge program-level tags with command-level tags
+  const allTags = [...(programTags || []), ...(tags || [])]
+
   // Resolve middleware
-  const middleware = resolveMiddleware(inspectorState, node, tags, typeChecker)
+  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
@@ -300,7 +365,8 @@ function processCommand(
       case 'render':
         meta.renderName = extractFunctionName(
           prop.initializer,
-          typeChecker
+          typeChecker,
+          inspectorState.rootDir
         ).pikkuFuncName
         break
 
@@ -336,7 +402,8 @@ function processCommand(
               sourceFile,
               typeChecker,
               programName,
-              fullPath
+              fullPath,
+              programTags
             )
 
             if (subCommand) {
@@ -345,9 +412,25 @@ function processCommand(
           }
         }
         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
     }
   }
 
+  // --- track used functions/middleware for service aggregation ---
+  inspectorState.serviceAggregation.usedFunctions.add(meta.pikkuFuncName)
+  extractWireNames(meta.middleware).forEach((name) =>
+    inspectorState.serviceAggregation.usedMiddleware.add(name)
+  )
+  // Note: subcommands are tracked recursively when they're processed
+
   return meta
 }
 
@@ -575,19 +658,24 @@ function extractEnumFromConfigType(
   // Look for Config type in typesLookup
   const configTypes = inspectorState.typesLookup.get('Config')
   if (!configTypes || configTypes.length === 0) {
-    logger.warn(
-      `Warning: Could not find Config type in typesLookup for option "${propertyName}". ` +
-        `Make sure you have a Config interface extending CoreConfig in your codebase.`
-    )
+    // 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
   }
 
   // Use the first Config type (there should only be one)
   const configType = configTypes[0]
   if (!configType) {
-    logger.warn(
-      `Warning: Config type is undefined in typesLookup for option "${propertyName}".`
-    )
+    if (!configTypeWarningShown.has('undefined-config-type')) {
+      configTypeWarningShown.add('undefined-config-type')
+      logger.warn(`Config type is undefined in typesLookup.`)
+    }
     return null
   }
 
@@ -661,3 +749,74 @@ function parseCommandPattern(pattern: string): any[] {
 
   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, typeArguments } = node
+
+  // Only handle pikkuCLIRender calls
+  if (!ts.isIdentifier(expression) || expression.text !== 'pikkuCLIRender') {
+    return
+  }
+
+  if (args.length === 0) return
+
+  // Extract renderer name
+  const { pikkuFuncName, exportedName } = extractFunctionName(
+    node,
+    typeChecker,
+    inspectorState.rootDir
+  )
+
+  // Get the source file path
+  const sourceFile = node.getSourceFile()
+  const filePath = sourceFile.fileName
+
+  // Extract services from type parameters (second type param is Services)
+  const services: { optimized: boolean; services: string[] } = {
+    optimized: true,
+    services: [],
+  }
+
+  if (typeArguments && typeArguments.length >= 2) {
+    // Second type parameter is the Services type
+    const servicesTypeNode = typeArguments[1]
+    if (servicesTypeNode) {
+      const servicesType = typeChecker.getTypeFromTypeNode(servicesTypeNode)
+
+      // Extract property names from the Services type
+      const properties = servicesType.getProperties()
+      for (const prop of properties) {
+        services.services.push(prop.getName())
+      }
+
+      // If no specific services found, it might be using the full services object
+      if (properties.length === 0) {
+        services.optimized = false
+      }
+    }
+  }
+
+  // Store renderer metadata
+  inspectorState.cli.meta.renderers[pikkuFuncName] = {
+    name: pikkuFuncName,
+    exportedName: exportedName ?? undefined,
+    services,
+    filePath,
+  }
+
+  // Add to files map if exported
+  if (exportedName) {
+    inspectorState.cli.files.add(filePath)
+  }
+}

package/src/add/add-file-extends-core-type.ts

@@ -36,11 +36,14 @@ export const addFileExtendsCoreType = (
               const variables = methods.get(fileName) || []
 
               if (!typeName) {
-                throw new Error('TODO')
+                throw new Error(
+                  `Found anonymous ${ts.isClassDeclaration(node) ? 'class' : 'interface'} extending ${expectedTypeName} in ${fileName}. ` +
+                    `Classes and interfaces that extend core types must have a name.`
+                )
               }
               variables.push({
                 variable: typeName,
-                type: typeName || null,
+                type: typeName,
                 typePath: extendedTypeDeclarationPath,
               })
               methods.set(fileName, variables)

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

@@ -1,17 +1,88 @@
 import * as ts from 'typescript'
-import { PathToNameAndType } from '../types.js'
+import { PathToNameAndType, InspectorState } from '../types.js'
+import { extractServicesFromFunction } from '../utils/extract-services.js'
+
+// Mapping of wrapper function names to their corresponding types
+const wrapperFunctionMap: Record<string, string> = {
+  pikkuConfig: 'CreateConfig',
+  pikkuServices: 'CreateSingletonServices',
+  pikkuSessionServices: 'CreateSessionServices',
+}
 
 export const addFileWithFactory = (
   node: ts.Node,
   checker: ts.TypeChecker,
   methods: PathToNameAndType = new Map(),
-  expectedTypeName: string
+  expectedTypeName: string,
+  state?: InspectorState
 ) => {
   if (ts.isVariableDeclaration(node)) {
     const fileName = node.getSourceFile().fileName
     const variableTypeNode = node.type
     const variableName = node.name.getText()
 
+    // Check for wrapper function calls FIRST (e.g., pikkuConfig(...), pikkuServices(...))
+    // This handles both cases: with and without explicit type annotations
+    if (node.initializer && ts.isCallExpression(node.initializer)) {
+      const callExpression = node.initializer
+      const expression = callExpression.expression
+
+      if (ts.isIdentifier(expression)) {
+        const wrapperFunctionName = expression.text
+        const inferredType = wrapperFunctionMap[wrapperFunctionName]
+
+        if (inferredType === expectedTypeName) {
+          // Get the type declaration path from the wrapper function
+          const typeSymbol = checker.getSymbolAtLocation(expression)
+          let typeDeclarationPath: string | null = null
+
+          if (
+            typeSymbol &&
+            typeSymbol.declarations &&
+            typeSymbol.declarations[0]
+          ) {
+            const declaration = typeSymbol.declarations[0]
+            const sourceFile = declaration.getSourceFile()
+            typeDeclarationPath = sourceFile.fileName
+          }
+
+          const variables = methods.get(fileName) || []
+          variables.push({
+            variable: variableName,
+            type: inferredType,
+            typePath: typeDeclarationPath,
+          })
+          methods.set(fileName, variables)
+
+          // Extract singleton services for CreateSessionServices factories
+          if (
+            expectedTypeName === 'CreateSessionServices' &&
+            state &&
+            callExpression.arguments.length > 0
+          ) {
+            const firstArg = callExpression.arguments[0]
+            let functionNode:
+              | ts.ArrowFunction
+              | ts.FunctionExpression
+              | undefined
+
+            if (ts.isArrowFunction(firstArg)) {
+              functionNode = firstArg
+            } else if (ts.isFunctionExpression(firstArg)) {
+              functionNode = firstArg
+            }
+
+            if (functionNode) {
+              const servicesMeta = extractServicesFromFunction(functionNode)
+              state.sessionServicesMeta.set(variableName, servicesMeta.services)
+            }
+          }
+
+          return // Early return since we found a match
+        }
+      }
+    }
+
     if (variableTypeNode && ts.isTypeReferenceNode(variableTypeNode)) {
       const typeNameNode = variableTypeNode.typeName || null
 
@@ -37,6 +108,25 @@ export const addFileWithFactory = (
           typePath: typeDeclarationPath,
         })
         methods.set(fileName, variables)
+
+        // Extract singleton services for CreateSessionServices factories
+        if (
+          expectedTypeName === 'CreateSessionServices' &&
+          state &&
+          node.initializer
+        ) {
+          let functionNode: ts.ArrowFunction | ts.FunctionExpression | undefined
+          if (ts.isArrowFunction(node.initializer)) {
+            functionNode = node.initializer
+          } else if (ts.isFunctionExpression(node.initializer)) {
+            functionNode = node.initializer
+          }
+
+          if (functionNode) {
+            const servicesMeta = extractServicesFromFunction(functionNode)
+            state.sessionServicesMeta.set(variableName, servicesMeta.services)
+          }
+        }
       }
 
       // Handle qualified type names if necessary
@@ -58,6 +148,28 @@ export const addFileWithFactory = (
             typePath: typeDeclarationPath,
           })
           methods.set(fileName, variables)
+
+          // Extract singleton services for CreateSessionServices factories
+          if (
+            expectedTypeName === 'CreateSessionServices' &&
+            state &&
+            node.initializer
+          ) {
+            let functionNode:
+              | ts.ArrowFunction
+              | ts.FunctionExpression
+              | undefined
+            if (ts.isArrowFunction(node.initializer)) {
+              functionNode = node.initializer
+            } else if (ts.isFunctionExpression(node.initializer)) {
+              functionNode = node.initializer
+            }
+
+            if (functionNode) {
+              const servicesMeta = extractServicesFromFunction(functionNode)
+              state.sessionServicesMeta.set(variableName, servicesMeta.services)
+            }
+          }
         }
       }
     }

package/src/add/add-functions.ts

@@ -27,7 +27,8 @@ const nullifyTypes = (type: string | null) => {
 const resolveTypeImports = (
   type: ts.Type,
   resolvedTypes: TypesMap,
-  isCustom: boolean
+  isCustom: boolean,
+  checker: ts.TypeChecker
 ): string[] => {
   const types: string[] = []
 
@@ -42,10 +43,14 @@ const resolveTypeImports = (
         const path = sourceFile.fileName
 
         // Skip built-in utility types or TypeScript lib types
+        // Skip enum members (but not the enum type itself)
+        const isEnumMember = declaration && ts.isEnumMember(declaration)
+
         if (
           !path.includes('node_modules/typescript') &&
           symbol.getName() !== '__type' &&
-          !isPrimitiveType(currentType)
+          !isPrimitiveType(currentType) &&
+          !isEnumMember
         ) {
           const originalName = symbol.getName()
           // Check if the type is already in the map
@@ -102,6 +107,32 @@ const resolveTypeImports = (
       const typeRef = currentType as ts.TypeReference
       typeRef.typeArguments?.forEach(visitType)
     }
+
+    // Handle anonymous object types with enum properties (e.g., { userType: UserType })
+    // Only traverse into enum property types to avoid over-importing other named types
+    if (currentType.flags & ts.TypeFlags.Object) {
+      const objectType = currentType as ts.ObjectType
+      const typeSymbol = objectType.getSymbol()
+
+      // Only traverse properties for anonymous object types (no symbol or __type symbol)
+      // Skip named types, interfaces, and enums to avoid over-importing
+      const isAnonymousObject = !typeSymbol || typeSymbol.getName() === '__type'
+
+      if (isAnonymousObject) {
+        const properties = objectType.getProperties()
+        for (const prop of properties) {
+          if (prop.valueDeclaration) {
+            const propType = checker.getTypeOfSymbolAtLocation(
+              prop,
+              prop.valueDeclaration
+            )
+            if (propType) {
+              visitType(propType)
+            }
+          }
+        }
+      }
+    }
   }
 
   visitType(type)
@@ -170,7 +201,7 @@ const getNamesAndTypes = (
 
     // record the alias in your TypesMap
     const references = rawTypes
-      .map((t) => resolveTypeImports(t, typesMap, true))
+      .map((t) => resolveTypeImports(t, typesMap, true, checker))
       .flat()
 
     typesMap.addCustomType(aliasName, aliasType, references)
@@ -192,7 +223,7 @@ const getNamesAndTypes = (
         return name
       }
       // non-primitive: import/alias it inline
-      return resolveTypeImports(t, typesMap, false)
+      return resolveTypeImports(t, typesMap, false, checker)
     })
     .flat()
 
@@ -270,7 +301,7 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
   if (args.length === 0) return
 
   const { pikkuFuncName, name, explicitName, exportedName } =
-    extractFunctionName(node, checker)
+    extractFunctionName(node, checker, state.rootDir)
 
   let tags: string[] | undefined
   let expose: boolean | undefined
@@ -300,6 +331,17 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
       (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))
     ) {
       logger.error(`• No valid 'func' property found for ${pikkuFuncName}.`)
+      // Create stub metadata to prevent "function not found" errors in wirings
+      state.functions.meta[pikkuFuncName] = {
+        pikkuFuncName,
+        name,
+        services: { optimized: false, services: [] },
+        inputSchemaName: null,
+        outputSchemaName: null,
+        inputs: [],
+        outputs: [],
+        middleware: undefined,
+      }
       return
     }
     handlerNode = fnProp
@@ -310,6 +352,17 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
     !ts.isFunctionExpression(handlerNode)
   ) {
     logger.error(`• Handler for ${name} is not a function.`)
+    // Create stub metadata to prevent "function not found" errors in wirings
+    state.functions.meta[pikkuFuncName] = {
+      pikkuFuncName,
+      name,
+      services: { optimized: false, services: [] },
+      inputSchemaName: null,
+      outputSchemaName: null,
+      inputs: [],
+      outputs: [],
+      middleware: undefined,
+    }
     return
   }
 
@@ -434,6 +487,8 @@ export const addFunctions: AddWiring = (logger, node, checker, state) => {
         path: node.getSourceFile().fileName,
         exportedName,
       })
+      // Track exposed RPC function for service aggregation
+      state.serviceAggregation.usedFunctions.add(pikkuFuncName)
     }
 
     // We add it to internal meta to allow autocomplete for everything