@kubb/cli 5.0.0-beta.62 → 5.0.0-beta.64

package/src/commands/init.ts

@@ -1,51 +0,0 @@
-import { defineCommand } from '@internals/utils'
-import { version } from '../../package.json'
-
-export const command = defineCommand({
-  name: 'init',
-  description:
-    'Scaffold a kubb.config.ts and install plugins for code generation from an OpenAPI spec. Run without flags for interactive setup, or pass --input, --output, and --plugins to skip the prompts.',
-  examples: [
-    'kubb init',
-    'kubb init --yes',
-    'kubb init --input ./openapi.yaml --output ./src/gen --plugins plugin-ts,plugin-zod',
-    'kubb init --plugins plugin-ts,plugin-client,plugin-react-query',
-  ],
-  options: {
-    yes: {
-      type: 'boolean',
-      description: 'Skip prompts and use default options',
-      short: 'y',
-      default: false,
-    },
-    input: {
-      type: 'string',
-      description: 'Path to the OpenAPI specification',
-      short: 'i',
-      hint: 'path',
-    },
-    output: {
-      type: 'string',
-      description: 'Output directory for generated files',
-      short: 'o',
-      hint: 'path',
-    },
-    plugins: {
-      type: 'string',
-      description:
-        'Comma-separated list of plugins to use (plugin-ts, plugin-client, plugin-react-query, plugin-vue-query, plugin-zod, plugin-faker, plugin-msw, plugin-cypress, plugin-mcp, plugin-redoc)',
-      hint: 'plugin-ts,plugin-zod,...',
-    },
-  },
-  async run({ values }) {
-    const { run } = await import('../runners/init/run.ts')
-
-    await run({
-      yes: values.yes,
-      version,
-      input: values.input,
-      output: values.output,
-      plugins: values.plugins,
-    })
-  },
-})

package/src/commands/mcp.ts

@@ -1,36 +0,0 @@
-import { defineCommand } from '@internals/utils'
-import { version } from '../../package.json'
-
-export const command = defineCommand({
-  name: 'mcp',
-  description:
-    'Start a Model Context Protocol (MCP) server that exposes Kubb code generation as tools for AI assistants. Once running, configure your AI client (Claude, Cursor, Windsurf, etc.) to connect to it — the assistant can then call kubb generate directly without leaving the chat.',
-  examples: [
-    'kubb mcp',
-    'kubb mcp --port 3001',
-    '# Then add to your MCP client config:',
-    '# { "mcpServers": { "kubb": { "command": "npx", "args": ["kubb", "mcp"] } } }',
-  ],
-  options: {
-    port: {
-      type: 'string',
-      short: 'p',
-      description: 'Port for HTTP MCP server (omit for stdio)',
-      hint: 'number',
-    },
-    host: {
-      type: 'string',
-      description: 'Hostname to bind to (HTTP mode only)',
-      default: 'localhost',
-    },
-  },
-  async run({ values }) {
-    const { run } = await import('../runners/mcp/run.ts')
-
-    await run({
-      version,
-      port: values.port,
-      host: values.host,
-    })
-  },
-})

package/src/commands/validate.ts

@@ -1,22 +0,0 @@
-import { defineCommand } from '@internals/utils'
-import { version } from '../../package.json'
-
-export const command = defineCommand({
-  name: 'validate',
-  description:
-    'Parse and validate an OpenAPI/Swagger file for structural correctness. Reports schema errors, missing required fields, and malformed references. Use this before running generate to catch spec issues early.',
-  examples: ['kubb validate --input ./openapi.yaml', 'kubb validate --input https://petstore3.swagger.io/api/v3/openapi.json'],
-  options: {
-    input: {
-      type: 'string',
-      description: 'Path or URL to the OpenAPI/Swagger file to validate',
-      short: 'i',
-      required: true,
-    },
-  },
-  async run({ values }) {
-    const { run } = await import('../runners/validate/run.ts')
-
-    await run({ input: values.input, version })
-  },
-})

package/src/constants.ts

