@kubb/cli 5.0.0-alpha.6 → 5.0.0-alpha.60

package/src/runners/generate.ts

@@ -4,26 +4,13 @@ import process from 'node:process'
 import { styleText } from 'node:util'
 import * as clack from '@clack/prompts'
 import type { AsyncEventEmitter } from '@internals/utils'
-import { AsyncEventEmitter as AsyncEventEmitterClass, executeIfOnline, toError } from '@internals/utils'
-import {
-  type CLIOptions,
-  type Config,
-  detectFormatter,
-  detectLinter,
-  formatters,
-  getConfigs,
-  isInputPath,
-  type KubbEvents,
-  linters,
-  logLevel as logLevelMap,
-  PromiseManager,
-  safeBuild,
-  setup,
-} from '@kubb/core'
+import { AsyncEventEmitter as AsyncEventEmitterClass, detectFormatter, detectLinter, executeIfOnline, formatters, linters, toError } from '@internals/utils'
+import { type CLIOptions, type Config, createKubb, isInputPath, type KubbHooks, logLevel as logLevelMap } from '@kubb/core'
 import { version } from '../../package.json'
 import { KUBB_NPM_PACKAGE_URL } from '../constants.ts'
 import { setupLogger } from '../loggers/utils.ts'
 import { executeHooks } from '../utils/executeHooks.ts'
+import { getConfigs } from '../utils/getConfig.ts'
 import { getCosmiConfig } from '../utils/getCosmiConfig.ts'
 import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
 import { startWatcher } from '../utils/watcher.ts'
@@ -31,7 +18,7 @@ import { startWatcher } from '../utils/watcher.ts'
 type GenerateProps = {
   input?: string
   config: Config
-  events: AsyncEventEmitter<KubbEvents>
+  hooks: AsyncEventEmitter<KubbHooks>
   logLevel: number
 }
 
