@kubb/cli 5.0.0-beta.6 → 5.0.0-beta.7

package/src/runners/generate.ts

@@ -1,333 +0,0 @@
-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 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'
-
-type GenerateProps = {
-  input?: string
-  config: Config
-  hooks: AsyncEventEmitter<KubbHooks>
-  logLevel: number
-}
-
-type ToolMap = typeof formatters | typeof linters
-
-type RunToolPassOptions = {
-  toolValue: string
-  detect: () => Promise<string | null>
-  toolMap: ToolMap
-  /** Short noun used in "Auto-detected <toolLabel>:" message, e.g. "formatter" or "linter". */
-  toolLabel: string
-  /** Verb prefix for the success message, e.g. "Formatting" or "Linting". */
-  successPrefix: string
-  noToolMessage: string
-  configName: string | undefined
-  outputPath: string
-  logLevel: number
-  hooks: AsyncEventEmitter<KubbHooks>
-  onStart: () => Promise<void>
-  onEnd: () => Promise<void>
-}
-
-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]
-
-    try {
-      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('kubb:hook:start') before the listener is registered.
-      const hookEndPromise = 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(`${toolConfig.errorMessage}`))
-            return
-          }
-          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)
-        }
-        hooks.on('kubb:hook:end', handler)
-      })
-
-      await hooks.emit('kubb:hook:start', {
-        id: hookId,
-        command: toolConfig.command,
-        args: toolConfig.args(outputPath),
-      })
-
-      await hookEndPromise
-    } catch (caughtError) {
-      // 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(options: GenerateProps): Promise<void> {
-  const { input, hooks, logLevel } = 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' })
-
-  // Handle build failures (either from failed plugins or general errors)
-
-  const hasFailures = failedPlugins.size > 0 || error
-  if (hasFailures) {
-    // Collect all errors from failed plugins and general error
-    const allErrors: Error[] = [
-      error,
-      ...Array.from(failedPlugins)
-        .filter((it) => it.error)
-        .map((it) => it.error),
-    ].filter(Boolean)
-
-    for (const err of allErrors) {
-      await hooks.emit('kubb:error', { error: err })
-    }
-
-    await hooks.emit('kubb:generation:end', { config, files, sources: kubb.sources })
-
-    await hooks.emit('kubb:generation:summary', {
-      config,
-      failedPlugins,
-      filesCreated: files.length,
-      status: 'failed',
-      hrStart,
-      pluginTimings: logLevel >= logLevelMap.verbose ? pluginTimings : undefined,
-    })
-
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'generate',
-        kubbVersion: version,
-        plugins: Array.from(driver.plugins.values(), (p) => ({
-          name: p.name,
-          options: p.options as Record<string, unknown>,
-        })),
-        hrStart,
-        filesCreated: files.length,
-        status: 'failed',
-      }),
-    )
-
-    process.exit(1)
-  }
-
-  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)
-
-  if (config.output.format) {
-    await runToolPass({
-      toolValue: config.output.format,
-      detect: detectFormatter,
-      toolMap: formatters,
-      toolLabel: 'formatter',
-      successPrefix: 'Formatting',
-      noToolMessage: 'No formatter found (oxfmt, biome, or prettier). Skipping formatting.',
-      configName: config.name,
-      outputPath,
-      logLevel,
-      hooks,
-      onStart: () => hooks.emit('kubb:format:start'),
-      onEnd: () => hooks.emit('kubb:format:end'),
-    })
-  }
-
-  if (config.output.lint) {
-    await runToolPass({
-      toolValue: config.output.lint,
-      detect: detectLinter,
-      toolMap: linters,
-      toolLabel: 'linter',
-      successPrefix: 'Linting',
-      noToolMessage: 'No linter found (oxlint, biome, or eslint). Skipping linting.',
-      configName: config.name,
-      outputPath,
-      logLevel,
-      hooks,
-      onStart: () => hooks.emit('kubb:lint:start'),
-      onEnd: () => hooks.emit('kubb:lint:end'),
-    })
-  }
-
-  if (config.hooks) {
-    await hooks.emit('kubb:hooks:start')
-    await executeHooks({ configHooks: config.hooks, hooks })
-
-    await hooks.emit('kubb:hooks:end')
-  }
-
-  // Only reached when there are no failures (process.exit(1) is called above otherwise)
-  await hooks.emit('kubb:generation:summary', {
-    config,
-    failedPlugins,
-    filesCreated: files.length,
-    status: 'success',
-    hrStart,
-    pluginTimings,
-  })
-
-  const telemetryEvent = buildTelemetryEvent({
-    command: 'generate',
-    kubbVersion: version,
-    plugins: Array.from(driver.plugins.values(), (p) => ({
-      name: p.name,
-      options: p.options as Record<string, unknown>,
-    })),
-    hrStart,
-    filesCreated: files.length,
-    status: 'success',
-  })
-
-  await sendTelemetry(telemetryEvent)
-}
-
-type GenerateCommandOptions = {
-  input?: string
-  configPath?: string
-  logLevel: string
-  watch: boolean
-}
-
-export async function runGenerateCommand({ input, configPath, logLevel: logLevelKey, watch }: GenerateCommandOptions): Promise<void> {
-  const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
-  const hooks = new AsyncEventEmitterClass<KubbHooks>()
-
-  await setupLogger(hooks, { logLevel })
-
-  await executeIfOnline(async () => {
-    try {
-      const res = await fetch(KUBB_NPM_PACKAGE_URL)
-      const data = (await res.json()) as { version: string }
-      const latestVersion = data.version
-
-      if (latestVersion && version < latestVersion) {
-        await hooks.emit('kubb:version:new', { currentVersion: version, latestVersion })
-      }
-    } catch {
-      // Ignore network errors for version check
-    }
-  })
-
-  try {
-    const result = await getCosmiConfig('kubb', configPath)
-    const configs = await getConfigs(result.config, { input } as CLIOptions)
-
-    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 hooks.emit('kubb:lifecycle:start', { version })
-
-    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()
-
-          await generate({ input, config, logLevel, hooks })
-
-          clack.log.step(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))
-        })
-      } else {
-        await generate({ input, config, logLevel, hooks })
-      }
-    }
-
-    await hooks.emit('kubb:lifecycle:end')
-  } catch (error) {
-    await hooks.emit('kubb:error', { error: toError(error) })
-    process.exit(1)
-  }
-}

