erii 3.0.0-beta.1 → 3.0.0-beta.2

package/dist/index.d.mts

@@ -1,117 +1,193 @@
 import validator from "validator";
 //#region src/types.d.ts
+/** Raw values the CLI parser may return; generic declarations do not convert them. */
 type ArgumentValue = string | number | boolean | ArgumentValue[] | {
   [key: string]: ArgumentValue;
 };
+/** Raw options stored internally, before narrowing to a command schema. */
 type CommandOptions = Record<string, ArgumentValue | undefined>;
 interface ParsedArguments extends CommandOptions {
   _: Array<string | number>;
 }
-type CommandHandler = (ctx: CommandCtx, options: CommandOptions) => unknown;
 type LifecycleHandler = () => unknown;
+/** Custom validators receive raw values and return false when validation fails. */
 type ArgumentValidator = (value: ArgumentValue | undefined, logger: (message: string) => void) => boolean;
-type ValidatorName = { [K in keyof typeof validator]: typeof validator[K] extends ((value: string) => boolean) ? K : never; }[keyof typeof validator];
+/** Only validator.js methods callable with a single string and returning a boolean are allowed. */
+type ValidatorName = { [K in keyof typeof validator]: (typeof validator)[K] extends ((value: string) => boolean) ? K : never; }[keyof typeof validator];
 interface MetaInfo {
   version?: string;
   name?: string;
 }
-interface Command {
-  name: string | string[];
-  description?: string;
-  argument?: Argument;
-  alias?: string[];
-  redirect?: string;
-  options?: Option[];
-  handler?: CommandHandler;
-}
-interface Option {
-  name: string | string[];
-  description?: string;
-  command?: string;
-  argument?: Argument;
-}
-interface CommandMap {
-  [key: string]: Command | undefined;
-}
-interface CommandCtx {
-  showVersion: () => void;
-  showHelp: () => void;
-  getArgument: (commandName?: string) => ArgumentValue | undefined;
-}
+/** Argument metadata and runtime validation rules for a command or option. */
 interface Argument {
   name: string;
   description: string;
   validate?: ValidatorName | ArgumentValidator;
 }
