@kubb/cli 5.0.0-beta.75 → 5.0.0-beta.8

package/src/constants.ts

@@ -1,9 +1,4 @@
-/**
- * Default filename for the Kubb configuration file.
- *
- * Used by the `init` command when scaffolding new projects and by the `agent` default config.
- */
-export const KUBB_CONFIG_FILENAME = 'kubb.config.ts' as const
+import { KUBB_CONFIG_FILENAME } from '@internals/shared'
 
 /**
  * NPM registry endpoint used to check for @kubb/cli updates.
@@ -45,60 +40,9 @@ export const agentDefaults = {
   host: 'localhost',
   configFile: KUBB_CONFIG_FILENAME,
   retryTimeout: '30000',
-  studioUrl: 'https://studio.kubb.dev',
+  studioUrl: 'https://kubb.studio',
   /**
    * Relative path from the @kubb/agent package root to the server entry.
    */
   serverEntryPath: '.output/server/index.mjs',
 } as const
-
-/**
- * Default values used during interactive `init` scaffolding.
- */
-export const initDefaults = {
-  inputPath: './openapi.yaml',
-  outputPath: './src/gen',
-  plugins: ['plugin-ts'],
-} as const
-
-/**
- * Maps each plugin value to the default config snippet inserted by `init`.
- * The `satisfies` constraint ensures all values remain plain strings while
- * `as const` keeps the object deeply immutable.
- */
-export const pluginDefaultConfigs = {
-  'plugin-ts': `pluginTs({
-      output: { path: 'models' },
-    })`,
-  'plugin-client': `pluginClient({
-      output: { path: 'clients' },
-    })`,
-  'plugin-react-query': `pluginReactQuery({
-      output: { path: 'hooks' },
-    })`,
-  'plugin-vue-query': `pluginVueQuery({
-      output: { path: 'hooks' },
-    })`,
-  'plugin-zod': `pluginZod({
-      output: { path: 'zod' },
-    })`,
-  'plugin-faker': `pluginFaker({
-      output: { path: 'mocks' },
-    })`,
-  'plugin-msw': `pluginMsw({
-      output: { path: 'msw' },
-    })`,
-  'plugin-cypress': `pluginCypress({
-      output: { path: 'cypress' },
-    })`,
-  'plugin-mcp': `pluginMcp({
-      output: { path: 'mcp' },
-    })`,
-  'plugin-redoc': `pluginRedoc({
-      output: { path: 'redoc' },
-    })`,
-} as const satisfies Record<string, string>
-
-/**
- * Color palette used by randomCliColor() for deterministic plugin name coloring.
- */

package/src/index.ts

@@ -1,9 +1,8 @@
 import { styleText } from 'node:util'
-import { createCLI } from '@internals/utils'
+import { createCLI, isFlag } from '@internals/utils'
 import { version } from '../package.json'
 import { QUIET_FLAGS } from './constants.ts'
-import { isFlag } from './utils/flags.ts'
-import { isTelemetryDisabled } from './utils/telemetry.ts'
+import { isTelemetryDisabled } from './telemetry.ts'
 
 const cli = createCLI()
 
@@ -11,14 +10,17 @@ function shouldShowTelemetryNotice(argv: Array<string>): boolean {
   if (isTelemetryDisabled()) {
     return false
   }
+
   // Skip when the user is just asking for help or version info
   if (argv.some((arg) => isFlag(QUIET_FLAGS, arg))) {
     return false
   }
+
   // Skip in non-interactive / scripting contexts
   if (!process.stdout.isTTY) {
     return false
   }
+
   return true
 }
 

package/src/loggers/clackLogger.ts

