@reliverse/rempts 1.7.11 → 1.7.13

package/README.md

@@ -6,19 +6,20 @@
 
 ## Features
 
+- 😘 drop-in alternative to `citty` + built-in prompts
+- 📂 file-based commands (app-router style by default)
 - 🫂 rempts keeps you from fighting with your CLI tool
+- 🏎️ prompt engine that *feels* modern — and actually is
 - ✨ rempts is your end-to-end CLI UI + command framework
 - 🌿 multi-level file-based subcommands (sibling + nested)
 - 💪 built for DX precision and high-context terminal UX
-- 🏎️ prompt engine that *feels* modern — and actually is
-- 📂 file-based commands (app-router style by default)
 - 🎭 looks great in plain scripts or full CLI apps
-- 🧠 type-safe from args to prompts
-- ⚡ blazing-fast, zero runtime baggage
-- 🧩 router + argument parser built-in
 - 🎨 customizable themes and styled output
 - 📦 built-in output formatter and logger
 - 🚨 crash-safe (Ctrl+C, SIGINT, errors)
+- ⚡ blazing-fast, zero runtime baggage
+- 🧩 router + argument parser built-in
+- 🧠 type-safe from args to prompts
 - 📐 smart layout for small terminals
 - 🎛️ override styles via prompt options
 - 🪄 minimal API surface, maximum expressiveness

package/bin/components/editor/editor-mod.js

@@ -1,8 +1,8 @@
+import path from "@reliverse/pathkit";
 import { re } from "@reliverse/relico";
 import { relinka } from "@reliverse/relinka";
 import { loadConfig } from "c12";
 import fs from "fs-extra";
