@pikku/cli 0.11.3 → 0.12.0

package/src/middleware/log-command-info-and-time.ts

@@ -1,35 +0,0 @@
-import type { Services } from '../../types/application-types.js'
-import type { PikkuWire } from '@pikku/core'
-
-// Middleware type for CLI
-type PikkuMiddleware = (
-  services: Services,
-  wire: PikkuWire,
-  next: () => Promise<void>
-) => Promise<void>
-
-export interface LogCommandInfoOptions {
-  commandStart: string
-  commandEnd: string
-}
-
-/**
- * Middleware to log command execution timing and status
- * Uses debug level so it only shows with --verbose flag
- */
-export const logCommandInfoAndTime = ({
-  commandStart,
-  commandEnd,
-}: LogCommandInfoOptions): PikkuMiddleware => {
-  return async ({ logger }, _wire, next) => {
-    const start = Date.now()
-    logger.debug(`• ${commandStart}...`)
-
-    await next()
-
-    logger.debug({
-      type: 'success',
-      message: `✓ ${commandEnd} in ${Date.now() - start}ms.`,
-    })
-  }
-}

package/src/services/cli-logger-forwarder.service.ts

@@ -1,99 +0,0 @@
-import { Logger, LogLevel } from '@pikku/core'
-import { PikkuChannel } from '@pikku/core/channel'
-import { ErrorCode } from '@pikku/inspector'
-
-/**
- * Log message structure sent through the channel
- */
-export interface ForwardedLogMessage {
-  message: string
-  level: 'trace' | 'debug' | 'info' | 'warn' | 'error'
-  type?: string
-}
-
-/**
- * A logger implementation that forwards log messages to a CLI channel
- * instead of logging to console directly.
- */
-export class CLILoggerForwarder implements Logger {
-  private level: LogLevel = LogLevel.info
-  private silent: boolean = false
-
-  constructor(
-    private logger: Logger,
-    private channel: PikkuChannel<unknown, any>
-  ) {}
-
-  setLevel(level: LogLevel): void {
-    this.level = level
-  }
-
-  setSilent(silent: boolean): void {
-    this.silent = silent
-  }
-
-  isSilent(): boolean {
-    return this.silent
-  }
-
-  private log(
-    level: ForwardedLogMessage['level'],
-    logLevel: LogLevel,
-    messageOrObj: string | Record<string, any> | Error,
-    type?: string
-  ) {
-    if (this.level > logLevel || this.silent) return
-
-    let message: string
-
-    if (messageOrObj instanceof Error) {
-      this.logger.error(messageOrObj.toString())
-      message = messageOrObj.message
-    } else if (typeof messageOrObj === 'object') {
-      if (
-        'message' in messageOrObj &&
-        typeof messageOrObj.message === 'string'
-      ) {
-        message = messageOrObj.message
-        type = type || (messageOrObj.type as string)
-      } else {
-        message = JSON.stringify(messageOrObj)
-      }
-    } else {
-      message = messageOrObj
-    }
-
-    this.channel.send({ message, level, type })
-  }
-
-  info(messageOrObj: string | Record<string, any>, ..._meta: any[]) {
-    this.log('info', LogLevel.info, messageOrObj)
-  }
-
-  error(messageOrObj: string | Record<string, any> | Error, ..._meta: any[]) {
-    this.log('error', LogLevel.error, messageOrObj)
-  }
-
-  warn(messageOrObj: string | Record<string, any>, ..._meta: any[]) {
-    this.log('warn', LogLevel.warn, messageOrObj)
-  }
-
-  debug(message: string, ..._meta: any[]) {
-    this.log('debug', LogLevel.debug, message)
-  }
-
-  trace(message: string, ..._meta: any[]) {
-    this.log('trace', LogLevel.trace, message)
-  }
-
-  critical(code: ErrorCode, message: string) {
-    const url = `https://pikku.dev/docs/pikku-cli/errors/${code.toLowerCase()}`
-    const formattedMessage = `[${code}] ${message}\n  → ${url}`
-    this.error(formattedMessage)
-  }
-
-  hasCriticalErrors(): boolean {
-    // The underlying logger (CLILogger) tracks critical errors
-    return (this.logger as any).hasCriticalErrors?.() ?? false
-  }
-}

