@bemoje/cli 1.0.2 → 1.0.4

package/cjs/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./lib/Command"), module.exports);
+__reExport(src_exports, require("./lib/CommandHelpAdapter"), module.exports);
+__reExport(src_exports, require("./lib/CommanderHelpAdapter"), module.exports);
+__reExport(src_exports, require("./lib/Help"), module.exports);
+__reExport(src_exports, require("./lib/renderHelp"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./lib/Command"),
+  ...require("./lib/CommandHelpAdapter"),
+  ...require("./lib/CommanderHelpAdapter"),
+  ...require("./lib/Help"),
+  ...require("./lib/renderHelp")
+});
+//# sourceMappingURL=index.cjs.map

package/cjs/lib/Command.cjs

@@ -0,0 +1,453 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Command_exports = {};
+__export(Command_exports, {
+  Command: () => Command
+});
+module.exports = __toCommonJS(Command_exports);
+var import_node_util = require("node:util");
+var import_CommandHelpAdapter = require("./CommandHelpAdapter");
+class Command {
+  /** Command name used for invocation */
+  name;
+  /** Optional version string */
+  version;
+  /** Alternative names for this command */
+  aliases;
+  /** Brief single-line description */
+  summary;
+  /** Full command description */
+  description;
+  /** Whether command should be hidden from help */
+  hidden;
+  /** Group name for organizing commands in help */
+  group;
+  /** Parent command if this is a subcommand */
+  parent;
+  /** Child subcommands */
+  commands;
+  /** Positional arguments */
+  arguments;
+  /** Named options/flags */
+  options;
+  /** Help system configuration */
+  helpConfiguration;
+  constructor(name = "", parent = null) {
+    this.name = name;
+    this.parent = parent;
+    this.aliases = [];
+    this.description = "";
+    this.commands = [];
+    this.arguments = [];
+    this.options = [];
+    this.helpConfiguration = { showGlobalOptions: true, sortOptions: true, sortSubcommands: true };
+    Object.defineProperty(this, "parent", { enumerable: false });
+  }
+  /** Updates multiple command properties at once */
+  setState(state) {
+    Object.assign(this, state);
+    if (state.commands) {
+      state.commands = state.commands.map((cmd) => new Command(cmd.name, this).setState(cmd));
+    }
+    return this;
+  }
+  /** Serializes command to JSON, maintaining compatibility with previous state-based structure */
+  toJSON() {
+    const result = {
+      name: this.name,
+      version: this.version,
+      aliases: this.aliases,
+      summary: this.summary,
+      description: this.description,
+      hidden: this.hidden,
+      group: this.group,
+      commands: this.commands,
+      arguments: this.arguments,
+      options: this.options,
+      helpConfiguration: this.helpConfiguration
+    };
+    Object.defineProperty(result, "parent", {
+      value: this.parent,
+      writable: true,
+      enumerable: false,
+      configurable: true
+    });
+    return result;
+  }
+  /** Sets the command name */
+  setName(name) {
+    this.name = name;
+  }
+  /** Sets command aliases, flattening nested arrays */
+  setAliases(...aliases) {
+    this.aliases = aliases.flat();
+    return this;
+  }
+  /** Adds aliases to existing ones */
+  addAliases(...aliases) {
+    this.aliases.push(...aliases.flat());
+    return this;
+  }
+  /** Sets the command version */
+  setVersion(version) {
+    this.version = version;
+    return this;
+  }
+  /** Sets the command summary */
+  setSummary(summary) {
+    this.summary = summary;
+    return this;
+  }
+  /** Sets command description, joining multiple lines */
+  setDescription(...lines) {
+    this.description = lines.join("\n");
+    return this;
+  }
+  /** Sets whether command is hidden from help */
+  setHidden(hidden = true) {
+    this.hidden = hidden;
+    return this;
+  }
+  /** Sets the command group for help organization */
+  setGroup(group) {
+    this.group = group;
+    return this;
+  }
+  /** Sets the parent command */
+  setParent(parent) {
+    this.parent = parent;
+    return this;
+  }
+  /** Extends existing help configuration with new settings */
+  extendHelpConfiguration(config) {
+    this.helpConfiguration = { ...this.helpConfiguration, ...config };
+    return this;
+  }
+  /** Sets help configuration, using defaults if not provided */
+  setHelpConfiguration(config) {
+    this.helpConfiguration = config ? { ...config } : { showGlobalOptions: true, sortOptions: true, sortSubcommands: true };
+    return this;
+  }
+  /** Creates and adds a subcommand */
+  subcommand(name) {
+    const sub = new Command(name, this);
+    this.commands.push(sub);
+    return sub;
+  }
+  /**
+   * Adds positional argument with type inference and CLI ordering validation.
+   */
+  argument(usage, description, options = {}) {
+    const match = usage.match(/^<(.*?)>$|^\[(.*?)\]$/);
+    if (!match) throw new Error(`Invalid argument format: ${usage}`);
+    const nameMatch = match[1] || match[2];
+    const name = nameMatch.replace(/\.\.\.$/, "");
+    this.assertArgumentNameNotInUse(name);
+    if (usage.startsWith("<")) {
+      if (nameMatch.endsWith("...")) {
+        this.assertNoMultipleVariadicArguments();
+        this.arguments.push({
+          name,
+          description,
+          required: true,
+          multiple: true,
+          ...options
+        });
+      } else {
+        this.assertNoOptionalOrVariadicArguments();
+        this.arguments.push({
+          name,
+          description,
+          required: true,
+          multiple: false,
+          ...options
+        });
+      }
+    } else if (usage.startsWith("[")) {
+      if (nameMatch.endsWith("...")) {
+        this.assertNoMultipleVariadicArguments();
+        this.arguments.push({
+          name,
+          description,
+          required: false,
+          multiple: true,
+          defaultValue: options.defaultValue ?? [],
+          ...options
+        });
+      } else {
+        this.assertNoVariadicArgument();
+        this.arguments.push({
+          name,
+          description,
+          required: false,
+          multiple: false,
+          ...options
+        });
+      }
+    }
+    return this;
+  }
+  /**
+   * Adds command-line option with type inference. Parses format: `-s, --long [<value>|[value]|<value...>|[value...]]`
+   */
+  option(usage, description, opts = {}) {
+    const match = usage.match(/^-(.+?), --([a-zA-Z][\w-]*)(?:\s*(<(.+?)>|\[(.+?)\]))?$/);
+    if (!match) throw new Error(`Invalid option format: ${usage}`);
+    const short = match[1];
+    this.assertOptionShortNameIsValid(short);
+    this.assertOptionShortNameNotInUse(short);
+    const name = match[2];
+    const argName = (match[4] || match[5])?.replace(/\.\.\.$/, "");
+    this.assertOptionNameNotInUse(name);
+    if (!argName) {
+      this.options.push({
+        type: "boolean",
+        short,
+        name,
+        description,
+        required: false,
+        multiple: false,
+        ...opts
+      });
+    } else if (usage.endsWith(">")) {
+      if (usage.endsWith("...>")) {
+        this.options.push({
+          type: "string",
+          short,
+          name,
+          argName,
+          description,
+          required: true,
+          multiple: true,
+          ...opts
+        });
+      } else {
+        this.options.push({
+          type: "string",
+          short,
+          name,
+          argName,
+          description,
+          required: true,
+          multiple: false,
+          ...opts
+        });
+      }
+    } else if (usage.endsWith("]")) {
+      if (usage.endsWith("...]")) {
+        this.options.push({
+          type: "string",
+          short,
+          name,
+          argName,
+          description,
+          required: false,
+          multiple: true,
+          defaultValue: opts.defaultValue ?? [],
+          ...opts
+        });
+      } else {
+        this.options.push({
+          type: "string",
+          short,
+          name,
+          argName,
+          description,
+          required: false,
+          multiple: false,
+          ...opts
+        });
+      }
+    }
+    return this;
+  }
+  /**
+   * Parses command-line arguments with subcommand support and type-safe validation.
+   *
+   * @example
+   * ```typescript
+   * const result = cmd.parse(['input.txt', '-v', '--format', 'json'])
+   * // { arguments: ['input.txt'], options: { verbose: true, format: 'json' } }
+   * ```
+   */
+  parse(argv = process.argv.slice(2), globalOptions = []) {
+    const maybeSubArg = (0, import_node_util.parseArgs)({
+      args: argv,
+      allowPositionals: true,
+      tokens: false,
+      strict: false,
+      allowNegative: true
+    }).positionals[0];
+    const sub = this.findCommand(maybeSubArg);
+    if (sub) {
+      return sub.parse(
+        argv?.filter((a) => a !== maybeSubArg),
+        [...globalOptions, ...this.options]
+      );
+    }
+    const parsed = (0, import_node_util.parseArgs)({
+      args: argv,
+      options: Object.fromEntries(
+        [...globalOptions, ...this.options].map((o) => {
+          return [o.name, o];
+        })
+      ),
+      allowPositionals: true,
+      tokens: true,
+      strict: true,
+      allowNegative: true
+    });
+    for (let i = 0; i < parsed.tokens.length; i++) {
+      const token = parsed.tokens[i];
+      if (token.kind === "option") {
+        const optionDescriptor = this.options.find((o) => o.name === token.name);
+        if (optionDescriptor && optionDescriptor.multiple && optionDescriptor.type === "string") {
+          const values = [token.value];
+          let j = i + 1;
+          while (j < parsed.tokens.length && parsed.tokens[j].kind === "positional") {
+            const positionalToken = parsed.tokens[j];
+            if (positionalToken.kind === "positional") {
+              values.push(positionalToken.value);
+              const posIndex = parsed.positionals.indexOf(positionalToken.value);
+              if (posIndex !== -1) {
+                parsed.positionals.splice(posIndex, 1);
+              }
+            }
+            j++;
+          }
+          Reflect.set(
+            parsed.values,
+            token.name,
+            values.filter((v) => v !== void 0)
+          );
+        }
+      }
+    }
+    const parsedArguments = this.arguments.map((arg, index) => {
+      if (arg.multiple) {
+        const remainingArgs = parsed.positionals.slice(index);
+        return remainingArgs.length > 0 ? remainingArgs : arg.defaultValue ?? [];
+      } else {
+        return parsed.positionals[index] ?? arg.defaultValue;
+      }
+    });
+    for (const option of this.options) {
+      if (!(option.name in parsed.values) && "defaultValue" in option) {
+        Reflect.set(parsed.values, option.name, option.defaultValue);
+      }
+    }
+    const self = this;
+    return {
+      get command() {
+        return self;
+      },
+      arguments: parsedArguments,
+      options: { ...parsed.values }
+    };
+  }
+  /** Validates CLI argument ordering */
+  assertNoOptionalOrVariadicArguments() {
+    if (this.arguments.some((arg) => !arg.required)) {
+      throw new Error("Cannot add required argument after optional or variadic arguments");
+    }
+  }
+  /** Validates optional args don't follow variadic args */
+  assertNoVariadicArgument() {
+    if (this.arguments.some((arg) => arg.multiple)) {
+      throw new Error("Cannot add optional argument after variadic argument");
+    }
+  }
+  /** Ensures only one variadic argument per command */
+  assertNoMultipleVariadicArguments() {
+    if (this.arguments.some((arg) => arg.multiple)) {
+      throw new Error("Cannot add more than one variadic argument");
+    }
+  }
+  /** Ensures unique argument names across arguments and options */
+  assertArgumentNameNotInUse(name) {
+    if (this.arguments.some((arg) => arg.name === name)) {
+      throw new Error(`Argument name already in use: ${name}`);
+    }
+    if (this.options.some((opt) => opt.name === name)) {
+      throw new Error(`Argument name already in use: ${name}`);
+    }
+  }
+  /** Validates option short names are single alphanumeric characters */
+  assertOptionShortNameIsValid(short) {
+    const isSingleAlphaNumericChar = /^[a-zA-Z0-9]$/.test(short);
+    if (!isSingleAlphaNumericChar) {
+      throw new Error(`Expected short name to be a single alpha-numeric character. Got: ${short}`);
+    }
+  }
+  /** Validates option short names are unique across command hierarchy */
+  assertOptionShortNameNotInUse(short) {
+    for (const opt of this.options) {
+      if (opt.short === short) {
+        throw new Error(`Option short name already in use: -${short}`);
+      }
+    }
+    this.parent?.assertOptionShortNameNotInUse(short);
+  }
+  /** Validates option names are unique across command hierarchy */
+  assertOptionNameNotInUse(name) {
+    if (this.options.some((opt) => opt.name === name)) {
+      throw new Error(`Option name already in use: --${name}`);
+    }
+    this.parent?.assertOptionNameNotInUse(name);
+  }
+  /** Returns command and all ancestor commands in hierarchy */
+  getCommandAndAncestors() {
+    const result = [];
+    let command = this;
+    for (; command; command = command.parent) {
+      result.push(command);
+    }
+    return result;
+  }
+  /** Returns all ancestor commands excluding this command */
+  getAncestors() {
+    return this.getCommandAndAncestors().slice(1);
+  }
+  /** Returns all options from this command and ancestors */
+  getOptionsInclAncestors() {
+    return this.getCommandAndAncestors().flatMap((cmd) => cmd.options);
+  }
+  /** Finds subcommand by name or alias */
+  findCommand(name) {
+    if (!name) return void 0;
+    return this.commands.find((cmd) => cmd.name === name || cmd.aliases.includes(name));
+  }
+  /** Finds option by short or long name */
+  findOption(arg) {
+    return this.options.find((option) => option.short === arg || option.name === arg);
+  }
+  /** Returns a view that is compliant with the CommandHelp interface */
+  createHelpAdapter() {
+    return new import_CommandHelpAdapter.CommandHelpAdapter(this);
+  }
+  /** Renders formatted help text using provided help definition */
+  renderHelp(help) {
+    return this.createHelpAdapter().renderHelp(help);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Command
+});
+//# sourceMappingURL=Command.cjs.map

