@kubb/cli 5.0.0-beta.3 → 5.0.0-beta.31

package/src/loggers/clackLogger.ts

@@ -2,12 +2,10 @@ import { relative } from 'node:path'
 import process from 'node:process'
 import { styleText } from 'node:util'
 import * as clack from '@clack/prompts'
-import { formatMs, formatMsWithColor, getIntro, toCause } from '@internals/utils'
-import { defineLogger, logLevel as logLevelMap } from '@kubb/core'
-import { getSummary } from '../utils/getSummary.ts'
-import { runHook } from '../utils/runHook.ts'
-import { ClackWritable } from '../utils/Writables.ts'
-import { buildProgressLine, formatCommandWithArgs, formatMessage } from './utils.ts'
+import { formatMs, formatMsWithColor, getElapsedMs, getIntro, toCause } from '@internals/utils'
+import { defineLogger, type KubbHooks, logLevel as logLevelMap } from '@kubb/core'
+import { getSummary } from './utils.ts'
+import { buildProgressLine, createProgressCounters, formatCommandWithArgs, formatMessage, recordPluginResult, resetProgressCounters } from './utils.ts'
 
 /**
  * TTY logger with beautiful UI and progress indicators for local development.
@@ -17,15 +15,11 @@ export const clackLogger = defineLogger({
   install(context, options) {
     const logLevel = options?.logLevel ?? logLevelMap.info
     const state = {
-      totalPlugins: 0,
-      completedPlugins: 0,
-      failedPlugins: 0,
-      totalFiles: 0,
-      processedFiles: 0,
-      hrStart: process.hrtime(),
+      ...createProgressCounters(),
       spinner: clack.spinner(),
       isSpinning: false,
       activeProgress: new Map<string, { interval?: NodeJS.Timeout; progressBar: clack.ProgressResult }>(),
+      activeHookLogs: new Map<string, { taskLog: ReturnType<typeof clack.taskLog>; hrStart: [number, number] }>(),
     }
 
     function reset() {
@@ -36,15 +30,11 @@ export const clackLogger = defineLogger({
         active.progressBar?.stop()
       }
 
-      state.totalPlugins = 0
-      state.completedPlugins = 0
-      state.failedPlugins = 0
-      state.totalFiles = 0
-      state.processedFiles = 0
-      state.hrStart = process.hrtime()
+      resetProgressCounters(state)
       state.spinner = clack.spinner()
       state.isSpinning = false
       state.activeProgress.clear()
+      state.activeHookLogs.clear()
     }
 
     function showProgressStep() {
@@ -62,12 +52,25 @@ export const clackLogger = defineLogger({
       return formatMessage(message, logLevel)
     }
 
+    // Registers a handler that prints a fixed step message, skipped at silent level.
+    function onStep<E extends keyof KubbHooks>(event: E, message: string): void {
+      context.on(event, () => {
+        if (logLevel <= logLevelMap.silent) {
+          return
+        }
+        clack.log.step(getMessage(message))
+      })
+    }
+
     function startSpinner(text?: string) {
       state.spinner.start(text)
       state.isSpinning = true
     }
 
     function stopSpinner(text?: string) {
+      if (!state.isSpinning) {
+        return
+      }
       state.spinner.stop(text)
       state.isSpinning = false
     }
@@ -81,9 +84,9 @@ export const clackLogger = defineLogger({
 
       if (state.isSpinning) {
         state.spinner.message(text)
-      } else {
-        clack.log.info(text)
+        return
       }
+      clack.log.info(text)
     })
 
     context.on('kubb:success', ({ message, info = '' }) => {
@@ -95,9 +98,9 @@ export const clackLogger = defineLogger({
 
       if (state.isSpinning) {
         stopSpinner(text)
-      } else {
-        clack.log.success(text)
+        return
       }
+      clack.log.success(text)
     })
 
     context.on('kubb:warn', ({ message, info }) => {
@@ -119,9 +122,9 @@ export const clackLogger = defineLogger({
 
       if (state.isSpinning) {
         stopSpinner(getMessage(text))
-      } else {
-        clack.log.error(getMessage(text))
+        return
       }
+      clack.log.error(getMessage(text))
 
       // Show stack trace in debug mode (first 3 frames)
       if (logLevel >= logLevelMap.debug && error.stack) {
@@ -199,6 +202,10 @@ Run \`npm install -g @kubb/cli\` to update`,
       // Initialize progress tracking for this generation
       state.totalPlugins = config.plugins?.length ?? 0
 
+      if (logLevel <= logLevelMap.silent) {
+        return
+      }
+
       const text = getMessage(['Generation started', config.name ? `for ${styleText('dim', config.name)}` : undefined].filter(Boolean).join(' '))
 
       clack.intro(text)
@@ -237,11 +244,7 @@ Run \`npm install -g @kubb/cli\` to update`,
 
       clearInterval(active.interval)
 
-      if (success) {
-        state.completedPlugins++
-      } else {
-        state.failedPlugins++
-      }
+      recordPluginResult(state, success)
 
       const durationStr = formatMsWithColor(duration)
       const text = getMessage(
@@ -279,23 +282,20 @@ Run \`npm install -g @kubb/cli\` to update`,
       state.activeProgress.set('files', { progressBar })
     })
 
-    context.on('kubb:file:processing:update', ({ file, config }) => {
+    context.on('kubb:files:processing:update', ({ files }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
       stopSpinner()
 
-      state.processedFiles++
-
-      const text = `Writing ${relative(config.root, file.path)}`
       const active = state.activeProgress.get('files')
-
-      if (!active) {
-        return
+      for (const { file, config } of files) {
+        state.processedFiles++
+        if (active) {
+          active.progressBar.advance(undefined, `Writing ${relative(config.root, file.path)}`)
+        }
       }
-
-      active.progressBar.advance(undefined, text)
     })
     context.on('kubb:files:processing:end', () => {
       if (logLevel <= logLevelMap.silent) {
@@ -319,107 +319,51 @@ Run \`npm install -g @kubb/cli\` to update`,
     })
 
     context.on('kubb:generation:end', ({ config }) => {
+      stopSpinner()
+
       const text = getMessage(config.name ? `Generation completed for ${styleText('dim', config.name)}` : 'Generation completed')
 
       clack.outro(text)
     })
 
-    context.on('kubb:format:start', () => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage('Format started')
-
-      clack.intro(text)
-    })
-
-    context.on('kubb:format:end', () => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage('Format completed')
+    onStep('kubb:format:start', 'Formatting')
+    onStep('kubb:lint:start', 'Linting')
+    onStep('kubb:hooks:start', 'Running hooks')
 
-      clack.outro(text)
-    })
-
-    context.on('kubb:lint:start', () => {
-      if (logLevel <= logLevelMap.silent) {
+    context.on('kubb:hook:start', ({ id, command, args }) => {
+      if (logLevel <= logLevelMap.silent || !id) {
         return
       }
 
-      const text = getMessage('Lint started')
-
-      clack.intro(text)
-    })
-
-    context.on('kubb:lint:end', () => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage('Lint completed')
-
-      clack.outro(text)
-    })
+      stopSpinner()
 
-    context.on('kubb:hook:start', async ({ id, command, args }) => {
       const commandWithArgs = formatCommandWithArgs(command, args)
-      const text = getMessage(`Hook ${styleText('dim', commandWithArgs)} started`)
+      const title = getMessage(`Running ${styleText('dim', commandWithArgs)}`)
+      const taskLog = clack.taskLog({ title })
 
-      // Skip hook execution if no id is provided (e.g., during benchmarks or tests)
-      if (!id) {
-        return
-      }
+      state.activeHookLogs.set(id, { taskLog, hrStart: process.hrtime() })
+    })
 
-      if (logLevel <= logLevelMap.silent) {
-        await runHook({
-          id,
-          command,
-          args,
-          commandWithArgs,
-          context,
-          sink: {
-            onStderr: (s) => console.error(s),
-            onStdout: (s) => console.log(s),
-          },
-        })
+    context.on('kubb:hook:end', ({ id, command, args, success, error }) => {
+      if (logLevel <= logLevelMap.silent || !id) {
         return
       }
 
-      clack.intro(text)
-
-      const logger = clack.taskLog({
-        title: getMessage(['Executing hook', logLevel >= logLevelMap.info ? styleText('dim', commandWithArgs) : undefined].filter(Boolean).join(' ')),
-      })
-
-      const writable = new ClackWritable(logger)
-
-      await runHook({
-        id,
-        command,
-        args,
-        commandWithArgs,
-        context,
-        stream: true,
-        sink: {
-          onLine: (line) => writable.write(line),
-          onStderr: (s) => logger.error(s),
-          onStdout: (s) => logger.message(s),
-        },
-      })
-    })
-
-    context.on('kubb:hook:end', ({ command, args }) => {
-      if (logLevel <= logLevelMap.silent) {
+      const active = state.activeHookLogs.get(id)
+      if (!active) {
         return
       }
+      state.activeHookLogs.delete(id)
 
       const commandWithArgs = formatCommandWithArgs(command, args)
-      const text = getMessage(`Hook ${styleText('dim', commandWithArgs)} successfully executed`)
+      const duration = formatMsWithColor(getElapsedMs(active.hrStart))
 
-      clack.outro(text)
+      if (success) {
+        active.taskLog.success(getMessage(`${styleText('dim', commandWithArgs)} completed in ${duration}`))
+      } else {
+        const reason = error?.message ? ` (${error.message})` : ''
+        active.taskLog.error(getMessage(`${styleText('dim', commandWithArgs)} failed${reason}`), { showLog: true })
+      }
     })
 
     context.on('kubb:generation:summary', ({ config, pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
@@ -454,5 +398,28 @@ Run \`npm install -g @kubb/cli\` to update`,
     context.on('kubb:lifecycle:end', () => {
       reset()
     })
+
+    return (_commandWithArgs: string, hookId: string) => {
+      if (logLevel <= logLevelMap.silent) {
+        return {
+          onStdout: (s: string) => console.log(s),
+          onStderr: (s: string) => console.error(s),
+        }
+      }
+
+      const active = state.activeHookLogs.get(hookId)
+      if (!active) {
+        return null
+      }
+
+      const { taskLog } = active
+
+      return {
+        stream: true,
+        onLine: (line: string) => taskLog.message(styleText('dim', line)),
+        onStdout: (s: string) => taskLog.message(s),
+        onStderr: (s: string) => taskLog.message(styleText('red', s)),
+      }
+    }
   },
 })

package/src/loggers/fileSystemLogger.ts

@@ -4,14 +4,24 @@ import { formatMs, write } from '@internals/utils'
 import { defineLogger } from '@kubb/core'
 
 type CachedEvent = {
+  /**
+   * Timestamp when this event was captured, used to derive the log filename.
+   */
   date: Date