+type SchemaCommands<Schema> = Schema extends {
+  commands: infer Commands;
+} ? Commands : never;
+type LocalOptions<Command> = Command extends {
+  options?: infer Options;
+} ? NonNullable<Options> : {};
+type CommonOptions<Schema> = Schema extends {
+  commonOptions?: infer Options;
+} ? NonNullable<Options> : {};
+type SchemaOptionValues<Options> = { [Name in keyof Options]: ArgumentValue | undefined; };
+type SchemaCommand<Command> = {
+  argument?: ArgumentValue;
+  options?: SchemaOptionValues<LocalOptions<Command>>;
+  aliases?: string;
+};
+type DefaultSchema = {
+  commands: Record<string, {
+    options?: CommandOptions;
+  }>;
+  commonOptions?: CommandOptions;
+};
+/**
+ * Compile-time schema constraints, with no role in runtime parsing or validation.
+ * Checks the supplied schema's own keys, supporting named interfaces without widening valid names.
+ */
+interface EriiSchema<Schema = DefaultSchema> {
+  commonOptions?: SchemaOptionValues<CommonOptions<Schema>>;
+  commands: { [Name in keyof SchemaCommands<Schema>]: SchemaCommand<SchemaCommands<Schema>[Name]>; };
+}
+type CommandName<Schema extends EriiSchema<Schema>> = Extract<keyof Schema["commands"], string>;
+type CommandAliases<Command> = "aliases" extends keyof Command ? Extract<Command["aliases"], string> : never;
+/** All valid command lookup names, including aliases declared in the schema. */
+type CommandLookup<Schema extends EriiSchema<Schema>> = { [Name in CommandName<Schema>]: Name | CommandAliases<Schema["commands"][Name]>; }[CommandName<Schema>];
+/** Resolves a primary name or alias to its command key in the schema. */
+type ResolveCommand<Schema extends EriiSchema<Schema>, Lookup extends CommandLookup<Schema>> = { [Name in CommandName<Schema>]: Lookup extends Name | CommandAliases<Schema["commands"][Name]> ? Name : never; }[CommandName<Schema>];
+/** Detects argument declarations by key presence, preserving the optional value type of argument?: T. */
+type CommandArgument<Command> = "argument" extends keyof Command ? Command["argument"] : ArgumentValue;
+type LowerLetter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+/** Generates candidate camelCase names for kebab-case keys; underscores are not converted. */
+type CamelKey<Key extends string> = Key extends `${infer Head}-${infer Letter}${infer Tail}` ? Letter extends LowerLetter ? `${Head}${Uppercase<Letter>}${CamelKey<Tail>}` : `${Head}-${CamelKey<`${Letter}${Tail}`>}` : Key;
+type KebabLetter<Letter extends string> = Letter extends Uppercase<LowerLetter> ? `-${Lowercase<Letter>}` : Letter;
+type KebabTail<Key extends string> = Key extends `${infer Head}${infer Tail}` ? `${KebabLetter<Head>}${KebabTail<Tail>}` : Key;
+/** Matches runtime toKebabCase: lowercases the first letter and inserts hyphens before subsequent uppercase ASCII letters. */
+type KebabKey<Key extends string> = Key extends `${infer Head}${infer Tail}` ? `${Lowercase<Head>}${KebabTail<Tail>}` : Key;
+/** Only candidates that the proxy can resolve back to the original key are valid aliases. */
+type CamelAliases<Options> = { [Name in Extract<keyof Options, string>]: KebabKey<CamelKey<Name>> extends Name ? CamelKey<Name> : never; }[Extract<keyof Options, string>];
+type OptionValue<Options, Name> = Name extends keyof Options ? Options[Name] : never;
+type FallbackOptionValue<Options, Name> = Name extends string ? OptionValue<Options, KebabKey<Name>> : never;
+/**
+ * Matches proxy reads: checks the original key first, then falls back to the kebab-case key when absent.
+ * Name collisions may yield either value; any option may be omitted.
+ */
+type ProxiedOptions<Options> = { readonly [Name in keyof Options | CamelAliases<Options>]?: OptionValue<Options, Name> | FallbackOptionValue<Options, Name>; };
+/** Common option names take precedence and are excluded from command-specific declarations. */
+type ScopedOptions<Schema extends EriiSchema<Schema>, Name extends CommandName<Schema>> = Omit<LocalOptions<Schema["commands"][Name]>, keyof CommonOptions<Schema>>;
+/** Options available to a handler: command-specific options, common options, and camelCase aliases. */
+type TypedCommandOptions<Schema extends EriiSchema<Schema>, Name extends CommandName<Schema>> = ProxiedOptions<ScopedOptions<Schema, Name> & CommonOptions<Schema>>;
+/** Reads the current command's argument when no name is supplied, or the argument of the named command or alias. */
+interface TypedCommandCtx<Schema extends EriiSchema<Schema>, Name extends CommandName<Schema>> {
+  showVersion: () => void;
+  showHelp: () => void;
+  getArgument(): CommandArgument<Schema["commands"][Name]> | undefined;
+  getArgument<Lookup extends CommandLookup<Schema>>(name: Lookup): LookupArgument<Schema, Lookup> | undefined;
+}
+/** Provides context and option types matching the specified command for independently defined handlers. */
+type TypedCommandHandler<Schema extends EriiSchema<Schema>, Name extends CommandName<Schema>> = (ctx: TypedCommandCtx<Schema, Name>, options: TypedCommandOptions<Schema, Name>) => unknown;
+/** Argument metadata is required, optional, or forbidden according to the schema declaration. */
+type ArgumentDefinition<Command> = "argument" extends keyof Command ? {} extends Pick<Command, "argument"> ? {
+  argument?: Argument;
+} : {
+  argument: Argument;
+} : {
+  argument?: never;
+};
+/** bind configuration: the first name must be the primary command name; subsequent names must be its aliases. */
+type TypedCommand<Schema extends EriiSchema<Schema>, Name extends CommandName<Schema>> = {
+  name: Name | readonly [Name, ...CommandAliases<Schema["commands"][Name]>[]];
+  description?: string;
+} & ArgumentDefinition<Schema["commands"][Name]>;
+type OptionDefinition<Name extends string> = {
+  name: Name | readonly [Name, ...string[]];
+  description?: string;
+  argument?: Argument;
+};
+/** Generates a separate configuration for each option, preserving the association between its name and command scope. */
+type OptionDefinitions<Options, Scope> = { [Name in Extract<keyof Options, string>]: OptionDefinition<Name> & Scope; }[Extract<keyof Options, string>];
+type ScopedOptionDefinitions<Schema extends EriiSchema<Schema>> = { [Name in CommandName<Schema>]: OptionDefinitions<ScopedOptions<Schema, Name>, {
+  command: Name | CommandAliases<Schema["commands"][Name]>;
+}>; }[CommandName<Schema>];
+/** addOption configuration: common options omit command; scoped options must specify their owning command or alias. */
+type TypedOption<Schema extends EriiSchema<Schema>> = OptionDefinitions<CommonOptions<Schema>, {
+  command?: never;
+}> | ScopedOptionDefinitions<Schema>;
+/** Internal lookup result for Erii.getArgument; the method signature separately accounts for missing values. */
+type LookupArgument<Schema extends EriiSchema<Schema>, Lookup extends CommandLookup<Schema>> = CommandArgument<Schema["commands"][ResolveCommand<Schema, Lookup>]>;
 //#endregion
 //#region src/erii.d.ts