-import path from "pathe";
 import termkit from "terminal-kit";
 const { terminal: term } = termkit;
 let state = {

package/bin/components/launcher/launcher-mod.d.ts

@@ -1,140 +1,5 @@
 import type { ReliArgParserOptions } from "@reliverse/reliarg";
-type EmptyArgs = Record<string, never>;
-type BaseArgProps = {
-    description?: string;
-    required?: boolean;
-    allowed?: string[];
-};
-type PositionalArgDefinition = {
-    type: "positional";
-    default?: string;
-} & BaseArgProps;
-type BooleanArgDefinition = {
-    type: "boolean";
-    default?: boolean;
-    allowed?: boolean[];
-} & BaseArgProps;
-type StringArgDefinition = {
-    type: "string";
-    default?: string;
-} & BaseArgProps;
-type NumberArgDefinition = {
-    type: "number";
-    default?: number;
-    allowed?: number[];
-} & BaseArgProps;
-type ArrayArgDefinition = {
-    type: "array";
-    default?: string | readonly string[];
-} & BaseArgProps;
-export type ArgDefinition = PositionalArgDefinition | BooleanArgDefinition | StringArgDefinition | NumberArgDefinition | ArrayArgDefinition;
-export type ArgDefinitions = Record<string, ArgDefinition>;
-type CommandMeta = {
-    name: string;
-    version?: string;
-    description?: string;
-    hidden?: boolean;
-    aliases?: string[];
-};
-/**
- * A subcommand can be either:
- * 1) A string path to a module with a default export of type Command.
- * 2) A lazy import function returning a Promise that resolves to
- *    { default: Command<any> } or directly to a Command instance.
- */
-type CommandSpec = string | (() => Promise<{
-    default: Command<any>;
-} | Command<any>>);
-export type CommandsMap = Record<string, CommandSpec>;
-type CommandContext<ARGS> = {
-    args: ARGS;
-    raw: string[];
-};
-type CommandRun<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
-type CommandHook<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
-type DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> = {
-    meta?: CommandMeta;
-    args?: A;
-    run?: CommandRun<InferArgTypes<A>>;
-    /**
-     * Object subcommands for this command.
-     */
-    commands?: CommandsMap;
-    /**
-     * @deprecated Use `commands` instead. Will be removed in a future major version.
-     */
-    subCommands?: CommandsMap;
-    /**
-     * Called before the command runs. Receives `{ args, raw }` (parsed args and raw argv).
-     */
-    onCmdInit?: CommandHook<InferArgTypes<A>>;
-    /**
-     * Called after the command finishes. Receives `{ args, raw }` (parsed args and raw argv).
-     */
-    onCmdExit?: CommandHook<InferArgTypes<A>>;
-    /**
-     * @deprecated Use onCmdInit instead
-     */
-    setup?: CommandHook<InferArgTypes<A>>;
-    /**
-     * @deprecated Use onCmdExit instead
-     */
-    cleanup?: CommandHook<InferArgTypes<A>>;
-    /**
-     * Called once per CLI process, before any command/run() is executed
-     */
-    onLauncherInit?: () => void | Promise<void>;
-    /**
-     * Called once per CLI process, after all command/run() logic is finished
-     */
-    onLauncherExit?: () => void | Promise<void>;
-};
-export type Command<A extends ArgDefinitions = EmptyArgs> = {
-    meta?: CommandMeta;
-    args: A;
-    run?: CommandRun<InferArgTypes<A>>;
-    /**
-     * Object subcommands for this command.
-     */
-    commands?: CommandsMap;
-    /**
-     * @deprecated Use `commands` instead. Will be removed in a future major version.
-     */
-    subCommands?: CommandsMap;
-    /**
-     * Called before the command runs. Receives `{ args, raw }` (parsed args and raw argv).
-     */
-    onCmdInit?: CommandHook<InferArgTypes<A>>;
-    /**
-     * Called after the command finishes. Receives `{ args, raw }` (parsed args and raw argv).
-     */
-    onCmdExit?: CommandHook<InferArgTypes<A>>;
-    /**
-     * @deprecated Use onCmdInit instead
-     */
-    setup?: CommandHook<InferArgTypes<A>>;
-    /**
-     * @deprecated Use onCmdExit instead
-     */
-    cleanup?: CommandHook<InferArgTypes<A>>;
-    /**
-     * Called once per CLI process, before any command/run() is executed
-     */
-    onLauncherInit?: () => void | Promise<void>;
-    /**
-     * Called once per CLI process, after all command/run() logic is finished
-     */
-    onLauncherExit?: () => void | Promise<void>;
-};
-export type InferArgTypes<A extends ArgDefinitions> = {
-    [K in keyof A]: A[K] extends PositionalArgDefinition ? string : A[K] extends BooleanArgDefinition ? boolean : A[K] extends StringArgDefinition ? string : A[K] extends NumberArgDefinition ? number : A[K] extends {
-        type: "array";
-    } ? string[] : never;
-};
-export type FileBasedCmdsOptions = {
-    enable: boolean;
-    cmdsRootPath: string;
-};
+import type { ArgDefinitions, Command, DefineCommandOptions, EmptyArgs, FileBasedCmdsOptions } from "./launcher-types.js";
 /**
  * Defines a command with metadata, argument definitions,
  * an execution function, and (optional) subCommands.
@@ -185,4 +50,3 @@ export declare function defineArgs<A extends ArgDefinitions>(args: A): A;
  * @param parserOptions Optional reliArgParser options
  */
 export declare function runCmd<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, argv?: string[], parserOptions?: ReliArgParserOptions): Promise<void>;
-export {};

package/bin/components/launcher/launcher-mod.js

@@ -1,8 +1,9 @@
+import path from "@reliverse/pathkit";
 import { reliArgParser } from "@reliverse/reliarg";
+import { re } from "@reliverse/relico";
 import { relinka, relinkaConfig, relinkaShutdown } from "@reliverse/relinka";
 import fs from "fs-extra";
 import process from "node:process";
-import path from "pathe";
 import { readPackageJSON } from "pkg-types";
 function buildExampleArgs(args) {
   const parts = [];
@@ -101,29 +102,49 @@ async function getDefaultCliNameAndVersion() {
     return { name: "cli", version: void 0 };
   }
 }
