@reliverse/rempts 1.7.30 → 1.7.32

package/README.md

@@ -28,6 +28,7 @@
 - 🏞️ no more hacking together `inquirer`/`citty`/`commander`/`chalk`
 - 🆕 automatic command creation (`bun dler rempts --init cmd1 cmd2`)
 - 🐦‍🔥 automatic creation of `src/app/cmds.ts` file (`bun dler rempts`)
+- 🔌 tRPC/ORPC router integration - automatically generate CLI commands from your RPC procedures
 
 ## Installation
 
@@ -364,6 +365,48 @@ See [example/launcher/app/nested](./example/launcher/app/nested/) and [example/l
 
 When playing with the example, you can run e.g. `bun dev:modern nested foo bar baz` to see the result in action.
 
+## RPC Integration
+
+Rempts now supports seamless integration with tRPC and ORPC routers, allowing you to automatically generate CLI commands from your RPC procedures. This provides a powerful way to expose your API endpoints as command-line tools.
+
+```typescript
+import { z } from "zod";
+import { initTRPC } from "@trpc/server";
+import { createCli } from "@reliverse/rempts";
+
+const t = initTRPC.create();
+
+const appRouter = t.router({
+  hello: t.procedure
+    .input(z.object({ name: z.string().optional() }))
+    .query(({ input }) => `Hello ${input.name ?? "World"}!`),
+  
+  add: t.procedure
+    .input(z.object({ a: z.number(), b: z.number() }))
+    .mutation(({ input }) => input.a + input.b)
+});
+
+// Automatically generates CLI commands from your tRPC procedures
+await createCli({
+  name: "my-cli",
+  rpc: { router: appRouter }
+});
+```
+
+**Features:**
+
+- 🚀 Automatic CLI generation from tRPC procedures
+- 🔄 Support for both tRPC v10 and v11
+- 🏗️ Nested command structures from sub-routers
+- ✅ Input validation from Zod schemas
+- 📖 Automatic help generation from procedure metadata
+- 🎯 Full TypeScript support with type inference
+- 🎨 Interactive prompts for missing arguments
+- ⌨️ Shell completion support
+- 🔧 Customizable logging and error handling
+
+See [RPC Integration Guide](./docs/launcher-rpc.md) for detailed documentation and examples.
+
 ### Playground
 
 ```bash
@@ -377,6 +420,12 @@ bun dev
 - `bun dev:modern`: This example will show you a modern CLI launcher usage with file-based commands.
 - `bun dev:classic`: This example will show you a classic CLI launcher usage with programmatic commands.
 
+### tRPC/oRPC Integration Example Commands
+
+```bash
+bun example/trpc-orpc/rempts/effect-primary.ts create-profile --name 'Jane Smith' --age 28 --bio 'Software Engineer' --tags 'developer,typescript'
+```
+
 ### Launcher Usage Examples
 
 #### Minimal Usage Example

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

@@ -1,5 +1,7 @@
 import type { ReliArgParserOptions } from "@reliverse/reliarg";
 import type { ArgDefinitions, Command, DefineCommandOptions, EmptyArgs, FileBasedOptions } from "./launcher-types.js";
+import type { AnyRouter } from "./trpc-orpc-support/trpc-compat.js";
+import type { Logger, OmeletteInstanceLike, Promptable } from "./trpc-orpc-support/types.js";
 /**
  * Defines a command with metadata, argument definitions,
  * an execution function, and (optional) subCommands.
@@ -28,6 +30,7 @@ export declare function showUsage<A extends ArgDefinitions>(command: Command<A>,
  * - File-based Commands: scanning for commands within a given commands root.
  * - Commands defined within the command object.
  * - Standard flags like --help, --version, and --debug.
+ * - RPC functionality: tRPC/oRPC router integration with automatic CLI generation.
  *
  * This function passes along remaining arguments to command runners to ensure
  * consistent parsing.
@@ -50,21 +53,48 @@ export declare function createCli<A extends ArgDefinitions = EmptyArgs>(options:
     onCmdExit?: Command<A>["onCmdExit"];
     onLauncherInit?: Command<A>["onLauncherInit"];
     onLauncherExit?: Command<A>["onLauncherExit"];
+    rpc?: {
+        /** A tRPC router. Procedures will become CLI commands. */
+        router: AnyRouter;
+        /** Context to be supplied when invoking the router. */
+        context?: any;
+        /** The `@trpc/server` module to use for calling procedures. Required when using trpc v10. */
+        trpcServer?: any | Promise<any>;
+        /** Usage code examples to display in `--help` output. */
+        usage?: string | string[];
+        /** Dependencies for schema validation libraries */
+        "@valibot/to-json-schema"?: {
+            toJsonSchema: (input: unknown, options?: {
+                errorMode?: "throw" | "ignore" | "warn";
+            }) => any;
+        };
+        effect?: {
+            Schema: {
+                isSchema: (input: unknown) => input is "JSONSchemaMakeable";
+            };
+            JSONSchema: {
+                make: (input: "JSONSchemaMakeable") => any;
+            };
+        };
+    };
+    rpcRunParams?: {
+        argv?: string[];
+        logger?: Logger;
+        completion?: OmeletteInstanceLike | (() => Promise<OmeletteInstanceLike>);
+        prompts?: Promptable;
+        /** Format an error thrown by the root procedure before logging to `logger.error` */
+        formatError?: (error: unknown) => string;
+        process?: {
+            exit: (code: number) => never;
+        };
+    };
 }, legacyParserOptions?: ReliArgParserOptions & {
     fileBased?: FileBasedOptions;
     autoExit?: boolean;
     metaSettings?: {
         showDescriptionOnMain?: boolean;
     };
-}): {
-    /**
-     * @deprecated Use createCli() directly instead. This method will be removed in a future version.
-     * @example
-     * // Instead of:
-     * createCli({...}).run()
-     * // Use:
-     * await createCli({...})
-     */
+}): Promise<void> & {
     run(_ctx?: any): Promise<void>;
 };
 /**

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

@@ -5,6 +5,7 @@ import fs from "@reliverse/relifso";
 import { relinka, relinkaConfig, relinkaShutdown } from "@reliverse/relinka";
 import process from "node:process";
 import { readPackageJSON } from "pkg-types";
+import { createRpcCli } from "./trpc-orpc-support/index.js";
 function buildExampleArgs(args) {
   const parts = [];
   const positionalKeys = Object.keys(args || {}).filter(
@@ -71,6 +72,7 @@ export function defineCommand(options) {
     onCmdExit,
     onLauncherInit,
     onLauncherExit,
+    router: options.router,
     // Backward-compatible aliases
     setup: onCmdInit,
     cleanup: onCmdExit
@@ -379,95 +381,220 @@ export function createCli(options, legacyParserOptions) {
       meta: mergedMeta
     };
   }
-  return {
-    /**
-     * @deprecated Use createCli() directly instead. This method will be removed in a future version.
-     * @example
-     * // Instead of:
-     * createCli({...}).run()
-     * // Use:
-     * await createCli({...})
-     */
-    async run(_ctx) {
-      relinka(
-        "warn",
-        "\u26A0\uFE0F  Deprecated: .run() method is deprecated. Use createCli() directly instead."
+  const execute = async (_ctx) => {
+    if (options && typeof options === "object" && "rpc" in options && options.rpc) {
+      const rpcOptions = options.rpc;
+      const rpcRunParams = options.rpcRunParams || {};
+      debugLog("RPC integration detected, creating RPC CLI...");
+      try {
+        require("tsx/cjs");
+        await import("tsx/esm");
+        debugLog("tsx loaded successfully for TypeScript support");
+      } catch {
+        debugLog("tsx not available, continuing without TypeScript support");
+      }
+      const getRouterMeta = (router) => {
+        if ("_def" in router && router._def && "meta" in router._def) {
+          return router._def.meta;
+        }
+        return void 0;
+      };
+      const routerMeta = getRouterMeta(rpcOptions.router);
+      const rpcCli = createRpcCli({
+        router: rpcOptions.router,
+        name: globalCliMeta.name || routerMeta?.name,
+        version: globalCliMeta.version || routerMeta?.version,
+        description: globalCliMeta.description || routerMeta?.description,
+        usage: rpcOptions.usage,
+        context: rpcOptions.context,
+        trpcServer: rpcOptions.trpcServer,
+        "@valibot/to-json-schema": rpcOptions["@valibot/to-json-schema"],
+        effect: rpcOptions.effect
+      });
+      debugLog(
+        "RPC CLI created, running with argv:",
+        rpcRunParams.argv || process.argv.slice(2)
       );
-      relinka("warn", "   Instead of: createCli({...}).run()");
-      relinka("warn", "   Use: await createCli({...})");
-      if (typeof command.onLauncherInit === "function") {
+      await rpcCli.run({
+        argv: rpcRunParams.argv || process.argv.slice(2),
+        logger: rpcRunParams.logger || {
+          info: console.log,
+          error: console.error
+        },
+        completion: rpcRunParams.completion,
+        prompts: rpcRunParams.prompts,
+        formatError: rpcRunParams.formatError,
+        process: rpcRunParams.process
+      });
+      return;
+    }
+    if (command.router) {
+      debugLog(
+        "Router detected in command, automatically enabling RPC mode..."
+      );
+      try {
+        require("tsx/cjs");
+        await import("tsx/esm");
+        debugLog("tsx loaded successfully for TypeScript support");
+      } catch {
+        debugLog("tsx not available, continuing without TypeScript support");
+      }
+      const getRouterMeta = (router) => {
+        if ("_def" in router && router._def && "meta" in router._def) {
+          return router._def.meta;
+        }
+        return void 0;
+      };
+      const routerMeta = getRouterMeta(command.router);
+      const rpcCli = createRpcCli({
+        router: command.router,
+        name: globalCliMeta.name || command.meta?.name || routerMeta?.name,
+        version: globalCliMeta.version || command.meta?.version || routerMeta?.version,
+        description: globalCliMeta.description || command.meta?.description || routerMeta?.description
+      });
+      debugLog(
+        "RPC CLI created from command router, running with argv:",
+        process.argv.slice(2)
+      );
+      await rpcCli.run({
+        argv: process.argv.slice(2),
+        logger: {
+          info: console.log,
+          error: console.error
+        },
+        process: {
+          exit: process.exit
+        }
+      });
+      return;
+    }
+    if (typeof command.onLauncherInit === "function") {
+      try {
+        await command.onLauncherInit();
+      } catch (err) {
+        relinka("error", "Error in onLauncherInit:", err);
+        if (parserOptions.autoExit !== false) process.exit(1);
+        throw err;
+      }
+    }
+    try {
+      if (!parserOptions.fileBased && !command.commands) {
+        const mainEntry = process.argv[1] ? path.dirname(path.resolve(process.argv[1])) : process.cwd();
+        const defaultCmdsRoot = path.join(mainEntry, "src", "app");
+        const exists = await fs.pathExists(defaultCmdsRoot);
+        const finalCmdsRoot = exists ? defaultCmdsRoot : path.join(mainEntry, "app");
+        parserOptions.fileBased = {
+          enable: true,
+          cmdsRootPath: finalCmdsRoot
+        };
+      }
+      const rawArgv = process.argv.slice(2);
+      const autoExit = parserOptions.autoExit !== false;
+      if (!(parserOptions.fileBased?.enable || command.commands && Object.keys(command.commands).length > 0 || command.run || command.router)) {
+        relinka(
+          "error",
+          "Invalid CLI configuration: No file-based commands, subCommands, run() handler, or router are defined. This CLI will not do anything.\n\u2502   To fix: add file-based commands (./app), or provide at least one subCommand, a run() handler, or a router."
+        );
+        process.exit(1);
+      }
+      if (parserOptions.fileBased?.enable && rawArgv.length > 0) {
+        const commandsDir = path.resolve(parserOptions.fileBased.cmdsRootPath);
+        const resolved = await resolveFileBasedCommandPath(
+          commandsDir,
+          rawArgv
+        );
+        if (resolved) {
+          const {
+            def: subCommand,
+            leftoverArgv,
+            path: pathSegments
+          } = resolved;
+          const helpIdx = leftoverArgv.findIndex(
+            (arg) => arg === "help" || arg === "--help" || arg === "-h"
+          );
+          if (helpIdx !== -1) {
+            await showUsage(
+              subCommand,
+              {
+                ...parserOptions,
+                _fileBasedCurrentDir: pathSegments.length ? path.join(commandsDir, ...pathSegments) : commandsDir,
+                _fileBasedPathSegments: pathSegments
+              },
+              globalCliMeta
+            );
+            if (autoExit) process.exit(0);
+            return;
+          }
+        }
+      }
+      const fileBasedEnabled = parserOptions.fileBased?.enable;
+      if (fileBasedEnabled && rawArgv.length > 0 && rawArgv[0] && !isFlag(rawArgv[0])) {
+        const [subName, ...subCmdArgv] = rawArgv;
         try {
-          await command.onLauncherInit();
+          const ctx = getParsedContext(command, rawArgv, parserOptions);
+          if (typeof command.onCmdInit === "function")
+            await command.onCmdInit(ctx);
+          await runFileBasedSubCmd(
+            subName,
+            subCmdArgv,
+            parserOptions.fileBased,
+            parserOptions,
+            command.onCmdExit ? async (_subCtx) => {
+              await command.onCmdExit?.(ctx);
+            } : void 0,
+            globalCliMeta
+          );
+          if (autoExit) process.exit(0);
+          return;
         } catch (err) {
-          relinka("error", "Error in onLauncherInit:", err);
-          if (parserOptions.autoExit !== false) process.exit(1);
+          relinka("error", "Error loading file-based subcommand:", err.message);
+          if (autoExit) process.exit(1);
           throw err;
         }
       }
-      try {
-        if (!parserOptions.fileBased && !command.commands) {
-          const mainEntry = process.argv[1] ? path.dirname(path.resolve(process.argv[1])) : process.cwd();
-          const defaultCmdsRoot = path.join(mainEntry, "src", "app");
-          const exists = await fs.pathExists(defaultCmdsRoot);
-          const finalCmdsRoot = exists ? defaultCmdsRoot : path.join(mainEntry, "app");
-          parserOptions.fileBased = {
-            enable: true,
-            cmdsRootPath: finalCmdsRoot
-          };
-        }
-        const rawArgv = process.argv.slice(2);
-        const autoExit = parserOptions.autoExit !== false;
-        if (!(parserOptions.fileBased?.enable || command.commands && Object.keys(command.commands).length > 0 || command.run)) {
-          relinka(
-            "error",
-            "Invalid CLI configuration: No file-based commands, subCommands, or run() handler are defined. This CLI will not do anything.\n\u2502   To fix: add file-based commands (./app), or provide at least one subCommand or a run() handler."
-          );
-          process.exit(1);
+      if (!fileBasedEnabled && command.commands && rawArgv.length > 0 && rawArgv[0] && !isFlag(rawArgv[0])) {
+        const [maybeSub, ...subCmdArgv] = rawArgv;
+        let subSpec;
+        for (const [key, spec] of Object.entries(command.commands)) {
+          if (key === maybeSub) {
+            subSpec = spec;
+            break;
+          }
+          try {
+            const cmd = await loadSubCommand(spec);
+            if (cmd.meta?.aliases?.includes(maybeSub)) {
+              subSpec = spec;
+              break;
+            }
+          } catch (err) {
+            debugLog(`Error checking alias for command ${key}:`, err);
+          }
         }
-        if (parserOptions.fileBased?.enable && rawArgv.length > 0) {
-          const commandsDir = path.resolve(
-            parserOptions.fileBased.cmdsRootPath
+        if (subSpec) {
+          const helpIdx = subCmdArgv.findIndex(
+            (arg) => arg === "help" || arg === "--help" || arg === "-h"
           );
-          const resolved = await resolveFileBasedCommandPath(
-            commandsDir,
-            rawArgv
-          );
-          if (resolved) {
-            const {
-              def: subCommand,
-              leftoverArgv,
-              path: pathSegments
-            } = resolved;
-            const helpIdx = leftoverArgv.findIndex(
-              (arg) => arg === "help" || arg === "--help" || arg === "-h"
+          if (helpIdx !== -1) {
+            const subCommandDef = await loadSubCommand(subSpec);
+            await showUsage(
+              subCommandDef,
+              {
+                ...parserOptions,
+                _isSubcommand: true
+              },
+              globalCliMeta
             );
-            if (helpIdx !== -1) {
-              await showUsage(
-                subCommand,
-                {
-                  ...parserOptions,
-                  _fileBasedCurrentDir: pathSegments.length ? path.join(commandsDir, ...pathSegments) : commandsDir,
-                  _fileBasedPathSegments: pathSegments
-                },
-                globalCliMeta
-              );
-              if (autoExit) process.exit(0);
-              return;
-            }
+            if (autoExit) process.exit(0);
+            return;
           }
-        }
-        const fileBasedEnabled = parserOptions.fileBased?.enable;
-        if (fileBasedEnabled && rawArgv.length > 0 && rawArgv[0] && !isFlag(rawArgv[0])) {
-          const [subName, ...subCmdArgv] = rawArgv;
           try {
             const ctx = getParsedContext(command, rawArgv, parserOptions);
             if (typeof command.onCmdInit === "function")
               await command.onCmdInit(ctx);
-            await runFileBasedSubCmd(
-              subName,
+            await runSubCommand(
+              subSpec,
               subCmdArgv,
-              parserOptions.fileBased,
-              parserOptions,
+              { ...parserOptions, _isSubcommand: true },
               command.onCmdExit ? async (_subCtx) => {
                 await command.onCmdExit?.(ctx);
               } : void 0,
@@ -476,107 +603,64 @@ export function createCli(options, legacyParserOptions) {
             if (autoExit) process.exit(0);
             return;
           } catch (err) {
-            relinka(
-              "error",
-              "Error loading file-based subcommand:",
-              err.message
-            );
+            relinka("error", "Error running subcommand:", err.message);
             if (autoExit) process.exit(1);
             throw err;
           }
         }
-        if (!fileBasedEnabled && command.commands && rawArgv.length > 0 && rawArgv[0] && !isFlag(rawArgv[0])) {
-          const [maybeSub, ...subCmdArgv] = rawArgv;
-          let subSpec;
-          for (const [key, spec] of Object.entries(command.commands)) {
-            if (key === maybeSub) {
-              subSpec = spec;
-              break;
-            }
-            try {
-              const cmd = await loadSubCommand(spec);
-              if (cmd.meta?.aliases?.includes(maybeSub)) {
-                subSpec = spec;
-                break;
-              }
-            } catch (err) {
-              debugLog(`Error checking alias for command ${key}:`, err);
-            }
-          }
-          if (subSpec) {
-            const helpIdx = subCmdArgv.findIndex(
-              (arg) => arg === "help" || arg === "--help" || arg === "-h"
-            );
-            if (helpIdx !== -1) {
-              const subCommandDef = await loadSubCommand(subSpec);
-              await showUsage(
-                subCommandDef,
-                {
-                  ...parserOptions,
-                  _isSubcommand: true
-                },
-                globalCliMeta
-              );
-              if (autoExit) process.exit(0);
-              return;
-            }
-            try {
-              const ctx = getParsedContext(command, rawArgv, parserOptions);
-              if (typeof command.onCmdInit === "function")
-                await command.onCmdInit(ctx);
-              await runSubCommand(
-                subSpec,
-                subCmdArgv,
-                { ...parserOptions, _isSubcommand: true },
-                command.onCmdExit ? async (_subCtx) => {
-                  await command.onCmdExit?.(ctx);
-                } : void 0,
-                globalCliMeta
-              );
-              if (autoExit) process.exit(0);
-              return;
-            } catch (err) {
-              relinka("error", "Error running subcommand:", err.message);
-              if (autoExit) process.exit(1);
-              throw err;
-            }
-          }
-        }
-        await relinkaConfig;
-        if (rawArgv[0] === "help" || checkHelp(rawArgv)) {
-          await showUsage(command, parserOptions, globalCliMeta);
-          if (autoExit) process.exit(0);
-          return;
-        }
-        if (checkVersion(rawArgv)) {
-          if (command.meta?.name) {
-            relinka(
-              "info",
-              `${command.meta?.name} ${command.meta?.version ? `v${command.meta?.version}` : ""}`
-            );
-          }
-          if (autoExit) process.exit(0);
-          return;
-        }
-        try {
-          await runCommandWithArgs(
-            command,
-            rawArgv,
-            parserOptions,
-            globalCliMeta
+      }
+      await relinkaConfig;
+      if (rawArgv[0] === "help" || checkHelp(rawArgv)) {
+        await showUsage(command, parserOptions, globalCliMeta);
+        if (autoExit) process.exit(0);
+        return;
+      }
+      if (checkVersion(rawArgv)) {
+        if (command.meta?.name) {
+          relinka(
+            "info",
+            `${command.meta?.name} ${command.meta?.version ? `v${command.meta?.version}` : ""}`
           );
-        } finally {
         }
-        await relinkaShutdown();
+        if (autoExit) process.exit(0);
+        return;
+      }
+      try {
+        await runCommandWithArgs(
+          command,
+          rawArgv,
+          parserOptions,
+          globalCliMeta
+        );
       } finally {
-        if (typeof command.onLauncherExit === "function")
-          await command.onLauncherExit();
       }
-      throw new Error(
-        "\u26A0\uFE0F  Deprecated: .run() method is deprecated. Use createCli() directly instead.\n   Instead of: createCli({...}).run()\n   Use: await createCli({...})"
-      );
+      await relinkaShutdown();
+    } finally {
+      if (typeof command.onLauncherExit === "function")
+        await command.onLauncherExit();
     }
   };
+  const promise = execute();
+  const cli = Object.assign(promise, {
+    /**
+     * @deprecated Use createCli() directly instead. This method will be removed in a future version.
+     * @example
+     * // Instead of:
+     * createCli({...}).run()
+     * // Use:
+     * await createCli({...})
+     */
+    async run(_ctx) {
+      relinka(
+        "warn",
+        "\u26A0\uFE0F  Deprecated: .run() method is deprecated. Use createCli() directly instead."
+      );
+      relinka("warn", "   Instead of: createCli({...}).run()");
+      relinka("warn", "   Use: await createCli({...})");
+      return execute(_ctx);
+    }
+  });
+  return cli;
 }
 function checkHelp(argv) {
   return argv.includes("--help") || argv.includes("-h");
@@ -784,7 +868,7 @@ async function runCommandWithArgs(command, argv, parserOptions, globalCliMeta, r
     if (command.run) {
       await command.run(ctx);
     } else {
-      const isDispatcher = parserOptions.fileBased?.enable || command.commands && Object.keys(command.commands).length > 0;
+      const isDispatcher = parserOptions.fileBased?.enable || command.commands && Object.keys(command.commands).length > 0 || command.router;
       const noSubcommandArgInCurrentCall = !argv.some((arg) => !isFlag(arg));
       if (isDispatcher && noSubcommandArgInCurrentCall) {
         relinka("warn", "Please specify a command");

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

@@ -1,3 +1,4 @@
+import type { AnyRouter } from "./trpc-orpc-support/trpc-compat.js";
 export type EmptyArgs = Record<string, never>;
 export interface BaseArgProps {
     description?: string;
@@ -99,6 +100,11 @@ export interface DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> {
      * Called once per CLI process, after all command/run() logic is finished
      */
     onLauncherExit?: () => void | Promise<void>;
+    /**
+     * tRPC/oRPC router for RPC mode. When provided, the command will automatically
+     * switch to RPC mode and use the router's procedures as CLI commands.
+     */
+    router?: AnyRouter;
 }
 export interface Command<A extends ArgDefinitions = EmptyArgs> {
     meta?: CommandMeta;
@@ -136,6 +142,11 @@ export interface Command<A extends ArgDefinitions = EmptyArgs> {
      * Called once per CLI process, after all command/run() logic is finished
      */
     onLauncherExit?: () => void | Promise<void>;
+    /**
+     * tRPC/oRPC router for RPC mode. When provided, the command will automatically
+     * switch to RPC mode and use the router's procedures as CLI commands.
+     */
+    router?: AnyRouter;
 }
 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 {

package/bin/mod.d.ts

@@ -1,6 +1,5 @@
 export { animationMap, animateText } from "./libs/animate/animate-mod.js";
 export { anykeyPrompt } from "./libs/anykey/anykey-mod.js";
-export { createAsciiArt } from "./libs/visual/visual-mod.js";
 export type { CancelValue } from "./libs/cancel/cancel.js";
 export { CANCEL, isWindows, setRawMode, getColumns, block, isCancel, cancel, createCancel, } from "./libs/cancel/cancel.js";
 export { confirm } from "./libs/confirm/confirm-alias.js";
@@ -63,4 +62,5 @@ export { completePrompt, renderEndLine, renderEndLineInput, } from "./libs/utils
 export { streamText, streamTextBox, streamTextWithSpinner, } from "./libs/utils/stream-text.js";
 export { pm, reliversePrompts } from "./libs/utils/system.js";
 export { isTerminalInteractive, isValidName, normalizeName, } from "./libs/utils/validate.js";
+export { createAsciiArt } from "./libs/visual/visual-mod.js";
 export type { MsgType, TypographyName, BorderColorName, ColorName, VariantName, MsgConfig, PromptOptions, ChoiceOptions, SelectOption, StandardColor, OutputColor, EditorExitResult, MessageKind, AllKinds, MessageConfig, StreamOptions, ProgressBarOptions, ProgressBar, PromptType, ConfirmPromptOptions, StreamTextOptions, PreventWrongTerminalSizeOptions, InputPromptOptions, RenderParams, SymbolName, Symbols, FmtMsgOptions, TogglePromptParams, SeparatorOption, MultiselectPromptParams, DatePromptOptions, } from "./types.js";

package/bin/mod.js

@@ -1,6 +1,5 @@
 export { animationMap, animateText } from "./libs/animate/animate-mod.js";
 export { anykeyPrompt } from "./libs/anykey/anykey-mod.js";
-export { createAsciiArt } from "./libs/visual/visual-mod.js";
 export {
   CANCEL,
   isWindows,
@@ -148,3 +147,4 @@ export {
   isValidName,
   normalizeName
 } from "./libs/utils/validate.js";
+export { createAsciiArt } from "./libs/visual/visual-mod.js";

package/package.json

@@ -17,6 +17,7 @@
     "cli-spinners": "^3.2.0",
     "commander": "^14.0.0",
     "detect-package-manager": "^3.0.2",
+    "effect": "^3.16.8",
     "enquirer": "^2.4.1",
     "figlet": "^1.8.1",
     "gradient-string": "^3.0.0",
@@ -43,7 +44,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.30",
+  "version": "1.7.32",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",