@kubb/cli 5.0.0-beta.2 → 5.0.0-beta.21

package/src/loggers/clackLogger.ts

@@ -2,11 +2,9 @@ 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 { formatMs, formatMsWithColor, getElapsedMs, 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 { getSummary } from './utils.ts'
 import { buildProgressLine, formatCommandWithArgs, formatMessage } from './utils.ts'
 
 /**
@@ -26,6 +24,7 @@ export const clackLogger = defineLogger({
       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() {
@@ -45,6 +44,7 @@ export const clackLogger = defineLogger({
       state.spinner = clack.spinner()
       state.isSpinning = false
       state.activeProgress.clear()
+      state.activeHookLogs.clear()
     }
 
     function showProgressStep() {
@@ -68,6 +68,9 @@ export const clackLogger = defineLogger({
     }
 
     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)
@@ -279,23 +286,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,6 +323,8 @@ 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)
@@ -329,97 +335,59 @@ Run \`npm install -g @kubb/cli\` to update`,
         return
       }
 
-      const text = getMessage('Format started')
-
-      clack.intro(text)
+      clack.log.step(getMessage('Formatting'))
     })
 
-    context.on('kubb:format:end', () => {
+    context.on('kubb:lint:start', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      const text = getMessage('Format completed')
-
-      clack.outro(text)
+      clack.log.step(getMessage('Linting'))
     })
 
-    context.on('kubb:lint:start', () => {
+    context.on('kubb:hooks:start', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      const text = getMessage('Lint started')
-
-      clack.intro(text)
+      clack.log.step(getMessage('Running hooks'))
     })
 
-    context.on('kubb:lint:end', () => {
-      if (logLevel <= logLevelMap.silent) {
+    context.on('kubb:hook:start', ({ id, command, args }) => {
+      if (logLevel <= logLevelMap.silent || !id) {
         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 +422,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
+  /**
+   * Accumulated log lines for this event.
+   */
   logs: 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',
@@ -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}`)],
       })
     })
 

package/src/loggers/githubActionsLogger.ts

@@ -1,7 +1,7 @@
+import process from 'node:process'
 import { styleText } from 'node:util'
-import { formatHrtime, formatMs, formatMsWithColor, toCause } from '@internals/utils'
+import { formatHrtime, formatMs, formatMsWithColor, getElapsedMs, toCause } from '@internals/utils'
 import { type Config, defineLogger, logLevel as logLevelMap } from '@kubb/core'
-import { runHook } from '../utils/runHook.ts'
 import { buildProgressLine, formatCommandWithArgs, formatMessage } from './utils.ts'
 
 /**
@@ -19,9 +19,12 @@ export const githubActionsLogger = defineLogger({
       processedFiles: 0,
       hrStart: process.hrtime(),
       currentConfigs: [] as Array<Config>,
+      hookStarts: new Map<string, [number, number]>(),
+      openGroupDepth: 0,
     }
 
     function reset() {
+      closeAllGroups()
       state.totalPlugins = 0
       state.completedPlugins = 0
       state.failedPlugins = 0
@@ -29,6 +32,7 @@ export const githubActionsLogger = defineLogger({
       state.processedFiles = 0
       state.hrStart = process.hrtime()
       state.currentConfigs = []
+      state.hookStarts.clear()
     }
 
     function showProgressStep() {
@@ -48,10 +52,19 @@ export const githubActionsLogger = defineLogger({
 
     function openGroup(name: string) {
       console.log(`::group::${name}`)
+      state.openGroupDepth++
     }
 
     function closeGroup(_name: string) {
       console.log('::endgroup::')
+      if (state.openGroupDepth > 0) state.openGroupDepth--
+    }
+
+    function closeAllGroups() {
+      while (state.openGroupDepth > 0) {
+        console.log('::endgroup::')
+        state.openGroupDepth--
+      }
     }
 
     context.on('kubb:info', ({ message, info = '' }) => {
@@ -87,6 +100,10 @@ export const githubActionsLogger = defineLogger({
     context.on('kubb:error', ({ error }) => {
       const caused = toCause(error)
 
+      // Always release any unclosed groups so a thrown :start without a matching :end
+      // (e.g., when getConfigs or kubb.setup throws) doesn't leak an open section.
+      closeAllGroups()
+
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -116,6 +133,10 @@ export const githubActionsLogger = defineLogger({
       reset()
     })
 
+    context.on('kubb:version:new', ({ currentVersion, latestVersion }) => {
+      console.log(`::notice::Update available for Kubb: v${currentVersion} → v${latestVersion}. Run \`npm install -g @kubb/cli\` to update.`)
+    })
+
     context.on('kubb:config:start', () => {
       if (logLevel <= logLevelMap.silent) {
         return
@@ -235,12 +256,12 @@ export const githubActionsLogger = defineLogger({
       showProgressStep()
     })
 
-    context.on('kubb:file:processing:update', () => {
+    context.on('kubb:files:processing:update', ({ files }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      state.processedFiles++
+      state.processedFiles += files.length
     })
 
     context.on('kubb:generation:end', ({ config }) => {
@@ -307,45 +328,65 @@ export const githubActionsLogger = defineLogger({
       }
     })
 
-    context.on('kubb:hook:start', async ({ id, command, args }) => {
-      const commandWithArgs = formatCommandWithArgs(command, args)
-      const text = getMessage(`Hook ${styleText('dim', commandWithArgs)} started`)
+    context.on('kubb:hooks:start', () => {
+      if (logLevel <= logLevelMap.silent) {
+        return
+      }
 
-      if (logLevel > logLevelMap.silent) {
-        if (state.currentConfigs.length === 1) {
-          openGroup(`Hook ${commandWithArgs}`)
-        }
-        console.log(text)
+      if (state.currentConfigs.length === 1) {
+        openGroup('Hooks')
       }
 
-      // Skip hook execution if no id is provided (e.g., during benchmarks or tests)
-      if (!id) {
+      console.log(getMessage('Hooks started'))
+    })
+
+    context.on('kubb:hooks:end', () => {
+      if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      await runHook({
-        id,
-        command,
-        args,
-        commandWithArgs,
-        context,
-        sink: {
-          // GHA formats errors with the ::error:: annotation
-          onStdout: logLevel > logLevelMap.silent ? (s) => console.log(s) : undefined,
-          onStderr: logLevel > logLevelMap.silent ? (s) => console.error(`::error::${s}`) : undefined,
-        },
-      })
+      console.log(getMessage('Hooks completed'))
+
+      if (state.currentConfigs.length === 1) {
+        closeGroup('Hooks')
+      }
     })
 
-    context.on('kubb:hook:end', ({ command, args }) => {
+    context.on('kubb:hook:start', ({ id, command, args }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
+      if (id) {
+        state.hookStarts.set(id, process.hrtime())
+      }
+
       const commandWithArgs = formatCommandWithArgs(command, args)
-      const text = getMessage(`Hook ${styleText('dim', commandWithArgs)} completed`)
+      const text = getMessage(`Hook ${styleText('dim', commandWithArgs)} started`)
 
+      if (state.currentConfigs.length === 1) {
+        openGroup(`Hook ${commandWithArgs}`)
+      }
       console.log(text)
+    })
+
+    context.on('kubb:hook:end', ({ id, command, args, success, error }) => {
+      if (logLevel <= logLevelMap.silent) {
+        return
+      }
+
+      const hrStart = id ? state.hookStarts.get(id) : undefined
+      if (id) state.hookStarts.delete(id)
+      const durationStr = hrStart ? ` in ${formatMsWithColor(getElapsedMs(hrStart))}` : ''
+
+      const commandWithArgs = formatCommandWithArgs(command, args)
+
+      if (success) {
+        console.log(getMessage(`${styleText('green', '✓')} Hook ${styleText('dim', commandWithArgs)} completed${durationStr}`))
+      } else {
+        const reason = error?.message ? ` (${error.message})` : ''
+        console.log(`::error::Hook ${commandWithArgs} failed${durationStr}${reason}`)
+      }
 
       if (state.currentConfigs.length === 1) {
         closeGroup(`Hook ${commandWithArgs}`)
@@ -375,5 +416,10 @@ export const githubActionsLogger = defineLogger({
     context.on('kubb:lifecycle:end', () => {
       reset()
     })
+
+    return (_commandWithArgs: string, _hookId: string) => ({
+      onStdout: logLevel > logLevelMap.silent ? (s: string) => console.log(s) : undefined,
+      onStderr: logLevel > logLevelMap.silent ? (s: string) => console.error(`::error::${s}`) : undefined,
+    })
   },
 })