-async function findDirectFileBasedSubcommands(currentDir) {
+async function findRecursiveFileBasedCommands(baseDir, currentPath = []) {
   const results = [];
-  const items = await fs.readdir(currentDir, { withFileTypes: true });
+  const items = await fs.readdir(path.join(baseDir, ...currentPath), {
+    withFileTypes: true
+  });
   for (const dirent of items) {
     if (dirent.isDirectory()) {
+      const newPath = [...currentPath, dirent.name];
       for (const fname of ["cmd.ts", "cmd.js"]) {
-        const fpath = path.join(currentDir, dirent.name, fname);
+        const fpath = path.join(baseDir, ...newPath, fname);
         if (await fs.pathExists(fpath)) {
           try {
             const imported = await import(path.resolve(fpath));
             if (imported.default && !imported.default.meta?.hidden) {
-              results.push({ name: dirent.name, def: imported.default });
+              results.push({
+                name: dirent.name,
+                def: imported.default,
+                path: newPath
+              });
             }
           } catch (err) {
-            debugLog(`Skipping file-based subcommand in ${fpath}:`, err);
+            debugLog(`Skipping file-based command in ${fpath}:`, err);
           }
           break;
         }
       }
+      const subResults = await findRecursiveFileBasedCommands(baseDir, newPath);
+      results.push(...subResults);
     }
   }
   return results;
 }
+function calculatePadding(items, minPad = 2) {
+  const maxLength = items.reduce(
+    (max, item) => Math.max(max, item.text.length),
+    0
+  );
+  return maxLength + minPad;
+}
+function formatTableRow(text, desc, padding) {
+  const spaces = " ".repeat(Math.max(0, padding - text.length));
+  return `${text}${spaces}| ${desc || ""}`;
+}
 export async function showUsage(command, parserOptions = {}) {
   const { name: fallbackName, version: fallbackVersion } = await getDefaultCliNameAndVersion();
   const cliName = command.meta?.name || fallbackName;
@@ -146,36 +167,64 @@ export async function showUsage(command, parserOptions = {}) {
   const fileCmds = parserOptions.fileBasedCmds;
   if (fileCmds?.enable) {
     const commandsDir = path.resolve(fileCmds.cmdsRootPath);
-    const currentDir = parserOptions._fileBasedCurrentDir || commandsDir;
     const pathSegments = parserOptions._fileBasedPathSegments || [];
     let usageLine = [pkgName, ...pathSegments].join(" ");
-    const directSubs = await findDirectFileBasedSubcommands(currentDir);
-    if (directSubs.length > 0) {
+    const allCommands = await findRecursiveFileBasedCommands(
+      commandsDir,
+      pathSegments
+    );
+    const directCommands = allCommands.filter(
+      (cmd) => cmd.path.length === pathSegments.length + 1
+    );
+    if (directCommands.length > 0) {
       usageLine += " <command> [command's options]";
     } else {
       usageLine += " [command's options]";
       const pos = renderPositional(command.args);
       if (pos) usageLine += ` ${pos}`;
     }
-    relinka("log", `Usage: ${usageLine}`);
-    if (directSubs.length > 0) {
-      const randomIdx = Math.floor(Math.random() * directSubs.length);
-      const { name: exampleCmd, def: exampleDef } = directSubs[randomIdx];
+    relinka("log", re.cyan(`Usage: ${usageLine}`));
+    if (directCommands.length > 0) {
+      const randomIdx = Math.floor(Math.random() * allCommands.length);
+      const { path: path2, def: exampleDef } = allCommands[randomIdx];
       const exampleArgs = buildExampleArgs(exampleDef.args || {});
       relinka(
         "log",
-        `Example: ${pkgName} ${[...pathSegments, exampleCmd].join(" ")}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        re.cyan(
+          `Example: ${pkgName} ${path2.join(" ")}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        )
       );
     }
-    if (directSubs.length > 0) {
+    if (allCommands.length > 0) {
       relinka("info", "Available commands (run with `help` to see more):");
-      directSubs.forEach(({ name, def }) => {
-        const desc = def?.meta?.description ?? "";
-        relinka(
-          "log",
-          `\u2022 ${[...pathSegments, name].join(" ")}${desc ? ` | ${desc}` : ""}`
-        );
-      });
+      const commandsByPath = /* @__PURE__ */ new Map();
+      for (const cmd of allCommands) {
+        const parentPath = cmd.path.slice(0, -1).join("/") || "/";
+        if (!commandsByPath.has(parentPath)) {
+          commandsByPath.set(parentPath, []);
+        }
+        commandsByPath.get(parentPath).push(cmd);
+      }
+      const groupPaddings = /* @__PURE__ */ new Map();
+      for (const [parentPath, cmds] of commandsByPath) {
+        const items = cmds.map(({ path: path2, def }) => ({
+          text: `${parentPath === "/" ? "" : "  "}\u2022 ${path2.join(" ")}`,
+          desc: def?.meta?.description
+        }));
+        groupPaddings.set(parentPath, calculatePadding(items));
+      }
+      for (const [parentPath, cmds] of commandsByPath) {
+        if (parentPath !== "/") {
+          relinka("log", re.cyanPastel(`Sub-commands in ${parentPath}:`));
+        }
+        const padding = groupPaddings.get(parentPath);
+        for (const { def, path: path2 } of cmds) {
+          const desc = def?.meta?.description ?? "";
+          const indent = parentPath === "/" ? "" : "  ";
+          const text = `${indent}\u2022 ${path2.join(" ")}`;
+          relinka("log", formatTableRow(text, desc, padding));
+        }
+      }
     }
   } else {
     const subCommandNames = [];
@@ -204,46 +253,57 @@ export async function showUsage(command, parserOptions = {}) {
     } else {
       usageLine += ` [command's options] ${renderPositional(command.args)}`;
     }
-    relinka("log", `Usage: ${usageLine}`);
+    relinka("log", re.cyan(`Usage: ${usageLine}`));
     if (subCommandDefs.length > 0) {
       const randomIdx = Math.floor(Math.random() * subCommandDefs.length);
       const { name: exampleCmd, def: exampleDef } = subCommandDefs[randomIdx];
       const exampleArgs = buildExampleArgs(exampleDef.args || {});
       relinka(
         "log",
-        `Example: ${pkgName}${parserOptions._isSubcommand ? ` ${cliName}` : ""} ${exampleCmd}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        re.cyan(
+          `Example: ${pkgName}${parserOptions._isSubcommand ? ` ${cliName}` : ""} ${exampleCmd}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        )
       );
     }
     if (subCommandNames.length > 0) {
       relinka("info", "Available commands (run with `help` to see more):");
-      subCommandDefs.forEach(({ name, def }) => {
-        const desc = def?.meta?.description ?? "";
-        relinka("log", `\u2022 ${name}${desc ? ` | ${desc}` : ""}`);
-      });
+      const commandItems = subCommandDefs.map(({ name, def }) => ({
+        text: `\u2022 ${name}`,
+        desc: def?.meta?.description
+      }));
+      const padding = calculatePadding(commandItems);
+      for (const { text, desc } of commandItems) {
+        relinka("log", formatTableRow(text, desc, padding));
+      }
     }
   }
   relinka("info", "Available options:");
-  relinka("log", "\u2022 -h, --help    | Show help");
-  relinka("log", "\u2022 -v, --version | Show version");
-  relinka("log", "\u2022 --debug       | Enable debug mode");
+  const optionItems = [
+    { text: "\u2022 -h, --help", desc: "Show help" },
+    { text: "\u2022 -v, --version", desc: "Show version" },
+    { text: "\u2022 --debug", desc: "Enable debug mode" }
+  ];
   for (const [key, def] of Object.entries(command.args || {})) {
     if (def.type === "positional") {
-      relinka(
-        "log",
-        `\u2022 <${key}>   | ${def.description ?? ""}${def.required ? " | required" : ""}`
-      );
+      optionItems.push({
+        text: `\u2022 <${key}>`,
+        desc: `${def.description ?? ""}${def.required ? " | required" : ""}`
+      });
     } else {
+      const text = `\u2022 --${key}${"alias" in def && def.alias ? `, -${def.alias}` : ""}`;
       const parts = [
-        `\u2022 --${key}${"alias" in def && def.alias ? `, -${def.alias}` : ""}`,
         def.description ?? "",
-        `type=${def.type}`
-      ];
-      if (def.default !== void 0)
-        parts.push(`default=${JSON.stringify(def.default)}`);
-      if (def.required) parts.push("required");
-      relinka("log", parts.filter(Boolean).join(" | "));
+        `type=${def.type}`,
+        def.default !== void 0 ? `default=${JSON.stringify(def.default)}` : null,
+        def.required ? "required" : null
+      ].filter(Boolean);
+      optionItems.push({ text, desc: parts.join(" | ") });
     }
   }
+  const optionsPadding = calculatePadding(optionItems);
+  for (const { text, desc } of optionItems) {
+    relinka("log", formatTableRow(text, desc, optionsPadding));
+  }
 }
 export async function runMain(command, parserOptions = {}) {
   if (typeof command.onLauncherInit === "function")
@@ -464,8 +524,8 @@ async function runFileBasedSubCmd(subName, argv, fileCmdOpts, parserOptions, par
         }
       }
       throw new Error(
-        `Unknown command or arguments: ${args.join(" ")}
-
+        `
+Unknown command or arguments: ${args.join(" ")}
 Info for this CLI's developer: No valid command file found in ${baseDir}`
       );
     }
@@ -483,8 +543,8 @@ Info for this CLI's developer: No valid command file found in ${baseDir}`
       }
     }
     throw new Error(
-      `Unknown command or arguments: ${args.join(" ")}
-
+      `
+Unknown command or arguments: ${args.join(" ")}
 Info for this CLI's developer: No valid command file found in ${baseDir}`
     );
   }
