zod-args-parser 2.0.0-alpha.0 → 2.0.0-beta.1

package/src/coerce/coerce-methods.ts

@@ -0,0 +1,75 @@
+import { stringToBooleanArray, stringToNumberArray, stringToStringArray } from "./string-to-array.ts";
+import { stringToBoolean, stringToNumber } from "./string-to-primitive.ts";
+import { stringToBooleanSet, stringToNumberSet, stringToStringSet } from "./string-to-set.ts";
+
+import type { CoerceMethod } from "../types/types.ts";
+
+const string: CoerceMethod<string> = terminalInput => terminalInput;
+string.type = "string";
+
+const boolean: CoerceMethod<boolean> = terminalInput => stringToBoolean(terminalInput);
+boolean.type = "boolean";
+
+const number: CoerceMethod<number> = terminalInput => stringToNumber(terminalInput);
+number.type = "number";
+
+const json = <T>(reviver?: (this: any, key: string, value: any) => any): CoerceMethod<T> => {
+  const coerceMethod: CoerceMethod<T> = terminalInput => JSON.parse(terminalInput, reviver) as T;
+  coerceMethod.type = "unknown";
+  return coerceMethod;
+};
+
+const stringArray = (separator: string): CoerceMethod<string[]> => {
+  const coerceMethod: CoerceMethod<string[]> = terminalInput => stringToStringArray(terminalInput, separator);
+  coerceMethod.type = "string[]";
+  return coerceMethod;
+};
+
+const numberArray = (separator: string) => {
+  const coerceMethod: CoerceMethod<number[]> = terminalInput => stringToNumberArray(terminalInput, separator);
+  coerceMethod.type = "number[]";
+  return coerceMethod;
+};
+
+const booleanArray = (separator: string) => {
+  const coerceMethod: CoerceMethod<boolean[]> = terminalInput => stringToBooleanArray(terminalInput, separator);
+  coerceMethod.type = "boolean[]";
+  return coerceMethod;
+};
+
+const stringSet = (separator: string) => {
+  const coerceMethod: CoerceMethod<Set<string>> = terminalInput => stringToStringSet(terminalInput, separator);
+  coerceMethod.type = "set<string>";
+  return coerceMethod;
+};
+
+const numberSet = (separator: string) => {
+  const coerceMethod: CoerceMethod<Set<number>> = terminalInput => stringToNumberSet(terminalInput, separator);
+  coerceMethod.type = "set<number>";
+  return coerceMethod;
+};
+
+const booleanSet = (separator: string) => {
+  const coerceMethod: CoerceMethod<Set<boolean>> = terminalInput => stringToBooleanSet(terminalInput, separator);
+  coerceMethod.type = "set<boolean>";
+  return coerceMethod;
+};
+
+export const coerce = {
+  string,
+  boolean,
+  number,
+  /** @param separator - The separator to use to split the string. **Default** is `","` */
+  stringArray,
+  /** @param separator - The separator to use to split the string. **Default** is `","` */
+  numberArray,
+  /** @param separator - The separator to use to split the string. **Default** is `","` */
+  booleanArray,
+  /** @param separator - The separator to use to split the string. **Default** is `","` */
+  stringSet,
+  /** @param separator - The separator to use to split the string. **Default** is `","` */
+  numberSet,
+  /** @param separator - The separator to use to split the string. **Default** is `","` */
+  booleanSet,
+  json,
+};

package/src/coerce/string-to-array.ts

@@ -0,0 +1,18 @@
+import { stringToBoolean, stringToNumber } from "./string-to-primitive.ts";
+
+export function stringToStringArray(stringValue: string, separator: string = ","): string[] {
+  return stringValue
+    .split(separator)
+    .map(s => s.trim())
+    .filter(Boolean);
+}
+
+/** @throws {TypeError} - Because of `stringToNumber` */
+export function stringToNumberArray(stringValue: string, separator: string = ","): number[] {
+  return stringToStringArray(stringValue, separator).map(element => stringToNumber(element));
+}
+
+/** @throws {TypeError} - Because of `stringToBoolean` */
+export function stringToBooleanArray(stringValue: string, separator: string = ","): boolean[] {
+  return stringToStringArray(stringValue, separator).map(element => stringToBoolean(element));
+}

