breadc 0.4.6 → 0.6.1

package/README.md

@@ -6,8 +6,8 @@ Yet another Command Line Application Framework powered by [minimist](https://www
 
 ## Features
 
-+ ⚡️ **Light-weight**: Only 61 kB.
-+ 📖 **East to Learn**: Breadc is basically compatible with [cac](https://github.com/cacjs/cac) and there are only 4 APIs for building a CLI application: `command`, `option`, `action`, `run`.
++ ⚡️ **Light-weight**: Only 40 kB (Unpacked).
++ 📖 **East to Learn**: Breadc is basically compatible with [cac](https://github.com/cacjs/cac) and there are only 5 APIs for building a CLI application: `Breadc`, `command`, `option`, `action`, `run`.
 + 💻 **TypeScript Infer**: IDE will automatically infer the type of your command action function.
 
 ## Installation

package/dist/index.cjs

@@ -1,14 +1,21 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const kolorist = require('kolorist');
 const minimist = require('minimist');
+const kolorist = require('kolorist');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
 
-const kolorist__default = /*#__PURE__*/_interopDefaultLegacy(kolorist);
 const minimist__default = /*#__PURE__*/_interopDefaultLegacy(minimist);
+const kolorist__default = /*#__PURE__*/_interopDefaultLegacy(kolorist);
+
+function twoColumn(texts, split = "  ") {
+  const left = padRight(texts.map((t) => t[0]));
+  return left.map((l, idx) => l + split + texts[idx][1]);
+}
+function padRight(texts, fill = " ") {
+  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
+  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) => {
@@ -64,15 +71,32 @@ Option.OptionRE = /^(-[a-zA-Z0-9], )?--([a-zA-Z0-9\-]+)( \[[a-zA-Z0-9]+\]| <[a-z
 const _Command = class {
   constructor(format, config) {
     this.options = [];
-    this.format = config.condition ? [format] : format.split(" ").map((t) => t.trim()).filter(Boolean);
-    this.default = this.format.length === 0 || this.format[0][0] === "[" || this.format[0][0] === "<";
+    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.conditionFn = config.condition;
     this.logger = config.logger;
-    if (this.format.length > _Command.MaxDep) {
-      this.logger.warn(`Command format string "${format}" is too long`);
+    {
+      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`);
+      }
+      if (pieces.length > _Command.MaxDep) {
+        this.logger.warn(`Command format string "${format}" is too long`);
+      }
     }
   }
+  get isInternal() {
+    return this instanceof InternalCommand;
+  }
+  alias(command) {
+    const pieces = command.split(" ").map((t) => t.trim()).filter(Boolean);
+    this.prefix.push(pieces);
+    return this;
+  }
   option(format, configOrDescription = "", otherConfig = {}) {
     const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
     try {
@@ -83,59 +107,63 @@ const _Command = class {
     }
     return this;
   }
-  get hasConditionFn() {
-    return !!this.conditionFn;
-  }
-  shouldRun(args) {
-    if (this.conditionFn) {
-      return this.conditionFn(args);
+  hasPrefix(parsedArgs) {
+    const argv = parsedArgs["_"];
+    if (argv.length === 0) {
+      return this.default;
     } else {
-      if (this.default)
-        return true;
-      const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
-      for (let i = 0; i < this.format.length; i++) {
-        if (!isCmd(this.format[i])) {
+      for (const prefix of this.prefix) {
+        if (prefix.length > 0 && prefix[0] === argv[0]) {
           return true;
         }
-        if (i >= args["_"].length || this.format[i] !== args["_"][i]) {
-          return false;
-        }
       }
-      return true;
+      return false;
     }
   }
-  parseArgs(args, globalOptions) {
-    if (this.conditionFn) {
-      const argumentss2 = args["_"];
-      const options2 = args;
-      delete options2["_"];
-      return {
-        command: this,
-        arguments: argumentss2,
-        options: args
-      };
+  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;
+        }
+      }
+      if (match) {
+        args.splice(0, prefix.length);
+        return true;
+      }
     }
-    const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
-    const argumentss = [];
-    for (let i = 0; i < this.format.length; i++) {
-      if (isCmd(this.format[i]))
-        continue;
-      if (i < args["_"].length) {
-        if (this.format[i].startsWith("[...")) {
-          argumentss.push(args["_"].slice(i).map(String));
+    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 {
-          argumentss.push(String(args["_"][i]));
+          args.push(String(pieces[i]));
+          used++;
         }
       } else {
-        if (this.format[i].startsWith("<")) {
-          this.logger.warn(`You should provide the argument "${this.format[i]}"`);
-          argumentss.push(void 0);
-        } else if (this.format[i].startsWith("[...")) {
-          argumentss.push([]);
-        } else if (this.format[i].startsWith("[")) {
-          argumentss.push(void 0);
+        if (this.arguments[i].startsWith("<")) {
+          this.logger.warn(`You should provide the argument "${this.arguments[i]}"`);
+          args.push("");
+        } else if (this.arguments[i].startsWith("[...")) {
+          args.push([]);
+        } else if (this.arguments[i].startsWith("[")) {
+          args.push(void 0);
         } else {
-          this.logger.warn(`unknown format string ("${this.format[i]}")`);
+          this.logger.warn(`unknown format string ("${this.arguments[i]}")`);
         }
       }
     }
@@ -143,7 +171,7 @@ const _Command = class {
       map.set(o.name, o);
       return map;
     }, /* @__PURE__ */ new Map());
-    const options = args;
+    const options = argv;
     delete options["_"];
     for (const [name, rawOption] of fullOptions) {
       if (rawOption.required) {
@@ -159,13 +187,14 @@ const _Command = class {
           options[name] = void 0;
         }
       }
-      if (rawOption.construct) {
-        options[name] = rawOption.construct(options[name]);
-      } else if (rawOption.default) {
-        if (!options[name]) {
+      if (rawOption.default !== void 0) {
+        if (options[name] === void 0 || options[name] === false) {
           options[name] = rawOption.default;
         }
       }
+      if (rawOption.construct !== void 0) {
+        options[name] = rawOption.construct(options[name]);
+      }
     }
     for (const key of Object.keys(options)) {
       if (!fullOptions.has(key)) {
@@ -174,66 +203,103 @@ const _Command = class {
     }
     return {
       command: this,
-      arguments: argumentss,
-      options
+      arguments: args,
+      options,
+      "--": restArgs
     };
   }
   action(fn) {
     this.actionFn = fn;
-    return this;
   }
   async run(...args) {
     if (this.actionFn) {
-      return await this.actionFn(...args, { logger: this.logger });
+      return await this.actionFn(...args, {
+        logger: this.logger,
+        color: kolorist__default
+      });
     } else {
-      this.logger.warn(`You may miss action function in "${this.format}"`);
+      this.logger.warn(`You may miss action function in ${this.format ? `"${this.format}"` : "<default command>"}`);
+      return void 0;
     }
   }
 };
 let Command = _Command;
 Command.MaxDep = 5;
-function createHelpCommand(breadc) {
-  let helpCommand = void 0;
-  return new Command("-h, --help", {
-    condition(args) {
-      const isEmpty = !args["--"]?.length;
-      if ((args.help || args.h) && isEmpty) {
-        if (args["_"].length > 0) {
-          for (const cmd of breadc.commands) {
-            if (!cmd.hasConditionFn && !cmd.default && cmd.shouldRun(args)) {
-              helpCommand = cmd;
-              return true;
+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 {
+      command: this,
+      arguments: argumentss,
+      options: args,
+      "--": []
+    };
+  }
+}
+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;
       }
-    },
-    logger: breadc.logger
-  }).action(() => {
-    for (const line of breadc.help(helpCommand)) {
-      breadc.logger.println(line);
+      return true;
+    } else {
+      return false;
     }
-  });
+  }
+  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);
+  }
 }
-function createVersionCommand(breadc) {
-  return new Command("-v, --version", {
-    condition(args) {
-      const isEmpty = !args["_"].length && !args["--"]?.length;
-      if (args.version && isEmpty) {
-        return true;
-      } else if (args.v && isEmpty) {
-        return true;
-      } else {
-        return false;
-      }
-    },
-    logger: breadc.logger
-  }).action(() => {
-    breadc.logger.println(breadc.version());
-  });
+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 {
+      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] === ">";
 }
 
 class Breadc {
@@ -248,24 +314,16 @@ class Breadc {
     this._version = option.version ?? "unknown";
     this.description = option.description;
     this.logger = createDefaultLogger(name, option.logger);
-    const breadc = {
-      name: this.name,
-      version: () => this.version.call(this),
-      help: (command) => this.help.call(this, command),
-      logger: this.logger,
-      options: this.options,
-      commands: this.commands
-    };
-    this.commands.push(createVersionCommand(breadc), createHelpCommand(breadc));
+    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(command) {
+  help(commands = []) {
     const output = [];
     const println = (msg) => output.push(msg);
     println(this.version());
-    if (!command) {
+    if (commands.length === 0) {
       if (this.description) {
         println("");
         if (Array.isArray(this.description)) {
@@ -276,27 +334,26 @@ class Breadc {
           println(this.description);
         }
       }
-    } else {
-      if (command.description) {
-        println("");
-        println(command.description);
-      }
-    }
-    if (!command) {
       if (this.defaultCommand) {
         println(``);
         println(`Usage:`);
-        println(`  $ ${this.name} ${this.defaultCommand.format.join(" ")}`);
+        println(`  $ ${this.name} ${this.defaultCommand.format}`);
+      }
+    } else if (commands.length === 1) {
+      const command = commands[0];
+      if (command.description) {
+        println("");
+        println(command.description);
       }
-    } else {
       println(``);
       println(`Usage:`);
-      println(`  $ ${this.name} ${command.format.join(" ")}`);
+      println(`  $ ${this.name} ${command.format}`);
     }
-    if (!command && this.commands.length > 2) {
+    if (commands.length !== 1) {
+      const cmdList = (commands.length === 0 ? this.commands : commands).filter((c) => !c.isInternal);
       println(``);
       println(`Commands:`);
-      const commandHelps = this.commands.filter((c) => !c.hasConditionFn).map((c) => [`  $ ${this.name} ${c.format.join(" ")}`, c.description]);
+      const commandHelps = cmdList.map((c) => [`  $ ${this.name} ${c.format}`, c.description]);
       for (const line of twoColumn(commandHelps)) {
         println(line);
       }
@@ -304,7 +361,7 @@ class Breadc {
     println(``);
     println(`Options:`);
     const optionHelps = [].concat([
-      ...command ? command.options.map((o) => [`  ${o.format}`, o.description]) : [],
+      ...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`]
@@ -342,16 +399,30 @@ class Breadc {
       ...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`);
+          }
+        } else {
+          names.set(option.name, option);
+        }
+      }
+    }
     const alias = allowOptions.reduce((map, o) => {
       if (o.shortcut) {
         map[o.shortcut] = o.name;
       }
       return map;
-    }, {});
+    }, { h: "help", v: "version" });
     const argv = minimist__default(args, {
       string: allowOptions.filter((o) => o.type === "string").map((o) => o.name),
-      boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name),
+      boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name).concat(["help", "version"]),
       alias,
+      "--": true,
       unknown: (t) => {
         if (t[0] !== "-")
           return true;
@@ -374,15 +445,20 @@ class Breadc {
       }
     }
     if (this.defaultCommand) {
+      this.defaultCommand.shouldRun(argv);
       return this.defaultCommand.parseArgs(argv, this.options);
     }
     const argumentss = argv["_"];
     const options = argv;
     delete options["_"];
+    delete options["--"];
+    delete options["help"];
+    delete options["version"];
     return {
       command: void 0,
       arguments: argumentss,
-      options
+      options,
+      "--": []
     };
   }
   on(event, fn) {
@@ -392,25 +468,20 @@ class Breadc {
     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.options);
+      const returnValue = await parsed.command.run(...parsed.arguments, {
+        "--": parsed["--"],
+        ...parsed.options
+      });
       await Promise.all(this.callbacks.post.map((fn) => fn(parsed.options)));
       return returnValue;
+    } else {
+      return void 0;
     }
   }
 }
-function twoColumn(texts, split = "  ") {
-  const left = padRight(texts.map((t) => t[0]));
-  return left.map((l, idx) => l + split + texts[idx][1]);
-}
-function padRight(texts, fill = " ") {
-  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
-  return texts.map((t) => t + fill.repeat(length - t.length));
-}
 
 function breadc(name, option = {}) {
   return new Breadc(name, option);
 }
 
-exports.kolorist = kolorist__default;
-exports.minimist = minimist__default;
-exports["default"] = breadc;
+module.exports = breadc;

package/dist/index.d.ts

@@ -1,10 +1,18 @@
+import kolorist from 'kolorist';
 import { ParsedArgs } from 'minimist';
-export { default as minimist } from 'minimist';
-export { default as kolorist } from 'kolorist';
 
 interface OptionConfig<F extends string, T = never> {
+    /**
+     * Option description
+     */
     description?: string;
-    default?: T;
+    /**
+     * Option string default value
+     */
+    default?: string;
+    /**
+     * Transform option text
+     */
     construct?: (rawText: ExtractOptionType<F>) => T;
 }
 /**
@@ -20,7 +28,7 @@ declare class Option<T extends string = string, F = string> {
     private static OptionRE;
     readonly name: string;
     readonly shortcut?: string;
-    readonly default?: F;
+    readonly default?: string;
     readonly format: string;
     readonly description: string;
     readonly type: 'string' | 'boolean';
@@ -29,29 +37,30 @@ declare class Option<T extends string = string, F = string> {
     constructor(format: T, config?: OptionConfig<T, F>);
 }
 
-declare type ConditionFn = (args: ParsedArgs) => boolean;
 interface CommandConfig {
     description?: string;
 }
 declare class Command<F extends string = string, CommandOption extends object = {}> {
-    private static MaxDep;
-    private readonly conditionFn?;
-    private readonly logger;
-    readonly format: string[];
-    readonly default: boolean;
+    protected static MaxDep: number;
+    protected readonly logger: Logger;
+    readonly format: string;
     readonly description: string;
+    readonly prefix: string[][];
+    readonly arguments: string[];
+    readonly default: boolean;
     readonly options: Option[];
     private actionFn?;
     constructor(format: F, config: CommandConfig & {
-        condition?: ConditionFn;
         logger: Logger;
     });
+    get isInternal(): boolean;
+    alias(command: string): this;
     option<OF extends string, T = undefined>(format: OF, description: string, config?: Omit<OptionConfig<OF, T>, 'description'>): Command<F, CommandOption & ExtractOption<OF, T>>;
     option<OF extends string, T = undefined>(format: OF, config?: OptionConfig<OF, T>): Command<F, CommandOption & ExtractOption<OF, T>>;
-    get hasConditionFn(): boolean;
-    shouldRun(args: ParsedArgs): boolean;
-    parseArgs(args: ParsedArgs, globalOptions: Option[]): ParseResult;
-    action(fn: ActionFn<ExtractCommand<F>, CommandOption>): this;
+    hasPrefix(parsedArgs: ParsedArgs): boolean;
+    shouldRun(parsedArgs: ParsedArgs): boolean;
+    parseArgs(argv: ParsedArgs, globalOptions: Option[]): ParseResult;
+    action(fn: ActionFn<ExtractCommand<F>, CommandOption>): void;
     run(...args: any[]): Promise<any>;
 }
 
@@ -73,6 +82,7 @@ interface ParseResult {
     command: Command | undefined;
     arguments: any[];
     options: Record<string, string>;
+    '--': string[];
 }
 declare type ExtractOption<T extends string, D = undefined> = {
     [k in ExtractOptionName<T>]: D extends undefined ? ExtractOptionType<T> : D;
@@ -92,8 +102,11 @@ declare type Letter = Lowercase | Uppercase;
 declare type Push<T extends any[], U, R> = [...T, U, R];
 declare type Context = {
     logger: Logger;
+    color: typeof kolorist;
 };
-declare type ActionFn<T extends any[], Option extends object = {}, R = any> = (...arg: Push<T, Option, Context>) => R | Promise<R>;
+declare type ActionFn<T extends any[], Option extends object = {}, R = any> = (...arg: Push<T, Option & {
+    '--': string[];
+}, Context>) => R | Promise<R>;
 /**
  * Max Dep: 5
  *
@@ -105,13 +118,13 @@ declare class Breadc<GlobalOption extends object = {}> {
     private readonly name;
     private readonly _version;
     private readonly description?;
+    readonly logger: Logger;
     private readonly options;
     private readonly commands;
     private defaultCommand?;
-    readonly logger: Logger;
     constructor(name: string, option: AppOption);
     version(): string;
-    help(command?: Command): string[];
+    help(commands?: Command[]): string[];
     option<F extends string, T = undefined>(format: F, description: string, config?: Omit<OptionConfig<F, T>, 'description'>): Breadc<GlobalOption & ExtractOption<F, T>>;
     option<F extends string, T = undefined>(format: F, config?: OptionConfig<F, T>): Breadc<GlobalOption & ExtractOption<F, T>>;
     command<F extends string>(format: F, description: string, config?: Omit<CommandConfig, 'description'>): Command<F, GlobalOption>;
@@ -119,9 +132,9 @@ declare class Breadc<GlobalOption extends object = {}> {
     parse(args: string[]): ParseResult;
     private readonly callbacks;
     on(event: 'pre' | 'post', fn: (option: GlobalOption) => void | Promise<void>): void;
-    run(args: string[]): Promise<any>;
+    run<T>(args: string[]): Promise<T | undefined>;
 }
 
-declare function breadc(name: string, option?: AppOption): Breadc<{}>;
+declare function breadc<T extends object = {}>(name: string, option?: AppOption): Breadc<T>;
 
 export { breadc as default };

package/dist/index.mjs

@@ -1,7 +1,14 @@
-import { blue, yellow, red, gray } from 'kolorist';
-export { default as kolorist } from 'kolorist';
 import minimist from 'minimist';
-export { default as minimist } from 'minimist';
+import kolorist, { blue, yellow, red, gray } from 'kolorist';
+
+function twoColumn(texts, split = "  ") {
+  const left = padRight(texts.map((t) => t[0]));
+  return left.map((l, idx) => l + split + texts[idx][1]);
+}
+function padRight(texts, fill = " ") {
+  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
+  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) => {
@@ -57,15 +64,32 @@ Option.OptionRE = /^(-[a-zA-Z0-9], )?--([a-zA-Z0-9\-]+)( \[[a-zA-Z0-9]+\]| <[a-z
 const _Command = class {
   constructor(format, config) {
     this.options = [];
-    this.format = config.condition ? [format] : format.split(" ").map((t) => t.trim()).filter(Boolean);
-    this.default = this.format.length === 0 || this.format[0][0] === "[" || this.format[0][0] === "<";
+    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.conditionFn = config.condition;
     this.logger = config.logger;
-    if (this.format.length > _Command.MaxDep) {
-      this.logger.warn(`Command format string "${format}" is too long`);
+    {
+      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`);
+      }
+      if (pieces.length > _Command.MaxDep) {
+        this.logger.warn(`Command format string "${format}" is too long`);
+      }
     }
   }
+  get isInternal() {
+    return this instanceof InternalCommand;
+  }
+  alias(command) {
+    const pieces = command.split(" ").map((t) => t.trim()).filter(Boolean);
+    this.prefix.push(pieces);
+    return this;
+  }
   option(format, configOrDescription = "", otherConfig = {}) {
     const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
     try {
@@ -76,59 +100,63 @@ const _Command = class {
     }
     return this;
   }
-  get hasConditionFn() {
-    return !!this.conditionFn;
-  }
-  shouldRun(args) {
-    if (this.conditionFn) {
-      return this.conditionFn(args);
+  hasPrefix(parsedArgs) {
+    const argv = parsedArgs["_"];
+    if (argv.length === 0) {
+      return this.default;
     } else {
-      if (this.default)
-        return true;
-      const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
-      for (let i = 0; i < this.format.length; i++) {
-        if (!isCmd(this.format[i])) {
+      for (const prefix of this.prefix) {
+        if (prefix.length > 0 && prefix[0] === argv[0]) {
           return true;
         }
-        if (i >= args["_"].length || this.format[i] !== args["_"][i]) {
-          return false;
-        }
       }
-      return true;
+      return false;
     }
   }
-  parseArgs(args, globalOptions) {
-    if (this.conditionFn) {
-      const argumentss2 = args["_"];
-      const options2 = args;
-      delete options2["_"];
-      return {
-        command: this,
-        arguments: argumentss2,
-        options: args
-      };
+  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;
+        }
+      }
+      if (match) {
+        args.splice(0, prefix.length);
+        return true;
+      }
     }
-    const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
-    const argumentss = [];
-    for (let i = 0; i < this.format.length; i++) {
-      if (isCmd(this.format[i]))
-        continue;
-      if (i < args["_"].length) {
-        if (this.format[i].startsWith("[...")) {
-          argumentss.push(args["_"].slice(i).map(String));
+    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 {
-          argumentss.push(String(args["_"][i]));
+          args.push(String(pieces[i]));
+          used++;
         }
       } else {
-        if (this.format[i].startsWith("<")) {
-          this.logger.warn(`You should provide the argument "${this.format[i]}"`);
-          argumentss.push(void 0);
-        } else if (this.format[i].startsWith("[...")) {
-          argumentss.push([]);
-        } else if (this.format[i].startsWith("[")) {
-          argumentss.push(void 0);
+        if (this.arguments[i].startsWith("<")) {
+          this.logger.warn(`You should provide the argument "${this.arguments[i]}"`);
+          args.push("");
+        } else if (this.arguments[i].startsWith("[...")) {
+          args.push([]);
+        } else if (this.arguments[i].startsWith("[")) {
+          args.push(void 0);
         } else {
-          this.logger.warn(`unknown format string ("${this.format[i]}")`);
+          this.logger.warn(`unknown format string ("${this.arguments[i]}")`);
         }
       }
     }
@@ -136,7 +164,7 @@ const _Command = class {
       map.set(o.name, o);
       return map;
     }, /* @__PURE__ */ new Map());
-    const options = args;
+    const options = argv;
     delete options["_"];
     for (const [name, rawOption] of fullOptions) {
       if (rawOption.required) {
@@ -152,13 +180,14 @@ const _Command = class {
           options[name] = void 0;
         }
       }
-      if (rawOption.construct) {
-        options[name] = rawOption.construct(options[name]);
-      } else if (rawOption.default) {
-        if (!options[name]) {
+      if (rawOption.default !== void 0) {
+        if (options[name] === void 0 || options[name] === false) {
           options[name] = rawOption.default;
         }
       }
+      if (rawOption.construct !== void 0) {
+        options[name] = rawOption.construct(options[name]);
+      }
     }
     for (const key of Object.keys(options)) {
       if (!fullOptions.has(key)) {
@@ -167,66 +196,103 @@ const _Command = class {
     }
     return {
       command: this,
-      arguments: argumentss,
-      options
+      arguments: args,
+      options,
+      "--": restArgs
     };
   }
   action(fn) {
     this.actionFn = fn;
-    return this;
   }
   async run(...args) {
     if (this.actionFn) {
-      return await this.actionFn(...args, { logger: this.logger });
+      return await this.actionFn(...args, {
+        logger: this.logger,
+        color: kolorist
+      });
     } else {
-      this.logger.warn(`You may miss action function in "${this.format}"`);
+      this.logger.warn(`You may miss action function in ${this.format ? `"${this.format}"` : "<default command>"}`);
+      return void 0;
     }
   }
 };
 let Command = _Command;
 Command.MaxDep = 5;
-function createHelpCommand(breadc) {
-  let helpCommand = void 0;
-  return new Command("-h, --help", {
-    condition(args) {
-      const isEmpty = !args["--"]?.length;
-      if ((args.help || args.h) && isEmpty) {
-        if (args["_"].length > 0) {
-          for (const cmd of breadc.commands) {
-            if (!cmd.hasConditionFn && !cmd.default && cmd.shouldRun(args)) {
-              helpCommand = cmd;
-              return true;
+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 {
+      command: this,
+      arguments: argumentss,
+      options: args,
+      "--": []
+    };
+  }
+}
+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;
       }
-    },
-    logger: breadc.logger
-  }).action(() => {
-    for (const line of breadc.help(helpCommand)) {
-      breadc.logger.println(line);
+      return true;
+    } else {
+      return false;
     }
-  });
+  }
+  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);
+  }
 }
-function createVersionCommand(breadc) {
-  return new Command("-v, --version", {
-    condition(args) {
-      const isEmpty = !args["_"].length && !args["--"]?.length;
-      if (args.version && isEmpty) {
-        return true;
-      } else if (args.v && isEmpty) {
-        return true;
-      } else {
-        return false;
-      }
-    },
-    logger: breadc.logger
-  }).action(() => {
-    breadc.logger.println(breadc.version());
-  });
+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 {
+      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] === ">";
 }
 
 class Breadc {
@@ -241,24 +307,16 @@ class Breadc {
     this._version = option.version ?? "unknown";
     this.description = option.description;
     this.logger = createDefaultLogger(name, option.logger);
-    const breadc = {
-      name: this.name,
-      version: () => this.version.call(this),
-      help: (command) => this.help.call(this, command),
-      logger: this.logger,
-      options: this.options,
-      commands: this.commands
-    };
-    this.commands.push(createVersionCommand(breadc), createHelpCommand(breadc));
+    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(command) {
+  help(commands = []) {
     const output = [];
     const println = (msg) => output.push(msg);
     println(this.version());
-    if (!command) {
+    if (commands.length === 0) {
       if (this.description) {
         println("");
         if (Array.isArray(this.description)) {
@@ -269,27 +327,26 @@ class Breadc {
           println(this.description);
         }
       }
-    } else {
-      if (command.description) {
-        println("");
-        println(command.description);
-      }
-    }
-    if (!command) {
       if (this.defaultCommand) {
         println(``);
         println(`Usage:`);
-        println(`  $ ${this.name} ${this.defaultCommand.format.join(" ")}`);
+        println(`  $ ${this.name} ${this.defaultCommand.format}`);
+      }
+    } else if (commands.length === 1) {
+      const command = commands[0];
+      if (command.description) {
+        println("");
+        println(command.description);
       }
-    } else {
       println(``);
       println(`Usage:`);
-      println(`  $ ${this.name} ${command.format.join(" ")}`);
+      println(`  $ ${this.name} ${command.format}`);
     }
-    if (!command && this.commands.length > 2) {
+    if (commands.length !== 1) {
+      const cmdList = (commands.length === 0 ? this.commands : commands).filter((c) => !c.isInternal);
       println(``);
       println(`Commands:`);
-      const commandHelps = this.commands.filter((c) => !c.hasConditionFn).map((c) => [`  $ ${this.name} ${c.format.join(" ")}`, c.description]);
+      const commandHelps = cmdList.map((c) => [`  $ ${this.name} ${c.format}`, c.description]);
       for (const line of twoColumn(commandHelps)) {
         println(line);
       }
@@ -297,7 +354,7 @@ class Breadc {
     println(``);
     println(`Options:`);
     const optionHelps = [].concat([
-      ...command ? command.options.map((o) => [`  ${o.format}`, o.description]) : [],
+      ...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`]
@@ -335,16 +392,30 @@ class Breadc {
       ...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`);
+          }
+        } else {
+          names.set(option.name, option);
+        }
+      }
+    }
     const alias = allowOptions.reduce((map, o) => {
       if (o.shortcut) {
         map[o.shortcut] = o.name;
       }
       return map;
-    }, {});
+    }, { h: "help", v: "version" });
     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),
+      boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name).concat(["help", "version"]),
       alias,
+      "--": true,
       unknown: (t) => {
         if (t[0] !== "-")
           return true;
@@ -367,15 +438,20 @@ class Breadc {
       }
     }
     if (this.defaultCommand) {
+      this.defaultCommand.shouldRun(argv);
       return this.defaultCommand.parseArgs(argv, this.options);
     }
     const argumentss = argv["_"];
     const options = argv;
     delete options["_"];
+    delete options["--"];
+    delete options["help"];
+    delete options["version"];
     return {
       command: void 0,
       arguments: argumentss,
-      options
+      options,
+      "--": []
     };
   }
   on(event, fn) {
@@ -385,20 +461,17 @@ class Breadc {
     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.options);
+      const returnValue = await parsed.command.run(...parsed.arguments, {
+        "--": parsed["--"],
+        ...parsed.options
+      });
       await Promise.all(this.callbacks.post.map((fn) => fn(parsed.options)));
       return returnValue;
+    } else {
+      return void 0;
     }
   }
 }
-function twoColumn(texts, split = "  ") {
-  const left = padRight(texts.map((t) => t[0]));
-  return left.map((l, idx) => l + split + texts[idx][1]);
-}
-function padRight(texts, fill = " ") {
-  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
-  return texts.map((t) => t + fill.repeat(length - t.length));
-}
 
 function breadc(name, option = {}) {
   return new Breadc(name, option);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breadc",
-  "version": "0.4.6",
+  "version": "0.6.1",
   "description": "Yet another Command Line Application Framework with fully strong TypeScript support",
   "keywords": [
     "cli",
@@ -43,11 +43,11 @@
     "bumpp": "^8.2.1",
     "prettier": "^2.7.1",
     "typescript": "^4.7.4",
-    "unbuild": "^0.7.4",
-    "vite": "^2.9.12",
-    "vitest": "^0.16.0"
+    "unbuild": "^0.7.6",
+    "vite": "^3.0.4",
+    "vitest": "^0.19.1"
   },
-  "packageManager": "pnpm@7.3.0",
+  "packageManager": "pnpm@7.5.2",
   "scripts": {
     "build": "unbuild",
     "format": "prettier --write src/**/*.ts test/*.ts examples/*.ts",