@reliverse/rempts 1.7.12 → 1.7.14

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,9 +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 = [];
@@ -524,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}`
       );
     }
@@ -543,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}`
     );
   }
@@ -555,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}`
     );
   }
@@ -964,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(cmdPath: string): Promise<Command>;

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

@@ -0,0 +1,50 @@
+import { resolve } from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import { createJiti } from "jiti";
+const jiti = createJiti(import.meta.url, {
+  debug: process.env.NODE_ENV === "development",
+  fsCache: true,
+  sourceMaps: true
+});
+export async function loadCommand(cmdPath) {
+  try {
+    const resolvedPath = cmdPath.startsWith("./") || cmdPath.startsWith("../") ? resolve(process.cwd(), cmdPath) : cmdPath;
+    if (!resolvedPath.endsWith("cmd.ts") && !resolvedPath.endsWith("cmd.js")) {
+      const possiblePaths = [
+        resolve(resolvedPath, "cmd.ts"),
+        resolve(resolvedPath, "cmd.js")
+      ];
+      for (const path of possiblePaths) {
+        if (await fs.pathExists(path)) {
+          relinka("verbose", `Loading command from: ${path}`);
+          const cmd2 = await jiti.import(path, { default: true });
+          relinka("verbose", `Successfully loaded command from: ${path}`);
+          return cmd2;
+        }
+      }
+      throw new Error(
+        `No command file found in ${resolvedPath}. Expected to find either:
+  - ${possiblePaths[0]}
+  - ${possiblePaths[1]}
+Please ensure one of these files exists and exports a default command.`
+      );
+    }
+    relinka("verbose", `Loading command from: ${resolvedPath}`);
+    const cmd = await jiti.import(resolvedPath, { default: true });
+    relinka("verbose", `Successfully loaded command from: ${resolvedPath}`);
+    return cmd;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("No command file found")) {
+      throw error;
+    }
+    relinka("error", `Failed to load command from ${cmdPath}:`, error);
+    throw new Error(
+      `Failed to load command from ${cmdPath}:
+  - Make sure the file exists and is accessible
+  - Ensure the file exports a default command
+  - Check that the file is a valid TypeScript/JavaScript module
+Original error: ${error instanceof Error ? error.message : String(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,

package/package.json

@@ -1,21 +1,22 @@
 {
   "dependencies": {
     "@figliolia/chalk-animation": "^1.0.4",
+    "@reliverse/pathkit": "^1.2.1",
     "@reliverse/reliarg": "^1.0.3",
     "@reliverse/relico": "^1.1.2",
-    "@reliverse/relinka": "^1.4.5",
+    "@reliverse/relinka": "^1.4.7",
     "@reliverse/runtime": "^1.0.3",
     "ansi-escapes": "^7.0.0",
-    "c12": "^3.0.3",
+    "c12": "^3.0.4",
     "cli-spinners": "^3.2.0",
     "detect-package-manager": "^3.0.2",
     "figlet": "^1.8.1",
     "fs-extra": "^11.3.0",
     "gradient-string": "^3.0.0",
+    "jiti": "^2.4.2",
     "log-update": "^6.1.0",
     "node-emoji": "^2.2.0",
     "ora": "^8.2.0",
-    "pathe": "^2.0.3",
     "pkg-types": "^2.1.0",
     "sisteransi": "^1.0.5",
     "terminal-kit": "^3.1.2",
@@ -28,7 +29,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.12",
+  "version": "1.7.14",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",
@@ -41,28 +42,7 @@
     "type": "git",
     "url": "git+https://github.com/reliverse/rempts.git"
   },
-  "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@eslint/js": "^9.26.0",
-    "@reliverse/dler": "^1.2.5",
-    "@reliverse/relidler-cfg": "^1.1.3",
-    "@stylistic/eslint-plugin": "^4.2.0",
-    "@total-typescript/ts-reset": "^0.6.1",
-    "@types/bun": "^1.2.13",
-    "@types/figlet": "^1.7.0",
-    "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.15.18",
-    "@types/terminal-kit": "^2.5.7",
-    "@types/wrap-ansi": "^8.1.0",
-    "eslint": "^9.26.0",
-    "eslint-plugin-no-relative-import-paths": "^1.6.1",
-    "eslint-plugin-perfectionist": "^4.13.0",
-    "jiti": "^2.4.2",
-    "knip": "^5.56.0",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.32.1",
-    "vitest": "^3.1.3"
-  },
+  "devDependencies": {},
   "exports": {
     ".": "./bin/mod.js"
   },
@@ -77,4 +57,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/bin/components/launcher/deprecated/_parser.ts.txt

@@ -1,167 +0,0 @@
-import type {
-  Default,
-  ParserArgv,
-  ParserOptions,
-} from "~/types.js";
-
-function toArr(any: any) {
-  // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-  return any == undefined ? [] : Array.isArray(any) ? any : [any];
-}
-
-function toVal(out, key, val, opts) {
-  let x;
-  const old = out[key];
-  const nxt = ~opts.string.indexOf(key)
-    ? // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-      val == undefined || val === true
-      ? ""
-      : String(val)
-    : typeof val === "boolean"
-      ? val
-      : ~opts.boolean.indexOf(key)
-        ? val === "false"
-          ? false
-          : val === "true" ||
-            // biome-ignore lint/style/noCommaOperator: <explanation>
-            (out._.push(((x = +val), x * 0 === 0) ? x : val), !!val)
-        : // biome-ignore lint/style/noCommaOperator: <explanation>
-          ((x = +val), x * 0 === 0)
-          ? x
-          : val;
-  out[key] =
-    // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-    old == undefined ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
-}
-
-export function parseRawArgs<T = Default>(
-  args: string[] = [],
-  opts: ParserOptions = {},
-): ParserArgv<T> {
-  let k;
-  let arr;
-  let arg;
-  let name;
-  let val;
-  const out = { _: [] };
-  let i = 0;
-  let j = 0;
-  let idx = 0;
-  const len = args.length;
-
-  const alibi = opts.alias !== void 0;
-  const strict = opts.unknown !== void 0;
-  const defaults = opts.default !== void 0;
-
-  opts.alias = opts.alias || {};
-  opts.string = toArr(opts.string);
-  opts.boolean = toArr(opts.boolean);
-
-  if (alibi) {
-    for (k in opts.alias) {
-      arr = opts.alias[k] = toArr(opts.alias[k]);
-      for (i = 0; i < arr.length; i++) {
-        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
-      }
-    }
-  }
-
-  for (i = opts.boolean.length; i-- > 0; ) {
-    arr = opts.alias[opts.boolean[i]] || [];
-    for (j = arr.length; j-- > 0; ) {
-      opts.boolean.push(arr[j]);
-    }
-  }
-
-  for (i = opts.string.length; i-- > 0; ) {
-    arr = opts.alias[opts.string[i]] || [];
-    for (j = arr.length; j-- > 0; ) {
-      opts.string.push(arr[j]);
-    }
-  }
-
-  if (defaults) {
-    for (k in opts.default) {
-      name = typeof opts.default[k];
-      arr = opts.alias[k] = opts.alias[k] || [];
-      if (opts[name] !== void 0) {
-        opts[name].push(k);
-        for (i = 0; i < arr.length; i++) {
-          opts[name].push(arr[i]);
-        }
-      }
-    }
-  }
-
-  const keys = strict ? Object.keys(opts.alias) : [];
-
-  for (i = 0; i < len; i++) {
-    arg = args[i];
-
-    if (arg === "--") {
-      out._ = out._.concat(args.slice(++i));
-      break;
-    }
-
-    for (j = 0; j < arg.length; j++) {
-      if (arg.charCodeAt(j) !== 45) {
-        break;
-      } // "-"
-    }
-
-    if (j === 0) {
-      out._.push(arg);
-    } else if (arg.substring(j, j + 3) === "no-") {
-      name = arg.slice(Math.max(0, j + 3));
-      if (strict && !~keys.indexOf(name)) {
-        // @ts-expect-error TODO: fix ts
-        return opts.unknown(arg);
-      }
-      out[name] = false;
-    } else {
-      for (idx = j + 1; idx < arg.length; idx++) {
-        if (arg.charCodeAt(idx) === 61) {
-          break;
-        } // "="
-      }
-
-      name = arg.substring(j, idx);
-      val =
-        arg.slice(Math.max(0, ++idx)) ||
-        i + 1 === len ||
-        // biome-ignore lint/style/useTemplate: <explanation>
-        ("" + args[i + 1]).charCodeAt(0) === 45 ||
-        args[++i];
-      arr = j === 2 ? [name] : name;
-
-      for (idx = 0; idx < arr.length; idx++) {
-        name = arr[idx];
-        if (strict && !~keys.indexOf(name)) {
-          // @ts-expect-error TODO: fix ts
-          return opts.unknown("-".repeat(j) + name);
-        }
-        toVal(out, name, idx + 1 < arr.length || val, opts);
-      }
-    }
-  }
-
-  if (defaults) {
-    for (k in opts.default) {
-      if (out[k] === void 0) {
-        out[k] = opts.default[k];
-      }
-    }
-  }
-
-  if (alibi) {
-    for (k in out) {
-      arr = opts.alias[k] || [];
-      while (arr.length > 0) {
-        out[arr.shift()] = out[k];
-      }
-    }
-  }
-
-  // @ts-expect-error TODO: fix ts
-  return out;
-}

package/bin/components/launcher/deprecated/_utils.ts.txt

@@ -1,41 +0,0 @@
-import type { Resolvable } from "~/types.js";
-
-export function toArray(val: any) {
-  if (Array.isArray(val)) {
-    return val;
-  }
-  return val === undefined ? [] : [val];
-}
-
-export function formatLineColumns(lines: string[][], linePrefix = "") {
-  const maxLength: number[] = [];
-  for (const line of lines) {
-    for (const [i, element] of line.entries()) {
-      maxLength[i] = Math.max(maxLength[i] || 0, element.length);
-    }
-  }
-  return lines
-    .map((l) =>
-      l
-        .map(
-          (c, i) =>
-            linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i]),
-        )
-        .join("  "),
-    )
-    .join("\n");
-}
-
-export function resolveValue<T>(input: Resolvable<T>): T | Promise<T> {
-  return typeof input === "function" ? (input as any)() : input;
-}
-
-export class CLIError extends Error {
-  constructor(
-    message: string,
-    public code?: string,
-  ) {
-    super(message);
-    this.name = "CLIError";
-  }
-}

