@kubb/cli 5.0.0-beta.1 → 5.0.0-beta.11

package/src/runners/generate/run.ts

@@ -0,0 +1,276 @@
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+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, detectFormatter, detectLinter, executeIfOnline, formatters, linters, toError } from '@internals/utils'
+import { 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, type HookSinkFactory } from '../../loggers/utils.ts'
+import { buildTelemetryEvent, sendTelemetry } from '../../telemetry.ts'
+import { executeHooks, getConfigs, startWatcher } from './utils.ts'
+
+type GenerateProps = {
+  input?: string
+  config: Config
+  hooks: AsyncEventEmitter<KubbHooks>
+  logLevel: number
+  makeSink?: HookSinkFactory
+}
+
+type ToolMap = typeof formatters | typeof linters
+
+type RunToolPassOptions = {
+  toolValue: string
+  detect: () => Promise<string | null>
+  toolMap: ToolMap
+  toolLabel: string
+  successPrefix: string
+  noToolMessage: string
+  configName: string | undefined
+  outputPath: string
+  logLevel: number
+  hooks: AsyncEventEmitter<KubbHooks>
+  onStart: () => Promise<void>
+  onEnd: () => Promise<void>
+}
+
+/**
+ * Registers a one-shot `kubb:hook:end` listener for `hookId` BEFORE the caller emits `kubb:hook:start`,
+ * avoiding the race where a synchronous emitter fires end before the listener is attached.
+ */
+function waitForHookEnd(hooks: AsyncEventEmitter<KubbHooks>, hookId: string, onSuccess: () => Promise<void>, fallbackErrorMessage: string): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    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(fallbackErrorMessage))
+        return
+      }
+      onSuccess().then(resolve).catch(reject)
+    }
+    hooks.on('kubb:hook:end', handler)
+  })
+}
+
+async function runToolPass({
+  toolValue,
+  detect,
+  toolMap,
+  toolLabel,
+  successPrefix,
+  noToolMessage,
+  configName,
+  outputPath,
+  logLevel,
+  hooks,
+  onStart,
+  onEnd,
+}: RunToolPassOptions) {
+  await onStart()
+
+  let resolvedTool = toolValue
+  if (resolvedTool === 'auto') {
+    const detected = await detect()
+    if (!detected) {
+      await hooks.emit('kubb:warn', { message: noToolMessage })
+    } else {
+      resolvedTool = detected
+      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]
+    const hookId = createHash('sha256').update([configName, resolvedTool].filter(Boolean).join('-')).digest('hex')
+
+    const successMessage = [
+      `${successPrefix} with ${styleText('dim', resolvedTool)}`,
+      logLevel >= logLevelMap.info ? `on ${styleText('dim', outputPath)}` : undefined,
+      'successfully',
+    ]
+      .filter(Boolean)
+      .join(' ')
+
+    try {
+      const hookEndPromise = waitForHookEnd(hooks, hookId, () => hooks.emit('kubb:success', { message: successMessage }), toolConfig.errorMessage)
+
+      await hooks.emit('kubb:hook:start', { id: hookId, command: toolConfig.command, args: toolConfig.args(outputPath) })
+
+      await hookEndPromise
+    } catch (caughtError) {
+      const err = toError(caughtError)
+      await hooks.emit('kubb:error', { error: err })
+      toolError = err
+    }
+  }
+
+  await onEnd()
+
+  if (toolError) {
+    throw toolError
+  }
+}
+
+async function generate(options: GenerateProps): Promise<void> {
+  const { input, hooks, logLevel, makeSink } = options
+
+  const hrStart = process.hrtime()
+  const inputPath = input ?? (options.config.input && 'path' in options.config.input ? options.config.input.path : undefined)
+
+  const config: Config = {
+    ...options.config,
+    input: inputPath ? { ...options.config.input, path: inputPath } : options.config.input,
+    ...options.config.output,
+  } satisfies Config
+
+  const kubb = createKubb(config, { hooks })
+  await kubb.setup()
+
+  await hooks.emit('kubb:generation:start', { config })
+  await hooks.emit('kubb:info', { message: config.name ? `Setup generation ${styleText('bold', config.name)}` : 'Setup generation', info: inputPath })
+  await hooks.emit('kubb:info', { message: config.name ? `Build generation ${styleText('bold', config.name)}` : 'Build generation', info: inputPath })
+
+  const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild()
+
+  await hooks.emit('kubb:info', { message: 'Load summary' })
+
+  const telemetryPlugins = Array.from(driver.plugins.values(), (p) => ({ name: p.name, options: p.options as Record<string, unknown> }))
+
+  const reportTelemetry = (status: 'success' | 'failed') =>
+    sendTelemetry(buildTelemetryEvent({ command: 'generate', kubbVersion: version, plugins: telemetryPlugins, hrStart, filesCreated: files.length, status }))
+
+  if (failedPlugins.size > 0 || error) {
+    const allErrors = [error, ...Array.from(failedPlugins, (it) => it.error)].filter(Boolean) as Error[]
+
+    for (const err of allErrors) {
+      await hooks.emit('kubb:error', { error: err })
+    }
+
+    await hooks.emit('kubb:generation:end', { config, storage: kubb.storage })
+    await hooks.emit('kubb:generation:summary', {
+      config,
+      failedPlugins,
+      filesCreated: files.length,
+      status: 'failed',
+      hrStart,
+      pluginTimings: logLevel >= logLevelMap.verbose ? pluginTimings : undefined,
+    })
+
+    await reportTelemetry('failed')
+    process.exit(1)
+  }
+
+  await hooks.emit('kubb:success', { message: 'Generation succeeded', info: inputPath })
+  await hooks.emit('kubb:generation:end', { config, storage: kubb.storage })
+
+  const outputPath = path.resolve(config.root, config.output.path)
+
+  const toolPasses = [
+    config.output.format && {
+      toolValue: config.output.format,
+      detect: detectFormatter,
+      toolMap: formatters,
+      toolLabel: 'formatter',
+      successPrefix: 'Formatting',
+      noToolMessage: 'No formatter found (oxfmt, biome, or prettier). Skipping formatting.',
+      onStart: () => hooks.emit('kubb:format:start'),
+      onEnd: () => hooks.emit('kubb:format:end'),
+    },
+    config.output.lint && {
+      toolValue: config.output.lint,
+      detect: detectLinter,
+      toolMap: linters,
+      toolLabel: 'linter',
+      successPrefix: 'Linting',
+      noToolMessage: 'No linter found (oxlint, biome, or eslint). Skipping linting.',
+      onStart: () => hooks.emit('kubb:lint:start'),
+      onEnd: () => hooks.emit('kubb:lint:end'),
+    },
+  ].filter(Boolean) as Omit<RunToolPassOptions, 'configName' | 'outputPath' | 'logLevel' | 'hooks'>[]
+
+  for (const pass of toolPasses) {
+    await runToolPass({ ...pass, configName: config.name, outputPath, logLevel, hooks })
+  }
+
+  if (config.hooks) {
+    await hooks.emit('kubb:hooks:start')
+    await executeHooks({ configHooks: config.hooks, hooks, makeSink })
+    await hooks.emit('kubb:hooks:end')
+  }
+
+  await hooks.emit('kubb:generation:summary', { config, failedPlugins, filesCreated: files.length, status: 'success', hrStart, pluginTimings })
+
+  await reportTelemetry('success')
+}
+
+type GenerateCommandOptions = {
+  input?: string
+  configPath?: string
+  logLevel: string
+  watch: boolean
+}
+
+async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void> {
+  await executeIfOnline(async () => {
+    try {
+      const res = await fetch(KUBB_NPM_PACKAGE_URL)
+      const data = (await res.json()) as { version: string }
+      if (data.version && version < data.version) {
+        await hooks.emit('kubb:version:new', { currentVersion: version, latestVersion: data.version })
+      }
+    } catch {
+      // Ignore network errors
+    }
+  })
+}
+
+/**
+ * Runs the full Kubb generation lifecycle for the given CLI options.
+ * Sets up the logger, checks for a newer version, loads configs, and calls `generate` for each config entry.
+ */
+export async function run({ input, configPath, logLevel: logLevelKey, watch }: GenerateCommandOptions): Promise<void> {
+  const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
+  const hooks = new AsyncEventEmitterClass<KubbHooks>()
+
+  const makeSink = await setupLogger(hooks, { logLevel })
+
+  await checkForUpdate(hooks)
+
+  try {
+    const { configs, configPath: resolvedConfigPath } = await getConfigs({ configPath, input })
+    const relativeConfigPath = path.relative(process.cwd(), resolvedConfigPath)
+
+    await hooks.emit('kubb:config:start')
+    await hooks.emit('kubb:info', { message: 'Config loaded', info: relativeConfigPath })
+    await hooks.emit('kubb:success', { message: 'Config loaded successfully', info: relativeConfigPath })
+    await hooks.emit('kubb:config:end', { configs })
+    await hooks.emit('kubb:lifecycle:start', { version })
+
+    for (const config of configs) {
+      if (isInputPath(config) && watch) {
+        await startWatcher(
+          [input || config.input.path],
+          async (paths) => {
+            hooks.removeAll()
+            await generate({ input, config, logLevel, hooks, makeSink })
+            clack.log.step(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))
+          },
+          { info: (msg) => clack.log.info(msg), error: (msg) => clack.log.error(msg) },
+        )
+      } else {
+        await generate({ input, config, logLevel, hooks, makeSink })
+      }
+    }
+
+    await hooks.emit('kubb:lifecycle:end')
+  } catch (error) {
+    await hooks.emit('kubb:error', { error: toError(error) })
+    process.exit(1)
+  }
+}

