@kubb/cli 4.11.3 → 4.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/cli",
-  "version": "4.11.3",
+  "version": "4.12.1",
   "description": "Command-line interface for Kubb, enabling easy generation of TypeScript, React-Query, Zod, and other code from OpenAPI specifications.",
   "keywords": [
     "cli",
@@ -50,26 +50,26 @@
     }
   ],
   "dependencies": {
+    "@clack/prompts": "1.0.0-alpha.8",
     "chokidar": "^4.0.3",
     "citty": "^0.1.6",
-    "cli-progress": "^3.12.0",
-    "consola": "^3.4.2",
     "cosmiconfig": "^9.0.0",
     "execa": "^9.6.1",
     "gradient-string": "^3.0.0",
     "jiti": "^2.6.1",
     "latest-version": "^9.0.0",
     "picocolors": "^1.1.1",
+    "seedrandom": "^3.0.5",
     "semver": "^7.7.3",
     "string-argv": "^0.3.2",
-    "@kubb/core": "4.11.3"
+    "@kubb/core": "4.12.1"
   },
   "devDependencies": {
-    "@types/cli-progress": "^3.11.6",
+    "@types/seedrandom": "^3.0.8",
     "@types/semver": "^7.7.1",
     "source-map-support": "^0.5.21",
-    "@kubb/mcp": "4.11.3",
-    "@kubb/oas": "4.11.3"
+    "@kubb/mcp": "4.12.1",
+    "@kubb/oas": "4.12.1"
   },
   "engines": {
     "node": ">=20"

package/src/commands/generate.ts

@@ -1,19 +1,20 @@
 import path from 'node:path'
 import * as process from 'node:process'
-import { isInputPath, PromiseManager } from '@kubb/core'
-import { createLogger, LogMapper } from '@kubb/core/logger'
+import * as clack from '@clack/prompts'
+import { isInputPath, type KubbEvents, LogLevel, PromiseManager } from '@kubb/core'
+import { AsyncEventEmitter } from '@kubb/core/utils'
 import type { ArgsDef, ParsedArgs } from 'citty'
 import { defineCommand, showUsage } from 'citty'
-import type { SingleBar } from 'cli-progress'
+import getLatestVersion from 'latest-version'
 import pc from 'picocolors'
+import { lt } from 'semver'
+import { version } from '../../package.json'
+import { setupLogger } from '../loggers/utils.ts'
+import { generate } from '../runners/generate.ts'
 import { getConfig } from '../utils/getConfig.ts'
 import { getCosmiConfig } from '../utils/getCosmiConfig.ts'
 import { startWatcher } from '../utils/watcher.ts'
 
-declare global {
-  var isDevtoolsEnabled: any
-}
-
 const args = {
   config: {
     type: 'string',
@@ -62,11 +63,10 @@ const command = defineCommand({
   },
   args,
   async run(commandContext) {
-    const progressCache = new Map<string, SingleBar>()
-
     const { args } = commandContext
-
     const input = args._[0]
+    const events = new AsyncEventEmitter<KubbEvents>()
+    const promiseManager = new PromiseManager()
 
     if (args.help) {
       return showUsage(command)
@@ -80,75 +80,62 @@ const command = defineCommand({
       args.logLevel = 'verbose'
     }
 
-    const logLevel = LogMapper[args.logLevel as keyof typeof LogMapper] || 3
-    const logger = createLogger({
-      logLevel,
-    })
-    const { generate } = await import('../runners/generate.ts')
+    const logLevel = LogLevel[args.logLevel as keyof typeof LogLevel] || 3
 
-    logger.emit('start', 'Loading config')
+    await setupLogger(events, { logLevel })
 
-    const result = await getCosmiConfig('kubb', args.config)
-    logger.emit('success', `Config loaded(${pc.dim(path.relative(process.cwd(), result.filepath))})`)
+    const latestVersion = await getLatestVersion('@kubb/cli')
 
-    const config = await getConfig(result, args)
+    if (lt(version, latestVersion)) {
+      await events.emit('version:new', version, latestVersion)
+    }
 
-    const start = async () => {
-      if (Array.isArray(config)) {
-        const promiseManager = new PromiseManager()
-        const promises = config.map((c) => () => {
-          progressCache.clear()
+    try {
+      await events.emit('lifecycle:start', version)
 
-          return generate({
-            input,
-            config: c,
-            args,
-            progressCache,
-          })
-        })
+      await events.emit('config:start')
 
-        await promiseManager.run('seq', promises)
-        return
-      }
+      const result = await getCosmiConfig('kubb', args.config)
 
-      progressCache.clear()
+      await events.emit('info', 'Config loaded', path.relative(process.cwd(), result.filepath))
 
-      await generate({
-        input,
-        config,
-        progressCache,
-        args,
-      })
+      const config = await getConfig(result, args)
+      const configs = Array.isArray(config) ? config : [config]
 
-      return
-    }
+      await events.emit('success', 'Config loaded successfully', path.relative(process.cwd(), result.filepath))
+      await events.emit('config:end', configs)
 
-    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 start()
-          logger.emit('start', pc.yellow(pc.bold(`Watching for changes in ${paths.join(' and ')}`)))
-        })
-      }
-    }
+      const promises = configs.map((config) => {
+        return async () => {
+          if (isInputPath(config) && args.watch) {
+            await startWatcher([input || config.input.path], async (paths) => {
+              await generate({
+                input,
+                config,
+                logLevel,
+                events,
+              })
+
+              clack.log.step(pc.yellow(`Watching for changes in ${paths.join(' and ')}`))
+            })
 
-    await start()
+            return
+          }
 
-    if (globalThis.isDevtoolsEnabled) {
-      const canRestart = await logger.consola?.prompt('Restart(could be used to validate the profiler)?', {
-        type: 'confirm',
-        initial: false,
+          await generate({
+            input,
+            config,
+            logLevel,
+            events,
+          })
+        }
       })
 
-      if (canRestart) {
-        await start()
-      } else {
-        process.exit(1)
-      }
+      await promiseManager.run('seq', promises)
+
+      await events.emit('lifecycle:end')
+    } catch (e) {
+      await events.emit('error', e as Error)
     }
   },
 })

package/src/commands/mcp.ts

@@ -1,6 +1,5 @@
 import type { ArgsDef, ParsedArgs } from 'citty'
 import { defineCommand, showUsage } from 'citty'
-import consola from 'consola'
 import { createJiti } from 'jiti'
 import pc from 'picocolors'
 
@@ -36,16 +35,16 @@ const command = defineCommand({
     try {
       mod = await jiti.import('@kubb/mcp', { default: true })
     } catch (_e) {
-      consola.error(`Import of '@kubb/mcp' is required to start the MCP server`)
+      console.error(`Import of '@kubb/mcp' is required to start the MCP server`)
     }
 
     const { startServer } = mod
     try {
-      consola.start('Starting MCP server...')
-      consola.warn(pc.yellow('This feature is still under development — use with caution'))
+      console.log('⏳ Starting MCP server...')
+      console.warn(pc.yellow('This feature is still under development — use with caution'))
       await startServer()
     } catch (e) {
-      consola.error((e as Error)?.message)
+      console.error((e as Error)?.message)
     }
   },
 })

package/src/commands/validate.ts

@@ -1,7 +1,6 @@
 import process from 'node:process'
 import type { ArgsDef, ParsedArgs } from 'citty'
 import { defineCommand, showUsage } from 'citty'
-import consola from 'consola'
 import { createJiti } from 'jiti'
 
 const jiti = createJiti(import.meta.url, {
@@ -42,7 +41,7 @@ const command = defineCommand({
       try {
         mod = await jiti.import('@kubb/oas', { default: true })
       } catch (_e) {
-        consola.error(`Import of '@kubb/oas' is required to do validation`)
+        console.error(`Import of '@kubb/oas' is required to do validation`)
       }
 
       const { parse } = mod
@@ -50,10 +49,10 @@ const command = defineCommand({
         const oas = await parse(args.input)
         await oas.valdiate()
 
-        consola.success('Validation success')
+        console.log('✅ Validation success')
       } catch (e) {
-        consola.fail('Validation failed')
-        consola.log((e as Error)?.message)
+        console.error('❌ Validation failed')
+        console.log((e as Error)?.message)
         process.exit(1)
       }
     }

package/src/index.ts

@@ -1,15 +1,10 @@
 import { defineCommand, runCommand, runMain } from 'citty'
-import consola from 'consola'
-import { default as gradientString } from 'gradient-string'
-import getLatestVersion from 'latest-version'
-import { lt } from 'semver'
-import { version } from '../package.json'
 
-const name = 'kubb'
+import { version } from '../package.json'
 
 const main = defineCommand({
   meta: {
-    name,
+    name: 'kubb',
     version,
     description: 'Kubb generation',
   },
@@ -25,24 +20,14 @@ const main = defineCommand({
       console.log(version)
       process.exit(0)
     }
-    try {
-      consola.log(gradientString(['#F58517', '#F5A217', '#F55A17'])('Kubb CLI:'))
 
-      const latestVersion = await getLatestVersion('@kubb/cli')
+    if (args.debug) {
+      args.logLevel = 'debug'
+    }
 
-      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 (args.verbose) {
+      args.logLevel = 'verbose'
+    }
 
     if (!['generate', 'validate', 'mcp'].includes(rawArgs[0] as string)) {
       // generate is not being used