gunshi 0.12.0 → 0.14.0

package/README.md

@@ -32,8 +32,6 @@ Gunshi is designed to simplify the creation of modern command-line interfaces:
 
 ## 💿 Installation
 
-### 🐢 Node
-
 ```sh
 # npm
 npm install --save gunshi
@@ -43,41 +41,16 @@ pnpm add gunshi
 
 ## yarn
 yarn add gunshi
-```
-
-### 🦕 Deno
 
-```sh
+## deno
 deno add jsr:@kazupon/gunshi
-```
 
-### 🥟 Bun
-
-```sh
+## bun
 bun add gunshi
 ```
 
 ## 🚀 Usage
 
-### 📏 Simple API
-
-Gunshi has a simple API that is a facade:
-
-```js
-import { cli } from 'gunshi'
-
-const args = process.argv.slice(2)
-// run a simple command
-await cli(args, () => {
-  // something logic ...
-  console.log('Hello from Gunshi!', args)
-})
-```
-
-### ⚙️ Declarative Configuration
-
-Configure commands declaratively:
-
 ```js
 import { cli } from 'gunshi'
 
@@ -121,289 +94,7 @@ await cli(process.argv.slice(2), command, {
 })
 ```
 
-For more detailed examples, check out the [playground/declarative](https://github.com/kazupon/gunshi/tree/main/playground/declarative) in the repository.
-
-### 🛡️ Type-Safe Arguments
-
-Gunshi provides type-safe argument parsing with TypeScript:
-
-```ts
-import { cli } from 'gunshi'
-import type { ArgOptions, Command, CommandContext } from 'gunshi'
-
-// type-safe arguments parsing example
-// this demonstrates how to define and use typed command options with `satisfies`
-
-// define 'type-safe' command options with types
-const options = {
-  // define string option with short alias
-  name: {
-    type: 'string',
-    short: 'n'
-  },
-  // define number option with default value
-  age: {
-    type: 'number',
-    short: 'a',
-    default: 25
-  },
-  // define boolean flag
-  verbose: {
-    type: 'boolean',
-    short: 'v'
-  }
-} satisfies ArgOptions
-
-// define 'type-safe' command
-const command = {
-  name: 'type-safe',
-  options,
-  run: (ctx: CommandContext<UserOptions, UserValues>) => {
-    const { name, age, verbose } = ctx.values
-    console.log(`Hello, ${name || 'World'}! You are ${age} years old.`)
-  }
-} satisfies Command<typeof options>
-
-await cli(process.argv.slice(2), command)
-```
-
-For more detailed examples, check out the [playground/type-safe](https://github.com/kazupon/gunshi/tree/main/playground/type-safe) in the repository.
-
-### 🧩 Composable Sub-commands
-
-Run a CLI with composable sub-commands:
-
-```js
-import { cli } from 'gunshi'
-
-// define 'create' command
-const createCommand = {
-  name: 'create',
-  description: 'Create a new resource',
-  options: {
-    name: { type: 'string', short: 'n' }
-  },
-  run: ctx => {
-    console.log(`Creating resource: ${ctx.values.name}`)
-  }
-}
-
-// define 'list' command
-const listCommand = {
-  name: 'list',
-  description: 'List all resources',
-  run: () => {
-    console.log('Listing all resources...')
-  }
-}
-
-// prepare a Map of sub-commands
-const subCommands = new Map()
-subCommands.set('create', createCommand)
-subCommands.set('list', listCommand)
-
-// define the main ('resource-manager') command
-const mainCommand = {
-  name: 'resource-manager',
-  description: 'Manage resources',
-  run: () => {
-    console.log('Use one of the sub-commands: create, list')
-  }
-}
-
-// run the CLI with composable sub-commands
-await cli(process.argv.slice(2), mainCommand, {
-  name: 'my-app',
-  version: '1.0.0',
-  subCommands
-})
-```
-
-For more detailed examples, check out the [playground/composable](https://github.com/kazupon/gunshi/tree/main/playground/composable) in the repository.
-
-### ⏳ Lazy & Async Command Loading
-
-Load commands lazily and execute them asynchronously:
-
-```js
-import { cli } from 'gunshi'
-
-// define a command that will be loaded lazily
-const lazyCommand = async () => {
-  // simulate async loading
-  await new Promise(resolve => setTimeout(resolve, 1000))
-
-  // return the actual command
-  return {
-    name: 'lazy',
-    description: 'A command that is loaded lazily',
-    run: async ctx => {
-      // async execution
-      await new Promise(resolve => setTimeout(resolve, 500))
-      console.log('Command executed!')
-    }
-  }
-}
-
-// prepare a Map of sub-commands with lazy-loaded commands
-const subCommands = new Map()
-subCommands.set('lazy', lazyCommand)
-
-// run the CLI with lazy-loaded commands
-await cli(
-  process.argv.slice(2),
-  { name: 'main', run: () => {} },
-  {
-    name: 'my-app',
-    subCommands
-  }
-)
-```
-
-For more detailed examples, check out the [playground/lazy-async](https://github.com/kazupon/gunshi/tree/main/playground/lazy-async) in the repository.
-
-### 📜 Auto Usage Generation
-
-Gunshi automatically generates usage information:
-
-```js
-import { cli } from 'gunshi'
-
-const command = {
-  name: 'app',
-  description: 'My application',
-  options: {
-    path: {
-      type: 'string',
-      short: 'p',
-      description: 'File or directory path'
-    },
-    recursive: {
-      type: 'boolean',
-      short: 'r',
-      description: 'Operate recursively on directories'
-    },
-    operation: {
-      type: 'string',
-      short: 'o',
-      required: true,
-      description: 'Operation to perform (list, copy, move, delete)'
-    }
-  },
-  // define examples
-  examples: '# Example\n$ my-app --operation list --path ./src',
-  run: ctx => {
-    // command implementation
-  }
-}
-
-// run with --help to see the automatically generated usage information
-await cli(process.argv.slice(2), command, {
-  name: 'my-app',
-  version: '1.0.0'
-})
-```
-
-For more detailed examples, check out the [playground/auto-usage](https://github.com/kazupon/gunshi/tree/main/playground/auto-usage) in the repository.
-
-### 🎨 Custom Usage Generation
-
-Customize the usage message generation:
-
-```js
-import { cli } from 'gunshi'
-
-// define custom header renderer
-const customHeaderRenderer = ctx => {
-  return Promise.resolve(`
-╔═══════════════════════╗
-║      ${ctx.env.name.toUpperCase()}      ║
-╚═══════════════════════╝
-${ctx.env.description}
-Version: ${ctx.env.version}
-`)
-}
-
-// define custom usage renderer
-const customUsageRenderer = ctx => {
-  const lines = []
-  lines.push('USAGE:')
-  lines.push(`  $ ${ctx.env.name} [options]`)
-  lines.push('')
-  lines.push('OPTIONS:')
-
-  for (const [key, option] of Object.entries(ctx.options || Object.create(null))) {
-    const shortFlag = option.short ? `-${option.short}, ` : '    '
-    lines.push(`  ${shortFlag}--${key.padEnd(10)} ${ctx.translate(key)}`)
-  }
-
-  return Promise.resolve(lines.join('\n'))
-}
-
-// run with custom renderers
-await cli(
-  process.argv.slice(2),
-  { name: 'app', run: () => {} },
-  {
-    name: 'my-app',
-    version: '1.0.0',
-    description: 'My application',
-    renderHeader: customHeaderRenderer,
-    renderUsage: customUsageRenderer
-  }
-)
-```
-
-For more detailed examples, check out the [playground/custom-usage](https://github.com/kazupon/gunshi/tree/main/playground/custom-usage) in the repository.
-
-### 🌍 Internationalization
-
-Support internationalization:
-
-```js
-import { cli } from 'gunshi'
-import enUS from './locales/en-US.json' with { type: 'json' }
-
-const command = {
-  name: 'greeter',
-  options: {
-    name: {
-      type: 'string',
-      short: 'n'
-    },
-    formal: {
-      type: 'boolean',
-      short: 'f'
-    }
-  },
-  // resource fetcher for translations
-  resource: async ctx => {
-    if (ctx.locale.toString() === 'ja-JP') {
-      const resource = await import('./locales/ja-JP.json', { with: { type: 'json' } })
-      return resource.default
-    }
-
-    // default to English
-    return enUS
-  },
-  run: ctx => {
-    const { name = 'World', formal } = ctx.values
-    const greeting = formal ? ctx.translate('formal_greeting') : ctx.translate('informal_greeting')
-    console.log(`${greeting}, ${name}!`)
-  }
-}
-
-// run with locale support
-await cli(process.argv.slice(2), command, {
-  name: 'my-app',
-  version: '1.0.0',
-  // set the locale via an environment variable
-  // if Node v21 or later is used, you can use the built-in `navigator.language` instead)
-  locale: new Intl.Locale(process.env.MY_LOCALE || 'en-US')
-})
-```
-
-For more detailed examples, check out the [playground/i18n](https://github.com/kazupon/gunshi/tree/main/playground/i18n) in the repository.
+About more details and usage, see [documentations](https://gunshi.dev)
 
 ## 💁‍♀️ Showcases
 
@@ -423,6 +114,16 @@ This project is inspired and powered by:
 
 Thank you!
 
+## 🤝 Sponsors
+
+The development of Gunish is supported by my OSS sponsors!
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/kazupon/sponsors/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/kazupon/sponsors/sponsors.svg'/>
+  </a>
+</p>
+
 ## ©️ License
 
 [MIT](http://opensource.org/licenses/MIT)

package/lib/{cli-C-y15OeH.js → cli-DsMmOiVc.js}

@@ -1,4 +1,4 @@
-import { BUILT_IN_PREFIX, COMMAND_OPTIONS_DEFAULT, COMMON_OPTIONS, DEFAULT_LOCALE, NOOP, create, deepFreeze, log, mapResourceWithBuiltinKey, renderHeader, renderUsage, renderValidationErrors, resolveLazyCommand } from "./renderer-DAUAIZxV.js";
+import { BUILT_IN_PREFIX, COMMAND_OPTIONS_DEFAULT, COMMON_OPTIONS, DEFAULT_LOCALE, NOOP, create, deepFreeze, log, mapResourceWithBuiltinKey, renderHeader, renderUsage, renderValidationErrors, resolveLazyCommand, resolveOptionKey } from "./renderer-B2JVfepJ.js";
 import { parseArgs, resolveArgs } from "args-tokens";
 
 //#region src/locales/en-US.json
@@ -60,7 +60,7 @@ var DefaultTranslation = class {
 //#endregion
 //#region src/context.ts
 const BUILT_IN_PREFIX_CODE = BUILT_IN_PREFIX.codePointAt(0);
-async function createCommandContext({ options, values, positionals, command, commandOptions, omitted = false }) {
+async function createCommandContext({ options, values, positionals, args, tokens, command, commandOptions, omitted = false }) {
 	/**
 	* normailize the options schema and values, to avoid prototype pollution
 	*/
@@ -121,6 +121,8 @@ async function createCommandContext({ options, values, positionals, command, com
 		options: _options,
 		values,
 		positionals,
+		_: args,
+		tokens,
 		log: commandOptions.usageSilent ? NOOP : log,
 		loadCommands,
 		translate
@@ -133,7 +135,7 @@ async function createCommandContext({ options, values, positionals, command, com
 		return [key, description];
 	});
 	const defaultCommandResource = loadedOptionsResources.reduce((res, [key, value]) => {
-		res[key] = value;
+		res[resolveOptionKey(key)] = value;
 		return res;
 	}, create());
 	defaultCommandResource.description = command.description || "";
@@ -179,6 +181,8 @@ async function cli(args, entry, opts = {}) {
 		options,
 		values,
 		positionals,
+		args,
+		tokens,
 		omitted,
 		command,
 		commandOptions: resolvedCommandOptions

package/lib/definition-by5EpPkZ.js

@@ -0,0 +1,8 @@
+
+//#region src/definition.ts
+function define(definition) {
+	return definition;
+}
+
+//#endregion
+export { define };

package/lib/definition.d-CFbYyc6i.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "./types.d-CftFdhAF.js";
+import { ArgOptionSchema, ArgOptions, ArgOptions as ArgOptions$1, ArgValues as ArgValues$1 } from "args-tokens";
+
+//#region lib/.tsdown-types-es/definition.d.ts
+declare function define<Options extends ArgOptions = ArgOptions>(definition: Command<Options>): Command<Options>;
+
+//#endregion
+export { ArgOptionSchema, ArgOptions$1 as ArgOptions, ArgValues$1 as ArgValues, define };

package/lib/definition.d.ts

@@ -0,0 +1,4 @@
+import "./types.d-CftFdhAF.js";
+import { ArgOptionSchema, ArgOptions, ArgValues, define } from "./definition.d-CFbYyc6i.js";
+
+export { ArgOptionSchema, ArgOptions, ArgValues, define };

package/lib/definition.js

@@ -0,0 +1,3 @@
+import { define } from "./definition-by5EpPkZ.js";
+
+export { define };

package/lib/generator.d.ts

@@ -1,13 +1,8 @@
-import { ArgOptions } from 'args-tokens';
-import { C as Command, a as CommandOptions } from './types.d-DIY9YbHU.js';
+import { Command, CommandOptions } from "./types.d-CftFdhAF.js";
+import { ArgOptions } from "args-tokens";
 
-/**
-* Generate the command usage.
-* @param command - usage generate command, if you want to generate the usage of the default command where there are target commands and sub-commands, specify `null`.
-* @param entry - A {@link Command | entry command}
-* @param opts - A {@link CommandOptions | command options}
-* @returns A rendered usage.
-*/
+//#region lib/.tsdown-types-es/generator.d.ts
 declare function generate<Options extends ArgOptions = ArgOptions>(command: string | null, entry: Command<Options>, opts?: CommandOptions<Options>): Promise<string>;
 
-export { generate };
+//#endregion
+export { generate };

package/lib/generator.js

@@ -1,5 +1,5 @@
-import { create } from "./renderer-DAUAIZxV.js";
-import { cli } from "./cli-C-y15OeH.js";
+import { create } from "./renderer-B2JVfepJ.js";
+import { cli } from "./cli-DsMmOiVc.js";
 
 //#region src/generator.ts
 async function generate(command, entry, opts = {}) {

package/lib/index.d.ts

@@ -1,17 +1,12 @@
-import { ArgOptions } from 'args-tokens';
-export { ArgOptionSchema, ArgOptions, ArgValues } from 'args-tokens';
-import { C as Command, b as CommandRunner, a as CommandOptions, T as TranslationAdapter, c as TranslationAdapterFactoryOptions } from './types.d-DIY9YbHU.js';
-export { f as CommandBuiltinKeys, d as CommandBuiltinOptionsKeys, e as CommandBuiltinResourceKeys, h as CommandContext, g as CommandEnvironment, i as CommandResource, j as CommandResourceFetcher, l as Commandable, D as DEFAULT_LOCALE, G as GenerateNamespacedKey, L as LazyCommand, k as TranslationAdapterFactory } from './types.d-DIY9YbHU.js';
+import { Command, CommandBuiltinKeys, CommandBuiltinOptionsKeys, CommandBuiltinResourceKeys, CommandContext, CommandEnvironment, CommandOptionKeys, CommandOptions, CommandResource, CommandResourceFetcher, CommandRunner, Commandable, DEFAULT_LOCALE, GenerateNamespacedKey, LazyCommand, RemovedIndex, TranslationAdapter, TranslationAdapterFactory, TranslationAdapterFactoryOptions } from "./types.d-CftFdhAF.js";
+import { define } from "./definition.d-CFbYyc6i.js";
+import { ArgOptionSchema, ArgOptions, ArgOptions as ArgOptions$1, ArgValues, parseArgs, resolveArgs } from "args-tokens";
 
-/**
-* Run the command.
-* @param args Command line arguments
-* @param entry A {@link Command | entry command} or an {@link CommandRunner | inline command runner}
-* @param opts A {@link CommandOptions | command options}
-* @returns A rendered usage or undefined. if you will use {@link CommandOptions.usageSilent} option, it will return rendered usage string.
-*/
-declare function cli<Options extends ArgOptions = ArgOptions>(args: string[], entry: Command<Options> | CommandRunner<Options>, opts?: CommandOptions<Options>): Promise<string | undefined>;
+//#region lib/.tsdown-types-es/cli.d.ts
+declare function cli<Options extends ArgOptions$1 = ArgOptions$1>(args: string[], entry: Command<Options> | CommandRunner<Options>, opts?: CommandOptions<Options>): Promise<string | undefined>;
 
+//#endregion
+//#region lib/.tsdown-types-es/translation.d.ts
 declare class DefaultTranslation implements TranslationAdapter {
 	#private;
 	constructor(options: TranslationAdapterFactoryOptions);
@@ -21,4 +16,5 @@ declare class DefaultTranslation implements TranslationAdapter {
 	translate(locale: string, key: string, values?: Record<string, unknown>): string | undefined;
 }
 
-export { Command, CommandOptions, CommandRunner, DefaultTranslation, TranslationAdapter, TranslationAdapterFactoryOptions, cli };
+//#endregion
+export { ArgOptionSchema, ArgOptions, ArgValues, Command, CommandBuiltinKeys, CommandBuiltinOptionsKeys, CommandBuiltinResourceKeys, CommandContext, CommandEnvironment, CommandOptionKeys, CommandOptions, CommandResource, CommandResourceFetcher, CommandRunner, Commandable, DEFAULT_LOCALE, DefaultTranslation, GenerateNamespacedKey, LazyCommand, RemovedIndex, TranslationAdapter, TranslationAdapterFactory, TranslationAdapterFactoryOptions, cli, define, parseArgs, resolveArgs };

package/lib/index.js

@@ -1,4 +1,6 @@
-import { DEFAULT_LOCALE } from "./renderer-DAUAIZxV.js";
-import { DefaultTranslation, cli } from "./cli-C-y15OeH.js";
+import { define } from "./definition-by5EpPkZ.js";
+import { DEFAULT_LOCALE } from "./renderer-B2JVfepJ.js";
+import { DefaultTranslation, cli } from "./cli-DsMmOiVc.js";
+import { parseArgs, resolveArgs } from "args-tokens";
 
-export { DEFAULT_LOCALE, DefaultTranslation, cli };
+export { DEFAULT_LOCALE, DefaultTranslation, cli, define, parseArgs, resolveArgs };

package/lib/renderer/index.d.ts

@@ -1,26 +1,16 @@
-import { ArgOptions } from 'args-tokens';
-import { h as CommandContext } from '../types.d-DIY9YbHU.js';
+import { CommandContext } from "../types.d-CftFdhAF.js";
+import { ArgOptions } from "args-tokens";
 
-/**
-* Render the header.
-* @param ctx A {@link CommandContext | command context}
-* @returns A rendered header.
-*/
+//#region lib/.tsdown-types-es/renderer/header.d.ts
 declare function renderHeader<Options extends ArgOptions = ArgOptions>(ctx: Readonly<CommandContext<Options>>): Promise<string>;
 
-/**
-* Render the usage.
-* @param ctx A {@link CommandContext | command context}
-* @returns A rendered usage.
-*/
+//#endregion
+//#region lib/.tsdown-types-es/renderer/usage.d.ts
 declare function renderUsage<Options extends ArgOptions = ArgOptions>(ctx: Readonly<CommandContext<Options>>): Promise<string>;
 
-/**
-* Render the validation errors.
-* @param ctx A {@link CommandContext | command context}
-* @param error An {@link AggregateError} of option in `args-token` validation
-* @returns A rendered validation error.
-*/
+//#endregion
+//#region lib/.tsdown-types-es/renderer/validation.d.ts
 declare function renderValidationErrors<Options extends ArgOptions = ArgOptions>(_ctx: CommandContext<Options>, error: AggregateError): Promise<string>;
 
-export { renderHeader, renderUsage, renderValidationErrors };
+//#endregion
+export { renderHeader, renderUsage, renderValidationErrors };

package/lib/renderer/index.js

@@ -1,3 +1,3 @@
-import { renderHeader, renderUsage, renderValidationErrors } from "../renderer-DAUAIZxV.js";
+import { renderHeader, renderUsage, renderValidationErrors } from "../renderer-B2JVfepJ.js";
 
 export { renderHeader, renderUsage, renderValidationErrors };

package/lib/{renderer-DAUAIZxV.js → renderer-B2JVfepJ.js}

@@ -2,6 +2,7 @@
 //#region src/constants.ts
 const DEFAULT_LOCALE = "en-US";
 const BUILT_IN_PREFIX = "_";
+const OPTION_PREFIX = "Option";
 const BUILT_IN_KEY_SEPARATOR = ":";
 const NOOP = () => {};
 const COMMON_OPTIONS = {
@@ -42,6 +43,9 @@ async function resolveLazyCommand(cmd, name) {
 function resolveBuiltInKey(key) {
 	return `${BUILT_IN_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
 }
+function resolveOptionKey(key) {
+	return `${OPTION_PREFIX}${BUILT_IN_KEY_SEPARATOR}${key}`;
+}
 function mapResourceWithBuiltinKey(resource) {
 	return Object.entries(resource).reduce((acc, [key, value]) => {
 		acc[resolveBuiltInKey(key)] = value;
@@ -244,7 +248,7 @@ async function generateOptionsUsage(ctx, optionsPairs) {
 	const optionsMaxLength = Math.max(...Object.entries(optionsPairs).map(([_, value]) => value.length));
 	const optionSchemaMaxLength = ctx.env.usageOptionType ? Math.max(...Object.entries(optionsPairs).map(([key, _]) => ctx.options[key].type.length)) : 0;
 	const usages = await Promise.all(Object.entries(optionsPairs).map(([key, value]) => {
-		const rawDesc = ctx.translate(key);
+		const rawDesc = ctx.translate(resolveOptionKey(key));
 		const optionsSchema = ctx.env.usageOptionType ? `[${ctx.options[key].type}] ` : "";
 		const desc = `${optionsSchema ? optionsSchema.padEnd(optionSchemaMaxLength + 3) : ""}${rawDesc}`;
 		const option = `${value.padEnd(optionsMaxLength + ctx.env.middleMargin)}${desc}`;
@@ -262,4 +266,4 @@ function renderValidationErrors(_ctx, error) {
 }
 
 //#endregion
-export { BUILT_IN_PREFIX, COMMAND_OPTIONS_DEFAULT, COMMON_OPTIONS, DEFAULT_LOCALE, NOOP, create, deepFreeze, log, mapResourceWithBuiltinKey, renderHeader, renderUsage, renderValidationErrors, resolveLazyCommand };
+export { BUILT_IN_PREFIX, COMMAND_OPTIONS_DEFAULT, COMMON_OPTIONS, DEFAULT_LOCALE, NOOP, create, deepFreeze, log, mapResourceWithBuiltinKey, renderHeader, renderUsage, renderValidationErrors, resolveLazyCommand, resolveOptionKey };

package/lib/{types.d-DIY9YbHU.d.ts → types.d-CftFdhAF.d.ts}

@@ -1,71 +1,24 @@
-import { ArgOptions, ArgValues } from 'args-tokens';
+import { ArgOptions, ArgToken, ArgValues } from "args-tokens";
 
-/**
-* The default locale string, which format is BCP 47 language tag.
-*/
+//#region lib/.tsdown-types-es/constants.d.ts
 declare const DEFAULT_LOCALE = "en-US";
 declare const BUILT_IN_PREFIX = "_";
+declare const OPTION_PREFIX = "Option";
 declare const BUILT_IN_KEY_SEPARATOR = ":";
-declare const NOOP: () => void;
-type CommonOptionType = {
-	readonly help: {
-		readonly type: "boolean"
-		readonly short: "h"
-		readonly description: string
-	}
-	readonly version: {
-		readonly type: "boolean"
-		readonly short: "v"
-		readonly description: string
-	}
-};
-declare const COMMON_OPTIONS: CommonOptionType;
-declare const COMMAND_OPTIONS_DEFAULT: CommandOptions<ArgOptions>;
-declare const COMMAND_BUILTIN_RESOURCE_KEYS: readonly ["USAGE", "COMMAND", "SUBCOMMAND", "COMMANDS", "OPTIONS", "EXAMPLES", "FORMORE"];
-
-declare const __constants_ts_BUILT_IN_KEY_SEPARATOR: typeof BUILT_IN_KEY_SEPARATOR;
-declare const __constants_ts_BUILT_IN_PREFIX: typeof BUILT_IN_PREFIX;
-declare const __constants_ts_COMMAND_BUILTIN_RESOURCE_KEYS: typeof COMMAND_BUILTIN_RESOURCE_KEYS;
-declare const __constants_ts_COMMAND_OPTIONS_DEFAULT: typeof COMMAND_OPTIONS_DEFAULT;
-declare const __constants_ts_COMMON_OPTIONS: typeof COMMON_OPTIONS;
-declare const __constants_ts_DEFAULT_LOCALE: typeof DEFAULT_LOCALE;
-declare const __constants_ts_NOOP: typeof NOOP;
-declare namespace __constants_ts {
-  export {
-    __constants_ts_BUILT_IN_KEY_SEPARATOR as BUILT_IN_KEY_SEPARATOR,
-    __constants_ts_BUILT_IN_PREFIX as BUILT_IN_PREFIX,
-    __constants_ts_COMMAND_BUILTIN_RESOURCE_KEYS as COMMAND_BUILTIN_RESOURCE_KEYS,
-    __constants_ts_COMMAND_OPTIONS_DEFAULT as COMMAND_OPTIONS_DEFAULT,
-    __constants_ts_COMMON_OPTIONS as COMMON_OPTIONS,
-    __constants_ts_DEFAULT_LOCALE as DEFAULT_LOCALE,
-    __constants_ts_NOOP as NOOP,
-  };
-}
 
-/**
-* Define a promise type that can be await from T.
-*/
+//#endregion
+//#region lib/.tsdown-types-es/types.d.ts
 type Awaitable<T> = T | Promise<T>;
+type RemoveIndexSignature<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K] : T[K] };
+type RemovedIndex<T> = RemoveIndexSignature<{ [K in keyof T] : T[K] }>;
 type GenerateNamespacedKey<
 	Key extends string,
 	Prefixed extends string = typeof BUILT_IN_PREFIX
 > = `${Prefixed}${typeof BUILT_IN_KEY_SEPARATOR}${Key}`;
-/**
-* Command i18n built-in options keys.
-*/
-type CommandBuiltinOptionsKeys = keyof (typeof __constants_ts)["COMMON_OPTIONS"];
-/**
-* Command i18n built-in resource keys.
-*/
-type CommandBuiltinResourceKeys = (typeof __constants_ts)["COMMAND_BUILTIN_RESOURCE_KEYS"][number];
-/**
-* Command i18n built-in keys.
-* The command i18n built-in keys are used to {@link CommandContext.translate | translate} function.
-*/
+type CommandBuiltinOptionsKeys = keyof (typeof import("./constants.ts"))["COMMON_OPTIONS"];
+type CommandBuiltinResourceKeys = (typeof import("./constants.ts"))["COMMAND_BUILTIN_RESOURCE_KEYS"][number];
 type CommandBuiltinKeys = GenerateNamespacedKey<CommandBuiltinOptionsKeys> | GenerateNamespacedKey<CommandBuiltinResourceKeys> | "description" | "examples";
-/**
-* Command environment.
-*/
+type CommandOptionKeys<Options extends ArgOptions> = GenerateNamespacedKey<keyof RemovedIndex<Options>, typeof OPTION_PREFIX>;
 interface CommandEnvironment<Options extends ArgOptions = ArgOptions> {
 	/**
 	* Current working directory.
@@ -130,9 +83,6 @@ interface CommandEnvironment<Options extends ArgOptions = ArgOptions> {
 	*/
 	renderValidationErrors: ((ctx: CommandContext<Options>, error: AggregateError) => Promise<string>) | null | undefined;
 }
-/**
-* Command options.
-*/
 interface CommandOptions<Options extends ArgOptions = ArgOptions> {
 	/**
 	* Current working directory.
@@ -192,10 +142,6 @@ interface CommandOptions<Options extends ArgOptions = ArgOptions> {
 	*/
 	translationAdapterFactory?: TranslationAdapterFactory;
 }
-/**
-* Command context.
-* Command context is the context of the command execution.
-*/
 interface CommandContext<
 	Options extends ArgOptions = ArgOptions,
 	Values = ArgValues<Options>
@@ -235,6 +181,15 @@ interface CommandContext<
 	*/
 	positionals: string[];
 	/**
+	* Original command line arguments.
+	* This argument is passed from `cli` function.
+	*/
+	_: string[];
+	/**
+	* Argument tokens, that is parsed by `parseArgs` function.
+	*/
+	tokens: ArgToken[];
+	/**
 	* Whether the currently executing command has been executed with the sub-command name omitted.
 	*/
 	omitted: boolean;
@@ -259,12 +214,10 @@ interface CommandContext<
 	*/
 	translate: <
 		T extends string = CommandBuiltinKeys,
-		Key = CommandBuiltinKeys | keyof Options | T
+		O = CommandOptionKeys<Options>,
+		Key = CommandBuiltinKeys | O | T
 	>(key: Key, values?: Record<string, unknown>) => string;
 }
-/**
-* Command interface.
-*/
 interface Command<Options extends ArgOptions = ArgOptions> {
 	/**
 	* Command name.
@@ -295,9 +248,6 @@ interface Command<Options extends ArgOptions = ArgOptions> {
 	*/
 	resource?: CommandResourceFetcher<Options>;
 }
-/**
-* Command resource.
-*/
 type CommandResource<Options extends ArgOptions = ArgOptions> = {
 	/**
 	* Command description.
@@ -307,25 +257,14 @@ type CommandResource<Options extends ArgOptions = ArgOptions> = {
 	* Examples usage.
 	*/
 	examples: string
-} & { [Option in keyof Options] : string } & {
+} & { [Option in GenerateNamespacedKey<keyof RemovedIndex<Options>, typeof OPTION_PREFIX>] : string } & {
 	[key: string]: string
 };
-/**
-* Command resource fetcher.
-* @param ctx A {@link CommandContext | command context}
-* @returns A fetched {@link CommandResource | command resource}.
-*/
 type CommandResourceFetcher<
 	Options extends ArgOptions = ArgOptions,
 	Values = ArgValues<Options>
 > = (ctx: Readonly<CommandContext<Options, Values>>) => Promise<CommandResource<Options>>;
-/**
-* Translation adapter factory.
-*/
 type TranslationAdapterFactory = (options: TranslationAdapterFactoryOptions) => TranslationAdapter;
-/**
-* Translation adapter factory options.
-*/
 interface TranslationAdapterFactoryOptions {
 	/**
 	* A locale.
@@ -336,11 +275,6 @@ interface TranslationAdapterFactoryOptions {
 	*/
 	fallbackLocale: string;
 }
-/**
-* Translation adapter.
-* This adapter is used to custom message formatter like {@link https://github.com/intlify/vue-i18n/blob/master/spec/syntax.ebnf | Intlify message format}, {@link https://github.com/tc39/proposal-intl-messageformat | `Intl.MessageFormat` (MF2)}, and etc.
-* This adapter will support localization with your preferred message format.
-*/
 interface TranslationAdapter<MessageResource = string> {
 	/**
 	* Get a resource of locale.
@@ -370,20 +304,9 @@ interface TranslationAdapter<MessageResource = string> {
 	*/
 	translate(locale: string, key: string, values?: Record<string, unknown>): string | undefined;
 }
-/**
-* Command runner.
-* @param ctx A {@link CommandContext | command context}
-*/
 type CommandRunner<Options extends ArgOptions = ArgOptions> = (ctx: Readonly<CommandContext<Options>>) => Awaitable<void>;
-/**
-* Lazy command interface.
-* Lazy command that's not loaded until it is executed.
-*/
 type LazyCommand<Options extends ArgOptions = ArgOptions> = () => Awaitable<Command<Options>>;
-/**
-* Define a command type.
-*/
 type Commandable<Options extends ArgOptions> = Command<Options> | LazyCommand<Options>;
 
-export { DEFAULT_LOCALE as D };
-export type { Command as C, GenerateNamespacedKey as G, LazyCommand as L, TranslationAdapter as T, CommandOptions as a, CommandRunner as b, TranslationAdapterFactoryOptions as c, CommandBuiltinOptionsKeys as d, CommandBuiltinResourceKeys as e, CommandBuiltinKeys as f, CommandEnvironment as g, CommandContext as h, CommandResource as i, CommandResourceFetcher as j, TranslationAdapterFactory as k, Commandable as l };
+//#endregion
+export { Command, CommandBuiltinKeys, CommandBuiltinOptionsKeys, CommandBuiltinResourceKeys, CommandContext, CommandEnvironment, CommandOptionKeys, CommandOptions, CommandResource, CommandResourceFetcher, CommandRunner, Commandable, DEFAULT_LOCALE, GenerateNamespacedKey, LazyCommand, RemovedIndex, TranslationAdapter, TranslationAdapterFactory, TranslationAdapterFactoryOptions };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gunshi",
   "description": "Modern javascript command-line library",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "author": {
     "name": "kazuya kawaguchi",
     "email": "kawakazu80@gmail.com"
@@ -41,6 +41,12 @@
       "require": "./lib/index.js",
       "default": "./lib/index.js"
     },
+    "./definition": {
+      "types": "./lib/definition.d.ts",
+      "import": "./lib/definition.js",
+      "require": "./lib/definition.js",
+      "default": "./lib/definition.js"
+    },
     "./renderer": {
       "types": "./lib/renderer/index.d.ts",
       "import": "./lib/renderer/index.js",
@@ -87,15 +93,17 @@
     "eslint-plugin-regexp": "^2.7.0",
     "eslint-plugin-unicorn": "^58.0.0",
     "eslint-plugin-unused-imports": "^4.1.4",
+    "eslint-plugin-vue": "^10.0.0",
+    "eslint-plugin-vue-composable": "^1.0.0",
     "eslint-plugin-yml": "^1.17.0",
     "gh-changelogen": "^0.2.8",
     "jsr": "^0.13.4",
     "knip": "^5.46.3",
     "lint-staged": "^15.5.0",
     "messageformat": "4.0.0-10",
-    "pkg-pr-new": "^0.0.41",
+    "pkg-pr-new": "^0.0.42",
     "prettier": "^3.5.3",
-    "tsdown": "^0.6.10",
+    "tsdown": "^0.7.0",
     "typedoc": "^0.28.1",
     "typedoc-plugin-markdown": "^4.6.0",
     "typedoc-vitepress-theme": "^1.1.2",
@@ -103,8 +111,9 @@
     "typescript-eslint": "^8.28.0",
     "vitepress": "^1.6.3",
     "vitepress-plugin-group-icons": "^1.3.8",
-    "vitepress-plugin-llms": "^0.0.21",
-    "vitest": "^3.0.9"
+    "vitepress-plugin-llms": "^0.0.22",
+    "vitest": "^3.0.9",
+    "vue": "^3.5.13"
   },
   "prettier": "@kazupon/prettier-config",
   "lint-staged": {