package/bin/components/launcher/deprecated/args.ts.txt

@@ -1,108 +0,0 @@
-import { kebabCase, camelCase } from "scule";
-
-import type { Arg, ArgsDef, ParsedArgs } from "~/types.js";
-
-import { parseRawArgs } from "./_parser.js";
-import { CLIError, toArray } from "./_utils.js";
-
-export function parseArgs<T extends ArgsDef = ArgsDef>(
-  rawArgs: string[],
-  argsDef: ArgsDef,
-): ParsedArgs<T> {
-  const parseOptions = {
-    boolean: [] as string[],
-    string: [] as string[],
-    number: [] as string[],
-    enum: [] as (number | string)[],
-    mixed: [] as string[],
-    alias: {} as Record<string, string | string[]>,
-    default: {} as Record<string, boolean | number | string>,
-  };
-
-  const args = resolveArgs(argsDef);
-
-  for (const arg of args) {
-    if (arg.type === "positional") {
-      continue;
-    }
-    if (arg.type === "string" || arg.type === "number") {
-      parseOptions.string.push(arg.name);
-    } else if (arg.type === "boolean") {
-      parseOptions.boolean.push(arg.name);
-    } else if (arg.type === "enum") {
-      parseOptions.enum.push(...(arg.options || []));
-    }
-
-    if (arg.default !== undefined) {
-      parseOptions.default[arg.name] = arg.default;
-    }
-    if (arg.alias) {
-      parseOptions.alias[arg.name] = arg.alias;
-    }
-  }
-
-  const parsed = parseRawArgs(rawArgs, parseOptions);
-  const [...positionalArguments] = parsed._;
-
-  const parsedArgsProxy = new Proxy(parsed, {
-    get(target: ParsedArgs<any>, prop: string) {
-      return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
-    },
-  });
-
-  for (const [, arg] of args.entries()) {
-    if (arg.type === "positional") {
-      const nextPositionalArgument = positionalArguments.shift();
-      if (nextPositionalArgument !== undefined) {
-        parsedArgsProxy[arg.name] = nextPositionalArgument;
-      } else if (arg.default === undefined && arg.required !== false) {
-        throw new CLIError(
-          `Missing required positional argument: ${arg.name.toUpperCase()}`,
-          "EARG",
-        );
-      } else {
-        parsedArgsProxy[arg.name] = arg.default;
-      }
-    } else if (arg.type === "enum") {
-      const argument = parsedArgsProxy[arg.name];
-      const options = arg.options || [];
-      if (
-        argument !== undefined &&
-        options.length > 0 &&
-        !options.includes(argument)
-      ) {
-        throw new CLIError(
-          `Invalid value for argument: \`--${arg.name}\` (\`${argument}\`). Expected one of: ${options.map((o) => `\`${o}\``).join(", ")}.`,
-          "EARG",
-        );
-      }
-    } else if (arg.type === "number") {
-      const _originalValue = parsedArgsProxy[arg.name];
-      parsedArgsProxy[arg.name] = Number.parseFloat(
-        parsedArgsProxy[arg.name] as string,
-      );
-      if (Number.isNaN(parsedArgsProxy[arg.name])) {
-        throw new CLIError(
-          `Invalid value for argument: \`--${arg.name}\` (\`${_originalValue}\`). Expected a number.`,
-          "EARG",
-        );
-      }
-    } else if (arg.required && parsedArgsProxy[arg.name] === undefined) {
-      throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
-    }
-  }
-
-  return parsedArgsProxy as ParsedArgs<T>;
-}
-
-export function resolveArgs(argsDef: ArgsDef): Arg[] {
-  const args: Arg[] = [];
-  for (const [name, argDef] of Object.entries(argsDef || {})) {
-    args.push({
-      ...argDef,
-      name,
-      alias: toArray((argDef as any).alias),
-    });
-  }
-  return args;
-}