package/src/runners/mcp.ts

@@ -1,56 +0,0 @@
-import process from 'node:process'
-import { styleText } from 'node:util'
-import { getErrorMessage } from '@internals/utils'
-import type * as McpModule from '@kubb/mcp'
-import { buildTelemetryEvent, sendTelemetry } from '../utils/telemetry.ts'
-
-type McpOptions = {
-  version: string
-  port?: string
-  host?: string
-}
-
-export async function runMcp({ version, port, host }: McpOptions): Promise<void> {
-  let mod: typeof McpModule
-  try {
-    mod = (await import('@kubb/mcp')) as typeof McpModule
-  } catch (_e) {
-    console.error(styleText('red', 'The @kubb/mcp package is not installed.'))
-    console.error('')
-    console.error('Install it with:')
-    console.error(styleText('cyan', '  npm install @kubb/mcp'))
-    console.error(styleText('cyan', '  # or'))
-    console.error(styleText('cyan', '  pnpm install @kubb/mcp'))
-    console.error('')
-    process.exit(1)
-  }
-
-  const { run } = mod
-  const hrStart = process.hrtime()
-  try {
-    console.log('⏳ Starting MCP server...')
-    console.warn(styleText('yellow', 'This feature is still under development — use with caution'))
-    run(undefined, {
-      port: port !== undefined ? Number(port) : undefined,
-      host,
-    })
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'mcp',
-        kubbVersion: version,
-        hrStart,
-        status: 'success',
-      }),
-    )
-  } catch (error) {
-    await sendTelemetry(
-      buildTelemetryEvent({
-        command: 'mcp',
-        kubbVersion: version,
-        hrStart,
-        status: 'failed',
-      }),
-    )
-    console.error(getErrorMessage(error))
-  }
-}

package/src/types.ts

@@ -1,11 +0,0 @@
-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/Writables.ts

@@ -1,17 +0,0 @@
-import type { WritableOptions } from 'node:stream'
-import { Writable } from 'node:stream'
-import { styleText } from 'node:util'
-import type * as clack from '@clack/prompts'
-
-export 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()
-  }
-}

package/src/utils/executeHooks.ts