@@ -495,9 +555,23 @@ Info for this CLI's developer: No valid command file found in ${baseDir}`
       process.cwd(),
       path.join(fileCmdOpts.cmdsRootPath, subName, "cmd.{ts,js}")
     );
+    const allCommands = await findRecursiveFileBasedCommands(
+      fileCmdOpts.cmdsRootPath
+    );
+    const commandNames = allCommands.map((cmd) => cmd.path.join(" "));
+    let closestMatch = "";
+    let minDistance = Number.POSITIVE_INFINITY;
+    for (const cmd of commandNames) {
+      const distance = levenshteinDistance(subName, cmd.split(" ")[0]);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestMatch = cmd;
+      }
+    }
+    const suggestion = minDistance <= 3 ? ` (Did you mean: \`${closestMatch}\`?)` : "";
     throw new Error(
-      `Unknown command or arguments: ${attempted}
-
+      `
+Unknown command or arguments: ${attempted}${suggestion}
 Info for this CLI's developer: No valid command directory found, expected: ${expectedPath}`
     );
   }
@@ -904,3 +978,31 @@ async function resolveFileBasedCommandPath(cmdsRoot, argv) {
   }
   return null;
 }
+function levenshteinDistance(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}

package/bin/components/launcher/launcher-types.d.ts

