@kubb/cli 4.12.10 → 4.12.12

package/src/loggers/clackLogger.ts

@@ -6,6 +6,7 @@ import { formatHrtime, formatMs } from '@kubb/core/utils'
 import { execa } from 'execa'
 import { default as gradientString } from 'gradient-string'
 import pc from 'picocolors'
+import { formatMsWithColor } from '../utils/formatMsWithColor.ts'
 import { getSummary } from '../utils/getSummary.ts'
 import { ClackWritable } from '../utils/Writables.ts'
 
@@ -261,9 +262,9 @@ Run \`npm install -g @kubb/cli\` to update`,
         state.failedPlugins++
       }
 
-      const durationStr = formatMs(duration)
+      const durationStr = formatMsWithColor(duration)
       const text = getMessage(
-        success ? `${pc.bold(plugin.name)} completed in ${pc.green(durationStr)}` : `${pc.bold(plugin.name)} failed in ${pc.red(durationStr)}`,
+        success ? `${pc.bold(plugin.name)} completed in ${durationStr}` : `${pc.bold(plugin.name)} failed in ${pc.red(formatMs(duration))}`,
       )
 
       active.progressBar.stop(text)

package/src/loggers/fileSystemLogger.ts

@@ -1,4 +1,4 @@
-import { resolve } from 'node:path'
+import { relative, resolve } from 'node:path'
 import { defineLogger } from '@kubb/core'
 import { write } from '@kubb/core/fs'
 import { formatMs } from '@kubb/core/utils'