package/src/coerce/string-to-primitive.ts

@@ -0,0 +1,31 @@
+/** @throws {TypeError} */
+export function stringToBoolean(string: string): boolean {
+  if (string.toLowerCase() === "true") {
+    return true;
+  }
+
+  if (string.toLowerCase() === "false") {
+    return false;
+  }
+
+  throw new TypeError(`Invalid boolean value: ${string}`);
+}
+
+/** @throws {TypeError} */
+export function stringToNumber(string: string): number {
+  const trimmed = string.trim();
+
+  // Reject empty, whitespace-only, or signs without digits
+  if (trimmed === "" || trimmed === "+" || trimmed === "-") {
+    throw new TypeError(`Invalid number: "${string}"`);
+  }
+
+  const result = Number(trimmed);
+
+  // Reject NaN, Infinity, and -Infinity
+  if (!Number.isFinite(result)) {
+    throw new TypeError(`Invalid number: "${string}"`);
+  }
+
+  return result;
+}

package/src/coerce/string-to-set.ts

@@ -0,0 +1,15 @@
+import { stringToBooleanArray, stringToNumberArray, stringToStringArray } from "./string-to-array.ts";
+
+export function stringToStringSet(stringValue: string, separator: string = ","): Set<string> {
+  return new Set(stringToStringArray(stringValue, separator));
+}
+
+/** @throws {TypeError} - Because of `stringToNumber` */
+export function stringToNumberSet(stringValue: string, separator: string = ","): Set<number> {
+  return new Set(stringToNumberArray(stringValue, separator));
+}
+
+/** @throws {TypeError} - Because of `stringToBoolean` */
+export function stringToBooleanSet(stringValue: string, separator: string = ","): Set<boolean> {
+  return new Set(stringToBooleanArray(stringValue, separator));
+}

package/src/definitions/define-arguments.ts

@@ -0,0 +1,10 @@
+import { prepareDefinitionTypes } from "../utilities.ts";
+
+import type { Argument } from "../types/definitions-types.ts";
+
+export function defineArguments<const T extends Record<string, Argument>>(arguments_: {
+  [K in keyof T]: T[K] & Argument<T[K]["schema"]>;
+}): { [K in keyof T]: Argument<T[K]["schema"]> } {
+  prepareDefinitionTypes(arguments_);
+  return arguments_;
+}

package/src/definitions/define-cli.ts

