@kubb/cli 5.0.0-beta.62 → 5.0.0-beta.64

package/src/loggers/plainLogger.ts

@@ -1,199 +0,0 @@
-import { relative } from 'node:path'
-import { formatMs, toCause } from '@internals/utils'
-import { Diagnostics, type KubbHooks, logLevel as logLevelMap } from '@kubb/core'
-import { defineLogger } from './defineLogger.ts'
-import { createHookTimer, formatCommandWithArgs, formatMessage } from './utils.ts'
-
-/**
- * Plain console adapter for non-TTY environments, built on `console.log`.
- */
-export const plainLogger = defineLogger({
-  name: 'plain',
-  install(context, options) {
-    const logLevel = options?.logLevel ?? logLevelMap.info
-    const hookTimer = createHookTimer()
-
-    function getMessage(message: string): string {
-      return formatMessage(message, logLevel)
-    }
-
-    // Registers a handler that logs a fixed message, skipped at silent level.
-    function onStep<E extends keyof KubbHooks>(event: E, message: string): void {
-      context.on(event, () => {
-        if (logLevel <= logLevelMap.silent) {
-          return
-        }
-        console.log(getMessage(message))
-      })
-    }
-
-    context.on('kubb:info', ({ message, info }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage(['ℹ', message, info].join(' '))
-
-      console.log(text)
-    })
-
-    context.on('kubb:success', ({ message, info = '' }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage(['✓', message, logLevel >= logLevelMap.info ? info : undefined].filter(Boolean).join(' '))
-
-      console.log(text)
-    })
-
-    context.on('kubb:warn', ({ message, info }) => {
-      if (logLevel < logLevelMap.warn) {
-        return
-      }
-
-      const text = getMessage(['⚠', message, logLevel >= logLevelMap.info ? info : undefined].filter(Boolean).join(' '))
-
-      console.log(text)
-    })
-
-    context.on('kubb:error', ({ error }) => {
-      const caused = toCause(error)
-
-      const text = getMessage(['✗', error.message].join(' '))
-
-      console.log(text)
-
-      // Show stack trace in verbose mode (first 3 frames)
-      if (logLevel >= logLevelMap.verbose && error.stack) {
-        const frames = error.stack.split('\n').slice(1, 4)
-        for (const frame of frames) {
-          console.log(getMessage(frame.trim()))
-        }
-
-        if (caused?.stack) {
-          console.log(`└─ caused by ${caused.message}`)
-
-          const frames = caused.stack.split('\n').slice(1, 4)
-          for (const frame of frames) {
-            console.log(getMessage(`    ${frame.trim()}`))
-          }
-        }
-      }
-    })
-
-    context.on('kubb:diagnostic', ({ diagnostic }) => {
-      // Silent still surfaces errors so failures stay visible. It drops warnings and info.
-      if (logLevel <= logLevelMap.silent && diagnostic.severity !== 'error') {
-        return
-      }
-      console.log(getMessage(Diagnostics.formatLines(diagnostic).join('\n')))
-    })
-
-    context.on('kubb:lifecycle:start', ({ version }) => {
-      console.log(`Kubb CLI v${version}`)
-    })
-
-    context.on('kubb:generation:start', () => {
-      const text = getMessage('Generation started')
-
-      console.log(text)
-    })
-
-    context.on('kubb:plugin:start', ({ plugin }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-      const text = getMessage(`Generating ${plugin.name}`)
-
-      console.log(text)
-    })
-
-    context.on('kubb:plugin:end', ({ plugin, duration, success }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const durationStr = formatMs(duration)
-      const text = getMessage(success ? `${plugin.name} completed in ${durationStr}` : `${plugin.name} failed in ${durationStr}`)
-
-      console.log(text)
-    })
-
-    context.on('kubb:files:processing:start', ({ files }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage(`Writing ${files.length} files`)
-
-      console.log(text)
-    })
-
-    context.on('kubb:files:processing:update', ({ files }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      for (const { file, config } of files) {
-        console.log(getMessage(`Writing ${relative(config.root, file.path)}`))
-      }
-    })
-
-    context.on('kubb:files:processing:end', () => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage('Files written successfully')
-
-      console.log(text)
-    })
-
-    context.on('kubb:generation:end', ({ config }) => {
-      const text = getMessage(config.name ? `Generation completed for ${config.name}` : 'Generation completed')
-
-      console.log(text)
-    })
-
-    onStep('kubb:format:start', 'Format started')
-    onStep('kubb:format:end', 'Format completed')
-    onStep('kubb:lint:start', 'Lint started')
-    onStep('kubb:lint:end', 'Lint completed')
-    onStep('kubb:hooks:start', 'Hooks started')
-    onStep('kubb:hooks:end', 'Hooks completed')
-
-    context.on('kubb:hook:start', ({ id, command, args }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      if (id) {
-        hookTimer.start(id)
-      }
-
-      const commandWithArgs = formatCommandWithArgs(command, args)
-      console.log(getMessage(`Hook ${commandWithArgs} started`))
-    })
-
-    context.on('kubb:hook:end', ({ id, command, args, success, error, stdout, stderr }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const ms = id ? hookTimer.end(id) : undefined
-      const durationStr = ms !== undefined ? ` in ${formatMs(ms)}` : ''
-
-      const commandWithArgs = formatCommandWithArgs(command, args)
-
-      if (success) {
-        console.log(getMessage(`✓ Hook ${commandWithArgs} completed${durationStr}`))
-      } else {
-        if (stdout) console.log(stdout)
-        if (stderr) console.error(stderr)
-        const reason = error?.message ? ` (${error.message})` : ''
-        console.log(getMessage(`✗ Hook ${commandWithArgs} failed${durationStr}${reason}`))
-      }
-    })
-  },
-})