@@ -39,7 +26,7 @@ type ToolMap = typeof formatters | typeof linters
 
 type RunToolPassOptions = {
   toolValue: string
-  detect: () => Promise<string | undefined>
+  detect: () => Promise<string | null>
   toolMap: ToolMap
   /** Short noun used in "Auto-detected <toolLabel>:" message, e.g. "formatter" or "linter". */
   toolLabel: string
@@ -49,7 +36,7 @@ type RunToolPassOptions = {
   configName: string | undefined
   outputPath: string
   logLevel: number
-  events: AsyncEventEmitter<KubbEvents>
+  hooks: AsyncEventEmitter<KubbHooks>
   onStart: () => Promise<void>
   onEnd: () => Promise<void>
 }
@@ -64,7 +51,7 @@ async function runToolPass({
   configName,
   outputPath,
   logLevel,
-  events,
+  hooks,
   onStart,
   onEnd,
 }: RunToolPassOptions) {
@@ -74,13 +61,15 @@ async function runToolPass({
   if (resolvedTool === 'auto') {
     const detected = await detect()
     if (!detected) {
-      await events.emit('warn', noToolMessage)
+      await hooks.emit('kubb:warn', { message: noToolMessage })
     } else {
       resolvedTool = detected
-      await events.emit('info', `Auto-detected ${toolLabel}: ${styleText('dim', resolvedTool)}`)
+      await hooks.emit('kubb:info', { message: `Auto-detected ${toolLabel}: ${styleText('dim', resolvedTool)}` })
     }
   }
 
+  let toolError: Error | undefined
+
   if (resolvedTool && resolvedTool !== 'auto' && resolvedTool in toolMap) {
     const toolConfig = toolMap[resolvedTool as keyof ToolMap]
 
@@ -88,33 +77,32 @@ async function runToolPass({
       const hookId = createHash('sha256').update([configName, resolvedTool].filter(Boolean).join('-')).digest('hex')
 
       // Wire up the hook:end listener BEFORE emitting hook:start to avoid the race condition
-      // where hook:end fires synchronously inside emit('hook:start') before the listener is registered.
+      // where hook:end fires synchronously inside emit('kubb:hook:start') before the listener is registered.
       const hookEndPromise = new Promise<void>((resolve, reject) => {
-        const handler = ({ id, success, error }: { id?: string; command: string; args?: readonly string[]; success: boolean; error: Error | null }) => {
-          if (id !== hookId) return
-          events.off('hook:end', handler)
-          if (!success) {
-            reject(error ?? new Error(`${toolConfig.errorMessage}`))
+        const handler = (ctx: { id?: string; command: string; args?: readonly string[]; success: boolean; error: Error | null }) => {
+          if (ctx.id !== hookId) return
+          hooks.off('kubb:hook:end', handler)
+          if (!ctx.success) {
+            reject(ctx.error ?? new Error(`${toolConfig.errorMessage}`))
             return
           }
-          events
-            .emit(
-              'success',
-              [
+          hooks
+            .emit('kubb:success', {
+              message: [
                 `${successPrefix} with ${styleText('dim', resolvedTool)}`,
                 logLevel >= logLevelMap.info ? `on ${styleText('dim', outputPath)}` : undefined,
                 'successfully',
               ]
                 .filter(Boolean)
                 .join(' '),
-            )
+            })
             .then(resolve)
             .catch(reject)
         }
-        events.on('hook:end', handler)
+        hooks.on('kubb:hook:end', handler)
       })
 
-      await events.emit('hook:start', {
+      await hooks.emit('kubb:hook:start', {
         id: hookId,
         command: toolConfig.command,
         args: toolConfig.args(outputPath),
@@ -122,59 +110,52 @@ async function runToolPass({
 
       await hookEndPromise
     } catch (caughtError) {
-      const err = new Error(toolConfig.errorMessage)
-      err.cause = caughtError
-      await events.emit('error', err)
+      // Use the actual error from the hook. toolConfig.errorMessage (e.g. "Oxlint not found")
+      // is misleading when the binary was found and ran but exited with a non-zero code.
+      // runHook already emitted kubb:error for binary-not-found cases; here we surface the
+      // real reason (e.g. "Hook execute failed: oxlint --fix …") for non-zero exits.
+      const err = toError(caughtError)
+      await hooks.emit('kubb:error', { error: err })
+      toolError = err
     }
   }
 
   await onEnd()
+
+  if (toolError) {
+    throw toolError
+  }
 }
 
-async function generate({ input, config: userConfig, events, logLevel }: GenerateProps): Promise<void> {
-  const inputPath = input ?? ('path' in userConfig.input ? userConfig.input.path : undefined)
+async function generate(options: GenerateProps): Promise<void> {
+  const { input, hooks, logLevel } = options
+
   const hrStart = process.hrtime()
+  const inputPath = input ?? ('path' in options.config.input ? options.config.input.path : undefined)
 
   const config: Config = {
-    ...userConfig,
-    root: userConfig.root || process.cwd(),
+    ...options.config,
     input: inputPath
       ? {
-          ...userConfig.input,
+          ...options.config.input,
           path: inputPath,
         }
-      : userConfig.input,
-    output: {
-      write: true,
-      barrelType: 'named',
-      extension: {
-        '.ts': '.ts',
-      },
-      format: 'prettier',
-      ...userConfig.output,
-    },
-  }
+      : options.config.input,
+    ...options.config.output,
+  } satisfies Config
 
-  await events.emit('generation:start', config)
+  const kubb = createKubb(config, { hooks })
+  await kubb.setup()
 
-  await events.emit('info', config.name ? `Setup generation ${styleText('bold', config.name)}` : 'Setup generation', inputPath)
+  await hooks.emit('kubb:generation:start', { config })
 
-  const { sources, fabric, pluginManager } = await setup({
-    config,
-    events,
-  })
+  await hooks.emit('kubb:info', { message: config.name ? `Setup generation ${styleText('bold', config.name)}` : 'Setup generation', info: inputPath })
 
-  await events.emit('info', config.name ? `Build generation ${styleText('bold', config.name)}` : 'Build generation', inputPath)
+  await hooks.emit('kubb:info', { message: config.name ? `Build generation ${styleText('bold', config.name)}` : 'Build generation', info: inputPath })
 
-  const { files, failedPlugins, pluginTimings, error } = await safeBuild(
-    {
-      config,
-      events,
-    },
-    { pluginManager, fabric, events, sources },
-  )
+  const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild()
 
-  await events.emit('info', 'Load summary')
+  await hooks.emit('kubb:info', { message: 'Load summary' })
 
   // Handle build failures (either from failed plugins or general errors)
 
@@ -189,12 +170,13 @@ async function generate({ input, config: userConfig, events, logLevel }: Generat
     ].filter(Boolean)
 
     for (const err of allErrors) {
-      await events.emit('error', err)
+      await hooks.emit('kubb:error', { error: err })
     }
 
-    await events.emit('generation:end', config, files, sources)
+    await hooks.emit('kubb:generation:end', { config, files, sources: kubb.sources })
 
-    await events.emit('generation:summary', config, {
+    await hooks.emit('kubb:generation:summary', {
+      config,
       failedPlugins,
       filesCreated: files.length,
       status: 'failed',
@@ -206,7 +188,10 @@ async function generate({ input, config: userConfig, events, logLevel }: Generat
       buildTelemetryEvent({
         command: 'generate',
         kubbVersion: version,
-        plugins: pluginManager.plugins.map((p) => ({ name: p.name, options: p.options as Record<string, unknown> })),
+        plugins: Array.from(driver.plugins.values(), (p) => ({
+          name: p.name,
+          options: p.options as Record<string, unknown>,
+        })),
         hrStart,
         filesCreated: files.length,
         status: 'failed',
@@ -216,8 +201,8 @@ async function generate({ input, config: userConfig, events, logLevel }: Generat
     process.exit(1)
   }
 
-  await events.emit('success', 'Generation successfully', inputPath)
-  await events.emit('generation:end', config, files, sources)
+  await hooks.emit('kubb:success', { message: 'Generation successfully', info: inputPath })
+  await hooks.emit('kubb:generation:end', { config, files, sources: kubb.sources })
 
   const outputPath = path.resolve(config.root, config.output.path)
 
@@ -228,13 +213,13 @@ async function generate({ input, config: userConfig, events, logLevel }: Generat
       toolMap: formatters,
       toolLabel: 'formatter',
       successPrefix: 'Formatting',
-      noToolMessage: 'No formatter found (biome, prettier, or oxfmt). Skipping formatting.',
+      noToolMessage: 'No formatter found (oxfmt, biome, or prettier). Skipping formatting.',
       configName: config.name,
       outputPath,
       logLevel,
-      events,
-      onStart: () => events.emit('format:start'),
-      onEnd: () => events.emit('format:end'),
+      hooks,
+      onStart: () => hooks.emit('kubb:format:start'),
+      onEnd: () => hooks.emit('kubb:format:end'),
     })
   }
 
@@ -245,25 +230,26 @@ async function generate({ input, config: userConfig, events, logLevel }: Generat
       toolMap: linters,
       toolLabel: 'linter',
       successPrefix: 'Linting',
-      noToolMessage: 'No linter found (biome, oxlint, or eslint). Skipping linting.',
+      noToolMessage: 'No linter found (oxlint, biome, or eslint). Skipping linting.',
       configName: config.name,
       outputPath,
       logLevel,
-      events,
-      onStart: () => events.emit('lint:start'),
-      onEnd: () => events.emit('lint:end'),
+      hooks,
+      onStart: () => hooks.emit('kubb:lint:start'),
+      onEnd: () => hooks.emit('kubb:lint:end'),
     })
   }
 
   if (config.hooks) {
-    await events.emit('hooks:start')
-    await executeHooks({ hooks: config.hooks, events })
+    await hooks.emit('kubb:hooks:start')
+    await executeHooks({ configHooks: config.hooks, hooks })
 
-    await events.emit('hooks:end')
+    await hooks.emit('kubb:hooks:end')
   }
 
   // Only reached when there are no failures (process.exit(1) is called above otherwise)
-  await events.emit('generation:summary', config, {
+  await hooks.emit('kubb:generation:summary', {
+    config,
     failedPlugins,
     filesCreated: files.length,
     status: 'success',
@@ -274,7 +260,10 @@ async function generate({ input, config: userConfig, events, logLevel }: Generat
   const telemetryEvent = buildTelemetryEvent({
     command: 'generate',
     kubbVersion: version,
-    plugins: pluginManager.plugins.map((p) => ({ name: p.name, options: p.options as Record<string, unknown> })),
+    plugins: Array.from(driver.plugins.values(), (p) => ({
+      name: p.name,
+      options: p.options as Record<string, unknown>,
+    })),
     hrStart,
     filesCreated: files.length,
     status: 'success',
@@ -292,10 +281,9 @@ type GenerateCommandOptions = {
 
 export async function runGenerateCommand({ input, configPath, logLevel: logLevelKey, watch }: GenerateCommandOptions): Promise<void> {
   const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
-  const events = new AsyncEventEmitterClass<KubbEvents>()
-  const promiseManager = new PromiseManager()
+  const hooks = new AsyncEventEmitterClass<KubbHooks>()
 
-  await setupLogger(events, { logLevel })
+  await setupLogger(hooks, { logLevel })
 
   await executeIfOnline(async () => {
     try {
@@ -304,7 +292,7 @@ export async function runGenerateCommand({ input, configPath, logLevel: logLevel
       const latestVersion = data.version
 
       if (latestVersion && version < latestVersion) {
-        await events.emit('version:new', version, latestVersion)
+        await hooks.emit('kubb:version:new', { currentVersion: version, latestVersion })
       }
     } catch {
       // Ignore network errors for version check
@@ -315,37 +303,31 @@ export async function runGenerateCommand({ input, configPath, logLevel: logLevel
     const result = await getCosmiConfig('kubb', configPath)
     const configs = await getConfigs(result.config, { input } as CLIOptions)
 
-    await events.emit('config:start')
-    await events.emit('info', 'Config loaded', path.relative(process.cwd(), result.filepath))
-    await events.emit('success', 'Config loaded successfully', path.relative(process.cwd(), result.filepath))
-    await events.emit('config:end', configs)
-
-    await events.emit('lifecycle:start', version)
-
-    const promises = configs.map((config) => {
-      return async () => {
-        if (isInputPath(config) && watch) {
-          await startWatcher([input || config.input.path], async (paths) => {
-            // remove to avoid duplicate listeners after each change
-            events.removeAll()
+    await hooks.emit('kubb:config:start')
+    await hooks.emit('kubb:info', { message: 'Config loaded', info: path.relative(process.cwd(), result.filepath) })
+    await hooks.emit('kubb:success', { message: 'Config loaded successfully', info: path.relative(process.cwd(), result.filepath) })
+    await hooks.emit('kubb:config:end', { configs })
 
-            await generate({ input, config, logLevel, events })
+    await hooks.emit('kubb:lifecycle:start', { version })
 
-            clack.log.step(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))
-          })
+    for (const config of configs) {
+      if (isInputPath(config) && watch) {
+        await startWatcher([input || config.input.path], async (paths) => {
+          // remove to avoid duplicate listeners after each change
+          hooks.removeAll()
 
-          return
-        }
+          await generate({ input, config, logLevel, hooks })
 
-        await generate({ input, config, logLevel, events })
+          clack.log.step(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))
+        })
+      } else {
+        await generate({ input, config, logLevel, hooks })
       }
-    })
-
-    await promiseManager.run('seq', promises)
+    }
 
-    await events.emit('lifecycle:end')
+    await hooks.emit('kubb:lifecycle:end')
   } catch (error) {
-    await events.emit('error', toError(error))
+    await hooks.emit('kubb:error', { error: toError(error) })
     process.exit(1)
   }
 }

package/src/runners/init.ts

@@ -5,7 +5,7 @@ import { styleText } from 'node:util'
 import * as clack from '@clack/prompts'
 import type { PackageManagerInfo } from '@internals/utils'
 import { detectPackageManager } from '@internals/utils'
-import { initDefaults, pluginDefaultConfigs } from '../constants.ts'
+import { initDefaults, KUBB_CONFIG_FILENAME, pluginDefaultConfigs } from '../constants.ts'
 import { hasPackageJson, initPackageJson, installPackages } from '../utils/packageManager.ts'
 
 type PluginOption = {
@@ -123,7 +123,7 @@ function generateConfigFile(selectedPlugins: PluginOption[], inputPath: string,
     })
     .join('\n')
 
-  return `import { defineConfig } from '@kubb/core'
+  return `import { defineConfig } from 'kubb'
 ${imports}
 
 export default defineConfig({
@@ -257,7 +257,7 @@ export async function runInit({ yes, version }: InitOptions): Promise<void> {
     }
 
     // Install packages
-    const packagesToInstall = ['@kubb/core', '@kubb/cli', '@kubb/agent', ...selectedPlugins.map((p) => p.packageName)]
+    const packagesToInstall = ['kubb', ...selectedPlugins.map((p) => p.packageName)]
 
     const spinner = clack.spinner()
     spinner.start(`Installing ${packagesToInstall.length} packages with ${packageManager.name}`)
@@ -272,17 +272,17 @@ export async function runInit({ yes, version }: InitOptions): Promise<void> {
 
     // Generate config file
     const configSpinner = clack.spinner()
-    configSpinner.start('Creating kubb.config.ts')
+    configSpinner.start(`Creating ${KUBB_CONFIG_FILENAME}`)
 
     const configContent = generateConfigFile(selectedPlugins, inputPath, outputPath)
-    const configPath = path.join(cwd, 'kubb.config.ts')
+    const configPath = path.join(cwd, KUBB_CONFIG_FILENAME)
 
     if (fs.existsSync(configPath)) {
-      configSpinner.stop('kubb.config.ts already exists')
+      configSpinner.stop(`${KUBB_CONFIG_FILENAME} already exists`)
 
       if (!yes) {
         const shouldOverwrite = await clack.confirm({
-          message: 'kubb.config.ts already exists. Overwrite?',
+          message: `${KUBB_CONFIG_FILENAME} already exists. Overwrite?`,
           initialValue: false,
         })
 
@@ -291,12 +291,12 @@ export async function runInit({ yes, version }: InitOptions): Promise<void> {
         }
       }
 
-      configSpinner.start('Overwriting kubb.config.ts')
+      configSpinner.start(`Overwriting ${KUBB_CONFIG_FILENAME}`)
     }
 
     fs.writeFileSync(configPath, configContent, 'utf-8')
 
-    configSpinner.stop('Created kubb.config.ts')
+    configSpinner.stop(`Created ${KUBB_CONFIG_FILENAME}`)
 
     clack.outro(
       styleText('green', '✓ All set!') +

package/src/runners/mcp.ts

@@ -12,7 +12,9 @@ type McpOptions = {
 export async function runMcp({ version }: McpOptions): Promise<void> {
   let mod: typeof McpModule
   try {
-    mod = (await jiti.import('@kubb/mcp', { default: true })) as typeof McpModule
+    mod = (await jiti.import('@kubb/mcp', {
+      default: true,
+    })) as typeof McpModule
   } catch (_e) {
     console.error(`Import of '@kubb/mcp' is required to start the MCP server`)
     process.exit(1)
@@ -24,9 +26,23 @@ export async function runMcp({ version }: McpOptions): Promise<void> {
     console.log('⏳ Starting MCP server...')
     console.warn(styleText('yellow', 'This feature is still under development — use with caution'))
     run()
-    await sendTelemetry(buildTelemetryEvent({ command: 'mcp', kubbVersion: version, hrStart, status: 'success' }))
+    await sendTelemetry(
+      buildTelemetryEvent({
+        command: 'mcp',
+        kubbVersion: version,
+        hrStart,
+        status: 'success',
+      }),
+    )
   } catch (error) {
-    await sendTelemetry(buildTelemetryEvent({ command: 'mcp', kubbVersion: version, hrStart, status: 'failed' }))
+    await sendTelemetry(
+      buildTelemetryEvent({
+        command: 'mcp',
+        kubbVersion: version,
+        hrStart,
+        status: 'failed',
+      }),
+    )
     console.error(getErrorMessage(error))
   }
 }

package/src/runners/validate.ts

@@ -1,7 +1,6 @@
 import process from 'node:process'
 import { getErrorMessage } from '@internals/utils'
-import type * as OasModule from '@kubb/oas'
-import { jiti } from '../utils/jiti.ts'
+import { parseDocument, validateDocument } from '@kubb/adapter-oas'
 import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
 
 type ValidateOptions = {
@@ -10,24 +9,29 @@ type ValidateOptions = {
 }
 
 export async function runValidate({ input, version }: ValidateOptions): Promise<void> {
-  let mod: typeof OasModule
-  try {
-    mod = (await jiti.import('@kubb/oas', { default: true })) as typeof OasModule
-  } catch (_e) {
-    console.error(`Import of '@kubb/oas' is required to do validation`)
-    process.exit(1)
-  }
-
-  const { parse } = mod
   const hrStart = process.hrtime()
   try {
-    const oas = await parse(input)
-    await oas.validate()
+    const document = await parseDocument(input)
+    await validateDocument(document, { throwOnError: true })
 
-    await sendTelemetry(buildTelemetryEvent({ command: 'validate', kubbVersion: version, hrStart, status: 'success' }))
+    await sendTelemetry(
+      buildTelemetryEvent({
+        command: 'validate',
+        kubbVersion: version,
+        hrStart,
+        status: 'success',
+      }),
+    )
     console.log('✅ Validation success')
   } catch (error) {
-    await sendTelemetry(buildTelemetryEvent({ command: 'validate', kubbVersion: version, hrStart, status: 'failed' }))
+    await sendTelemetry(
+      buildTelemetryEvent({
+        command: 'validate',
+        kubbVersion: version,
+        hrStart,
+        status: 'failed',
+      }),
+    )
     console.error('❌ Validation failed')
     console.error(getErrorMessage(error))
     process.exit(1)

package/src/types.ts

@@ -0,0 +1,11 @@
+export type QuiteFlag = '--help' | '-h' | '--version' | '-v'
+
+export type GenerateFlag = '--config' | '-c' | '--log-level' | '-l' | '--watch' | '-w' | '--debug' | '-d' | '--verbose' | '-v' | '--silent' | '-s'
+
+export type ValidateFlag = '--input' | '-i'
+
+export type InitFlag = '--yes' | '-y'
+
+export type AgentStartFlag = '--config' | '-c' | '--port' | '-p' | '--host' | '--allow-write' | '--allow-all'
+
+export type Arg = QuiteFlag | GenerateFlag | ValidateFlag | InitFlag | AgentStartFlag

package/src/utils/executeHooks.ts

@@ -2,15 +2,15 @@ import { createHash } from 'node:crypto'
 import { styleText } from 'node:util'
 import type { AsyncEventEmitter } from '@internals/utils'
 import { tokenize } from '@internals/utils'
-import type { Config, KubbEvents } from '@kubb/core'
+import type { Config, KubbHookEndContext, KubbHooks } from '@kubb/core'
 
 type ExecutingHooksProps = {
-  hooks: NonNullable<Config['hooks']>
-  events: AsyncEventEmitter<KubbEvents>
+  configHooks: NonNullable<Config['hooks']>
+  hooks: AsyncEventEmitter<KubbHooks>
 }
 
-export async function executeHooks({ hooks, events }: ExecutingHooksProps): Promise<void> {
-  const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done].filter(Boolean)
+export async function executeHooks({ configHooks, hooks }: ExecutingHooksProps): Promise<void> {
+  const commands = Array.isArray(configHooks.done) ? configHooks.done : [configHooks.done].filter(Boolean)
 
   for (const command of commands) {
     const [cmd, ...args] = tokenize(command)
@@ -22,24 +22,24 @@ export async function executeHooks({ hooks, events }: ExecutingHooksProps): Prom
     const hookId = createHash('sha256').update(command).digest('hex')
 
     // Wire up the hook:end listener BEFORE emitting hook:start to avoid the race condition
-    // where hook:end fires synchronously inside emit('hook:start') before the listener is registered.
+    // where hook:end fires synchronously inside emit('kubb:hook:start') before the listener is registered.
     const hookEndPromise = new Promise<void>((resolve, reject) => {
-      const handler = ({ id, success, error }: { id?: string; command: string; args?: readonly string[]; success: boolean; error: Error | null }) => {
-        if (id !== hookId) return
-        events.off('hook:end', handler)
-        if (!success) {
-          reject(error ?? new Error(`Hook failed: ${command}`))
+      const handler = (ctx: KubbHookEndContext) => {
+        if (ctx.id !== hookId) return
+        hooks.off('kubb:hook:end', handler)
+        if (!ctx.success) {
+          reject(ctx.error ?? new Error(`Hook failed: ${command}`))
           return
         }
-        events
-          .emit('success', `${styleText('dim', command)} successfully executed`)
+        hooks
+          .emit('kubb:success', { message: `${styleText('dim', command)} successfully executed` })
           .then(resolve)
           .catch(reject)
       }
-      events.on('hook:end', handler)
+      hooks.on('kubb:hook:end', handler)
     })
 
-    await events.emit('hook:start', { id: hookId, command: cmd, args })
+    await hooks.emit('kubb:hook:start', { id: hookId, command: cmd, args })
     await hookEndPromise
   }
 }

package/src/utils/flags.ts

@@ -0,0 +1,10 @@
+/**
+ * Type guard that checks whether a raw string is a member of a typed flag set.
+ * Avoids the need for type assertions when working with `Set<T extends string>`.
+ */
+export function isFlag<T extends string>(set: ReadonlySet<T>, value: string): value is T {
+  for (const flag of set) {
+    if (flag === value) return true
+  }
+  return false
+}

package/src/utils/getConfig.ts

@@ -0,0 +1,10 @@
+import type { CLIOptions, Config, PossibleConfig } from '@kubb/core'
+
+type ConfigInput = PossibleConfig<CLIOptions>
+
+export async function getConfigs(config: ConfigInput, args: CLIOptions): Promise<Array<Config>> {
+  const resolved = await (typeof config === 'function' ? config(args as CLIOptions) : config)
+  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
+
+  return userConfigs.map((item) => ({ ...item, plugins: item.plugins ?? [] }) as Config)
+}