@@ -0,0 +1,105 @@
+import { generateCliHelpMessage } from "../help-message/generate-for-cli.ts";
+import { generateSubcommandHelpMessage } from "../help-message/generate-for-subcommand.ts";
+import { buildObjectContext } from "../parse/context/object-context-builder.ts";
+import { safeParse, safeParseAsync } from "../parse/safe-parse.ts";
+import { validate } from "../parse/validation/validate-context.ts";
+import { prepareDefinitionTypes } from "../utilities.ts";
+
+import type { Argument, Cli, Option, Subcommand } from "../types/definitions-types.ts";
+import type { PrintHelpOptions } from "../types/help-message-types.ts";
+import type { AttachedMethods, AttachedMethodsWide, ValidateMethods } from "../types/types.ts";
+import type { Prettify } from "../types/utilities-types.ts";
+
+type OptionsInput<T> =
+  T extends Record<string, Option> ? { [OptionName in keyof T]: Option<T[OptionName]["schema"]> } : T;
+
+type ArgumentsInput<T> =
+  T extends Record<string, Argument> ? { [ArgumentName in keyof T]: Argument<T[ArgumentName]["schema"]> } : T;
+
+type SubcommandsInput<T extends readonly [Subcommand, ...Subcommand[]]> = {
+  [SubcommandIndex in keyof T]: {
+    [K in keyof T[SubcommandIndex]]: T[SubcommandIndex][K] extends Record<string, Option>
+      ? OptionsInput<T[SubcommandIndex][K]>
+      : T[SubcommandIndex][K] extends Record<string, Argument>
+        ? ArgumentsInput<T[SubcommandIndex][K]>
+        : T[SubcommandIndex][K];
+  } & Subcommand;
+};
+
+// This will prevent extra keys and enable jsdoc on hover
+type CliInput<T extends Cli> = {
+  [K in keyof T]: K extends keyof Cli
+    ? T[K] extends readonly [Subcommand, ...Subcommand[]]
+      ? SubcommandsInput<T[K]>
+      : K extends "options"
+        ? OptionsInput<T[K]>
+        : K extends "arguments"
+          ? ArgumentsInput<T[K]>
+          : T[K]
+    : never;
+};
+
+export function defineCLI<T extends Cli>(input: CliInput<T> & Cli) {
+  const cliSchema = input as Prettify<T & AttachedMethods<T> & ValidateMethods<T>>;
+
+  prepareDefinitionTypes(cliSchema.options);
+  prepareDefinitionTypes(cliSchema.arguments);
+
+  if (cliSchema.subcommands) {
+    for (const subcommand of Object.values(cliSchema.subcommands)) {
+      prepareDefinitionTypes(subcommand.options);
+      prepareDefinitionTypes(subcommand.arguments);
+    }
+  }
+
+  const onExecute = (handler: (Cli["_onExecute"] & {})[number]) => {
+    cliSchema._onExecute ??= [];
+    cliSchema._onExecute.push(handler);
+
+    return () => {
+      const handlerIndex = cliSchema._onExecute?.indexOf(handler);
+      if (!handlerIndex || handlerIndex < 0) return;
+      cliSchema._onExecute?.splice(handlerIndex, 1);
+    };
+  };
+
+  const execute: AttachedMethodsWide["execute"] = inputValues => {
+    inputValues ??= {};
+    if (!cliSchema._onExecute) throw new Error("Action is not defined");
+    const context = buildObjectContext(inputValues, cliSchema);
+    const validateResult = validate(context, cliSchema);
+
+    if (cliSchema._onExecute) {
+      for (const handler of cliSchema._onExecute) {
+        handler(validateResult);
+      }
+    }
+  };
+
+  // Add print methods for CLI schema and its subcommands
+  const generateHelpMethods: Pick<AttachedMethodsWide, "generateCliHelpMessage" | "generateSubcommandHelpMessage"> = {
+    generateCliHelpMessage(options?: PrintHelpOptions) {
+      return generateCliHelpMessage(cliSchema, options);
+    },
+    generateSubcommandHelpMessage(subcommandName: string, options?: PrintHelpOptions) {
+      const foundSubcommand = cliSchema.subcommands?.find(s => s.name === subcommandName);
+      if (!foundSubcommand) throw new Error(`Subcommand ${subcommandName} not found`);
+      return generateSubcommandHelpMessage(foundSubcommand, options, cliSchema.cliName);
+    },
+  };
+
+  Object.assign(cliSchema, generateHelpMethods);
+
+  if (cliSchema.subcommands) {
+    for (const subcommandSchema of cliSchema.subcommands) {
+      Object.assign(subcommandSchema, generateHelpMethods);
+    }
+  }
+
+  return Object.assign(cliSchema, {
+    execute,
+    onExecute,
+    run: (stringOrArgv: string | string[]) => safeParse(stringOrArgv, cliSchema),
+    runAsync: (stringOrArgv: string | string[]) => safeParseAsync(stringOrArgv, cliSchema),
+  });
+}

package/src/definitions/define-options.ts