@@ -0,0 +1,136 @@
+export type EmptyArgs = Record<string, never>;
+export type BaseArgProps = {
+    description?: string;
+    required?: boolean;
+    allowed?: string[];
+};
+export type PositionalArgDefinition = {
+    type: "positional";
+    default?: string;
+} & BaseArgProps;
+export type BooleanArgDefinition = {
+    type: "boolean";
+    default?: boolean;
+    allowed?: boolean[];
+} & BaseArgProps;
+export type StringArgDefinition = {
+    type: "string";
+    default?: string;
+} & BaseArgProps;
+export type NumberArgDefinition = {
+    type: "number";
+    default?: number;
+    allowed?: number[];
+} & BaseArgProps;
+export type ArrayArgDefinition = {
+    type: "array";
+    default?: string | readonly string[];
+} & BaseArgProps;
+export type ArgDefinition = PositionalArgDefinition | BooleanArgDefinition | StringArgDefinition | NumberArgDefinition | ArrayArgDefinition;
+export type ArgDefinitions = Record<string, ArgDefinition>;
+export type CommandMeta = {
+    name: string;
+    version?: string;
+    description?: string;
+    hidden?: boolean;
+    aliases?: string[];
+};
+/**
+ * A subcommand can be either:
+ * 1) A string path to a module with a default export of type Command.
+ * 2) A lazy import function returning a Promise that resolves to
+ *    { default: Command<any> } or directly to a Command instance.
+ */
+export type CommandSpec = string | (() => Promise<{
+    default: Command<any>;
+} | Command<any>>);
+export type CommandsMap = Record<string, CommandSpec>;
+export type CommandContext<ARGS> = {
+    args: ARGS;
+    raw: string[];
+};
+export type CommandRun<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
+export type CommandHook<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
+export type DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> = {
+    meta?: CommandMeta;
+    args?: A;
+    run?: CommandRun<InferArgTypes<A>>;
+    /**
+     * Object subcommands for this command.
+     */
+    commands?: CommandsMap;
+    /**
+     * @deprecated Use `commands` instead. Will be removed in a future major version.
+     */
+    subCommands?: CommandsMap;
+    /**
+     * Called before the command runs. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdInit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called after the command finishes. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdExit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdInit instead
+     */
+    setup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdExit instead
+     */
+    cleanup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called once per CLI process, before any command/run() is executed
+     */
+    onLauncherInit?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/run() logic is finished
+     */
+    onLauncherExit?: () => void | Promise<void>;
+};
+export type Command<A extends ArgDefinitions = EmptyArgs> = {
+    meta?: CommandMeta;
+    args: A;
+    run?: CommandRun<InferArgTypes<A>>;
+    /**
+     * Object subcommands for this command.
+     */
+    commands?: CommandsMap;
+    /**
+     * @deprecated Use `commands` instead. Will be removed in a future major version.
+     */
+    subCommands?: CommandsMap;
+    /**
+     * Called before the command runs. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdInit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called after the command finishes. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdExit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdInit instead
+     */
+    setup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdExit instead
+     */
+    cleanup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called once per CLI process, before any command/run() is executed
+     */
+    onLauncherInit?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/run() logic is finished
+     */
+    onLauncherExit?: () => void | Promise<void>;
+};
+export type InferArgTypes<A extends ArgDefinitions> = {
+    [K in keyof A]: A[K] extends PositionalArgDefinition ? string : A[K] extends BooleanArgDefinition ? boolean : A[K] extends StringArgDefinition ? string : A[K] extends NumberArgDefinition ? number : A[K] extends {
+        type: "array";
+    } ? string[] : never;
+};
+export type FileBasedCmdsOptions = {
+    enable: boolean;
+    cmdsRootPath: string;
+};

