@kubb/cli 4.12.6 → 4.12.8

package/src/loggers/clackLogger.ts

@@ -1,10 +1,11 @@
 import { relative } from 'node:path'
+import process from 'node:process'
 import * as clack from '@clack/prompts'
 import { defineLogger, LogLevel } from '@kubb/core'
+import { formatHrtime, formatMs } from '@kubb/core/utils'
 import { execa } from 'execa'
 import { default as gradientString } from 'gradient-string'
 import pc from 'picocolors'
-
 import { getSummary } from '../utils/getSummary.ts'
 import { ClackWritable } from '../utils/Writables.ts'
 
@@ -16,9 +17,62 @@ export const clackLogger = defineLogger({
   name: 'clack',
   install(context, options) {
     const logLevel = options?.logLevel || LogLevel.info
-    const activeProgress = new Map<string, { interval?: NodeJS.Timeout; progressBar: clack.ProgressResult }>()
-    const spinner = clack.spinner()
-    let isSpinning = false
+    const state = {
+      totalPlugins: 0,
+      completedPlugins: 0,
+      failedPlugins: 0,
+      totalFiles: 0,
+      processedFiles: 0,
+      hrStart: process.hrtime(),
+      spinner: clack.spinner(),
+      isSpinning: false,
+      activeProgress: new Map<string, { interval?: NodeJS.Timeout; progressBar: clack.ProgressResult }>(),
+    }
+
+    function reset() {
+      for (const [_key, active] of state.activeProgress) {
+        if (active.interval) {
+          clearInterval(active.interval)
+        }
+        active.progressBar?.stop()
+      }
+
+      state.totalPlugins = 0
+      state.completedPlugins = 0
+      state.failedPlugins = 0
+      state.totalFiles = 0
+      state.processedFiles = 0
+      state.hrStart = process.hrtime()
+      state.spinner = clack.spinner()
+      state.isSpinning = false
+      state.activeProgress.clear()
+    }
+
+    function showProgressStep() {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const parts: string[] = []
+      const duration = formatHrtime(state.hrStart)
+
+      if (state.totalPlugins > 0) {
+        const pluginStr =
+          state.failedPlugins > 0
+            ? `Plugins ${pc.green(state.completedPlugins.toString())}/${state.totalPlugins} ${pc.red(`(${state.failedPlugins} failed)`)}`
+            : `Plugins ${pc.green(state.completedPlugins.toString())}/${state.totalPlugins}`
+        parts.push(pluginStr)
+      }
+
+      if (state.totalFiles > 0) {
+        parts.push(`Files ${pc.green(state.processedFiles.toString())}/${state.totalFiles}`)
+      }
+
+      if (parts.length > 0) {
+        parts.push(`${pc.green(duration)} elapsed`)
+        clack.log.step(getMessage(parts.join(pc.dim(' | '))))
+      }
+    }
 
     function getMessage(message: string): string {
       if (logLevel >= LogLevel.verbose) {
@@ -36,13 +90,13 @@ export const clackLogger = defineLogger({
     }
 
     function startSpinner(text?: string) {
-      spinner.start(text)
-      isSpinning = true
+      state.spinner.start(text)
+      state.isSpinning = true
     }
 
     function stopSpinner(text?: string) {
-      spinner.stop(text)
-      isSpinning = false
+      state.spinner.stop(text)
+      state.isSpinning = false
     }
 
     context.on('info', (message, info = '') => {
@@ -52,8 +106,8 @@ export const clackLogger = defineLogger({
 
       const text = getMessage([pc.blue('ℹ'), message, pc.dim(info)].join(' '))
 
-      if (isSpinning) {
-        spinner.message(text)
+      if (state.isSpinning) {
+        state.spinner.message(text)
       } else {
         clack.log.info(text)
       }
@@ -66,7 +120,7 @@ export const clackLogger = defineLogger({
 
       const text = getMessage([pc.blue('✓'), message, logLevel >= LogLevel.info ? pc.dim(info) : undefined].filter(Boolean).join(' '))
 
-      if (isSpinning) {
+      if (state.isSpinning) {
         stopSpinner(text)
       } else {
         clack.log.success(text)
@@ -88,7 +142,7 @@ export const clackLogger = defineLogger({
 
       const text = [pc.red('✗'), error.message].join(' ')
 
-      if (isSpinning) {
+      if (state.isSpinning) {
         stopSpinner(getMessage(text))
       } else {
         clack.log.error(getMessage(text))
@@ -134,6 +188,7 @@ Run \`npm install -g @kubb/cli\` to update`,
 
     context.on('lifecycle:start', (version) => {
       console.log(gradientString(['#F58517', '#F5A217', '#F55A17'])(`Kubb ${version} 🧩`))
+      reset()
     })
 
     context.on('config:start', () => {
@@ -147,7 +202,7 @@ Run \`npm install -g @kubb/cli\` to update`,
       startSpinner(getMessage('Configuration loading'))
     })
 
-    context.on('config:end', () => {
+    context.on('config:end', (_configs) => {
       if (logLevel <= LogLevel.silent) {
         return
       }
@@ -158,9 +213,13 @@ Run \`npm install -g @kubb/cli\` to update`,
     })
 
     context.on('generation:start', (config) => {
+      // Initialize progress tracking
+      state.totalPlugins = config.plugins?.length || 0
+
       const text = getMessage(['Generation started', config.name ? `for ${pc.dim(config.name)}` : undefined].filter(Boolean).join(' '))
 
       clack.intro(text)
+      reset()
     })
 
     context.on('plugin:start', (plugin) => {
@@ -180,15 +239,15 @@ Run \`npm install -g @kubb/cli\` to update`,
 
       const interval = setInterval(() => {
         progressBar.advance()
-      }, 50)
+      }, 100)
 
-      activeProgress.set(plugin.name, { progressBar, interval })
+      state.activeProgress.set(plugin.name, { progressBar, interval })
     })
 
-    context.on('plugin:end', (plugin, duration) => {
+    context.on('plugin:end', (plugin, { duration, success }) => {
       stopSpinner()
 
-      const active = activeProgress.get(plugin.name)
+      const active = state.activeProgress.get(plugin.name)
 
       if (!active || logLevel === LogLevel.silent) {
         return
@@ -196,11 +255,22 @@ Run \`npm install -g @kubb/cli\` to update`,
 
       clearInterval(active.interval)
 
-      const durationStr = duration >= 1000 ? `${(duration / 1000).toFixed(2)}s` : `${duration}ms`
-      const text = getMessage(`${pc.bold(plugin.name)} completed in ${pc.green(durationStr)}`)
+      if (success) {
+        state.completedPlugins++
+      } else {
+        state.failedPlugins++
+      }
+
+      const durationStr = formatMs(duration)
+      const text = getMessage(
+        success ? `${pc.bold(plugin.name)} completed in ${pc.green(durationStr)}` : `${pc.bold(plugin.name)} failed in ${pc.red(durationStr)}`,
+      )
 
       active.progressBar.stop(text)
-      activeProgress.delete(plugin.name)
+      state.activeProgress.delete(plugin.name)
+
+      // Show progress step after each plugin
+      showProgressStep()
     })
 
     context.on('files:processing:start', (files) => {
@@ -210,6 +280,9 @@ Run \`npm install -g @kubb/cli\` to update`,
 
       stopSpinner()
 
+      state.totalFiles = files.length
+      state.processedFiles = 0
+
       const text = `Writing ${files.length} files`
       const progressBar = clack.progress({
         style: 'block',
@@ -219,7 +292,7 @@ Run \`npm install -g @kubb/cli\` to update`,
 
       context.emit('info', text)
       progressBar.start(getMessage(text))
-      activeProgress.set('files', { progressBar })
+      state.activeProgress.set('files', { progressBar })
     })
 
     context.on('file:processing:update', ({ file, config }) => {
@@ -229,8 +302,10 @@ Run \`npm install -g @kubb/cli\` to update`,
 
       stopSpinner()
 
+      state.processedFiles++
+
       const text = `Writing ${relative(config.root, file.path)}`
-      const active = activeProgress.get('files')
+      const active = state.activeProgress.get('files')
 
       if (!active) {
         return
@@ -246,14 +321,17 @@ Run \`npm install -g @kubb/cli\` to update`,
       stopSpinner()
 
       const text = getMessage('Files written successfully')
-      const active = activeProgress.get('files')
+      const active = state.activeProgress.get('files')
 
       if (!active) {
         return
       }
 
       active.progressBar.stop(text)
-      activeProgress.delete('files')
+      state.activeProgress.delete('files')
+
+      // Show final progress step after files are written
+      showProgressStep()
     })
 
     context.on('generation:end', (config) => {
@@ -262,7 +340,49 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.outro(text)
     })
 
-    context.on('hook:execute', async ({ command, args }, cb) => {
+    context.on('format:start', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Format started')
+
+      clack.intro(text)
+    })
+
+    context.on('format:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Format completed')
+
+      clack.outro(text)
+    })
+
+    context.on('lint:start', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Lint started')
+
+      clack.intro(text)
+    })
+
+    context.on('lint:end', () => {
+      if (logLevel <= LogLevel.silent) {
+        return
+      }
+
+      const text = getMessage('Lint completed')
+
+      clack.outro(text)
+    })
+
+    context.on('hook:start', async ({ id, command, args }) => {
+      const text = getMessage(`Hook ${pc.dim(command)} started`)
+
       if (logLevel <= LogLevel.silent) {
         try {
           const result = await execa(command, args, {
@@ -275,7 +395,7 @@ Run \`npm install -g @kubb/cli\` to update`,
             logs: [result.stdout],
           })
 
-          cb()
+          await context.emit('hook:end', { command, id })
         } catch (err) {
           const error = new Error('Hook execute failed')
           error.cause = err
@@ -291,6 +411,8 @@ Run \`npm install -g @kubb/cli\` to update`,
         return
       }
 
+      clack.intro(text)
+
       const logger = clack.taskLog({
         title: getMessage(['Executing hook', logLevel >= LogLevel.info ? pc.dim(`${command} ${args?.join(' ')}`) : undefined].filter(Boolean).join(' ')),
       })
@@ -309,7 +431,7 @@ Run \`npm install -g @kubb/cli\` to update`,
           logs: [result.stdout],
         })
 
-        cb()
+        await context.emit('hook:end', { command, id })
       } catch (err) {
         const error = new Error('Hook execute failed')
         error.cause = err
@@ -323,62 +445,12 @@ Run \`npm install -g @kubb/cli\` to update`,
       }
     })
 
-    context.on('format:start', () => {
-      if (logLevel <= LogLevel.silent) {
-        return
-      }
-
-      const text = getMessage('Format started')
-
-      clack.intro(text)
-    })
-
-    context.on('format:end', () => {
-      if (logLevel <= LogLevel.silent) {
-        return
-      }
-
-      const text = getMessage('Format completed')
-
-      clack.outro(text)
-    })
-
-    context.on('lint:start', () => {
-      if (logLevel <= LogLevel.silent) {
-        return
-      }
-
-      const text = getMessage('Lint started')
-
-      clack.intro(text)
-    })
-
-    context.on('lint:end', () => {
-      if (logLevel <= LogLevel.silent) {
-        return
-      }
-
-      const text = getMessage('Lint completed')
-
-      clack.outro(text)
-    })
-
-    context.on('hook:start', (command) => {
-      if (logLevel <= LogLevel.silent) {
-        return
-      }
-
-      const text = getMessage(`Hook ${pc.dim(command)} started`)
-
-      clack.intro(text)
-    })
-
-    context.on('hook:end', (command) => {
+    context.on('hook:end', ({ command }) => {
       if (logLevel <= LogLevel.silent) {
         return
       }
 
-      const text = getMessage(`Hook ${pc.dim(command)} completed`)
+      const text = getMessage(`Hook ${pc.dim(command)} successfully executed`)
 
       clack.outro(text)
     })
@@ -421,13 +493,7 @@ Run \`npm install -g @kubb/cli\` to update`,
     })
 
     context.on('lifecycle:end', () => {
-      for (const [_key, active] of activeProgress) {
-        if (active.interval) {
-          clearInterval(active.interval)
-        }
-        active.progressBar?.stop()
-      }
-      activeProgress.clear()
+      reset()
     })
   },
 })

package/src/loggers/fileSystemLogger.ts

@@ -1,6 +1,7 @@
 import { resolve } from 'node:path'
 import { defineLogger } from '@kubb/core'
 import { write } from '@kubb/core/fs'
+import { formatMs } from '@kubb/core/utils'
 
 type CachedEvent = {
   date: Date
@@ -18,26 +19,34 @@ type CachedEvent = {
 export const fileSystemLogger = defineLogger({
   name: 'filesystem',
   install(context) {
-    const cachedLogs: Set<CachedEvent> = new Set()
-    const startDate = Date.now()
+    const state = {
+      cachedLogs: new Set<CachedEvent>(),
+      startDate: Date.now(),
+    }
+
+    function reset() {
+      state.cachedLogs = new Set<CachedEvent>()
+      state.startDate = Date.now()
+    }
 
-    async function writeLogs() {
-      if (cachedLogs.size === 0) {
+    async function writeLogs(name?: string) {
+      if (state.cachedLogs.size === 0) {
         return
       }
 
       const files: Record<string, string[]> = {}
 
-      for (const log of cachedLogs) {
-        const fileName = resolve(process.cwd(), '.kubb', log.fileName || `kubb-${startDate}.log`)
+      for (const log of state.cachedLogs) {
+        const baseName = log.fileName || `${['kubb', name, state.startDate].filter(Boolean).join('-')}.log`
+        const pathName = resolve(process.cwd(), '.kubb', baseName)
 
-        if (!files[fileName]) {
-          files[fileName] = []
+        if (!files[pathName]) {
+          files[pathName] = []
         }
 
         if (log.logs.length > 0) {
           const timestamp = log.date.toLocaleString()
-          files[fileName].push(`[${timestamp}]\n${log.logs.join('\n')}`)
+          files[pathName].push(`[${timestamp}]\n${log.logs.join('\n')}`)
         }
       }
 
@@ -46,26 +55,83 @@ export const fileSystemLogger = defineLogger({
           return write(fileName, logs.join('\n\n'))
         }),
       )
-
-      cachedLogs.clear()
     }
 
+    context.on('info', (message, info) => {
+      state.cachedLogs.add({
+        date: new Date(),
+        logs: [`ℹ ${message} ${info}`],
+        fileName: undefined,
+      })
+    })
+
+    context.on('success', (message, info) => {
+      state.cachedLogs.add({
+        date: new Date(),
+        logs: [`✓ ${message} ${info}`],
+        fileName: undefined,
+      })
+    })
+
+    context.on('warn', (message, info) => {
+      state.cachedLogs.add({
+        date: new Date(),
+        logs: [`⚠ ${message} ${info}`],
+        fileName: undefined,
+      })
+    })
+
+    context.on('error', (error) => {
+      state.cachedLogs.add({
+        date: new Date(),
+        logs: [`✗ ${error.message}`, error.stack || 'unknown stack'],
+        fileName: undefined,
+      })
+    })
+
     context.on('debug', (message) => {
-      cachedLogs.add({
+      state.cachedLogs.add({
         date: new Date(),
         logs: message.logs,
         fileName: undefined,
       })
     })
 
-    context.on('lifecycle:end', async () => {
-      await writeLogs()
+    context.on('plugin:start', (plugin) => {
+      state.cachedLogs.add({
+        date: new Date(),
+        logs: [`Generating ${plugin.name}`],
+        fileName: undefined,
+      })
+    })
+
+    context.on('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}`],
+        fileName: undefined,
+      })
+    })
+
+    context.on('files:processing:start', (files) => {
+      state.cachedLogs.add({
+        date: new Date(),
+        logs: [`Start ${files.length} writing:`, ...files.map((file) => file.path)],
+        fileName: undefined,
+      })
+    })
+
+    context.on('generation:end', async (config) => {
+      await writeLogs(config.name)
+      reset()
     })
 
     // Fallback: Write logs on process exit to handle crashes
     const exitHandler = () => {
       // Synchronous write on exit - best effort
-      if (cachedLogs.size > 0) {
+      if (state.cachedLogs.size > 0) {
         writeLogs().catch(() => {
           // Ignore errors on exit
         })