@@ -0,0 +1,12 @@
+import { prepareDefinitionTypes } from "../utilities.ts";
+
+import type { Option } from "../types/definitions-types.ts";
+
+export function defineOptions<T extends Record<string, Option>>(options: {
+  [K in keyof T]: T[K] & Option<T[K]["schema"]>;
+}): {
+  [K in keyof T]: Option<T[K]["schema"]>;
+} {
+  prepareDefinitionTypes(options);
+  return options;
+}

package/src/definitions/define-subcommand.ts

@@ -0,0 +1,57 @@
+import { buildObjectContext } from "../parse/context/object-context-builder.ts";
+import { validate } from "../parse/validation/validate-context.ts";
+import { prepareDefinitionTypes } from "../utilities.ts";
+
+import type { Argument, Option, Subcommand } from "../types/definitions-types.ts";
+import type { AttachedMethods, AttachedMethodsWide } from "../types/types.ts";
+import type { Prettify } from "../types/utilities-types.ts";
+
+type OptionsInput<T> =
+  T extends Record<string, Option> ? { [OptionName in keyof T]: Option<T[OptionName]["schema"]> } : T;
+
+type ArgumentsInput<T> =
+  T extends Record<string, Argument> ? { [ArgumentName in keyof T]: Argument<T[ArgumentName]["schema"]> } : T;
+
+// This will prevent extra keys and enable jsdoc on hover
+type SubcommandInput<T extends Subcommand> = {
+  [K in keyof T]: K extends keyof Subcommand
+    ? K extends "options"
+      ? OptionsInput<T[K]>
+      : K extends "arguments"
+        ? ArgumentsInput<T[K]>
+        : T[K]
+    : never;
+};
+
+export function defineSubcommand<T extends Subcommand>(input: SubcommandInput<T> & Subcommand) {
+  const subcommandSchema = input as Prettify<T & AttachedMethods<T>>;
+
+  prepareDefinitionTypes(subcommandSchema.options);
+  prepareDefinitionTypes(subcommandSchema.arguments);
+
+  const onExecute = (handler: (Subcommand["_onExecute"] & {})[number]) => {
+    subcommandSchema._onExecute ??= [];
+    subcommandSchema._onExecute.push(handler);
+
+    return () => {
+      const handlerIndex = subcommandSchema._onExecute?.indexOf(handler);
+      if (!handlerIndex || handlerIndex < 0) return;
+      subcommandSchema._onExecute?.splice(handlerIndex, 1);
+    };
+  };
+
+  const execute: AttachedMethodsWide["execute"] = inputValues => {
+    inputValues ??= {};
+    if (!subcommandSchema._onExecute) throw new Error("Action is not defined");
+    const context = buildObjectContext(inputValues, subcommandSchema);
+    const validateResult = validate(context, subcommandSchema);
+
+    if (subcommandSchema._onExecute) {
+      for (const handler of subcommandSchema._onExecute) {
+        handler(validateResult);
+      }
+    }
+  };
+
+  return Object.assign(subcommandSchema, { onExecute, execute });
+}

package/src/definitions/validate-cli-definition.ts