@@ -1,19 +0,0 @@
-/**
- * NPM registry endpoint used to check for @kubb/cli updates.
- */
-export const KUBB_NPM_PACKAGE_URL = 'https://registry.npmjs.org/@kubb/cli/latest' as const
-
-/**
- * OpenTelemetry ingestion endpoint for anonymous usage telemetry.
- */
-export const OTLP_ENDPOINT = 'https://otlp.kubb.dev' as const
-
-/**
- * Glob pattern for paths the file watcher ignores.
- */
-export const WATCHER_IGNORED_PATHS = '**/{.git,node_modules}/**' as const
-
-/**
- * Flags that short-circuit execution (help and version). The telemetry notice is suppressed for these.
- */
-export const QUIET_FLAGS = new Set<string>(['--help', '-h', '--version', '-v'])

package/src/index.ts

@@ -1,27 +0,0 @@
-import { styleText } from 'node:util'
-import { createCLI } from '@internals/utils'
-import { Telemetry } from './Telemetry.ts'
-import { version } from '../package.json'
-import { QUIET_FLAGS } from './constants.ts'
-
-const cli = createCLI()
-export async function run(argv: Array<string> = process.argv): Promise<void> {
-  const isQuietFlag = argv.some((arg) => QUIET_FLAGS.has(arg))
-
-  if (!Telemetry.isDisabled && !isQuietFlag) {
-    console.log(
-      `${styleText('yellow', 'Notice:')} Kubb collects anonymous telemetry data to help improve the tool. No personal data or file contents are collected. \nTo disable, set ${styleText('cyan', 'KUBB_DISABLE_TELEMETRY=1')}.\n`,
-    )
-  }
-
-  const { command: generateCommand } = await import('./commands/generate.ts')
-  const { command: validateCommand } = await import('./commands/validate.ts')
-  const { command: mcpCommand } = await import('./commands/mcp.ts')
-  const { command: initCommand } = await import('./commands/init.ts')
-
-  await cli.run([generateCommand, validateCommand, mcpCommand, initCommand], argv, {
-    programName: 'kubb',
-    defaultCommandName: 'generate',
-    version,
-  })
-}

package/src/loggers/clackLogger.ts

