@pikku/cli 0.11.2 → 0.12.0

package/src/services.ts

@@ -1,315 +0,0 @@
-import type {
-  Config,
-  Services,
-  SingletonServices,
-  UserSession,
-} from '../types/application-types.js'
-import {
-  CreateConfig,
-  CreateWireServices,
-  CreateSingletonServices,
-} from '@pikku/core'
-import { pikkuCLIRender } from '@pikku/core/cli'
-import { LocalVariablesService, LogLevel } from '@pikku/core/services'
-import { CLILogger } from './services/cli-logger.service.js'
-import { getPikkuCLIConfig } from './utils/pikku-cli-config.js'
-import {
-  inspect,
-  InspectorState,
-  InspectorFilters,
-  serializeInspectorState,
-  deserializeInspectorState,
-  filterInspectorState,
-  getInitialInspectorState,
-} from '@pikku/inspector'
-import { glob } from 'tinyglobby'
-import path from 'path'
-import { PikkuCLIConfig } from '../types/config.js'
-import {
-  CLILoggerForwarder,
-  ForwardedLogMessage,
-} from './services/cli-logger-forwarder.service.js'
-import { readFile, writeFile } from 'fs/promises'
-
-// Logger instance will be configured with log level from CLI flags in createConfig
-// Logo will be displayed conditionally in createConfig based on --silent flag
-const logger = new CLILogger({ logLogo: false, silent: false })
-
-/**
- * Parse a comma-separated string or array into an array of trimmed, non-empty strings
- * Returns undefined if the input is empty/undefined or results in an empty array
- */
-function parseCommaSeparated(
-  value: string | string[] | undefined
-): string[] | undefined {
-  if (!value) return undefined
-
-  // If already an array, flatten and split any comma-separated values
-  if (Array.isArray(value)) {
-    const flattened = value
-      .flatMap((item) => item.split(','))
-      .map((item) => item.trim())
-      .filter((item) => item.length > 0)
-    return flattened.length > 0 ? flattened : undefined
-  }
-
-  // If string, split by comma
-  const parsed = value
-    .split(',')
-    .map((item) => item.trim())
-    .filter((item) => item.length > 0)
-
-  return parsed.length > 0 ? parsed : undefined
-}
-
-/**
- * Parse CLI filter arguments into InspectorFilters format
- */
-function parseCLIFilters(data: any): InspectorFilters {
-  const filters: InspectorFilters = {}
-
-  if (data.filters) {
-    return JSON.parse(data.filters)
-  }
-
-  // Parse each filter type from CLI arguments
-  const names = parseCommaSeparated(data.names)
-  const tags = parseCommaSeparated(data.tags)
-  const types = parseCommaSeparated(data.types)
-  const directories = parseCommaSeparated(data.directories)
-  const httpRoutes = parseCommaSeparated(data.httpRoutes)
-  const httpMethods = parseCommaSeparated(data.httpMethods)
-
-  // Only include non-undefined values in the result
-  if (names) filters.names = names
-  if (tags) filters.tags = tags
-  if (types) filters.types = types
-  if (directories) filters.directories = directories
-  if (httpRoutes) filters.httpRoutes = httpRoutes
-  if (httpMethods) filters.httpMethods = httpMethods
-
-  return filters
-}
-
-/**
- * Default CLI renderer that logs output using the logger
- */
-export const defaultCLIRenderer = pikkuCLIRender<
-  ForwardedLogMessage,
-  SingletonServices
->(({ logger }, data) => {
-  if (data) {
-    logger[data.level]({ message: data.message, type: data.type })
-  }
-})
-
-// /**
-//  * Client-safe CLI renderer that outputs to console (no service dependencies)
-//  * This renderer can be used in CLI-over-channel clients
-//  */
-// export const clientCLIRenderer = pikkuCLIRender<ForwardedLogMessage>(
-//   ({ logger }, data) => {
-//     if (data) {
-//       logger[data.level]?.({ message: data.message, type: data.type } as any)
-//     }
-//   }
-// )
-
-export const createConfig: CreateConfig<Config, [PikkuCLIConfig]> = async (
-  _variablesService,
-  data
-) => {
-  // Determine log level based on CLI flags with precedence:
-  // --silent > --loglevel > --verbose > --info > default (warn)
-  let logLevel: LogLevel = LogLevel.warn // default
-  let isSilent = false
-
-  if ((data as any).silent) {
-    logLevel = LogLevel.critical
-    isSilent = true
-  } else if ((data as any).loglevel) {
-    const levelStr = (data as any).loglevel
-    if (LogLevel[levelStr] !== undefined) {
-      logLevel = LogLevel[levelStr as keyof typeof LogLevel]
-    } else {
-      logger.warn(
-        `Invalid log level "${levelStr}". Valid levels: trace, debug, info, warn, error, critical. Using default (warn).`
-      )
-    }
-  } else if ((data as any).verbose) {
-    logLevel = LogLevel.debug
-  } else if ((data as any).info) {
-    logLevel = LogLevel.info
-  }
-
-  logger.setLevel(logLevel)
-  logger.setSilent(isSilent)
-
-  // Display logo unless in silent mode
-  if (!isSilent) {
-    logger.logLogo()
-  }
-
-  const cliConfig = await getPikkuCLIConfig(logger, data.configFile, [], true)
-
-  // Load inspector state from file if stateInput is provided
-  let preloadedInspectorState: Omit<InspectorState, 'typesLookup'> | undefined =
-    undefined
-
-  if (data.stateInput) {
-    try {
-      logger.info(`Loading inspector state from ${data.stateInput}`)
-      const stateJson = await readFile(data.stateInput, 'utf-8')
-      const serializedState = JSON.parse(stateJson)
-      preloadedInspectorState = deserializeInspectorState(serializedState)
-      logger.info(`Inspector state loaded successfully`)
-    } catch (error: any) {
-      logger.error(
-        `Failed to load inspector state from ${data.stateInput}: ${error.message}`
-      )
-      throw error
-    }
-  }
-
-  return {
-    ...cliConfig,
-    ...data,
-    filters: parseCLIFilters(data),
-    preloadedInspectorState,
-  }
-}
-
-/**
- * Singleton services factory for the Pikku CLI
- * This function creates the singleton services used by the CLI and is created once on start.
- */
-export const createSingletonServices: CreateSingletonServices<
-  Config,
-  SingletonServices
-> = async (config) => {
-  const {
-    rootDir,
-    srcDirectories,
-    filters,
-    preloadedInspectorState,
-    stateOutput,
-  } = config
-  const variables = new LocalVariablesService()
-
-  // Store unfiltered state
-  let unfilteredState:
-    | InspectorState
-    | Omit<InspectorState, 'typesLookup'>
-    | undefined = preloadedInspectorState
-
-  const getInspectorState = async (
-    refresh: boolean = false,
-    setupOnly: boolean = false,
-    bootstrapMode: boolean = false
-  ) => {
-    // In bootstrap mode, return a minimal "zero state" with core types
-    // This allows bootstrap to run immediately without inspecting the codebase
-    if (bootstrapMode) {
-      const corePackagePath = '@pikku/core'
-      const initialState = getInitialInspectorState(rootDir)
-
-      // Populate filesAndMethods with core types from @pikku/core
-      initialState.filesAndMethods = {
-        userSessionType: {
-          file: corePackagePath,
-          variable: 'CoreUserSession',
-          type: 'CoreUserSession',
-          typePath: corePackagePath,
-        },
-        wireServicesType: {
-          file: corePackagePath,
-          variable: 'CoreServices',
-          type: 'CoreServices',
-          typePath: corePackagePath,
-        },
-        singletonServicesType: {
-          file: corePackagePath,
-          variable: 'CoreSingletonServices',
-          type: 'CoreSingletonServices',
-          typePath: corePackagePath,
-        },
-        pikkuConfigType: {
-          file: corePackagePath,
-          variable: 'CoreConfig',
-          type: 'CoreConfig',
-          typePath: corePackagePath,
-        },
-      }
-
-      return initialState
-    }
-
-    // Get or refresh the unfiltered state
-    if (!unfilteredState || refresh) {
-      // Run inspector WITHOUT filters to get full state
-      const wiringFiles = (
-        await Promise.all(
-          srcDirectories.map((dir) =>
-            glob(`${path.join(rootDir, dir)}/**/*.ts`, {
-              ignore: config.ignoreFiles || [],
-            })
-          )
-        )
-      ).flat()
-      unfilteredState = inspect(logger, wiringFiles, {
-        setupOnly,
-        types: {
-          configFileType: config.configFile,
-          userSessionType: config.userSessionType,
-          singletonServicesFactoryType: config.singletonServicesFactoryType,
-          wireServicesFactoryType: config.wireServicesFactoryType,
-        },
-      })
-
-      // Save unfiltered inspector state to file if stateOutput is provided
-      if (stateOutput && 'typesLookup' in unfilteredState) {
-        try {
-          logger.info(`Saving inspector state to ${stateOutput}`)
-          const serialized = serializeInspectorState(unfilteredState)
-          await writeFile(
-            stateOutput,
-            JSON.stringify(serialized, null, 2),
-            'utf-8'
-          )
-          logger.info(`Inspector state saved successfully`)
-        } catch (error: any) {
-          logger.error(
-            `Failed to save inspector state to ${stateOutput}: ${error.message}`
-          )
-          // Don't throw - state saving is optional/nice-to-have
-        }
-      }
-    }
-
-    // Apply filters as a post-processing step
-    const filteredState = filterInspectorState(unfilteredState, filters, logger)
-
-    return filteredState as InspectorState
-  }
-
-  return {
-    config,
-    logger,
-    variables,
-    getInspectorState,
-  }
-}
-
-export const createWireServices: CreateWireServices<
-  SingletonServices,
-  Services,
-  UserSession
-> = async ({ logger }, { cli, channel }) => {
-  const vChannel = cli ? cli.channel : channel
-  if (!vChannel) {
-    throw new Error('No channel provided for CLI services')
-  }
-  return {
-    logger: new CLILoggerForwarder(logger, vChannel),
-  }
-}

