@kubb/cli 4.12.14 → 4.13.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as version } from "./package-BTZmtBhm.js";
+import { t as version } from "./package-BCi1eAUE.js";
 import { defineCommand, runCommand, runMain } from "citty";
 
 //#region src/index.ts
@@ -23,12 +23,12 @@ const main = defineCommand({
 			"validate",
 			"mcp"
 		].includes(rawArgs[0])) {
-			await runCommand(await import("./generate-BlUnSQtu.js").then((r) => r.default), { rawArgs });
+			await runCommand(await import("./generate-CZAftsLc.js").then((r) => r.default), { rawArgs });
 			process.exit(0);
 		}
 	},
 	subCommands: {
-		generate: () => import("./generate-BlUnSQtu.js").then((r) => r.default),
+		generate: () => import("./generate-CZAftsLc.js").then((r) => r.default),
 		validate: () => import("./validate-Bt922JN-.js").then((r) => r.default),
 		mcp: () => import("./mcp-B5FWDVjp.js").then((r) => r.default)
 	}

package/dist/package-BCi1eAUE.js

@@ -0,0 +1,6 @@
+//#region package.json
+var version = "4.13.0";
+
+//#endregion
+export { version as t };
+//# sourceMappingURL=package-BCi1eAUE.js.map

package/dist/package-BCi1eAUE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-BCi1eAUE.js","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}

package/dist/{package-uCB9uBUP.cjs → package-rLoLT3Y2.cjs}

@@ -1,6 +1,6 @@
 
 //#region package.json
-var version = "4.12.14";
+var version = "4.13.0";
 
 //#endregion
 Object.defineProperty(exports, 'version', {
@@ -9,4 +9,4 @@ Object.defineProperty(exports, 'version', {
     return version;
   }
 });
-//# sourceMappingURL=package-uCB9uBUP.cjs.map
+//# sourceMappingURL=package-rLoLT3Y2.cjs.map

package/dist/package-rLoLT3Y2.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-rLoLT3Y2.cjs","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/cli",
-  "version": "4.12.14",
+  "version": "4.13.0",
   "description": "Command-line interface for Kubb, enabling easy generation of TypeScript, React-Query, Zod, and other code from OpenAPI specifications.",
   "keywords": [
     "cli",
@@ -62,14 +62,14 @@
     "seedrandom": "^3.0.5",
     "semver": "^7.7.3",
     "string-argv": "^0.3.2",
-    "@kubb/core": "4.12.14"
+    "@kubb/core": "4.13.0"
   },
   "devDependencies": {
     "@types/seedrandom": "^3.0.8",
     "@types/semver": "^7.7.1",
     "source-map-support": "^0.5.21",
-    "@kubb/mcp": "4.12.14",
-    "@kubb/oas": "4.12.14"
+    "@kubb/mcp": "4.13.0",
+    "@kubb/oas": "4.13.0"
   },
   "engines": {
     "node": ">=20"

package/src/commands/generate.ts

@@ -146,6 +146,7 @@ const command = defineCommand({
       await events.emit('lifecycle:end')
     } catch (error) {
       await events.emit('error', error as Error)
+      process.exit(1)
     }
   },
 })

package/src/runners/generate.ts

@@ -4,6 +4,8 @@ import process from 'node:process'
 import { type Config, type KubbEvents, LogLevel, safeBuild, setup } from '@kubb/core'
 import type { AsyncEventEmitter } from '@kubb/core/utils'
 import pc from 'picocolors'