-export declare class Erii {
+export declare class Erii<S extends EriiSchema<S> = never> {
   rawArguments: string[];
   parsedArguments: ParsedArguments;
   private version;
   private name;
-  commands: CommandMap;
-  commonOptions: Option[];
+  private commands;
+  private commonOptions;
   validator: typeof validator;
   alwaysHandler?: LifecycleHandler;
   defaultHandler?: LifecycleHandler;
-  constructor();
+  constructor(..._schema: [S] extends [never] ? [schema: never] : []);
   /**
-   * 绑定命令处理函数
+   * Binds a command handler.
    * @param config
    * @param handler
    */
-  bind(config: Command, handler: CommandHandler): void;
+  bind<K extends CommandName<S>>(config: TypedCommand<S, K>, handler: TypedCommandHandler<S, NoInfer<K>>): void;
+  private bindCommand;
   /**
-   * 总是执行
+   * Registers a handler that runs on every start.
    * @param handler
    */
   always(handler: LifecycleHandler): void;
   default(handler: LifecycleHandler): void;
   /**
-   * 增加设置项
+   * Registers an option.
    * @param config
    */
-  addOption(config: Option): void;
+  addOption(config: TypedOption<S>): void;
+  private registerOption;
   private commandCtx;
   /**
-   * 设定基础信息
+   * Sets the CLI metadata.
    * @param metaInfo
    */
   setMetaInfo({ version, name }?: MetaInfo): void;
   /**
-   * 显示帮助信息
+   * Displays help information.
    */
-  showHelp(command?: string): void;
+  showHelp(command?: CommandLookup<S>): void;
   /**
-   * 显示版本号
+   * Displays the version number.
    */
   showVersion(): void;
   /**
-   * 启动
+   * Starts command dispatch.
    */
   start(): void;
   /**
-   * 执行命令担当函数
+   * Executes the command handler.
    * @param command
    */
   private exec;
   validateArgument(argumentValue: ArgumentValue | undefined, argument?: Argument): boolean;
   /**
-   * 获得命令的参数
+   * Gets the argument for a command.
    * @param commandName
-   * @param followRedirect 是否遵循重定向
+   * @param followRedirect Whether to follow alias redirects.
    */
-  getArgument(commandName: string, followRedirect?: boolean): ArgumentValue | undefined;
+  getArgument<N extends CommandLookup<S>>(commandName: N, followRedirect?: boolean): LookupArgument<S, N> | undefined;
+  private readArgument;
   private findArgument;
   /**
-   * 启动
-   * エリイ 起きてます❤
+   * Starts command dispatch.
+   * Erii is awake!
    */
   okite(): void;
 }
 //#endregion
-//#region src/index.d.ts
-declare const _default: Erii;
-//#endregion
-export { type Argument, type ArgumentValidator, type ArgumentValue, type Command, type CommandCtx, type CommandHandler, type CommandMap, type CommandOptions, type LifecycleHandler, type MetaInfo, type Option, type ParsedArguments, type ValidatorName, _default as default };
+export { type Argument, type ArgumentValidator, type ArgumentValue, Erii as default, type EriiSchema, type LifecycleHandler, type MetaInfo, type TypedCommand, type TypedCommandCtx, type TypedCommandHandler, type TypedCommandOptions, type TypedOption, type ValidatorName };

package/dist/index.mjs

@@ -60,18 +60,16 @@ var Erii = class {
 	validator;
 	alwaysHandler;
 	defaultHandler;
-	constructor() {
+	constructor(..._schema) {
 		this.rawArguments = process.argv.slice(2);
 		this.parsedArguments = yargs(process.argv.slice(2), { configuration: { "boolean-negation": false } });
 		this.validator = validator;
 		for (const key of Object.keys(this.parsedArguments)) if (key !== "_" && !this.rawArguments.includes("--" + key) && !this.rawArguments.includes("-" + key)) delete this.parsedArguments[key];
 	}
-	/**
-	* 绑定命令处理函数
-	* @param config
-	* @param handler
-	*/
 	bind(config, handler) {
+		this.bindCommand(config, handler);
+	}
+	bindCommand(config, handler) {
 		if (config.name === void 0) return console.error(chalk.red("Invalid command binding, ignored."));
 		const { name, description, argument } = config;
 		const [mainCommand, ...aliases] = Array.isArray(name) ? name : [name];
@@ -93,7 +91,7 @@ var Erii = class {
 		};
 	}
 	/**
-	* 总是执行
+	* Registers a handler that runs on every start.
 	* @param handler
 	*/
 	always(handler) {
@@ -102,11 +100,10 @@ var Erii = class {
 	default(handler) {
 		this.defaultHandler = handler;
 	}
-	/**
-	* 增加设置项
-	* @param config
-	*/
 	addOption(config) {
+		this.registerOption(config);
+	}
+	registerOption(config) {
 		config.name = Array.isArray(config.name) ? config.name : [config.name];
 		if (!config.command) this.commonOptions.push(config);
 		else {
@@ -125,12 +122,12 @@ var Erii = class {
 				this.showHelp();
 			},
 			getArgument: (commandName = command) => {
-				return this.getArgument(commandName);
+				return this.readArgument(commandName);
 			}
 		};
 	}
 	/**
-	* 设定基础信息
+	* Sets the CLI metadata.
 	* @param metaInfo
 	*/
 	setMetaInfo({ version = "", name = "" } = {}) {
@@ -138,20 +135,20 @@ var Erii = class {
 		this.name = name;
 	}
 	/**
-	* 显示帮助信息
+	* Displays help information.
 	*/
 	showHelp(command) {
 		this.showVersion();
 		renderHelp(this.commands, this.commonOptions);
 	}
 	/**
-	* 显示版本号
+	* Displays the version number.
 	*/
 	showVersion() {
 		console.log(`${this.name} / ${this.version}`);
 	}
 	/**
-	* 启动
+	* Starts command dispatch.
 	*/
 	start() {
 		if (this.alwaysHandler) this.alwaysHandler();
@@ -162,7 +159,7 @@ var Erii = class {
 		for (const key of this.parsedArguments["_"]) if (key in this.commands) this.exec(String(key));
 	}
 	/**
-	* 执行命令担当函数
+	* Executes the command handler.
 	* @param command
 	*/
 	exec(command) {
@@ -207,12 +204,10 @@ var Erii = class {
 			console.log(chalk.red(message));
 		});
 	}
-	/**
-	* 获得命令的参数
-	* @param commandName
-	* @param followRedirect 是否遵循重定向
-	*/
 	getArgument(commandName, followRedirect = true) {
+		return this.readArgument(commandName, followRedirect);
+	}
+	readArgument(commandName, followRedirect = true) {
 		const value = this.findArgument(commandName, followRedirect);
 		if (value === void 0) console.error(chalk.red(`Command ${commandName} not found.`));
 		return value;
@@ -225,8 +220,8 @@ var Erii = class {
 		for (const alias of command.alias ?? []) if (Object.hasOwn(this.parsedArguments, alias)) return this.parsedArguments[alias];
 	}
 	/**
-	* 启动
-	* エリイ 起きてます❤
+	* Starts command dispatch.
+	* Erii is awake!
 	*/
 	okite() {
 		return this.start();
@@ -234,6 +229,6 @@ var Erii = class {
 };
 //#endregion
 //#region src/index.ts
-var src_default = new Erii();
+var src_default = Erii;
 //#endregion
 export { Erii, src_default as default };

package/package.json

@@ -1,55 +1,58 @@
 {
-  "name": "erii",
-  "version": "3.0.0-beta.1",
-  "description": "",
-  "main": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
-  "scripts": {
-    "build": "tsdown",
-    "typecheck": "tsc --noEmit",
-    "test": "npm run build && npm run typecheck && node --test test/*.test.mjs",
-    "test:coverage": "npm run build && npm run typecheck && node --test --experimental-test-coverage --test-coverage-include=dist/index.mjs --test-coverage-include=src/utils/convert.ts --test-coverage-lines=100 --test-coverage-functions=100 --test-coverage-branches=95 test/*.test.mjs",
-    "prepack": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Last-Order/erii.git"
-  },
-  "author": "",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/Last-Order/erii/issues"
-  },
-  "homepage": "https://github.com/Last-Order/erii#readme",
-  "dependencies": {
-    "@types/validator": "^13.15.10",
-    "chalk": "^6.0.0",
-    "cli-color": "^2.0.0",
-    "clui": "^0.3.6",
-    "validator": "^13.15.35",
-    "yargs-parser": "^21.0.0"
-  },
-  "devDependencies": {
-    "@types/cli-color": "^2.0.6",
-    "@types/clui": "^0.3.5",
-    "@types/node": "^24.13.5",
-    "@types/yargs-parser": "^21.0.3",
-    "tsdown": "^0.23.0",
-    "typescript": "^7.0.2"
-  },
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+    "name": "erii",
+    "version": "3.0.0-beta.2",
+    "description": "",
+    "main": "./dist/index.mjs",
+    "types": "./dist/index.d.mts",
+    "scripts": {
+        "format": "prettier --write .",
+        "format:check": "prettier --check .",
+        "build": "tsdown",
+        "typecheck": "tsc --noEmit",
+        "test": "npm run build && npm run typecheck && node --test test/*.test.mjs",
+        "test:coverage": "npm run build && npm run typecheck && node --test --experimental-test-coverage --test-coverage-include=dist/index.mjs --test-coverage-include=src/utils/convert.ts --test-coverage-lines=100 --test-coverage-functions=100 --test-coverage-branches=95 test/*.test.mjs",
+        "prepack": "npm run build"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Last-Order/erii.git"
+    },
+    "author": "",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/Last-Order/erii/issues"
+    },
+    "homepage": "https://github.com/Last-Order/erii#readme",
+    "dependencies": {
+        "@types/validator": "^13.15.10",
+        "chalk": "^6.0.0",
+        "cli-color": "^2.0.0",
+        "clui": "^0.3.6",
+        "validator": "^13.15.35",
+        "yargs-parser": "^21.0.0"
+    },
+    "devDependencies": {
+        "@types/cli-color": "^2.0.6",
+        "@types/clui": "^0.3.5",
+        "@types/node": "^24.13.5",
+        "@types/yargs-parser": "^21.0.3",
+        "prettier": "3.9.7",
+        "tsdown": "^0.23.0",
+        "typescript": "^7.0.2"
+    },
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.mts",
+            "import": "./dist/index.mjs"
+        }
+    },
+    "files": [
+        "dist",
+        "readme.md",
+        "logo.png"
+    ],
+    "engines": {
+        "node": ">=22.18.0"
     }
-  },
-  "files": [
-    "dist",
-    "readme.md",
-    "logo.png"
-  ],
-  "engines": {
-    "node": ">=22.18.0"
-  }
 }

package/readme.md

@@ -2,166 +2,144 @@
 
 ![](./logo.png)
 
-[![npm version](https://badge.fury.io/js/erii.svg)](https://badge.fury.io/js/erii)
-
 ## Installation
-`npm install erii --save`
-This package is ESM-only and requires Node.js 22.18 or later. Use `import` from an ESM project (`"type": "module"` in package.json, or an `.mjs` file).
-
-## Development
-
-- `npm run build`: bundle ESM and TypeScript declarations with tsdown.
-- `npm run typecheck`: check source and consumer types in strict mode.
-- `npm test`: build, check types, and run regression tests.
-- `npm run test:coverage`: run the same checks with coverage gates (100% lines/functions, 95% branches).
-
-See [test/README.md](test/README.md) for the test scenario matrix. Runtime tests exercise the built ESM package; utility tests also cover source functions that are removed from the bundle when unused.
-
-## TypeScript
-
-The package exports `Command`, `Option`, `Argument`, `CommandCtx`, `CommandHandler`, `CommandOptions`, `ArgumentValue`, `ArgumentValidator`, `ValidatorName`, `ParsedArguments`, and `MetaInfo` types. Handler options are always provided; individual options and `getArgument()` can be `undefined`. Values retain the parser's strings, numbers, booleans, arrays, and nested objects, so narrow them before use. String validators accept only validator.js methods callable with one string and returning a boolean.
-
-## Usage
 
-```JavaScript
-import Erii from 'erii';
+Use Node.js 22.18 or later and set `"type": "module"` in your `package.json`.
 
-Erii.setMetaInfo({
-    version: '0.0.1',
-    name: 'example'
-});
-
-// Bind commands
-Erii.bind({
-    name: ['help', 'h'], // `h` will be set as an alias
-    description: 'Show Help', // command description
-    argument: {
-        name: 'command',
-        description: 'query help of a specified command'
-    }
-}, (ctx, options) => {
-    ctx.showHelp(); // show help text
-});
-
-// add options for `help` command
-Erii.addOption({
-    name: ['verbose', 'debug'],
-    command: 'help', // bind to command
-    description: 'debug output', // option description
-    argument: { // definition of option argument
-        name: 'level',
-        description: 'level of debug output'
-    }
-});
-
-Erii.addOption({
-    name: ['test'],
-    // without binding to a specified command,
-    // this option will be set as a common option.
-    description: 'show test information',
-    argument: {
-        name: 'test-argument',
-        description: 'test argument'
-    }
-});
-
-Erii.start(); // don't forget to start Erii.
+```sh
+npm install erii
 ```
 
-**Example**
-
-Call with
-
-`node index.js --help xxx --debug 1`
+## Usage
 
-```Javascript
-// ...
-// PART OF CODE
-Erii.bind({
-    name: ['help', 'h'],
-    description: 'Show Help',
-    argument: {
-        name: 'command',
-        description: 'query help of a specified command'
-    }
-}, (ctx, options) => {
-    const { verbose } = options; // option aliases use the primary name
-    console.log(verbose); // 1
-    console.log(ctx.getArgument()); // 'xxx'
+Define your commands and options, register handlers, then call `start()`.
+
+```ts
+import Erii from "erii";
+
+type CLI = {
+    commonOptions: {
+        verbose?: boolean;
+    };
+    commands: {
+        build: {
+            aliases: "b";
+            argument: string;
+            options: {
+                outDir?: string;
+                minify?: boolean;
+            };
+        };
+        serve: {
+            options: {
+                port?: number;
+                mode?: "dev" | "prod";
+            };
+        };
+    };
+};
+
+const cli = new Erii<CLI>();
+cli.setMetaInfo({ name: "example", version: "1.0.0" });
+
+cli.bind(
+    {
+        name: ["build", "b"],
+        description: "Build the project",
+        argument: { name: "path", description: "Source directory" },
+    },
+    (ctx, options) => {
+        const path = ctx.getArgument(); // string | undefined
+        const output = options.outDir; // string | undefined
+        const verbose = options.verbose; // boolean | undefined
+        console.log({ path, output, verbose });
+    },
+);
+
+cli.bind({ name: "serve" }, (_, options) => {
+    console.log(options.port, options.mode);
 });
 
-Erii.addOption({
-    name: ['verbose', 'debug'],
-    description: 'show verbose output',
+cli.addOption({ name: ["verbose", "v"] });
+cli.addOption({ command: "build", name: ["outDir", "out-dir", "o"] });
+cli.addOption({ command: "b", name: "minify" });
+cli.addOption({ command: "serve", name: "port" });
+cli.addOption({
+    command: "serve",
+    name: "mode",
     argument: {
-        name: 'level',
-        description: 'level of verbose output'
-    }
+        name: "mode",
+        description: "Server mode",
+        validate: (value) => value === "dev" || value === "prod",
+    },
 });
 
-Erii.start();
+cli.start(); // okite() is also available.
 ```
 
-
-**Help Text**
+```sh
+node index.js --build src --out-dir dist --verbose
+node index.js serve --port 3000 --mode dev
 ```
-example / 0.0.1
-
-Help:
-     Commands                      Description                   Alias
 
-     --help <command>              Show Help                     --h
-         <command>                 query help of a specified comm
+## Aliases
 
-Options:
+Put the primary name first and aliases after it. Read options using the primary name, such as `options.outDir`.
 
-     Options                       Description
-     --verbose, debug <level>      show verbose output
-         <level>                   level of verbose output
+```sh
+node index.js -b src -o dist -v
 ```
 
-**Argument Validation**
+## Reading arguments
 
-Argument validation are based on [validator.js](https://github.com/chriso/validator.js/).
+Use `ctx.getArgument()` inside a handler, or look up a command by name:
 
-`Erii.validator` points to a `validator` exported by `validator.js`.
+```ts
+const path = cli.getArgument("build");
+if (path !== undefined) {
+    console.log(path);
+}
+```
 
-Erii can validate arguments automatically.
+## Validation
 
-Define the validate methods in `argument` parameter.
+Use `argument.validate` to check values with a validator.js method:
 
-```JavaScript
-Erii.addOption({
-    name: ['verbose', 'debug'],
-    description: 'show verbose output',
-    argument: {
-        name: 'level',
-        description: 'level of verbose output',
-        validate: 'isInt'
-    }
+```ts
+cli.addOption({
+    command: "serve",
+    name: "port",
+    argument: { name: "port", description: "Listening port", validate: "isInt" },
 });
 ```
 
-`validate` can also be a function, for example:
+To use a custom validator, return `true` for accepted input:
 
-```JavaScript
-Erii.addOption({
-    name: ['verbose', 'debug'],
-    description: 'show verbose output',
+```ts
+cli.addOption({
+    command: "serve",
+    name: "port",
     argument: {
-        name: 'level',
-        description: 'level of verbose output',
-        validate: (value) => Erii.validator.isInt(String(value))
-    }
+        name: "port",
+        description: "Listening port",
+        validate: (value) => typeof value === "number" && value > 0 && value <= 65535,
+    },
 });
 ```
 
-`argument.validate` works in both command and option definitions.
+## Help and lifecycle
 
-**Example Output for Argument Validation**
+Register lifecycle handlers before calling `start()`:
 
-```
-PS D:\Git\erii.test> node index.js --help --verbose f
-Argument validation failed for option 'verbose'.
-<level> should be a/an Int.
+```ts
+cli.always(() => {
+    console.log("Starting");
+});
+
+cli.default(() => {
+    cli.showHelp(); // Show help when no arguments are supplied.
+});
+
+cli.showVersion();
+cli.start();
 ```