@kubb/cli 5.0.0-alpha.9 → 5.0.0-beta.10

package/src/loggers/clackLogger.ts

@@ -4,14 +4,30 @@ 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 { getSummary } from './utils.ts'
 import { buildProgressLine, formatCommandWithArgs, formatMessage } from './utils.ts'
+import { Writable } from 'node:stream'
+import type { WritableOptions } from 'node:stream'
 
 /**
- * Clack adapter for local TTY environments
- * Provides a beautiful CLI UI with flat structure inspired by Claude's CLI patterns
+ * Node.js `Writable` stream that forwards each chunk to a clack `taskLog` message.
+ * Used to pipe hook subprocess output into the clack task log UI.
+ */
+class ClackWritable extends Writable {
+  taskLog: ReturnType<typeof clack.taskLog>
+  constructor(taskLog: ReturnType<typeof clack.taskLog>, opts?: WritableOptions) {
+    super(opts)
+
+    this.taskLog = taskLog
+  }
+  _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+    this.taskLog.message(`${styleText('dim', chunk.toString())}`)
+    callback()
+  }
+}
+
+/**
+ * TTY logger with beautiful UI and progress indicators for local development.
  */
 export const clackLogger = defineLogger({
   name: 'clack',
@@ -73,7 +89,7 @@ export const clackLogger = defineLogger({
       state.isSpinning = false
     }
 
-    context.on('info', (message, info = '') => {
+    context.on('kubb:info', ({ message, info = '' }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -87,7 +103,7 @@ export const clackLogger = defineLogger({
       }
     })
 
-    context.on('success', (message, info = '') => {
+    context.on('kubb:success', ({ message, info = '' }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -101,7 +117,7 @@ export const clackLogger = defineLogger({
       }
     })
 
-    context.on('warn', (message, info) => {
+    context.on('kubb:warn', ({ message, info }) => {
       if (logLevel < logLevelMap.warn) {
         return
       }
@@ -113,7 +129,7 @@ export const clackLogger = defineLogger({
       clack.log.warn(text)
     })
 
-    context.on('error', (error) => {
+    context.on('kubb:error', ({ error }) => {
       const caused = toCause(error)
 
       const text = [styleText('red', '✗'), error.message].join(' ')
@@ -142,33 +158,38 @@ export const clackLogger = defineLogger({
       }
     })
 
-    context.on('version:new', (version, latestVersion) => {
+    context.on('kubb:version:new', ({ currentVersion, latestVersion }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      clack.box(
-        `\`v${version}\` → \`v${latestVersion}\`
+      try {
+        clack.box(
+          `\`v${currentVersion}\` → \`v${latestVersion}\`
 Run \`npm install -g @kubb/cli\` to update`,
-        'Update available for `Kubb`',
-        {
-          width: 'auto',
-          formatBorder: (s: string) => styleText('yellow', s),
-          rounded: true,
-          withGuide: false,
-          contentAlign: 'center',
-          titleAlign: 'center',
-        },
-      )
+          'Update available for `Kubb`',
+          {
+            width: 'auto',
+            formatBorder: (s: string) => styleText('yellow', s),
+            rounded: true,
+            withGuide: false,
+            contentAlign: 'center',
+            titleAlign: 'center',
+          },
+        )
+      } catch {
+        console.log(`Update available for Kubb: v${currentVersion} → v${latestVersion}`)
+        console.log('Run `npm install -g @kubb/cli` to update')
+      }
     })
 
-    context.on('lifecycle:start', async (version) => {
+    context.on('kubb:lifecycle:start', async ({ version }) => {
       console.log(`\n${getIntro({ title: 'The ultimate toolkit for working with APIs', description: 'Ready to start', version, areEyesOpen: true })}\n`)
 
       reset()
     })
 
-    context.on('config:start', () => {
+    context.on('kubb:config:start', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -179,7 +200,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       startSpinner(getMessage('Configuration loading'))
     })
 
-    context.on('config:end', (_configs) => {
+    context.on('kubb:config:end', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -189,7 +210,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.outro(text)
     })
 
-    context.on('generation:start', (config) => {
+    context.on('kubb:generation:start', ({ config }) => {
       reset()
 
       // Initialize progress tracking for this generation
@@ -200,7 +221,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.intro(text)
     })
 
-    context.on('plugin:start', (plugin) => {
+    context.on('kubb:plugin:start', ({ plugin }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -222,7 +243,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       state.activeProgress.set(plugin.name, { progressBar, interval })
     })
 
-    context.on('plugin:end', (plugin, { duration, success }) => {
+    context.on('kubb:plugin:end', ({ plugin, duration, success }) => {
       stopSpinner()
 
       const active = state.activeProgress.get(plugin.name)
@@ -253,7 +274,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       showProgressStep()
     })
 
-    context.on('files:processing:start', (files) => {
+    context.on('kubb:files:processing:start', ({ files }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -270,12 +291,12 @@ Run \`npm install -g @kubb/cli\` to update`,
         size: 30,
       })
 
-      context.emit('info', text)
+      context.emit('kubb:info', { message: text })
       progressBar.start(getMessage(text))
       state.activeProgress.set('files', { progressBar })
     })
 
-    context.on('file:processing:update', ({ file, config }) => {
+    context.on('kubb:file:processing:update', ({ file, config }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -293,7 +314,7 @@ Run \`npm install -g @kubb/cli\` to update`,
 
       active.progressBar.advance(undefined, text)
     })
-    context.on('files:processing:end', () => {
+    context.on('kubb:files:processing:end', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -314,13 +335,13 @@ Run \`npm install -g @kubb/cli\` to update`,
       showProgressStep()
     })
 
-    context.on('generation:end', (config) => {
+    context.on('kubb:generation:end', ({ config }) => {
       const text = getMessage(config.name ? `Generation completed for ${styleText('dim', config.name)}` : 'Generation completed')
 
       clack.outro(text)
     })
 
-    context.on('format:start', () => {
+    context.on('kubb:format:start', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -330,7 +351,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.intro(text)
     })
 
-    context.on('format:end', () => {
+    context.on('kubb:format:end', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -340,7 +361,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.outro(text)
     })
 
-    context.on('lint:start', () => {
+    context.on('kubb:lint:start', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -350,7 +371,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.intro(text)
     })
 
-    context.on('lint:end', () => {
+    context.on('kubb:lint:end', () => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -360,54 +381,18 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.outro(text)
     })
 
-    context.on('hook:start', async ({ id, command, args }) => {
-      const commandWithArgs = formatCommandWithArgs(command, args)
-      const text = getMessage(`Hook ${styleText('dim', commandWithArgs)} started`)
-
-      // Skip hook execution if no id is provided (e.g., during benchmarks or tests)
-      if (!id) {
-        return
-      }
-
+    context.on('kubb:hook:start', ({ command, args }) => {
       if (logLevel <= logLevelMap.silent) {
-        await runHook({
-          id,
-          command,
-          args,
-          commandWithArgs,
-          context,
-          sink: {
-            onStderr: (s) => console.error(s),
-            onStdout: (s) => console.log(s),
-          },
-        })
         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)
+      const commandWithArgs = formatCommandWithArgs(command, args)
+      const text = getMessage(`Hook ${styleText('dim', commandWithArgs)} started`)
 
-      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),
-        },
-      })
+      clack.intro(text)
     })
 
-    context.on('hook:end', ({ command, args }) => {
+    context.on('kubb:hook:end', ({ command, args }) => {
       if (logLevel <= logLevelMap.silent) {
         return
       }
@@ -418,7 +403,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.outro(text)
     })
 
-    context.on('generation:summary', (config, { pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
+    context.on('kubb:generation:summary', ({ config, pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
       const summary = getSummary({
         failedPlugins,
         filesCreated,
@@ -433,18 +418,43 @@ Run \`npm install -g @kubb/cli\` to update`,
       summary.push('\n')
 
       const borderColor = status === 'success' ? 'green' : 'red'
-      clack.box(summary.join('\n'), getMessage(title), {
-        width: 'auto',
-        formatBorder: (s: string) => styleText(borderColor, s),
-        rounded: true,
-        withGuide: false,
-        contentAlign: 'left',
-        titleAlign: 'center',
-      })
+      try {
+        clack.box(summary.join('\n'), getMessage(title), {
+          width: 'auto',
+          formatBorder: (s: string) => styleText(borderColor, s),
+          rounded: true,
+          withGuide: false,
+          contentAlign: 'left',
+          titleAlign: 'center',
+        })
+      } catch {
+        console.log(summary.join('\n'))
+      }
     })
 
-    context.on('lifecycle:end', () => {
+    context.on('kubb:lifecycle:end', () => {
       reset()
     })
+
+    return (commandWithArgs: string) => {
+      if (logLevel <= logLevelMap.silent) {
+        return {
+          onStdout: (s: string) => console.log(s),
+          onStderr: (s: string) => console.error(s),
+        }
+      }
+
+      const logger = clack.taskLog({
+        title: getMessage(['Executing hook', logLevel >= logLevelMap.info ? styleText('dim', commandWithArgs) : undefined].filter(Boolean).join(' ')),
+      })
+      const writable = new ClackWritable(logger)
+
+      return {
+        stream: true,
+        onLine: (line: string) => writable.write(line),
+        onStdout: (s: string) => logger.message(s),
+        onStderr: (s: string) => logger.error(s),
+      }
+    }
   },
 })

package/src/loggers/fileSystemLogger.ts

@@ -4,17 +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 for debug log persistence
- * Captures debug and verbose events and writes them to files in .kubb directory
+ * FileSystem logger that captures debug events and writes them to `.kubb` directory files.
  *
- * Note: Logs are written on lifecycle:end or process exit. If the process crashes
- * before these events, some cached logs may be lost.
+ * @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',
@@ -45,79 +52,84 @@ 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'))
         }
       }
 
-      await Promise.all(Object.entries(files).map(([fileName, logs]) => write(fileName, logs.join('\n\n'))))
+      for (const [fileName, logs] of Object.entries(files)) {
+        await write(fileName, logs.join('\n'))
+      }
 
       return Object.keys(files)
     }
 
-    context.on('info', (message, info) => {
+    context.on('kubb:info', ({ message, info }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`ℹ ${message} ${info}`],
+        logs: [`ℹ ${[message, info].filter(Boolean).join(' ')}`],
       })
     })
 
-    context.on('success', (message, info) => {
+    context.on('kubb:success', ({ message, info }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`✓ ${message} ${info}`],
+        logs: [`✓ ${[message, info].filter(Boolean).join(' ')}`],
       })
     })
 
-    context.on('warn', (message, info) => {
+    context.on('kubb:warn', ({ message, info }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`⚠ ${message} ${info}`],
+        logs: [`⚠ ${[message, info].filter(Boolean).join(' ')}`],
       })
     })
 
-    context.on('error', (error) => {
+    context.on('kubb:error', ({ error }) => {
       state.cachedLogs.add({
         date: new Date(),
         logs: [`✗ ${error.message}`, error.stack || 'unknown stack'],
       })
     })
 
-    context.on('debug', (message) => {
+    context.on('kubb:debug', ({ date, fileName, logs }) => {
       state.cachedLogs.add({
-        date: new Date(),
-        logs: message.logs,
+        date,
+        fileName,
+        logs,
       })
     })
 
-    context.on('plugin:start', (plugin) => {
+    context.on('kubb:plugin:start', ({ plugin }) => {
       state.cachedLogs.add({
         date: new Date(),
-        logs: [`Generating ${plugin.name}`],
+        logs: [`► Generating ${plugin.name}`],
       })
     })
 
-    context.on('plugin:end', (plugin, { duration, success }) => {
+    context.on('kubb:plugin:end', ({ plugin, duration, success }) => {
       const durationStr = formatMs(duration)
 
       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('files:processing:start', (files) => {
+    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}`)],
       })
     })
 
-    context.on('generation:end', async (config) => {
+    context.on('kubb:generation:end', async ({ config }) => {
       const writtenFilePaths = await writeLogs(config.name)
       if (writtenFilePaths.length > 0) {
         const files = writtenFilePaths.map((f) => relative(process.cwd(), f))
-        await context.emit('info', 'Debug files written to:', files.join(', '))
+        await context.emit('kubb:info', { message: 'Debug files written to:', info: files.join(', ') })
       }
       reset()
     })