package/src/utils/check-required-types.ts

@@ -1,65 +0,0 @@
-import { FilesAndMethodsErrors } from '@pikku/inspector'
-
-export type RequiredTypes = Partial<{
-  config: boolean
-  wireServiceType: boolean
-  singletonServicesType: boolean
-  userSessionType: boolean
-  singletonServicesFactory: boolean
-  wireServicesFactory: boolean
-}>
-
-export const checkRequiredTypes = (
-  errors: FilesAndMethodsErrors,
-  requires: RequiredTypes = {}
-): void => {
-  // Filter out errors that are about missing Types when we have the corresponding Factory
-  // e.g., if we have a CreateConfig factory, we don't need a CoreConfig type
-  const errorMessages = Array.from(errors.keys())
-  const hasCreateConfigFactory = errorMessages.every(
-    (msg) => !msg.includes('No CreateConfig found')
-  )
-
-  // Only throw if there are errors AND we require those types
-  const hasRequiredErrors = errorMessages.some((message) => {
-    // Skip CoreConfig type errors if we have a CreateConfig factory
-    if (
-      requires.config &&
-      message.includes('No CoreConfig found') &&
-      hasCreateConfigFactory
-    ) {
-      return false
-    }
-    if (requires.config && message.includes('CoreConfig')) return true
-    if (requires.wireServiceType && message.includes('CoreServices'))
-      return true
-    if (
-      requires.singletonServicesType &&
-      message.includes('CoreSingletonServices')
-    )
-      return true
-    if (requires.userSessionType && message.includes('CoreUserSession'))
-      return true
-    if (
-      requires.singletonServicesFactory &&
-      message.includes('CreateSingletonServices')
-    )
-      return true
-    if (requires.wireServicesFactory && message.includes('CreateWireServices'))
-      return true
-    return false
-  })
-
-  if (hasRequiredErrors) {
-    const result: string[] = ['Found errors:']
-    errors.forEach((filesAndMethods, message) => {
-      result.push(`- ${message}`)
-      filesAndMethods.forEach((methods, file) => {
-        result.push(
-          `\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`
-        )
-      })
-    })
-    throw new Error(result.join('\n'))
-  }
-}

