@reliverse/rempts 1.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025 blefnk Nazar Kornienko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,408 @@
+# @reliverse/rempts
+
+[💬 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.
+
+## Stop Fighting Your CLI
+
+- CLIs are still the sharpest tool in the builder's belt. But most libraries are either clunky or crusty.
+- **@reliverse/rempts** is your end-to-end CLI UI + command framework — made for developer experience, DX precision, and high-context terminal UX.
+- No more hacking together `inquirer`, `citty`, `commander`, `chalk`, and other friends.
+
+## What Makes It Different?
+
+- 🧠 Type-safe from args to prompts
+- 🎨 Customizable themes, styled output
+- 🧩 Router + argument parser built-in
+- ⚡ Blazing-fast, no runtime baggage
+- 🪄 Minimal API surface, max expressiveness
+- 🏎️ Prompt engine that *feels* modern, actually is
+- 🧪 Scriptable for testing, stable for production
+- 🚨 Crash-safe (Ctrl+C, SIGINT, errors)
+
+## Screenshot
+
+![Rempts Example CLI Screenshot](./example.png)
+
+## CLI Launcher (Router)
+
+Finally, a full-featured CLI launcher without the ceremony. The launcher supports both programmatically defined subcommands and file-based routing, so you can structure your CLI however you like. It automatically detects and loads subcommands from your filesystem and provides robust usage and error handling out-of-the-box.
+
+**Key Features:**
+
+- **File-Based & Defined Subcommands:**  
+  Use `subCommands` in your command definition or let the launcher automatically load commands from a specified directory.
+
+- **Automatic Command Detection:**  
+  The launcher scans your specified `cmdsRootPath` for command files matching common patterns such as:
+  - `arg-cmdName.{ts,js}`
+  - `cmdName/index.{ts,js}`
+  - `cmdName/cmdName-mod.{ts,js}`
+  - And more — with automatic usage output if a command file is not found.
+
+- **Built-In Flag Handling:**  
+  Automatically processes global flags such as:
+  - `--help` and `-h` to show usage details.
+  - `--version` and `-v` to display version information.
+  - `--debug` for verbose logging during development.
+
+- **Unified Argument Parsing:**  
+  Seamlessly combines positional and named arguments with zero configuration, auto-parsing booleans, strings, numbers, arrays, and even supporting negated flags like `--no-flag`.
+
+- **Customizable Behavior:**  
+  Options such as `fileBasedCmds.enable`, `cmdsRootPath`, and `autoExit` allow you to tailor the launcher's behavior. For example, you can choose whether the process should exit automatically on error or allow manual error handling.
+
+- **Error Management & Usage Output:**  
+  The launcher provides clear error messages for missing required arguments, invalid types, or command import issues, and it automatically displays usage information for your CLI.
+
+**Usage Example:**
+
+```ts
+await runMain(myCommand, {
+  fileBasedCmds: {
+    enable: true,
+    cmdsRootPath: "./cli/args",
+  },
+  // Optionally disable auto-exit to handle errors manually:
+  autoExit: false,
+});
+```
+
+This flexibility allows you to easily build a rich, multi-command CLI with minimal boilerplate. The launcher even supports nested subcommands, making it simple to construct complex CLI applications.
+
+### File-Based Subcommands
+
+Drop a `./src/cli/args/add/index.ts` and it's live.
+
+```ts
+export default defineCommand({
+  meta: {
+    name: "add",
+    version: "1.0.0",
+    description: "Add stuff to your project",
+  },
+  args: {
+    name: {
+      type: "string",
+      required: true,
+      description: "Name of what to add",
+    },
+  },
+  async run({ args }) {
+    relinka("info", "Adding:", args.name);
+  },
+});
+```
+
+**Supports**:
+
+- `arg-cmdName.{ts,js}`,
+- `cmdName/index.{ts,js}`,
+- `cmdName/cmdName-mod.{ts,js}`,
+- And more — with automatic usage output.
+
+**Hint**:
+
+- Install `bun i -g @reliverse/rempts-cli`
+- Use `rempts init --cmd my-cmd-1 my-cmd-2` to init commands automatically
+
+## 📦 Built-In Prompts
+
+- 🧠 `inputPrompt` – Single-line, password, masked
+- ✅ `selectPrompt` – Radio menu
+- 🧰 `multiselectPrompt` – Checkbox menu
+- 🔢 `numberPrompt` – Type-safe number input
+- 🔄 `confirmPrompt` – Yes/No toggle
+- 🚥 `togglePrompt` – Custom on/off toggles
+- ⏳ `spinnerPrompt` – Async loaders with status
+- 📜 `logPrompt` – Styled logs / steps
+- 🧼 `clearPrompt` – Clears console with style
+
+## 🧱 Minimal, Functional API
+
+```ts
+defineCommand({
+  meta: { name: "cli", version: "1.0.0" },
+  args: {
+    name: { type: "string", required: true },
+    verbose: { type: "boolean", default: false },
+    animals: { type: "array", options: ["cat","dog"] },
+  },
+  async run({ args, raw }) { // or `async run(ctx)`
+    relinka("info", args.name, args.verbose, args.animals); // or `relinka("info", ctx.args.name, ...);`
+  },
+});
+```
+
+**Supports**:
+
+- `positional` args
+- `array` types (`--tag foo --tag bar`)
+- Default values, validations, descriptions
+- Full help rendering from metadata
+
+## Theming + Customization
+
+- Built-in output formatter and logger
+- Override styles via prompt options
+- Smart layout for small terminals
+- Looks great in plain scripts or full CLI apps
+
+## Playground
+
+```bash
+bun i -g @reliverse/rempts-cli
+rempts examples # supported options: name
+```
+
+OR:
+
+```bash
+git clone https://github.com/reliverse/rempts
+cd rempts
+bun i
+bun dev # supported options: name
+```
+
+- Both `rempts examples` from @reliverse/rempts and `bun dev` (which is the same thing) are themselves examples of `launcher` functionality.
+- This launcher will show you a `multiselectPrompt()` where you can choose which CLI prompts you want to play with.
+
+### Minimal Usage Example
+
+```ts
+import { defineCommand, runMain } from "@reliverse/rempts";
+
+const main = defineCommand({
+  meta: {
+    name: "mycli",
+  },
+  run() {
+    console.log("Happy, Reliversing!");
+  },
+});
+
+await runMain(main);
+```
+
+### Medium Usage Example
+
+```ts
+import { relinka } from "@reliverse/relinka";
+
+import {
+  startPrompt,
+  inputPrompt,
+  selectPrompt,
+  defineCommand,
+  runMain
+} from "@reliverse/rempts";
+
+const main = defineCommand({
+  meta: {
+    name: "mycli",
+    version: "1.0.0",
+    description: "CLI powered by Rempts",
+  },
+  args: {
+    name: {
+      type: "string",
+      required: false,
+      description: "The name of the project",
+    },
+  },
+  async run({ args }) {
+    await startPrompt({
+      title: "🚀 Project Setup",
+    });
+
+    const name = await inputPrompt({
+      title: "What's your project name?",
+      placeholder: args.name ?? "my-cool-cli",
+    });
+
+    const framework = await selectPrompt({
+      title: "Pick your framework",
+      options: [
+        { value: "next", label: "Next.js" },
+        { value: "svelte", label: "SvelteKit" },
+        { value: "start", label: "TanStack Start" },
+      ],
+    });
+
+    relinka("info", "You have selected:", { name, framework });
+  },
+});
+
+await runMain(main);
+```
+
+### Advanced Usage Example
+
+```ts
+import { relinka } from "@reliverse/relinka";
+
+import {
+  startPrompt,
+  inputPrompt,
+  selectPrompt,
+  defineCommand,
+  runMain,
+} from "@reliverse/rempts";
+
+/**
+ * Main command defined using `defineCommand()`.
+ *
+ * This command demonstrates the full range of launcher features along with all supported argument types:
+ *
+ * - Global Usage Handling: Automatically processes `--help` and `--version`.
+ * - File-Based Subcommands: Scans "src/cli/args" for subcommands (e.g., `init`).
+ * - Comprehensive Argument Parsing: Supports positional, boolean, string, number, and array arguments.
+ * - Interactive Prompts: Uses built-in prompt functions for an engaging CLI experience.
+ */
+const mainCommand = defineCommand({
+  meta: {
+    name: "rempts",
+    version: "1.6.0",
+    description:
+      "An example CLI that supports file-based subcommands and all argument types.",
+  },
+  args: {
+    // Positional arguments
+    inputFile: {
+      type: "positional",
+      required: false,
+      description: "Path to the input file (only for the main command).",
+    },
+    config: {
+      type: "positional",
+      required: false,
+      description: "Path to the configuration file.",
+    },
+    // Boolean arguments
+    verbose: {
+      type: "boolean",
+      default: false,
+      description: "Whether to print verbose logs in the main command.",
+    },
+    debug: {
+      type: "boolean",
+      default: false,
+      description: "Enable debug mode for additional logging.",
+    },
+    // String argument
+    name: {
+      type: "string",
+      required: false,
+      description: "The name of the project.",
+    },
+    // Number argument
+    timeout: {
+      type: "number",
+      required: false,
+      default: 30,
+      description: "Timeout in seconds for the CLI operation.",
+    },
+    // Array argument
+    tags: {
+      type: "array",
+      required: false,
+      default: ["cli", "rempts"],
+      description: "List of tags associated with the project.",
+    },
+  },
+  async run({ args, raw }) {
+    // Display invocation details and parsed arguments.
+    relinka("info", "Main command was invoked!");
+    relinka("info", "Parsed main-command args:", args);
+    relinka("info", "Raw argv:", raw);
+    relinka("info", "\nHelp: `rempts --help`, `rempts cmdName --help`");
+
+    // Begin interactive session with a prompt.
+    await startPrompt({
+      title: "🚀 Project Setup",
+    });
+
+    // Ask for the project name, falling back to provided argument or a default.
+    const projectName = await inputPrompt({
+      title: "What's your project name?",
+      placeholder: args.name ?? "my-cool-cli",
+    });
+
+    // Let the user pick a framework from a select prompt.
+    const framework = await selectPrompt({
+      title: "Pick your framework",
+      options: [
+        { value: "next", label: "Next.js" },
+        { value: "svelte", label: "SvelteKit" },
+        { value: "start", label: "TanStack Start" },
+      ],
+    });
+
+    // Log all gathered input details.
+    relinka("info", "You have selected:", {
+      projectName,
+      framework,
+      inputFile: args.inputFile,
+      config: args.config,
+      verbose: args.verbose,
+      debug: args.debug,
+      timeout: args.timeout,
+      tags: args.tags,
+    });
+  },
+});
+
+/**
+ * The `runMain()` function sets up the launcher with several advanced features:
+ *
+ * - File-Based Subcommands: Enables scanning for subcommands within the "src/cli/args" directory.
+ * - Alias Mapping: Shorthand flags (e.g., `-v`) are mapped to their full names (e.g., `--verbose`).
+ * - Strict Mode & Unknown Flag Warnings: Unknown flags are either warned about or handled via a callback.
+ * - Negated Boolean Support: Allows flags to be negated (e.g., `--no-verbose`).
+ * - Custom Unknown Flag Handler: Provides custom handling for unrecognized flags.
+ */
+await runMain(mainCommand, {
+  fileBasedCmds: {
+    enable: true, // Enables file-based subcommand detection.
+    cmdsRootPath: "src/cli/args", // Directory to scan for subcommands.
+  },
+  alias: {
+    v: "verbose", // Maps shorthand flag -v to --verbose.
+  },
+  strict: false, // Do not throw errors for unknown flags.
+  warnOnUnknown: true, // 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;
+  },
+});
+```
+
+## Contributing
+
+Bug report? Prompt idea? Want to build the best DX possible?
+
+You're in the right place:
+
+- ✨ [Star the repo](https://github.com/reliverse/rempts)
+- 💬 [Join the Discord](https://discord.gg/3GawfWfAPe)
+- ❤️ [Sponsor @blefnk](https://github.com/sponsors/blefnk)
+
+> *No classes. No magic. Just clean, composable tools for CLI devs.*
+
+## Related
+
+- [`@reliverse/cli`](https://npmjs.com/package/@reliverse/cli) – CLI-first toolkit for fullstack workflows
+- [`@reliverse/reliarg`](https://npmjs.com/package/@reliverse/reliarg) – Tiny, strict, zero-dep argument parser
+- [`@reliverse/reglob`](https://npmjs.com/package/@reliverse/reglob) – Fast, minimal file matcher
+- [`@reliverse/relinka`](https://npmjs.com/package/@reliverse/relinka) – Styled CLI logs, steps, and symbols
+
+## Shoutouts
+
+- [citty](https://github.com/unjs/citty#readme) - launcher design inspiration
+
+## License
+
+💖 MIT © [blefnk (Nazar Kornienko)](https://github.com/blefnk)

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

@@ -0,0 +1,12 @@
+import type { ColorName } from "../../core-types.js";
+type Options = {
+    ctrlC?: number | false | "reject";
+    preserveLog?: boolean;
+    hideMessage?: boolean;
+    shouldStream?: boolean;
+    streamDelay?: number;
+    color?: ColorName;
+    placeholderColor?: ColorName;
+};
+export declare function anykeyPrompt(message?: string, options?: Options): Promise<void>;
+export {};

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

@@ -0,0 +1,125 @@
+import logUpdate from "log-update";
+import { cursor } from "sisteransi";
+import { fmt } from "../msg-fmt/messages.js";
+import { endPrompt } from "../st-end/end.js";
+import { streamText } from "../utils/stream-text.js";
+const DEFAULT_MESSAGE = "Press any key to continue...";
+const CTRL_C_CODE = 3;
+const terminal = {
+  /**
+   * Move cursor to start of line
+   */
+  moveToStart: () => process.stdout.write("\r"),
+  /**
+   * Clear current line and move cursor up
+   */
+  clearLineAndMoveUp: () => process.stdout.write("\x1B[1A\x1B[2K"),
+  /**
+   * Clear multiple lines above current position
+   */
+  clearLines: (count) => {
+    terminal.moveToStart();
+    process.stdout.write("\x1B[2K");
+    for (let i = 0; i < count; i++) {
+      terminal.clearLineAndMoveUp();
+    }
+  }
+};
+export async function anykeyPrompt(message = DEFAULT_MESSAGE, options = {}) {
+  const {
+    ctrlC = 1,
+    preserveLog = false,
+    hideMessage = false,
+    shouldStream = false,
+    streamDelay = 20,
+    color = "dim",
+    placeholderColor = "gray"
+  } = options;
+  if (message) {
+    if (!shouldStream) {
+      const { text } = fmt({
+        hintPlaceholderColor: placeholderColor,
+        type: "M_GENERAL",
+        title: message,
+        titleColor: color,
+        dontRemoveBar: true
+      });
+      message = text;
+    }
+  }
+  if (message && !hideMessage) {
+    if (shouldStream) {
+      await streamText({
+        text: `\u25C6  ${message}`,
+        delay: streamDelay,
+        newline: false,
+        clearLine: true,
+        color
+      });
+      const lineCount = message.split("\n").length;
+      terminal.clearLines(lineCount);
+      const { text } = fmt({
+        hintPlaceholderColor: placeholderColor,
+        type: "M_GENERAL",
+        title: message,
+        titleColor: color,
+        dontRemoveBar: true
+      });
+      terminal.moveToStart();
+      logUpdate(text);
+    } else {
+      logUpdate(message);
+    }
+  }
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      process.stdin.removeListener("data", handler);
+      if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      process.stdout.write(cursor.show);
+    };
+    const handleCtrlC = () => {
+      cleanup();
+      void endPrompt({
+        title: "\u270B User pressed Ctrl+C, exiting...",
+        titleAnimation: "pulse",
+        titleColor: "redBright",
+        titleTypography: "bold",
+        endTitleColor: "redBright",
+        titleAnimationDelay: 400
+      }).then(() => {
+        if (ctrlC === "reject") {
+          reject(new Error("User pressed CTRL+C"));
+        } else if (ctrlC === false) {
+          resolve();
+        } else if (typeof ctrlC === "number") {
+          process.exit(0);
+        } else {
+          throw new TypeError("Invalid ctrlC option");
+        }
+      }).catch(reject);
+    };
+    const handler = (buffer) => {
+      cleanup();
+      if (message && !preserveLog) {
+        logUpdate.clear();
+      } else {
+        logUpdate.done();
+        process.stdout.write("\n");
+      }
+      const [firstByte] = buffer;
+      if (firstByte === CTRL_C_CODE) {
+        handleCtrlC();
+      } else {
+        resolve();
+      }
+    };
+    process.stdin.resume();
+    if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.once("data", handler);
+  });
+}

package/bin/core-impl/date/date.d.ts

@@ -0,0 +1,2 @@
+import type { DatePromptOptions } from "../../core-types.js";
+export declare function datePrompt(opts: DatePromptOptions): Promise<string>;