breadc 0.7.0 → 0.8.0

package/dist/index.cjs

@@ -1,21 +1,142 @@
 'use strict';
 
-const minimist = require('minimist');
-const kolorist = require('kolorist');
+Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
+const color = require('@breadc/color');
+
+function makePluginContainer(plugins = []) {
+  const onPreCommand = {};
+  const onPostCommand = {};
+  for (const plugin of plugins) {
+    for (const [key, fn] of Object.entries(plugin.onPreCommand ?? {})) {
+      if (!(key in onPreCommand)) {
+        onPreCommand[key] = [];
+      }
+      onPreCommand[key].push(fn);
+    }
+    for (const [key, fn] of Object.entries(plugin.onPostCommand ?? {})) {
+      if (!(key in onPostCommand)) {
+        onPostCommand[key] = [];
+      }
+      onPostCommand[key].push(fn);
     }
   }
-  n.default = e;
-  return n;
+  const run = async (container, command) => {
+    const prefix = command._arguments.filter((a) => a.type === "const").map((a) => a.name);
+    for (let i = 0; i <= prefix.length; i++) {
+      const key = i === 0 ? "*" : prefix.slice(0, i).map(
+        (t, idx) => idx === 0 ? t : t[0].toUpperCase() + t.slice(1)
+      ).join("");
+      const fns = container[key];
+      if (fns && fns.length > 0) {
+        await Promise.all(fns.map((fn) => fn()));
+      }
+    }
+  };
+  return {
+    async preRun(breadc) {
+      for (const p of plugins) {
+        await p.onPreRun?.(breadc);
+      }
+    },
+    async preCommand(command) {
+      await run(onPreCommand, command);
+    },
+    async postCommand(command) {
+      await run(onPostCommand, command);
+    },
+    async postRun(breadc) {
+      for (const p of plugins) {
+        await p.onPostRun?.(breadc);
+      }
+    }
+  };
+}
+function definePlugin(plugin) {
+  return plugin;
 }
 
-const kolorist__namespace = /*#__PURE__*/_interopNamespaceDefault(kolorist);
+class Token {
+  constructor(text) {
+    this.text = text;
+  }
+  /**
+   * @returns Raw argument text
+   */
+  raw() {
+    return this.text;
+  }
+  /**
+   * @returns Number representation
+   */
+  number() {
+    return Number(this.text);
+  }
+  /**
+   * @returns Remove start - for long or short option
+   */
+  option() {
+    return this.text.replace(/^-+/, "");
+  }
+  isOption() {
+    return this.type() === "long" || this._type === "short";
+  }
+  isText() {
+    return this.type() === "number" || this._type === "string";
+  }
+  type() {
+    if (this._type) {
+      return this._type;
+    } else if (this.text === "--") {
+      return this._type = "--";
+    } else if (this.text === "-") {
+      return this._type = "-";
+    } else if (!isNaN(Number(this.text))) {
+      return this._type = "number";
+    } else if (this.text.startsWith("--")) {
+      return this._type = "long";
+    } else if (this.text.startsWith("-")) {
+      return this._type = "short";
+    } else {
+      return this._type = "string";
+    }
+  }
+}
+class Lexer {
+  constructor(rawArgs) {
+    this.cursor = 0;
+    this.rawArgs = rawArgs;
+  }
+  next() {
+    const value = this.rawArgs[this.cursor];
+    this.cursor += 1;
+    return value ? new Token(value) : void 0;
+  }
+  hasNext() {
+    return this.cursor + 1 < this.rawArgs.length;
+  }
+  peek() {
+    const value = this.rawArgs[this.cursor];
+    return value ? new Token(value) : void 0;
+  }
+  [Symbol.iterator]() {
+    const that = this;
+    return {
+      next() {
+        const value = that.rawArgs[that.cursor];
+        that.cursor += 1;
+        return {
+          value: value ? new Token(value) : void 0,
+          done: that.cursor > that.rawArgs.length
+        };
+      }
+    };
+  }
+}
 
