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

package/src/loggers/utils.ts

@@ -1,250 +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 With args
- * `formatCommandWithArgs('prettier', ['--write', '.'])` returns `'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, except for `cli`: it both installs the live logger view
- * here and registers as a reporter that prints the per-config summary. The `json` reporter owns
- * stdout, so the whole `cli` reporter (live logger and summary) is skipped 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
-}

package/src/runners/generate/run.ts

@@ -1,399 +0,0 @@
-import { hash } from 'node:crypto'
-import { existsSync } from 'node:fs'
-import path from 'node:path'
-import process from 'node:process'
-import { styleText } from 'node:util'
-import * as clack from '@clack/prompts'
-import type { AsyncEventEmitter } from '@internals/utils'
-import { AsyncEventEmitter as AsyncEventEmitterClass, detectTool, formatters, linters, toError } from '@internals/utils'
-import {
-  type CLIOptions,
-  cliReporter,
-  type Config,
-  createKubb,
-  type Diagnostic,
-  Diagnostics,
-  type KubbHooks,
-  logLevel as logLevelMap,
-  type ProblemDiagnostic,
-  type ReporterName,
-} from '@kubb/core'
-import { version } from '../../../package.json'
-import { KUBB_NPM_PACKAGE_URL } from '../../constants.ts'
-import { Telemetry } from '../../Telemetry.ts'
-import setupReporters, { selectReporters } from '../../loggers/utils.ts'
-import { executeHooks, getConfigs, runHook, startWatcher } from './utils.ts'
-
-type GenerateProps = {
-  input?: string
-  config: Config
-  hooks: AsyncEventEmitter<KubbHooks>
-  logLevel: number
-}
-
-type ToolMap = typeof formatters | typeof linters
-
-type RunToolPassOptions = {
-  toolValue: string
-  detect: () => Promise<string | null>
-  toolMap: ToolMap
-  toolLabel: string
-  successPrefix: string
-  noToolMessage: string
-  configName: string | undefined
-  outputPath: string
-  logLevel: number
-  hooks: AsyncEventEmitter<KubbHooks>
-  onStart: () => Promise<void>
-  onEnd: () => Promise<void>
-}
-
-/**
- * Registers a one-shot `kubb:hook:end` listener for `hookId` before the caller emits `kubb:hook:start`,
- * so a synchronous emitter cannot fire end before the listener is attached.
- */
-function waitForHookEnd(
-  hooks: AsyncEventEmitter<KubbHooks>,
-  hookId: string,
-  onSuccess: () => Promise<void> | void,
-  fallbackErrorMessage: string,
-): Promise<void> {
-  return new Promise<void>((resolve, reject) => {
-    const handler = (ctx: { id?: string; command: string; args?: ReadonlyArray<string>; success: boolean; error: Error | null }) => {
-      if (ctx.id !== hookId) return
-      hooks.off('kubb:hook:end', handler)
-      if (!ctx.success) {
-        reject(ctx.error ?? new Error(fallbackErrorMessage))
-        return
-      }
-      Promise.resolve(onSuccess()).then(resolve).catch(reject)
-    }
-    hooks.on('kubb:hook:end', handler)
-  })
-}
-
-async function runToolPass({
-  toolValue,
-  detect,
-  toolMap,
-  toolLabel,
-  successPrefix,
-  noToolMessage,
-  configName,
-  outputPath,
-  logLevel,
-  hooks,
-  onStart,
-  onEnd,
-}: RunToolPassOptions) {
-  await onStart()
-
-  let resolvedTool = toolValue
-  if (resolvedTool === 'auto') {
-    const detected = await detect()
-    if (!detected) {
-      await hooks.emit('kubb:warn', { message: noToolMessage })
-    } else {
-      resolvedTool = detected
-      await hooks.emit('kubb:info', { message: `Auto-detected ${toolLabel}: ${styleText('dim', resolvedTool)}` })
-    }
-  }
-
-  let toolError: Error | undefined
-
-  // Nothing to lint or format when the output dir was never written. Skip so the tool
-  // (e.g. oxlint with --no-ignore) doesn't fail with "No files found to lint".
-  if (resolvedTool && resolvedTool !== 'auto' && resolvedTool in toolMap && existsSync(outputPath)) {
-    const toolConfig = toolMap[resolvedTool as keyof ToolMap]
-    const hookId = hash('sha256', [configName, resolvedTool].filter(Boolean).join('-'), 'hex')
-
-    const successMessage = [
-      `${successPrefix} with ${styleText('dim', resolvedTool)}`,
-      logLevel >= logLevelMap.info ? `on ${styleText('dim', outputPath)}` : undefined,
-      'successfully',
-    ]
-      .filter(Boolean)
-      .join(' ')
-
-    try {
-      const hookArgs = toolConfig.args(outputPath)
-      const commandWithArgs = [toolConfig.command, ...hookArgs].join(' ')
-      const hookEndPromise = waitForHookEnd(hooks, hookId, () => hooks.emit('kubb:success', { message: successMessage }), toolConfig.errorMessage)
-
-      await hooks.emit('kubb:hook:start', { id: hookId, command: toolConfig.command, args: hookArgs })
-
-      runHook({
-        id: hookId,
-        command: toolConfig.command,
-        args: hookArgs,
-        commandWithArgs,
-        hooks,
-      }).catch(() => {})
-
-      await hookEndPromise
-    } catch (caughtError) {
-      // Don't render here. The caller turns this into a coded diagnostic and emits it through
-      // `Diagnostics.emit`, so format/lint/hook failures render like every other diagnostic.
-      toolError = toError(caughtError)
-    }
-  }
-
-  await onEnd()
-
-  if (toolError) {
-    throw toolError
-  }
-}
-
-async function generate(options: GenerateProps): Promise<boolean> {
-  const { input, hooks, logLevel } = options
-
-  const hrStart = process.hrtime()
-  const inputPath = input ?? (options.config.input && 'path' in options.config.input ? options.config.input.path : undefined)
-
-  const config: Config = {
-    ...options.config,
-    input: inputPath ? { ...options.config.input, path: inputPath } : options.config.input,
-    ...options.config.output,
-  } satisfies Config
-
-  const kubb = createKubb(config, { hooks })
-
-  await hooks.emit('kubb:generation:start', { config })
-  await hooks.emit('kubb:info', { message: config.name ? `Setup generation ${styleText('bold', config.name)}` : 'Setup generation', info: inputPath })
-
-  await kubb.setup()
-
-  await hooks.emit('kubb:info', { message: config.name ? `Build generation ${styleText('bold', config.name)}` : 'Build generation', info: inputPath })
-
-  const { files, diagnostics, driver } = await kubb.safeBuild()
-
-  await hooks.emit('kubb:info', { message: 'Load summary' })
-
-  const telemetryPlugins = Array.from(driver.plugins.values(), (p) => ({ name: p.name, options: p.options as Record<string, unknown> }))
-
-  const reportTelemetry = (status: 'success' | 'failed') =>
-    Telemetry.send(Telemetry.build({ command: 'generate', kubbVersion: version, plugins: telemetryPlugins, hrStart, filesCreated: files.length, status }))
-
-  // Render every problem, not just on failure, so warnings and info surface too.
-  // `performance` diagnostics feed the summary, not the log.
-  for (const diagnostic of diagnostics) {
-    if (!Diagnostics.isProblem(diagnostic)) {
-      continue
-    }
-    const unknown = Diagnostics.narrow(diagnostic, Diagnostics.code.unknown)
-    if (unknown) {
-      await hooks.emit('kubb:error', { error: unknown.cause ?? new Error(unknown.message) })
-    } else {
-      await Diagnostics.emit(hooks, diagnostic)
-    }
-  }
-
-  // Only an error-severity diagnostic fails the run. Warnings and info do not.
-  if (Diagnostics.hasError(diagnostics)) {
-    await hooks.emit('kubb:generation:end', { config, storage: kubb.storage, diagnostics, filesCreated: files.length, status: 'failed', hrStart })
-
-    await reportTelemetry('failed')
-    return false
-  }
-
-  const outputPath = path.resolve(config.root, config.output.path)
-
-  // The build succeeded. The formatter, linter, and post-generate hooks run after it. Their
-  // failures used to only emit `kubb:error`, so they never reached the summary, the json report,
-  // or the exit code. Collect them as coded diagnostics here.
-  const outputDiagnostics: Array<Diagnostic> = []
-
-  const toolPasses = [
-    config.output.format && {
-      code: Diagnostics.code.formatFailed,
-      toolValue: config.output.format,
-      detect: () => detectTool(['oxfmt', 'biome', 'prettier'] as const),
-      toolMap: formatters,
-      toolLabel: 'formatter',
-      successPrefix: 'Formatting',
-      noToolMessage: 'No formatter found (oxfmt, biome, or prettier). Skipping formatting.',
-      onStart: () => hooks.emit('kubb:format:start'),
-      onEnd: () => hooks.emit('kubb:format:end'),
-    },
-    config.output.lint && {
-      code: Diagnostics.code.lintFailed,
-      toolValue: config.output.lint,
-      detect: () => detectTool(['oxlint', 'biome', 'eslint'] as const),
-      toolMap: linters,
-      toolLabel: 'linter',
-      successPrefix: 'Linting',
-      noToolMessage: 'No linter found (oxlint, biome, or eslint). Skipping linting.',
-      onStart: () => hooks.emit('kubb:lint:start'),
-      onEnd: () => hooks.emit('kubb:lint:end'),
-    },
-  ].filter(Boolean) as Array<{ code: ProblemDiagnostic['code'] } & Omit<RunToolPassOptions, 'configName' | 'outputPath' | 'logLevel' | 'hooks'>>
-
-  for (const { code, ...pass } of toolPasses) {
-    try {
-      await runToolPass({ ...pass, configName: config.name, outputPath, logLevel, hooks })
-    } catch (caughtError) {
-      const diagnostic = outputDiagnostic(code, pass.toolLabel, caughtError)
-      outputDiagnostics.push(diagnostic)
-      await Diagnostics.emit(hooks, diagnostic)
-    }
-  }
-
-  if (config.hooks) {
-    await hooks.emit('kubb:hooks:start')
-    // `runHook` reports a failed `done` hook via `kubb:hook:end` rather than throwing, so listen
-    // for it across this pass and collect each failure.
-    const hookFailures: Array<Error> = []
-    const onHookEnd = (ctx: { success: boolean; error: Error | null }) => {
-      if (!ctx.success) hookFailures.push(ctx.error ?? new Error('Post-generate hook failed'))
-    }
-    hooks.on('kubb:hook:end', onHookEnd)
-    try {
-      await executeHooks({ configHooks: config.hooks, hooks })
-    } finally {
-      hooks.off('kubb:hook:end', onHookEnd)
-    }
-    for (const error of hookFailures) {
-      const diagnostic = outputDiagnostic(Diagnostics.code.hookFailed, 'Post-generate hook', error)
-      outputDiagnostics.push(diagnostic)
-      await Diagnostics.emit(hooks, diagnostic)
-    }
-    await hooks.emit('kubb:hooks:end')
-  }
-
-  const finalDiagnostics = [...diagnostics, ...outputDiagnostics]
-  const failed = Diagnostics.hasError(outputDiagnostics)
-
-  if (!failed) {
-    await hooks.emit('kubb:success', { message: 'Generation succeeded', info: inputPath })
-  }
-
-  await hooks.emit('kubb:generation:end', {
-    config,
-    storage: kubb.storage,
-    diagnostics: finalDiagnostics,
-    filesCreated: files.length,
-    status: failed ? 'failed' : 'success',
-    hrStart,
-  })
-
-  await reportTelemetry(failed ? 'failed' : 'success')
-  return !failed
-}
-
-/**
- * Builds a coded diagnostic for an output-phase failure (formatter, linter, or `done` hook).
- */
-function outputDiagnostic(code: ProblemDiagnostic['code'], label: string, caughtError: unknown): ProblemDiagnostic {
-  const error = toError(caughtError)
-  return {
-    code,
-    severity: 'error',
-    message: `${label} failed: ${error.message}`,
-    help: 'Check that the tool is installed and that the command and its config are correct.',
-    location: { kind: 'config' },
-    cause: error,
-  }
-}
-
-type GenerateCommandOptions = {
-  input?: string
-  configPath?: string
-  logLevel: string
-  watch: boolean
-  reporters?: Array<ReporterName>
-}
-
-async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void> {
-  try {
-    const res = await fetch(KUBB_NPM_PACKAGE_URL)
-    const data = (await res.json()) as { version: string }
-    if (data.version && version < data.version) {
-      await Diagnostics.emit(hooks, Diagnostics.update({ currentVersion: version, latestVersion: data.version }))
-    }
-  } catch {
-    // Ignore network errors
-  }
-}
-
-/**
- * Runs the full Kubb generation lifecycle for the given CLI options.
- * Loads configs, sets up the reporters (CLI `--reporter` picks which of `config.reporters` to trigger),
- * checks for a newer version, and calls `generate` for each config entry.
- */
-export async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters }: GenerateCommandOptions): Promise<void> {
-  const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
-  const hooks = new AsyncEventEmitterClass<KubbHooks>()
-
-  // Load the config first so `config.reporters` can pick the reporters. A failure here has no
-  // reporter installed yet, so fall back to the default `cli` reporter to surface it.
-  let configs: Array<Config>
-  let resolvedConfigPath: string
-  try {
-    const loaded = await getConfigs({
-      configPath,
-      input,
-      watch,
-      logLevel: logLevelKey as CLIOptions['logLevel'],
-    })
-    configs = loaded.configs
-    resolvedConfigPath = loaded.configPath
-  } catch (error) {
-    await setupReporters(hooks, { logLevel, reporters: [cliReporter] })
-    await hooks.emit('kubb:error', { error: toError(error) })
-    process.exit(1)
-  }
-
-  // CLI `--reporter` selects which reporters to trigger by name, defaulting to `cli`. The config
-  // always carries the available reporters (defineConfig registers the built-ins).
-  const requestedNames: Array<ReporterName> = cliReporters?.length ? cliReporters : ['cli']
-  const available = configs[0]?.reporters ?? []
-  const reporters = selectReporters(available, requestedNames)
-  await setupReporters(hooks, { logLevel, reporters })
-
-  await hooks.emit('kubb:lifecycle:start', { version })
-
-  await checkForUpdate(hooks)
-
-  try {
-    const relativeConfigPath = path.relative(process.cwd(), resolvedConfigPath)
-
-    await hooks.emit('kubb:info', { message: 'Config loaded', info: relativeConfigPath })
-    await hooks.emit('kubb:success', { message: 'Config loaded successfully', info: relativeConfigPath })
-
-    let anyFailed = false
-    for (const config of configs) {
-      if (config.input && 'path' in config.input && watch) {
-        await startWatcher(
-          [input || config.input.path],
-          async (paths) => {
-            // Don't removeAll(), that would also drop logger and lifecycle listeners.
-            // Plugin listeners are already disposed by safeBuild's
-            // setupResult.dispose() in its finally block, so re-running generate()
-            // on the same hooks emitter is safe.
-            await generate({ input, config, logLevel, hooks })
-            clack.log.step(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))
-          },
-          { info: (msg) => clack.log.info(msg), error: (msg) => clack.log.error(msg) },
-        )
-      } else {
-        try {
-          const succeeded = await generate({ input, config, logLevel, hooks })
-          if (!succeeded) anyFailed = true
-        } catch (configError) {
-          await hooks.emit('kubb:error', { error: toError(configError) })
-          anyFailed = true
-        }
-      }
-    }
-
-    await hooks.emit('kubb:lifecycle:end')
-
-    if (anyFailed) {
-      process.exit(1)
-    }
-  } catch (error) {
-    await hooks.emit('kubb:error', { error: toError(error) })
-    process.exit(1)
-  }
-}