@@ -1,392 +0,0 @@
-import { relative } from 'node:path'
-import process from 'node:process'
-import { styleText } from 'node:util'
-import * as clack from '@clack/prompts'
-import { formatMsWithColor, getElapsedMs, getIntro, toCause } from '@internals/utils'
-import { Diagnostics, type KubbHooks, logLevel as logLevelMap } from '@kubb/core'
-import { defineLogger } from './defineLogger.ts'
-import { buildProgressLine, createProgressCounters, formatCommandWithArgs, formatMessage, recordPluginResult, resetProgressCounters } from './utils.ts'
-
-/**
- * TTY logger for local development, with spinners and progress bars.
- */
-export const clackLogger = defineLogger({
-  name: 'clack',
-  install(context, options) {
-    const logLevel = options?.logLevel ?? logLevelMap.info
-    const state = {
-      ...createProgressCounters(),
-      spinner: clack.spinner(),
-      isSpinning: false,
-      runningPlugins: new Set<string>(),
-      activeProgress: new Map<string, { interval?: NodeJS.Timeout; progressBar: clack.ProgressResult }>(),
-      activeHookLogs: new Map<string, { taskLog: ReturnType<typeof clack.taskLog>; hrStart: [number, number] }>(),
-    }
-
-    // Clear every active progress bar's interval, stop it, and drop the map.
-    function stopActiveProgress() {
-      for (const [, active] of state.activeProgress) {
-        if (active.interval) {
-          clearInterval(active.interval)
-        }
-        active.progressBar?.stop()
-      }
-      state.activeProgress.clear()
-    }
-
-    function reset() {
-      stopActiveProgress()
-
-      resetProgressCounters(state)
-      state.spinner = clack.spinner()
-      state.isSpinning = false
-      state.runningPlugins.clear()
-      state.activeHookLogs.clear()
-    }
-
-    // Label for the shared plugin bar, listing the plugins currently generating.
-    function pluginProgressText(): string {
-      const running = [...state.runningPlugins].map((name) => styleText('bold', name))
-      return getMessage(running.length > 0 ? `Generating ${running.join(', ')}` : 'Generating plugins')
-    }
-
-    function showProgressStep() {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const line = buildProgressLine(state)
-      if (line) {
-        clack.log.step(getMessage(line))
-      }
-    }
-
-    function getMessage(message: string): string {
-      return formatMessage(message, logLevel)
-    }
-
-    // Registers a handler that prints a fixed step message, skipped at silent level.
-    function onStep<E extends keyof KubbHooks>(event: E, message: string): void {
-      context.on(event, () => {
-        if (logLevel <= logLevelMap.silent) {
-          return
-        }
-        clack.log.step(getMessage(message))
-      })
-    }
-
-    function stopSpinner(text?: string) {
-      if (!state.isSpinning) {
-        return
-      }
-      state.spinner.stop(text)
-      state.isSpinning = false
-    }
-
-    context.on('kubb:info', ({ message, info = '' }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage([styleText('blue', 'ℹ'), message, info ? styleText('dim', info) : undefined].filter(Boolean).join(' '))
-
-      if (state.isSpinning) {
-        state.spinner.message(text)
-        return
-      }
-      clack.log.info(text)
-    })
-
-    context.on('kubb:success', ({ message, info = '' }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage([styleText('blue', '✓'), message, logLevel >= logLevelMap.info ? styleText('dim', info) : undefined].filter(Boolean).join(' '))
-
-      if (state.isSpinning) {
-        stopSpinner(text)
-        return
-      }
-      clack.log.success(text)
-    })
-
-    context.on('kubb:warn', ({ message, info }) => {
-      if (logLevel < logLevelMap.warn) {
-        return
-      }
-
-      const text = getMessage(
-        [styleText('yellow', '⚠'), message, logLevel >= logLevelMap.info && info ? styleText('dim', info) : undefined].filter(Boolean).join(' '),
-      )
-
-      clack.log.warn(text)
-    })
-
-    context.on('kubb:error', ({ error }) => {
-      const caused = toCause(error)
-
-      const text = [styleText('red', '✗'), error.message].join(' ')
-
-      if (state.isSpinning) {
-        stopSpinner(getMessage(text))
-        return
-      }
-      clack.log.error(getMessage(text))
-
-      // Show stack trace in verbose mode (first 3 frames)
-      if (logLevel >= logLevelMap.verbose && error.stack) {
-        const frames = error.stack.split('\n').slice(1, 4)
-        for (const frame of frames) {
-          clack.log.message(getMessage(styleText('dim', frame.trim())))
-        }
-
-        if (caused?.stack) {
-          clack.log.message(styleText('dim', `└─ caused by ${caused.message}`))
-
-          const frames = caused.stack.split('\n').slice(1, 4)
-          for (const frame of frames) {
-            clack.log.message(getMessage(`    ${styleText('dim', frame.trim())}`))
-          }
-        }
-      }
-    })
-
-    context.on('kubb:diagnostic', ({ diagnostic }) => {
-      // Silent still surfaces errors so failures stay visible. It drops warnings and info.
-      if (logLevel <= logLevelMap.silent && diagnostic.severity !== 'error') {
-        return
-      }
-
-      stopSpinner()
-
-      // Stop any lingering progress UI so the multi-line block renders cleanly.
-      stopActiveProgress()
-
-      // The version-update notice keeps its own framed box instead of the diagnostic gutter.
-      if (Diagnostics.isUpdate(diagnostic)) {
-        clack.box(
-          `\`v${diagnostic.currentVersion}\` → \`v${diagnostic.latestVersion}\`
-Run \`npm install -g @kubb/cli\` to update`,
-          'Update available for `Kubb`',
-          {
-            width: 'auto',
-            formatBorder: (s: string) => styleText('yellow', s),
-            rounded: true,
-            withGuide: false,
-            contentAlign: 'center',
-            titleAlign: 'center',
-          },
-        )
-
-        return
-      }
-
-      // Hand the severity glyph to clack as the gutter `symbol`, then let it draw the
-      // bar on each detail line via the default `secondarySymbol`. The headline and
-      // details carry their own colors, so clack only owns the gutter.
-      const { symbol, headline, details } = Diagnostics.format(diagnostic)
-      clack.log.message([headline, ...details], { symbol })
-    })
-
-    context.on('kubb:lifecycle:start', async ({ version }) => {
-      console.log(`\n${getIntro({ title: 'The meta framework for code generation', description: 'Ready to start', version, areEyesOpen: true })}\n`)
-
-      reset()
-    })
-
-    context.on('kubb:generation:start', ({ config }) => {
-      reset()
-
-      // Initialize progress tracking for this generation
-      state.totalPlugins = config.plugins?.length ?? 0
-
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      const text = getMessage(['Generation started', config.name ? `for ${styleText('dim', config.name)}` : undefined].filter(Boolean).join(' '))
-
-      clack.intro(text)
-    })
-
-    // Plugins run concurrently, so they share a single progress bar. A bar per plugin
-    // would make clack render them side by side and pile up keypress listeners.
-    context.on('kubb:plugin:start', ({ plugin }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      stopSpinner()
-
-      state.runningPlugins.add(plugin.name)
-
-      const active = state.activeProgress.get('plugins')
-      if (active) {
-        active.progressBar.advance(0, pluginProgressText())
-        return
-      }
-
-      const progressBar = clack.progress({
-        style: 'block',
-        max: Math.max(state.totalPlugins, 1),
-        size: 30,
-      })
-      progressBar.start(pluginProgressText())
-      // Catch up to plugins already finished before this bar opened.
-      progressBar.advance(state.completedPlugins + state.failedPlugins, pluginProgressText())
-      state.activeProgress.set('plugins', { progressBar })
-    })
-
-    context.on('kubb:plugin:end', ({ plugin, success }) => {
-      stopSpinner()
-
-      const active = state.activeProgress.get('plugins')
-
-      if (!active || logLevel === logLevelMap.silent) {
-        return
-      }
-
-      state.runningPlugins.delete(plugin.name)
-      recordPluginResult(state, success)
-      active.progressBar.advance(1, pluginProgressText())
-
-      // Close the bar once nothing is generating, then print the progress step.
-      if (state.runningPlugins.size === 0) {
-        active.progressBar.stop(getMessage('Plugins generated'))
-        state.activeProgress.delete('plugins')
-        showProgressStep()
-      }
-    })
-
-    context.on('kubb:files:processing:start', ({ files }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      stopSpinner()
-
-      state.totalFiles = files.length
-      state.processedFiles = 0
-
-      const text = `Writing ${files.length} files`
-      const progressBar = clack.progress({
-        style: 'block',
-        max: files.length,
-        size: 30,
-      })
-
-      context.emit('kubb:info', { message: text })
-      progressBar.start(getMessage(text))
-      state.activeProgress.set('files', { progressBar })
-    })
-
-    context.on('kubb:files:processing:update', ({ files }) => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      stopSpinner()
-
-      const active = state.activeProgress.get('files')
-      for (const { file, config } of files) {
-        state.processedFiles++
-        if (active) {
-          active.progressBar.advance(undefined, `Writing ${relative(config.root, file.path)}`)
-        }
-      }
-    })
-    context.on('kubb:files:processing:end', () => {
-      if (logLevel <= logLevelMap.silent) {
-        return
-      }
-
-      stopSpinner()
-
-      const text = getMessage('Files written successfully')
-      const active = state.activeProgress.get('files')
-
-      if (!active) {
-        return
-      }
-
-      active.progressBar.stop(text)
-      state.activeProgress.delete('files')
-
-      // Show final progress step after files are written
-      showProgressStep()
-    })
-
-    context.on('kubb:generation:end', ({ config }) => {
-      stopSpinner()
-
-      const text = getMessage(config.name ? `Generation completed for ${styleText('dim', config.name)}` : 'Generation completed')
-
-      clack.outro(text)
-    })
-
-    onStep('kubb:format:start', 'Formatting')
-    onStep('kubb:lint:start', 'Linting')
-    onStep('kubb:hooks:start', 'Running hooks')
-
-    context.on('kubb:hook:start', ({ id, command, args }) => {
-      if (logLevel <= logLevelMap.silent || !id) {
-        return
-      }
-
-      stopSpinner()
-
-      const commandWithArgs = formatCommandWithArgs(command, args)
-      const title = getMessage(`Running ${styleText('dim', commandWithArgs)}`)
-      const taskLog = clack.taskLog({ title })
-
-      state.activeHookLogs.set(id, { taskLog, hrStart: process.hrtime() })
-    })
-
-    // Registered only when not silent, so its presence is what tells the runner to stream
-    // (`kubb:hook:line` listenerCount). At silent level the listener is absent, so no streaming happens.
-    if (logLevel > logLevelMap.silent) {
-      context.on('kubb:hook:line', ({ id, line }) => {
-        const active = state.activeHookLogs.get(id)
-        active?.taskLog.message(styleText('dim', line))
-      })
-    }
-
-    context.on('kubb:hook:end', ({ id, command, args, success, error, stdout, stderr }) => {
-      if (!id) {
-        return
-      }
-
-      if (logLevel <= logLevelMap.silent) {
-        // Even when silent, surface a failed hook's captured output.
-        if (!success) {
-          if (stdout) console.log(stdout)
-          if (stderr) console.error(stderr)
-        }
-        return
-      }
-
-      const active = state.activeHookLogs.get(id)
-      if (!active) {
-        return
-      }
-      state.activeHookLogs.delete(id)
-
-      const commandWithArgs = formatCommandWithArgs(command, args)
-      const duration = formatMsWithColor(getElapsedMs(active.hrStart))
-
-      if (success) {
-        active.taskLog.success(getMessage(`${styleText('dim', commandWithArgs)} completed in ${duration}`))
-      } else {
-        // The hook's output already reached the taskLog live via `kubb:hook:line`, so `showLog`
-        // replays it here. `kubb:hook:end` carries no captured output on the streaming path.
-        const reason = error?.message ? ` (${error.message})` : ''
-        active.taskLog.error(getMessage(`${styleText('dim', commandWithArgs)} failed${reason}`), { showLog: true })
-      }
-    })
-
-    context.on('kubb:lifecycle:end', () => {
-      reset()
-    })
-  },
-})