package/bin/components/launcher/deprecated/command.ts.txt

@@ -1,95 +0,0 @@
-import type {
-  ArgsDef,
-  CommandContext,
-  CommandDef,
-  RunCommandOptions,
-} from "~/types.js";
-
-import { CLIError, resolveValue } from "./_utils.js";
-import { parseArgs } from "./args.js";
-
-export function defineCommand<const T extends ArgsDef = ArgsDef>(
-  def: CommandDef<T>,
-): CommandDef<T> {
-  return def;
-}
-
-export async function runCommand<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  opts: RunCommandOptions,
-): Promise<{ result: unknown }> {
-  const cmdArgs = await resolveValue(cmd.args || {});
-  const parsedArgs = parseArgs<T>(opts.rawArgs, cmdArgs);
-
-  const context: CommandContext<T> = {
-    rawArgs: opts.rawArgs,
-    args: parsedArgs,
-    data: opts.data,
-    cmd,
-  };
-
-  // Setup hook
-  if (typeof cmd.setup === "function") {
-    await cmd.setup(context);
-  }
-
-  // Handle sub command
-  let result: unknown;
-  try {
-    const subCommands = await resolveValue(cmd.subCommands);
-    if (subCommands && Object.keys(subCommands).length > 0) {
-      const subCommandArgIndex = opts.rawArgs.findIndex(
-        (arg) => !arg.startsWith("-"),
-      );
-      const subCommandName = opts.rawArgs[subCommandArgIndex];
-      if (subCommandName) {
-        if (!subCommands[subCommandName]) {
-          throw new CLIError(
-            `Unknown command \`${subCommandName}\``,
-            "E_UNKNOWN_COMMAND",
-          );
-        }
-        const subCommand = await resolveValue(subCommands[subCommandName]);
-        if (subCommand) {
-          await runCommand(subCommand, {
-            rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1),
-          });
-        }
-      } else if (!cmd.run) {
-        // biome-ignore lint/style/noUnusedTemplateLiteral: <explanation>
-        throw new CLIError(`No command specified.`, "E_NO_COMMAND");
-      }
-    }
-
-    // Handle main command
-    if (typeof cmd.run === "function") {
-      result = await cmd.run(context);
-    }
-  } finally {
-    if (typeof cmd.cleanup === "function") {
-      await cmd.cleanup(context);
-    }
-  }
-  return { result };
-}
-
-export async function resolveSubCommand<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  rawArgs: string[],
-  parent?: CommandDef<T>,
-): Promise<[CommandDef<T>, CommandDef<T>?]> {
-  const subCommands = await resolveValue(cmd.subCommands);
-  if (subCommands && Object.keys(subCommands).length > 0) {
-    const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
-    const subCommandName = rawArgs[subCommandArgIndex];
-    const subCommand = await resolveValue(subCommands[subCommandName]);
-    if (subCommand) {
-      return resolveSubCommand(
-        subCommand,
-        rawArgs.slice(subCommandArgIndex + 1),
-        cmd,
-      );
-    }
-  }
-  return [cmd, parent];
-}