package/bin/components/launcher/run-command.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "./launcher-types.js";
+export declare function loadCommand(path: string): Promise<Command>;

package/bin/components/launcher/run-command.js

@@ -0,0 +1,18 @@
+import { relinka } from "@reliverse/relinka";
+import { createJiti } from "jiti";
+const jiti = createJiti(import.meta.url, {
+  debug: process.env.NODE_ENV === "development",
+  fsCache: true,
+  sourceMaps: true
+});
+export async function loadCommand(path) {
+  try {
+    relinka("verbose", `Loading command from: ${path}`);
+    const cmd = await jiti.import(path, { default: true });
+    relinka("verbose", `Successfully loaded command from: ${path}`);
+    return cmd;
+  } catch (error) {
+    relinka("error", `Failed to load command from ${path}:`, error);
+    throw error;
+  }
+}

package/bin/mod.d.ts

@@ -4,8 +4,9 @@ export { startEditor } from "./components/editor/editor-mod.js";
 export { mainSymbols, fallbackSymbols, } from "./components/figures/figures-mod.js";
 export { confirmPrompt } from "./components/input/confirm-prompt.js";
 export { inputPrompt } from "./components/input/input-prompt.js";
-export type { ArgDefinition, ArgDefinitions, CommandsMap, Command, InferArgTypes, FileBasedCmdsOptions, } from "./components/launcher/launcher-mod.js";
+export * from "./components/launcher/launcher-types.js";
 export { defineCommand, defineArgs, showUsage, runMain, runCmd, } from "./components/launcher/launcher-mod.js";
+export { loadCommand } from "./components/launcher/run-command.js";
 export { toBaseColor, toSolidColor } from "./components/msg-fmt/colors.js";
 export { relinkaByRemptsDeprecated, relinkaAsyncByRemptsDeprecated, throwError, } from "./components/msg-fmt/logger.js";
 export { colorMap, typographyMap } from "./components/msg-fmt/mapping.js";

package/bin/mod.js

@@ -7,6 +7,7 @@ export {
 } from "./components/figures/figures-mod.js";
 export { confirmPrompt } from "./components/input/confirm-prompt.js";
 export { inputPrompt } from "./components/input/input-prompt.js";
+export * from "./components/launcher/launcher-types.js";
 export {
   defineCommand,
   defineArgs,
@@ -14,6 +15,7 @@ export {
   runMain,
   runCmd
 } from "./components/launcher/launcher-mod.js";
+export { loadCommand } from "./components/launcher/run-command.js";
 export { toBaseColor, toSolidColor } from "./components/msg-fmt/colors.js";
 export {
   relinkaByRemptsDeprecated,