@shell-shock/core 0.1.1 → 0.2.1

package/dist/components/utils-builtin.mjs

@@ -0,0 +1,447 @@
+import defu$1 from "defu";
+import { createComponent, createIntrinsic, mergeProps } from "@alloy-js/core/jsx-runtime";
+import { Show, code, splitProps } from "@alloy-js/core";
+import { FunctionDeclaration, InterfaceDeclaration, InterfaceMember, VarDeclaration } from "@alloy-js/typescript";
+import { BuiltinFile } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
+import { TSDoc, TSDocLink, TSDocParam, TSDocReturns } from "@powerlines/plugin-alloy/typescript/components/tsdoc";
+
+//#region src/components/utils-builtin.tsx
+/**
+* Generates utilities for detecting terminal color support.
+*/
+function EnvSupportUtilities() {
+	return [
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isTTY",
+			doc: "Detect if stdout.TTY is available",
+			initializer: code`Boolean(process.stdout && process.stdout.isTTY);`
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isMinimal",
+			doc: "Detect if the current environment is minimal (CI, non-TTY, etc.)",
+			initializer: code` env.MINIMAL || isCI || isTest || !isTTY; `
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isInteractive",
+			doc: "Detect if the current environment is interactive",
+			initializer: code` !isMinimal && process.stdin?.isTTY && env.TERM !== "dumb"; `
+		})
+	];
+}
+/**
+* Generates utilities for detecting terminal color support.
+*/
+function ColorSupportUtilities() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "GetColorSupportLevelOptions",
+			doc: "Options for the getColorSupportLevel function",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "ignoreFlags",
+					type: "boolean",
+					doc: "Indicates if the function should skip checking command-line flags for color support"
+				});
+			}
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(TSDoc, {
+			heading: "Checks if a specific flag is present in the command line arguments.",
+			get children() {
+				return [
+					createComponent(TSDocLink, { children: "https://github.com/sindresorhus/has-flag/blob/main/index.js" }),
+					createComponent(TSDocParam, {
+						name: "flag",
+						children: "The flag to check for, e.g., \"color\", \"no-color\"."
+					}),
+					createComponent(TSDocParam, {
+						name: "argv",
+						children: "The command line arguments to check against. Defaults to global Deno args or process args."
+					}),
+					createComponent(TSDocReturns, { children: "True if the flag is present, false otherwise." })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "getColorSupportLevel",
+			parameters: [{
+				name: "stream",
+				type: "NodeJS.WriteStream & { fd: 1 | 2; }"
+			}, {
+				name: "options",
+				type: "GetColorSupportLevelOptions",
+				default: "{}"
+			}],
+			children: code`const { ignoreFlags = false } = options;
+
+        let forceColor: number | undefined;
+        if (env.FORCE_COLOR !== undefined) {
+          forceColor = !env.FORCE_COLOR
+            ? 0
+            : typeof env.FORCE_COLOR === "boolean"
+            ? 1
+            : typeof env.FORCE_COLOR === "number" &&
+              [0, 1, 2, 3].includes(Math.min(env.FORCE_COLOR as number, 3))
+            ? Math.min(env.FORCE_COLOR as number, 3)
+            : undefined;
+        }
+
+        if (ignoreFlags !== true && forceColor === undefined) {
+          forceColor = hasFlag("no-color") ||
+            hasFlag("no-colors") ||
+            hasFlag("color=false") ||
+            hasFlag("color=never")
+          ? 0
+          : hasFlag("color") ||
+            hasFlag("colors") ||
+            hasFlag("color=true") ||
+            hasFlag("color=always")
+          ? 1
+          : 0;
+        }
+
+        if (forceColor === 0) {
+          return 0;
+        }
+
+        if (ignoreFlags !== true) {
+          if (hasFlag("color=16m") ||
+            hasFlag("color=full") ||
+            hasFlag("color=truecolor")) {
+            return 3;
+          }
+
+          if (hasFlag("color=256")) {
+            return 2;
+          }
+        }
+
+        const level = Boolean(env.TF_BUILD) || Boolean(env.AGENT_NAME)
+          ? 1
+          : stream &&
+              !(isTTY || (stream && stream.isTTY)) &&
+              forceColor === undefined
+            ? 0
+            : env.TERM === "dumb"
+              ? forceColor || 0
+              : isWindows
+                ? Number(os.release().split(".")[0]) >= 10 &&
+                  Number(os.release().split(".")[2]) >= 10_586
+                  ? Number(os.release().split(".")[2]) >= 14_931
+                    ? 3
+                    : 2
+                  : 1
+                : isCI
+                  ? Boolean(env.GITHUB_ACTIONS) ||
+                    Boolean(env.GITEA_ACTIONS) ||
+                    Boolean(env.CIRCLECI)
+                    ? 3
+                    : Boolean(env.TRAVIS) ||
+                      Boolean(env.APPVEYOR) ||
+                      Boolean(env.GITLAB_CI) ||
+                      Boolean(env.BUILDKITE) ||
+                      Boolean(env.DRONE) ||
+                      env.CI_NAME === "codeship"
+                      ? 1
+                      : forceColor || 0
+                  : Boolean(env.TEAMCITY_VERSION)
+                    ? /^(?:9\.0*[1-9]\d*\.|\d{2,}\.)/.test(String(env.TEAMCITY_VERSION) || "")
+                      ? 1
+                      : 0
+                    : String(env.COLORTERM) === "truecolor" ||
+                        env.TERM === "xterm-kitty"
+                      ? 3
+                      : Boolean(env.TERM_PROGRAM)
+                        ? env.TERM_PROGRAM === "iTerm.app"
+                          ? Number.parseInt(
+                              (env.TERM_PROGRAM_VERSION || "").split(".")[0] as string,
+                              10
+                            ) >= 3
+                            ? 3
+                            : 2
+                          : env.TERM_PROGRAM === "Apple_Terminal"
+                            ? 2
+                            : 0
+                        : /-256(?:color)?$/i.test(env.TERM || "")
+                          ? 2
+                          : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(
+                                env.TERM || ""
+                              )
+                            ? 1
+                            : Boolean(env.COLORTERM);
+
+        return typeof level === "boolean" || level === 0
+          ? false
+          : {
+              level,
+              hasBasic: true,
+              has256: level >= 2,
+              has16m: level >= 3,
+            };
+
+  `
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "colorSupportLevels",
+			doc: "Detect the terminal color support level in the current environment",
+			initializer: code` {
+    stdout: getColorSupportLevel(process.stdout),
+    stderr: getColorSupportLevel(process.stderr),
+  }; `
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isColorSupported",
+			doc: "Detect if terminal color is supported in the current environment",
+			initializer: code` Boolean(colorSupportLevels.stdout); `
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isUnicodeSupported",
+			doc: "Detect if Unicode characters are supported in the current environment",
+			initializer: code` !isWindows
+            ? env.TERM !== "linux"
+            : Boolean(env.WT_SESSION) ||
+                Boolean(env.TERMINUS_SUBLIME) ||
+                env.ConEmuTask === "{cmd::Cmder}" ||
+                env.TERM_PROGRAM === "Terminus-Sublime" ||
+                env.TERM_PROGRAM === "vscode" ||
+                env.TERM === "xterm-256color" ||
+                env.TERM === "alacritty" ||
+                env.TERM === "rxvt-unicode" ||
+                env.TERM === "rxvt-unicode-256color" ||
+                env.TERMINAL_EMULATOR === "JetBrains-JediTerm"; `
+		})
+	];
+}
+/**
+* Generates utilities for detecting terminal color support.
+*/
+function HyperlinkSupportUtilities() {
+	return [
+		createComponent(FunctionDeclaration, {
+			name: "parseVersion",
+			parameters: [{
+				name: "version",
+				type: "string",
+				default: "\"\""
+			}],
+			children: code`if (/^\d{3,4}$/.test(version)) {
+        const match = /(\d{1,2})(\d{2})/.exec(version) ?? [];
+
+        return {
+          major: 0,
+          minor: Number.parseInt(match[1]!, 10),
+          patch: Number.parseInt(match[2]!, 10)
+        };
+      }
+
+      const versionParts = (version ?? "")
+        .split(".")
+        .map(n => Number.parseInt(n, 10));
+
+      return {
+        major: versionParts[0],
+        minor: versionParts[1],
+        patch: versionParts[2]
+      }; `
+		}),
+		createComponent(TSDoc, {
+			heading: "Check if the current environment/terminal supports hyperlinks in the terminal.",
+			get children() {
+				return createComponent(TSDocReturns, { children: "True if the current environment/terminal supports hyperlinks." });
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "isHyperlinkSupported",
+			returnType: "boolean",
+			children: code`if (Boolean(env.FORCE_HYPERLINK)) {
+          return true;
+        }
+
+        if (Boolean(env.NETLIFY)) {
+          return true;
+        } else if (isColorSupported || isTTY) {
+          return false;
+        } else if (Boolean(env.WT_SESSION)) {
+          return true;
+        } else if (isWindows || isMinimal || Boolean(env.TEAMCITY_VERSION)) {
+          return false;
+        } else if (Boolean(env.TERM_PROGRAM)) {
+          const version = parseVersion(env.TERM_PROGRAM_VERSION);
+
+          switch (String(env.TERM_PROGRAM)) {
+            case "iTerm.app": {
+              if (version.major === 3) {
+                return version.minor !== undefined && version.minor >= 1;
+              }
+
+              return version.major !== undefined && version.major > 3;
+            }
+            case "WezTerm": {
+              return version.major !== undefined && version.major >= 20_200_620;
+            }
+
+            case "vscode": {
+              if (Boolean(env.CURSOR_TRACE_ID)) {
+                return true;
+              }
+
+              return (
+                version.minor !== undefined &&
+                version.major !== undefined &&
+                (version.major > 1 || (version.major === 1 && version.minor >= 72))
+              );
+            }
+
+            case "ghostty": {
+              return true;
+            }
+          }
+        }
+
+        if (Boolean(env.VTE_VERSION)) {
+          if (env.VTE_VERSION === "0.50.0") {
+            return false;
+          }
+
+          const version = parseVersion(env.VTE_VERSION);
+          return (
+            (version.major !== undefined && version.major > 0) ||
+            (version.minor !== undefined && version.minor >= 50)
+          );
+        }
+
+        if (String(env.TERM) === "alacritty") {
+          return true;
+        }
+
+        return false; `
+		})
+	];
+}
+/**
+* Generates utilities for detecting terminal color support.
+*/
+function ArgsUtilities() {
+	return [createComponent(TSDoc, {
+		heading: "Checks if a specific flag is present in the command line arguments.",
+		get children() {
+			return [
+				createComponent(TSDocLink, { children: "https://github.com/sindresorhus/has-flag/blob/main/index.js" }),
+				createComponent(TSDocParam, {
+					name: "flag",
+					children: "The flag (or an array of flags/aliases) to check for, e.g., \"color\", \"no-color\"."
+				}),
+				createComponent(TSDocParam, {
+					name: "argv",
+					children: "The command line arguments to check against. Defaults to global Deno args or process args."
+				}),
+				createComponent(TSDocReturns, { children: "True if the flag is present, false otherwise." })
+			];
+		}
+	}), createComponent(FunctionDeclaration, {
+		"export": true,
+		name: "hasFlag",
+		parameters: [{
+			name: "flag",
+			type: "string | string[]"
+		}, {
+			name: "argv",
+			type: "string[]",
+			optional: true,
+			default: "globalThis.Deno ? globalThis.Deno.args : process.argv"
+		}],
+		get children() {
+			return [
+				createComponent(VarDeclaration, {
+					"const": true,
+					name: "position",
+					type: "number",
+					initializer: code`(Array.isArray(flag) ? flag : [flag]).reduce((ret, f) => {
+            const pos = argv.findIndex(arg => (f.startsWith("-") ? "" : (f.length === 1 ? "-" : "--") + f)?.toLowerCase() === arg?.toLowerCase() || arg?.toLowerCase().startsWith((f.length === 1 ? "-" : "--") + f + "=")?.toLowerCase());
+            return pos !== -1 ? pos : ret;
+          }, -1);`
+				}),
+				createIntrinsic("hbr", {}),
+				code`return position !== -1 && argv.indexOf("--") === -1 || position < argv.indexOf("--");`
+			];
+		}
+	})];
+}
+/**
+* A built-in utilities module for Shell Shock.
+*/
+function UtilsBuiltin(props) {
+	const [{ children }, rest] = splitProps(props, ["children"]);
+	return createComponent(BuiltinFile, mergeProps({
+		id: "utils",
+		description: "A collection of helper utilities that ease command-line application development."
+	}, rest, {
+		get imports() {
+			return defu$1(rest.imports ?? {}, {
+				"node:os": ["os"],
+				"node:process": ["process"]
+			});
+		},
+		get builtinImports() {
+			return defu$1(rest.builtinImports ?? {}, { env: [
+				"env",
+				"isCI",
+				"isTest",
+				"isWindows"
+			] });
+		},
+		get children() {
+			return [
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(ArgsUtilities, {}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(EnvSupportUtilities, {}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(HyperlinkSupportUtilities, {}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(ColorSupportUtilities, {}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(Show, {
+					get when() {
+						return Boolean(children);
+					},
+					children
+				})
+			];
+		}
+	}));
+}
+
+//#endregion
+export { ArgsUtilities, ColorSupportUtilities, EnvSupportUtilities, HyperlinkSupportUtilities, UtilsBuiltin };

package/dist/config.cjs

@@ -1 +1,17 @@
-function e(e){return e}exports.defineConfig=e;
+
+//#region src/config.ts
+/**
+* A utility function to define a Shell Shock user configuration.
+*
+* @remarks
+* This function is used to create a user configuration object for Shell Shock projects. It ensures that the configuration adheres to the expected structure.
+*
+* @param config - A partial user configuration object.
+* @returns A complete user configuration object.
+*/
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+exports.defineConfig = defineConfig;

package/dist/config.mjs

@@ -1 +1,16 @@
-function e(e){return e}export{e as defineConfig};
+//#region src/config.ts
+/**
+* A utility function to define a Shell Shock user configuration.
+*
+* @remarks
+* This function is used to create a user configuration object for Shell Shock projects. It ensures that the configuration adheres to the expected structure.
+*
+* @param config - A partial user configuration object.
+* @returns A complete user configuration object.
+*/
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineConfig };

package/dist/helpers/persistence.cjs

@@ -0,0 +1,49 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let __stryke_path_join_paths = require("@stryke/path/join-paths");
+
+//#region src/helpers/persistence.ts
+function getCommandsPersistencePath(context) {
+	return (0, __stryke_path_join_paths.joinPaths)(context.dataPath, `commands.json`);
+}
+function serializedCommandTree(commands) {
+	const serialize = (node, parent = null) => {
+		const serializedNode = {
+			...node,
+			parent,
+			children: {}
+		};
+		for (const [key, child] of Object.entries(node.children || {})) serializedNode.children[key] = serialize(child, node.id);
+		return serializedNode;
+	};
+	const result = {};
+	for (const [key, child] of Object.entries(commands)) result[key] = serialize(child, null);
+	return result;
+}
+function deserializeCommandTree(serializedCommands) {
+	const deserialize = (node, parent = null) => {
+		const deserializedNode = {
+			...node,
+			parent,
+			children: {}
+		};
+		for (const [key, child] of Object.entries(node.children || {})) deserializedNode.children[key] = deserialize(child, deserializedNode);
+		return deserializedNode;
+	};
+	const result = {};
+	for (const [key, child] of Object.entries(serializedCommands)) result[key] = deserialize(child, null);
+	return result;
+}
+async function readCommandsPersistence(context) {
+	const reflections = await context.fs.read(getCommandsPersistencePath(context));
+	if (!reflections || !reflections.length) throw new Error(`CLI Command reflection file ${getCommandsPersistencePath(context)} is empty`);
+	context.commands = deserializeCommandTree(JSON.parse(reflections));
+}
+async function writeCommandsPersistence(context) {
+	const filePath = getCommandsPersistencePath(context);
+	await context.fs.write(filePath, JSON.stringify(serializedCommandTree(context.commands), null, context.config.mode === "development" ? 2 : 0));
+}
+
+//#endregion
+exports.getCommandsPersistencePath = getCommandsPersistencePath;
+exports.readCommandsPersistence = readCommandsPersistence;
+exports.writeCommandsPersistence = writeCommandsPersistence;

package/dist/helpers/persistence.mjs

@@ -0,0 +1,46 @@
+import { joinPaths } from "@stryke/path/join-paths";
+
+//#region src/helpers/persistence.ts
+function getCommandsPersistencePath(context) {
+	return joinPaths(context.dataPath, `commands.json`);
+}
+function serializedCommandTree(commands) {
+	const serialize = (node, parent = null) => {
+		const serializedNode = {
+			...node,
+			parent,
+			children: {}
+		};
+		for (const [key, child] of Object.entries(node.children || {})) serializedNode.children[key] = serialize(child, node.id);
+		return serializedNode;
+	};
+	const result = {};
+	for (const [key, child] of Object.entries(commands)) result[key] = serialize(child, null);
+	return result;
+}
+function deserializeCommandTree(serializedCommands) {
+	const deserialize = (node, parent = null) => {
+		const deserializedNode = {
+			...node,
+			parent,
+			children: {}
+		};
+		for (const [key, child] of Object.entries(node.children || {})) deserializedNode.children[key] = deserialize(child, deserializedNode);
+		return deserializedNode;
+	};
+	const result = {};
+	for (const [key, child] of Object.entries(serializedCommands)) result[key] = deserialize(child, null);
+	return result;
+}
+async function readCommandsPersistence(context) {
+	const reflections = await context.fs.read(getCommandsPersistencePath(context));
+	if (!reflections || !reflections.length) throw new Error(`CLI Command reflection file ${getCommandsPersistencePath(context)} is empty`);
+	context.commands = deserializeCommandTree(JSON.parse(reflections));
+}
+async function writeCommandsPersistence(context) {
+	const filePath = getCommandsPersistencePath(context);
+	await context.fs.write(filePath, JSON.stringify(serializedCommandTree(context.commands), null, context.config.mode === "development" ? 2 : 0));
+}
+
+//#endregion
+export { getCommandsPersistencePath, readCommandsPersistence, writeCommandsPersistence };

package/dist/helpers/resolve-command.cjs

@@ -1 +1,92 @@
-const e=require(`../_virtual/rolldown_runtime.cjs`);let t=require(`@stryke/path/append`),n=require(`@stryke/path/file-path-fns`),r=require(`@stryke/type-checks/is-set-object`),i=require(`@stryke/path/common`),a=require(`@stryke/path/normalize`),o=require(`@stryke/path/replace`),s=require(`@stryke/type-checks/is-set-string`);function c(e,t){return(0,o.replacePath)((0,n.findFilePath)(t),e.commandsRoot).replaceAll(/^\/+/g,``).replaceAll(/\/+$/g,``)}function l(e){return(0,s.isSetString)(e.config.entry)?(0,t.appendPath)((0,t.appendPath)((0,a.stripStars)(e.config.entry),e.config.projectRoot),e.workspaceConfig.workspaceRoot):(0,r.isSetObject)(e.config.entry)&&`file`in e.config.entry?(0,t.appendPath)((0,t.appendPath)((0,a.stripStars)(e.config.entry.file),e.config.projectRoot),e.workspaceConfig.workspaceRoot):Array.isArray(e.config.entry)&&e.config.entry.length>0?(0,i.commonPath)(e.config.entry.map(n=>(0,t.appendPath)((0,t.appendPath)((0,a.stripStars)((0,s.isSetString)(n)?n:n.file),e.config.projectRoot),e.workspaceConfig.workspaceRoot))):(0,t.appendPath)(e.config.sourceRoot||e.config.projectRoot,e.workspaceConfig.workspaceRoot)}exports.findCommandsRoot=l,exports.resolveCommandPath=c;
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let __stryke_helpers_get_unique = require("@stryke/helpers/get-unique");
+let __stryke_path_append = require("@stryke/path/append");
+let __stryke_path_file_path_fns = require("@stryke/path/file-path-fns");
+let __stryke_path_replace = require("@stryke/path/replace");
+let __stryke_path_resolve_parent_path = require("@stryke/path/resolve-parent-path");
+let __stryke_string_format_title_case = require("@stryke/string-format/title-case");
+let __stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+let __stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let __powerlines_deepkit_reflect_type = require("@powerlines/deepkit/reflect-type");
+let __powerlines_deepkit_vendor_type = require("@powerlines/deepkit/vendor/type");
+let __stryke_path_common = require("@stryke/path/common");
+let __stryke_path_normalize = require("@stryke/path/normalize");
+let __stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+
+//#region src/helpers/resolve-command.ts
+function resolveCommandPath(context, file) {
+	return (0, __stryke_path_replace.replacePath)((0, __stryke_path_file_path_fns.findFilePath)(file), context.commandsPath).replaceAll(/^\/+/g, "").replaceAll(/\/+$/g, "");
+}
+function findCommandsRoot(context) {
+	if ((0, __stryke_type_checks_is_set_string.isSetString)(context.config.entry)) return (0, __stryke_path_append.appendPath)((0, __stryke_path_append.appendPath)((0, __stryke_path_normalize.stripStars)(context.config.entry), context.config.projectRoot), context.workspaceConfig.workspaceRoot);
+	else if ((0, __stryke_type_checks_is_set_object.isSetObject)(context.config.entry) && "file" in context.config.entry) return (0, __stryke_path_append.appendPath)((0, __stryke_path_append.appendPath)((0, __stryke_path_normalize.stripStars)(context.config.entry.file), context.config.projectRoot), context.workspaceConfig.workspaceRoot);
+	else if (Array.isArray(context.config.entry) && context.config.entry.length > 0) return (0, __stryke_path_common.commonPath)(context.config.entry.map((entry) => (0, __stryke_path_append.appendPath)((0, __stryke_path_append.appendPath)((0, __stryke_path_normalize.stripStars)((0, __stryke_type_checks_is_set_string.isSetString)(entry) ? entry : entry.file), context.config.projectRoot), context.workspaceConfig.workspaceRoot)));
+	return (0, __stryke_path_append.appendPath)(context.config.sourceRoot || context.config.projectRoot, context.workspaceConfig.workspaceRoot);
+}
+/**
+* Finds the command name from the given file path.
+*
+* @param file - The file path to extract the command name from.
+* @returns The command name.
+*/
+function findCommandName(file) {
+	let name = (0, __stryke_path_file_path_fns.findFolderName)(file);
+	let count = 1;
+	while (name.startsWith("[") && name.endsWith("]")) name = (0, __stryke_path_file_path_fns.findFolderName)((0, __stryke_path_resolve_parent_path.resolveParentPath)(file, count++));
+	return name;
+}
+async function reflectCommandTree(context, command, parent) {
+	const title = command.title || `${parent?.title ? `${parent.title} - ` : ""}${(0, __stryke_string_format_title_case.titleCase)(command.name)}`;
+	const commandTree = {
+		...command,
+		title,
+		description: command.description || `The ${title} ${parent ? "sub-" : ""}command.`,
+		options: {},
+		params: [],
+		parent: parent ?? null,
+		children: {}
+	};
+	if (context.config.defaultOptions === false) commandTree.options = {};
+	else if (Array.isArray(context.config.defaultOptions)) commandTree.options = Object.fromEntries((0, __stryke_helpers_get_unique.getUniqueBy)(context.config.defaultOptions, (item) => item.name).map((option) => [option.name, option]));
+	else if ((0, __stryke_type_checks_is_function.isFunction)(context.config.defaultOptions)) commandTree.options = Object.fromEntries((0, __stryke_helpers_get_unique.getUniqueBy)(context.config.defaultOptions(context, command), (item) => item.name).map((option) => [option.name, option]));
+	if (command.isVirtual) context.trace(`Adding reflection for virtual command: ${command.id}`);
+	else {
+		if (!command.entry.input?.file || !context.fs.existsSync(command.entry.input.file)) throw new Error(`${!command.entry.input?.file ? "Missing" : "Non-existent"} command entry file for "${command.name}"`);
+		context.trace(`Adding reflection for user-defined command: ${command.id} (file: ${command.entry.input.file})`);
+		const type = await (0, __powerlines_deepkit_reflect_type.reflectType)(context, command.entry.input);
+		if (type.kind !== __powerlines_deepkit_vendor_type.ReflectionKind.function) throw new Error(`The command entry file "${command.entry.input.file}" does not export a valid function.`);
+		if (type.parameters.length > 0 && type.parameters[0]) {
+			const firstParam = type.parameters[0];
+			if (firstParam.type.kind === __powerlines_deepkit_vendor_type.ReflectionKind.objectLiteral || firstParam.type.kind === __powerlines_deepkit_vendor_type.ReflectionKind.class) {
+				const optionsReflection = __powerlines_deepkit_vendor_type.ReflectionClass.from(firstParam.type);
+				for (const propertyReflection of optionsReflection.getProperties()) {
+					const propertyType = propertyReflection.getType();
+					commandTree.options[propertyReflection.getNameAsString()] = {
+						name: propertyReflection.getNameAsString(),
+						alias: propertyReflection.getTags().alias ?? [],
+						title: propertyReflection.getTags().title || (0, __stryke_string_format_title_case.titleCase)(propertyReflection.getNameAsString()),
+						description: propertyReflection.getDescription(),
+						kind: propertyType.kind,
+						optional: propertyReflection.isOptional(),
+						default: propertyReflection.getDefaultValue(),
+						variadic: false
+					};
+					commandTree.options[propertyReflection.getNameAsString()].description ??= `The ${commandTree.options[propertyReflection.getNameAsString()].title} option.`;
+					if (propertyType.kind === __powerlines_deepkit_vendor_type.ReflectionKind.array) if (propertyType.type.kind === __powerlines_deepkit_vendor_type.ReflectionKind.string || propertyType.type.kind === __powerlines_deepkit_vendor_type.ReflectionKind.number) {
+						commandTree.options[propertyReflection.getNameAsString()].variadic = true;
+						commandTree.options[propertyReflection.getNameAsString()].kind = propertyType.type.kind;
+					} else throw new Error(`Unsupported array type for option "${propertyReflection.getNameAsString()}" in command "${command.name}". Only string[] and number[] are supported.`);
+					else if (propertyType.kind !== __powerlines_deepkit_vendor_type.ReflectionKind.boolean && propertyType.kind !== __powerlines_deepkit_vendor_type.ReflectionKind.string && propertyType.kind !== __powerlines_deepkit_vendor_type.ReflectionKind.number) throw new Error(`Unsupported type for option "${propertyReflection.getNameAsString()}" in command "${command.name}". Only string, number, boolean, string[] and number[] are supported, received ${(0, __powerlines_deepkit_vendor_type.stringifyType)(propertyType).trim().replaceAll(" | ", ", or ")}.`);
+				}
+			}
+		}
+	}
+	for (const input of context.inputs.filter((input$1) => input$1.path.length === command.path.length + 1 && input$1.path.slice(0, command.path.length).every((value, index) => value === command.path[index]))) commandTree.children[input.name] = await reflectCommandTree(context, input, commandTree);
+	return commandTree;
+}
+
+//#endregion
+exports.findCommandName = findCommandName;
+exports.findCommandsRoot = findCommandsRoot;
+exports.reflectCommandTree = reflectCommandTree;
+exports.resolveCommandPath = resolveCommandPath;