package/cjs/lib/CommandHelpAdapter.cjs

@@ -0,0 +1,130 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var CommandHelpAdapter_exports = {};
+__export(CommandHelpAdapter_exports, {
+  CommandHelpAdapter: () => CommandHelpAdapter
+});
+module.exports = __toCommonJS(CommandHelpAdapter_exports);
+var import_lazyProp = __toESM(require("./internal/lazyProp"), 1);
+var import_Help = require("./Help");
+var import_renderHelp = require("./renderHelp");
+const _CommandHelpAdapter = class _CommandHelpAdapter {
+  constructor(cmd) {
+    this.cmd = cmd;
+  }
+  renderHelp(help = new import_Help.Help()) {
+    return (0, import_renderHelp.renderHelp)(this, help);
+  }
+  get name() {
+    return this.cmd.name;
+  }
+  get aliases() {
+    return this.cmd.aliases;
+  }
+  get summary() {
+    return this.cmd.summary ?? (this.cmd.description.includes("\n") ? this.cmd.description.split("\n")[0] : void 0);
+  }
+  get description() {
+    return this.cmd.description;
+  }
+  get hidden() {
+    return this.cmd.hidden;
+  }
+  get usage() {
+    return [
+      ...this.cmd.options.length ? ["[options]"] : [],
+      ...this.cmd.commands.length ? ["[command]"] : [],
+      ...this.cmd.arguments.map((arg) => this.renderArgumentFlags(arg))
+    ].join(" ");
+  }
+  get group() {
+    return this.cmd.group;
+  }
+  get commands() {
+    return this.cmd.commands.map((c) => new _CommandHelpAdapter(c));
+  }
+  get options() {
+    return this.cmd.options.map((opt) => ({
+      ...opt,
+      flags: this.renderOptionFlags(opt),
+      long: opt.name,
+      optional: !opt.required,
+      negate: false,
+      variadic: opt.multiple
+    }));
+  }
+  get arguments() {
+    return this.cmd.arguments.map((arg) => ({
+      ...arg,
+      variadic: arg.multiple
+    }));
+  }
+  get parent() {
+    return this.cmd.parent ? new _CommandHelpAdapter(this.cmd.parent) : null;
+  }
+  get helpConfiguration() {
+    return { ...this.cmd.helpConfiguration };
+  }
+  renderArgumentFlags(arg) {
+    return arg.required ? arg.multiple ? `<${arg.name}...>` : `<${arg.name}>` : arg.multiple ? `[${arg.name}...]` : `[${arg.name}]`;
+  }
+  renderOptionFlags(opt) {
+    const flags = `-${opt.short}, --${opt.name}`;
+    return opt.type === "boolean" ? flags : opt.required ? opt.multiple ? flags + ` <${opt.argName}...>` : flags + ` <${opt.argName}>` : opt.multiple ? flags + ` [${opt.argName}...]` : flags + ` [${opt.argName}]`;
+  }
+};
+__decorateClass([
+  import_lazyProp.default
+], _CommandHelpAdapter.prototype, "usage", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommandHelpAdapter.prototype, "commands", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommandHelpAdapter.prototype, "arguments", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommandHelpAdapter.prototype, "parent", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommandHelpAdapter.prototype, "helpConfiguration", 1);
+let CommandHelpAdapter = _CommandHelpAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandHelpAdapter
+});
+//# sourceMappingURL=CommandHelpAdapter.cjs.map