package/src/services/cli-logger.service.ts

@@ -1,108 +0,0 @@
-import chalk from 'chalk'
-import { Logger, LogLevel } from '@pikku/core'
-import { ErrorCode } from '@pikku/inspector'
-
-const logo = `
- ______ _ _     _
-(_____ (_) |   | |
- _____) )| |  _| |  _ _   _
-|  ____/ | |_/ ) |_/ ) | | |
-| |    | |  _ (|  _ (|  _ (| |_| |
-|_|    |_|_| _)_| _)____/
-`
-
-const BASE_ERROR_URL = 'https://pikku.dev/docs/pikku-cli/errors'
-
-export class CLILogger implements Logger {
-  private silent: boolean
-  private level: LogLevel = LogLevel.warn // default to warn level
-  private criticalErrors: string[] = []
-
-  constructor({
-    logLogo,
-    silent = false,
-  }: {
-    logLogo: boolean
-    silent?: boolean
-  }) {
-    this.silent = silent
-    if (logLogo && !silent) {
-      this.logLogo()
-    }
-  }
-
-  setLevel(level: LogLevel): void {
-    this.level = level
-  }
-
-  setSilent(silent: boolean): void {
-    this.silent = silent
-  }
-
-  isSilent(): boolean {
-    return this.silent
-  }
-
-  info(message: string | { message: string; type?: string }) {
-    if (this.level > LogLevel.info || this.silent) return
-
-    let c = chalk.blue
-    if (typeof message === 'object') {
-      if (message.type === 'success') {
-        c = chalk.green
-      } else if (message.type === 'timing') {
-        c = chalk.gray
-      }
-    }
-    console.log(c(typeof message === 'string' ? message : message.message))
-  }
-
-  error(message: string) {
-    if (this.level > LogLevel.error) return
-    console.error(chalk.red(message))
-  }
-
-  warn(message: string) {
-    if (this.level > LogLevel.warn) return
-    console.error(chalk.yellow(message))
-  }
-
-  debug(message: string | { message: string; type?: string }) {
-    if (this.level > LogLevel.debug || this.silent) return
-
-    let c = chalk.gray
-    if (typeof message === 'object') {
-      if (message.type === 'success') {
-        c = chalk.green
-      }
-    }
-    console.log(c(typeof message === 'string' ? message : message.message))
-  }
-
-  critical(code: ErrorCode, message: string) {
-    const url = `${BASE_ERROR_URL}/${code.toLowerCase()}`
-    const formattedMessage = `[${code}] ${message}\n  → ${url}`
-    this.criticalErrors.push(formattedMessage)
-    console.error(chalk.red.bold(formattedMessage))
-  }
-
-  hasCriticalErrors(): boolean {
-    return this.criticalErrors.length > 0
-  }
-
-  logLogo() {
-    this.primary(logo)
-    // // When running from dist/, __filename is dist/src/services/cli-logger.service.js
-    // // So we need to go up 3 levels: dist/src/services -> dist/src -> dist -> package.json
-    // const packageJson = JSON.parse(
-    //   readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8')
-    // )
-    // this.primary(`⚙️  Welcome to the Pikku CLI (v${packageJson.version})\n`)
-  }
-
-  private primary(message: string) {
-    if (!this.silent) {
-      console.log(chalk.green(message))
-    }
-  }
-}

package/src/services.ts

@@ -1,322 +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,
-  LocalSecretService,
-  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 || [],
-              absolute: true,
-            })
-          )
-        )
-      ).flat()
-      unfilteredState = inspect(logger, wiringFiles, {
-        setupOnly,
-        rootDir,
-        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,
-    secrets: new LocalSecretService(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'))
-  }
-}