@@ -4,10 +4,27 @@ 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'
+
+/**
+ * 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.
@@ -364,51 +381,15 @@ Run \`npm install -g @kubb/cli\` to update`,
       clack.outro(text)
     })
 
-    context.on('kubb: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('kubb:hook:end', ({ command, args }) => {
@@ -454,5 +435,26 @@ Run \`npm install -g @kubb/cli\` to update`,
     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,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,6 @@
 import { styleText } from 'node:util'
 import { formatHrtime, formatMs, formatMsWithColor, 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'
 
 /**
@@ -307,34 +306,18 @@ export const githubActionsLogger = defineLogger({
       }
     })
 
-    context.on('kubb:hook:start', async ({ id, command, args }) => {
+    context.on('kubb:hook:start', ({ command, args }) => {
+      if (logLevel <= logLevelMap.silent) {
+        return
+      }
+
       const commandWithArgs = formatCommandWithArgs(command, args)
       const text = getMessage(`Hook ${styleText('dim', commandWithArgs)} started`)
 
-      if (logLevel > logLevelMap.silent) {
-        if (state.currentConfigs.length === 1) {
-          openGroup(`Hook ${commandWithArgs}`)
-        }
-        console.log(text)
-      }
-
-      // Skip hook execution if no id is provided (e.g., during benchmarks or tests)
-      if (!id) {
-        return
+      if (state.currentConfigs.length === 1) {
+        openGroup(`Hook ${commandWithArgs}`)
       }
-
-      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(text)
     })
 
     context.on('kubb:hook:end', ({ command, args }) => {
@@ -375,5 +358,10 @@ export const githubActionsLogger = defineLogger({
     context.on('kubb:lifecycle:end', () => {
       reset()
     })
+
+    return (_commandWithArgs: string) => ({
+      onStdout: logLevel > logLevelMap.silent ? (s: string) => console.log(s) : undefined,
+      onStderr: logLevel > logLevelMap.silent ? (s: string) => console.error(`::error::${s}`) : undefined,
+    })
   },
 })

package/src/loggers/plainLogger.ts

@@ -2,8 +2,7 @@ import { relative } from 'node:path'
 import { formatMs, toCause } from '@internals/utils'
 import { defineLogger, logLevel as logLevelMap } from '@kubb/core'
 import { SUMMARY_SEPARATOR } from '../constants.ts'
-import { getSummary } from '../utils/getSummary.ts'
-import { runHook } from '../utils/runHook.ts'
+import { getSummary } from './utils.ts'
 import { formatCommandWithArgs, formatMessage } from './utils.ts'
 
 /**
@@ -199,30 +198,15 @@ export const plainLogger = defineLogger({
       console.log(text)
     })
 
-    context.on('kubb:hook:start', async ({ id, command, args }) => {
-      const commandWithArgs = formatCommandWithArgs(command, args)
-      const text = getMessage(`Hook ${commandWithArgs} started`)
-
-      if (logLevel > logLevelMap.silent) {
-        console.log(text)
-      }
-
-      // Skip hook execution if no id is provided (e.g., during benchmarks or tests)
-      if (!id) {
+    context.on('kubb:hook:start', ({ command, args }) => {
+      if (logLevel <= logLevelMap.silent) {
         return
       }
 
-      await runHook({
-        id,
-        command,
-        args,
-        commandWithArgs,
-        context,
-        sink: {
-          onStdout: logLevel > logLevelMap.silent ? (s) => console.log(s) : undefined,
-          onStderr: logLevel > logLevelMap.silent ? (s) => console.error(s) : undefined,
-        },
-      })
+      const commandWithArgs = formatCommandWithArgs(command, args)
+      const text = getMessage(`Hook ${commandWithArgs} started`)
+
+      console.log(text)
     })
 
     context.on('kubb:hook:end', ({ command, args }) => {
@@ -250,5 +234,10 @@ export const plainLogger = defineLogger({
       console.log(summary.join('\n'))
       console.log(SUMMARY_SEPARATOR)
     })
+
+    return (_commandWithArgs: string) => ({
+      onStdout: logLevel > logLevelMap.silent ? (s: string) => console.log(s) : undefined,
+      onStderr: logLevel > logLevelMap.silent ? (s: string) => console.error(s) : undefined,
+    })
   },
 })

package/src/loggers/types.ts

@@ -1 +1,7 @@
+/**
+ * Logger adapter selected by `setupLogger` based on the runtime environment.
+ * - `'clack'`: TTY-aware output with spinners and progress bars.
+ * - `'github-actions'`: CI output using `::group::` annotations.
+ * - `'plain'`: Plain `console.log` output for non-TTY environments.
+ */
 export type LoggerType = 'clack' | 'github-actions' | 'plain'

