@kubb/cli 4.12.7 → 4.12.9

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
         })

package/src/loggers/githubActionsLogger.ts

@@ -21,6 +21,15 @@ export const githubActionsLogger = defineLogger({
       currentConfigs: [] as Array<Config>,
     }
 
+    function reset() {
+      state.totalPlugins = 0
+      state.completedPlugins = 0
+      state.failedPlugins = 0
+      state.totalFiles = 0
+      state.processedFiles = 0
+      state.hrStart = process.hrtime()
+    }
+
     function showProgressStep() {
       if (logLevel <= LogLevel.silent) {
         return
@@ -42,8 +51,8 @@ export const githubActionsLogger = defineLogger({
       }
 
       if (parts.length > 0) {
-        parts.push(pc.green(duration))
-        console.log(parts.join(pc.dim(' | ')))
+        parts.push(`${pc.green(duration)} elapsed`)
+        console.log(getMessage(parts.join(pc.dim(' | '))))
       }
     }
 
@@ -110,6 +119,7 @@ export const githubActionsLogger = defineLogger({
 
     context.on('lifecycle:start', (version) => {
       console.log(pc.yellow(`Kubb ${version} 🧩`))
+      reset()
     })
 
     context.on('config:start', () => {
@@ -141,9 +151,6 @@ export const githubActionsLogger = defineLogger({
     context.on('generation:start', (config) => {
       // Initialize progress tracking
       state.totalPlugins = config.plugins?.length || 0
-      state.completedPlugins = 0
-      state.failedPlugins = 0
-      state.hrStart = process.hrtime()
 
       const text = config.name ? `Generation for ${pc.bold(config.name)}` : 'Generation'
 
@@ -154,6 +161,8 @@ export const githubActionsLogger = defineLogger({
       if (state.currentConfigs.length === 1) {
         console.log(getMessage(text))
       }
+
+      reset()
     })
 
     context.on('plugin:start', (plugin) => {
@@ -250,34 +259,6 @@ export const githubActionsLogger = defineLogger({
       console.log(text)
     })
 
-    context.on('hook:execute', async ({ command, args }, cb) => {
-      try {
-        const result = await execa(command, args, {
-          detached: true,
-          stripFinalNewline: true,
-        })
-
-        await context.emit('debug', {
-          date: new Date(),
-          logs: [result.stdout],
-        })
-
-        console.log(result.stdout)
-
-        cb()
-      } catch (err) {
-        const error = new Error('Hook execute failed')
-        error.cause = err
-
-        await context.emit('debug', {
-          date: new Date(),
-          logs: [(err as any).stdout],
-        })
-
-        await context.emit('error', error)
-      }
-    })
-
     context.on('format:start', () => {
       if (logLevel <= LogLevel.silent) {
         return
@@ -334,21 +315,45 @@ export const githubActionsLogger = defineLogger({
       }
     })
 
-    context.on('hook:start', (command) => {
-      if (logLevel <= LogLevel.silent) {
-        return
-      }
-
+    context.on('hook:start', async ({ id, command, args }) => {
       const text = getMessage(`Hook ${pc.dim(command)} started`)
 
-      if (state.currentConfigs.length === 1) {
-        openGroup(`Hook ${command}`)
+      if (logLevel > LogLevel.silent) {
+        if (state.currentConfigs.length === 1) {
+          openGroup(`Hook ${command}`)
+        }
+
+        console.log(text)
       }
 
-      console.log(text)
+      try {
+        const result = await execa(command, args, {
+          detached: true,
+          stripFinalNewline: true,
+        })
+
+        await context.emit('debug', {
+          date: new Date(),
+          logs: [result.stdout],
+        })
+
+        console.log(result.stdout)
+
+        await context.emit('hook:end', { command, id })
+      } catch (err) {
+        const error = new Error('Hook execute failed')
+        error.cause = err
+
+        await context.emit('debug', {
+          date: new Date(),
+          logs: [(err as any).stdout],
+        })
+
+        await context.emit('error', error)
+      }
     })
 
-    context.on('hook:end', (command) => {
+    context.on('hook:end', ({ command }) => {
       if (logLevel <= LogLevel.silent) {
         return
       }
@@ -362,9 +367,10 @@ export const githubActionsLogger = defineLogger({
       }
     })
 
-    context.on('generation:summary', (config, { status, failedPlugins }) => {
+    context.on('generation:summary', (config, { status, hrStart, failedPlugins }) => {
       const pluginsCount = config.plugins?.length || 0
       const successCount = pluginsCount - failedPlugins.size
+      const duration = formatHrtime(hrStart)
 
       if (state.currentConfigs.length > 1) {
         console.log(' ')
@@ -372,8 +378,8 @@ export const githubActionsLogger = defineLogger({
 
       console.log(
         status === 'success'
-          ? `Kubb Summary: ${pc.blue('✓')} ${`${successCount} successful`}, ${pluginsCount} total`
-          : `Kubb Summary: ${pc.blue('✓')} ${`${successCount} successful`}, ✗ ${`${failedPlugins.size} failed`}, ${pluginsCount} total`,
+          ? `Kubb Summary: ${pc.blue('✓')} ${`${successCount} successful`}, ${pluginsCount} total, ${pc.green(duration)}`
+          : `Kubb Summary: ${pc.blue('✓')} ${`${successCount} successful`}, ✗ ${`${failedPlugins.size} failed`}, ${pluginsCount} total, ${pc.green(duration)}`,
       )
 
       if (state.currentConfigs.length > 1) {

package/src/loggers/plainLogger.ts

@@ -169,34 +169,6 @@ export const plainLogger = defineLogger({
       console.log(text)
     })
 
-    context.on('hook:execute', async ({ command, args }, cb) => {
-      try {
-        const result = await execa(command, args, {
-          detached: true,
-          stripFinalNewline: true,
-        })
-
-        await context.emit('debug', {
-          date: new Date(),
-          logs: [result.stdout],
-        })
-
-        console.log(result.stdout)
-
-        cb()
-      } catch (err) {
-        const error = new Error('Hook execute failed')
-        error.cause = err
-
-        await context.emit('debug', {
-          date: new Date(),
-          logs: [(err as any).stdout],
-        })
-
-        await context.emit('error', error)
-      }
-    })
-
     context.on('format:start', () => {
       if (logLevel <= LogLevel.silent) {
         return
@@ -237,14 +209,38 @@ export const plainLogger = defineLogger({
       console.log(text)
     })
 
-    context.on('hook:start', (command) => {
-      if (logLevel <= LogLevel.silent) {
-        return
+    context.on('hook:start', async ({ id, command, args }) => {
+      const text = getMessage(`Hook ${command} started`)
+
+      if (logLevel > LogLevel.silent) {
+        console.log(text)
       }
 
-      const text = getMessage(`Hook ${command} started`)
+      try {
+        const result = await execa(command, args, {
+          detached: true,
+          stripFinalNewline: true,
+        })
 
-      console.log(text)
+        await context.emit('debug', {
+          date: new Date(),
+          logs: [result.stdout],
+        })
+
+        console.log(result.stdout)
+
+        await context.emit('hook:end', { command, id })
+      } catch (err) {
+        const error = new Error('Hook execute failed')
+        error.cause = err
+
+        await context.emit('debug', {
+          date: new Date(),
+          logs: [(err as any).stdout],
+        })
+
+        await context.emit('error', error)
+      }
     })
 
     context.on('hook:end', (command) => {

package/src/runners/generate.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto'
 import path from 'node:path'
 import process from 'node:process'
 import { type Config, type KubbEvents, LogLevel, safeBuild, setup } from '@kubb/core'
@@ -106,13 +107,15 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.format === 'prettier') {
       try {
-        await events.emit(
-          'hook:execute',
-          {
-            command: 'prettier',
-            args: ['--ignore-unknown', '--write', path.resolve(definedConfig.root, definedConfig.output.path)],
-          },
-          async () => {
+        const hookId = createHash('sha256').update([config.name, config.output.format].filter(Boolean).join('-')).digest('hex')
+        await events.emit('hook:start', {
+          id: hookId,
+          command: 'prettier',
+          args: ['--ignore-unknown', '--write', path.resolve(definedConfig.root, definedConfig.output.path)],
+        })
+
+        await events.on('hook:end', async ({ id }) => {
+          if (id === hookId) {
             await events.emit(
               'success',
               [
@@ -123,8 +126,8 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
                 .filter(Boolean)
                 .join(' '),
             )
-          },
-        )
+          }
+        })
       } catch (caughtError) {
         await events.emit('error', caughtError as Error)
       }
@@ -134,13 +137,15 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.format === 'biome') {
       try {
-        await events.emit(
-          'hook:execute',
-          {
-            command: 'biome',
-            args: ['format', '--write', path.resolve(definedConfig.root, definedConfig.output.path)],
-          },
-          async () => {
+        const hookId = createHash('sha256').update([config.name, config.output.format].filter(Boolean).join('-')).digest('hex')
+        await events.emit('hook:start', {
+          id: hookId,
+          command: 'biome',
+          args: ['format', '--write', path.resolve(definedConfig.root, definedConfig.output.path)],
+        })
+
+        await events.on('hook:end', async ({ id }) => {
+          if (id === hookId) {
             await events.emit(
               'success',
               [
@@ -151,8 +156,8 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
                 .filter(Boolean)
                 .join(' '),
             )
-          },
-        )
+          }
+        })
       } catch (caughtError) {
         const error = new Error('Biome not found')
         error.cause = caughtError
@@ -179,13 +184,15 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.lint === 'eslint') {
       try {
-        await events.emit(
-          'hook:execute',
-          {
-            command: 'eslint',
-            args: [path.resolve(definedConfig.root, definedConfig.output.path), '--fix'],
-          },
-          async () => {
+        const hookId = createHash('sha256').update([config.name, config.output.lint].filter(Boolean).join('-')).digest('hex')
+        await events.emit('hook:start', {
+          id: hookId,
+          command: 'eslint',
+          args: [path.resolve(definedConfig.root, definedConfig.output.path), '--fix'],
+        })
+
+        await events.on('hook:end', async ({ id }) => {
+          if (id === hookId) {
             await events.emit(
               'success',
               [
@@ -196,8 +203,8 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
                 .filter(Boolean)
                 .join(' '),
             )
-          },
-        )
+          }
+        })
       } catch (caughtError) {
         const error = new Error('Eslint not found')
         error.cause = caughtError
@@ -207,13 +214,15 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.lint === 'biome') {
       try {
-        await events.emit(
-          'hook:execute',
-          {
-            command: 'biome',
-            args: ['lint', '--fix', path.resolve(definedConfig.root, definedConfig.output.path)],
-          },
-          async () => {
+        const hookId = createHash('sha256').update([config.name, config.output.lint].filter(Boolean).join('-')).digest('hex')
+        await events.emit('hook:start', {
+          id: hookId,
+          command: 'biome',
+          args: ['lint', '--fix', path.resolve(definedConfig.root, definedConfig.output.path)],
+        })
+
+        await events.on('hook:end', async ({ id }) => {
+          if (id === hookId) {
             await events.emit(
               'success',
               [
@@ -224,8 +233,8 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
                 .filter(Boolean)
                 .join(' '),
             )
-          },
-        )
+          }
+        })
       } catch (caughtError) {
         const error = new Error('Biome not found')
         error.cause = caughtError
@@ -235,13 +244,15 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.lint === 'oxlint') {
       try {
-        await events.emit(
-          'hook:execute',
-          {
-            command: 'oxlint',
-            args: ['--fix', path.resolve(definedConfig.root, definedConfig.output.path)],
-          },
-          async () => {
+        const hookId = createHash('sha256').update([config.name, config.output.lint].filter(Boolean).join('-')).digest('hex')
+        await events.emit('hook:start', {
+          id: hookId,
+          command: 'oxlint',
+          args: ['--fix', path.resolve(definedConfig.root, definedConfig.output.path)],
+        })
+
+        await events.on('hook:end', async ({ id }) => {
+          if (id === hookId) {
             await events.emit(
               'success',
               [
@@ -252,8 +263,8 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
                 .filter(Boolean)
                 .join(' '),
             )
-          },
-        )
+          }
+        })
       } catch (caughtError) {
         const error = new Error('Oxlint not found')
         error.cause = caughtError

package/src/utils/executeHooks.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto'
 import type { Config, KubbEvents } from '@kubb/core'
 import type { AsyncEventEmitter } from '@kubb/core/utils'
 
@@ -19,12 +20,14 @@ export async function executeHooks({ hooks, events }: ExecutingHooksProps): Prom
       continue
     }
 
-    await events.emit('hook:start', command)
+    const hookId = createHash('sha256').update(command).digest('hex')
 
-    await events.emit('hook:execute', { command: cmd, args }, async () => {
-      await events.emit('success', `${pc.dim(command)} successfully executed`)
+    await events.emit('hook:start', { id: hookId, command: cmd, args })
 
-      await events.emit('hook:end', command)
+    await events.on('hook:end', async ({ id }) => {
+      if (id === hookId) {
+        await events.emit('success', `${pc.dim(command)} successfully executed`)
+      }
     })
   }
 }