package/src/utils/command-summary.ts

@@ -1,103 +0,0 @@
-import chalk from 'chalk'
-
-export interface CommandSummaryStats {
-  httpRoutes?: number
-  channels?: number
-  functions?: number
-  scheduledTasks?: number
-  queueWorkers?: number
-  mcpEndpoints?: number
-  cliCommands?: number
-  workflows?: number
-  [key: string]: number | undefined
-}
-
-/**
- * Utility class to collect and display command execution summaries
- */
-export class CommandSummary {
-  private stats: CommandSummaryStats = {}
-  private startTime: number
-  private commandName: string
-
-  constructor(commandName: string) {
-    this.commandName = commandName
-    this.startTime = Date.now()
-  }
-
-  /**
-   * Increment a stat counter
-   */
-  increment(key: keyof CommandSummaryStats, count: number = 1): void {
-    this.stats[key] = (this.stats[key] || 0) + count
-  }
-
-  /**
-   * Set a stat value directly
-   */
-  set(key: keyof CommandSummaryStats, value: number): void {
-    this.stats[key] = value
-  }
-
-  /**
-   * Get current stats
-   */
-  getStats(): CommandSummaryStats {
-    return { ...this.stats }
-  }
-
-  /**
-   * Get elapsed time in milliseconds
-   */
-  getElapsedTime(): number {
-    return Date.now() - this.startTime
-  }
-
-  /**
-   * Format the summary for display
-   */
-  format(): string {
-    const elapsed = this.getElapsedTime()
-    const lines: string[] = []
-
-    // Header with timing
-    lines.push(
-      chalk.green(`\npikku ${this.commandName} (completed in ${elapsed}ms)`)
-    )
-
-    // Stats
-    const statLabels: Record<keyof CommandSummaryStats, string> = {
-      httpRoutes: 'HTTP route',
-      channels: 'WebSocket channel',
-      functions: 'Function',
-      scheduledTasks: 'Scheduled task',
-      queueWorkers: 'Queue worker',
-      mcpEndpoints: 'MCP endpoint',
-      cliCommands: 'CLI command',
-      workflows: 'Workflow',
-    }
-
-    for (const [key, label] of Object.entries(statLabels)) {
-      const value = this.stats[key]
-      if (value !== undefined && value > 0) {
-        lines.push(chalk.gray(`  • ${value} ${label}${value > 1 ? 's' : ''}`))
-      }
-    }
-
-    // If no stats, show a simple completion message
-    if (Object.values(this.stats).every((v) => !v || v === 0)) {
-      return chalk.green(
-        `\npikku ${this.commandName} (completed in ${elapsed}ms)\n`
-      )
-    }
-
-    return lines.join('\n') + '\n'
-  }
-
-  /**
-   * Check if there are any stats to display
-   */
-  hasStats(): boolean {
-    return Object.values(this.stats).some((v) => v && v > 0)
-  }
-}