@@ -0,0 +1,331 @@
+import { transformOptionToArgument } from "../parse/parser-utilities.ts";
+import { findDuplicateStrings } from "../utilities.ts";
+
+import type { Cli, Subcommand } from "../types/definitions-types.ts";
+
+/** @throws {Error} If validation fails. */
+export function validateCliDefinition(cliDefinition: Cli) {
+  if (!cliDefinition.cliName) {
+    throw new Error(`invalid cli definition: "cliName" property is required.`);
+  }
+
+  // validate cli options
+  validateOptions(cliDefinition);
+
+  // validate cli arguments
+  validateArguments(cliDefinition);
+
+  const subcommands = cliDefinition.subcommands;
+  if (!subcommands) return; // ok
+
+  // no empty subcommands array
+  if (subcommands.length === 0) {
+    throw new Error(
+      `invalid cli definition "${cliDefinition.cliName}": "subcommands" property is optional but cannot be empty.`,
+    );
+  }
+
+  const commandsNames = subcommands.map(c => c.name);
+
+  // required subcommand name
+  if (commandsNames.some(c => !c)) {
+    throw new Error(`invalid subcommand definition: subcommand's "name" property is required.`);
+  }
+
+  // no duplicate subcommand names
+  const commandsNamesDuplicates = findDuplicateStrings(commandsNames).map(c => `"${c}"`);
+  if (commandsNamesDuplicates.length > 0) {
+    throw new Error(
+      `invalid cli definition "${cliDefinition.cliName}" has duplicated subcommands: ${commandsNamesDuplicates.join(", ")}.`,
+    );
+  }
+
+  for (const subcommand of subcommands) {
+    // command aliases check
+    if (subcommand.aliases) {
+      // no duplicated aliases
+      const aliasesDuplicates = findDuplicateStrings(subcommand.aliases).map(c => `"${c}"`);
+      if (aliasesDuplicates.length > 0) {
+        throw new Error(`subcommand "${subcommand.name}" has duplicated aliases: ${aliasesDuplicates.join(", ")}.`);
+      }
+
+      for (const alias of subcommand.aliases) {
+        // no empty alias
+        if (alias === "") {
+          throw new Error(`subcommand "${subcommand.name}" has an empty string alias.`);
+        }
+
+        // no conflict with subcommand name
+        if (commandsNames.includes(alias)) {
+          throw new Error(`subcommand "${subcommand.name}" alias "${alias}" conflicts with another subcommand name.`);
+        }
+
+        // no conflict with another alias
+        const aliasConflicts = subcommands.filter(c => c.name !== subcommand.name && c.aliases?.includes(alias));
+        if (aliasConflicts.length > 0) {
+          throw new Error(
+            `subcommand "${subcommand.name}" alias "${alias}" conflicts with another subcommand alias: "${aliasConflicts[0].name}".`,
+          );
+        }
+      }
+    }
+
+    // validate subcommand options
+    validateOptions(subcommand);
+
+    // validate subcommand arguments
+    validateArguments(subcommand);
+  }
+}
+
+function validateOptions(commandDefinition: Cli | Subcommand) {
+  if (!commandDefinition.options) return; // ok
+
+  const isCli = "cliName" in commandDefinition;
+  const name = isCli ? commandDefinition.cliName : commandDefinition.name;
+
+  const createError = (message: string) => {
+    return new Error(`invalid ${isCli ? "cli" : "subcommand"} definition "${name}": ${message}`);
+  };
+
+  const optionsDefinitionEntries = Object.entries(commandDefinition.options);
+
+  // no empty options
+  if (optionsDefinitionEntries.length === 0) {
+    throw createError(`"options" property is optional but cannot be empty.`);
+  }
+
+  for (const [name, option] of optionsDefinitionEntries) {
+    // required type
+    if (!option.schema) {
+      throw createError(`the option "${name}" missing a required property: "schema".`);
+    }
+
+    // should not happen
+    if (!option._preparedType) {
+      throw createError(`internal error: missing prepared type for option "${name}".`);
+    }
+
+    // no negated option name for boolean options
+    if (isNegatedOptionName(name)) {
+      throw createError(`the option "${name}" is a negated option name.`);
+    }
+
+    // no conflict with argument name
+    if (commandDefinition.arguments && name in commandDefinition.arguments) {
+      throw createError(`the option "${name}" name conflicts with an argument name.`);
+    }
+
+    if (option.aliases) {
+      // no duplicate aliases
+      const aliasesDuplicates = findDuplicateStrings(option.aliases);
+      if (aliasesDuplicates.length > 0) {
+        throw createError(`the option "${name}" has duplicated aliases: ${aliasesDuplicates.join(", ")}.`);
+      }
+
+      for (const alias of option.aliases) {
+        // no empty string aliases
+        if (alias === "") {
+          throw createError(`the option "${name}" has an empty string alias.`);
+        }
+
+        // no negated alias name for boolean options
+        if (isNegatedOptionName(alias)) {
+          throw createError(`the alias "${alias}" of the option "${name}" is a negated option name.`);
+        }
+
+        // no alias name should conflict with any option name
+        if (commandDefinition.options[alias]) {
+          throw createError(`the alias "${alias}" of the option "${name}" conflicts with another option name.`);
+        }
+
+        // no alias name should conflict with any argument name
+        if (commandDefinition.arguments && alias in commandDefinition.arguments) {
+          throw createError(`the alias "${alias}" of the option "${name}" conflicts with an argument name.`);
+        }
+
+        // no alias name should conflict with any other alias name
+        const findConflict = optionsDefinitionEntries.find(([n, d]) => n !== name && d.aliases?.includes(alias));
+        if (findConflict) {
+          throw createError(
+            `the alias "${alias}" of the option "${name}" conflicts with another alias name of the option "${findConflict[0]}".`,
+          );
+        }
+      }
+    }
+
+    if (option.requires) {
+      // no self require
+      if (option.requires.includes(name)) {
+        throw createError(`the option "${name}" cannot require itself.`);
+      }
+
+      // no duplicate requires
+      const duplicateRequires = findDuplicateStrings(option.requires).map(required => `"${required}"`);
+      if (duplicateRequires.length > 0) {
+        throw createError(`the option "${name}" has duplicate requires: ${duplicateRequires.join(", ")}.`);
+      }
+
+      // no unknown required name
+      for (const required of option.requires) {
+        const exits = required in commandDefinition.options || required in (commandDefinition.arguments ?? []);
+        if (!exits) {
+          throw createError(`the option "${name}" requires "${required}", but it does not exist.`);
+        }
+      }
+    }
+
+    if (option.conflictWith) {
+      // no self conflict
+      if (option.conflictWith.includes(name)) {
+        throw createError(`the option "${name}" cannot conflict itself.`);
+      }
+
+      // no duplicate conflicts
+      const duplicateRequires = findDuplicateStrings(option.conflictWith).map(conflict => `"${conflict}"`);
+      if (duplicateRequires.length > 0) {
+        throw createError(`the option "${name}" has duplicate conflicts: ${duplicateRequires.join(", ")}.`);
+      }
+
+      // no unknown conflict name
+      for (const required of option.conflictWith) {
+        const exits = required in commandDefinition.options || required in (commandDefinition.arguments ?? []);
+        if (!exits) {
+          throw createError(`the option "${name}" conflict with "${required}", but it does not exist.`);
+        }
+      }
+    }
+
+    // no intersection between requires and conflicts
+    if (option.requires && option.conflictWith) {
+      const requiresSet = new Set(option.requires);
+      const conflictsSet = new Set(option.conflictWith);
+
+      const intersection = requiresSet.intersection(conflictsSet);
+      const intersectionArray = Array.from(intersection).map(name => `"${name}"`);
+
+      if (intersectionArray.length > 0) {
+        const s = intersectionArray.length > 1 ? "s" : "";
+        throw createError(
+          `the option "${name}" cannot require and conflict with the same name${s}: ${intersectionArray.join(", ")}.`,
+        );
+      }
+    }
+  }
+}
+
+function validateArguments(commandDefinition: Cli | Subcommand) {
+  if (!commandDefinition.arguments) return; // ok
+
+  const isCli = "cliName" in commandDefinition;
+  const name = isCli ? commandDefinition.cliName : commandDefinition.name;
+
+  const createError = (message: string) => {
+    return new Error(`invalid ${isCli ? "cli" : "subcommand"} definition "${name}": ${message}`);
+  };
+
+  if (commandDefinition.arguments) {
+    const argumentsDefinitionEntries = Object.entries(commandDefinition.arguments);
+
+    // no empty arguments record
+    if (argumentsDefinitionEntries.length === 0) {
+      throw createError(`"arguments" property is optional but cannot be empty.`);
+    }
+
+    for (const [index, [name, argument]] of argumentsDefinitionEntries.entries()) {
+      // no number key name
+      if (/^\d+$/.test(name)) {
+        throw createError(`the argument "${name}" name cannot be a number.`);
+      }
+
+      // should not happen
+      if (!argument._preparedType) {
+        throw createError(`internal error: missing prepared type for argument "${name}".`);
+      }
+
+      // no missing type
+      if (!argument.schema) {
+        throw createError(`the argument "${name}" missing a required property: "schema".`);
+      }
+
+      // no conflicting option
+      if (commandDefinition.options && name in commandDefinition.options) {
+        throw createError(`the argument "${name}" name conflicts with an option name.`);
+      }
+
+      if (!argument._preparedType.optional) continue; // ok
+
+      // no optional argument when "allowPositionals" is enabled
+      if (commandDefinition.allowPositionals) {
+        throw createError(`the argument "${name}" cannot be optional when "allowPositionals" is enabled.`);
+      }
+
+      // only last argument can be optional
+      if (index !== argumentsDefinitionEntries.length - 1) {
+        throw createError(`the argument "${name}" cannot be optional unless it is the last argument.`);
+      }
+
+      if (argument.requires) {
+        // no self require
+        if (argument.requires.includes(name)) {
+          throw createError(`the argument "${name}" cannot require itself.`);
+        }
+
+        // no duplicate requires
+        const duplicateRequires = findDuplicateStrings(argument.requires).map(required => `"${required}"`);
+        if (duplicateRequires.length > 0) {
+          throw createError(`the argument "${name}" has duplicate requires: ${duplicateRequires.join(", ")}.`);
+        }
+
+        // no unknown require
+        for (const required of argument.requires) {
+          const exits = required in (commandDefinition.options ?? {}) || required in commandDefinition.arguments;
+          if (!exits) {
+            throw createError(`the argument "${name}" requires "${required}", but it does not exist.`);
+          }
+        }
+      }
+
+      if (argument.conflictWith) {
+        // no self conflict
+        if (argument.conflictWith.includes(name)) {
+          throw createError(`the argument "${name}" cannot conflict itself.`);
+        }
+
+        // no duplicate conflicts
+        const duplicateRequires = findDuplicateStrings(argument.conflictWith).map(conflict => `"${conflict}"`);
+        if (duplicateRequires.length > 0) {
+          throw createError(`the argument "${name}" has duplicate conflicts: ${duplicateRequires.join(", ")}.`);
+        }
+
+        // no unknown conflict
+        for (const required of argument.conflictWith) {
+          const exits = required in (commandDefinition.options ?? {}) || required in commandDefinition.arguments;
+          if (!exits) {
+            throw createError(`the argument "${name}" conflict with "${required}", but it does not exist.`);
+          }
+        }
+      }
+
+      // no intersection between requires and conflicts
+      if (argument.requires && argument.conflictWith) {
+        const requiresSet = new Set(argument.requires);
+        const conflictsSet = new Set(argument.conflictWith);
+
+        const intersection = requiresSet.intersection(conflictsSet);
+        const intersectionArray = Array.from(intersection).map(name => `"${name}"`);
+
+        if (intersectionArray.length > 0) {
+          const s = intersectionArray.length > 1 ? "s" : "";
+          throw createError(
+            `the argument "${name}" cannot require and conflict with the same name${s}: ${intersectionArray.join(", ")}.`,
+          );
+        }
+      }
+    }
+  }
+}
+
+function isNegatedOptionName(name: string) {
+  return transformOptionToArgument(name).startsWith("--no-");
+}