@kubb/cli 5.0.0-beta.6 → 5.0.0-beta.61

package/src/loggers/plainLogger.ts

@@ -1,23 +1,32 @@
 import { relative } from 'node:path'
 import { formatMs, toCause } from '@internals/utils'
-import { defineLogger, logLevel as logLevelMap } from '@kubb/core'
-import { SUMMARY_SEPARATOR } from '../constants.ts'
-import { getSummary } from '../utils/getSummary.ts'
-import { runHook } from '../utils/runHook.ts'
-import { formatCommandWithArgs, formatMessage } from './utils.ts'
+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 with simple `console.log` output.
+ * 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
@@ -55,8 +64,8 @@ export const plainLogger = defineLogger({
 
       console.log(text)
 
-      // Show stack trace in debug mode (first 3 frames)
-      if (logLevel >= logLevelMap.debug && error.stack) {
+      // 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()))
@@ -73,28 +82,16 @@ export const plainLogger = defineLogger({
       }
     })
 
-    context.on('kubb:lifecycle:start', () => {
-      console.log('Kubb CLI 🧩')
-    })
-
-    context.on('kubb:config:start', () => {
-      if (logLevel <= logLevelMap.silent) {
+    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
       }
-
-      const text = getMessage('Configuration started')
-
-      console.log(text)
+      console.log(getMessage(Diagnostics.formatLines(diagnostic).join('\n')))
     })
 
-    context.on('kubb:config:end', () => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage('Configuration completed')
-
-      console.log(text)
+    context.on('kubb:lifecycle:start', ({ version }) => {
+      console.log(`Kubb CLI v${version}`)
     })
 
     context.on('kubb:generation:start', () => {
@@ -133,14 +130,14 @@ export const plainLogger = defineLogger({
       console.log(text)
     })
 
-    context.on('kubb:file:processing:update', ({ file, config }) => {
+    context.on('kubb:files:processing:update', ({ files }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      const text = getMessage(`Writing ${relative(config.root, file.path)}`)
-
-      console.log(text)
+      for (const { file, config } of files) {
+        console.log(getMessage(`Writing ${relative(config.root, file.path)}`))
+      }
     })
 
     context.on('kubb:files:processing:end', () => {
@@ -159,96 +156,44 @@ export const plainLogger = defineLogger({
       console.log(text)
     })
 
-    context.on('kubb:format:start', () => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage('Format started')
+    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')
 
-      console.log(text)
-    })
-
-    context.on('kubb:format:end', () => {
+    context.on('kubb:hook:start', ({ id, command, args }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      const text = getMessage('Format completed')
-
-      console.log(text)
-    })
-
-    context.on('kubb:lint:start', () => {
-      if (logLevel <= logLevelMap.silent) {
-        return
+      if (id) {
+        hookTimer.start(id)
       }
 
-      const text = getMessage('Lint started')
-
-      console.log(text)
+      const commandWithArgs = formatCommandWithArgs(command, args)
+      console.log(getMessage(`Hook ${commandWithArgs} started`))
     })
 
-    context.on('kubb:lint:end', () => {
+    context.on('kubb:hook:end', ({ id, command, args, success, error, stdout, stderr }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      const text = getMessage('Lint completed')
+      const ms = id ? hookTimer.end(id) : undefined
+      const durationStr = ms !== undefined ? ` in ${formatMs(ms)}` : ''
 
-      console.log(text)
-    })
-
-    context.on('kubb:hook:start', async ({ id, command, args }) => {
       const commandWithArgs = formatCommandWithArgs(command, args)
-      const text = getMessage(`Hook ${commandWithArgs} started`)
-
-      if (logLevel > logLevelMap.silent) {
-        console.log(text)
-      }
-
-      // Skip hook execution if no id is provided (e.g., during benchmarks or tests)
-      if (!id) {
-        return
-      }
-
-      await runHook({
-        id,
-        command,
-        args,
-        commandWithArgs,
-        context,
-        sink: {
-          onStdout: logLevel > logLevelMap.silent ? (s) => console.log(s) : undefined,
-          onStderr: logLevel > logLevelMap.silent ? (s) => console.error(s) : undefined,
-        },
-      })
-    })
 
-    context.on('kubb:hook:end', ({ command, args }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
+      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}`))
       }
-
-      const commandWithArgs = formatCommandWithArgs(command, args)
-      const text = getMessage(`Hook ${commandWithArgs} completed`)
-
-      console.log(text)
-    })
-
-    context.on('kubb:generation:summary', ({ config, pluginTimings, status, hrStart, failedPlugins, filesCreated }) => {
-      const summary = getSummary({
-        failedPlugins,
-        filesCreated,
-        config,
-        status,
-        hrStart,
-        pluginTimings: logLevel >= logLevelMap.verbose ? pluginTimings : undefined,
-      })
-
-      console.log(SUMMARY_SEPARATOR)
-      console.log(summary.join('\n'))
-      console.log(SUMMARY_SEPARATOR)
     })
   },
 })

package/src/loggers/types.ts

@@ -1 +1,6 @@
-export type LoggerType = 'clack' | 'github-actions' | 'plain'
+/**
+ * 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,10 +1,10 @@
+import process from 'node:process'
 import { styleText } from 'node:util'
-import { canUseTTY, formatHrtime, isGitHubActions } from '@internals/utils'
-import type { Logger, LoggerContext, LoggerOptions } from '@kubb/core'
+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 { fileSystemLogger } from './fileSystemLogger.ts'
-import { githubActionsLogger } from './githubActionsLogger.ts'
 import { plainLogger } from './plainLogger.ts'
 import type { LoggerType } from './types.ts'
 
@@ -26,20 +26,38 @@ export function formatMessage(message: string, logLevel: number): string {
 }
 
 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 shared by clack and GitHub Actions loggers.
+ * 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: string[] = []
+  const parts: Array<string> = []
   const duration = formatHrtime(state.hrStart)
 
   if (state.totalPlugins > 0) {
@@ -62,45 +80,170 @@ export function buildProgressLine(state: ProgressState): string | null {
   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.
- * e.g. ("prettier", ["--write", "."]) → "prettier --write ."
+ *
+ * @example
+ * `formatCommandWithArgs('prettier', ['--write', '.']) → 'prettier --write .'`
  */
-export function formatCommandWithArgs(command: string, args?: readonly string[]): string {
+export function formatCommandWithArgs(command: string, args?: ReadonlyArray<string>): string {
   return args?.length ? `${command} ${args.join(' ')}` : command
 }
 
 function detectLogger(): LoggerType {
-  if (isGitHubActions()) {
-    return 'github-actions'
-  }
   if (canUseTTY()) {
     return 'clack'
   }
   return 'plain'
 }
 
-const logMapper = {
+const logMapper: Record<LoggerType, Logger> = {
   clack: clackLogger,
   plain: plainLogger,
-  'github-actions': githubActionsLogger,
-} as const satisfies Record<LoggerType, Logger>
+}
 
-export async function setupLogger(context: LoggerContext, { logLevel }: LoggerOptions): Promise<void> {
-  const type = detectLogger()
+/**
+ * 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)
+  })
 
-  const logger = logMapper[type] as Logger
+  if (reporter.drain) {
+    context.on('kubb:lifecycle:end', () => reporter.drain?.(ctx))
+  }
+}
 
-  if (!logger) {
-    throw new Error(`Unknown adapter type: ${type}`)
+/**
+ * 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)
   }
+}
 
-  // Install primary logger
-  const cleanup = await logger.install(context, { logLevel })
+export default setupReporters
 
-  if (logLevel >= logLevelMap.debug) {
-    await fileSystemLogger.install(context, { logLevel })
+/**
+ * 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 cleanup
+  return selected
 }