@reliverse/rempts 1.6.0 → 1.6.2

package/LICENSE

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) 2025 blefnk Nazar Kornienko
+Copyright (c) 2025 Nazar Kornienko (blefnk), Reliverse
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,7 +2,7 @@
 
 [💬 Discord](https://discord.gg/3GawfWfAPe) • [📦 NPM](https://npmjs.com/package/@reliverse/rempts) • [🧠 Docs](https://docs.reliverse.org/reliverse/rempts) • [🌐 JSR](https://jsr.io/@reliverse/rempts) • [✨ GitHub](https://github.com/reliverse/rempts)
 
-> @reliverse/rempts is a prompt library built for modern CLI devs. Fast. Type-safe. Unreasonably delightful.
+> @reliverse/rempts is a prompt library built with developer joy in mind. File-based commands. Flexible. Fast. Forget the clutter, it just works. This is a typesafe toolkit for building delightful CLI experiences.
 
 ## Stop Fighting Your CLI
 
@@ -12,6 +12,7 @@
 
 ## What Makes It Different?
 
+- 📂 File-based commands (optional)
 - 🧠 Type-safe from args to prompts
 - 🎨 Customizable themes, styled output
 - 🧩 Router + argument parser built-in
@@ -20,6 +21,7 @@
 - 🏎️ Prompt engine that *feels* modern, actually is
 - 🧪 Scriptable for testing, stable for production
 - 🚨 Crash-safe (Ctrl+C, SIGINT, errors)
+- 🆕 Automatic commands creation via `rempts init --cmd my-cool-cmd`
 
 ## Screenshot
 
@@ -371,12 +373,12 @@ await runMain(mainCommand, {
     v: "verbose", // Maps shorthand flag -v to --verbose.
   },
   strict: false, // Do not throw errors for unknown flags.
-  warnOnUnknown: true, // Warn when encountering unknown flags.
+  warnOnUnknown: false, // Warn when encountering unknown flags.
   negatedBoolean: true, // Support for negated booleans (e.g., --no-verbose).
-  unknown: (flagName) => {
-    relinka("warn", "Unknown flag encountered:", flagName);
-    return false;
-  },
+  // unknown: (flagName) => {
+  //   relinka("warn", "Unknown flag encountered:", flagName);
+  //   return false;
+  // },
 });
 ```
 
@@ -392,6 +394,10 @@ You're in the right place:
 
 > *No classes. No magic. Just clean, composable tools for CLI devs.*
 
+### Helpful Links
+
+- [CLI application with the Node.js Readline module](https://dev.to/camptocamp-geo/cli-application-with-the-nodejs-readline-module-48ic)
+
 ## Related
 
 - [`@reliverse/cli`](https://npmjs.com/package/@reliverse/cli) – CLI-first toolkit for fullstack workflows

package/bin/core-impl/launcher/launcher-mod.d.ts

@@ -31,8 +31,9 @@ type CommandMeta = {
 };
 /**
  * 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.
+ * 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 SubCommandSpec = string | (() => Promise<{
     default: Command<any>;
@@ -64,7 +65,7 @@ export type FileBasedCmdsOptions = {
 };
 /**
  * Defines a command with metadata, argument definitions,
- * an execution function, and subCommands.
+ * an execution function, and (optional) subCommands.
  */
 export declare function defineCommand<A extends ArgDefinitions = EmptyArgs>(options: DefineCommandOptions<A>): Command<A>;
 /**
@@ -75,10 +76,14 @@ export declare function showUsage<A extends ArgDefinitions>(command: Command<A>,
     autoExit?: boolean;
 }): Promise<void>;
 /**
- * Primary entry point to run a command, with support for subcommands or file-based commands.
+ * Primary entry point to run a command. This function supports:
  *
- * If the user does not provide any subCommands (or they are empty) AND no fileBasedCmds options,
- * then file-based command detection is automatically enabled with a default cmdsRootPath.
+ * - File-based Subcommands: scanning for subcommands within a given commands root.
+ * - SubCommands defined within the command object.
+ * - Standard flags like --help, --version, and --debug.
+ *
+ * This function passes along remaining arguments to subcommand runners to ensure
+ * consistent parsing.
  */
 export declare function runMain<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, parserOptions?: ReliArgParserOptions & {
     fileBasedCmds?: FileBasedCmdsOptions;

package/bin/core-impl/launcher/launcher-mod.js

@@ -1,5 +1,5 @@
 import { reliArgParser } from "@reliverse/reliarg";
-import { relinka } from "@reliverse/relinka";
+import { relinka, relinkaConfig, relinkaShutdown } from "@reliverse/relinka";
 import fs from "fs-extra";
 import process from "node:process";
 import path from "pathe";
@@ -9,6 +9,9 @@ function debugLog(...args) {
     relinka("info", "[DEBUG]", ...args);
   }
 }
+function isFlag(str) {
+  return str.startsWith("-");
+}
 export function defineCommand(options) {
   return {
     meta: options.meta,
@@ -18,7 +21,7 @@ export function defineCommand(options) {
   };
 }
 export async function showUsage(command, parserOptions = {}) {
-  relinka("info", `${command.meta.name} v${command.meta.version || ""}`);
+  relinka("info", `${command.meta.name} v${command.meta.version ?? ""}`);
   if (command.meta.description) {
     relinka("info", command.meta.description);
   }
@@ -28,7 +31,9 @@ export async function showUsage(command, parserOptions = {}) {
     relinka("info", usageLine);
     try {
       const commandsDir = path.resolve(fileCmds.cmdsRootPath);
-      const items = await fs.readdir(commandsDir, { withFileTypes: true });
+      const items = await fs.readdir(commandsDir, {
+        withFileTypes: true
+      });
       const subCommandNames = [];
       for (const dirent of items) {
         if (dirent.isDirectory() || dirent.isFile()) {
@@ -36,14 +41,14 @@ export async function showUsage(command, parserOptions = {}) {
           try {
             const importPath = path.join(
               commandsDir,
-              dirent.isDirectory() ? `${name}/index.js` : `${name}.js`
+              dirent.isDirectory() ? `${name}/index.ts` : `${name}.ts`
             );
             const imported = await import(path.resolve(importPath));
             if (imported.default && !imported.default.meta?.hidden) {
               subCommandNames.push(name);
             }
-          } catch (_err) {
-            debugLog(`Skipping file ${dirent.name}:`, _err);
+          } catch (err) {
+            debugLog(`Skipping file ${dirent.name}:`, err);
           }
         }
       }
@@ -51,13 +56,13 @@ export async function showUsage(command, parserOptions = {}) {
         relinka("info", "\nAvailable file-based subCommands:");
         subCommandNames.forEach((sc) => relinka("info", `  ${sc}`));
       }
-    } catch (_err) {
+    } catch (err) {
       relinka(
         "info",
         `
 (No file-based subcommands found in ${fileCmds.cmdsRootPath}.)`
       );
-      debugLog("Error reading file-based commands:", _err);
+      debugLog("Error reading file-based commands:", err);
     }
   } else {
     const subCommandNames = [];
@@ -69,8 +74,8 @@ export async function showUsage(command, parserOptions = {}) {
             const aliasDisplay = cmd.meta.aliases ? ` (aliases: ${cmd.meta.aliases.join(", ")})` : "";
             subCommandNames.push(`${name}${aliasDisplay}`);
           }
-        } catch (_err) {
-          debugLog(`Error loading subcommand ${name}:`, _err);
+        } catch (err) {
+          debugLog(`Error loading subcommand ${name}:`, err);
         }
       }
     }
@@ -94,12 +99,12 @@ export async function showUsage(command, parserOptions = {}) {
     if (def.type === "positional") {
       relinka(
         "info",
-        `  <${key}> : ${def.description || ""} ${def.required ? "(required)" : ""}`
+        `  <${key}> : ${def.description ?? ""} ${def.required ? "(required)" : ""}`
       );
     } else {
       relinka(
         "info",
-        `  --${key} : ${def.description || ""} (type=${def.type})${def.required ? " (required)" : ""}${def.default !== void 0 ? ` [default: ${def.default}]` : ""}`
+        `  --${key} : ${def.description ?? ""} (type=${def.type})${def.required ? " (required)" : ""}${def.default !== void 0 ? ` [default: ${def.default}]` : ""}`
       );
     }
   }
@@ -112,24 +117,26 @@ export async function runMain(command, parserOptions = {}) {
       // default path
     };
   }
-  const argv = process.argv.slice(2);
+  const rawArgv = process.argv.slice(2);
   const autoExit = parserOptions.autoExit !== false;
-  if (checkHelp(argv)) {
+  await relinkaConfig;
+  if (checkHelp(rawArgv)) {
     await showUsage(command, parserOptions);
     if (autoExit) process.exit(0);
     return;
   }
-  if (checkVersion(argv)) {
-    relinka("info", `${command.meta.name} v${command.meta.version || ""}`);
+  if (checkVersion(rawArgv)) {
+    relinka("info", `${command.meta.name} v${command.meta.version ?? ""}`);
     if (autoExit) process.exit(0);
     return;
   }
   const fileBasedEnabled = parserOptions.fileBasedCmds?.enable;
-  if (fileBasedEnabled && argv.length > 0) {
-    const subName = argv.shift();
+  if (fileBasedEnabled && rawArgv.length > 0 && !isFlag(rawArgv[0])) {
+    const [subName, ...subCmdArgv] = rawArgv;
     try {
       await runFileBasedSubCmd(
         subName,
+        subCmdArgv,
         parserOptions.fileBasedCmds,
         parserOptions
       );
@@ -141,8 +148,8 @@ export async function runMain(command, parserOptions = {}) {
       throw err;
     }
   }
-  if (!fileBasedEnabled && command.subCommands && argv.length > 0) {
-    const maybeSub = argv[0];
+  if (!fileBasedEnabled && command.subCommands && rawArgv.length > 0 && !isFlag(rawArgv[0])) {
+    const [maybeSub, ...subCmdArgv] = rawArgv;
     let subSpec;
     for (const [key, spec] of Object.entries(command.subCommands)) {
       if (key === maybeSub) {
@@ -155,14 +162,13 @@ export async function runMain(command, parserOptions = {}) {
           subSpec = spec;
           break;
         }
-      } catch (_err) {
-        debugLog(`Error checking alias for subcommand ${key}:`, _err);
+      } catch (err) {
+        debugLog(`Error checking alias for subcommand ${key}:`, err);
       }
     }
     if (subSpec) {
-      argv.shift();
       try {
-        await runSubCommand(subSpec, parserOptions);
+        await runSubCommand(subSpec, subCmdArgv, parserOptions);
         if (autoExit) process.exit(0);
         return;
       } catch (err) {
@@ -172,7 +178,8 @@ export async function runMain(command, parserOptions = {}) {
       }
     }
   }
-  await runCommandWithArgs(command, argv, parserOptions);
+  await runCommandWithArgs(command, rawArgv, parserOptions);
+  await relinkaShutdown();
 }
 function checkHelp(argv) {
   return argv.includes("--help") || argv.includes("-h");
@@ -197,14 +204,16 @@ async function loadSubCommand(spec) {
   }
   throw new Error("Subcommand import did not return a valid command");
 }
-async function runFileBasedSubCmd(subName, fileCmdOpts, parserOptions) {
+async function runFileBasedSubCmd(subName, argv, fileCmdOpts, parserOptions) {
   const subPathDir = path.join(fileCmdOpts.cmdsRootPath, subName);
   let importPath;
   const possibleFiles = [
+    // When command is inside a directory
     path.join(subPathDir, "index.js"),
     path.join(subPathDir, "index.ts"),
     path.join(subPathDir, `${subName}-mod.js`),
     path.join(subPathDir, `${subName}-mod.ts`),
+    // When command is a file in the root directory
     path.join(fileCmdOpts.cmdsRootPath, `${subName}.js`),
     path.join(fileCmdOpts.cmdsRootPath, `${subName}.ts`),
     path.join(fileCmdOpts.cmdsRootPath, `arg-${subName}.js`),
@@ -248,13 +257,11 @@ async function runFileBasedSubCmd(subName, fileCmdOpts, parserOptions) {
       `File-based subcommand "${subName}" has no default export or is invalid.`
     );
   }
-  const argvRemaining = process.argv.slice(2);
-  await runCommandWithArgs(subCommand, argvRemaining, parserOptions);
+  await runCommandWithArgs(subCommand, argv, parserOptions);
 }
-async function runSubCommand(spec, parserOptions) {
+async function runSubCommand(spec, argv, parserOptions) {
   const subCommand = await loadSubCommand(spec);
-  const argvRemaining = process.argv.slice(2);
-  await runCommandWithArgs(subCommand, argvRemaining, parserOptions);
+  await runCommandWithArgs(subCommand, argv, parserOptions);
 }
 async function runCommandWithArgs(command, argv, parserOptions) {
   const autoExit = parserOptions.autoExit !== false;

package/bin/core-impl/utils/errors.js

@@ -9,7 +9,7 @@ export const errorHandler = (error, customMessage) => {
   } else {
     relinka(
       "error",
-      "\u2502  If this issue is related to @reliverse/prompts itself, please\n\u2502  report the details at https://github.com/reliverse/prompts/issues"
+      "\u2502  If this issue is related to @reliverse/rempts itself, please\n\u2502  report the details at https://github.com/reliverse/rempts/issues"
     );
   }
   relinka("error", `\u2570${separator}`);

package/bin/core-impl/utils/system.js

@@ -1,7 +1,7 @@
 import { getUserPkgManager } from "@reliverse/runtime";
 export const pm = await getUserPkgManager();
 export const reliversePrompts = {
-  name: "@reliverse/prompts",
+  name: "@reliverse/rempts",
   version: "1.6.0",
-  description: "@reliverse/prompts is a powerful library that enables seamless, typesafe, and resilient prompts for command-line applications. Crafted with simplicity and elegance, it provides developers with an intuitive and robust way to build interactive CLIs."
+  description: "@reliverse/rempts is a powerful library that enables seamless, typesafe, and resilient prompts for command-line applications. Crafted with simplicity and elegance, it provides developers with an intuitive and robust way to build interactive CLIs."
 };

package/bin/core-types.d.ts

@@ -156,7 +156,7 @@ export type StreamTextOptions = {
      */
     color?: ColorName;
     /**
-     * Whether to add a newline at the end
+     * Whether to inject a newline at the end
      * @default true
      */
     newline?: boolean;

package/package.json

@@ -1,9 +1,9 @@
 {
-  "description": "@reliverse/prompts is your modern, type-safe toolkit for building delightful CLI experiences. It's fast, flexible, and built with developer joy in mind. Forget the clutter — this is how CLI should feel.",
+  "description": "@reliverse/rempts is a prompt library built with developer joy in mind. File-based commands. Flexible. Fast. Forget the clutter, it just works. This is a typesafe toolkit for building delightful CLI experiences.",
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",
@@ -19,15 +19,15 @@
   },
   "dependencies": {
     "@figliolia/chalk-animation": "^1.0.4",
-    "@reliverse/reliarg": "^1.0.2",
+    "@reliverse/reliarg": "^1.0.3",
     "@reliverse/relico": "^1.1.0",
-    "@reliverse/relinka": "^1.3.8",
+    "@reliverse/relinka": "^1.4.1",
     "@reliverse/runtime": "^1.0.3",
     "ansi-escapes": "^7.0.0",
     "c12": "^3.0.3",
     "cli-spinners": "^3.2.0",
     "detect-package-manager": "^3.0.2",
-    "figlet": "^1.8.0",
+    "figlet": "^1.8.1",
     "fs-extra": "^11.3.0",
     "gradient-string": "^3.0.0",
     "log-update": "^6.1.0",