package/src/loggers/utils.ts

@@ -1,13 +1,57 @@
+import path from 'node:path'
 import { styleText } from 'node:util'
-import { canUseTTY, formatHrtime, isGitHubActions } from '@internals/utils'
-import type { Logger, LoggerContext, LoggerOptions } from '@kubb/core'
+import { canUseTTY, formatHrtime, isGitHubActions, randomCliColor } from '@internals/utils'
+import type { Config, Logger, LoggerContext, LoggerOptions, Plugin } from '@kubb/core'
 import { logLevel as logLevelMap } from '@kubb/core'
+import { SUMMARY_MAX_BAR_LENGTH, SUMMARY_TIME_SCALE_DIVISOR } from '../constants.ts'
 import { clackLogger } from './clackLogger.ts'
 import { fileSystemLogger } from './fileSystemLogger.ts'
 import { githubActionsLogger } from './githubActionsLogger.ts'
 import { plainLogger } from './plainLogger.ts'
 import type { LoggerType } from './types.ts'
 
+/**
+ * Output sink for a hook subprocess, controlling how streamed lines and exit output are forwarded.
+ */
+type HookOutputSink = {
+  /**
+   * Called for each streamed stdout line while the hook runs.
+   */
+  onLine?: (line: string) => void
+  /**
+   * Called with stderr content after the hook exits with a non-zero code.
+   */
+  onStderr?: (text: string) => void
+  /**
+   * Called with stdout content after the hook exits with a non-zero code.
+   */
+  onStdout?: (text: string) => void
+}
+
+/**
+ * Output sink combined with stream control for a hook subprocess.
+ */
+export type HookSinkOptions = HookOutputSink & {
+  /**
+   * When `true`, streams process output line-by-line via `onLine`.
+   *
+   * @default false
+   */
+  stream?: boolean
+}
+
+/**
+ * Factory called once per hook command to build the output sink and streaming flag.
+ * The function should set up any logger UI (e.g., spinner) and return callbacks that forward subprocess output to it.
+ */
+export type HookSinkFactory = (commandWithArgs: string) => HookSinkOptions | undefined
+
+/**
+ * Logger variant that may return a {@link HookSinkFactory} from `install`.
+ * The factory is forwarded to hook execution so the logger controls subprocess output routing.
+ */
+type CLILogger = Logger<LoggerOptions, HookSinkFactory | void>
+
 /**
  * Optionally prefix a message with a [HH:MM:SS] timestamp when logLevel >= verbose.
  * Shared across all logger adapters to avoid duplication.
@@ -26,11 +70,29 @@ export function formatMessage(message: string, logLevel: number): string {
 }
 
 type ProgressState = {
+  /**
+   * Total number of plugins scheduled for this generation run.
+   */
   totalPlugins: number
+  /**
+   * Number of plugins that have finished without error.
+   */
   completedPlugins: number
+  /**
+   * Number of plugins that exited with an error.
+   */
   failedPlugins: number
+  /**
+   * Total number of files expected to be written.
+   */
   totalFiles: number
+  /**
+   * Number of files written so far.
+   */
   processedFiles: number
+  /**
+   * `process.hrtime()` snapshot taken at the start of generation, used to compute elapsed time.
+   */
   hrStart: [number, number]
 }
 
@@ -80,27 +142,111 @@ function detectLogger(): LoggerType {
   return 'plain'
 }
 
-const logMapper = {
+const logMapper: Record<LoggerType, CLILogger> = {
   clack: clackLogger,
   plain: plainLogger,
   'github-actions': githubActionsLogger,
-} as const satisfies Record<LoggerType, Logger>
+}
 