package/src/loggers/defineLogger.ts

@@ -1,59 +0,0 @@
-import type { AsyncEventEmitter } from '@internals/utils'
-import type { KubbHooks } from '@kubb/core'
-
-/**
- * Options accepted by a logger's `install` callback.
- */
-export type LoggerOptions = {
-  /**
-   * Output verbosity. Use the `logLevel` constants exported from `@kubb/core`
-   * (`silent`, `error`, `warn`, `info`, `verbose`, `debug`).
-   */
-  logLevel: number
-}
-
-/**
- * Event emitter handed to `Logger.install`. Use `.on('kubb:info', ...)` and
- * friends to subscribe to build events.
- */
-export type LoggerContext = AsyncEventEmitter<KubbHooks>
-
-/**
- * Logger contract. A logger receives the build's event emitter and subscribes
- * to whichever lifecycle events it wants to forward to its destination
- * (console, file, remote service).
- */
-export type Logger<TOptions extends LoggerOptions = LoggerOptions> = {
-  /**
-   * Display name used in diagnostics.
-   */
-  name: string
-  /**
-   * Called once per build with the shared event emitter. Subscribe to the
-   * lifecycle events the logger wants to forward to its destination.
-   */
-  install: (context: LoggerContext, options?: TOptions) => void | Promise<void>
-}
-
-export type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Logger<TOptions>
-
-/**
- * Defines a typed logger. The `install` method subscribes to lifecycle events
- * on the shared emitter and forwards them to the logger's destination.
- *
- * @example
- * ```ts
- * import { defineLogger } from '@kubb/cli'
- *
- * export const myLogger = defineLogger({
- *   name: 'my-logger',
- *   install(context) {
- *     context.on('kubb:info', ({ message }) => console.log('ℹ', message))
- *     context.on('kubb:error', ({ error }) => console.error('✗', error.message))
- *   },
- * })
- * ```
- */
-export function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options> {
-  return logger
-}