zod-commander 0.0.5 → 0.1.1

package/README.md

@@ -45,4 +45,19 @@ program
 - **Async actions**: The `action` function can be async and receives parsed args and opts.
 - **No boilerplate**: Just export your command; integrate with your CLI runner as needed.
 - **Aliases for options**: If you start a description with a letter and a semicolon (e.g. `"f;The file to export to"`), that letter will be used as a short alias (e.g. `-f`).
-- **Perfect help output**: The generated help text is clear and complete—try running your command with `--help` to see for yourself!
+- **Perfect help output**: The generated help text is clear and complete—try running your command with `--help` to see for yourself!
+
+### Zod 4 support
+
+Currently, the package uses zod `v3` by default. Zod version can be specified by importing the appropriate version from the `zod3` or `zod4` submodules.
+
+```ts
+import { zodCommand } from 'zod-commander/zod4'
+// or
+import { zodCommand } from 'zod-commander/zod3' // equivalent to `import { zodCommand } from 'zod-commander'`
+```
+
+In the future, the default version will be changed to zod `v4`.
+
+> [!NOTE]
+> To use `zod-commander/zod4` in the same way as `zod-commander/zod3`, you should use [`.prefault()`](https://zod.dev/v4/changelog#default-updates) instead of `.default()`.

package/dist/chunk-Cmkb9WIj.cjs

@@ -0,0 +1,15 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+
+//#endregion
+
+Object.defineProperty(exports, '__name', {
+  enumerable: true,
+  get: function () {
+    return __name;
+  }
+});

package/dist/chunk-Dco9itRc.mjs

@@ -0,0 +1,9 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+
+//#endregion
+export { __name as t };

package/dist/common--ZfG2Kuo.d.mts

@@ -0,0 +1,8 @@
+import { t as __name } from "./chunk-Dco9itRc.mjs";
+
+//#region src/common.d.ts
+type BeforeFirstUnderscore<S> = S extends `${infer T}_${infer _}` ? T : S;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+//#endregion
+export { Prettify as n, BeforeFirstUnderscore as t };
+//# sourceMappingURL=common--ZfG2Kuo.d.mts.map

package/dist/common-x9DEqOZ0.d.cts

@@ -0,0 +1,7 @@
+//#endregion
+//#region src/common.d.ts
+type BeforeFirstUnderscore<S> = S extends `${infer T}_${infer _}` ? T : S;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+//#endregion
+export { Prettify as n, __name as r, BeforeFirstUnderscore as t };
+//# sourceMappingURL=common-x9DEqOZ0.d.cts.map

package/dist/zod3/index.cjs

@@ -0,0 +1,104 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-Cmkb9WIj.cjs');
+let commander = require("commander");
+let zod_v3 = require("zod/v3");
+
+//#region src/zod3/utils.ts
+const zodCore = (zod, fn) => {
+	const types = [
+		zod_v3.z.ZodDefault,
+		zod_v3.z.ZodNullable,
+		zod_v3.z.ZodOptional
+	];
+	for (const type of types) if (zod instanceof type) return zodCore(zod._def.innerType, fn);
+	if (zod instanceof zod_v3.z.ZodEffects) return zodCore(zod._def.schema, fn);
+	return fn(zod);
+};
+const zodEnumVals = (zod) => zodCore(zod, (zod) => zod instanceof zod_v3.z.ZodEnum ? zod._def.values : null);
+const zodIsBoolean = (zod) => zodCore(zod, (zod) => zod instanceof zod_v3.z.ZodBoolean);
+const zodDefault = (zod) => zod instanceof zod_v3.z.ZodEffects ? zodDefault(zod._def.schema) : zod instanceof zod_v3.z.ZodDefault ? zod._def.defaultValue() : void 0;
+const utils = {
+	zodCore,
+	zodEnumVals,
+	zodIsBoolean,
+	zodDefault
+};
+
+//#endregion
+//#region src/zod3/index.ts
+/**
+* Utilities for building type-safe Commander commands using Zod schemas.
+* @module
+*/
+const zodParser = (zod, opt) => (value) => {
+	const result = zod.safeParse(value);
+	if (result.success) return result.data;
+	const msg = result.error.issues[0].message;
+	if (opt) throw new commander.InvalidOptionArgumentError(msg);
+	throw new commander.InvalidArgumentError(msg);
+};
+/**
+* Creates a Commander.js Argument from a Zod schema.
+* Handles optionality, default values, and enum choices.
+* @param key - The argument name
+* @param zod - The Zod schema for the argument
+* @returns A Commander Argument instance
+*/
+const zodArgument = (key, zod) => {
+	const arg = new commander.Argument(zod.isOptional() ? `[${key}]` : `<${key}>`, zod.description);
+	const def = utils.zodDefault(zod);
+	if (def !== void 0) arg.default(zod.parse(def));
+	const choices = utils.zodEnumVals(zod);
+	if (choices) arg.choices(choices);
+	return arg.argParser(zodParser(zod));
+};
+/**
+* Creates a Commander.js Option from a Zod schema.
+* Handles optionality, default values, enum choices, and boolean flags.
+* Supports short flags via description prefix (e.g., 's;...').
+* @param key - The option name (can include underscores for grouping)
+* @param zod - The Zod schema for the option
+* @returns A Commander Option instance
+*/
+const zodOption = (key, zod) => {
+	const abbr = zod.description?.match(/^(\w);/)?.[1];
+	const description = abbr ? zod.description.slice(2) : zod.description;
+	const arg = key.includes("_") ? key.split("_").slice(1).join("-") : key;
+	if (key.includes("_")) [key] = key.split("_");
+	const isBoolean = utils.zodIsBoolean(zod);
+	const flag = `--${key}${isBoolean ? "" : ` <${arg}>`}`;
+	const opt = new commander.Option(abbr ? `-${abbr}, ${flag}` : flag, description);
+	if (isBoolean) opt.optional = true;
+	else if (!zod.isOptional()) opt.makeOptionMandatory();
+	const def = utils.zodDefault(zod);
+	if (def !== void 0) opt.default(zod.parse(def));
+	const choices = utils.zodEnumVals(zod);
+	if (choices) opt.choices(choices);
+	return opt.argParser(zodParser(zod, "opt"));
+};
+/**
+* Defines a Commander.js Command using Zod schemas for arguments and options.
+* Automatically wires up parsing, validation, and help configuration.
+* @template A - ZodRawShape for arguments
+* @template O - ZodRawShape for options
+* @param props - Command properties (name, description, args, opts, action)
+* @returns A Commander Command instance
+*/
+const zodCommand = ({ name, description, args, opts, action }) => {
+	const command = new commander.Command(name);
+	if (description) command.description(description);
+	for (const key in args) command.addArgument(zodArgument(key, args[key]));
+	for (const key in opts) command.addOption(zodOption(key, opts[key]));
+	if (action) command.action(async (...all) => {
+		const resultArgs = Object.fromEntries(Object.keys(args ?? {}).map((key, i) => [key, all[i]]));
+		const resultOpts = all[Object.keys(args ?? {}).length];
+		await action(resultArgs, resultOpts);
+	});
+	return command;
+};
+
+//#endregion
+exports.zodArgument = zodArgument;
+exports.zodCommand = zodCommand;
+exports.zodOption = zodOption;
+//# sourceMappingURL=index.cjs.map

package/dist/zod3/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["z","InvalidOptionArgumentError","InvalidArgumentError","Argument","Option","Command"],"sources":["../../src/zod3/utils.ts","../../src/zod3/index.ts"],"sourcesContent":["import { z } from 'zod/v3'\n\nconst zodCore = <T>(zod: z.ZodTypeAny, fn: (zod: z.ZodTypeAny) => T): T => {\n\tconst types = [z.ZodDefault, z.ZodNullable, z.ZodOptional]\n\tfor (const type of types)\n\t\tif (zod instanceof type) return zodCore(zod._def.innerType, fn)\n\tif (zod instanceof z.ZodEffects) return zodCore(zod._def.schema, fn)\n\treturn fn(zod)\n}\n\nconst zodEnumVals = (zod: z.ZodTypeAny): string[] | null =>\n\tzodCore(zod, (zod) => (zod instanceof z.ZodEnum ? zod._def.values : null))\n\nconst zodIsBoolean = (zod: z.ZodTypeAny): boolean =>\n\tzodCore(zod, (zod) => zod instanceof z.ZodBoolean)\n\nconst zodDefault = <Output, Def extends z.ZodTypeDef, Input>(\n\tzod: z.ZodType<Output, Def, Input>,\n): Input | undefined =>\n\tzod instanceof z.ZodEffects\n\t\t? zodDefault(zod._def.schema)\n\t\t: zod instanceof z.ZodDefault\n\t\t\t? zod._def.defaultValue()\n\t\t\t: undefined\n\nconst utils = {\n\tzodCore,\n\tzodEnumVals,\n\tzodIsBoolean,\n\tzodDefault,\n}\n\nexport default utils\n","/**\n * Utilities for building type-safe Commander commands using Zod schemas.\n * @module\n */\n\nimport {\n\tArgument,\n\tCommand,\n\tInvalidArgumentError,\n\tInvalidOptionArgumentError,\n\tOption,\n} from 'commander'\nimport type { z } from 'zod/v3'\nimport type { BeforeFirstUnderscore, Prettify } from '#/common.js'\nimport utils from './utils.js'\n\nexport type { Argument, Command, Option } from 'commander'\n\ntype ReplaceKeyTypes<Type extends z.ZodRawShape> = {\n\t[Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key]\n}\n\n/**\n * The action function signature for a Zod-powered command.\n * @template A - ZodRawShape for arguments\n * @template O - ZodRawShape for options\n * @param args - Parsed and validated arguments\n * @param opts - Parsed and validated options (with key normalization)\n * @returns A Promise or void\n */\nexport type ZodCommandAction<\n\tA extends z.ZodRawShape,\n\tO extends z.ZodRawShape,\n> = ZodCommandProps<A, O>['action']\n\ntype ZodCommandProps<A extends z.ZodRawShape, O extends z.ZodRawShape> = {\n\tname?: string\n\tdescription?: string\n\targs?: A\n\topts?: O\n\taction?: (\n\t\targs: Prettify<z.infer<z.ZodObject<A>>>,\n\t\topts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>,\n\t) => Promise<void> | void\n}\n\nconst zodParser = (zod: z.ZodTypeAny, opt?: 'opt') => (value: string) => {\n\tconst result = zod.safeParse(value)\n\tif (result.success) return result.data\n\tconst msg = result.error.issues[0].message\n\tif (opt) throw new InvalidOptionArgumentError(msg)\n\tthrow new InvalidArgumentError(msg)\n}\n\n/**\n * Creates a Commander.js Argument from a Zod schema.\n * Handles optionality, default values, and enum choices.\n * @param key - The argument name\n * @param zod - The Zod schema for the argument\n * @returns A Commander Argument instance\n */\nexport const zodArgument = (key: string, zod: z.ZodTypeAny): Argument => {\n\tconst flag = zod.isOptional() ? `[${key}]` : `<${key}>`\n\tconst arg = new Argument(flag, zod.description)\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) arg.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)\n\tif (choices) arg.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn arg.argParser(zodParser(zod))\n}\n\n/**\n * Creates a Commander.js Option from a Zod schema.\n * Handles optionality, default values, enum choices, and boolean flags.\n * Supports short flags via description prefix (e.g., 's;...').\n * @param key - The option name (can include underscores for grouping)\n * @param zod - The Zod schema for the option\n * @returns A Commander Option instance\n */\nexport const zodOption = (key: string, zod: z.ZodTypeAny): Option => {\n\tconst abbr = zod.description?.match(/^(\\w);/)?.[1]\n\tconst description = abbr ? zod.description.slice(2) : zod.description\n\tconst arg = key.includes('_') ? key.split('_').slice(1).join('-') : key\n\tif (key.includes('_')) [key] = key.split('_')\n\tconst isBoolean = utils.zodIsBoolean(zod)\n\tconst flag = `--${key}${isBoolean ? '' : ` <${arg}>`}`\n\tconst flags = abbr ? `-${abbr}, ${flag}` : flag\n\tconst opt = new Option(flags, description)\n\n\t// required for boolean flags\n\tif (isBoolean) opt.optional = true\n\telse if (!zod.isOptional()) opt.makeOptionMandatory()\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) opt.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)\n\tif (choices) opt.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn opt.argParser(zodParser(zod, 'opt'))\n}\n\n/**\n * Defines a Commander.js Command using Zod schemas for arguments and options.\n * Automatically wires up parsing, validation, and help configuration.\n * @template A - ZodRawShape for arguments\n * @template O - ZodRawShape for options\n * @param props - Command properties (name, description, args, opts, action)\n * @returns A Commander Command instance\n */\nexport const zodCommand = <A extends z.ZodRawShape, O extends z.ZodRawShape>({\n\tname,\n\tdescription,\n\targs,\n\topts,\n\taction,\n}: ZodCommandProps<A, O>): Command => {\n\tconst command = new Command(name)\n\tif (description) command.description(description)\n\tfor (const key in args) command.addArgument(zodArgument(key, args[key]))\n\tfor (const key in opts) command.addOption(zodOption(key, opts[key]))\n\tif (action)\n\t\tcommand.action(async (...all) => {\n\t\t\tconst resultArgs = Object.fromEntries(\n\t\t\t\tObject.keys(args ?? {}).map((key, i) => [key, all[i]]),\n\t\t\t) as z.infer<z.ZodObject<A>>\n\t\t\tconst resultOpts = all[Object.keys(args ?? {}).length] as z.infer<\n\t\t\t\tz.ZodObject<ReplaceKeyTypes<O>>\n\t\t\t>\n\t\t\tawait action(resultArgs, resultOpts)\n\t\t})\n\treturn command\n}\n"],"mappings":"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"}

