@kubb/cli 2.18.3 → 2.18.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/cli",
-  "version": "2.18.3",
+  "version": "2.18.5",
   "description": "Generator cli",
   "keywords": [
     "typescript",
@@ -41,26 +41,30 @@
   ],
   "dependencies": {
     "bundle-require": "^4.1.0",
-    "cac": "^6.7.14",
     "chokidar": "^3.6.0",
+    "citty": "^0.1.6",
+    "consola": "^3.2.3",
     "cosmiconfig": "^9.0.0",
     "esbuild": "^0.20.2",
     "execa": "^8.0.1",
     "js-runtime": "^0.0.8",
+    "latest-version": "^9.0.0",
     "ora": "^8.0.1",
-    "pretty-error": "^4.0.0",
+    "semver": "^7.6.2",
     "string-argv": "^0.3.2",
     "tinyrainbow": "^1.1.1",
-    "@kubb/core": "2.18.3"
+    "@kubb/core": "2.18.5",
+    "@kubb/fs": "2.18.5"
   },
   "devDependencies": {
     "@types/node": "^20.12.11",
+    "@types/semver": "^7.5.8",
     "source-map-support": "^0.5.21",
     "tsup": "^8.0.2",
     "typescript": "^5.4.5",
-    "@kubb/config-ts": "2.18.3",
-    "@kubb/config-tsup": "2.18.3",
-    "@kubb/plugin-oas": "2.18.3"
+    "@kubb/config-ts": "2.18.5",
+    "@kubb/config-tsup": "2.18.5",
+    "@kubb/plugin-oas": "2.18.5"
   },
   "engines": {
     "node": ">=18",

package/src/commands/generate.ts

@@ -0,0 +1,115 @@
+import { LogLevel } from '@kubb/core/logger'
+import { defineCommand, showUsage } from 'citty'
+import type { ArgsDef, ParsedArgs } from 'citty'
+import { execa } from 'execa'
+import c from 'tinyrainbow'
+
+import path from 'node:path'
+import { getConfig } from '../utils/getConfig.ts'
+import { getCosmiConfig } from '../utils/getCosmiConfig.ts'
+import { spinner } from '../utils/spinner.ts'
+import { startWatcher } from '../utils/watcher.ts'
+
+import { PromiseManager, isInputPath } from '@kubb/core'
+import { generate } from '../generate.ts'
+
+const args = {
+  config: {
+    type: 'string',
+    description: 'Path to the Kubb config',
+    alias: 'c',
+  },
+  logLevel: {
+    type: 'string',
+    description: 'Info, silent or debug',
+    alias: 'l',
+    default: LogLevel.info,
+    valueHint: `${LogLevel.silent}|${LogLevel.info}|${LogLevel.debug}`,
+  },
+  watch: {
+    type: 'boolean',
+    description: 'Watch mode based on the input file',
+    alias: 'w',
+    default: false,
+  },
+  bun: {
+    type: 'boolean',
+    description: 'Run Kubb with Bun',
+    alias: 'b',
+    default: false,
+  },
+  debug: {
+    type: 'boolean',
+    description: 'Override logLevel to debug',
+    alias: 'd',
+    default: false,
+  },
+  help: {
+    type: 'boolean',
+    description: 'Show help',
+    alias: 'h',
+    default: false,
+  },
+} as const satisfies ArgsDef
+
+export type Args = ParsedArgs<typeof args>
+
+const command = defineCommand({
+  meta: {
+    name: 'generate',
+    description: "[input] Generate files based on a 'kubb.config.ts' file",
+  },
+  args,
+  setup() {
+    spinner.start('🔍 Loading config')
+  },
+  async run({ args }) {
+    const input = args._[0]
+
+    if (args.help) {
+      showUsage(command)
+      return
+    }
+
+    if (args.debug) {
+      args.logLevel = LogLevel.debug
+    }
+
+    if (args.bun) {
+      const command = process.argv.splice(2).filter((item) => item !== '--bun')
+
+      await execa('bkubb', command, { stdout: process.stdout, stderr: process.stderr })
+      return
+    }
+
+    const result = await getCosmiConfig('kubb', args.config)
+    spinner.succeed(`🔍 Config loaded(${c.dim(path.relative(process.cwd(), result.filepath))})`)
+
+    const config = await getConfig(result, args)
+
+    if (args.watch) {
+      if (Array.isArray(config)) {
+        throw new Error('Cannot use watcher with multiple Configs(array)')
+      }
+
+      if (isInputPath(config)) {
+        return startWatcher([input || config.input.path], async (paths) => {
+          await generate({ config, args })
+          spinner.spinner = 'simpleDotsScrolling'
+          spinner.start(c.yellow(c.bold(`Watching for changes in ${paths.join(' and ')}`)))
+        })
+      }
+    }
+
+    if (Array.isArray(config)) {
+      const promiseManager = new PromiseManager()
+      const promises = config.map((item) => () => generate({ input, config: item, args }))
+
+      return promiseManager.run('seq', promises)
+    }
+
+    await generate({ input, config, args })
+  },
+})
+
+export default command

package/src/generate.ts

@@ -1,91 +1,49 @@
-import { LogLevel, createLogger, randomCliColour } from '@kubb/core/logger'
+import { LogLevel, LogMapper, createLogger, randomCliColour } from '@kubb/core/logger'
 
-import { execa } from 'execa'
-import { get } from 'js-runtime'
-import { parseArgsStringToArgv } from 'string-argv'
 import c from 'tinyrainbow'
 
-import { OraWritable } from './utils/OraWritable.ts'
 import { spinner } from './utils/spinner.ts'
 
-import type { Writable } from 'node:stream'
-import { type CLIOptions, type Config, safeBuild } from '@kubb/core'
+import { type Config, Warning, safeBuild } from '@kubb/core'
+import { createConsola } from 'consola'
+import type { Args } from './commands/generate.ts'
+import { executeHooks } from './utils/executeHooks.ts'
+import { getErrorCauses } from './utils/getErrorCauses.ts'
 import { getSummary } from './utils/getSummary.ts'
+import { writeLog } from './utils/writeLog.ts'
 
 type GenerateProps = {
   input?: string
   config: Config
-  CLIOptions: CLIOptions
+  args: Args
 }
 
-type ExecutingHooksProps = {
-  hooks: Config['hooks']
-  logLevel: LogLevel
-}
-
-async function executeHooks({ hooks, logLevel }: ExecutingHooksProps): Promise<void> {
-  if (!hooks?.done) {
-    return
-  }
-
-  const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done]
-
-  if (logLevel === LogLevel.silent) {
-    spinner.start('Executing hooks')
-  }
-
-  const executers = commands
-    .map(async (command) => {
-      const oraWritable = new OraWritable(spinner, command)
-      const abortController = new AbortController()
-      const [cmd, ..._args] = [...parseArgsStringToArgv(command)]
-
-      if (!cmd) {
-        return null
-      }
-
-      spinner.start(`Executing hook ${logLevel !== 'silent' ? c.dim(command) : ''}`)
-
-      const subProcess = await execa(cmd, _args, {
-        detached: true,
-        signal: abortController.signal,
-      }).pipeStdout?.(oraWritable as Writable)
-      spinner.suffixText = ''
-
-      if (logLevel === LogLevel.silent) {
-        spinner.succeed(`Executing hook ${logLevel !== 'silent' ? c.dim(command) : ''}`)
-
-        if (subProcess) {
-          console.log(subProcess.stdout)
-        }
-      }
-
-      oraWritable.destroy()
-      return { subProcess, abort: abortController.abort.bind(abortController) }
-    })
-    .filter(Boolean)
-
-  await Promise.all(executers)
-
-  if (logLevel === LogLevel.silent) {
-    spinner.succeed('Executing hooks')
-  }
-}
-
-export async function generate({ input, config, CLIOptions }: GenerateProps): Promise<void> {
+export async function generate({ input, config, args }: GenerateProps): Promise<void> {
+  const logLevel = (args.logLevel as LogLevel) || LogLevel.silent
   const logger = createLogger({
-    logLevel: CLIOptions.logLevel || LogLevel.silent,
+    logLevel,
     name: config.name,
     spinner,
+    consola: createConsola({
+      level: LogMapper[logLevel] || 3,
+    }),
   })
 
+  logger.on('debug', async (messages: string[]) => {
+    if (logLevel === LogLevel.debug) {
+      await writeLog(messages.join('\n'))
+    }
+  })
+
+  logger.consola?.wrapConsole()
+
   if (logger.name) {
     spinner.prefixText = randomCliColour(logger.name)
   }
 
   const hrstart = process.hrtime()
 
-  if (CLIOptions.logLevel === LogLevel.debug) {
+  if (args.logLevel === LogLevel.debug) {
     const { performance, PerformanceObserver } = await import('node:perf_hooks')
 
     const performanceOpserver = new PerformanceObserver((items) => {
@@ -100,10 +58,9 @@ export async function generate({ input, config, CLIOptions }: GenerateProps): Pr
   }
 
   const { root: _root, ...userConfig } = config
-  const logLevel = logger.logLevel
   const inputPath = input ?? ('path' in userConfig.input ? userConfig.input.path : undefined)
 
-  spinner.start(`🚀 Building with ${get()} ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
+  spinner.start(`🚀 Building ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
 
   const definedConfig: Config = {
     root: process.cwd(),
@@ -138,13 +95,27 @@ export async function generate({ input, config, CLIOptions }: GenerateProps): Pr
 
     console.log(summary.join(''))
 
-    throw error
+    if (error instanceof Warning) {
+      spinner.warn(c.yellow(error.message))
+      process.exit(0)
+    }
+
+    const errors = getErrorCauses([error])
+    if (logger.consola && errors.length && logLevel === LogLevel.debug) {
+      errors.forEach((err) => {
+        logger.consola!.error(err)
+      })
+    }
+
+    logger.consola?.error(error)
+
+    process.exit(0)
   }
 
   await executeHooks({ hooks: config.hooks, logLevel })
 
   spinner.suffixText = ''
-  spinner.succeed(`🚀 Build completed with ${get()} ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
+  spinner.succeed(`🚀 Build completed ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
 
   console.log(summary.join(''))
 }

package/src/index.ts

@@ -1,110 +1,50 @@
-import path from 'node:path'
-
-import { PromiseManager, Warning, isInputPath } from '@kubb/core'
-
-import { cac } from 'cac'
-import c from 'tinyrainbow'
+import { defineCommand, runCommand, runMain } from 'citty'
+import getLatestVersion from 'latest-version'
+import { lt } from 'semver'
 
+import consola from 'consola'
 import { version } from '../package.json'
-import { generate } from './generate.ts'
-import { init } from './init.ts'
-import { getConfig } from './utils/getConfig.ts'
-import { getCosmiConfig } from './utils/getCosmiConfig.ts'
-import { renderErrors } from './utils/renderErrors.ts'
-import { spinner } from './utils/spinner.ts'
-import { startWatcher } from './utils/watcher.ts'
-
-import type { CLIOptions } from '@kubb/core'
-import { execa } from 'execa'
-
-const moduleName = 'kubb'
-
-function programCatcher(e: unknown, CLIOptions: CLIOptions): void {
-  const error = e as Error
-  const message = renderErrors(error, { logLevel: CLIOptions.logLevel })
-
-  if (error instanceof Warning) {
-    spinner.warn(c.yellow(error.message))
-    process.exit(0)
-  }
-  spinner.fail(message)
-  process.exit(1)
-}
-
-async function generateAction(input: string, CLIOptions: CLIOptions) {
-  if (CLIOptions.bun) {
-    const command = process.argv.splice(2).filter((item) => item !== '--bun')
-
-    await execa('bkubb', command, { stdout: process.stdout, stderr: process.stderr })
-    return
-  }
-
-  spinner.start('🔍 Loading config')
-  const result = await getCosmiConfig(moduleName, CLIOptions.config)
-  spinner.succeed(`🔍 Config loaded(${c.dim(path.relative(process.cwd(), result.filepath))})`)
-
-  const config = await getConfig(result, CLIOptions)
-
-  if (CLIOptions.watch) {
-    if (Array.isArray(config)) {
-      throw new Error('Cannot use watcher with multiple Configs(array)')
-    }
 
-    if (isInputPath(config)) {
-      return startWatcher([input || config.input.path], async (paths) => {
-        await generate({ config, CLIOptions })
-        spinner.spinner = 'simpleDotsScrolling'
-        spinner.start(c.yellow(c.bold(`Watching for changes in ${paths.join(' and ')}`)))
-      })
+const name = 'kubb'
+
+const main = defineCommand({
+  meta: {
+    name,
+    version,
+    description: 'Kubb generation',
+  },
+  async setup({ rawArgs }) {
+    try {
+      const latestVersion = await getLatestVersion('@kubb/cli')
+
+      if (lt(version, latestVersion)) {
+        consola.box({
+          title: 'Update available for `Kubb` ',
+          message: `\`v${version}\` → \`v${latestVersion}\`
+Run \`npm install -g @kubb/cli\` to update`,
+          style: {
+            padding: 2,
+            borderColor: 'yellow',
+            borderStyle: 'rounded',
+          },
+        })
+      }
+    } catch (_e) {}
+
+    if (rawArgs[0] !== 'generate') {
+      // generate is not being used
+      const generateCommand = await import('./commands/generate.ts').then((r) => r.default)
+
+      await runCommand(generateCommand, { rawArgs })
+
+      process.exit(0)
     }
-  }
-
-  if (Array.isArray(config)) {
-    const promiseManager = new PromiseManager()
-    const promises = config.map((item) => () => generate({ input, config: item, CLIOptions }))
-
-    await promiseManager.run('seq', promises)
-
-    return
-  }
-
-  await generate({ input, config, CLIOptions })
+  },
+  subCommands: {
+    generate: () => import('./commands/generate.ts').then((r) => r.default),
+  },
+})
+
+export async function run(_argv?: string[]): Promise<void> {
+  await runMain(main)
 }
-
-export async function run(argv?: string[]): Promise<void> {
-  const program = cac(moduleName)
-
-  program
-    .command('[input]', 'Path of the input file(overrides the one in `kubb.config.js`)')
-    .option('-c, --config <path>', 'Path to the Kubb config')
-    .option('-l, --log-level <type>', 'Info, silent or debug')
-    .option('-w, --watch', 'Watch mode based on the input file')
-    .option('-b, --bun', 'Run Kubb with Bun')
-    .action(generateAction)
-
-  program
-    .command('generate [input]', 'Path of the input file(overrides the one in `kubb.config.js`)')
-    .option('-c, --config <path>', 'Path to the Kubb config')
-    .option('-l, --log-level <type>', 'Info, silent or debug')
-    .option('-w, --watch', 'Watch mode based on the input file')
-    .option('-b, --bun', 'Run Kubb with Bun')
-    .action(generateAction)
-
-  program.command('init', 'Init Kubb').action(async () => {
-    return init({ logLevel: 'info' })
-  })
-
-  program.help()
-  program.version(version)
-  program.parse(argv, { run: false })
-
-  try {
-    await program.runMatchedCommand()
-
-    process.exit(0)
-  } catch (e) {
-    programCatcher(e, program.options)
-  }
-}
-
-export default run

package/src/utils/executeHooks.ts

@@ -0,0 +1,64 @@
+import { LogLevel } from '@kubb/core/logger'
+import { execa } from 'execa'
+import { parseArgsStringToArgv } from 'string-argv'
+import c from 'tinyrainbow'
+
+import { OraWritable } from './OraWritable.ts'
+import { spinner } from './spinner.ts'
+
+import type { Writable } from 'node:stream'
+import type { Config } from '@kubb/core'
+
+type ExecutingHooksProps = {
+  hooks: Config['hooks']
+  logLevel: LogLevel
+}
+
+export async function executeHooks({ hooks, logLevel }: ExecutingHooksProps): Promise<void> {
+  if (!hooks?.done) {
+    return
+  }
+
+  const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done]
+
+  if (logLevel === LogLevel.silent) {
+    spinner.start('Executing hooks')
+  }
+
+  const executers = commands
+    .map(async (command) => {
+      const oraWritable = new OraWritable(spinner, command)
+      const abortController = new AbortController()
+      const [cmd, ..._args] = [...parseArgsStringToArgv(command)]
+
+      if (!cmd) {
+        return null
+      }
+
+      spinner.start(`Executing hook ${logLevel !== 'silent' ? c.dim(command) : ''}`)
+
+      const subProcess = await execa(cmd, _args, {
+        detached: true,
+        signal: abortController.signal,
+      }).pipeStdout?.(oraWritable as Writable)
+      spinner.suffixText = ''
+
+      if (logLevel === LogLevel.silent) {
+        spinner.succeed(`Executing hook ${logLevel !== 'silent' ? c.dim(command) : ''}`)
+
+        if (subProcess) {
+          console.log(subProcess.stdout)
+        }
+      }
+
+      oraWritable.destroy()
+      return { subProcess, abort: abortController.abort.bind(abortController) }
+    })
+    .filter(Boolean)
+
+  await Promise.all(executers)
+
+  if (logLevel === LogLevel.silent) {
+    spinner.succeed('Executing hooks')
+  }
+}

package/src/utils/getConfig.ts

@@ -2,19 +2,20 @@ import { isPromise } from '@kubb/core/utils'
 
 import { getPlugins } from './getPlugins.ts'
 
-import type { CLIOptions, Config, UserConfig, defineConfig } from '@kubb/core'
+import type { Config, UserConfig } from '@kubb/core'
+import type { Args } from '../commands/generate.ts'
 import type { CosmiconfigResult } from './getCosmiConfig.ts'
 
 /**
  * Converting UserConfig to Config without a change in the object beside the JSON convert.
  */
-export async function getConfig(result: CosmiconfigResult, CLIOptions: CLIOptions): Promise<Array<Config> | Config> {
+export async function getConfig(result: CosmiconfigResult, args: Args): Promise<Array<Config> | Config> {
   const config = result?.config
   let kubbUserConfig = Promise.resolve(config) as Promise<UserConfig | Array<UserConfig>>
 
   // for ts or js files
   if (typeof config === 'function') {
-    const possiblePromise = config(CLIOptions)
+    const possiblePromise = config(args)
     if (isPromise(possiblePromise)) {
       kubbUserConfig = possiblePromise
     }

package/src/utils/getErrorCauses.ts

@@ -0,0 +1,14 @@
+export function getErrorCauses(errors: Error[]): Error[] {
+  return errors
+    .reduce((prev, error) => {
+      const causedError = error?.cause as Error
+      if (causedError) {
+        prev = [...prev, ...getErrorCauses([causedError])]
+        return prev
+      }
+      prev = [...prev, error]
+
+      return prev
+    }, [] as Error[])
+    .filter(Boolean)
+}

package/src/utils/getSummary.ts

@@ -72,7 +72,6 @@ export function getSummary({ pluginManager, status, hrstart, config, logger }: S
       [`     ${c.bold('Time:')}      ${meta.time}`, true],
       [`    ${c.bold('Ended:')}      ${meta.endTime}`, true],
       [`   ${c.bold('Output:')}      ${meta.output}`, true],
-      ['\n', true],
     ]
       .map((item) => {
         if (item.at(1)) {

package/src/utils/writeLog.ts

@@ -0,0 +1,18 @@
+import { resolve } from 'node:path'
+import { read, write } from '@kubb/fs'
+
+export async function writeLog(data: string): Promise<string | undefined> {
+  if (data.trim() === '') {
+    return undefined
+  }
+  const path = resolve(process.cwd(), 'kubb-log.log')
+  let previousLogs = ''
+
+  try {
+    previousLogs = await read(resolve(path))
+  } catch (_err) {
+    /* empty */
+  }
+
+  return write(path, [previousLogs, data.trim()].filter(Boolean).join('\n\n\n'), { sanity: false })
+}