@@ -31,7 +31,7 @@ export const fileSystemLogger = defineLogger({
 
     async function writeLogs(name?: string) {
       if (state.cachedLogs.size === 0) {
-        return
+        return []
       }
 
       const files: Record<string, string[]> = {}
@@ -55,6 +55,8 @@ export const fileSystemLogger = defineLogger({
           return write(fileName, logs.join('\n\n'))
         }),
       )
+
+      return Object.keys(files)
     }
 
     context.on('info', (message, info) => {
@@ -124,10 +126,18 @@ export const fileSystemLogger = defineLogger({
     })
 
     context.on('generation:end', async (config) => {
-      await writeLogs(config.name)
+      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(', '))
+      }
       reset()
     })
 
+    context.on('lifecycle:end', async () => {
+      // lifecycle:end handler can be used for cleanup if needed in the future
+    })
+
     // Fallback: Write logs on process exit to handle crashes
     const exitHandler = () => {
       // Synchronous write on exit - best effort

package/src/loggers/githubActionsLogger.ts

@@ -2,6 +2,7 @@ import { type Config, defineLogger, LogLevel } from '@kubb/core'
 import { formatHrtime, formatMs } from '@kubb/core/utils'
 import { execa } from 'execa'
 import pc from 'picocolors'
+import { formatMsWithColor } from '../utils/formatMsWithColor.ts'
 
 /**
  * GitHub Actions adapter for CI environments
@@ -189,9 +190,9 @@ export const githubActionsLogger = defineLogger({
         state.failedPlugins++
       }
 
-      const durationStr = formatMs(duration)
+      const durationStr = formatMsWithColor(duration)
       const text = getMessage(
-        success ? `${pc.bold(plugin.name)} completed in ${pc.green(durationStr)}` : `${pc.bold(plugin.name)} failed in ${pc.red(durationStr)}`,
+        success ? `${pc.bold(plugin.name)} completed in ${durationStr}` : `${pc.bold(plugin.name)} failed in ${pc.red(formatMs(duration))}`,
       )
 
       console.log(text)

package/src/runners/generate.ts

@@ -1,4 +1,3 @@
-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'
@@ -13,14 +12,13 @@ type GenerateProps = {
   logLevel: number
 }
 
-export async function generate({ input, config, events, logLevel }: GenerateProps): Promise<void> {
-  const { root = process.cwd(), ...userConfig } = config
+export async function generate({ input, config: userConfig, events, logLevel }: GenerateProps): Promise<void> {
   const inputPath = input ?? ('path' in userConfig.input ? userConfig.input.path : undefined)
   const hrStart = process.hrtime()
 
-  const definedConfig: Config = {
-    root,
+  const config: Config = {
     ...userConfig,
+    root: userConfig.root || process.cwd(),
     input: inputPath
       ? {
           ...userConfig.input,
@@ -38,12 +36,12 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
     },
   }
 
-  await events.emit('generation:start', definedConfig)
+  await events.emit('generation:start', config)
 
   await events.emit('info', config.name ? `Setup generation ${pc.bold(config.name)}` : 'Setup generation', inputPath)
 
   const { fabric, pluginManager } = await setup({
-    config: definedConfig,
+    config,
     events,
   })
 
@@ -51,7 +49,7 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
   const { files, failedPlugins, pluginTimings, error } = await safeBuild(
     {
-      config: definedConfig,
+      config,
       events,
     },
     { pluginManager, fabric, events },
@@ -75,9 +73,9 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
       events.emit('error', err)
     })
 
-    await events.emit('generation:end', definedConfig)
+    await events.emit('generation:end', config)
 
-    await events.emit('generation:summary', definedConfig, {
+    await events.emit('generation:summary', config, {
       failedPlugins,
       filesCreated: files.length,
       status: failedPlugins.size > 0 || error ? 'failed' : 'success',
@@ -89,7 +87,7 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
   }
 
   await events.emit('success', 'Generation successfully', inputPath)
-  await events.emit('generation:end', definedConfig)
+  await events.emit('generation:end', config)
 
   // formatting
   if (config.output.format) {
@@ -99,7 +97,7 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
       'info',
       [
         `Formatting with ${pc.dim(config.output.format as string)}`,
-        logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : undefined,
+        logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
       ]
         .filter(Boolean)
         .join(' '),
@@ -107,26 +105,22 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.format === 'prettier') {
       try {
-        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)],
+          args: ['--ignore-unknown', '--write', path.resolve(config.root, config.output.path)],
         })
 
-        await events.on('hook:end', async ({ id }) => {
-          if (id === hookId) {
-            await events.emit(
-              'success',
-              [
-                `Formatting with ${pc.dim(config.output.format as string)}`,
-                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : undefined,
-                'successfully',
-              ]
-                .filter(Boolean)
-                .join(' '),
-            )
-          }
+        await events.onOnce('hook:end', async () => {
+          await events.emit(
+            'success',
+            [
+              `Formatting with ${pc.dim(config.output.format as string)}`,
+              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+              'successfully',
+            ]
+              .filter(Boolean)
+              .join(' '),
+          )
         })
       } catch (caughtError) {
         await events.emit('error', caughtError as Error)
@@ -137,26 +131,22 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.format === 'biome') {
       try {
-        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)],
+          args: ['format', '--write', path.resolve(config.root, config.output.path)],
         })
 
-        await events.on('hook:end', async ({ id }) => {
-          if (id === hookId) {
-            await events.emit(
-              'success',
-              [
-                `Formatting with ${pc.dim(config.output.format as string)}`,
-                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : undefined,
-                'successfully',
-              ]
-                .filter(Boolean)
-                .join(' '),
-            )
-          }
+        await events.onOnce('hook:end', async () => {
+          await events.emit(
+            'success',
+            [
+              `Formatting with ${pc.dim(config.output.format as string)}`,
+              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+              'successfully',
+            ]
+              .filter(Boolean)
+              .join(' '),
+          )
         })
       } catch (caughtError) {
         const error = new Error('Biome not found')
@@ -176,7 +166,7 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
       'info',
       [
         `Linting with ${pc.dim(config.output.lint as string)}`,
-        logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : undefined,
+        logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
       ]
         .filter(Boolean)
         .join(' '),
@@ -184,26 +174,22 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.lint === 'eslint') {
       try {
-        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'],
+          args: [path.resolve(config.root, config.output.path), '--fix'],
         })
 
-        await events.on('hook:end', async ({ id }) => {
-          if (id === hookId) {
-            await events.emit(
-              'success',
-              [
-                `Linted with ${pc.dim(config.output.lint as string)}`,
-                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : undefined,
-                'successfully',
-              ]
-                .filter(Boolean)
-                .join(' '),
-            )
-          }
+        await events.onOnce('hook:end', async () => {
+          await events.emit(
+            'success',
+            [
+              `Linted with ${pc.dim(config.output.lint as string)}`,
+              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+              'successfully',
+            ]
+              .filter(Boolean)
+              .join(' '),
+          )
         })
       } catch (caughtError) {
         const error = new Error('Eslint not found')
@@ -214,26 +200,22 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.lint === 'biome') {
       try {
-        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)],
+          args: ['lint', '--fix', path.resolve(config.root, config.output.path)],
         })
 
-        await events.on('hook:end', async ({ id }) => {
-          if (id === hookId) {
-            await events.emit(
-              'success',
-              [
-                `Linted with ${pc.dim(config.output.lint as string)}`,
-                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : undefined,
-                'successfully',
-              ]
-                .filter(Boolean)
-                .join(' '),
-            )
-          }
+        await events.onOnce('hook:end', async () => {
+          await events.emit(
+            'success',
+            [
+              `Linted with ${pc.dim(config.output.lint as string)}`,
+              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+              'successfully',
+            ]
+              .filter(Boolean)
+              .join(' '),
+          )
         })
       } catch (caughtError) {
         const error = new Error('Biome not found')
@@ -244,26 +226,22 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
 
     if (config.output.lint === 'oxlint') {
       try {
-        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)],
+          args: ['--fix', path.resolve(config.root, config.output.path)],
         })
 
-        await events.on('hook:end', async ({ id }) => {
-          if (id === hookId) {
-            await events.emit(
-              'success',
-              [
-                `Linted with ${pc.dim(config.output.lint as string)}`,
-                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(definedConfig.root, definedConfig.output.path))}` : undefined,
-                'successfully',
-              ]
-                .filter(Boolean)
-                .join(' '),
-            )
-          }
+        await events.onOnce('hook:end', async () => {
+          await events.emit(
+            'success',
+            [
+              `Linted with ${pc.dim(config.output.lint as string)}`,
+              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+              'successfully',
+            ]
+              .filter(Boolean)
+              .join(' '),
+          )
         })
       } catch (caughtError) {
         const error = new Error('Oxlint not found')
@@ -282,7 +260,7 @@ export async function generate({ input, config, events, logLevel }: GenerateProp
     await events.emit('hooks:end')
   }
 
-  await events.emit('generation:summary', definedConfig, {
+  await events.emit('generation:summary', config, {
     failedPlugins,
     filesCreated: files.length,
     status: failedPlugins.size > 0 || error ? 'failed' : 'success',

package/src/utils/executeHooks.ts

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

package/src/utils/formatMsWithColor.ts

@@ -0,0 +1,22 @@
+import { formatMs } from '@kubb/core/utils'
+import pc from 'picocolors'
+
+/**
+ * Formats milliseconds with color based on duration thresholds:
+ * - Green: <= 500ms
+ * - Yellow: > 500ms and <= 1000ms
+ * - Red: > 1000ms
+ */
+export function formatMsWithColor(ms: number): string {
+  const formatted = formatMs(ms)
+
+  if (ms <= 500) {
+    return pc.green(formatted)
+  }
+
+  if (ms <= 1000) {
+    return pc.yellow(formatted)
+  }
+
+  return pc.red(formatted)
+}