package/bin/components/launcher/deprecated/launcher-mod.ts.txt

@@ -1,50 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-
-import type { ArgsDef, CommandDef } from "~/types.js";
-
-import { CLIError } from "./_utils.js";
-import { resolveSubCommand, runCommand } from "./command.js";
-import { showUsage as _showUsage } from "./usage.js";
-
-export type RunMainOptions = {
-  rawArgs?: string[];
-  showUsage?: typeof _showUsage;
-};
-
-export async function runMain<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  opts: RunMainOptions = {},
-) {
-  const rawArgs = opts.rawArgs || process.argv.slice(2);
-  const showUsage = opts.showUsage || _showUsage;
-  try {
-    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-      await showUsage(...(await resolveSubCommand(cmd, rawArgs)));
-      process.exit(0);
-    } else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
-      const meta =
-        typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
-      if (!meta?.version) {
-        throw new CLIError("No version specified", "E_NO_VERSION");
-      }
-      relinka("log", meta.version);
-    } else {
-      await runCommand(cmd, { rawArgs });
-    }
-  } catch (error: any) {
-    const isCLIError = error instanceof CLIError;
-    if (isCLIError) {
-      await showUsage(...(await resolveSubCommand(cmd, rawArgs)));
-      relinka("error", error.message);
-    } else {
-      relinka("error", error, "\n");
-    }
-    process.exit(1);
-  }
-}
-
-export function createMain<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-): (opts?: RunMainOptions) => Promise<void> {
-  return (opts: RunMainOptions = {}) => runMain(cmd, opts);
-}