package/src/runners/generate/utils.ts

@@ -0,0 +1,209 @@
+import { createHash } from 'node:crypto'
+import { styleText } from 'node:util'
+import type { AsyncEventEmitter } from '@internals/utils'
+import { toError, tokenize } from '@internals/utils'
+import type { CLIOptions, Config, KubbHooks, PossibleConfig } from '@kubb/core'
+import { cosmiconfig } from 'cosmiconfig'
+import { createJiti } from 'jiti'
+import { NonZeroExitError, x } from 'tinyexec'
+import type { HookSinkOptions } from '../../loggers/utils.ts'
+import { WATCHER_IGNORED_PATHS } from '../../constants.ts'
+
+type CosmiconfigResult = {
+  filepath: string
+  isEmpty?: boolean
+  config: PossibleConfig<CLIOptions>
+}
+
+const jiti = createJiti(import.meta.url, {
+  jsx: { runtime: 'automatic', importSource: '@kubb/renderer-jsx' },
+  moduleCache: false,
+})
+
+const tsLoader = (configFile: string) => jiti.import(configFile, { default: true })
+
+const MODULE_NAME = 'kubb'
+
+const BASE_SEARCH_PLACES = [
+  'package.json',
+  `.${MODULE_NAME}rc`,
+  `.${MODULE_NAME}rc.json`,
+  `.${MODULE_NAME}rc.yaml`,
+  `.${MODULE_NAME}rc.yml`,
+  `.${MODULE_NAME}rc.ts`,
+  `.${MODULE_NAME}rc.mts`,
+  `.${MODULE_NAME}rc.cts`,
+  `.${MODULE_NAME}rc.js`,
+  `.${MODULE_NAME}rc.mjs`,
+  `.${MODULE_NAME}rc.cjs`,
+  `${MODULE_NAME}.config.ts`,
+  `${MODULE_NAME}.config.mts`,
+  `${MODULE_NAME}.config.cts`,
+  `${MODULE_NAME}.config.js`,
+  `${MODULE_NAME}.config.mjs`,
+  `${MODULE_NAME}.config.cjs`,
+]
+
+const SEARCH_PLACES = ['', '.config/', 'configs/'].flatMap((prefix) => BASE_SEARCH_PLACES.map((p) => `${prefix}${p}`))
+
+async function getCosmiConfig(configFile?: string): Promise<CosmiconfigResult> {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    cache: false,
+    searchPlaces: SEARCH_PLACES,
+    loaders: { '.ts': tsLoader, '.mts': tsLoader, '.cts': tsLoader },
+  })
+
+  let result: CosmiconfigResult
+  try {
+    result = (configFile ? await explorer.load(configFile) : await explorer.search()) as CosmiconfigResult
+  } catch (error) {
+    throw new Error('Config failed loading', { cause: error })
+  }
+
+  if (!result?.config || result.isEmpty) {
+    throw new Error('Config not defined, create a kubb.config.js or pass through your config with the option --config')
+  }
+
+  return result
+}
+
+type GetConfigsOptions = {
+  /**
+   * Explicit path to the Kubb config file. When omitted, cosmiconfig searches from the current directory.
+   */
+  configPath?: string
+  /**
+   * Optional OpenAPI input path that overrides `config.input.path` for this run.
+   */
+  input?: string
+}
+
+type GetConfigsResult = {
+  /**
+   * Absolute path to the resolved config file.
+   */
+  configPath: string
+  /**
+   * Resolved and normalized array of Kubb configs, each guaranteed to have a `plugins` array.
+   */
+  configs: Array<Config>
+}
+
+/**
+ * Discovers the Kubb config via cosmiconfig and resolves it into a normalized array of configs.
+ * Every config in the result is guaranteed to have a `plugins` array.
+ */
+export async function getConfigs({ configPath, input }: GetConfigsOptions): Promise<GetConfigsResult> {
+  const result = await getCosmiConfig(configPath)
+  const resolved = await (typeof result.config === 'function' ? result.config({ input } as CLIOptions) : result.config)
+  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
+
+  return {
+    configPath: result.filepath,
+    configs: userConfigs.map((item) => ({ ...item, plugins: item.plugins ?? [] }) as Config),
+  }
+}
+
+type ExecuteHooksOptions = {
+  configHooks: NonNullable<Config['hooks']>
+  hooks: AsyncEventEmitter<KubbHooks>
+  makeSink?: (commandWithArgs: string) => HookSinkOptions | undefined
+}
+
+/**
+ * Runs the `done` hooks defined in a Kubb config in sequence.
+ */
+export async function executeHooks({ configHooks, hooks, makeSink }: ExecuteHooksOptions): Promise<void> {
+  const commands = Array.isArray(configHooks.done) ? configHooks.done : [configHooks.done].filter(Boolean)
+
+  for (const command of commands) {
+    const [cmd, ...args] = tokenize(command)
+    if (!cmd) continue
+
+    const hookId = createHash('sha256').update(command).digest('hex')
+    const commandWithArgs = [cmd, ...args].join(' ')
+
+    await hooks.emit('kubb:hook:start', { id: hookId, command: cmd, args })
+
+    const { stream = false, onLine, onStdout, onStderr } = makeSink?.(commandWithArgs) ?? {}
+    await runHook({ id: hookId, command: cmd, args, commandWithArgs, context: hooks, stream, sink: { onLine, onStdout, onStderr } })
+  }
+}
+
+type RunHookOptions = {
+  id: string
+  command: string
+  args?: readonly string[]
+  commandWithArgs: string
+  context: AsyncEventEmitter<KubbHooks>
+  stream?: boolean
+  sink?: HookSinkOptions
+}
+
+async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }: RunHookOptions): Promise<void> {
+  const emitEnd = (success: boolean, error: Error | null) => context.emit('kubb:hook:end', { command, args, id, success, error })
+
+  try {
+    const proc = x(command, [...(args ?? [])], {
+      nodeOptions: { detached: process.platform !== 'win32' },
+      throwOnError: true,
+    })
+
+    if (stream && sink?.onLine) {
+      for await (const line of proc) {
+        sink.onLine(line)
+      }
+    }
+
+    const result = await proc
+    await context.emit('kubb:debug', { date: new Date(), logs: [result.stdout.trimEnd()] })
+    await context.emit('kubb:success', { message: `${styleText('dim', commandWithArgs)} successfully executed` })
+    await emitEnd(true, null)
+  } catch (err) {
+    if (!(err instanceof NonZeroExitError)) {
+      const error = toError(err)
+      await emitEnd(false, error)
+      await context.emit('kubb:error', { error })
+      return
+    }
+
+    const stderr = err.output?.stderr ?? ''
+    const stdout = err.output?.stdout ?? ''
+
+    await context.emit('kubb:debug', { date: new Date(), logs: [stdout, stderr].filter(Boolean) })
+
+    if (stderr) sink?.onStderr?.(stderr)
+    if (stdout) sink?.onStdout?.(stdout)
+
+    const error = new Error(`Hook execute failed: ${commandWithArgs}`)
+    await emitEnd(false, error)
+    await context.emit('kubb:error', { error })
+  }
+}
+
+type WatcherLog = {
+  info: (message: string) => void
+  error: (message: string) => void
+}
+
+/**
+ * Starts a file watcher on the given paths and calls `cb` on any change.
+ * Ignores `.git` and `node_modules` directories.
+ */
+export async function startWatcher(
+  path: string[],
+  cb: (path: string[]) => Promise<void>,
+  log: WatcherLog = { info: console.log, error: console.log },
+): Promise<void> {
+  const { watch } = await import('chokidar')
+  const watcher = watch(path, { ignorePermissionErrors: true, ignored: WATCHER_IGNORED_PATHS })
+
+  watcher.on('all', async (type, file) => {
+    log.info(styleText('yellow', styleText('bold', `Change detected: ${type} ${file}`)))
+    try {
+      await cb(path)
+    } catch (_e) {
+      log.error(styleText('red', 'Watcher failed'))
+    }
+  })
+}