package/dist/{index.d.cts → zod3/index.d.cts}

@@ -1,13 +1,9 @@
-import { Argument, Option, Command } from 'commander';
-import { z } from 'zod';
+import { n as Prettify, r as __name, t as BeforeFirstUnderscore } from "../common-x9DEqOZ0.cjs";
+import { Argument, Argument as Argument$1, Command, Command as Command$1, Option, Option as Option$1 } from "commander";
+import { z } from "zod/v3";
 
-type BeforeFirstUnderscore<S> = S extends `${infer T}_${infer _}` ? T : S;
-type ReplaceKeyTypes<Type extends z.ZodRawShape> = {
-    [Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key];
-};
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
+//#region src/zod3/index.d.ts
+type ReplaceKeyTypes<Type extends z.ZodRawShape> = { [Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key] };
 /**
  * The action function signature for a Zod-powered command.
  * @template A - ZodRawShape for arguments
@@ -18,11 +14,11 @@ type Prettify<T> = {
  */
 type ZodCommandAction<A extends z.ZodRawShape, O extends z.ZodRawShape> = ZodCommandProps<A, O>['action'];
 type ZodCommandProps<A extends z.ZodRawShape, O extends z.ZodRawShape> = {
-    name?: string;
-    description?: string;
-    args?: A;
-    opts?: O;
-    action?: (args: Prettify<z.infer<z.ZodObject<A>>>, opts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>) => Promise<void> | void;
+  name?: string;
+  description?: string;
+  args?: A;
+  opts?: O;
+  action?: (args: Prettify<z.infer<z.ZodObject<A>>>, opts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>) => Promise<void> | void;
 };
 /**
  * Creates a Commander.js Argument from a Zod schema.
@@ -31,7 +27,7 @@ type ZodCommandProps<A extends z.ZodRawShape, O extends z.ZodRawShape> = {
  * @param zod - The Zod schema for the argument
  * @returns A Commander Argument instance
  */
-declare const zodArgument: (key: string, zod: z.ZodTypeAny) => Argument;
+declare const zodArgument: (key: string, zod: z.ZodTypeAny) => Argument$1;
 /**
  * Creates a Commander.js Option from a Zod schema.
  * Handles optionality, default values, enum choices, and boolean flags.
@@ -40,7 +36,7 @@ declare const zodArgument: (key: string, zod: z.ZodTypeAny) => Argument;
  * @param zod - The Zod schema for the option
  * @returns A Commander Option instance
  */
-declare const zodOption: (key: string, zod: z.ZodTypeAny) => Option;
+declare const zodOption: (key: string, zod: z.ZodTypeAny) => Option$1;
 /**
  * Defines a Commander.js Command using Zod schemas for arguments and options.
  * Automatically wires up parsing, validation, and help configuration.
@@ -49,6 +45,13 @@ declare const zodOption: (key: string, zod: z.ZodTypeAny) => Option;
  * @param props - Command properties (name, description, args, opts, action)
  * @returns A Commander Command instance
  */
-declare const zodCommand: <A extends z.ZodRawShape, O extends z.ZodRawShape>({ name, description, args, opts, action, }: ZodCommandProps<A, O>) => Command;
-
-export { type ZodCommandAction, zodArgument, zodCommand, zodOption };
+declare const zodCommand: <A extends z.ZodRawShape, O extends z.ZodRawShape>({
+  name,
+  description,
+  args,
+  opts,
+  action
+}: ZodCommandProps<A, O>) => Command$1;
+//#endregion
+export { type Argument, type Command, type Option, ZodCommandAction, zodArgument, zodCommand, zodOption };
+//# sourceMappingURL=index.d.cts.map

package/dist/{index.d.ts → zod3/index.d.mts}

@@ -1,13 +1,10 @@
-import { Argument, Option, Command } from 'commander';
-import { z } from 'zod';
+import { t as __name } from "../chunk-Dco9itRc.mjs";
+import { n as Prettify, t as BeforeFirstUnderscore } from "../common--ZfG2Kuo.mjs";
+import { Argument, Argument as Argument$1, Command, Command as Command$1, Option, Option as Option$1 } from "commander";
+import { z } from "zod/v3";
 
-type BeforeFirstUnderscore<S> = S extends `${infer T}_${infer _}` ? T : S;
-type ReplaceKeyTypes<Type extends z.ZodRawShape> = {
-    [Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key];
-};
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
+//#region src/zod3/index.d.ts
+type ReplaceKeyTypes<Type extends z.ZodRawShape> = { [Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key] };
 /**
  * The action function signature for a Zod-powered command.
  * @template A - ZodRawShape for arguments
@@ -18,11 +15,11 @@ type Prettify<T> = {
  */
 type ZodCommandAction<A extends z.ZodRawShape, O extends z.ZodRawShape> = ZodCommandProps<A, O>['action'];
 type ZodCommandProps<A extends z.ZodRawShape, O extends z.ZodRawShape> = {
-    name?: string;
-    description?: string;
-    args?: A;
-    opts?: O;
-    action?: (args: Prettify<z.infer<z.ZodObject<A>>>, opts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>) => Promise<void> | void;
+  name?: string;
+  description?: string;
+  args?: A;
+  opts?: O;
+  action?: (args: Prettify<z.infer<z.ZodObject<A>>>, opts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>) => Promise<void> | void;
 };
 /**
  * Creates a Commander.js Argument from a Zod schema.
@@ -31,7 +28,7 @@ type ZodCommandProps<A extends z.ZodRawShape, O extends z.ZodRawShape> = {
  * @param zod - The Zod schema for the argument
  * @returns A Commander Argument instance
  */
-declare const zodArgument: (key: string, zod: z.ZodTypeAny) => Argument;
+declare const zodArgument: (key: string, zod: z.ZodTypeAny) => Argument$1;
 /**
  * Creates a Commander.js Option from a Zod schema.
  * Handles optionality, default values, enum choices, and boolean flags.
@@ -40,7 +37,7 @@ declare const zodArgument: (key: string, zod: z.ZodTypeAny) => Argument;
  * @param zod - The Zod schema for the option
  * @returns A Commander Option instance
  */
-declare const zodOption: (key: string, zod: z.ZodTypeAny) => Option;
+declare const zodOption: (key: string, zod: z.ZodTypeAny) => Option$1;
 /**
  * Defines a Commander.js Command using Zod schemas for arguments and options.
  * Automatically wires up parsing, validation, and help configuration.
@@ -49,6 +46,13 @@ declare const zodOption: (key: string, zod: z.ZodTypeAny) => Option;
  * @param props - Command properties (name, description, args, opts, action)
  * @returns A Commander Command instance
  */
-declare const zodCommand: <A extends z.ZodRawShape, O extends z.ZodRawShape>({ name, description, args, opts, action, }: ZodCommandProps<A, O>) => Command;
-
-export { type ZodCommandAction, zodArgument, zodCommand, zodOption };
+declare const zodCommand: <A extends z.ZodRawShape, O extends z.ZodRawShape>({
+  name,
+  description,
+  args,
+  opts,
+  action
+}: ZodCommandProps<A, O>) => Command$1;
+//#endregion
+export { type Argument, type Command, type Option, ZodCommandAction, zodArgument, zodCommand, zodOption };
+//# sourceMappingURL=index.d.mts.map

package/dist/zod3/index.mjs