-export async function setupLogger(context: LoggerContext, { logLevel }: LoggerOptions): Promise<void> {
+export async function setupLogger(context: LoggerContext, { logLevel }: LoggerOptions): Promise<HookSinkFactory | undefined> {
   const type = detectLogger()
 
-  const logger = logMapper[type] as Logger
+  const logger = logMapper[type]
 
   if (!logger) {
     throw new Error(`Unknown adapter type: ${type}`)
   }
 
-  // Install primary logger
-  const cleanup = await logger.install(context, { logLevel })
+  const makeSink = await logger.install(context, { logLevel })
 
   if (logLevel >= logLevelMap.debug) {
     await fileSystemLogger.install(context, { logLevel })
   }
 
-  return cleanup
+  return typeof makeSink === 'function' ? makeSink : undefined
+}
+
+type SummaryProps = {
+  /**
+   * Set of plugins that failed during this generation run, each with its error.
+   */
+  failedPlugins: Set<{ plugin: Plugin; error: Error }>
+  /**
+   * Overall generation status used to choose success or failure formatting.
+   */
+  status: 'success' | 'failed'
+  /**
+   * `process.hrtime()` snapshot taken at the start of generation, used to compute elapsed time.
+   */
+  hrStart: [number, number]
+  /**
+   * Total number of files written during this generation run.
+   */
+  filesCreated: number
+  /**
+   * Resolved Kubb config for this generation entry, used to read plugin count and output path.
+   */
+  config: Config
+  /**
+   * Per-plugin timing map (plugin name → duration in ms). When provided, a timing bar chart is appended.
+   */
+  pluginTimings?: Map<string, number>
+}
+
+/**
+ * Builds the generation summary lines rendered in the end-of-run box.
+ * Returns an array of styled strings, one per summary row.
+ */
+export function getSummary({ failedPlugins, filesCreated, status, hrStart, config, pluginTimings }: SummaryProps): string[] {
+  const duration = formatHrtime(hrStart)
+
+  const pluginsCount = config.plugins?.length ?? 0
+  const successCount = pluginsCount - failedPlugins.size
+
+  const meta = {
+    plugins:
+      status === 'success'
+        ? `${styleText('green', `${successCount} successful`)}, ${pluginsCount} total`
+        : `${styleText('green', `${successCount} successful`)}, ${styleText('red', `${failedPlugins.size} failed`)}, ${pluginsCount} total`,
+    pluginsFailed: status === 'failed' ? [...failedPlugins].map(({ plugin }) => randomCliColor(plugin.name)).join(', ') : undefined,
+    filesCreated,
+    time: styleText('green', duration),
+    output: path.resolve(config.root, config.output.path),
+  } as const
+
+  const labels = {
+    plugins: 'Plugins:',
+    failed: 'Failed:',
+    generated: 'Generated:',
+    pluginTimings: 'Plugin Timings:',
+    output: 'Output:',
+  }
+  const maxLength = Math.max(0, ...[...Object.values(labels), ...(pluginTimings ? Array.from(pluginTimings.keys()) : [])].map((s) => s.length))
+
+  const summaryLines: string[] = []
+  summaryLines.push(`${labels.plugins.padEnd(maxLength + 2)} ${meta.plugins}`)
+
+  if (meta.pluginsFailed) {
+    summaryLines.push(`${labels.failed.padEnd(maxLength + 2)} ${meta.pluginsFailed}`)
+  }
+
+  summaryLines.push(`${labels.generated.padEnd(maxLength + 2)} ${meta.filesCreated} files in ${meta.time}`)
+
+  if (pluginTimings && pluginTimings.size > 0) {
+    const sortedTimings = Array.from(pluginTimings.entries()).sort((a, b) => b[1] - a[1])
+
+    summaryLines.push(`${labels.pluginTimings}`)
+
+    sortedTimings.forEach(([name, time]) => {
+      const timeStr = time >= 1000 ? `${(time / 1000).toFixed(2)}s` : `${Math.round(time)}ms`
+      const barLength = Math.min(Math.ceil(time / SUMMARY_TIME_SCALE_DIVISOR), SUMMARY_MAX_BAR_LENGTH)
+      const bar = styleText('dim', '█'.repeat(barLength))
+
+      summaryLines.push(`${styleText('dim', '•')} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`)
+    })
+  }
+
+  summaryLines.push(`${labels.output.padEnd(maxLength + 2)} ${meta.output}`)
+
+  return summaryLines
 }