package/bin/components/launcher/deprecated/usage.ts.txt

@@ -1,157 +0,0 @@
-import { re } from "@reliverse/relico";
-import { relinka } from "@reliverse/relinka";
-
-import type { ArgsDef, CommandDef } from "~/types.js";
-
-import { formatLineColumns, resolveValue } from "./_utils.js";
-import { resolveArgs } from "./args.js";
-
-export async function showUsage<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  parent?: CommandDef<T>,
-) {
-  try {
-    // biome-ignore lint/style/useTemplate: <explanation>
-    relinka("log", (await renderUsage(cmd, parent)) + "\n");
-  } catch (error) {
-    relinka("error", String(error));
-  }
-}
-
-// `no` prefix matcher (kebab-case or camelCase)
-const negativePrefixRe = /^no[-A-Z]/;
-
-export async function renderUsage<T extends ArgsDef = ArgsDef>(
-  cmd: CommandDef<T>,
-  parent?: CommandDef<T>,
-) {
-  const cmdMeta = await resolveValue(cmd.meta || {});
-  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
-  const parentMeta = await resolveValue(parent?.meta || {});
-
-  const commandName =
-    (parentMeta.name ? `${parentMeta.name} ` : "") +
-    (cmdMeta.name || process.argv[1]);
-
-  const argLines: string[][] = [];
-  const posLines: string[][] = [];
-  const commandsLines: string[][] = [];
-  const usageLine = [];
-
-  for (const arg of cmdArgs) {
-    if (arg.type === "positional") {
-      const name = arg.name.toUpperCase();
-      const isRequired = arg.required !== false && arg.default === undefined;
-      // (isRequired ? " (required)" : " (optional)"
-      const defaultHint = arg.default ? `="${arg.default}"` : "";
-      posLines.push([
-        // biome-ignore lint/style/useTemplate: <explanation>
-        "`" + name + defaultHint + "`",
-        arg.description || "",
-        arg.valueHint ? `<${arg.valueHint}>` : "",
-      ]);
-      usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
-    } else {
-      const isRequired = arg.required === true && arg.default === undefined;
-      const argStr =
-        [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") +
-        (arg.type === "string" && (arg.valueHint || arg.default)
-          ? `=${
-              arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`
-            }`
-          : "") +
-        (arg.type === "enum" && arg.options
-          ? `=<${arg.options.join("|")}>`
-          : "");
-      argLines.push([
-        // biome-ignore lint/style/useTemplate: <explanation>
-        "`" + argStr + (isRequired ? " (required)" : "") + "`",
-        arg.description || "",
-      ]);
-
-      /**
-       * print negative boolean arg variant usage when
-       * - enabled by default or has `negativeDescription`
-       * - not prefixed with `no-` or `no[A-Z]`
-       */
-      if (
-        arg.type === "boolean" &&
-        (arg.default === true || arg.negativeDescription) &&
-        !negativePrefixRe.test(arg.name)
-      ) {
-        const negativeArgStr = [
-          ...(arg.alias || []).map((a) => `--no-${a}`),
-          `--no-${arg.name}`,
-        ].join(", ");
-        argLines.push([
-          // biome-ignore lint/style/useTemplate: <explanation>
-          "`" + negativeArgStr + (isRequired ? " (required)" : "") + "`",
-          arg.negativeDescription || "",
-        ]);
-      }
-
-      if (isRequired) {
-        usageLine.push(argStr);
-      }
-    }
-  }
-
-  if (cmd.subCommands) {
-    const commandNames: string[] = [];
-    const subCommands = await resolveValue(cmd.subCommands);
-    for (const [name, sub] of Object.entries(subCommands)) {
-      const subCmd = await resolveValue(sub);
-      const meta = await resolveValue(subCmd?.meta);
-      if (meta?.hidden) {
-        continue;
-      }
-      commandsLines.push([`\`${name}\``, meta?.description || ""]);
-      commandNames.push(name);
-    }
-    usageLine.push(commandNames.join("|"));
-  }
-
-  const usageLines: (string | undefined)[] = [];
-
-  const version = cmdMeta.version || parentMeta.version;
-
-  usageLines.push(
-    re.gray(
-      `${cmdMeta.description} (${
-        commandName + (version ? ` v${version}` : "")
-      })`,
-    ),
-    "",
-  );
-
-  const hasOptions = argLines.length > 0 || posLines.length > 0;
-  usageLines.push(
-    `${re.underline(re.bold("USAGE"))} \`${commandName}${
-      hasOptions ? " [OPTIONS]" : ""
-    } ${usageLine.join(" ")}\``,
-    "",
-  );
-
-  if (posLines.length > 0) {
-    usageLines.push(re.underline(re.bold("ARGUMENTS")), "");
-    usageLines.push(formatLineColumns(posLines, "  "));
-    usageLines.push("");
-  }
-
-  if (argLines.length > 0) {
-    usageLines.push(re.underline(re.bold("OPTIONS")), "");
-    usageLines.push(formatLineColumns(argLines, "  "));
-    usageLines.push("");
-  }
-
-  if (commandsLines.length > 0) {
-    usageLines.push(re.underline(re.bold("COMMANDS")), "");
-    usageLines.push(formatLineColumns(commandsLines, "  "));
-    usageLines.push(
-      "",
-      `Use \`${commandName} <command> --help\` for more information about a command.`,
-    );
-  }
-
-  return usageLines.filter((l) => typeof l === "string").join("\n");
-}