package/src/runners/init/run.ts

@@ -0,0 +1,211 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import { styleText } from 'node:util'
+import * as clack from '@clack/prompts'
+import { detectPackageManager } from '@internals/utils'
+import { availablePlugins, generateConfigFile, initDefaults, KUBB_CONFIG_FILENAME, type PluginOption } from '@internals/shared'
+import { hasPackageJson, initPackageJson, installPackages } from './utils.ts'
+
+function cancelAndExit(message = 'Operation cancelled.'): never {
+  clack.cancel(message)
+  process.exit(0)
+}
+
+type InitOptions = {
+  /**
+   * When `true`, skips all interactive prompts and uses default values.
+   */
+  yes: boolean
+  /**
+   * Current `@kubb/cli` version string, shown in the outro and used for package installation.
+   */
+  version: string
+  /**
+   * Input path flag value from `--input`. When provided, skips the input prompt.
+   */
+  input?: string
+  /**
+   * Output directory flag value from `--output`. When provided, skips the output prompt.
+   */
+  output?: string
+  /**
+   * Comma-separated plugin list from `--plugins`, e.g. `'plugin-ts,plugin-zod'`. When provided, skips the plugin selection prompt.
+   */
+  plugins?: string
+}
+
+/**
+ * Runs the interactive Kubb scaffolding wizard.
+ * Detects the package manager, prompts for input/output paths and plugins, installs packages, and writes `kubb.config.ts`.
+ * Pass `yes: true` to skip all prompts and use defaults.
+ */
+export async function run({ yes, version, input: inputFlag, output: outputFlag, plugins: pluginsFlag }: InitOptions): Promise<void> {
+  const cwd = process.cwd()
+
+  clack.intro(styleText('bgCyan', styleText('black', ' Kubb Init ')))
+
+  /**
+   * Returns `flag` when provided, the `defaultValue` when `yes` is set,
+   * or calls `prompt()` for interactive input. Exits on cancellation.
+   */
+  async function resolveOrPrompt<T>(flag: T | undefined, defaultValue: T, logLabel: string, prompt: () => Promise<T | symbol>): Promise<T> {
+    if (flag !== undefined) {
+      clack.log.info(`${logLabel}: ${styleText('cyan', String(flag))}`)
+      return flag
+    }
+    if (yes) {
+      clack.log.info(`${logLabel}: ${styleText('cyan', String(defaultValue))}`)
+      return defaultValue
+    }
+    const result = await prompt()
+    if (clack.isCancel(result)) cancelAndExit()
+    return result as T
+  }
+
+  try {
+    // Check/create package.json — detect package manager once after the block
+    if (!hasPackageJson(cwd)) {
+      if (!yes) {
+        const shouldInit = await clack.confirm({
+          message: 'No package.json found. Would you like to create one?',
+          initialValue: true,
+        })
+
+        if (clack.isCancel(shouldInit) || !shouldInit) {
+          cancelAndExit()
+        }
+      }
+
+      const packageManager = detectPackageManager(cwd)
+      const spinner = clack.spinner()
+      spinner.start(`Initializing package.json with ${packageManager.name}`)
+      await initPackageJson(cwd, packageManager)
+      spinner.stop(`Created package.json with ${packageManager.name}`)
+    }
+
+    const packageManager = detectPackageManager(cwd)
+    if (hasPackageJson(cwd)) {
+      clack.log.info(`Detected package manager: ${styleText('cyan', packageManager.name)}`)
+    }
+
+    // Prompt for OpenAPI spec path
+    const inputPath = await resolveOrPrompt(inputFlag, initDefaults.inputPath, 'Using input path', () =>
+      clack.text({
+        message: 'Where is your OpenAPI specification located?',
+        placeholder: initDefaults.inputPath,
+        defaultValue: initDefaults.inputPath,
+        validate: (value) => {
+          if (!value) return 'Input path is required'
+        },
+      }),
+    )
+
+    // Prompt for output directory
+    const outputPath = await resolveOrPrompt(outputFlag, initDefaults.outputPath, 'Using output path', () =>
+      clack.text({
+        message: 'Where should the generated files be output?',
+        placeholder: initDefaults.outputPath,
+        defaultValue: initDefaults.outputPath,
+        validate: (value) => {
+          if (!value) return 'Output path is required'
+        },
+      }),
+    )
+
+    // Plugin selection
+    const defaultPlugins = availablePlugins.filter((p) => (initDefaults.plugins as readonly string[]).includes(p.value))
+    const pluginLabel = (plugins: PluginOption[]) => styleText('cyan', plugins.map((p) => p.label).join(', '))
+
+    let selectedPlugins: PluginOption[]
+    if (pluginsFlag) {
+      const requested = pluginsFlag
+        .split(',')
+        .map((v) => v.trim())
+        .filter(Boolean)
+      selectedPlugins = availablePlugins.filter((p) => requested.includes(p.value))
+      if (selectedPlugins.length === 0) {
+        selectedPlugins = defaultPlugins
+        clack.log.warn(`No valid plugins found in --plugins value; falling back to default: ${pluginLabel(defaultPlugins)}`)
+      } else {
+        clack.log.info(`Using plugins: ${pluginLabel(selectedPlugins)}`)
+      }
+    } else if (yes) {
+      selectedPlugins = defaultPlugins
+      clack.log.info(`Using plugins: ${pluginLabel(defaultPlugins)}`)
+    } else {
+      const values = await clack.multiselect({
+        message: 'Select plugins to use:',
+        options: availablePlugins.map(({ value, label, hint }) => ({ value, label, hint })),
+        initialValues: [...initDefaults.plugins],
+        required: true,
+      })
+      if (clack.isCancel(values)) cancelAndExit()
+      selectedPlugins = availablePlugins.filter((p) => (values as string[]).includes(p.value))
+    }
+
+    // Install packages
+    const packagesToInstall = ['kubb', ...selectedPlugins.map((p) => p.packageName)]
+
+    const spinner = clack.spinner()
+    spinner.start(`Installing ${packagesToInstall.length} packages with ${packageManager.name}`)
+
+    try {
+      await installPackages(packagesToInstall, packageManager, cwd)
+      spinner.stop(`Installed ${packagesToInstall.length} packages`)
+    } catch (error) {
+      spinner.stop('Installation failed')
+      throw error
+    }
+
+    // Generate config file
+    const configSpinner = clack.spinner()
+    configSpinner.start(`Creating ${KUBB_CONFIG_FILENAME}`)
+
+    const configContent = generateConfigFile({ selectedPlugins, inputPath, outputPath })
+    const configPath = path.join(cwd, KUBB_CONFIG_FILENAME)
+
+    if (fs.existsSync(configPath)) {
+      configSpinner.stop(`${KUBB_CONFIG_FILENAME} already exists`)
+
+      if (!yes) {
+        const shouldOverwrite = await clack.confirm({
+          message: `${KUBB_CONFIG_FILENAME} already exists. Overwrite?`,
+          initialValue: false,
+        })
+
+        if (clack.isCancel(shouldOverwrite) || !shouldOverwrite) {
+          cancelAndExit('Keeping existing configuration. Packages have been installed.')
+        }
+      }
+
+      configSpinner.start(`Overwriting ${KUBB_CONFIG_FILENAME}`)
+    }
+
+    await fs.promises.writeFile(configPath, configContent, 'utf-8')
+
+    configSpinner.stop(`Created ${KUBB_CONFIG_FILENAME}`)
+
+    clack.outro(
+      styleText('green', '✓ All set!') +
+        '\n\n' +
+        styleText('dim', 'Next steps:') +
+        '\n' +
+        styleText('cyan', `  1. Make sure your OpenAPI spec is at: ${inputPath}`) +
+        '\n' +
+        styleText('cyan', '  2. Generate code with: npx kubb generate') +
+        '\n' +
+        styleText('cyan', '     Or start a stream server with: npx kubb agent start') +
+        '\n' +
+        styleText('cyan', `  3. Find generated files in: ${outputPath}`) +
+        '\n\n' +
+        styleText('dim', `Using ${packageManager.name} • Kubb v${version}`),
+    )
+  } catch (error) {
+    clack.log.error(styleText('red', 'An error occurred during initialization'))
+    if (error instanceof Error) {
+      clack.log.error(error.message)
+    }
+    process.exit(1)
+  }
+}