+function camelCase(text) {
+  return text.split("-").map((t, idx) => idx === 0 ? t : t[0].toUpperCase() + t.slice(1)).join("");
+}
 function twoColumn(texts, split = "  ") {
   const left = padRight(texts.map((t) => t[0]));
   return left.map((l, idx) => l + split + texts[idx][1]);
@@ -25,507 +146,518 @@ function padRight(texts, fill = " ") {
   return texts.map((t) => t + fill.repeat(length - t.length));
 }
 
-function createDefaultLogger(name, logger) {
-  const println = !!logger && typeof logger === "function" ? logger : logger?.println ?? ((message, ...args) => {
-    console.log(message, ...args);
-  });
-  const info = typeof logger === "object" && logger?.info ? logger.info : (message, ...args) => {
-    println(`${kolorist.blue("INFO")} ${message}`, ...args);
-  };
-  const warn = typeof logger === "object" && logger?.warn ? logger.warn : (message, ...args) => {
-    println(`${kolorist.yellow("WARN")} ${message}`, ...args);
-  };
-  const error = typeof logger === "object" && logger?.error ? logger.error : (message, ...args) => {
-    println(`${kolorist.red("ERROR")} ${message}`, ...args);
-  };
-  const debug = typeof logger === "object" && logger?.debug ? logger.debug : (message, ...args) => {
-    println(`${kolorist.gray(name)} ${message}`, ...args);
-  };
-  return {
-    println,
-    info,
-    warn,
-    error,
-    debug
-  };
+class BreadcError extends Error {
+}
+class ParseError extends Error {
 }
 
-const _Option = class {
-  constructor(format, config = {}) {
-    this.format = format;
-    const match = _Option.OptionRE.exec(format);
-    if (match) {
-      if (match[3]) {
-        this.type = "string";
+function makeTreeNode(pnode) {
+  const node = {
+    children: /* @__PURE__ */ new Map(),
+    init() {
+    },
+    next(token, context) {
+      const t = token.raw();
+      context.result["--"].push(t);
+      if (node.children.has(t)) {
+        const next = node.children.get(t);
+        next.init(context);
+        return next;
       } else {
-        this.type = "boolean";
+        return node;
       }
-      this.name = match[2];
-      if (match[1]) {
-        this.shortcut = match[1][1];
+    },
+    finish() {
+    },
+    ...pnode
+  };
+  return node;
+}
+function parseOption(cursor, token, context) {
+  const o = token.option();
+  const [key, rawV] = o.split("=");
+  if (context.options.has(key)) {
+    const option = context.options.get(key);
+    const name = camelCase(option.name);
+    if (option.action) {
+      return option.action(cursor, token, context);
+    } else if (option.type === "boolean") {
+      context.result.options[name] = !key.startsWith("no-") ? true : false;
+    } else if (option.type === "string") {
+      if (rawV !== void 0) {
+        context.result.options[name] = rawV;
+      } else {
+        const value = context.lexer.next();
+        if (value !== void 0 && !value.isOption()) {
+          context.result.options[name] = value.raw();
+        } else {
+          throw new ParseError(
+            `You should provide arguments for ${option.format}`
+          );
+        }
       }
     } else {
-      throw new Error(`Can not parse option format from "${format}"`);
+      throw new ParseError("unreachable");
+    }
+    if (option.cast) {
+      context.result.options[name] = option.cast(context.result.options[name]);
     }
-    this.description = config.description ?? "";
-    this.required = format.indexOf("<") !== -1;
-    this.default = config.default;
-    this.construct = config.construct;
+  } else {
+    throw new ParseError(`Unknown option ${token.raw()}`);
   }
-};
-let Option = _Option;
-Option.OptionRE = /^(-[a-zA-Z0-9], )?--([a-zA-Z0-9\-]+)( \[[a-zA-Z0-9]+\]| <[a-zA-Z0-9]+>)?$/;
-
-const _Command = class {
-  constructor(format, config) {
-    this.options = [];
-    this.format = format;
-    const pieces = format.split(" ").map((t) => t.trim()).filter(Boolean);
-    const prefix = pieces.filter((p) => !isArg(p));
-    this.default = prefix.length === 0;
-    this.prefix = this.default ? [] : [prefix];
-    this.arguments = pieces.filter(isArg);
-    this.description = config.description ?? "";
-    this.logger = config.logger;
-    {
-      const restArgs = this.arguments.findIndex((a) => a.startsWith("[..."));
-      if (restArgs !== -1 && restArgs !== this.arguments.length - 1) {
-        this.logger.warn(
-          `Expand arguments ${this.arguments[restArgs]} should be placed at the last position`
-        );
+  return cursor;
+}
+function parse(root, args) {
+  const lexer = new Lexer(args);
+  const context = {
+    lexer,
+    options: /* @__PURE__ */ new Map(),
+    result: {
+      arguments: [],
+      options: {},
+      "--": []
+    }
+  };
+  let cursor = root;
+  root.init(context);
+  for (const token of lexer) {
+    if (token.type() === "--") {
+      break;
+    } else if (token.isOption()) {
+      const res = parseOption(cursor, token, context);
+      if (res === false) {
+        break;
+      } else {
+        cursor = res;
       }
-      if (pieces.length > _Command.MaxDep) {
-        this.logger.warn(`Command format string "${format}" is too long`);
+    } else if (token.isText()) {
+      const res = cursor.next(token, context);
+      if (res === false) {
+        break;
+      } else {
+        cursor = res;
       }
+    } else {
+      throw new ParseError("unreachable");
     }
   }
-  get isInternal() {
-    return this instanceof InternalCommand;
-  }
-  alias(command) {
-    const pieces = command.split(" ").map((t) => t.trim()).filter(Boolean);
-    this.prefix.push(pieces);
-    return this;
+  cursor.finish(context);
+  for (const token of lexer) {
+    context.result["--"].push(token.raw());
   }
-  option(format, configOrDescription = "", otherConfig = {}) {
-    const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
-    try {
-      const option = new Option(format, config);
-      this.options.push(option);
-    } catch (error) {
-      this.logger.warn(error.message);
+  return {
+    command: cursor.command,
+    arguments: context.result.arguments,
+    options: context.result.options,
+    "--": context.result["--"]
+  };
+}
+
+const OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z0-9\-]+)( <[a-zA-Z0-9\-]+>)?$/;
+function makeOption(format, config = {}) {
+  let name = "";
+  let short = void 0;
+  const match = OptionRE.exec(format);
+  if (match) {
+    name = match[2];
+    if (name.startsWith("no-")) {
+      throw new BreadcError(`Can not parse option format (${format})`);
     }
-    return this;
-  }
-  hasPrefix(parsedArgs) {
-    const argv = parsedArgs["_"];
-    if (argv.length === 0) {
-      return this.default;
+    if (match[1]) {
+      short = match[1][1];
+    }
+    if (match[3]) {
+      const initial = config.default ?? "";
+      return {
+        format,
+        type: "string",
+        name,
+        short,
+        description: config.description ?? "",
+        order: 0,
+        // @ts-ignore
+        initial: config.cast ? config.cast(initial) : initial,
+        cast: config.cast
+      };
     } else {
-      for (const prefix of this.prefix) {
-        if (prefix.length > 0 && prefix[0] === argv[0]) {
-          return true;
-        }
-      }
-      return false;
+      const initial = config.default === void 0 || config.default === null ? false : config.default;
+      return {
+        format,
+        type: "boolean",
+        name,
+        short,
+        description: config.description ?? "",
+        order: 0,
+        // @ts-ignore
+        initial: config.cast ? config.cast(initial) : initial,
+        cast: config.cast
+      };
     }
+  } else {
+    throw new BreadcError(`Can not parse option format (${format})`);
   }
-  shouldRun(parsedArgs) {
-    const args = parsedArgs["_"];
-    for (const prefix of this.prefix) {
-      let match = true;
-      for (let i = 0; match && i < prefix.length; i++) {
-        if (args[i] !== prefix[i]) {
-          match = false;
+}
+const initContextOptions = (options, context) => {
+  for (const option of options) {
+    context.options.set(option.name, option);
+    if (option.short) {
+      context.options.set(option.short, option);
+    }
+    if (option.type === "boolean") {
+      context.options.set("no-" + option.name, option);
+    }
+    if (option.initial !== void 0) {
+      context.result.options[camelCase(option.name)] = option.initial;
+    }
+  }
+};
+
+function makeCommand(format, config, root, container) {
+  let cursor = root;
+  const args = [];
+  const options = [];
+  const command = {
+    callback: void 0,
+    format,
+    description: config.description ?? "",
+    _arguments: args,
+    _options: options,
+    option(format2, _config, _config2 = {}) {
+      const config2 = typeof _config === "string" ? { description: _config, ..._config2 } : _config;
+      const option = makeOption(format2, config2);
+      options.push(option);
+      return command;
+    },
+    action(fn) {
+      command.callback = async (...args2) => {
+        await container.preCommand(command);
+        const result = await fn(...args2);
+        await container.postCommand(command);
+        return result;
+      };
+    }
+  };
+  const node = makeTreeNode({
+    command,
+    init(context) {
+      initContextOptions(options, context);
+    },
+    finish(context) {
+      const rest = context.result["--"];
+      for (let i = 0; i < args.length; i++) {
+        if (args[i].type === "const") {
+          if (rest[i] !== args[i].name) {
+            throw new ParseError(`Sub-command ${args[i].name} mismatch`);
+          }
+        } else if (args[i].type === "require") {
+          if (i >= rest.length) {
+            throw new ParseError(
+              `You must provide require argument ${args[i].name}`
+            );
+          }
+          context.result.arguments.push(rest[i]);
+        } else if (args[i].type === "optional") {
+          context.result.arguments.push(rest[i]);
+        } else if (args[i].type === "rest") {
+          context.result.arguments.push(rest.splice(i));
         }
       }
-      if (match) {
-        args.splice(0, prefix.length);
-        return true;
-      }
+      context.result["--"] = rest.splice(args.length);
     }
-    if (this.default)
-      return true;
-    return false;
-  }
-  parseArgs(argv, globalOptions) {
-    const pieces = argv["_"];
-    const args = [];
-    const restArgs = [];
-    for (let i = 0, used = 0; i <= this.arguments.length; i++) {
-      if (i === this.arguments.length) {
-        restArgs.push(...pieces.slice(used).map(String));
-        restArgs.push(...(argv["--"] ?? []).map(String));
-      } else if (i < pieces.length) {
-        if (this.arguments[i].startsWith("[...")) {
-          args.push(pieces.slice(i).map(String));
-          used = pieces.length;
-        } else {
-          args.push(String(pieces[i]));
-          used++;
+  });
+  {
+    let state = 0;
+    for (let i = 0; i < format.length; i++) {
+      if (format[i] === "<") {
+        if (state !== 0 && state !== 1) {
+          throw new BreadcError(
+            `Required arguments should be placed before optional or rest arguments`
+          );
         }
-      } else {
-        if (this.arguments[i].startsWith("<")) {
-          this.logger.warn(
-            `You should provide the argument "${this.arguments[i]}"`
+        const start = i;
+        while (i < format.length && format[i] !== ">") {
+          i++;
+        }
+        const name = format.slice(start + 1, i);
+        state = 1;
+        args.push({ type: "require", name });
+      } else if (format[i] === "[") {
+        if (state !== 0 && state !== 1) {
+          throw new BreadcError(
+            `There is at most one optional or rest arguments`
           );
-          args.push("");
-        } else if (this.arguments[i].startsWith("[...")) {
-          args.push([]);
-        } else if (this.arguments[i].startsWith("[")) {
-          args.push(void 0);
+        }
+        const start = i;
+        while (i < format.length && format[i] !== "]") {
+          i++;
+        }
+        const name = format.slice(start + 1, i);
+        state = 2;
+        if (name.startsWith("...")) {
+          args.push({ type: "rest", name });
         } else {
-          this.logger.warn(`unknown format string ("${this.arguments[i]}")`);
+          args.push({ type: "optional", name });
         }
-      }
-    }
-    const fullOptions = globalOptions.concat(this.options).reduce((map, o) => {
-      map.set(o.name, o);
-      return map;
-    }, /* @__PURE__ */ new Map());
-    const options = argv;
-    delete options["_"];
-    for (const [name, rawOption] of fullOptions) {
-      if (rawOption.type === "boolean")
-        continue;
-      if (rawOption.required) {
-        if (options[name] === void 0) {
-          options[name] = false;
-        } else if (options[name] === "") {
-          options[name] = true;
+      } else if (format[i] !== " ") {
+        if (state !== 0) {
+          throw new BreadcError(
+            `Sub-command should be placed at the beginning`
+          );
         }
-      } else {
-        if (options[name] === false) {
-          options[name] = void 0;
-        } else if (!(name in options)) {
-          options[name] = void 0;
+        const start = i;
+        while (i < format.length && format[i] !== " ") {
+          i++;
         }
-      }
-      if (rawOption.construct !== void 0) {
-        options[name] = rawOption.construct(options[name]);
-      } else if (rawOption.default !== void 0) {
-        if (options[name] === void 0 || options[name] === false || options[name] === "") {
-          options[name] = rawOption.default;
+        const name = format.slice(start, i);
+        if (cursor.children.has(name)) {
+          cursor = cursor.children.get(name);
+        } else {
+          const internalNode = makeTreeNode({
+            next(token, context) {
+              const t = token.raw();
+              context.result["--"].push(t);
+              if (internalNode.children.has(t)) {
+                const next = internalNode.children.get(t);
+                next.init(context);
+                return next;
+              } else {
+                throw new ParseError(`Unknown sub-command (${t})`);
+              }
+            },
+            finish() {
+              throw new ParseError(`Unknown sub-command`);
+            }
+          });
+          cursor.children.set(name, internalNode);
+          cursor = internalNode;
         }
+        state = 0;
+        args.push({ type: "const", name });
       }
     }
-    for (const key of Object.keys(options)) {
-      if (!fullOptions.has(key)) {
-        delete options[key];
+    cursor.command = command;
+    if (cursor !== root) {
+      for (const [key, value] of cursor.children) {
+        node.children.set(key, value);
       }
-    }
-    return {
-      // @ts-ignore
-      command: this,
-      arguments: args,
-      options,
-      "--": restArgs
-    };
-  }
-  action(fn) {
-    this.actionFn = fn;
-  }
-  async run(...args) {
-    if (this.actionFn) {
-      return await this.actionFn(...args, {
-        logger: this.logger,
-        color: kolorist__namespace
-      });
+      cursor.children = node.children;
+      cursor.next = node.next;
+      cursor.init = node.init;
+      cursor.finish = node.finish;
     } else {
-      this.logger.warn(
-        `You may miss action function in ${this.format ? `"${this.format}"` : "<default command>"}`
-      );
-      return void 0;
+      cursor.finish = node.finish;
     }
   }
-};
-let Command = _Command;
-Command.MaxDep = 5;
-class InternalCommand extends Command {
-  hasPrefix(_args) {
-    return false;
-  }
-  parseArgs(args, _globalOptions) {
-    const argumentss = args["_"];
-    const options = args;
-    delete options["_"];
-    delete options["help"];
-    delete options["version"];
-    return {
-      // @ts-ignore
-      command: this,
-      arguments: argumentss,
-      options: args,
-      "--": []
-    };
-  }
+  return command;
 }
-class HelpCommand extends InternalCommand {
-  constructor(commands, help, logger) {
-    super("-h, --help", { description: "Display this message", logger });
-    this.runCommands = [];
-    this.helpCommands = [];
-    this.commands = commands;
-    this.help = help;
-  }
-  shouldRun(args) {
-    const isRestEmpty = !args["--"]?.length;
-    if ((args.help || args.h) && isRestEmpty) {
-      if (args["_"].length > 0) {
-        for (const cmd of this.commands) {
-          if (!cmd.default && !cmd.isInternal) {
-            if (cmd.shouldRun(args)) {
-              this.runCommands.push(cmd);
-            } else if (cmd.hasPrefix(args)) {
-              this.helpCommands.push(cmd);
-            }
-          }
-        }
-      }
-      return true;
-    } else {
-      return false;
+function makeVersionCommand(name, config) {
+  const command = {
+    callback() {
+      const text = `${name}/${config.version ? config.version : "unknown"}`;
+      console.log(text);
+      return text;
+    },
+    format: "-v, --version",
+    description: "Print version",
+    _arguments: [],
+    _options: [],
+    option() {
+      return command;
+    },
+    action() {
     }
-  }
-  async run() {
-    const shouldHelp = this.runCommands.length > 0 ? this.runCommands : this.helpCommands;
-    for (const line of this.help(shouldHelp)) {
-      this.logger.println(line);
-    }
-    this.runCommands.splice(0);
-    this.helpCommands.splice(0);
-  }
-}
-class VersionCommand extends InternalCommand {
-  constructor(version, logger) {
-    super("-v, --version", { description: "Display version number", logger });
-    this.version = version;
-  }
-  shouldRun(args) {
-    const isEmpty = !args["_"].length && !args["--"]?.length;
-    if (args.version && isEmpty) {
-      return true;
-    } else if (args.v && isEmpty) {
-      return true;
-    } else {
+  };
+  const node = makeTreeNode({
+    command,
+    next() {
       return false;
     }
-  }
-  async run() {
-    this.logger.println(this.version);
-  }
-}
-function isArg(arg) {
-  return arg[0] === "[" && arg[arg.length - 1] === "]" || arg[0] === "<" && arg[arg.length - 1] === ">";
+  });
+  const option = {
+    format: "-v, --version",
+    name: "version",
+    short: "v",
+    type: "boolean",
+    initial: void 0,
+    order: 999999999 + 1,
+    description: "Print version",
+    action() {
+      return node;
+    }
+  };
+  return option;
 }
-
-class Breadc {
-  constructor(name, option) {
-    this.options = [];
-    this.commands = [];
-    this.callbacks = {
-      pre: [],
-      post: []
-    };
-    this.name = name;
-    this._version = option.version ?? "unknown";
-    this.description = option.description;
-    this.logger = createDefaultLogger(name, option.logger);
-    this.commands.push(
-      new VersionCommand(this.version(), this.logger),
-      new HelpCommand(this.commands, this.help.bind(this), this.logger)
-    );
-  }
-  version() {
-    return `${this.name}/${this._version}`;
-  }
-  help(commands = []) {
-    const output = [];
-    const println = (msg) => output.push(msg);
-    println(this.version());
-    if (commands.length === 0) {
-      if (this.description) {
-        println("");
-        if (Array.isArray(this.description)) {
-          for (const line of this.description) {
-            println(line);
-          }
-        } else {
-          println(this.description);
+function makeHelpCommand(name, config) {
+  function expandMessage(message) {
+    const result = [];
+    for (const row of message) {
+      if (typeof row === "function") {
+        const r = row();
+        if (r) {
+          result.push(...expandMessage(r));
+        }
+      } else if (typeof row === "string") {
+        result.push(row);
+      } else if (Array.isArray(row)) {
+        const lines = twoColumn(row);
+        for (const line of lines) {
+          result.push(line);
         }
       }
-      if (this.defaultCommand) {
-        println(``);
-        println(`Usage:`);
-        println(`  $ ${this.name} ${this.defaultCommand.format}`);
-      }
-    } else if (commands.length === 1) {
-      const command = commands[0];
-      if (command.description) {
-        println("");
-        println(command.description);
-      }
-      println(``);
-      println(`Usage:`);
-      println(`  $ ${this.name} ${command.format}`);
-    }
-    if (commands.length !== 1) {
-      const cmdList = (commands.length === 0 ? this.commands : commands).filter(
-        (c) => !c.isInternal
-      );
-      println(``);
-      println(`Commands:`);
-      const commandHelps = cmdList.map(
-        (c) => [`  $ ${this.name} ${c.format}`, c.description]
-      );
-      for (const line of twoColumn(commandHelps)) {
-        println(line);
-      }
-    }
-    println(``);
-    println(`Options:`);
-    const optionHelps = [].concat([
-      ...commands.length > 0 ? commands.flatMap(
-        (cmd) => cmd.options.map(
-          (o) => [`  ${o.format}`, o.description]
-        )
-      ) : [],
-      ...this.options.map(
-        (o) => [`  ${o.format}`, o.description]
-      ),
-      [`  -h, --help`, `Display this message`],
-      [`  -v, --version`, `Display version number`]
-    ]);
-    for (const line of twoColumn(optionHelps)) {
-      println(line);
-    }
-    println(``);
-    return output;
-  }
-  option(format, configOrDescription = "", otherConfig = {}) {
-    const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
-    try {
-      const option = new Option(format, config);
-      this.options.push(option);
-    } catch (error) {
-      this.logger.warn(error.message);
-    }
-    return this;
-  }
-  command(format, configOrDescription = "", otherConfig = {}) {
-    const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
-    const command = new Command(format, { ...config, logger: this.logger });
-    if (command.default) {
-      if (this.defaultCommand) {
-        this.logger.warn("You can not have two default commands.");
-      }
-      this.defaultCommand = command;
     }
-    this.commands.push(command);
-    return command;
+    return result;
   }
-  parse(args) {
-    const allowOptions = [
-      ...this.options,
-      ...this.commands.flatMap((c) => c.options)
-    ];
-    {
-      const names = /* @__PURE__ */ new Map();
-      for (const option of allowOptions) {
-        if (names.has(option.name)) {
-          const otherOption = names.get(option.name);
-          if (otherOption.type !== option.type) {
-            this.logger.warn(`Option "${option.name}" encounters conflict`);
+  function expandCommands(cursor) {
+    const visited = /* @__PURE__ */ new WeakSet();
+    const commands = cursor.command ? [cursor.command] : [];
+    const q = [cursor];
+    visited.add(cursor);
+    for (let i = 0; i < q.length; i++) {
+      const cur = q[i];
+      for (const [_key, cmd] of cur.children) {
+        if (!visited.has(cmd)) {
+          visited.add(cmd);
+          if (cmd.command) {
+            commands.push(cmd.command);
           }
-        } else {
-          names.set(option.name, option);
+          q.push(cmd);
         }
       }
     }
-    const alias = allowOptions.reduce(
-      (map, o) => {
-        if (o.shortcut) {
-          map[o.shortcut] = o.name;
-        }
-        return map;
-      },
-      { h: "help", v: "version" }
-    );
-    const defaultValue = allowOptions.filter(
-      (o) => o.type === "boolean" && o.default !== void 0 && o.default !== null && typeof o.default === "boolean"
-    ).reduce((map, o) => {
-      map[o.name] = o.default;
-      return map;
-    }, {});
-    const argv = minimist(args, {
-      string: allowOptions.filter((o) => o.type === "string").map((o) => o.name),
-      boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name).concat(["help", "version"]),
-      default: defaultValue,
-      alias,
-      "--": true,
-      unknown: (t) => {
-        if (t[0] !== "-")
-          return true;
-        else {
-          if (["--help", "-h", "--version", "-v"].includes(t)) {
-            return true;
+    return commands;
+  }
+  const command = {
+    callback(option2) {
+      const context = option2.__context__;
+      const cursor = option2.__cursor__;
+      const output = [
+        `${name}/${config.version ? config.version : "unknown"}`,
+        () => {
+          if (config.description) {
+            return ["", config.description];
           } else {
-            this.logger.warn(`Find unknown flag "${t}"`);
-            return false;
+            return void 0;
           }
-        }
-      }
-    });
-    for (const shortcut of Object.keys(alias)) {
-      delete argv[shortcut];
+        },
+        () => {
+          const cmds = expandCommands(cursor);
+          if (cmds.length > 0) {
+            return [
+              "",
+              color.bold(color.underline("Commands:")),
+              cmds.map((cmd) => [
+                `  ${color.bold(name)} ${color.bold(cmd.format)}`,
+                cmd.description
+              ])
+            ];
+          } else {
+            return void 0;
+          }
+        },
+        "",
+        color.bold(color.underline("Options:")),
+        [...context.options.entries()].filter(([key, op]) => key === op.name).sort((lhs, rhs) => lhs[1].order - rhs[1].order).map(([_key, op]) => [
+          "  " + (!op.short ? "    " : "") + color.bold(op.format),
+          op.description
+        ]),
+        ""
+      ];
+      const text = expandMessage(output).join("\n");
+      console.log(text);
+      return text;
+    },
+    format: "-h, --help",
+    description: "Print help",
+    _arguments: [],
+    _options: [],
+    option() {
+      return command;
+    },
+    action() {
     }
-    for (const command of this.commands) {
-      if (!command.default && command.shouldRun(argv)) {
-        return command.parseArgs(argv, this.options);
-      }
+  };
+  const node = makeTreeNode({
+    command,
+    next() {
+      return false;
     }
-    if (this.defaultCommand) {
-      this.defaultCommand.shouldRun(argv);
-      return this.defaultCommand.parseArgs(argv, this.options);
+  });
+  const option = {
+    format: "-h, --help",
+    name: "help",
+    short: "h",
+    type: "boolean",
+    initial: void 0,
+    description: "Print help",
+    order: 999999999,
+    action(cursor, _token, context) {
+      context.result.options.__cursor__ = cursor;
+      context.result.options.__context__ = context;
+      return node;
     }
-    const argumentss = argv["_"];
-    const options = argv;
-    delete options["_"];
-    delete options["--"];
-    delete options["help"];
-    delete options["version"];
-    return {
-      command: void 0,
-      arguments: argumentss,
-      options,
-      "--": []
-    };
-  }
-  on(event, fn) {
-    this.callbacks[event].push(fn);
-  }
-  async run(args) {
-    const parsed = this.parse(args);
-    if (parsed.command) {
-      await Promise.all(
-        this.callbacks.pre.map((fn) => fn(parsed.options))
-      );
-      const returnValue = await parsed.command.run(...parsed.arguments, {
-        "--": parsed["--"],
-        ...parsed.options
-      });
-      await Promise.all(
-        this.callbacks.post.map((fn) => fn(parsed.options))
+  };
+  return option;
+}
+
+function breadc(name, config = {}) {
+  let defaultCommand = void 0;
+  const globalOptions = [];
+  const container = makePluginContainer(config.plugins);
+  const root = makeTreeNode({
+    init(context) {
+      initContextOptions(globalOptions, context);
+      if (defaultCommand) {
+        initContextOptions(defaultCommand._options, context);
+      }
+      initContextOptions(
+        [makeHelpCommand(name, config), makeVersionCommand(name, config)],
+        context
       );
-      return returnValue;
-    } else {
+    },
+    finish() {
+    }
+  });
+  const breadc2 = {
+    option(format, _config, _config2 = {}) {
+      const config2 = typeof _config === "string" ? { description: _config, ..._config2 } : _config;
+      const option = makeOption(format, config2);
+      globalOptions.push(option);
+      return breadc2;
+    },
+    command(text, _config = {}) {
+      const config2 = typeof _config === "string" ? { description: _config } : _config;
+      const command = makeCommand(text, config2, root, container);
+      if (command._arguments.length === 0 || command._arguments[0].type !== "const") {
+        defaultCommand = command;
+      }
+      return command;
+    },
+    parse(args) {
+      const result = parse(root, args);
+      return result;
+    },
+    async run(args) {
+      const result = breadc2.parse(args);
+      const command = result.command;
+      if (command) {
+        if (command.callback) {
+          await container.preRun(breadc2);
+          const r = command.callback(...result.arguments, {
+            ...result.options,
+            "--": result["--"]
+          });
+          await container.postRun(breadc2);
+          return r;
+        }
+      }
       return void 0;
     }
-  }
-}
-
-function breadc(name, option = {}) {
-  return new Breadc(name, option);
+  };
+  return breadc2;
 }
 
-module.exports = breadc;
+exports.BreadcError = BreadcError;
+exports.ParseError = ParseError;
+exports.breadc = breadc;
+exports.default = breadc;
+exports.definePlugin = definePlugin;