@@ -0,0 +1,101 @@
+import { t as __name } from "../chunk-Dco9itRc.mjs";
+import { Argument, Command, InvalidArgumentError, InvalidOptionArgumentError, Option } from "commander";
+import { z } from "zod/v3";
+
+//#region src/zod3/utils.ts
+const zodCore = (zod, fn) => {
+	const types = [
+		z.ZodDefault,
+		z.ZodNullable,
+		z.ZodOptional
+	];
+	for (const type of types) if (zod instanceof type) return zodCore(zod._def.innerType, fn);
+	if (zod instanceof z.ZodEffects) return zodCore(zod._def.schema, fn);
+	return fn(zod);
+};
+const zodEnumVals = (zod) => zodCore(zod, (zod) => zod instanceof z.ZodEnum ? zod._def.values : null);
+const zodIsBoolean = (zod) => zodCore(zod, (zod) => zod instanceof z.ZodBoolean);
+const zodDefault = (zod) => zod instanceof z.ZodEffects ? zodDefault(zod._def.schema) : zod instanceof z.ZodDefault ? zod._def.defaultValue() : void 0;
+const utils = {
+	zodCore,
+	zodEnumVals,
+	zodIsBoolean,
+	zodDefault
+};
+
+//#endregion
+//#region src/zod3/index.ts
+/**
+* Utilities for building type-safe Commander commands using Zod schemas.
+* @module
+*/
+const zodParser = (zod, opt) => (value) => {
+	const result = zod.safeParse(value);
+	if (result.success) return result.data;
+	const msg = result.error.issues[0].message;
+	if (opt) throw new InvalidOptionArgumentError(msg);
+	throw new InvalidArgumentError(msg);
+};
+/**
+* Creates a Commander.js Argument from a Zod schema.
+* Handles optionality, default values, and enum choices.
+* @param key - The argument name
+* @param zod - The Zod schema for the argument
+* @returns A Commander Argument instance
+*/
+const zodArgument = (key, zod) => {
+	const arg = new Argument(zod.isOptional() ? `[${key}]` : `<${key}>`, zod.description);
+	const def = utils.zodDefault(zod);
+	if (def !== void 0) arg.default(zod.parse(def));
+	const choices = utils.zodEnumVals(zod);
+	if (choices) arg.choices(choices);
+	return arg.argParser(zodParser(zod));
+};
+/**
+* Creates a Commander.js Option from a Zod schema.
+* Handles optionality, default values, enum choices, and boolean flags.
+* Supports short flags via description prefix (e.g., 's;...').
+* @param key - The option name (can include underscores for grouping)
+* @param zod - The Zod schema for the option
+* @returns A Commander Option instance
+*/
+const zodOption = (key, zod) => {
+	const abbr = zod.description?.match(/^(\w);/)?.[1];
+	const description = abbr ? zod.description.slice(2) : zod.description;
+	const arg = key.includes("_") ? key.split("_").slice(1).join("-") : key;
+	if (key.includes("_")) [key] = key.split("_");
+	const isBoolean = utils.zodIsBoolean(zod);
+	const flag = `--${key}${isBoolean ? "" : ` <${arg}>`}`;
+	const opt = new Option(abbr ? `-${abbr}, ${flag}` : flag, description);
+	if (isBoolean) opt.optional = true;
+	else if (!zod.isOptional()) opt.makeOptionMandatory();
+	const def = utils.zodDefault(zod);
+	if (def !== void 0) opt.default(zod.parse(def));
+	const choices = utils.zodEnumVals(zod);
+	if (choices) opt.choices(choices);
+	return opt.argParser(zodParser(zod, "opt"));
+};
+/**
+* Defines a Commander.js Command using Zod schemas for arguments and options.
+* Automatically wires up parsing, validation, and help configuration.
+* @template A - ZodRawShape for arguments
+* @template O - ZodRawShape for options
+* @param props - Command properties (name, description, args, opts, action)
+* @returns A Commander Command instance
+*/
+const zodCommand = ({ name, description, args, opts, action }) => {
+	const command = new Command(name);
+	if (description) command.description(description);
+	for (const key in args) command.addArgument(zodArgument(key, args[key]));
+	for (const key in opts) command.addOption(zodOption(key, opts[key]));
+	if (action) command.action(async (...all) => {
+		const resultArgs = Object.fromEntries(Object.keys(args ?? {}).map((key, i) => [key, all[i]]));
+		const resultOpts = all[Object.keys(args ?? {}).length];
+		await action(resultArgs, resultOpts);
+	});
+	return command;
+};
+
+//#endregion
+export { zodArgument, zodCommand, zodOption };
+//# sourceMappingURL=index.mjs.map