@@ -1,45 +0,0 @@
-import { createHash } from 'node:crypto'
-import { styleText } from 'node:util'
-import type { AsyncEventEmitter } from '@internals/utils'
-import { tokenize } from '@internals/utils'
-import type { Config, KubbHookEndContext, KubbHooks } from '@kubb/core'
-
-type ExecutingHooksProps = {
-  configHooks: NonNullable<Config['hooks']>
-  hooks: AsyncEventEmitter<KubbHooks>
-}
-
-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)
-
-    if (!cmd) {
-      continue
-    }
-
-    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('kubb:hook:start') before the listener is registered.
-    const hookEndPromise = new Promise<void>((resolve, reject) => {
-      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
-        }
-        hooks
-          .emit('kubb:success', { message: `${styleText('dim', command)} successfully executed` })
-          .then(resolve)
-          .catch(reject)
-      }
-      hooks.on('kubb:hook:end', handler)
-    })
-
-    await hooks.emit('kubb:hook:start', { id: hookId, command: cmd, args })
-    await hookEndPromise
-  }
-}

package/src/utils/flags.ts

@@ -1,9 +0,0 @@
-/**
- * Type guard that confirms `value` is a member of `set`. Avoids type assertions 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

@@ -1,10 +0,0 @@
-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)
-}

package/src/utils/getCosmiConfig.ts

@@ -1,75 +0,0 @@
-import type { Config } from '@kubb/core'
-import { cosmiconfig } from 'cosmiconfig'
-import { createJiti } from 'jiti'
-
-type CosmiconfigResult = {
-  filepath: string
-  isEmpty?: boolean
-  config: Config
-}
-
-const jiti = createJiti(import.meta.url, {
-  jsx: {
-    runtime: 'automatic',
-    importSource: '@kubb/renderer-jsx',
-  },
-  moduleCache: false,
-})
-
-const tsLoader = async (configFile: string) => {
-  return jiti.import(configFile, { default: true })
-}
-
-export async function getCosmiConfig(moduleName: string, config?: string): Promise<CosmiconfigResult> {
-  let result: CosmiconfigResult
-  const searchPlaces = [
-    'package.json',
-    `.${moduleName}rc`,
-    `.${moduleName}rc.json`,
-    `.${moduleName}rc.yaml`,
-    `.${moduleName}rc.yml`,
-
-    `.${moduleName}rc.ts`,
-    `.${moduleName}rc.mts`,
-    `.${moduleName}rc.cts`,
-    `.${moduleName}rc.js`,
-    `.${moduleName}rc.mjs`,
-    `.${moduleName}rc.cjs`,
-
-    `${moduleName}.config.ts`,
-    `${moduleName}.config.mts`,
-    `${moduleName}.config.cts`,
-    `${moduleName}.config.js`,
-    `${moduleName}.config.mjs`,
-    `${moduleName}.config.cjs`,
-  ]
-  const explorer = cosmiconfig(moduleName, {
-    cache: false,
-    searchPlaces: [
-      ...searchPlaces.map((searchPlace) => {
-        return `.config/${searchPlace}`
-      }),
-      ...searchPlaces.map((searchPlace) => {
-        return `configs/${searchPlace}`
-      }),
-      ...searchPlaces,
-    ],
-    loaders: {
-      '.ts': tsLoader,
-      '.mts': tsLoader,
-      '.cts': tsLoader,
-    },
-  })
-
-  try {
-    result = config ? ((await explorer.load(config)) as CosmiconfigResult) : ((await explorer.search()) as CosmiconfigResult)
-  } catch (error) {
-    throw new Error('Config failed loading', { cause: error })
-  }
-
-  if (result?.isEmpty || !result || !result.config) {
-    throw new Error('Config not defined, create a kubb.config.js or pass through your config with the option --config')
-  }
-
-  return result as CosmiconfigResult
-}

package/src/utils/getSummary.ts

@@ -1,68 +0,0 @@
-import path from 'node:path'
-import { styleText } from 'node:util'
-import { formatHrtime, randomCliColor } from '@internals/utils'
-import type { Config, Plugin } from '@kubb/core'
-import { SUMMARY_MAX_BAR_LENGTH, SUMMARY_TIME_SCALE_DIVISOR } from '../constants.ts'
-
-type SummaryProps = {
-  failedPlugins: Set<{ plugin: Plugin; error: Error }>
-  status: 'success' | 'failed'
-  hrStart: [number, number]
-  filesCreated: number
-  config: Config
-  pluginTimings?: Map<string, number>
-}
-
-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
-}