package/src/loggers/types.ts

@@ -1,6 +0,0 @@
-/**
- * Logger adapter selected by `setupReporters` based on the runtime environment.
- * - `'clack'`: TTY-aware output with spinners and progress bars.
- * - `'plain'`: Plain `console.log` output for non-TTY environments.
- */
-export type LoggerType = 'clack' | 'plain'

package/src/loggers/utils.ts

@@ -1,249 +0,0 @@
-import process from 'node:process'
-import { styleText } from 'node:util'
-import { canUseTTY, formatHrtime, getElapsedMs } from '@internals/utils'
-import type { Reporter, ReporterContext } from '@kubb/core'
-import { logLevel as logLevelMap } from '@kubb/core'
-import type { Logger, LoggerContext, LoggerOptions } from './defineLogger.ts'
-import { clackLogger } from './clackLogger.ts'
-import { plainLogger } from './plainLogger.ts'
-import type { LoggerType } from './types.ts'
-
-/**
- * Optionally prefix a message with a [HH:MM:SS] timestamp when logLevel >= verbose.
- * Shared across all logger adapters to avoid duplication.
- */
-export function formatMessage(message: string, logLevel: number): string {
-  if (logLevel >= logLevelMap.verbose) {
-    const timestamp = new Date().toLocaleTimeString('en-US', {
-      hour12: false,
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-    })
-    return `${styleText('dim', `[${timestamp}]`)} ${message}`
-  }
-  return message
-}
-
-type ProgressState = {
-  /**
-   * Total number of plugins scheduled for this generation run.
-   */
-  totalPlugins: number
-  /**
-   * Number of plugins that have finished without error.
-   */
-  completedPlugins: number
-  /**
-   * Number of plugins that exited with an error.
-   */
-  failedPlugins: number
-  /**
-   * Total number of files expected to be written.
-   */
-  totalFiles: number
-  /**
-   * Number of files written so far.
-   */
-  processedFiles: number
-  /**
-   * `process.hrtime()` snapshot taken at the start of generation, used to compute elapsed time.
-   */
-  hrStart: [number, number]
-}
-
-/**
- * Build the progress summary line shown by the clack logger.
- * Returns null when there is nothing to display.
- */
-export function buildProgressLine(state: ProgressState): string | null {
-  const parts: Array<string> = []
-  const duration = formatHrtime(state.hrStart)
-
-  if (state.totalPlugins > 0) {
-    const pluginStr =
-      state.failedPlugins > 0
-        ? `Plugins ${styleText('green', state.completedPlugins.toString())}/${state.totalPlugins} ${styleText('red', `(${state.failedPlugins} failed)`)}`
-        : `Plugins ${styleText('green', state.completedPlugins.toString())}/${state.totalPlugins}`
-    parts.push(pluginStr)
-  }
-
-  if (state.totalFiles > 0) {
-    parts.push(`Files ${styleText('green', state.processedFiles.toString())}/${state.totalFiles}`)
-  }
-
-  if (parts.length === 0) {
-    return null
-  }
-
-  parts.push(`${styleText('green', duration)} elapsed`)
-  return parts.join(styleText('dim', ' | '))
-}
-
-/**
- * Creates the per-run progress counters used by the clack logger.
- */
-export function createProgressCounters(): ProgressState {
-  return {
-    totalPlugins: 0,
-    completedPlugins: 0,
-    failedPlugins: 0,
-    totalFiles: 0,
-    processedFiles: 0,
-    hrStart: process.hrtime(),
-  }
-}
-
-/**
- * Resets the progress counters in place at the start/end of a generation run.
- */
-export function resetProgressCounters(state: ProgressState): void {
-  state.totalPlugins = 0
-  state.completedPlugins = 0
-  state.failedPlugins = 0
-  state.totalFiles = 0
-  state.processedFiles = 0
-  state.hrStart = process.hrtime()
-}
-
-/**
- * Records a finished plugin against the progress counters.
- */
-export function recordPluginResult(state: ProgressState, success: boolean): void {
-  if (success) {
-    state.completedPlugins++
-  } else {
-    state.failedPlugins++
-  }
-}
-
-/**
- * Tracks per-hook start times so a logger can report a hook's elapsed duration.
- * Used by the plain logger, which keys timing by hook `id`.
- */
-export type HookTimer = {
-  start(id: string): void
-  /**
-   * Returns the elapsed milliseconds since `start(id)`, or `undefined` when no start was recorded.
-   */
-  end(id: string): number | undefined
-  clear(): void
-}
-
-/**
- * Creates a {@link HookTimer} backed by a private `id → hrtime` map.
- */
-export function createHookTimer(): HookTimer {
-  const starts = new Map<string, [number, number]>()
-
-  return {
-    start(id: string): void {
-      starts.set(id, process.hrtime())
-    },
-    end(id: string): number | undefined {
-      const hrStart = starts.get(id)
-      if (!hrStart) {
-        return undefined
-      }
-      starts.delete(id)
-      return getElapsedMs(hrStart)
-    },
-    clear(): void {
-      starts.clear()
-    },
-  }
-}
-
-/**
- * Join a command and its optional args into a single display string.
- *
- * @example
- * `formatCommandWithArgs('prettier', ['--write', '.']) → 'prettier --write .'`
- */
-export function formatCommandWithArgs(command: string, args?: ReadonlyArray<string>): string {
-  return args?.length ? `${command} ${args.join(' ')}` : command
-}
-
-function detectLogger(): LoggerType {
-  if (canUseTTY()) {
-    return 'clack'
-  }
-  return 'plain'
-}
-
-const logMapper: Record<LoggerType, Logger> = {
-  clack: clackLogger,
-  plain: plainLogger,
-}
-
-/**
- * Bridges a {@link Reporter} onto the run's event emitter: calls `report` with each config's
- * {@link GenerationResult} on `kubb:generation:end`. The reporter never touches the emitter.
- */
-export function installReporter(context: LoggerContext, reporter: Reporter, ctx: ReporterContext): void {
-  context.on('kubb:generation:end', async ({ config, diagnostics = [], filesCreated = 0, status = 'success', hrStart = process.hrtime() }) => {
-    await reporter.report({ config, diagnostics, filesCreated, status, hrStart }, ctx)
-  })
-
-  if (reporter.drain) {
-    context.on('kubb:lifecycle:end', () => reporter.drain?.(ctx))
-  }
-}
-
-/**
- * Installs the live logger (the TUI view) and the given reporters (the output). The reporters are
- * already selected by the caller (the CLI maps `--reporter` to names via `selectReporters`). This
- * only wires them. Loggers receive hook subprocess output through `kubb:hook:line` and the
- * `stdout`/`stderr` on `kubb:hook:end`, so nothing is returned here.
- *
- * Loggers and reporters are independent: the `cli` reporter also activates the env logger summary.
- * The `json` reporter owns stdout, so the live logger and the `cli` summary are suppressed whenever
- * `json` is among the reporters, even if `cli` is also listed.
- */
-async function setupReporters(context: LoggerContext, { logLevel, reporters }: LoggerOptions & { reporters: ReadonlyArray<Reporter> }): Promise<void> {
-  const hasJson = reporters.some((reporter) => reporter.name === 'json')
-  const ctx: ReporterContext = { logLevel }
-
-  for (const reporter of reporters) {
-    if (reporter.name === 'cli') {
-      if (hasJson) {
-        continue
-      }
-      const type = detectLogger()
-      const logger = logMapper[type]
-      if (!logger) {
-        throw new Error(`Unknown adapter type: ${type}`)
-      }
-      await logger.install(context, { logLevel })
-    }
-
-    installReporter(context, reporter, ctx)
-  }
-}
-
-export default setupReporters
-
-/**
- * Picks the reporters whose `name` matches one of `names`, in the order the names are given.
- * The config carries every available reporter, and the host selects which to activate by name
- * (the CLI maps `--reporter` to this). Duplicate names and names without a matching reporter are
- * skipped.
- */
-export function selectReporters(reporters: ReadonlyArray<Reporter>, names: ReadonlyArray<string>): Array<Reporter> {
-  const seen = new Set<string>()
-  const selected: Array<Reporter> = []
-
-  for (const name of names) {
-    if (seen.has(name)) {
-      continue
-    }
-    seen.add(name)
-
-    const reporter = reporters.find((candidate) => candidate.name === name)
-    if (reporter) {
-      selected.push(reporter)
-    }
-  }
-
-  return selected
-}