package/dist/zod3/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/zod3/utils.ts","../../src/zod3/index.ts"],"sourcesContent":["import { z } from 'zod/v3'\n\nconst zodCore = <T>(zod: z.ZodTypeAny, fn: (zod: z.ZodTypeAny) => T): T => {\n\tconst types = [z.ZodDefault, z.ZodNullable, z.ZodOptional]\n\tfor (const type of types)\n\t\tif (zod instanceof type) return zodCore(zod._def.innerType, fn)\n\tif (zod instanceof z.ZodEffects) return zodCore(zod._def.schema, fn)\n\treturn fn(zod)\n}\n\nconst zodEnumVals = (zod: z.ZodTypeAny): string[] | null =>\n\tzodCore(zod, (zod) => (zod instanceof z.ZodEnum ? zod._def.values : null))\n\nconst zodIsBoolean = (zod: z.ZodTypeAny): boolean =>\n\tzodCore(zod, (zod) => zod instanceof z.ZodBoolean)\n\nconst zodDefault = <Output, Def extends z.ZodTypeDef, Input>(\n\tzod: z.ZodType<Output, Def, Input>,\n): Input | undefined =>\n\tzod instanceof z.ZodEffects\n\t\t? zodDefault(zod._def.schema)\n\t\t: zod instanceof z.ZodDefault\n\t\t\t? zod._def.defaultValue()\n\t\t\t: undefined\n\nconst utils = {\n\tzodCore,\n\tzodEnumVals,\n\tzodIsBoolean,\n\tzodDefault,\n}\n\nexport default utils\n","/**\n * Utilities for building type-safe Commander commands using Zod schemas.\n * @module\n */\n\nimport {\n\tArgument,\n\tCommand,\n\tInvalidArgumentError,\n\tInvalidOptionArgumentError,\n\tOption,\n} from 'commander'\nimport type { z } from 'zod/v3'\nimport type { BeforeFirstUnderscore, Prettify } from '#/common.js'\nimport utils from './utils.js'\n\nexport type { Argument, Command, Option } from 'commander'\n\ntype ReplaceKeyTypes<Type extends z.ZodRawShape> = {\n\t[Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key]\n}\n\n/**\n * The action function signature for a Zod-powered command.\n * @template A - ZodRawShape for arguments\n * @template O - ZodRawShape for options\n * @param args - Parsed and validated arguments\n * @param opts - Parsed and validated options (with key normalization)\n * @returns A Promise or void\n */\nexport type ZodCommandAction<\n\tA extends z.ZodRawShape,\n\tO extends z.ZodRawShape,\n> = ZodCommandProps<A, O>['action']\n\ntype ZodCommandProps<A extends z.ZodRawShape, O extends z.ZodRawShape> = {\n\tname?: string\n\tdescription?: string\n\targs?: A\n\topts?: O\n\taction?: (\n\t\targs: Prettify<z.infer<z.ZodObject<A>>>,\n\t\topts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>,\n\t) => Promise<void> | void\n}\n\nconst zodParser = (zod: z.ZodTypeAny, opt?: 'opt') => (value: string) => {\n\tconst result = zod.safeParse(value)\n\tif (result.success) return result.data\n\tconst msg = result.error.issues[0].message\n\tif (opt) throw new InvalidOptionArgumentError(msg)\n\tthrow new InvalidArgumentError(msg)\n}\n\n/**\n * Creates a Commander.js Argument from a Zod schema.\n * Handles optionality, default values, and enum choices.\n * @param key - The argument name\n * @param zod - The Zod schema for the argument\n * @returns A Commander Argument instance\n */\nexport const zodArgument = (key: string, zod: z.ZodTypeAny): Argument => {\n\tconst flag = zod.isOptional() ? `[${key}]` : `<${key}>`\n\tconst arg = new Argument(flag, zod.description)\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) arg.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)\n\tif (choices) arg.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn arg.argParser(zodParser(zod))\n}\n\n/**\n * Creates a Commander.js Option from a Zod schema.\n * Handles optionality, default values, enum choices, and boolean flags.\n * Supports short flags via description prefix (e.g., 's;...').\n * @param key - The option name (can include underscores for grouping)\n * @param zod - The Zod schema for the option\n * @returns A Commander Option instance\n */\nexport const zodOption = (key: string, zod: z.ZodTypeAny): Option => {\n\tconst abbr = zod.description?.match(/^(\\w);/)?.[1]\n\tconst description = abbr ? zod.description.slice(2) : zod.description\n\tconst arg = key.includes('_') ? key.split('_').slice(1).join('-') : key\n\tif (key.includes('_')) [key] = key.split('_')\n\tconst isBoolean = utils.zodIsBoolean(zod)\n\tconst flag = `--${key}${isBoolean ? '' : ` <${arg}>`}`\n\tconst flags = abbr ? `-${abbr}, ${flag}` : flag\n\tconst opt = new Option(flags, description)\n\n\t// required for boolean flags\n\tif (isBoolean) opt.optional = true\n\telse if (!zod.isOptional()) opt.makeOptionMandatory()\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) opt.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)\n\tif (choices) opt.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn opt.argParser(zodParser(zod, 'opt'))\n}\n\n/**\n * Defines a Commander.js Command using Zod schemas for arguments and options.\n * Automatically wires up parsing, validation, and help configuration.\n * @template A - ZodRawShape for arguments\n * @template O - ZodRawShape for options\n * @param props - Command properties (name, description, args, opts, action)\n * @returns A Commander Command instance\n */\nexport const zodCommand = <A extends z.ZodRawShape, O extends z.ZodRawShape>({\n\tname,\n\tdescription,\n\targs,\n\topts,\n\taction,\n}: ZodCommandProps<A, O>): Command => {\n\tconst command = new Command(name)\n\tif (description) command.description(description)\n\tfor (const key in args) command.addArgument(zodArgument(key, args[key]))\n\tfor (const key in opts) command.addOption(zodOption(key, opts[key]))\n\tif (action)\n\t\tcommand.action(async (...all) => {\n\t\t\tconst resultArgs = Object.fromEntries(\n\t\t\t\tObject.keys(args ?? {}).map((key, i) => [key, all[i]]),\n\t\t\t) as z.infer<z.ZodObject<A>>\n\t\t\tconst resultOpts = all[Object.keys(args ?? {}).length] as z.infer<\n\t\t\t\tz.ZodObject<ReplaceKeyTypes<O>>\n\t\t\t>\n\t\t\tawait action(resultArgs, resultOpts)\n\t\t})\n\treturn command\n}\n"],"mappings":"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"}

package/dist/zod4/index.cjs

@@ -0,0 +1,107 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-Cmkb9WIj.cjs');
+let commander = require("commander");
+let zod_v4 = require("zod/v4");
+
+//#region src/zod4/utils.ts
+const zodCore = (zod, fn) => {
+	const types = [
+		zod_v4.z.ZodDefault,
+		zod_v4.z.ZodPrefault,
+		zod_v4.z.ZodNullable,
+		zod_v4.z.ZodOptional
+	];
+	for (const type of types) if (zod instanceof type) return zodCore(zod.def.innerType, fn);
+	if (zod instanceof zod_v4.z.ZodPipe) return zodCore(zod.def.in, fn);
+	return fn(zod);
+};
+const zodEnumVals = (zod) => zodCore(zod, (zod) => zod instanceof zod_v4.z.ZodEnum ? zod.options : null);
+const zodIsBoolean = (zod) => zodCore(zod, (zod) => zod instanceof zod_v4.z.ZodBoolean);
+const zodIsOptional = (zod) => zod.safeParse(void 0).success;
+const zodDefault = (zod) => zod instanceof zod_v4.z.ZodPipe ? zodDefault(zod.def.in) : zod instanceof zod_v4.z.ZodPrefault ? zod.def.defaultValue : void 0;
+const utils = {
+	zodCore,
+	zodEnumVals,
+	zodIsBoolean,
+	zodIsOptional,
+	zodDefault
+};
+
+//#endregion
+//#region src/zod4/index.ts
+/**
+* Utilities for building type-safe Commander commands using Zod schemas.
+* @module
+*/
+const zodParser = (zod, opt) => (value) => {
+	const result = zod.safeParse(value);
+	if (result.success) return result.data;
+	const msg = result.error.issues[0].message;
+	if (opt) throw new commander.InvalidOptionArgumentError(msg);
+	throw new commander.InvalidArgumentError(msg);
+};
+/**
+* Creates a Commander.js Argument from a Zod schema.
+* Handles optionality, default values, and enum choices.
+* @param key - The argument name
+* @param zod - The Zod schema for the argument
+* @returns A Commander Argument instance
+*/
+const zodArgument = (key, zod) => {
+	const arg = new commander.Argument(utils.zodIsOptional(zod) ? `[${key}]` : `<${key}>`, zod.description);
+	const def = utils.zodDefault(zod);
+	if (def !== void 0) arg.default(zod.parse(def));
+	const choices = utils.zodEnumVals(zod)?.map(String);
+	if (choices) arg.choices(choices);
+	return arg.argParser(zodParser(zod));
+};
+/**
+* Creates a Commander.js Option from a Zod schema.
+* Handles optionality, default values, enum choices, and boolean flags.
+* Supports short flags via description prefix (e.g., 's;...').
+* @param key - The option name (can include underscores for grouping)
+* @param zod - The Zod schema for the option
+* @returns A Commander Option instance
+*/
+const zodOption = (key, zod) => {
+	const abbr = zod.description?.match(/^(\w);/)?.[1];
+	const description = abbr ? zod.description?.slice(2) : zod.description;
+	const arg = key.includes("_") ? key.split("_").slice(1).join("-") : key;
+	if (key.includes("_")) [key] = key.split("_");
+	const isBoolean = utils.zodIsBoolean(zod);
+	const flag = `--${key}${isBoolean ? "" : ` <${arg}>`}`;
+	const opt = new commander.Option(abbr ? `-${abbr}, ${flag}` : flag, description);
+	if (isBoolean) opt.optional = true;
+	else if (!utils.zodIsOptional(zod)) opt.makeOptionMandatory();
+	const def = utils.zodDefault(zod);
+	if (def !== void 0) opt.default(zod.parse(def));
+	const choices = utils.zodEnumVals(zod)?.map(String);
+	if (choices) opt.choices(choices);
+	return opt.argParser(zodParser(zod, "opt"));
+};
+/**
+* Defines a Commander.js Command using Zod schemas for arguments and options.
+* Automatically wires up parsing, validation, and help configuration.
+* @template A - Record of key-value pairs where key is the argument name and value is the Zod schema
+* @template O - Record of key-value pairs where key is the option name and value is the Zod schema
+* @param props - Command properties (name, description, args, opts, action)
+* @returns A Commander Command instance
+*/
+const zodCommand = ({ name, description, args, opts, action }) => {
+	const command = new commander.Command(name);
+	if (description) command.description(description);
+	for (const key in args) command.addArgument(zodArgument(key, args[key]));
+	for (const key in opts) command.addOption(zodOption(key, opts[key]));
+	if (action) command.action(async (...all) => {
+		const resultArgs = Object.fromEntries(Object.keys(args ?? {}).map((key, i) => [key, all[i]]));
+		const resultOpts = all[Object.keys(args ?? {}).length];
+		await action(resultArgs, resultOpts);
+	});
+	return command;
+};
+
+//#endregion
+exports.zodArgument = zodArgument;
+exports.zodCommand = zodCommand;
+exports.zodOption = zodOption;
+//# sourceMappingURL=index.cjs.map

package/dist/zod4/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["z","InvalidOptionArgumentError","InvalidArgumentError","Argument","Option","Command"],"sources":["../../src/zod4/utils.ts","../../src/zod4/index.ts"],"sourcesContent":["import { z } from 'zod/v4'\n\nconst zodCore = <T>(\n\tzod: z.core.$ZodType,\n\tfn: (zod: z.core.$ZodType) => T,\n): T => {\n\tconst types = [z.ZodDefault, z.ZodPrefault, z.ZodNullable, z.ZodOptional]\n\tfor (const type of types)\n\t\tif (zod instanceof type) return zodCore(zod.def.innerType, fn)\n\tif (zod instanceof z.ZodPipe) return zodCore(zod.def.in, fn)\n\treturn fn(zod)\n}\n\nconst zodEnumVals = (zod: z.ZodTypeAny): z.core.util.EnumValue[] | null =>\n\tzodCore(zod, (zod) => (zod instanceof z.ZodEnum ? zod.options : null))\n\nconst zodIsBoolean = (zod: z.ZodTypeAny): boolean =>\n\tzodCore(zod, (zod) => zod instanceof z.ZodBoolean)\n\nconst zodIsOptional = (zod: z.ZodType): boolean =>\n\tzod.safeParse(undefined).success\n\nconst zodDefault = <Output, Input>(\n\tzod: z.ZodType<Output, Input>,\n): Input | undefined =>\n\tzod instanceof z.ZodPipe\n\t\t? zodDefault(zod.def.in as z.ZodType<unknown, Input>)\n\t\t: zod instanceof z.ZodPrefault\n\t\t\t? (zod.def.defaultValue as Input)\n\t\t\t: undefined\n\nconst utils = {\n\tzodCore,\n\tzodEnumVals,\n\tzodIsBoolean,\n\tzodIsOptional,\n\tzodDefault,\n}\n\nexport default utils\n","/**\n * Utilities for building type-safe Commander commands using Zod schemas.\n * @module\n */\n\nimport {\n\tArgument,\n\tCommand,\n\tInvalidArgumentError,\n\tInvalidOptionArgumentError,\n\tOption,\n} from 'commander'\nimport type { z } from 'zod/v4'\nimport type { BeforeFirstUnderscore, Prettify } from '#/common.js'\nimport utils from './utils.js'\n\nexport type { Argument, Command, Option } from 'commander'\n\ntype ReplaceKeyTypes<Type extends z.ZodRawShape> = {\n\t[Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key]\n}\n\n/**\n * The action function signature for a Zod-powered command.\n * @template A - Record of key-value pairs where key is the argument name and value is the Zod schema\n * @template O - Record of key-value pairs where key is the option name and value is the Zod schema\n * @param args - Parsed and validated arguments\n * @param opts - Parsed and validated options (with key normalization)\n * @returns A Promise or void\n */\nexport type ZodCommandAction<\n\tA extends Record<string, z.ZodType>,\n\tO extends Record<string, z.ZodType>,\n> = ZodCommandProps<A, O>['action']\n\ntype ZodCommandProps<\n\tA extends Record<string, z.ZodType>,\n\tO extends Record<string, z.ZodType>,\n> = {\n\tname?: string\n\tdescription?: string\n\targs?: A\n\topts?: O\n\taction?: (\n\t\targs: Prettify<z.infer<z.ZodObject<A>>>,\n\t\topts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>,\n\t) => Promise<void> | void\n}\n\nconst zodParser = (zod: z.ZodType, opt?: 'opt') => (value: string) => {\n\tconst result = zod.safeParse(value)\n\tif (result.success) return result.data\n\tconst msg = result.error.issues[0].message\n\tif (opt) throw new InvalidOptionArgumentError(msg)\n\tthrow new InvalidArgumentError(msg)\n}\n\n/**\n * Creates a Commander.js Argument from a Zod schema.\n * Handles optionality, default values, and enum choices.\n * @param key - The argument name\n * @param zod - The Zod schema for the argument\n * @returns A Commander Argument instance\n */\nexport const zodArgument = (key: string, zod: z.ZodType): Argument => {\n\tconst flag = utils.zodIsOptional(zod) ? `[${key}]` : `<${key}>`\n\tconst arg = new Argument(flag, zod.description)\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) arg.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)?.map(String)\n\tif (choices) arg.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn arg.argParser(zodParser(zod))\n}\n\n/**\n * Creates a Commander.js Option from a Zod schema.\n * Handles optionality, default values, enum choices, and boolean flags.\n * Supports short flags via description prefix (e.g., 's;...').\n * @param key - The option name (can include underscores for grouping)\n * @param zod - The Zod schema for the option\n * @returns A Commander Option instance\n */\nexport const zodOption = (key: string, zod: z.ZodType): Option => {\n\tconst abbr = zod.description?.match(/^(\\w);/)?.[1]\n\tconst description = abbr ? zod.description?.slice(2) : zod.description\n\tconst arg = key.includes('_') ? key.split('_').slice(1).join('-') : key\n\tif (key.includes('_')) [key] = key.split('_')\n\tconst isBoolean = utils.zodIsBoolean(zod)\n\tconst flag = `--${key}${isBoolean ? '' : ` <${arg}>`}`\n\tconst flags = abbr ? `-${abbr}, ${flag}` : flag\n\tconst opt = new Option(flags, description)\n\n\t// required for boolean flags\n\tif (isBoolean) opt.optional = true\n\telse if (!utils.zodIsOptional(zod)) opt.makeOptionMandatory()\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) opt.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)?.map(String)\n\tif (choices) opt.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn opt.argParser(zodParser(zod, 'opt'))\n}\n\n/**\n * Defines a Commander.js Command using Zod schemas for arguments and options.\n * Automatically wires up parsing, validation, and help configuration.\n * @template A - Record of key-value pairs where key is the argument name and value is the Zod schema\n * @template O - Record of key-value pairs where key is the option name and value is the Zod schema\n * @param props - Command properties (name, description, args, opts, action)\n * @returns A Commander Command instance\n */\nexport const zodCommand = <\n\tA extends Record<string, z.ZodType>,\n\tO extends Record<string, z.ZodType>,\n>({\n\tname,\n\tdescription,\n\targs,\n\topts,\n\taction,\n}: ZodCommandProps<A, O>): Command => {\n\tconst command = new Command(name)\n\tif (description) command.description(description)\n\tfor (const key in args) command.addArgument(zodArgument(key, args[key]))\n\tfor (const key in opts) command.addOption(zodOption(key, opts[key]))\n\tif (action)\n\t\tcommand.action(async (...all) => {\n\t\t\tconst resultArgs = Object.fromEntries(\n\t\t\t\tObject.keys(args ?? {}).map((key, i) => [key, all[i]]),\n\t\t\t) as z.infer<z.ZodObject<A>>\n\t\t\tconst resultOpts = all[Object.keys(args ?? {}).length] as z.infer<\n\t\t\t\tz.ZodObject<ReplaceKeyTypes<O>>\n\t\t\t>\n\t\t\tawait action(resultArgs, resultOpts)\n\t\t})\n\treturn command\n}\n"],"mappings":"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"}

