gunshi 0.26.3 → 0.27.0-alpha.2

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-	<img width="196" src="./assets/logo.png">
+	<img alt="logo" width="196" src="./assets/logo.png">
 </p>
 <h1 align="center">🏯 Gunshi</h1>
 
@@ -102,6 +102,7 @@ About more details and usage, see [documentations](https://gunshi.dev)
 - [sourcemap-publisher](https://github.com/es-tooling/sourcemap-publisher): A tool to publish sourcemaps externally and rewrite sourcemap URLs at pre-publish time
 - [curxy](https://github.com/ryoppippi/curxy): An proxy worker for using ollama in cursor
 - [SiteMCP](https://github.com/ryoppippi/sitemcp): Fetch an entire site and use it as an MCP Server
+- [ccusage](https://github.com/ryoppippi/ccusage): A CLI tool for analyzing Claude Code usage from local JSONL files.
 
 ## 🙌 Contributing guidelines
 
@@ -123,7 +124,7 @@ The development of Gunshi 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'/>
+    <img alt="sponsor" src='https://cdn.jsdelivr.net/gh/kazupon/sponsors/sponsors.svg'/>
   </a>
 </p>
 

package/lib/bone.d.ts

@@ -0,0 +1,36 @@
+import { ArgSchema, ArgToken, ArgValues, Args, Awaitable, CliOptions, Command, CommandCallMode, CommandContext, CommandContextCore, CommandContextExtension, CommandDecorator, CommandEnvironment, CommandExamplesFetcher, CommandLoader, CommandRunner, Commandable, DefaultGunshiParams, ExtendContext, ExtractArgs, ExtractExtensions, GunshiParams, GunshiParamsConstraint, LazyCommand, NormalizeToGunshiParams, RendererDecorator, ValidationErrorsDecorator } from "./types-ClnyW35e.js";
+
+//#region src/cli/bone.d.ts
+
+/**
+ * Run the command.
+ * @param args Command line arguments
+ * @param entry A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+ * @param options A {@link CliOptions | CLI options}
+ * @returns A rendered usage or undefined. if you will use {@link CliOptions.usageSilent} option, it will return rendered usage string.
+ */
+declare function cli<A extends Args = Args, G extends GunshiParams = {
+  args: A;
+  extensions: {};
+}>(argv: string[], entry: Command<G> | CommandRunner<G> | LazyCommand<G>, options?: CliOptions<G>): Promise<string | undefined>;
+/**
+ * Run the command.
+ * @param args Command line arguments
+ * @param entry A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+ * @param options A {@link CliOptions | CLI options}
+ * @returns A rendered usage or undefined. if you will use {@link CliOptions.usageSilent} option, it will return rendered usage string.
+ */
+declare function cli<E extends ExtendContext = ExtendContext, G extends GunshiParams = {
+  args: Args;
+  extensions: E;
+}>(argv: string[], entry: Command<G> | CommandRunner<G> | LazyCommand<G>, options?: CliOptions<G>): Promise<string | undefined>;
+/**
+ * Run the command.
+ * @param args Command line arguments
+ * @param entry A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+ * @param options A {@link CliOptions | CLI options}
+ * @returns A rendered usage or undefined. if you will use {@link CliOptions.usageSilent} option, it will return rendered usage string.
+ */
+declare function cli<G extends GunshiParams = DefaultGunshiParams>(argv: string[], entry: Command<G> | CommandRunner<G> | LazyCommand<G>, options?: CliOptions<G>): Promise<string | undefined>;
+//#endregion
+export { ArgSchema, ArgToken, ArgValues, Args, Awaitable, CliOptions, Command, CommandCallMode, CommandContext, CommandContextCore, CommandContextExtension, CommandDecorator, CommandEnvironment, CommandExamplesFetcher, CommandLoader, CommandRunner, Commandable, DefaultGunshiParams, ExtendContext, ExtractArgs, ExtractExtensions, GunshiParams, GunshiParamsConstraint, LazyCommand, NormalizeToGunshiParams, RendererDecorator, ValidationErrorsDecorator, cli };

package/lib/bone.js

@@ -0,0 +1,18 @@
+import "./context-DZ06drtF.js";
+import "./utils-DPIUzHzX.js";
+import { cliCore } from "./core-ClAxkDQL.js";
+
+//#region src/cli/bone.ts
+/**
+* Run the command.
+* @param args Command line arguments
+* @param entry A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+* @param options A {@link CliOptions | CLI options}
+* @returns A rendered usage or undefined. if you will use {@link CliOptions.usageSilent} option, it will return rendered usage string.
+*/
+async function cli(argv, entry, options = {}) {
+	return cliCore(argv, entry, options, []);
+}
+
+//#endregion
+export { cli };

package/lib/cli-CkDncXPO.js

@@ -0,0 +1,107 @@
+import { cliCore } from "./core-ClAxkDQL.js";
+import { plugin } from "./core-6RK6f9Jg.js";
+import { COMMON_ARGS, namespacedId, renderer } from "./src-Dgf8uyR8.js";
+
+//#region ../plugin-global/src/types.ts
+/**
+* The unique identifier for the global options plugin.
+*/
+const pluginId = namespacedId("global");
+
+//#endregion
+//#region ../plugin-global/src/decorator.ts
+/**
+* Decorator function to extend the command with global options.
+*/
+const decorator = (baseRunner) => async (ctx) => {
+	const { values, validationError, extensions: { [pluginId]: { showVersion, showHeader, showUsage, showValidationErrors } } } = ctx;
+	if (values.version) return showVersion();
+	const buf = [];
+	const header = await showHeader();
+	if (header) buf.push(header);
+	if (values.help) {
+		const usage = await showUsage();
+		if (usage) {
+			buf.push(usage);
+			return buf.join("\n");
+		}
+		return;
+	}
+	if (validationError) return await showValidationErrors(validationError);
+	return baseRunner(ctx);
+};
+var decorator_default = decorator;
+
+//#endregion
+//#region ../plugin-global/src/extension.ts
+function extension(ctx) {
+	return {
+		showVersion: () => {
+			const version = ctx.env.version || "unknown";
+			if (!ctx.env.usageSilent) ctx.log(version);
+			return version;
+		},
+		showHeader: async () => {
+			let header;
+			if (ctx.env.renderHeader != null) {
+				header = await ctx.env.renderHeader(ctx);
+				if (header) {
+					ctx.log(header);
+					ctx.log();
+				}
+			}
+			return header;
+		},
+		showUsage: async () => {
+			if (ctx.env.renderUsage != null) {
+				const usage = await ctx.env.renderUsage(ctx);
+				if (usage) {
+					ctx.log(usage);
+					return usage;
+				}
+			}
+		},
+		showValidationErrors: async (error) => {
+			if (ctx.env.renderValidationErrors === null) return;
+			if (ctx.env.renderValidationErrors !== void 0) {
+				const message = await ctx.env.renderValidationErrors(ctx, error);
+				ctx.log(message);
+				return message;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region ../plugin-global/src/index.ts
+/**
+* global options plugin
+*/
+function global() {
+	return plugin({
+		id: pluginId,
+		name: "global options",
+		extension,
+		setup(ctx) {
+			for (const [name, schema] of Object.entries(COMMON_ARGS)) ctx.addGlobalOption(name, schema);
+			ctx.decorateCommand(decorator_default);
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/builtin.ts
+/**
+* Run the command.
+* @param args Command line arguments
+* @param entry A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+* @param options A {@link CliOptions | CLI options}
+* @returns A rendered usage or undefined. if you will use {@link CliOptions.usageSilent} option, it will return rendered usage string.
+*/
+async function cli(argv, entry, options = {}) {
+	const builtInPlugins = [global(), renderer()];
+	return cliCore(argv, entry, options, builtInPlugins);
+}
+
+//#endregion
+export { cli };

package/lib/context-DZ06drtF.js

@@ -0,0 +1,87 @@
+import { create, deepFreeze, isLazyCommand, log } from "./utils-DPIUzHzX.js";
+
+//#region src/constants.ts
+const ANONYMOUS_COMMAND_NAME = "(anonymous)";
+const NOOP = () => {};
+const COMMAND_OPTIONS_DEFAULT = {
+	name: void 0,
+	description: void 0,
+	version: void 0,
+	cwd: void 0,
+	usageSilent: false,
+	subCommands: void 0,
+	leftMargin: 2,
+	middleMargin: 10,
+	usageOptionType: false,
+	usageOptionValue: true,
+	renderHeader: void 0,
+	renderUsage: void 0,
+	renderValidationErrors: void 0,
+	plugins: void 0
+};
+
+//#endregion
+//#region src/context.ts
+/**
+* Create a {@link CommandContext | command context}
+* @param param A {@link CommandContextParams | parameters} to create a {@link CommandContext | command context}
+* @returns A {@link CommandContext | command context}, which is readonly
+*/
+async function createCommandContext({ args, values, positionals, rest, argv, tokens, command, extensions = {}, cliOptions, callMode = "entry", omitted = false, validationError }) {
+	/**
+	* normailize the options schema and values, to avoid prototype pollution
+	*/
+	const _args = Object.entries(args).reduce((acc, [key, value]) => {
+		acc[key] = Object.assign(create(), value);
+		return acc;
+	}, create());
+	/**
+	* setup the environment
+	*/
+	const env = Object.assign(create(), COMMAND_OPTIONS_DEFAULT, cliOptions);
+	/**
+	* create the command context
+	*/
+	const core = Object.assign(create(), {
+		name: getCommandName(command),
+		description: command.description,
+		omitted,
+		callMode,
+		env,
+		args: _args,
+		values,
+		positionals,
+		rest,
+		_: argv,
+		tokens,
+		toKebab: command.toKebab,
+		log: cliOptions.usageSilent ? NOOP : log,
+		validationError
+	});
+	/**
+	* extend the command context with extensions
+	*/
+	if (Object.keys(extensions).length > 0) {
+		const ext = create(null);
+		Object.defineProperty(core, "extensions", {
+			value: ext,
+			writable: false,
+			enumerable: true,
+			configurable: true
+		});
+		for (const [key, extension] of Object.entries(extensions)) {
+			ext[key] = await extension.factory(core, command);
+			if (extension.onFactory) await extension.onFactory(core, command);
+		}
+	}
+	const ctx = deepFreeze(core, ["extensions"]);
+	return ctx;
+}
+function getCommandName(cmd) {
+	if (isLazyCommand(cmd)) return cmd.commandName || cmd.name || ANONYMOUS_COMMAND_NAME;
+	else if (typeof cmd === "object") return cmd.name || ANONYMOUS_COMMAND_NAME;
+	else return ANONYMOUS_COMMAND_NAME;
+}
+
+//#endregion
+export { ANONYMOUS_COMMAND_NAME, COMMAND_OPTIONS_DEFAULT, NOOP, createCommandContext };

package/lib/context.d.ts

@@ -1,19 +1,22 @@
-import { CliOptions, Command, CommandCallMode, CommandContext, LazyCommand } from "./types-DtEE4hKC.js";
-import { ArgToken, ArgValues, Args } from "args-tokens";
+import { ArgToken, ArgValues, CliOptions, Command, CommandCallMode, CommandContext, CommandContextExtension, DefaultGunshiParams, ExtendContext, ExtractArgs, GunshiParams, GunshiParamsConstraint, LazyCommand } from "./types-ClnyW35e.js";
 
 //#region src/context.d.ts
-/**
-* Parameters of {@link createCommandContext}
-*/
 
+/**
+ * Extract extension return types from extensions record
+ * @internal
+ */
+type ExtractExtensions<E extends Record<string, CommandContextExtension>> = { [K in keyof E]: E[K] extends CommandContextExtension<infer T> ? T : never };
 /**
  * Parameters of {@link createCommandContext}
  */
-interface CommandContextParams<A extends Args, V> {
+interface CommandContextParams<G extends GunshiParams | {
+  extensions: ExtendContext;
+}, V extends ArgValues<ExtractArgs<G>>, C extends Command<G> | LazyCommand<G> = Command<G>, E extends Record<string, CommandContextExtension> = Record<string, CommandContextExtension>> {
   /**
    * An arguments of target command
    */
-  args: A;
+  args: ExtractArgs<G>;
   /**
    * A values of target command
    */
@@ -45,18 +48,26 @@ interface CommandContextParams<A extends Args, V> {
   /**
    * A target command
    */
-  command: Command<A> | LazyCommand<A>;
+  command: C;
+  /**
+   * Plugin extensions to apply as the command context extension.
+   */
+  extensions?: E;
   /**
    * A command options, which is spicialized from `cli` function
    */
-  cliOptions: CliOptions<A>;
+  cliOptions: CliOptions<G>;
+  /**
+   * Validation error from argument parsing.
+   */
+  validationError?: AggregateError;
 }
 /**
  * Create a {@link CommandContext | command context}
  * @param param A {@link CommandContextParams | parameters} to create a {@link CommandContext | command context}
  * @returns A {@link CommandContext | command context}, which is readonly
  */
-declare function createCommandContext<A extends Args = Args, V extends ArgValues<A> = ArgValues<A>>({
+declare function createCommandContext<G extends GunshiParamsConstraint = DefaultGunshiParams, V extends ArgValues<ExtractArgs<G>> = ArgValues<ExtractArgs<G>>, C extends Command<G> | LazyCommand<G> = Command<G>, E extends Record<string, CommandContextExtension> = {}>({
   args,
   values,
   positionals,
@@ -64,8 +75,14 @@ declare function createCommandContext<A extends Args = Args, V extends ArgValues
   argv,
   tokens,
   command,
+  extensions,
   cliOptions,
   callMode,
-  omitted
-}: CommandContextParams<A, V>): Promise<Readonly<CommandContext<A, V>>>; //#endregion
-export { createCommandContext };
+  omitted,
+  validationError
+}: CommandContextParams<G, V, C, E>): Promise<{} extends ExtractExtensions<E> ? Readonly<CommandContext<G>> : Readonly<CommandContext<GunshiParams<{
+  args: ExtractArgs<G>;
+  extensions: ExtractExtensions<E>;
+}>>>>;
+//#endregion
+export { ExtractExtensions, createCommandContext };

package/lib/context.js

@@ -1,4 +1,4 @@
-import "./utils-D41C8Abf.js";
-import { createCommandContext } from "./context-D_EmfRNA.js";
+import { createCommandContext } from "./context-DZ06drtF.js";
+import "./utils-DPIUzHzX.js";
 
 export { createCommandContext };

package/lib/core-6RK6f9Jg.js

@@ -0,0 +1,46 @@
+//#region src/plugin/core.ts
+/**
+* Define a plugin
+* @param options - {@link PluginOptions | plugin options}
+* @returns A defined plugin.
+* @since v0.27.0
+*/
+function plugin(options) {
+	const { id, name, setup, extension, onExtension, dependencies } = options;
+	const pluginFn = async (ctx) => {
+		if (setup) await setup(ctx);
+	};
+	return Object.defineProperties(pluginFn, {
+		id: {
+			value: id,
+			writable: false,
+			enumerable: true,
+			configurable: true
+		},
+		...name && { name: {
+			value: name,
+			writable: false,
+			enumerable: true,
+			configurable: true
+		} },
+		...dependencies && { dependencies: {
+			value: dependencies,
+			writable: false,
+			enumerable: true,
+			configurable: true
+		} },
+		...extension && { extension: {
+			value: {
+				key: Symbol(id),
+				factory: extension,
+				onFactory: onExtension
+			},
+			writable: false,
+			enumerable: true,
+			configurable: true
+		} }
+	});
+}
+
+//#endregion
+export { plugin };

package/lib/core-ClAxkDQL.js

@@ -0,0 +1,285 @@
+import { ANONYMOUS_COMMAND_NAME, COMMAND_OPTIONS_DEFAULT, NOOP, createCommandContext } from "./context-DZ06drtF.js";
+import { create, isLazyCommand, resolveLazyCommand } from "./utils-DPIUzHzX.js";
+import { parseArgs, resolveArgs } from "args-tokens";
+
+//#region src/decorators.ts
+const EMPTY_RENDERER = async () => "";
+/**
+* Factory function for creating a decorators manager.
+* @returns A new decorators manager instance
+*/
+function createDecorators() {
+	/**
+	* private states
+	*/
+	const headerDecorators = [];
+	const usageDecorators = [];
+	const validationDecorators = [];
+	const commandDecorators = [];
+	/**
+	* helper function for building renderers
+	*/
+	function buildRenderer(decorators, defaultRenderer) {
+		if (decorators.length === 0) return defaultRenderer;
+		let renderer = defaultRenderer;
+		for (const decorator of decorators) {
+			const previousRenderer = renderer;
+			renderer = (ctx) => decorator(previousRenderer, ctx);
+		}
+		return renderer;
+	}
+	/**
+	* public interfaces
+	*/
+	return Object.freeze({
+		addHeaderDecorator(decorator) {
+			headerDecorators.push(decorator);
+		},
+		addUsageDecorator(decorator) {
+			usageDecorators.push(decorator);
+		},
+		addValidationErrorsDecorator(decorator) {
+			validationDecorators.push(decorator);
+		},
+		addCommandDecorator(decorator) {
+			commandDecorators.push(decorator);
+		},
+		get commandDecorators() {
+			return [...commandDecorators];
+		},
+		getHeaderRenderer() {
+			return buildRenderer(headerDecorators, EMPTY_RENDERER);
+		},
+		getUsageRenderer() {
+			return buildRenderer(usageDecorators, EMPTY_RENDERER);
+		},
+		getValidationErrorsRenderer() {
+			if (validationDecorators.length === 0) return EMPTY_RENDERER;
+			let renderer = EMPTY_RENDERER;
+			for (const decorator of validationDecorators) {
+				const previousRenderer = renderer;
+				renderer = (ctx, error) => decorator(previousRenderer, ctx, error);
+			}
+			return renderer;
+		}
+	});
+}
+
+//#endregion
+//#region src/plugin/context.ts
+/**
+* Factory function for creating a plugin context.
+* @param decorators - A {@link Decorators} instance.
+* @returns A new {@link PluginContext} instance.
+*/
+function createPluginContext(decorators) {
+	/**
+	* private states
+	*/
+	const globalOptions = new Map();
+	/**
+	* public interfaces
+	*/
+	return Object.freeze({
+		get globalOptions() {
+			return new Map(globalOptions);
+		},
+		addGlobalOption(name, schema) {
+			if (!name) throw new Error("Option name must be a non-empty string");
+			if (globalOptions.has(name)) throw new Error(`Global option '${name}' is already registered`);
+			globalOptions.set(name, schema);
+		},
+		decorateHeaderRenderer(decorator) {
+			decorators.addHeaderDecorator(decorator);
+		},
+		decorateUsageRenderer(decorator) {
+			decorators.addUsageDecorator(decorator);
+		},
+		decorateValidationErrorsRenderer(decorator) {
+			decorators.addValidationErrorsDecorator(decorator);
+		},
+		decorateCommand(decorator) {
+			decorators.addCommandDecorator(decorator);
+		}
+	});
+}
+
+//#endregion
+//#region src/plugin/dependency.ts
+/**
+* Resolve plugin dependencies using topological sort
+* @param plugins - Array of plugins to resolve
+* @returns Array of plugins sorted by dependencies
+* @throws Error if circular dependency is detected or required dependency is missing
+*/
+function resolveDependencies(plugins) {
+	const sorted = [];
+	const visited = new Set();
+	const visiting = new Set();
+	const pluginMap = new Map();
+	for (const plugin of plugins) if (plugin.id) {
+		if (pluginMap.has(plugin.id)) console.warn(`Duplicate plugin id detected: \`${plugin.id}\``);
+		pluginMap.set(plugin.id, plugin);
+	}
+	function visit(plugin) {
+		if (!plugin.id) return;
+		if (visited.has(plugin.id)) return;
+		if (visiting.has(plugin.id)) throw new Error(`Circular dependency detected: \`${[...visiting].join(` -> `) + " -> " + plugin.id}\``);
+		visiting.add(plugin.id);
+		const deps = plugin.dependencies || [];
+		for (const dep of deps) {
+			const depId = typeof dep === "string" ? dep : dep.id;
+			const isOptional = typeof dep === "string" ? false : dep.optional || false;
+			const depPlugin = pluginMap.get(depId);
+			if (!depPlugin && !isOptional) throw new Error(`Missing required dependency: \`${depId}\` on \`${plugin.id}\``);
+			if (depPlugin) visit(depPlugin);
+		}
+		visiting.delete(plugin.id);
+		visited.add(plugin.id);
+		sorted.push(plugin);
+	}
+	for (const plugin of plugins) visit(plugin);
+	return sorted;
+}
+
+//#endregion
+//#region src/cli/core.ts
+async function cliCore(argv, entry, options, plugins) {
+	const decorators = createDecorators();
+	const pluginContext = createPluginContext(decorators);
+	const resolvedPlugins = await applyPlugins(pluginContext, [...plugins, ...options.plugins || []]);
+	const cliOptions = normalizeCliOptions(options, entry, decorators);
+	const tokens = parseArgs(argv);
+	const subCommand = getSubCommand(tokens);
+	const { commandName: name, command, callMode } = await resolveCommand(subCommand, entry, cliOptions);
+	if (!command) throw new Error(`Command not found: ${name || ""}`);
+	const args = resolveArguments(pluginContext, getCommandArgs(command));
+	const { values, positionals, rest, error } = resolveArgs(args, tokens, {
+		shortGrouping: true,
+		toKebab: command.toKebab,
+		skipPositional: cliOptions.subCommands.size > 0 ? 0 : -1
+	});
+	const omitted = !subCommand;
+	const commandContext = await createCommandContext({
+		args,
+		values,
+		positionals,
+		rest,
+		argv,
+		tokens,
+		omitted,
+		callMode,
+		command,
+		extensions: getPluginExtensions(resolvedPlugins),
+		validationError: error,
+		cliOptions
+	});
+	return await executeCommand(command, commandContext, name || "", decorators.commandDecorators);
+}
+async function applyPlugins(pluginContext, plugins) {
+	const sortedPlugins = resolveDependencies(plugins);
+	try {
+		for (const plugin of sortedPlugins)
+ /**
+		* NOTE(kazupon):
+		* strictly `Args` are not required for plugin installation.
+		* because the strictly `Args` required by each plugin are unknown,
+		* and the plugin side can not know what the user will specify.
+		*/
+		await plugin(pluginContext);
+	} catch (error) {
+		console.error("Error loading plugin:", error.message);
+	}
+	return sortedPlugins;
+}
+function getCommandArgs(cmd) {
+	if (isLazyCommand(cmd)) return cmd.args || create();
+	else if (typeof cmd === "object") return cmd.args || create();
+	else return create();
+}
+function resolveArguments(pluginContext, args) {
+	return Object.assign(create(), Object.fromEntries(pluginContext.globalOptions), args);
+}
+function normalizeCliOptions(options, entry, decorators) {
+	const subCommands = new Map(options.subCommands);
+	if (options.subCommands) {
+		if (isLazyCommand(entry)) subCommands.set(entry.commandName, entry);
+		else if (typeof entry === "object" && entry.name) subCommands.set(entry.name, entry);
+	}
+	const resolvedOptions = Object.assign(create(), COMMAND_OPTIONS_DEFAULT, options, { subCommands });
+	if (resolvedOptions.renderHeader === void 0) resolvedOptions.renderHeader = decorators.getHeaderRenderer();
+	if (resolvedOptions.renderUsage === void 0) resolvedOptions.renderUsage = decorators.getUsageRenderer();
+	if (resolvedOptions.renderValidationErrors === void 0) resolvedOptions.renderValidationErrors = decorators.getValidationErrorsRenderer();
+	return resolvedOptions;
+}
+function getSubCommand(tokens) {
+	const firstToken = tokens[0];
+	return firstToken && firstToken.kind === "positional" && firstToken.index === 0 && firstToken.value ? firstToken.value : "";
+}
+const CANNOT_RESOLVE_COMMAND = { callMode: "unexpected" };
+async function resolveCommand(sub, entry, options) {
+	const omitted = !sub;
+	async function doResolveCommand() {
+		if (typeof entry === "function") if ("commandName" in entry && entry.commandName) return {
+			commandName: entry.commandName,
+			command: entry,
+			callMode: "entry"
+		};
+		else return {
+			command: { run: entry },
+			callMode: "entry"
+		};
+		else if (typeof entry === "object") return {
+			commandName: resolveEntryName(entry),
+			command: entry,
+			callMode: "entry"
+		};
+		else return CANNOT_RESOLVE_COMMAND;
+	}
+	if (omitted || options.subCommands?.size === 0) return doResolveCommand();
+	const cmd = options.subCommands?.get(sub);
+	if (cmd == null) return {
+		commandName: sub,
+		callMode: "unexpected"
+	};
+	if (isLazyCommand(cmd) && cmd.commandName == null) cmd.commandName = sub;
+	else if (typeof cmd === "object" && cmd.name == null) cmd.name = sub;
+	return {
+		commandName: sub,
+		command: cmd,
+		callMode: "subCommand"
+	};
+}
+function resolveEntryName(entry) {
+	return entry.name || ANONYMOUS_COMMAND_NAME;
+}
+function getPluginExtensions(plugins) {
+	const extensions = create();
+	for (const plugin of plugins) if (plugin.extension) {
+		const key = plugin.id;
+		if (extensions[key]) console.warn(`Plugin "${key}" is already installed. ignore it for command context extending.`);
+		else extensions[key] = plugin.extension;
+	}
+	return extensions;
+}
+async function executeCommand(cmd, ctx, name, decorators) {
+	const resolved = isLazyCommand(cmd) ? await resolveLazyCommand(cmd, name, true) : cmd;
+	const baseRunner = resolved.run || NOOP;
+	const decoratedRunner = decorators.reduceRight((runner, decorator) => decorator(runner), baseRunner);
+	try {
+		if (ctx.env.onBeforeCommand) await ctx.env.onBeforeCommand(ctx);
+		const result = await decoratedRunner(ctx);
+		if (ctx.env.onAfterCommand) await ctx.env.onAfterCommand(ctx, result);
+		return typeof result === "string" ? result : void 0;
+	} catch (error) {
+		if (ctx.env.onErrorCommand) try {
+			await ctx.env.onErrorCommand(ctx, error);
+		} catch (hookError) {
+			console.error("Error in onErrorCommand hook:", hookError);
+		}
+		throw error;
+	}
+}
+
+//#endregion
+export { cliCore };