@kubb/cli 5.0.0-beta.54 → 5.0.0-beta.56

package/dist/tools-BU99bhi8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-BU99bhi8.js","names":[],"sources":["../../../internals/utils/src/tools.ts"],"sourcesContent":["import { spawn } from 'node:child_process'\nimport { existsSync, readFileSync } from 'node:fs'\nimport { join } from 'node:path'\n\n/**\n * CLI command descriptors for each supported code formatter.\n *\n * Each entry contains the executable `command`, an `args` factory that maps an\n * output path to the correct argument list, and an `errorMessage` shown when\n * the formatter is not found.\n */\nexport const formatters = {\n  prettier: {\n    command: 'prettier',\n    args: (outputPath: string) => ['--ignore-unknown', '--write', outputPath],\n    errorMessage: 'Prettier not found',\n  },\n  biome: {\n    command: 'biome',\n    args: (outputPath: string) => ['format', '--write', outputPath],\n    errorMessage: 'Biome not found',\n  },\n  oxfmt: {\n    command: 'oxfmt',\n    args: (outputPath: string) => [outputPath],\n    errorMessage: 'Oxfmt not found',\n  },\n} as const\n\n/**\n * CLI command descriptors for each supported linter.\n *\n * Each entry contains the executable `command`, an `args` factory that maps an\n * output path to the correct argument list, and an `errorMessage` shown when\n * the linter is not found.\n */\nexport const linters = {\n  eslint: {\n    command: 'eslint',\n    args: (outputPath: string) => [outputPath, '--fix'],\n    errorMessage: 'Eslint not found',\n  },\n  biome: {\n    command: 'biome',\n    args: (outputPath: string) => ['lint', '--fix', outputPath],\n    errorMessage: 'Biome not found',\n  },\n  oxlint: {\n    command: 'oxlint',\n    // --no-ignore so oxlint lints the folder even when it's gitignored (generated output dirs usually are).\n    args: (outputPath: string) => ['--fix', '--no-ignore', outputPath],\n    errorMessage: 'Oxlint not found',\n  },\n} as const\n\n/**\n * Resolves to `true` when running `tool --version` exits with code 0.\n */\nasync function isToolAvailable(tool: string): Promise<boolean> {\n  return new Promise((resolve) => {\n    const child = spawn(tool, ['--version'], { stdio: 'ignore' })\n    child.on('close', (code) => resolve(code === 0))\n    child.on('error', () => resolve(false))\n  })\n}\n\n/**\n * Returns the first installed tool from `candidates`, checked in order, or `null` when none are found.\n *\n * Availability is probed by running `<tool> --version` and checking for a zero exit code.\n *\n * @example\n * ```ts\n * const formatter = await detectTool(['oxfmt', 'biome', 'prettier'] as const)\n * const linter = await detectTool(['oxlint', 'biome', 'eslint'] as const)\n * ```\n */\nexport async function detectTool<TName extends string>(candidates: ReadonlyArray<TName>): Promise<TName | null> {\n  for (const tool of candidates) {\n    if (await isToolAvailable(tool)) {\n      return tool\n    }\n  }\n\n  return null\n}\n\n/**\n * Supported package manager identifiers.\n *\n * @example\n * ```ts\n * const pm: PackageManagerName = 'pnpm'\n * ```\n */\nexport type PackageManagerName = 'npm' | 'pnpm' | 'yarn' | 'bun'\n\n/**\n * Metadata describing a package manager's lock file and install command.\n */\nexport interface PackageManagerInfo {\n  /**\n   * Identifier used in CLI commands, e.g. `pnpm`, `yarn`.\n   */\n  name: PackageManagerName\n  /**\n   * Lock file name that uniquely identifies this package manager in a project root.\n   */\n  lockFile: string\n  /**\n   * Subcommands passed to the package manager binary to install a dev dependency.\n   */\n  installCommand: ReadonlyArray<string>\n}\n\n/**\n * Metadata for each supported package manager, keyed by its short name.\n *\n * @example\n * ```ts\n * packageManagers.pnpm.installCommand // ['add', '-D']\n * packageManagers.npm.lockFile        // 'package-lock.json'\n * ```\n */\nconst packageManagers: Record<PackageManagerName, PackageManagerInfo> = {\n  pnpm: {\n    name: 'pnpm',\n    lockFile: 'pnpm-lock.yaml',\n    installCommand: ['add', '-D'],\n  },\n  yarn: {\n    name: 'yarn',\n    lockFile: 'yarn.lock',\n    installCommand: ['add', '-D'],\n  },\n  bun: {\n    name: 'bun',\n    lockFile: 'bun.lockb',\n    installCommand: ['add', '-d'],\n  },\n  npm: {\n    name: 'npm',\n    lockFile: 'package-lock.json',\n    installCommand: ['install', '--save-dev'],\n  },\n}\n\n/**\n * Minimal shape of `package.json` fields read during detection.\n */\ntype PackageJson = {\n  /**\n   * The `packageManager` field from `package.json` (e.g. `\"pnpm@9.0.0\"`).\n   */\n  packageManager?: string\n}\n\n/**\n * Detects the active package manager for the given directory.\n * Resolution order: `packageManager` field in `package.json`, then presence of a lock file.\n * Falls back to `npm` when no signal is found.\n *\n * @example\n * ```ts\n * detectPackageManager('/my/project') // { name: 'pnpm', lockFile: 'pnpm-lock.yaml', ... }\n * detectPackageManager()              // falls back to npm when no lock file is found\n * ```\n */\nexport function detectPackageManager(cwd: string = process.cwd()): PackageManagerInfo {\n  const packageJsonPath = join(cwd, 'package.json')\n  if (existsSync(packageJsonPath)) {\n    try {\n      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as PackageJson\n      const pmField = packageJson.packageManager\n      if (typeof pmField === 'string') {\n        const name = pmField.split('@')[0]\n        if (name && name in packageManagers) {\n          return packageManagers[name as PackageManagerName]\n        }\n      }\n    } catch {\n      // Continue to lock file detection\n    }\n  }\n\n  for (const pm of Object.values(packageManagers)) {\n    if (existsSync(join(cwd, pm.lockFile))) {\n      return pm\n    }\n  }\n\n  return packageManagers.npm\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,aAAa;CACxB,UAAU;EACR,SAAS;EACT,OAAO,eAAuB;GAAC;GAAoB;GAAW;EAAU;EACxE,cAAc;CAChB;CACA,OAAO;EACL,SAAS;EACT,OAAO,eAAuB;GAAC;GAAU;GAAW;EAAU;EAC9D,cAAc;CAChB;CACA,OAAO;EACL,SAAS;EACT,OAAO,eAAuB,CAAC,UAAU;EACzC,cAAc;CAChB;AACF;;;;;;;;AASA,MAAa,UAAU;CACrB,QAAQ;EACN,SAAS;EACT,OAAO,eAAuB,CAAC,YAAY,OAAO;EAClD,cAAc;CAChB;CACA,OAAO;EACL,SAAS;EACT,OAAO,eAAuB;GAAC;GAAQ;GAAS;EAAU;EAC1D,cAAc;CAChB;CACA,QAAQ;EACN,SAAS;EAET,OAAO,eAAuB;GAAC;GAAS;GAAe;EAAU;EACjE,cAAc;CAChB;AACF;;;;AAKA,eAAe,gBAAgB,MAAgC;CAC7D,OAAO,IAAI,SAAS,YAAY;EAC9B,MAAM,QAAQ,MAAM,MAAM,CAAC,WAAW,GAAG,EAAE,OAAO,SAAS,CAAC;EAC5D,MAAM,GAAG,UAAU,SAAS,QAAQ,SAAS,CAAC,CAAC;EAC/C,MAAM,GAAG,eAAe,QAAQ,KAAK,CAAC;CACxC,CAAC;AACH;;;;;;;;;;;;AAaA,eAAsB,WAAiC,YAAyD;CAC9G,KAAK,MAAM,QAAQ,YACjB,IAAI,MAAM,gBAAgB,IAAI,GAC5B,OAAO;CAIX,OAAO;AACT;;;;;;;;;;AAuCA,MAAM,kBAAkE;CACtE,MAAM;EACJ,MAAM;EACN,UAAU;EACV,gBAAgB,CAAC,OAAO,IAAI;CAC9B;CACA,MAAM;EACJ,MAAM;EACN,UAAU;EACV,gBAAgB,CAAC,OAAO,IAAI;CAC9B;CACA,KAAK;EACH,MAAM;EACN,UAAU;EACV,gBAAgB,CAAC,OAAO,IAAI;CAC9B;CACA,KAAK;EACH,MAAM;EACN,UAAU;EACV,gBAAgB,CAAC,WAAW,YAAY;CAC1C;AACF;;;;;;;;;;;;AAuBA,SAAgB,qBAAqB,MAAc,QAAQ,IAAI,GAAuB;CACpF,MAAM,kBAAkB,KAAK,KAAK,cAAc;CAChD,IAAI,WAAW,eAAe,GAC5B,IAAI;EAEF,MAAM,UADc,KAAK,MAAM,aAAa,iBAAiB,OAAO,CAC1C,CAAC,CAAC;EAC5B,IAAI,OAAO,YAAY,UAAU;GAC/B,MAAM,OAAO,QAAQ,MAAM,GAAG,CAAC,CAAC;GAChC,IAAI,QAAQ,QAAQ,iBAClB,OAAO,gBAAgB;EAE3B;CACF,QAAQ,CAER;CAGF,KAAK,MAAM,MAAM,OAAO,OAAO,eAAe,GAC5C,IAAI,WAAW,KAAK,KAAK,GAAG,QAAQ,CAAC,GACnC,OAAO;CAIX,OAAO,gBAAgB;AACzB"}

package/dist/tools-_Xp8-_zy.cjs

@@ -0,0 +1,175 @@
+require("./chunk-Bx3C2hgW.cjs");
+let node_child_process = require("node:child_process");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+//#region ../../internals/utils/src/tools.ts
+/**
+* CLI command descriptors for each supported code formatter.
+*
+* Each entry contains the executable `command`, an `args` factory that maps an
+* output path to the correct argument list, and an `errorMessage` shown when
+* the formatter is not found.
+*/
+const formatters = {
+	prettier: {
+		command: "prettier",
+		args: (outputPath) => [
+			"--ignore-unknown",
+			"--write",
+			outputPath
+		],
+		errorMessage: "Prettier not found"
+	},
+	biome: {
+		command: "biome",
+		args: (outputPath) => [
+			"format",
+			"--write",
+			outputPath
+		],
+		errorMessage: "Biome not found"
+	},
+	oxfmt: {
+		command: "oxfmt",
+		args: (outputPath) => [outputPath],
+		errorMessage: "Oxfmt not found"
+	}
+};
+/**
+* CLI command descriptors for each supported linter.
+*
+* Each entry contains the executable `command`, an `args` factory that maps an
+* output path to the correct argument list, and an `errorMessage` shown when
+* the linter is not found.
+*/
+const linters = {
+	eslint: {
+		command: "eslint",
+		args: (outputPath) => [outputPath, "--fix"],
+		errorMessage: "Eslint not found"
+	},
+	biome: {
+		command: "biome",
+		args: (outputPath) => [
+			"lint",
+			"--fix",
+			outputPath
+		],
+		errorMessage: "Biome not found"
+	},
+	oxlint: {
+		command: "oxlint",
+		args: (outputPath) => [
+			"--fix",
+			"--no-ignore",
+			outputPath
+		],
+		errorMessage: "Oxlint not found"
+	}
+};
+/**
+* Resolves to `true` when running `tool --version` exits with code 0.
+*/
+async function isToolAvailable(tool) {
+	return new Promise((resolve) => {
+		const child = (0, node_child_process.spawn)(tool, ["--version"], { stdio: "ignore" });
+		child.on("close", (code) => resolve(code === 0));
+		child.on("error", () => resolve(false));
+	});
+}
+/**
+* Returns the first installed tool from `candidates`, checked in order, or `null` when none are found.
+*
+* Availability is probed by running `<tool> --version` and checking for a zero exit code.
+*
+* @example
+* ```ts
+* const formatter = await detectTool(['oxfmt', 'biome', 'prettier'] as const)
+* const linter = await detectTool(['oxlint', 'biome', 'eslint'] as const)
+* ```
+*/
+async function detectTool(candidates) {
+	for (const tool of candidates) if (await isToolAvailable(tool)) return tool;
+	return null;
+}
+/**
+* Metadata for each supported package manager, keyed by its short name.
+*
+* @example
+* ```ts
+* packageManagers.pnpm.installCommand // ['add', '-D']
+* packageManagers.npm.lockFile        // 'package-lock.json'
+* ```
+*/
+const packageManagers = {
+	pnpm: {
+		name: "pnpm",
+		lockFile: "pnpm-lock.yaml",
+		installCommand: ["add", "-D"]
+	},
+	yarn: {
+		name: "yarn",
+		lockFile: "yarn.lock",
+		installCommand: ["add", "-D"]
+	},
+	bun: {
+		name: "bun",
+		lockFile: "bun.lockb",
+		installCommand: ["add", "-d"]
+	},
+	npm: {
+		name: "npm",
+		lockFile: "package-lock.json",
+		installCommand: ["install", "--save-dev"]
+	}
+};
+/**
+* Detects the active package manager for the given directory.
+* Resolution order: `packageManager` field in `package.json`, then presence of a lock file.
+* Falls back to `npm` when no signal is found.
+*
+* @example
+* ```ts
+* detectPackageManager('/my/project') // { name: 'pnpm', lockFile: 'pnpm-lock.yaml', ... }
+* detectPackageManager()              // falls back to npm when no lock file is found
+* ```
+*/
+function detectPackageManager(cwd = process.cwd()) {
+	const packageJsonPath = (0, node_path.join)(cwd, "package.json");
+	if ((0, node_fs.existsSync)(packageJsonPath)) try {
+		const pmField = JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf-8")).packageManager;
+		if (typeof pmField === "string") {
+			const name = pmField.split("@")[0];
+			if (name && name in packageManagers) return packageManagers[name];
+		}
+	} catch {}
+	for (const pm of Object.values(packageManagers)) if ((0, node_fs.existsSync)((0, node_path.join)(cwd, pm.lockFile))) return pm;
+	return packageManagers.npm;
+}
+//#endregion
+Object.defineProperty(exports, "detectPackageManager", {
+	enumerable: true,
+	get: function() {
+		return detectPackageManager;
+	}
+});
+Object.defineProperty(exports, "detectTool", {
+	enumerable: true,
+	get: function() {
+		return detectTool;
+	}
+});
+Object.defineProperty(exports, "formatters", {
+	enumerable: true,
+	get: function() {
+		return formatters;
+	}
+});
+Object.defineProperty(exports, "linters", {
+	enumerable: true,
+	get: function() {
+		return linters;
+	}
+});
+
+//# sourceMappingURL=tools-_Xp8-_zy.cjs.map

package/dist/tools-_Xp8-_zy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-_Xp8-_zy.cjs","names":[],"sources":["../../../internals/utils/src/tools.ts"],"sourcesContent":["import { spawn } from 'node:child_process'\nimport { existsSync, readFileSync } from 'node:fs'\nimport { join } from 'node:path'\n\n/**\n * CLI command descriptors for each supported code formatter.\n *\n * Each entry contains the executable `command`, an `args` factory that maps an\n * output path to the correct argument list, and an `errorMessage` shown when\n * the formatter is not found.\n */\nexport const formatters = {\n  prettier: {\n    command: 'prettier',\n    args: (outputPath: string) => ['--ignore-unknown', '--write', outputPath],\n    errorMessage: 'Prettier not found',\n  },\n  biome: {\n    command: 'biome',\n    args: (outputPath: string) => ['format', '--write', outputPath],\n    errorMessage: 'Biome not found',\n  },\n  oxfmt: {\n    command: 'oxfmt',\n    args: (outputPath: string) => [outputPath],\n    errorMessage: 'Oxfmt not found',\n  },\n} as const\n\n/**\n * CLI command descriptors for each supported linter.\n *\n * Each entry contains the executable `command`, an `args` factory that maps an\n * output path to the correct argument list, and an `errorMessage` shown when\n * the linter is not found.\n */\nexport const linters = {\n  eslint: {\n    command: 'eslint',\n    args: (outputPath: string) => [outputPath, '--fix'],\n    errorMessage: 'Eslint not found',\n  },\n  biome: {\n    command: 'biome',\n    args: (outputPath: string) => ['lint', '--fix', outputPath],\n    errorMessage: 'Biome not found',\n  },\n  oxlint: {\n    command: 'oxlint',\n    // --no-ignore so oxlint lints the folder even when it's gitignored (generated output dirs usually are).\n    args: (outputPath: string) => ['--fix', '--no-ignore', outputPath],\n    errorMessage: 'Oxlint not found',\n  },\n} as const\n\n/**\n * Resolves to `true` when running `tool --version` exits with code 0.\n */\nasync function isToolAvailable(tool: string): Promise<boolean> {\n  return new Promise((resolve) => {\n    const child = spawn(tool, ['--version'], { stdio: 'ignore' })\n    child.on('close', (code) => resolve(code === 0))\n    child.on('error', () => resolve(false))\n  })\n}\n\n/**\n * Returns the first installed tool from `candidates`, checked in order, or `null` when none are found.\n *\n * Availability is probed by running `<tool> --version` and checking for a zero exit code.\n *\n * @example\n * ```ts\n * const formatter = await detectTool(['oxfmt', 'biome', 'prettier'] as const)\n * const linter = await detectTool(['oxlint', 'biome', 'eslint'] as const)\n * ```\n */\nexport async function detectTool<TName extends string>(candidates: ReadonlyArray<TName>): Promise<TName | null> {\n  for (const tool of candidates) {\n    if (await isToolAvailable(tool)) {\n      return tool\n    }\n  }\n\n  return null\n}\n\n/**\n * Supported package manager identifiers.\n *\n * @example\n * ```ts\n * const pm: PackageManagerName = 'pnpm'\n * ```\n */\nexport type PackageManagerName = 'npm' | 'pnpm' | 'yarn' | 'bun'\n\n/**\n * Metadata describing a package manager's lock file and install command.\n */\nexport interface PackageManagerInfo {\n  /**\n   * Identifier used in CLI commands, e.g. `pnpm`, `yarn`.\n   */\n  name: PackageManagerName\n  /**\n   * Lock file name that uniquely identifies this package manager in a project root.\n   */\n  lockFile: string\n  /**\n   * Subcommands passed to the package manager binary to install a dev dependency.\n   */\n  installCommand: ReadonlyArray<string>\n}\n\n/**\n * Metadata for each supported package manager, keyed by its short name.\n *\n * @example\n * ```ts\n * packageManagers.pnpm.installCommand // ['add', '-D']\n * packageManagers.npm.lockFile        // 'package-lock.json'\n * ```\n */\nconst packageManagers: Record<PackageManagerName, PackageManagerInfo> = {\n  pnpm: {\n    name: 'pnpm',\n    lockFile: 'pnpm-lock.yaml',\n    installCommand: ['add', '-D'],\n  },\n  yarn: {\n    name: 'yarn',\n    lockFile: 'yarn.lock',\n    installCommand: ['add', '-D'],\n  },\n  bun: {\n    name: 'bun',\n    lockFile: 'bun.lockb',\n    installCommand: ['add', '-d'],\n  },\n  npm: {\n    name: 'npm',\n    lockFile: 'package-lock.json',\n    installCommand: ['install', '--save-dev'],\n  },\n}\n\n/**\n * Minimal shape of `package.json` fields read during detection.\n */\ntype PackageJson = {\n  /**\n   * The `packageManager` field from `package.json` (e.g. `\"pnpm@9.0.0\"`).\n   */\n  packageManager?: string\n}\n\n/**\n * Detects the active package manager for the given directory.\n * Resolution order: `packageManager` field in `package.json`, then presence of a lock file.\n * Falls back to `npm` when no signal is found.\n *\n * @example\n * ```ts\n * detectPackageManager('/my/project') // { name: 'pnpm', lockFile: 'pnpm-lock.yaml', ... }\n * detectPackageManager()              // falls back to npm when no lock file is found\n * ```\n */\nexport function detectPackageManager(cwd: string = process.cwd()): PackageManagerInfo {\n  const packageJsonPath = join(cwd, 'package.json')\n  if (existsSync(packageJsonPath)) {\n    try {\n      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as PackageJson\n      const pmField = packageJson.packageManager\n      if (typeof pmField === 'string') {\n        const name = pmField.split('@')[0]\n        if (name && name in packageManagers) {\n          return packageManagers[name as PackageManagerName]\n        }\n      }\n    } catch {\n      // Continue to lock file detection\n    }\n  }\n\n  for (const pm of Object.values(packageManagers)) {\n    if (existsSync(join(cwd, pm.lockFile))) {\n      return pm\n    }\n  }\n\n  return packageManagers.npm\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,aAAa;CACxB,UAAU;EACR,SAAS;EACT,OAAO,eAAuB;GAAC;GAAoB;GAAW;EAAU;EACxE,cAAc;CAChB;CACA,OAAO;EACL,SAAS;EACT,OAAO,eAAuB;GAAC;GAAU;GAAW;EAAU;EAC9D,cAAc;CAChB;CACA,OAAO;EACL,SAAS;EACT,OAAO,eAAuB,CAAC,UAAU;EACzC,cAAc;CAChB;AACF;;;;;;;;AASA,MAAa,UAAU;CACrB,QAAQ;EACN,SAAS;EACT,OAAO,eAAuB,CAAC,YAAY,OAAO;EAClD,cAAc;CAChB;CACA,OAAO;EACL,SAAS;EACT,OAAO,eAAuB;GAAC;GAAQ;GAAS;EAAU;EAC1D,cAAc;CAChB;CACA,QAAQ;EACN,SAAS;EAET,OAAO,eAAuB;GAAC;GAAS;GAAe;EAAU;EACjE,cAAc;CAChB;AACF;;;;AAKA,eAAe,gBAAgB,MAAgC;CAC7D,OAAO,IAAI,SAAS,YAAY;EAC9B,MAAM,SAAA,GAAA,mBAAA,MAAA,CAAc,MAAM,CAAC,WAAW,GAAG,EAAE,OAAO,SAAS,CAAC;EAC5D,MAAM,GAAG,UAAU,SAAS,QAAQ,SAAS,CAAC,CAAC;EAC/C,MAAM,GAAG,eAAe,QAAQ,KAAK,CAAC;CACxC,CAAC;AACH;;;;;;;;;;;;AAaA,eAAsB,WAAiC,YAAyD;CAC9G,KAAK,MAAM,QAAQ,YACjB,IAAI,MAAM,gBAAgB,IAAI,GAC5B,OAAO;CAIX,OAAO;AACT;;;;;;;;;;AAuCA,MAAM,kBAAkE;CACtE,MAAM;EACJ,MAAM;EACN,UAAU;EACV,gBAAgB,CAAC,OAAO,IAAI;CAC9B;CACA,MAAM;EACJ,MAAM;EACN,UAAU;EACV,gBAAgB,CAAC,OAAO,IAAI;CAC9B;CACA,KAAK;EACH,MAAM;EACN,UAAU;EACV,gBAAgB,CAAC,OAAO,IAAI;CAC9B;CACA,KAAK;EACH,MAAM;EACN,UAAU;EACV,gBAAgB,CAAC,WAAW,YAAY;CAC1C;AACF;;;;;;;;;;;;AAuBA,SAAgB,qBAAqB,MAAc,QAAQ,IAAI,GAAuB;CACpF,MAAM,mBAAA,GAAA,UAAA,KAAA,CAAuB,KAAK,cAAc;CAChD,KAAA,GAAA,QAAA,WAAA,CAAe,eAAe,GAC5B,IAAI;EAEF,MAAM,UADc,KAAK,OAAA,GAAA,QAAA,aAAA,CAAmB,iBAAiB,OAAO,CAC1C,CAAC,CAAC;EAC5B,IAAI,OAAO,YAAY,UAAU;GAC/B,MAAM,OAAO,QAAQ,MAAM,GAAG,CAAC,CAAC;GAChC,IAAI,QAAQ,QAAQ,iBAClB,OAAO,gBAAgB;EAE3B;CACF,QAAQ,CAER;CAGF,KAAK,MAAM,MAAM,OAAO,OAAO,eAAe,GAC5C,KAAA,GAAA,QAAA,WAAA,EAAA,GAAA,UAAA,KAAA,CAAoB,KAAK,GAAG,QAAQ,CAAC,GACnC,OAAO;CAIX,OAAO,gBAAgB;AACzB"}

package/dist/{validate-Bqf5fxQp.cjs → validate-CJZ7XveW.cjs}

@@ -1,6 +1,6 @@
 require("./chunk-Bx3C2hgW.cjs");
 const require_define = require("./define-C4AB3POr.cjs");
-const require_package = require("./package-C8wmoP1B.cjs");
+const require_package = require("./package-CsEMNf0Q.cjs");
 //#region src/commands/validate.ts
 const command = require_define.defineCommand({
 	name: "validate",
@@ -13,7 +13,7 @@ const command = require_define.defineCommand({
 		required: true
 	} },
 	async run({ values }) {
-		const { run } = await Promise.resolve().then(() => require("./run-DMWGLJUx.cjs"));
+		const { run } = await Promise.resolve().then(() => require("./run-Bj64iPU_.cjs"));
 		await run({
 			input: values.input,
 			version: require_package.version
@@ -23,4 +23,4 @@ const command = require_define.defineCommand({
 //#endregion
 exports.command = command;
 
-//# sourceMappingURL=validate-Bqf5fxQp.cjs.map
+//# sourceMappingURL=validate-CJZ7XveW.cjs.map

package/dist/{validate-Bqf5fxQp.cjs.map → validate-CJZ7XveW.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"validate-Bqf5fxQp.cjs","names":["defineCommand"],"sources":["../src/commands/validate.ts"],"sourcesContent":["import { defineCommand } from '@internals/utils'\nimport { version } from '../../package.json'\n\nexport const command = defineCommand({\n  name: 'validate',\n  description:\n    '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.',\n  examples: ['kubb validate --input ./openapi.yaml', 'kubb validate --input https://petstore3.swagger.io/api/v3/openapi.json'],\n  options: {\n    input: {\n      type: 'string',\n      description: 'Path or URL to the OpenAPI/Swagger file to validate',\n      short: 'i',\n      required: true,\n    },\n  },\n  async run({ values }) {\n    const { run } = await import('../runners/validate/run.ts')\n\n    await run({ input: values.input, version })\n  },\n})\n"],"mappings":";;;;AAGA,MAAa,UAAUA,eAAAA,cAAc;CACnC,MAAM;CACN,aACE;CACF,UAAU,CAAC,wCAAwC,wEAAwE;CAC3H,SAAS,EACP,OAAO;EACL,MAAM;EACN,aAAa;EACb,OAAO;EACP,UAAU;CACZ,EACF;CACA,MAAM,IAAI,EAAE,UAAU;EACpB,MAAM,EAAE,QAAQ,MAAA,QAAA,QAAA,CAAA,CAAA,WAAA,QAAM,oBAAA,CAAA;EAEtB,MAAM,IAAI;GAAE,OAAO,OAAO;GAAO,SAAA,gBAAA;EAAQ,CAAC;CAC5C;AACF,CAAC"}
+{"version":3,"file":"validate-CJZ7XveW.cjs","names":["defineCommand"],"sources":["../src/commands/validate.ts"],"sourcesContent":["import { defineCommand } from '@internals/utils'\nimport { version } from '../../package.json'\n\nexport const command = defineCommand({\n  name: 'validate',\n  description:\n    '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.',\n  examples: ['kubb validate --input ./openapi.yaml', 'kubb validate --input https://petstore3.swagger.io/api/v3/openapi.json'],\n  options: {\n    input: {\n      type: 'string',\n      description: 'Path or URL to the OpenAPI/Swagger file to validate',\n      short: 'i',\n      required: true,\n    },\n  },\n  async run({ values }) {\n    const { run } = await import('../runners/validate/run.ts')\n\n    await run({ input: values.input, version })\n  },\n})\n"],"mappings":";;;;AAGA,MAAa,UAAUA,eAAAA,cAAc;CACnC,MAAM;CACN,aACE;CACF,UAAU,CAAC,wCAAwC,wEAAwE;CAC3H,SAAS,EACP,OAAO;EACL,MAAM;EACN,aAAa;EACb,OAAO;EACP,UAAU;CACZ,EACF;CACA,MAAM,IAAI,EAAE,UAAU;EACpB,MAAM,EAAE,QAAQ,MAAA,QAAA,QAAA,CAAA,CAAA,WAAA,QAAM,oBAAA,CAAA;EAEtB,MAAM,IAAI;GAAE,OAAO,OAAO;GAAO,SAAA,gBAAA;EAAQ,CAAC;CAC5C;AACF,CAAC"}

package/dist/{validate-BlNh3LLm.js → validate-DPgK_e7n.js}

@@ -1,6 +1,6 @@
 import "./chunk-C0LytTxp.js";
 import { n as defineCommand } from "./define-C63T4jp6.js";
-import { t as version } from "./package-CNNBB6JV.js";
+import { t as version } from "./package-BSMI4dNK.js";
 //#region src/commands/validate.ts
 const command = defineCommand({
 	name: "validate",
@@ -13,7 +13,7 @@ const command = defineCommand({
 		required: true
 	} },
 	async run({ values }) {
-		const { run } = await import("./run-C7cr0qhi.js");
+		const { run } = await import("./run-CUkZ6gnP.js");
 		await run({
 			input: values.input,
 			version
@@ -23,4 +23,4 @@ const command = defineCommand({
 //#endregion
 export { command };
 
-//# sourceMappingURL=validate-BlNh3LLm.js.map
+//# sourceMappingURL=validate-DPgK_e7n.js.map

package/dist/{validate-BlNh3LLm.js.map → validate-DPgK_e7n.js.map}

@@ -1 +1 @@
-{"version":3,"file":"validate-BlNh3LLm.js","names":[],"sources":["../src/commands/validate.ts"],"sourcesContent":["import { defineCommand } from '@internals/utils'\nimport { version } from '../../package.json'\n\nexport const command = defineCommand({\n  name: 'validate',\n  description:\n    '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.',\n  examples: ['kubb validate --input ./openapi.yaml', 'kubb validate --input https://petstore3.swagger.io/api/v3/openapi.json'],\n  options: {\n    input: {\n      type: 'string',\n      description: 'Path or URL to the OpenAPI/Swagger file to validate',\n      short: 'i',\n      required: true,\n    },\n  },\n  async run({ values }) {\n    const { run } = await import('../runners/validate/run.ts')\n\n    await run({ input: values.input, version })\n  },\n})\n"],"mappings":";;;;AAGA,MAAa,UAAU,cAAc;CACnC,MAAM;CACN,aACE;CACF,UAAU,CAAC,wCAAwC,wEAAwE;CAC3H,SAAS,EACP,OAAO;EACL,MAAM;EACN,aAAa;EACb,OAAO;EACP,UAAU;CACZ,EACF;CACA,MAAM,IAAI,EAAE,UAAU;EACpB,MAAM,EAAE,QAAQ,MAAM,OAAO;EAE7B,MAAM,IAAI;GAAE,OAAO,OAAO;GAAO;EAAQ,CAAC;CAC5C;AACF,CAAC"}
+{"version":3,"file":"validate-DPgK_e7n.js","names":[],"sources":["../src/commands/validate.ts"],"sourcesContent":["import { defineCommand } from '@internals/utils'\nimport { version } from '../../package.json'\n\nexport const command = defineCommand({\n  name: 'validate',\n  description:\n    '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.',\n  examples: ['kubb validate --input ./openapi.yaml', 'kubb validate --input https://petstore3.swagger.io/api/v3/openapi.json'],\n  options: {\n    input: {\n      type: 'string',\n      description: 'Path or URL to the OpenAPI/Swagger file to validate',\n      short: 'i',\n      required: true,\n    },\n  },\n  async run({ values }) {\n    const { run } = await import('../runners/validate/run.ts')\n\n    await run({ input: values.input, version })\n  },\n})\n"],"mappings":";;;;AAGA,MAAa,UAAU,cAAc;CACnC,MAAM;CACN,aACE;CACF,UAAU,CAAC,wCAAwC,wEAAwE;CAC3H,SAAS,EACP,OAAO;EACL,MAAM;EACN,aAAa;EACb,OAAO;EACP,UAAU;CACZ,EACF;CACA,MAAM,IAAI,EAAE,UAAU;EACpB,MAAM,EAAE,QAAQ,MAAM,OAAO;EAE7B,MAAM,IAAI;GAAE,OAAO,OAAO;GAAO;EAAQ,CAAC;CAC5C;AACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/cli",
-  "version": "5.0.0-beta.54",
+  "version": "5.0.0-beta.56",
   "description": "Official CLI for Kubb. Run kubb generate, kubb init, kubb validate, and kubb mcp to manage the full code generation lifecycle from OpenAPI/Swagger specs.",
   "keywords": [
     "cli",
@@ -52,16 +52,16 @@
     "cosmiconfig": "^9.0.2",
     "jiti": "^2.7.0",
     "tinyexec": "~1.1.2",
-    "@kubb/core": "5.0.0-beta.54"
+    "@kubb/core": "5.0.0-beta.56"
   },
   "devDependencies": {
     "@internals/shared": "0.0.0",
     "@internals/utils": "0.0.0",
-    "@kubb/adapter-oas": "5.0.0-beta.54"
+    "@kubb/adapter-oas": "5.0.0-beta.56"
   },
   "peerDependencies": {
-    "@kubb/adapter-oas": "5.0.0-beta.54",
-    "@kubb/mcp": "5.0.0-beta.54"
+    "@kubb/adapter-oas": "5.0.0-beta.56",
+    "@kubb/mcp": "5.0.0-beta.56"
   },
   "peerDependenciesMeta": {
     "@kubb/adapter-oas": {

package/src/Telemetry.ts

@@ -1,7 +1,7 @@
 import { randomBytes } from 'node:crypto'
 import os from 'node:os'
 import process from 'node:process'
-import { executeIfOnline, getRuntimeName, getRuntimeVersion, isCIEnvironment, type RuntimeName } from '@internals/utils'
+import { isCIEnvironment, runtime } from '@internals/utils'
 import { OTLP_ENDPOINT } from './constants.ts'
 
 // OpenTelemetry OTLP JSON types
@@ -117,7 +117,7 @@ export type TelemetryEvent = {
   /**
    * Name of the JavaScript runtime that executed the run, `'bun'`, `'deno'`, or `'node'`.
    */
-  runtime: RuntimeName
+  runtime: string
   /**
    * Major version of the active runtime, e.g. `'1'` under Bun or `'22'` under Node.
    */
@@ -139,7 +139,7 @@ export class Telemetry {
   /**
    * Returns `true` when telemetry is disabled via `DO_NOT_TRACK` or `KUBB_DISABLE_TELEMETRY`.
    */
-  static isDisabled(): boolean {
+  static get isDisabled(): boolean {
     return (
       process.env['DO_NOT_TRACK'] === '1' ||
       process.env['DO_NOT_TRACK'] === 'true' ||
@@ -166,8 +166,8 @@ export class Telemetry {
       command: options.command,
       kubbVersion: options.kubbVersion,
       nodeVersion: process.versions.node.split('.')[0] as string,
-      runtime: getRuntimeName(),
-      runtimeVersion: getRuntimeVersion().split('.')[0] as string,
+      runtime: runtime.name,
+      runtimeVersion: runtime.version.split('.')[0] as string,
       platform: os.platform(),
       ci: isCIEnvironment(),
       plugins: options.plugins ?? [],
@@ -266,25 +266,23 @@ export class Telemetry {
    * `KUBB_DISABLE_TELEMETRY`, and fails silently so telemetry never interrupts a run.
    */
   static async send(event: TelemetryEvent): Promise<void> {
-    if (Telemetry.isDisabled()) {
+    if (Telemetry.isDisabled) {
       return
     }
 
-    await executeIfOnline(async () => {
-      try {
-        await fetch(`${OTLP_ENDPOINT}/v1/traces`, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'Kubb-Telemetry-Version': '1',
-            'Kubb-Telemetry-Source': 'kubb-core',
-          },
-          body: JSON.stringify(Telemetry.buildOtlpPayload(event)),
-          signal: AbortSignal.timeout(5_000),
-        })
-      } catch (_e) {
-        // Fail silently, telemetry must never break the run
-      }
-    })
+    try {
+      await fetch(`${OTLP_ENDPOINT}/v1/traces`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Kubb-Telemetry-Version': '1',
+          'Kubb-Telemetry-Source': 'kubb-core',
+        },
+        body: JSON.stringify(Telemetry.buildOtlpPayload(event)),
+        signal: AbortSignal.timeout(5_000),
+      })
+    } catch (_e) {
+      // Fail silently, telemetry must never break the run
+    }
   }
 }

package/src/commands/generate.ts

@@ -45,11 +45,6 @@ export const command = defineCommand({
       hint: 'cli|json|file',
       enum: ['cli', 'json', 'file'],
     },
-    'no-cache': {
-      type: 'boolean',
-      description: 'Disable the incremental build cache and force a full regeneration',
-      default: false,
-    },
   },
   async run({ values, positionals }) {
     const logLevel = values.verbose ? 'verbose' : values.silent ? 'silent' : values.logLevel
@@ -65,7 +60,6 @@ export const command = defineCommand({
       logLevel,
       watch: values.watch,
       reporters,
-      noCache: values['no-cache'],
     })
   },
 })

package/src/constants.ts

@@ -16,4 +16,4 @@ export const WATCHER_IGNORED_PATHS = '**/{.git,node_modules}/**' as const
 /**
  * Flags that short-circuit execution (help/version), no telemetry notice is shown.
  */
-export const QUIET_FLAGS = new Set(['--help', '-h', '--version', '-v'] as const)
+export const QUIET_FLAGS = new Set<string>(['--help', '-h', '--version', '-v'])

package/src/index.ts

@@ -1,31 +1,14 @@
 import { styleText } from 'node:util'
-import { createCLI, isFlag } from '@internals/utils'
+import { createCLI } from '@internals/utils'
 import { Telemetry } from './Telemetry.ts'
 import { version } from '../package.json'
 import { QUIET_FLAGS } from './constants.ts'
 
 const cli = createCLI()
-
-function shouldShowTelemetryNotice(argv: Array<string>): boolean {
-  if (Telemetry.isDisabled()) {
-    return false
-  }
-
-  // Skip when the user is just asking for help or version info
-  if (argv.some((arg) => isFlag(QUIET_FLAGS, arg))) {
-    return false
-  }
-
-  // Skip in non-interactive / scripting contexts
-  if (!process.stdout.isTTY) {
-    return false
-  }
-
-  return true
-}
-
 export async function run(argv: Array<string> = process.argv): Promise<void> {
-  if (shouldShowTelemetryNotice(argv)) {
+  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`,
     )

package/src/runners/generate/run.ts

@@ -5,7 +5,7 @@ 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 { AsyncEventEmitter as AsyncEventEmitterClass, detectTool, formatters, linters, toError } from '@internals/utils'
 import {
   type CLIOptions,
   cliReporter,
@@ -208,7 +208,7 @@ async function generate(options: GenerateProps): Promise<boolean> {
     config.output.format && {
       code: Diagnostics.code.formatFailed,
       toolValue: config.output.format,
-      detect: detectFormatter,
+      detect: () => detectTool(['oxfmt', 'biome', 'prettier'] as const),
       toolMap: formatters,
       toolLabel: 'formatter',
       successPrefix: 'Formatting',
@@ -219,7 +219,7 @@ async function generate(options: GenerateProps): Promise<boolean> {
     config.output.lint && {
       code: Diagnostics.code.lintFailed,
       toolValue: config.output.lint,
-      detect: detectLinter,
+      detect: () => detectTool(['oxlint', 'biome', 'eslint'] as const),
       toolMap: linters,
       toolLabel: 'linter',
       successPrefix: 'Linting',
@@ -302,21 +302,18 @@ type GenerateCommandOptions = {
   logLevel: string
   watch: boolean
   reporters?: Array<ReporterName>
-  noCache?: boolean
 }
 
 async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void> {
-  await executeIfOnline(async () => {
-    try {
-      const res = await fetch(KUBB_NPM_PACKAGE_URL)
-      const data = (await res.json()) as { version: string }
-      if (data.version && version < data.version) {
-        await Diagnostics.emit(hooks, Diagnostics.update({ currentVersion: version, latestVersion: data.version }))
-      }
-    } catch {
-      // Ignore network errors
+  try {
+    const res = await fetch(KUBB_NPM_PACKAGE_URL)
+    const data = (await res.json()) as { version: string }
+    if (data.version && version < data.version) {
+      await Diagnostics.emit(hooks, Diagnostics.update({ currentVersion: version, latestVersion: data.version }))
     }
-  })
+  } catch {
+    // Ignore network errors
+  }
 }
 
 /**
@@ -324,7 +321,7 @@ async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void
  * Loads configs, sets up the selected reporters (CLI `--reporter` overrides `config.reporters`),
  * checks for a newer version, and calls `generate` for each config entry.
  */
-export async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters, noCache }: GenerateCommandOptions): Promise<void> {
+export async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters }: GenerateCommandOptions): Promise<void> {
   const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
   const hooks = new AsyncEventEmitterClass<KubbHooks>()
 
@@ -338,7 +335,6 @@ export async function run({ input, configPath, logLevel: logLevelKey, watch, rep
       input,
       watch,
       logLevel: logLevelKey as CLIOptions['logLevel'],
-      noCache,
     })
     configs = loaded.configs
     resolvedConfigPath = loaded.configPath

package/src/runners/generate/utils.ts

@@ -1,10 +1,10 @@
 import { hash } from 'node:crypto'
 import { styleText } from 'node:util'
+import { createModuleLoader } from '@internals/shared'
 import type { AsyncEventEmitter } from '@internals/utils'
-import { toError, tokenize } from '@internals/utils'
+import { toError } from '@internals/utils'
 import type { CLIOptions, Config, KubbHooks, PossibleConfig } from '@kubb/core'
 import { cosmiconfig } from 'cosmiconfig'
-import { createJiti } from 'jiti'
 import { NonZeroExitError, x } from 'tinyexec'
 import { WATCHER_IGNORED_PATHS } from '../../constants.ts'
 
@@ -14,12 +14,9 @@ type CosmiconfigResult = {
   config: PossibleConfig<CLIOptions>
 }
 
-const jiti = createJiti(import.meta.url, {
-  jsx: { runtime: 'automatic', importSource: '@kubb/renderer-jsx' },
-  moduleCache: false,
-})
+const loader = createModuleLoader()
 
-const tsLoader = (configFile: string) => jiti.import(configFile, { default: true })
+const tsLoader = (configFile: string) => loader.load(configFile, { default: true })
 
 const MODULE_NAME = 'kubb'
 
@@ -83,10 +80,6 @@ type GetConfigsOptions = {
    * Log level forwarded to the user's `defineConfig` function.
    */
   logLevel?: CLIOptions['logLevel']
-  /**
-   * When set, turns off the incremental build cache for this run, forcing a full regeneration.
-   */
-  noCache?: boolean
 }
 
 type GetConfigsResult = {
@@ -104,20 +97,15 @@ type GetConfigsResult = {
  * Discovers the Kubb config via cosmiconfig and resolves it into a normalized array of configs.
  * Every config in the result is guaranteed to have a `plugins` array.
  */
-export async function getConfigs({ configPath, input, watch, logLevel, noCache }: GetConfigsOptions): Promise<GetConfigsResult> {
+export async function getConfigs({ configPath, input, watch, logLevel }: GetConfigsOptions): Promise<GetConfigsResult> {
   const result = await getCosmiConfig(configPath)
-  const cli: CLIOptions = { config: configPath, input, watch, logLevel, noCache }
+  const cli: CLIOptions = { config: configPath, input, watch, logLevel }
   const resolved = await (typeof result.config === 'function' ? result.config(cli) : result.config)
   const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
 
   return {
     configPath: result.filepath,
-    configs: userConfigs.map((item) => {
-      const config = { ...item, plugins: item.plugins ?? [] } as Config
-      // `--no-cache` overrides whatever cache the config resolved to (fsCache by default), so the
-      // run regenerates everything instead of restoring a snapshot.
-      return noCache ? { ...config, cache: undefined } : config
-    }),
+    configs: userConfigs.map((item) => ({ ...item, plugins: item.plugins ?? [] }) as Config),
   }
 }
 
@@ -126,6 +114,17 @@ type ExecuteHooksOptions = {
   hooks: AsyncEventEmitter<KubbHooks>
 }
 
+/**
+ * Tokenizes a shell command string, respecting single and double quotes.
+ *
+ * @example
+ * tokenize('git commit -m "initial commit"')
+ * // → ['git', 'commit', '-m', 'initial commit']
+ */
+function tokenize(command: string): Array<string> {
+  return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ''))
+}
+
 /**
  * Runs the `done` hooks defined in a Kubb config in sequence.
  */

package/src/runners/init/utils.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import process from 'node:process'
 import type { PackageManagerInfo, PackageManagerName } from '@internals/utils'
-import { spawnAsync } from '@internals/utils'
+import { x } from 'tinyexec'
 
 /**
  * Returns `true` when a `package.json` exists at `cwd`.
@@ -22,12 +22,18 @@ export async function initPackageJson(cwd: string, packageManager: PackageManage
     bun: ['init', '-y'],
   }
 
-  await spawnAsync(packageManager.name, commands[packageManager.name], { cwd })
+  await x(packageManager.name, commands[packageManager.name], {
+    nodeOptions: { cwd, stdio: 'inherit' },
+    throwOnError: true,
+  })
 }
 
 /**
  * Installs the given packages at `cwd` using the detected package manager.
  */
 export async function installPackages(packages: Array<string>, packageManager: PackageManagerInfo, cwd: string = process.cwd()): Promise<void> {
-  await spawnAsync(packageManager.name, [...packageManager.installCommand, ...packages], { cwd })
+  await x(packageManager.name, [...packageManager.installCommand, ...packages], {
+    nodeOptions: { cwd, stdio: 'inherit' },
+    throwOnError: true,
+  })
 }