package/dist/zod4/index.d.cts

@@ -0,0 +1,57 @@
+import { n as Prettify, r as __name, t as BeforeFirstUnderscore } from "../common-x9DEqOZ0.cjs";
+import { Argument, Argument as Argument$1, Command, Command as Command$1, Option, Option as Option$1 } from "commander";
+import { z } from "zod/v4";
+
+//#region src/zod4/index.d.ts
+type ReplaceKeyTypes<Type extends z.ZodRawShape> = { [Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key] };
+/**
+ * The action function signature for a Zod-powered command.
+ * @template A - Record of key-value pairs where key is the argument name and value is the Zod schema
+ * @template O - Record of key-value pairs where key is the option name and value is the Zod schema
+ * @param args - Parsed and validated arguments
+ * @param opts - Parsed and validated options (with key normalization)
+ * @returns A Promise or void
+ */
+type ZodCommandAction<A extends Record<string, z.ZodType>, O extends Record<string, z.ZodType>> = ZodCommandProps<A, O>['action'];
+type ZodCommandProps<A extends Record<string, z.ZodType>, O extends Record<string, z.ZodType>> = {
+  name?: string;
+  description?: string;
+  args?: A;
+  opts?: O;
+  action?: (args: Prettify<z.infer<z.ZodObject<A>>>, opts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>) => Promise<void> | void;
+};
+/**
+ * Creates a Commander.js Argument from a Zod schema.
+ * Handles optionality, default values, and enum choices.
+ * @param key - The argument name
+ * @param zod - The Zod schema for the argument
+ * @returns A Commander Argument instance
+ */
+declare const zodArgument: (key: string, zod: z.ZodType) => Argument$1;
+/**
+ * Creates a Commander.js Option from a Zod schema.
+ * Handles optionality, default values, enum choices, and boolean flags.
+ * Supports short flags via description prefix (e.g., 's;...').
+ * @param key - The option name (can include underscores for grouping)
+ * @param zod - The Zod schema for the option
+ * @returns A Commander Option instance
+ */
+declare const zodOption: (key: string, zod: z.ZodType) => Option$1;
+/**
+ * Defines a Commander.js Command using Zod schemas for arguments and options.
+ * Automatically wires up parsing, validation, and help configuration.
+ * @template A - Record of key-value pairs where key is the argument name and value is the Zod schema
+ * @template O - Record of key-value pairs where key is the option name and value is the Zod schema
+ * @param props - Command properties (name, description, args, opts, action)
+ * @returns A Commander Command instance
+ */
+declare const zodCommand: <A extends Record<string, z.ZodType>, O extends Record<string, z.ZodType>>({
+  name,
+  description,
+  args,
+  opts,
+  action
+}: ZodCommandProps<A, O>) => Command$1;
+//#endregion
+export { type Argument, type Command, type Option, ZodCommandAction, zodArgument, zodCommand, zodOption };
+//# sourceMappingURL=index.d.cts.map

package/dist/zod4/index.d.mts

@@ -0,0 +1,58 @@
+import { t as __name } from "../chunk-Dco9itRc.mjs";
+import { n as Prettify, t as BeforeFirstUnderscore } from "../common--ZfG2Kuo.mjs";
+import { Argument, Argument as Argument$1, Command, Command as Command$1, Option, Option as Option$1 } from "commander";
+import { z } from "zod/v4";
+
+//#region src/zod4/index.d.ts
+type ReplaceKeyTypes<Type extends z.ZodRawShape> = { [Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key] };
+/**
+ * The action function signature for a Zod-powered command.
+ * @template A - Record of key-value pairs where key is the argument name and value is the Zod schema
+ * @template O - Record of key-value pairs where key is the option name and value is the Zod schema
+ * @param args - Parsed and validated arguments
+ * @param opts - Parsed and validated options (with key normalization)
+ * @returns A Promise or void
+ */
+type ZodCommandAction<A extends Record<string, z.ZodType>, O extends Record<string, z.ZodType>> = ZodCommandProps<A, O>['action'];
+type ZodCommandProps<A extends Record<string, z.ZodType>, O extends Record<string, z.ZodType>> = {
+  name?: string;
+  description?: string;
+  args?: A;
+  opts?: O;
+  action?: (args: Prettify<z.infer<z.ZodObject<A>>>, opts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>) => Promise<void> | void;
+};
+/**
+ * Creates a Commander.js Argument from a Zod schema.
+ * Handles optionality, default values, and enum choices.
+ * @param key - The argument name
+ * @param zod - The Zod schema for the argument
+ * @returns A Commander Argument instance
+ */
+declare const zodArgument: (key: string, zod: z.ZodType) => Argument$1;
+/**
+ * Creates a Commander.js Option from a Zod schema.
+ * Handles optionality, default values, enum choices, and boolean flags.
+ * Supports short flags via description prefix (e.g., 's;...').
+ * @param key - The option name (can include underscores for grouping)
+ * @param zod - The Zod schema for the option
+ * @returns A Commander Option instance
+ */
+declare const zodOption: (key: string, zod: z.ZodType) => Option$1;
+/**
+ * Defines a Commander.js Command using Zod schemas for arguments and options.
+ * Automatically wires up parsing, validation, and help configuration.
+ * @template A - Record of key-value pairs where key is the argument name and value is the Zod schema
+ * @template O - Record of key-value pairs where key is the option name and value is the Zod schema
+ * @param props - Command properties (name, description, args, opts, action)
+ * @returns A Commander Command instance
+ */
+declare const zodCommand: <A extends Record<string, z.ZodType>, O extends Record<string, z.ZodType>>({
+  name,
+  description,
+  args,
+  opts,
+  action
+}: ZodCommandProps<A, O>) => Command$1;
+//#endregion
+export { type Argument, type Command, type Option, ZodCommandAction, zodArgument, zodCommand, zodOption };
+//# sourceMappingURL=index.d.mts.map

package/dist/zod4/index.mjs

@@ -0,0 +1,104 @@
+import { t as __name } from "../chunk-Dco9itRc.mjs";
+import { Argument, Command, InvalidArgumentError, InvalidOptionArgumentError, Option } from "commander";
+import { z } from "zod/v4";
+
+//#region src/zod4/utils.ts
+const zodCore = (zod, fn) => {
+	const types = [
+		z.ZodDefault,
+		z.ZodPrefault,
+		z.ZodNullable,
+		z.ZodOptional
+	];
+	for (const type of types) if (zod instanceof type) return zodCore(zod.def.innerType, fn);
+	if (zod instanceof z.ZodPipe) return zodCore(zod.def.in, fn);
+	return fn(zod);
+};
+const zodEnumVals = (zod) => zodCore(zod, (zod) => zod instanceof z.ZodEnum ? zod.options : null);
+const zodIsBoolean = (zod) => zodCore(zod, (zod) => zod instanceof z.ZodBoolean);
+const zodIsOptional = (zod) => zod.safeParse(void 0).success;
+const zodDefault = (zod) => zod instanceof z.ZodPipe ? zodDefault(zod.def.in) : zod instanceof z.ZodPrefault ? zod.def.defaultValue : void 0;
+const utils = {
+	zodCore,
+	zodEnumVals,
+	zodIsBoolean,
+	zodIsOptional,
+	zodDefault
+};
+
+//#endregion
+//#region src/zod4/index.ts
+/**
+* Utilities for building type-safe Commander commands using Zod schemas.
+* @module
+*/
+const zodParser = (zod, opt) => (value) => {
+	const result = zod.safeParse(value);
+	if (result.success) return result.data;
+	const msg = result.error.issues[0].message;
+	if (opt) throw new InvalidOptionArgumentError(msg);
+	throw new InvalidArgumentError(msg);
+};
+/**
+* Creates a Commander.js Argument from a Zod schema.
+* Handles optionality, default values, and enum choices.
+* @param key - The argument name
+* @param zod - The Zod schema for the argument
+* @returns A Commander Argument instance
+*/
+const zodArgument = (key, zod) => {
+	const arg = new Argument(utils.zodIsOptional(zod) ? `[${key}]` : `<${key}>`, zod.description);
+	const def = utils.zodDefault(zod);
+	if (def !== void 0) arg.default(zod.parse(def));
+	const choices = utils.zodEnumVals(zod)?.map(String);
+	if (choices) arg.choices(choices);
+	return arg.argParser(zodParser(zod));
+};
+/**
+* Creates a Commander.js Option from a Zod schema.
+* Handles optionality, default values, enum choices, and boolean flags.
+* Supports short flags via description prefix (e.g., 's;...').
+* @param key - The option name (can include underscores for grouping)
+* @param zod - The Zod schema for the option
+* @returns A Commander Option instance
+*/
+const zodOption = (key, zod) => {
+	const abbr = zod.description?.match(/^(\w);/)?.[1];
+	const description = abbr ? zod.description?.slice(2) : zod.description;
+	const arg = key.includes("_") ? key.split("_").slice(1).join("-") : key;
+	if (key.includes("_")) [key] = key.split("_");
+	const isBoolean = utils.zodIsBoolean(zod);
+	const flag = `--${key}${isBoolean ? "" : ` <${arg}>`}`;
+	const opt = new Option(abbr ? `-${abbr}, ${flag}` : flag, description);
+	if (isBoolean) opt.optional = true;
+	else if (!utils.zodIsOptional(zod)) opt.makeOptionMandatory();
+	const def = utils.zodDefault(zod);
+	if (def !== void 0) opt.default(zod.parse(def));
+	const choices = utils.zodEnumVals(zod)?.map(String);
+	if (choices) opt.choices(choices);
+	return opt.argParser(zodParser(zod, "opt"));
+};
+/**
+* Defines a Commander.js Command using Zod schemas for arguments and options.
+* Automatically wires up parsing, validation, and help configuration.
+* @template A - Record of key-value pairs where key is the argument name and value is the Zod schema
+* @template O - Record of key-value pairs where key is the option name and value is the Zod schema
+* @param props - Command properties (name, description, args, opts, action)
+* @returns A Commander Command instance
+*/
+const zodCommand = ({ name, description, args, opts, action }) => {
+	const command = new Command(name);
+	if (description) command.description(description);
+	for (const key in args) command.addArgument(zodArgument(key, args[key]));
+	for (const key in opts) command.addOption(zodOption(key, opts[key]));
+	if (action) command.action(async (...all) => {
+		const resultArgs = Object.fromEntries(Object.keys(args ?? {}).map((key, i) => [key, all[i]]));
+		const resultOpts = all[Object.keys(args ?? {}).length];
+		await action(resultArgs, resultOpts);
+	});
+	return command;
+};
+
+//#endregion
+export { zodArgument, zodCommand, zodOption };
+//# sourceMappingURL=index.mjs.map