+import { detectFormatter } from '../utils/detectFormatter.ts'
+import { detectLinter } from '../utils/detectLinter.ts'
 import { executeHooks } from '../utils/executeHooks.ts'
 
 type GenerateProps = {
@@ -94,69 +96,84 @@ export async function generate({ input, config: userConfig, events, logLevel }:
   if (config.output.format) {
     await events.emit('format:start')
 
-    await events.emit(
-      'info',
-      [
-        `Formatting with ${pc.dim(config.output.format as string)}`,
-        logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
-      ]
-        .filter(Boolean)
-        .join(' '),
-    )
-
-    if (config.output.format === 'prettier') {
-      try {
-        const hookId = createHash('sha256').update([config.name, config.output.format].filter(Boolean).join('-')).digest('hex')
-        await events.emit('hook:start', {
-          id: hookId,
-          command: 'prettier',
-          args: ['--ignore-unknown', '--write', path.resolve(config.root, config.output.path)],
-        })
-
-        await events.onOnce('hook:end', async () => {
-          await events.emit(
-            'success',
-            [
-              `Formatting with ${pc.dim(config.output.format as string)}`,
-              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
-              'successfully',
-            ]
-              .filter(Boolean)
-              .join(' '),
-          )
-        })
-      } catch (caughtError) {
-        await events.emit('error', caughtError as Error)
+    // Detect formatter if set to 'auto'
+    let formatter = config.output.format
+    if (formatter === 'auto') {
+      const detectedFormatter = await detectFormatter()
+      if (!detectedFormatter) {
+        await events.emit('warn', 'No formatter found (biome or prettier). Skipping formatting.')
+      } else {
+        formatter = detectedFormatter
+        await events.emit('info', `Auto-detected formatter: ${pc.dim(formatter)}`)
       }
-
-      await events.emit('success', `Formatted with ${config.output.format}`)
     }
 
-    if (config.output.format === 'biome') {
-      try {
-        const hookId = createHash('sha256').update([config.name, config.output.format].filter(Boolean).join('-')).digest('hex')
-        await events.emit('hook:start', {
-          id: hookId,
-          command: 'biome',
-          args: ['format', '--write', path.resolve(config.root, config.output.path)],
-        })
-
-        await events.onOnce('hook:end', async () => {
-          await events.emit(
-            'success',
-            [
-              `Formatting with ${pc.dim(config.output.format as string)}`,
-              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
-              'successfully',
-            ]
-              .filter(Boolean)
-              .join(' '),
-          )
-        })
-      } catch (caughtError) {
-        const error = new Error('Biome not found')
-        error.cause = caughtError
-        await events.emit('error', error)
+    // Only proceed with formatting if we have a valid formatter
+    if (formatter && formatter !== 'auto') {
+      await events.emit(
+        'info',
+        [
+          `Formatting with ${pc.dim(formatter as string)}`,
+          logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+        ]
+          .filter(Boolean)
+          .join(' '),
+      )
+
+      if (formatter === 'prettier') {
+        try {
+          const hookId = createHash('sha256').update([config.name, formatter].filter(Boolean).join('-')).digest('hex')
+          await events.emit('hook:start', {
+            id: hookId,
+            command: 'prettier',
+            args: ['--ignore-unknown', '--write', path.resolve(config.root, config.output.path)],
+          })
+
+          await events.onOnce('hook:end', async () => {
+            await events.emit(
+              'success',
+              [
+                `Formatting with ${pc.dim(formatter as string)}`,
+                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+                'successfully',
+              ]
+                .filter(Boolean)
+                .join(' '),
+            )
+          })
+        } catch (caughtError) {
+          await events.emit('error', caughtError as Error)
+        }
+
+        await events.emit('success', `Formatted with ${formatter}`)
+      }
+
+      if (formatter === 'biome') {
+        try {
+          const hookId = createHash('sha256').update([config.name, formatter].filter(Boolean).join('-')).digest('hex')
+          await events.emit('hook:start', {
+            id: hookId,
+            command: 'biome',
+            args: ['format', '--write', path.resolve(config.root, config.output.path)],
+          })
+
+          await events.onOnce('hook:end', async () => {
+            await events.emit(
+              'success',
+              [
+                `Formatting with ${pc.dim(formatter as string)}`,
+                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+                'successfully',
+              ]
+                .filter(Boolean)
+                .join(' '),
+            )
+          })
+        } catch (caughtError) {
+          const error = new Error('Biome not found')
+          error.cause = caughtError
+          await events.emit('error', error)
+        }
       }
     }
 
@@ -167,97 +184,109 @@ export async function generate({ input, config: userConfig, events, logLevel }:
   if (config.output.lint) {
     await events.emit('lint:start')
 
-    await events.emit(
-      'info',
-      [
-        `Linting with ${pc.dim(config.output.lint as string)}`,
-        logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
-      ]
-        .filter(Boolean)
-        .join(' '),
-    )
-
-    if (config.output.lint === 'eslint') {
-      try {
-        const hookId = createHash('sha256').update([config.name, config.output.lint].filter(Boolean).join('-')).digest('hex')
-        await events.emit('hook:start', {
-          id: hookId,
-          command: 'eslint',
-          args: [path.resolve(config.root, config.output.path), '--fix'],
-        })
-
-        await events.onOnce('hook:end', async () => {
-          await events.emit(
-            'success',
-            [
-              `Linted with ${pc.dim(config.output.lint as string)}`,
-              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
-              'successfully',
-            ]
-              .filter(Boolean)
-              .join(' '),
-          )
-        })
-      } catch (caughtError) {
-        const error = new Error('Eslint not found')
-        error.cause = caughtError
-        await events.emit('error', error)
+    // Detect linter if set to 'auto'
+    let linter = config.output.lint
+    if (linter === 'auto') {
+      const detectedLinter = await detectLinter()
+      if (!detectedLinter) {
+        await events.emit('warn', 'No linter found (biome, oxlint, or eslint). Skipping linting.')
+      } else {
+        linter = detectedLinter
+        await events.emit('info', `Auto-detected linter: ${pc.dim(linter)}`)
       }
     }
 
-    if (config.output.lint === 'biome') {
-      try {
-        const hookId = createHash('sha256').update([config.name, config.output.lint].filter(Boolean).join('-')).digest('hex')
-        await events.emit('hook:start', {
-          id: hookId,
-          command: 'biome',
-          args: ['lint', '--fix', path.resolve(config.root, config.output.path)],
-        })
-
-        await events.onOnce('hook:end', async () => {
-          await events.emit(
-            'success',
-            [
-              `Linted with ${pc.dim(config.output.lint as string)}`,
-              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
-              'successfully',
-            ]
-              .filter(Boolean)
-              .join(' '),
-          )
-        })
-      } catch (caughtError) {
-        const error = new Error('Biome not found')
-        error.cause = caughtError
-        await events.emit('error', error)
+    // Only proceed with linting if we have a valid linter
+    if (linter && linter !== 'auto') {
+      await events.emit(
+        'info',
+        [`Linting with ${pc.dim(linter as string)}`, logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined]
+          .filter(Boolean)
+          .join(' '),
+      )
+
+      if (linter === 'eslint') {
+        try {
+          const hookId = createHash('sha256').update([config.name, linter].filter(Boolean).join('-')).digest('hex')
+          await events.emit('hook:start', {
+            id: hookId,
+            command: 'eslint',
+            args: [path.resolve(config.root, config.output.path), '--fix'],
+          })
+
+          await events.onOnce('hook:end', async () => {
+            await events.emit(
+              'success',
+              [
+                `Linted with ${pc.dim(linter as string)}`,
+                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+                'successfully',
+              ]
+                .filter(Boolean)
+                .join(' '),
+            )
+          })
+        } catch (caughtError) {
+          const error = new Error('Eslint not found')
+          error.cause = caughtError
+          await events.emit('error', error)
+        }
+      }
+
+      if (linter === 'biome') {
+        try {
+          const hookId = createHash('sha256').update([config.name, linter].filter(Boolean).join('-')).digest('hex')
+          await events.emit('hook:start', {
+            id: hookId,
+            command: 'biome',
+            args: ['lint', '--fix', path.resolve(config.root, config.output.path)],
+          })
+
+          await events.onOnce('hook:end', async () => {
+            await events.emit(
+              'success',
+              [
+                `Linted with ${pc.dim(linter as string)}`,
+                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+                'successfully',
+              ]
+                .filter(Boolean)
+                .join(' '),
+            )
+          })
+        } catch (caughtError) {
+          const error = new Error('Biome not found')
+          error.cause = caughtError
+          await events.emit('error', error)
+        }
       }
-    }
 
-    if (config.output.lint === 'oxlint') {
-      try {
-        const hookId = createHash('sha256').update([config.name, config.output.lint].filter(Boolean).join('-')).digest('hex')
-        await events.emit('hook:start', {
-          id: hookId,
-          command: 'oxlint',
-          args: ['--fix', path.resolve(config.root, config.output.path)],
-        })
-
-        await events.onOnce('hook:end', async () => {
-          await events.emit(
-            'success',
-            [
-              `Linted with ${pc.dim(config.output.lint as string)}`,
-              logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
-              'successfully',
-            ]
-              .filter(Boolean)
-              .join(' '),
-          )
-        })
-      } catch (caughtError) {
-        const error = new Error('Oxlint not found')
-        error.cause = caughtError
-        await events.emit('error', error)
+      if (linter === 'oxlint') {
+        try {
+          const hookId = createHash('sha256').update([config.name, linter].filter(Boolean).join('-')).digest('hex')
+          await events.emit('hook:start', {
+            id: hookId,
+            command: 'oxlint',
+            args: ['--fix', path.resolve(config.root, config.output.path)],
+          })
+
+          await events.onOnce('hook:end', async () => {
+            await events.emit(
+              'success',
+              [
+                `Linted with ${pc.dim(linter as string)}`,
+                logLevel >= LogLevel.info ? `on ${pc.dim(path.resolve(config.root, config.output.path))}` : undefined,
+                'successfully',
+              ]
+                .filter(Boolean)
+                .join(' '),
+            )
+          })
+        } catch (caughtError) {
+          const error = new Error('Oxlint not found')
+          error.cause = caughtError
+          await events.emit('error', error)
+        }
       }
     }
 

package/src/utils/detectFormatter.ts

@@ -0,0 +1,55 @@
+import { execaCommand } from 'execa'
+
+type Formatter = 'biome' | 'prettier'
+
+/**
+ * Check if a formatter command is available in the system.
+ *
+ * @param formatter - The formatter to check ('biome' or 'prettier')
+ * @returns Promise that resolves to true if the formatter is available, false otherwise
+ *
+ * @remarks
+ * This function checks availability by running `<formatter> --version` command.
+ * All supported formatters (biome, prettier) implement the --version flag.
+ */
+async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
+  try {
+    // Try to get the version of the formatter to check if it's installed
+    await execaCommand(`${formatter} --version`, { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Detect which formatter is available in the system.
+ *
+ * @returns Promise that resolves to the first available formatter or undefined if none are found
+ *
+ * @remarks
+ * Checks in order of preference: biome, prettier.
+ * Uses the `--version` flag to detect if each formatter command is available.
+ * This is a reliable method as all supported formatters implement this flag.
+ *
+ * @example
+ * ```typescript
+ * const formatter = await detectFormatter()
+ * if (formatter) {
+ *   console.log(`Using ${formatter} for formatting`)
+ * } else {
+ *   console.log('No formatter found')
+ * }
+ * ```
+ */
+export async function detectFormatter(): Promise<Formatter | undefined> {
+  const formatters: Formatter[] = ['biome', 'prettier']
+
+  for (const formatter of formatters) {
+    if (await isFormatterAvailable(formatter)) {
+      return formatter
+    }
+  }
+
+  return undefined
+}

package/src/utils/detectLinter.ts

@@ -0,0 +1,55 @@
+import { execaCommand } from 'execa'
+
+type Linter = 'biome' | 'oxlint' | 'eslint'
+
+/**
+ * Check if a linter command is available in the system.
+ *
+ * @param linter - The linter to check ('biome', 'oxlint', or 'eslint')
+ * @returns Promise that resolves to true if the linter is available, false otherwise
+ *
+ * @remarks
+ * This function checks availability by running `<linter> --version` command.
+ * All supported linters (biome, oxlint, eslint) implement the --version flag.
+ */
+async function isLinterAvailable(linter: Linter): Promise<boolean> {
+  try {
+    // Try to get the version of the linter to check if it's installed
+    await execaCommand(`${linter} --version`, { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Detect which linter is available in the system.
+ *
+ * @returns Promise that resolves to the first available linter or undefined if none are found
+ *
+ * @remarks
+ * Checks in order of preference: biome, oxlint, eslint.
+ * Uses the `--version` flag to detect if each linter command is available.
+ * This is a reliable method as all supported linters implement this flag.
+ *
+ * @example
+ * ```typescript
+ * const linter = await detectLinter()
+ * if (linter) {
+ *   console.log(`Using ${linter} for linting`)
+ * } else {
+ *   console.log('No linter found')
+ * }
+ * ```
+ */
+export async function detectLinter(): Promise<Linter | undefined> {
+  const linters: Linter[] = ['biome', 'oxlint', 'eslint']
+
+  for (const linter of linters) {
+    if (await isLinterAvailable(linter)) {
+      return linter
+    }
+  }
+
+  return undefined
+}