package/src/utils/custom-types-generator.ts

@@ -1,55 +0,0 @@
-import { TypesMap } from '@pikku/inspector'
-
-export function generateCustomTypes(
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-  .map(([name, { type, references }]) => {
-    references.forEach((refName) => {
-      // Skip __object types (including those with suffixes like __object_abc123)
-      // These are placeholder types created by the inspector for invalid/broken functions
-      // (e.g., functions with type errors or missing return statements). Attempting to
-      // import these would fail since the source files don't actually export __object.
-      if (refName !== '__object' && !refName.startsWith('__object_')) {
-        requiredTypes.add(refName)
-      }
-    })
-
-    // Extract type names from the type string that might not be in references
-    const typeString = type
-    // Use regex to extract potential type names (PascalCase identifiers)
-    const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g
-    const potentialTypes = typeString.match(typeNameRegex) || []
-
-    potentialTypes.forEach((typeName) => {
-      // Skip string literals and common keywords
-      if (
-        typeString.includes(`"${typeName}"`) ||
-        ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Readonly'].includes(
-          typeName
-        )
-      ) {
-        return
-      }
-
-      // Try to find this type in the typesMap and add it if found
-      try {
-        const typeMeta = typesMap.getTypeMeta(typeName)
-        if (typeMeta.path) {
-          // Add originalName to preserve canonical import name
-          requiredTypes.add(typeMeta.originalName)
-        }
-      } catch (e) {
-        // Type not found in map (ambient/builtin type) - ignore it
-        // Do NOT add to requiredTypes to avoid crashes in serializeImportMap
-      }
-    })
-
-    return `export type ${name} = ${type}`
-  })
-  .join('\n')}`
-}