package/dist/zod4/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/zod4/utils.ts","../../src/zod4/index.ts"],"sourcesContent":["import { z } from 'zod/v4'\n\nconst zodCore = <T>(\n\tzod: z.core.$ZodType,\n\tfn: (zod: z.core.$ZodType) => T,\n): T => {\n\tconst types = [z.ZodDefault, z.ZodPrefault, z.ZodNullable, z.ZodOptional]\n\tfor (const type of types)\n\t\tif (zod instanceof type) return zodCore(zod.def.innerType, fn)\n\tif (zod instanceof z.ZodPipe) return zodCore(zod.def.in, fn)\n\treturn fn(zod)\n}\n\nconst zodEnumVals = (zod: z.ZodTypeAny): z.core.util.EnumValue[] | null =>\n\tzodCore(zod, (zod) => (zod instanceof z.ZodEnum ? zod.options : null))\n\nconst zodIsBoolean = (zod: z.ZodTypeAny): boolean =>\n\tzodCore(zod, (zod) => zod instanceof z.ZodBoolean)\n\nconst zodIsOptional = (zod: z.ZodType): boolean =>\n\tzod.safeParse(undefined).success\n\nconst zodDefault = <Output, Input>(\n\tzod: z.ZodType<Output, Input>,\n): Input | undefined =>\n\tzod instanceof z.ZodPipe\n\t\t? zodDefault(zod.def.in as z.ZodType<unknown, Input>)\n\t\t: zod instanceof z.ZodPrefault\n\t\t\t? (zod.def.defaultValue as Input)\n\t\t\t: undefined\n\nconst utils = {\n\tzodCore,\n\tzodEnumVals,\n\tzodIsBoolean,\n\tzodIsOptional,\n\tzodDefault,\n}\n\nexport default utils\n","/**\n * Utilities for building type-safe Commander commands using Zod schemas.\n * @module\n */\n\nimport {\n\tArgument,\n\tCommand,\n\tInvalidArgumentError,\n\tInvalidOptionArgumentError,\n\tOption,\n} from 'commander'\nimport type { z } from 'zod/v4'\nimport type { BeforeFirstUnderscore, Prettify } from '#/common.js'\nimport utils from './utils.js'\n\nexport type { Argument, Command, Option } from 'commander'\n\ntype ReplaceKeyTypes<Type extends z.ZodRawShape> = {\n\t[Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key]\n}\n\n/**\n * The action function signature for a Zod-powered command.\n * @template A - Record of key-value pairs where key is the argument name and value is the Zod schema\n * @template O - Record of key-value pairs where key is the option name and value is the Zod schema\n * @param args - Parsed and validated arguments\n * @param opts - Parsed and validated options (with key normalization)\n * @returns A Promise or void\n */\nexport type ZodCommandAction<\n\tA extends Record<string, z.ZodType>,\n\tO extends Record<string, z.ZodType>,\n> = ZodCommandProps<A, O>['action']\n\ntype ZodCommandProps<\n\tA extends Record<string, z.ZodType>,\n\tO extends Record<string, z.ZodType>,\n> = {\n\tname?: string\n\tdescription?: string\n\targs?: A\n\topts?: O\n\taction?: (\n\t\targs: Prettify<z.infer<z.ZodObject<A>>>,\n\t\topts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>,\n\t) => Promise<void> | void\n}\n\nconst zodParser = (zod: z.ZodType, opt?: 'opt') => (value: string) => {\n\tconst result = zod.safeParse(value)\n\tif (result.success) return result.data\n\tconst msg = result.error.issues[0].message\n\tif (opt) throw new InvalidOptionArgumentError(msg)\n\tthrow new InvalidArgumentError(msg)\n}\n\n/**\n * Creates a Commander.js Argument from a Zod schema.\n * Handles optionality, default values, and enum choices.\n * @param key - The argument name\n * @param zod - The Zod schema for the argument\n * @returns A Commander Argument instance\n */\nexport const zodArgument = (key: string, zod: z.ZodType): Argument => {\n\tconst flag = utils.zodIsOptional(zod) ? `[${key}]` : `<${key}>`\n\tconst arg = new Argument(flag, zod.description)\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) arg.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)?.map(String)\n\tif (choices) arg.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn arg.argParser(zodParser(zod))\n}\n\n/**\n * Creates a Commander.js Option from a Zod schema.\n * Handles optionality, default values, enum choices, and boolean flags.\n * Supports short flags via description prefix (e.g., 's;...').\n * @param key - The option name (can include underscores for grouping)\n * @param zod - The Zod schema for the option\n * @returns A Commander Option instance\n */\nexport const zodOption = (key: string, zod: z.ZodType): Option => {\n\tconst abbr = zod.description?.match(/^(\\w);/)?.[1]\n\tconst description = abbr ? zod.description?.slice(2) : zod.description\n\tconst arg = key.includes('_') ? key.split('_').slice(1).join('-') : key\n\tif (key.includes('_')) [key] = key.split('_')\n\tconst isBoolean = utils.zodIsBoolean(zod)\n\tconst flag = `--${key}${isBoolean ? '' : ` <${arg}>`}`\n\tconst flags = abbr ? `-${abbr}, ${flag}` : flag\n\tconst opt = new Option(flags, description)\n\n\t// required for boolean flags\n\tif (isBoolean) opt.optional = true\n\telse if (!utils.zodIsOptional(zod)) opt.makeOptionMandatory()\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) opt.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)?.map(String)\n\tif (choices) opt.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn opt.argParser(zodParser(zod, 'opt'))\n}\n\n/**\n * Defines a Commander.js Command using Zod schemas for arguments and options.\n * Automatically wires up parsing, validation, and help configuration.\n * @template A - Record of key-value pairs where key is the argument name and value is the Zod schema\n * @template O - Record of key-value pairs where key is the option name and value is the Zod schema\n * @param props - Command properties (name, description, args, opts, action)\n * @returns A Commander Command instance\n */\nexport const zodCommand = <\n\tA extends Record<string, z.ZodType>,\n\tO extends Record<string, z.ZodType>,\n>({\n\tname,\n\tdescription,\n\targs,\n\topts,\n\taction,\n}: ZodCommandProps<A, O>): Command => {\n\tconst command = new Command(name)\n\tif (description) command.description(description)\n\tfor (const key in args) command.addArgument(zodArgument(key, args[key]))\n\tfor (const key in opts) command.addOption(zodOption(key, opts[key]))\n\tif (action)\n\t\tcommand.action(async (...all) => {\n\t\t\tconst resultArgs = Object.fromEntries(\n\t\t\t\tObject.keys(args ?? {}).map((key, i) => [key, all[i]]),\n\t\t\t) as z.infer<z.ZodObject<A>>\n\t\t\tconst resultOpts = all[Object.keys(args ?? {}).length] as z.infer<\n\t\t\t\tz.ZodObject<ReplaceKeyTypes<O>>\n\t\t\t>\n\t\t\tawait action(resultArgs, resultOpts)\n\t\t})\n\treturn command\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-commander",
-  "version": "0.0.5",
+  "version": "0.1.1",
   "description": "A TypeScript utility for building type-safe CLI commands using commander and zod.",
   "author": "Román Via-Dufresne Saus <roman910dev@gmail.com>(https://github.com/roman910dev)",
   "license": "MIT",
@@ -15,49 +15,62 @@
     "typescript"
   ],
   "devDependencies": {
-    "@biomejs/biome": "^2.0.6",
+    "@biomejs/biome": "^2.4.12",
     "@types/node": "^22.16.3",
-    "commander": "^14.0.0",
+    "commander": "^14.0.3",
     "husky": "^9.1.7",
-    "tsup": "^8.5.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.2.4",
-    "zod": "^3.25.0"
+    "tsdown": "^0.21.9",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4",
+    "zod": "^4.3.6"
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.js"
+      "types": "./dist/zod3/index.d.ts",
+      "import": "./dist/zod3/index.js",
+      "require": "./dist/zod3/index.cjs",
+      "default": "./dist/zod3/index.js"
+    },
+    "./zod3": {
+      "types": "./dist/zod3/index.d.ts",
+      "import": "./dist/zod3/index.js",
+      "require": "./dist/zod3/index.cjs",
+      "default": "./dist/zod3/index.js"
+    },
+    "./zod4": {
+      "types": "./dist/zod4/index.d.ts",
+      "import": "./dist/zod4/index.js",
+      "require": "./dist/zod4/index.cjs",
+      "default": "./dist/zod4/index.js"
     }
   },
   "files": [
     "dist/"
   ],
   "imports": {
-    "#/*": "./src/*"
+    "#/*": "./src/*",
+    "#tests/*": "./tests/*"
   },
   "publishConfig": {
     "access": "public"
   },
   "peerDependencies": {
     "commander": ">=8 <15",
-    "zod": ">=3.20.0 <4"
+    "zod": ">=3.20.0 <5"
   },
   "type": "module",
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "check": "biome check .",
     "fix": "biome check . --write",
     "format": "biome format . --write",
     "full-check": "pnpm ts && pnpm check",
     "lint": "biome lint .",
     "ci": "biome ci --threads=4",
-    "test": "vitest",
+    "test": "vitest run",
     "ts": "tsc --noEmit"
   }
 }

package/dist/index.cjs