-  logs: string[]
+  /**
+   * Accumulated log lines for this event.
+   */
+  logs: Array<string>
+  /**
+   * Optional override for the output filename inside `.kubb/`. When omitted, the filename is derived from `date`.
+   */
   fileName?: string
 }
 
 /**
  * FileSystem logger that captures debug events and writes them to `.kubb` directory files.
- * Note: Logs write on `lifecycle:end` or process exit. Cached logs may be lost if the process crashes before these events.
+ *
+ * @note Logs are written on `kubb:lifecycle:end` or process exit. Cached logs may be lost if the process crashes before either event.
  */
 export const fileSystemLogger = defineLogger({
   name: 'filesystem',
@@ -31,7 +41,7 @@ export const fileSystemLogger = defineLogger({
         return []
       }
 
-      const files: Record<string, string[]> = {}
+      const files: Record<string, Array<string>> = {}
 
       for (const log of state.cachedLogs) {
         const baseName = log.fileName || `${['kubb', name, state.startDate].filter(Boolean).join('-')}.log`
@@ -42,13 +52,15 @@ export const fileSystemLogger = defineLogger({
         }
 
         if (log.logs.length > 0) {
-          const timestamp = log.date.toLocaleString()
-          files[pathName].push(`[${timestamp}]\n${log.logs.join('\n')}`)
+          const prefix = `[${log.date.toLocaleString()}] `
+          const indent = ' '.repeat(prefix.length)
+          const [first, ...rest] = log.logs
+          files[pathName].push([prefix + first, ...rest.map((line) => indent + line)].join('\n'))
         }
       }
 
       for (const [fileName, logs] of Object.entries(files)) {
-        await write(fileName, logs.join('\n\n'))
+        await write(fileName, logs.join('\n'))
       }
 
       return Object.keys(files)
@@ -57,21 +69,21 @@ export const fileSystemLogger = defineLogger({
     context.on('kubb:info', ({ message, info }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`ℹ ${message} ${info}`],
+        logs: [`ℹ ${[message, info].filter(Boolean).join(' ')}`],
       })
     })
 
     context.on('kubb:success', ({ message, info }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`✓ ${message} ${info}`],
+        logs: [`✓ ${[message, info].filter(Boolean).join(' ')}`],
       })
     })
 
     context.on('kubb:warn', ({ message, info }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`⚠ ${message} ${info}`],
+        logs: [`⚠ ${[message, info].filter(Boolean).join(' ')}`],
       })
     })
 
@@ -82,17 +94,18 @@ export const fileSystemLogger = defineLogger({
       })
     })
 
-    context.on('kubb:debug', (message) => {
+    context.on('kubb:debug', ({ date, fileName, logs }) => {
       state.cachedLogs.add({
-        date: new Date(),
-        logs: message.logs,
+        date,
+        fileName,
+        logs,
       })
     })
 
     context.on('kubb:plugin:start', ({ plugin }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`Generating ${plugin.name}`],
+        logs: [`► Generating ${plugin.name}`],
       })
     })
 
@@ -101,14 +114,14 @@ export const fileSystemLogger = defineLogger({
 
       state.cachedLogs.add({
         date: new Date(),
-        logs: [success ? `${plugin.name} completed in ${durationStr}` : `${plugin.name} failed in ${durationStr}`],
+        logs: [success ? `✓ ${plugin.name} completed in ${durationStr}` : `✗ ${plugin.name} failed in ${durationStr}`],
       })
     })
 
     context.on('kubb:files:processing:start', ({ files }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`Start ${files.length} writing:`, ...files.map((file) => file.path)],
+        logs: [`► Writing ${files.length} files`, ...files.map((file) => `  ${file.path}`)],
       })
     })