@@ -1,86 +0,0 @@
-'use strict';
-
-var commander = require('commander');
-var zod = require('zod');
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var zodCore = /* @__PURE__ */ __name((zod$1, fn) => {
-  const types = [zod.z.ZodDefault, zod.z.ZodNullable, zod.z.ZodOptional];
-  for (const type of types)
-    if (zod$1 instanceof type) return zodCore(zod$1._def.innerType, fn);
-  if (zod$1 instanceof zod.z.ZodEffects) return zodCore(zod$1._def.schema, fn);
-  return fn(zod$1);
-}, "zodCore");
-var zodEnumVals = /* @__PURE__ */ __name((zod$1) => zodCore(zod$1, (zod2) => zod2 instanceof zod.z.ZodEnum ? zod2._def.values : null), "zodEnumVals");
-var zodIsBoolean = /* @__PURE__ */ __name((zod$1) => zodCore(zod$1, (zod2) => zod2 instanceof zod.z.ZodBoolean), "zodIsBoolean");
-var zodDefault = /* @__PURE__ */ __name((zod$1) => zod$1 instanceof zod.z.ZodEffects ? zodDefault(zod$1._def.schema) : zod$1 instanceof zod.z.ZodDefault ? zod$1._def.defaultValue() : void 0, "zodDefault");
-var utils = {
-  zodCore,
-  zodEnumVals,
-  zodIsBoolean,
-  zodDefault
-};
-var utils_default = utils;
-
-// src/index.ts
-var zodParser = /* @__PURE__ */ __name((zod, opt) => (value) => {
-  const result = zod.safeParse(value);
-  if (result.success) return result.data;
-  const msg = result.error.issues[0].message;
-  if (opt) throw new commander.InvalidOptionArgumentError(msg);
-  throw new commander.InvalidArgumentError(msg);
-}, "zodParser");
-var zodArgument = /* @__PURE__ */ __name((key, zod) => {
-  const flag = zod.isOptional() ? `[${key}]` : `<${key}>`;
-  const arg = new commander.Argument(flag, zod.description);
-  const def = utils_default.zodDefault(zod);
-  if (def !== void 0) arg.default(zod.parse(def));
-  const choices = utils_default.zodEnumVals(zod);
-  if (choices) arg.choices(choices);
-  return arg.argParser(zodParser(zod));
-}, "zodArgument");
-var zodOption = /* @__PURE__ */ __name((key, zod) => {
-  const abbr = zod.description?.match(/^(\w);/)?.[1];
-  const description = abbr ? zod.description.slice(2) : zod.description;
-  const arg = key.includes("_") ? key.split("_").slice(1).join("-") : key;
-  if (key.includes("_")) [key] = key.split("_");
-  const isBoolean = utils_default.zodIsBoolean(zod);
-  const flag = `--${key}${isBoolean ? "" : ` <${arg}>`}`;
-  const flags = abbr ? `-${abbr}, ${flag}` : flag;
-  const opt = new commander.Option(flags, description);
-  if (isBoolean) opt.optional = true;
-  else if (!zod.isOptional()) opt.makeOptionMandatory();
-  const def = utils_default.zodDefault(zod);
-  if (def !== void 0) opt.default(zod.parse(def));
-  const choices = utils_default.zodEnumVals(zod);
-  if (choices) opt.choices(choices);
-  return opt.argParser(zodParser(zod, "opt"));
-}, "zodOption");
-var zodCommand = /* @__PURE__ */ __name(({
-  name,
-  description,
-  args,
-  opts,
-  action
-}) => {
-  const command = new commander.Command(name);
-  if (description) command.description(description);
-  for (const key in args) command.addArgument(zodArgument(key, args[key]));
-  for (const key in opts) command.addOption(zodOption(key, opts[key]));
-  if (action)
-    command.action(async (...all) => {
-      const resultArgs = Object.fromEntries(
-        Object.keys(args ?? {}).map((key, i) => [key, all[i]])
-      );
-      const resultOpts = all[Object.keys(args ?? {}).length];
-      await action(resultArgs, resultOpts);
-    });
-  return command;
-}, "zodCommand");
-
-exports.zodArgument = zodArgument;
-exports.zodCommand = zodCommand;
-exports.zodOption = zodOption;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils.ts","../src/index.ts"],"names":["zod","z","InvalidOptionArgumentError","InvalidArgumentError","Argument","Option","Command"],"mappings":"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","file":"index.cjs","sourcesContent":["import { z } from 'zod'\n\nconst zodCore = <T>(zod: z.ZodTypeAny, fn: (zod: z.ZodTypeAny) => T): T => {\n\tconst types = [z.ZodDefault, z.ZodNullable, z.ZodOptional]\n\tfor (const type of types)\n\t\tif (zod instanceof type) return zodCore(zod._def.innerType, fn)\n\tif (zod instanceof z.ZodEffects) return zodCore(zod._def.schema, fn)\n\treturn fn(zod)\n}\n\nconst zodEnumVals = (zod: z.ZodTypeAny): string[] | null =>\n\tzodCore(zod, (zod) => (zod instanceof z.ZodEnum ? zod._def.values : null))\n\nconst zodIsBoolean = (zod: z.ZodTypeAny): boolean =>\n\tzodCore(zod, (zod) => zod instanceof z.ZodBoolean)\n\nconst zodDefault = <Output, Def extends z.ZodTypeDef, Input>(\n\tzod: z.ZodType<Output, Def, Input>,\n): Input | undefined =>\n\tzod instanceof z.ZodEffects\n\t\t? zodDefault(zod._def.schema)\n\t\t: zod instanceof z.ZodDefault\n\t\t\t? zod._def.defaultValue()\n\t\t\t: undefined\n\nconst utils = {\n\tzodCore,\n\tzodEnumVals,\n\tzodIsBoolean,\n\tzodDefault,\n}\n\nexport default utils\n","import {\n\tArgument,\n\tCommand,\n\tInvalidArgumentError,\n\tInvalidOptionArgumentError,\n\tOption,\n} from 'commander'\nimport type { z } from 'zod'\nimport utils from './utils.js'\n\ntype BeforeFirstUnderscore<S> = S extends `${infer T}_${infer _}` ? T : S\n\ntype ReplaceKeyTypes<Type extends z.ZodRawShape> = {\n\t[Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key]\n}\n\ntype Prettify<T> = {\n\t[K in keyof T]: T[K]\n} & {}\n\n/**\n * The action function signature for a Zod-powered command.\n * @template A - ZodRawShape for arguments\n * @template O - ZodRawShape for options\n * @param args - Parsed and validated arguments\n * @param opts - Parsed and validated options (with key normalization)\n * @returns A Promise or void\n */\nexport type ZodCommandAction<\n\tA extends z.ZodRawShape,\n\tO extends z.ZodRawShape,\n> = ZodCommandProps<A, O>['action']\n\ntype ZodCommandProps<A extends z.ZodRawShape, O extends z.ZodRawShape> = {\n\tname?: string\n\tdescription?: string\n\targs?: A\n\topts?: O\n\taction?: (\n\t\targs: Prettify<z.infer<z.ZodObject<A>>>,\n\t\topts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>,\n\t) => Promise<void> | void\n}\n\nconst zodParser = (zod: z.ZodTypeAny, opt?: 'opt') => (value: string) => {\n\tconst result = zod.safeParse(value)\n\tif (result.success) return result.data\n\tconst msg = result.error.issues[0].message\n\tif (opt) throw new InvalidOptionArgumentError(msg)\n\tthrow new InvalidArgumentError(msg)\n}\n\n/**\n * Creates a Commander.js Argument from a Zod schema.\n * Handles optionality, default values, and enum choices.\n * @param key - The argument name\n * @param zod - The Zod schema for the argument\n * @returns A Commander Argument instance\n */\nexport const zodArgument = (key: string, zod: z.ZodTypeAny): Argument => {\n\tconst flag = zod.isOptional() ? `[${key}]` : `<${key}>`\n\tconst arg = new Argument(flag, zod.description)\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) arg.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)\n\tif (choices) arg.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn arg.argParser(zodParser(zod))\n}\n\n/**\n * Creates a Commander.js Option from a Zod schema.\n * Handles optionality, default values, enum choices, and boolean flags.\n * Supports short flags via description prefix (e.g., 's;...').\n * @param key - The option name (can include underscores for grouping)\n * @param zod - The Zod schema for the option\n * @returns A Commander Option instance\n */\nexport const zodOption = (key: string, zod: z.ZodTypeAny): Option => {\n\tconst abbr = zod.description?.match(/^(\\w);/)?.[1]\n\tconst description = abbr ? zod.description.slice(2) : zod.description\n\tconst arg = key.includes('_') ? key.split('_').slice(1).join('-') : key\n\tif (key.includes('_')) [key] = key.split('_')\n\tconst isBoolean = utils.zodIsBoolean(zod)\n\tconst flag = `--${key}${isBoolean ? '' : ` <${arg}>`}`\n\tconst flags = abbr ? `-${abbr}, ${flag}` : flag\n\tconst opt = new Option(flags, description)\n\n\t// required for boolean flags\n\tif (isBoolean) opt.optional = true\n\telse if (!zod.isOptional()) opt.makeOptionMandatory()\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) opt.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)\n\tif (choices) opt.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn opt.argParser(zodParser(zod, 'opt'))\n}\n\n/**\n * Defines a Commander.js Command using Zod schemas for arguments and options.\n * Automatically wires up parsing, validation, and help configuration.\n * @template A - ZodRawShape for arguments\n * @template O - ZodRawShape for options\n * @param props - Command properties (name, description, args, opts, action)\n * @returns A Commander Command instance\n */\nexport const zodCommand = <A extends z.ZodRawShape, O extends z.ZodRawShape>({\n\tname,\n\tdescription,\n\targs,\n\topts,\n\taction,\n}: ZodCommandProps<A, O>): Command => {\n\tconst command = new Command(name)\n\tif (description) command.description(description)\n\tfor (const key in args) command.addArgument(zodArgument(key, args[key]))\n\tfor (const key in opts) command.addOption(zodOption(key, opts[key]))\n\tif (action)\n\t\tcommand.action(async (...all) => {\n\t\t\tconst resultArgs = Object.fromEntries(\n\t\t\t\tObject.keys(args ?? {}).map((key, i) => [key, all[i]]),\n\t\t\t) as z.infer<z.ZodObject<A>>\n\t\t\tconst resultOpts = all[Object.keys(args ?? {}).length] as z.infer<\n\t\t\t\tz.ZodObject<ReplaceKeyTypes<O>>\n\t\t\t>\n\t\t\tawait action(resultArgs, resultOpts)\n\t\t})\n\treturn command\n}\n"]}

package/dist/index.js

@@ -1,82 +0,0 @@
-import { Argument, Option, Command, InvalidOptionArgumentError, InvalidArgumentError } from 'commander';
-import { z } from 'zod';
-
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var zodCore = /* @__PURE__ */ __name((zod, fn) => {
-  const types = [z.ZodDefault, z.ZodNullable, z.ZodOptional];
-  for (const type of types)
-    if (zod instanceof type) return zodCore(zod._def.innerType, fn);
-  if (zod instanceof z.ZodEffects) return zodCore(zod._def.schema, fn);
-  return fn(zod);
-}, "zodCore");
-var zodEnumVals = /* @__PURE__ */ __name((zod) => zodCore(zod, (zod2) => zod2 instanceof z.ZodEnum ? zod2._def.values : null), "zodEnumVals");
-var zodIsBoolean = /* @__PURE__ */ __name((zod) => zodCore(zod, (zod2) => zod2 instanceof z.ZodBoolean), "zodIsBoolean");
-var zodDefault = /* @__PURE__ */ __name((zod) => zod instanceof z.ZodEffects ? zodDefault(zod._def.schema) : zod instanceof z.ZodDefault ? zod._def.defaultValue() : void 0, "zodDefault");
-var utils = {
-  zodCore,
-  zodEnumVals,
-  zodIsBoolean,
-  zodDefault
-};
-var utils_default = utils;
-
-// src/index.ts
-var zodParser = /* @__PURE__ */ __name((zod, opt) => (value) => {
-  const result = zod.safeParse(value);
-  if (result.success) return result.data;
-  const msg = result.error.issues[0].message;
-  if (opt) throw new InvalidOptionArgumentError(msg);
-  throw new InvalidArgumentError(msg);
-}, "zodParser");
-var zodArgument = /* @__PURE__ */ __name((key, zod) => {
-  const flag = zod.isOptional() ? `[${key}]` : `<${key}>`;
-  const arg = new Argument(flag, zod.description);
-  const def = utils_default.zodDefault(zod);
-  if (def !== void 0) arg.default(zod.parse(def));
-  const choices = utils_default.zodEnumVals(zod);
-  if (choices) arg.choices(choices);
-  return arg.argParser(zodParser(zod));
-}, "zodArgument");
-var zodOption = /* @__PURE__ */ __name((key, zod) => {
-  const abbr = zod.description?.match(/^(\w);/)?.[1];
-  const description = abbr ? zod.description.slice(2) : zod.description;
-  const arg = key.includes("_") ? key.split("_").slice(1).join("-") : key;
-  if (key.includes("_")) [key] = key.split("_");
-  const isBoolean = utils_default.zodIsBoolean(zod);
-  const flag = `--${key}${isBoolean ? "" : ` <${arg}>`}`;
-  const flags = abbr ? `-${abbr}, ${flag}` : flag;
-  const opt = new Option(flags, description);
-  if (isBoolean) opt.optional = true;
-  else if (!zod.isOptional()) opt.makeOptionMandatory();
-  const def = utils_default.zodDefault(zod);
-  if (def !== void 0) opt.default(zod.parse(def));
-  const choices = utils_default.zodEnumVals(zod);
-  if (choices) opt.choices(choices);
-  return opt.argParser(zodParser(zod, "opt"));
-}, "zodOption");
-var zodCommand = /* @__PURE__ */ __name(({
-  name,
-  description,
-  args,
-  opts,
-  action
-}) => {
-  const command = new Command(name);
-  if (description) command.description(description);
-  for (const key in args) command.addArgument(zodArgument(key, args[key]));
-  for (const key in opts) command.addOption(zodOption(key, opts[key]));
-  if (action)
-    command.action(async (...all) => {
-      const resultArgs = Object.fromEntries(
-        Object.keys(args ?? {}).map((key, i) => [key, all[i]])
-      );
-      const resultOpts = all[Object.keys(args ?? {}).length];
-      await action(resultArgs, resultOpts);
-    });
-  return command;
-}, "zodCommand");
-
-export { zodArgument, zodCommand, zodOption };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils.ts","../src/index.ts"],"names":["zod"],"mappings":"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","file":"index.js","sourcesContent":["import { z } from 'zod'\n\nconst zodCore = <T>(zod: z.ZodTypeAny, fn: (zod: z.ZodTypeAny) => T): T => {\n\tconst types = [z.ZodDefault, z.ZodNullable, z.ZodOptional]\n\tfor (const type of types)\n\t\tif (zod instanceof type) return zodCore(zod._def.innerType, fn)\n\tif (zod instanceof z.ZodEffects) return zodCore(zod._def.schema, fn)\n\treturn fn(zod)\n}\n\nconst zodEnumVals = (zod: z.ZodTypeAny): string[] | null =>\n\tzodCore(zod, (zod) => (zod instanceof z.ZodEnum ? zod._def.values : null))\n\nconst zodIsBoolean = (zod: z.ZodTypeAny): boolean =>\n\tzodCore(zod, (zod) => zod instanceof z.ZodBoolean)\n\nconst zodDefault = <Output, Def extends z.ZodTypeDef, Input>(\n\tzod: z.ZodType<Output, Def, Input>,\n): Input | undefined =>\n\tzod instanceof z.ZodEffects\n\t\t? zodDefault(zod._def.schema)\n\t\t: zod instanceof z.ZodDefault\n\t\t\t? zod._def.defaultValue()\n\t\t\t: undefined\n\nconst utils = {\n\tzodCore,\n\tzodEnumVals,\n\tzodIsBoolean,\n\tzodDefault,\n}\n\nexport default utils\n","import {\n\tArgument,\n\tCommand,\n\tInvalidArgumentError,\n\tInvalidOptionArgumentError,\n\tOption,\n} from 'commander'\nimport type { z } from 'zod'\nimport utils from './utils.js'\n\ntype BeforeFirstUnderscore<S> = S extends `${infer T}_${infer _}` ? T : S\n\ntype ReplaceKeyTypes<Type extends z.ZodRawShape> = {\n\t[Key in keyof Type as BeforeFirstUnderscore<Key>]: Type[Key]\n}\n\ntype Prettify<T> = {\n\t[K in keyof T]: T[K]\n} & {}\n\n/**\n * The action function signature for a Zod-powered command.\n * @template A - ZodRawShape for arguments\n * @template O - ZodRawShape for options\n * @param args - Parsed and validated arguments\n * @param opts - Parsed and validated options (with key normalization)\n * @returns A Promise or void\n */\nexport type ZodCommandAction<\n\tA extends z.ZodRawShape,\n\tO extends z.ZodRawShape,\n> = ZodCommandProps<A, O>['action']\n\ntype ZodCommandProps<A extends z.ZodRawShape, O extends z.ZodRawShape> = {\n\tname?: string\n\tdescription?: string\n\targs?: A\n\topts?: O\n\taction?: (\n\t\targs: Prettify<z.infer<z.ZodObject<A>>>,\n\t\topts: Prettify<z.infer<z.ZodObject<ReplaceKeyTypes<O>>>>,\n\t) => Promise<void> | void\n}\n\nconst zodParser = (zod: z.ZodTypeAny, opt?: 'opt') => (value: string) => {\n\tconst result = zod.safeParse(value)\n\tif (result.success) return result.data\n\tconst msg = result.error.issues[0].message\n\tif (opt) throw new InvalidOptionArgumentError(msg)\n\tthrow new InvalidArgumentError(msg)\n}\n\n/**\n * Creates a Commander.js Argument from a Zod schema.\n * Handles optionality, default values, and enum choices.\n * @param key - The argument name\n * @param zod - The Zod schema for the argument\n * @returns A Commander Argument instance\n */\nexport const zodArgument = (key: string, zod: z.ZodTypeAny): Argument => {\n\tconst flag = zod.isOptional() ? `[${key}]` : `<${key}>`\n\tconst arg = new Argument(flag, zod.description)\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) arg.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)\n\tif (choices) arg.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn arg.argParser(zodParser(zod))\n}\n\n/**\n * Creates a Commander.js Option from a Zod schema.\n * Handles optionality, default values, enum choices, and boolean flags.\n * Supports short flags via description prefix (e.g., 's;...').\n * @param key - The option name (can include underscores for grouping)\n * @param zod - The Zod schema for the option\n * @returns A Commander Option instance\n */\nexport const zodOption = (key: string, zod: z.ZodTypeAny): Option => {\n\tconst abbr = zod.description?.match(/^(\\w);/)?.[1]\n\tconst description = abbr ? zod.description.slice(2) : zod.description\n\tconst arg = key.includes('_') ? key.split('_').slice(1).join('-') : key\n\tif (key.includes('_')) [key] = key.split('_')\n\tconst isBoolean = utils.zodIsBoolean(zod)\n\tconst flag = `--${key}${isBoolean ? '' : ` <${arg}>`}`\n\tconst flags = abbr ? `-${abbr}, ${flag}` : flag\n\tconst opt = new Option(flags, description)\n\n\t// required for boolean flags\n\tif (isBoolean) opt.optional = true\n\telse if (!zod.isOptional()) opt.makeOptionMandatory()\n\n\tconst def = utils.zodDefault(zod)\n\tif (def !== undefined) opt.default(zod.parse(def))\n\n\tconst choices = utils.zodEnumVals(zod)\n\tif (choices) opt.choices(choices)\n\n\t// parsing must be done at the end to override default parsers\n\treturn opt.argParser(zodParser(zod, 'opt'))\n}\n\n/**\n * Defines a Commander.js Command using Zod schemas for arguments and options.\n * Automatically wires up parsing, validation, and help configuration.\n * @template A - ZodRawShape for arguments\n * @template O - ZodRawShape for options\n * @param props - Command properties (name, description, args, opts, action)\n * @returns A Commander Command instance\n */\nexport const zodCommand = <A extends z.ZodRawShape, O extends z.ZodRawShape>({\n\tname,\n\tdescription,\n\targs,\n\topts,\n\taction,\n}: ZodCommandProps<A, O>): Command => {\n\tconst command = new Command(name)\n\tif (description) command.description(description)\n\tfor (const key in args) command.addArgument(zodArgument(key, args[key]))\n\tfor (const key in opts) command.addOption(zodOption(key, opts[key]))\n\tif (action)\n\t\tcommand.action(async (...all) => {\n\t\t\tconst resultArgs = Object.fromEntries(\n\t\t\t\tObject.keys(args ?? {}).map((key, i) => [key, all[i]]),\n\t\t\t) as z.infer<z.ZodObject<A>>\n\t\t\tconst resultOpts = all[Object.keys(args ?? {}).length] as z.infer<\n\t\t\t\tz.ZodObject<ReplaceKeyTypes<O>>\n\t\t\t>\n\t\t\tawait action(resultArgs, resultOpts)\n\t\t})\n\treturn command\n}\n"]}