@reliverse/rempts 1.7.0 → 1.7.2

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

@@ -44,10 +44,10 @@ type CommandMeta = {
  * 2) A lazy import function returning a Promise that resolves to
  *    { default: Command<any> } or directly to a Command instance.
  */
-type SubCommandSpec = string | (() => Promise<{
+type CommandSpec = string | (() => Promise<{
     default: Command<any>;
 } | Command<any>>);
-export type SubCommandsMap = Record<string, SubCommandSpec>;
+export type CommandsMap = Record<string, CommandSpec>;
 type CommandContext<ARGS> = {
     args: ARGS;
     raw: string[];
@@ -57,17 +57,75 @@ type DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> = {
     meta?: CommandMeta;
     args?: A;
     run?: CommandRun<InferArgTypes<A>>;
-    subCommands?: SubCommandsMap;
+    /**
+     * 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
+     */
+    onCmdStart?: () => void | Promise<void>;
+    /**
+     * Called after the command finishes
+     */
+    onCmdEnd?: () => void | Promise<void>;
+    /**
+     * @deprecated Use onCmdStart instead
+     */
     setup?: () => void | Promise<void>;
+    /**
+     * @deprecated Use onCmdEnd instead
+     */
     cleanup?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, before any command/run() is executed
+     */
+    onLauncherStart?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/run() logic is finished
+     */
+    onLauncherEnd?: () => void | Promise<void>;
 };
 export type Command<A extends ArgDefinitions = EmptyArgs> = {
     meta?: CommandMeta;
     args: A;
     run?: CommandRun<InferArgTypes<A>>;
-    subCommands?: SubCommandsMap;
+    /**
+     * 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
+     */
+    onCmdStart?: () => void | Promise<void>;
+    /**
+     * Called after the command finishes
+     */
+    onCmdEnd?: () => void | Promise<void>;
+    /**
+     * @deprecated Use onCmdStart instead
+     */
     setup?: () => void | Promise<void>;
+    /**
+     * @deprecated Use onCmdEnd instead
+     */
     cleanup?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, before any command/run() is executed
+     */
+    onLauncherStart?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/run() logic is finished
+     */
+    onLauncherEnd?: () => 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 {
@@ -108,11 +166,11 @@ export declare function showUsage<A extends ArgDefinitions>(command: Command<A>,
 /**
  * Primary entry point to run a command. This function supports:
  *
- * - File-based Subcommands: scanning for subcommands within a given commands root.
- * - SubCommands defined within the command object.
+ * - File-based Commands: scanning for commands within a given commands root.
+ * - Commands defined within the command object.
  * - Standard flags like --help, --version, and --debug.
  *
- * This function passes along remaining arguments to subcommand runners to ensure
+ * This function passes along remaining arguments to command runners to ensure
  * consistent parsing.
  */
 export declare function runMain<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, parserOptions?: ReliArgParserOptions & {
@@ -130,4 +188,14 @@ export declare function runMain<A extends ArgDefinitions = EmptyArgs>(command: C
  * precise default value validation (e.g., `options: ["a", "b"] as const`).
  */
 export declare function defineArgs<A extends ArgDefinitions>(args: A & ValidateArrayDefaults<A>): A;
+/**
+ * Programmatically run a command's run() handler with parsed arguments.
+ * Does not handle subcommands, file-based commands, or global hooks.
+ * Suitable for use in demos, tests, or programmatic invocation.
+ *
+ * @param command The command definition (from defineCommand)
+ * @param argv The argv array to parse (default: [])
+ * @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

@@ -50,21 +50,42 @@ function buildExampleArgs(args) {
 const isDebugMode = process.argv.includes("--debug");
 function debugLog(...args) {
   if (isDebugMode) {
-    relinka("info", "[DEBUG]", ...args);
+    relinka("log", "[DEBUG]", ...args);
   }
 }
 function isFlag(str) {
   return str.startsWith("-");
 }
 export function defineCommand(options) {
-  return {
+  const onCmdStart = options.onCmdStart || options.setup;
+  const onCmdEnd = options.onCmdEnd || options.cleanup;
+  const onLauncherStart = options.onLauncherStart;
+  const onLauncherEnd = options.onLauncherEnd;
+  let commands = options.commands;
+  if (!commands) {
+    commands = options.subCommands;
+  }
+  const cmdObj = {
     meta: options.meta,
     args: options.args || {},
     run: options.run,
-    subCommands: options.subCommands,
-    setup: options.setup,
-    cleanup: options.cleanup
+    commands,
+    onCmdStart,
+    onCmdEnd,
+    onLauncherStart,
+    onLauncherEnd,
+    // Backward-compatible aliases
+    setup: onCmdStart,
+    cleanup: onCmdEnd
   };
+  Object.defineProperty(cmdObj, "subCommands", {
+    get() {
+      return this.commands;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return cmdObj;
 }
 let _cachedDefaultCliName;
 let _cachedDefaultCliVersion;
@@ -88,7 +109,7 @@ export async function showUsage(command, parserOptions = {}, displayNotFoundMess
   const { name: fallbackName, version: fallbackVersion } = await getDefaultCliNameAndVersion();
   const cliName = command.meta?.name || fallbackName;
   const cliVersion = command.meta?.version || fallbackVersion;
-  relinka("info", `${cliName}${cliVersion ? ` v${cliVersion}` : ""}`);
+  relinka("log", `${cliName}${cliVersion ? ` v${cliVersion}` : ""}`);
   if (parserOptions.metaSettings?.showDescriptionOnMain) {
     let description = command.meta?.description;
     if (!description) {
@@ -146,7 +167,7 @@ export async function showUsage(command, parserOptions = {}, displayNotFoundMess
         );
       }
       if (subCommandNames.length > 0) {
-        relinka("info", "Available commands (run with `help` to see more):");
+        relinka("log", "Available commands (run with `help` to see more):");
         subCommandDefs.forEach(({ name, def }) => {
           const desc = def?.meta?.description ?? "";
           relinka("log", `\u2022 ${name}${desc ? ` | ${desc}` : ""}`);
@@ -164,8 +185,9 @@ export async function showUsage(command, parserOptions = {}, displayNotFoundMess
   } else {
     const subCommandNames = [];
     const subCommandDefs = [];
-    if (command.subCommands) {
-      for (const [name, spec] of Object.entries(command.subCommands)) {
+    const objectCommands = command.commands;
+    if (objectCommands) {
+      for (const [name, spec] of Object.entries(objectCommands)) {
         try {
           const cmd = await loadSubCommand(spec);
           if (!cmd?.meta?.hidden) {
@@ -174,7 +196,7 @@ export async function showUsage(command, parserOptions = {}, displayNotFoundMess
             subCommandDefs.push({ name, def: cmd });
           }
         } catch (err) {
-          debugLog(`Error loading subcommand ${name}:`, err);
+          debugLog(`Error loading command ${name}:`, err);
         }
       }
     }
@@ -195,14 +217,14 @@ export async function showUsage(command, parserOptions = {}, displayNotFoundMess
       );
     }
     if (subCommandNames.length > 0) {
-      relinka("info", "Available commands (run with `help` to see more):");
+      relinka("log", "Available commands (run with `help` to see more):");
       subCommandDefs.forEach(({ name, def }) => {
         const desc = def?.meta?.description ?? "";
         relinka("log", `\u2022 ${name}${desc ? ` | ${desc}` : ""}`);
       });
     }
   }
-  relinka("info", "Available options:");
+  relinka("log", "Available options:");
   relinka("log", "\u2022 -h, --help    | Show help");
   relinka("log", "\u2022 -v, --version | Show version");
   relinka("log", "\u2022 --debug       | Enable debug mode");
@@ -228,146 +250,153 @@ export async function showUsage(command, parserOptions = {}, displayNotFoundMess
   }
 }
 export async function runMain(command, parserOptions = {}) {
-  if (!parserOptions.fileBasedCmds && !command.subCommands) {
-    let callerDir = process.cwd();
-    let callerFile;
-    try {
-      const err = new Error();
-      const stack = err.stack?.split("\n");
-      if (stack) {
-        for (const line of stack) {
-          const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-          if (match?.[1] && !match[1].includes("launcher-mod")) {
-            callerFile = match[1];
-            break;
+  if (typeof command.onLauncherStart === "function")
+    await command.onLauncherStart();
+  try {
+    if (!parserOptions.fileBasedCmds && !command.commands) {
+      let callerDir = process.cwd();
+      let callerFile;
+      try {
+        const err = new Error();
+        const stack = err.stack?.split("\n");
+        if (stack) {
+          for (const line of stack) {
+            const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
+            if (match?.[1] && !match[1].includes("launcher-mod")) {
+              callerFile = match[1];
+              break;
+            }
           }
         }
-      }
-      if (callerFile) {
-        callerDir = path.dirname(callerFile);
-        const rel = path.relative(process.cwd(), callerFile);
-        if (/app[/][^/]+[/]cmd\.(ts|js)$/.test(rel)) {
-          relinka(
-            "error",
-            `runMain() should not be called from a file-based subcommand: ${rel}
+        if (callerFile) {
+          callerDir = path.dirname(callerFile);
+          const rel = path.relative(process.cwd(), callerFile);
+          if (/app[/][^/]+[/]cmd\.(ts|js)$/.test(rel)) {
+            relinka(
+              "error",
+              `runMain() should not be called from a file-based subcommand: ${rel}
 This can cause recursion or unexpected behavior.
 Move your runMain() call to your main CLI entry file.`
-          );
-          process.exit(1);
-        }
-        const mainEntry = process.argv[1] ? path.resolve(process.argv[1]) : void 0;
-        if (mainEntry && path.resolve(callerFile) !== mainEntry) {
-          relinka(
-            "error",
-            `runMain() should only be called from your main CLI entry file.
+            );
+            process.exit(1);
+          }
+          const mainEntry = process.argv[1] ? path.resolve(process.argv[1]) : void 0;
+          if (mainEntry && path.resolve(callerFile) !== mainEntry) {
+            relinka(
+              "error",
+              `runMain() should only be called from your main CLI entry file.
 Detected: ${callerFile}
 Main entry: ${mainEntry}
 This can cause recursion or unexpected behavior.`
-          );
-          process.exit(1);
+            );
+            process.exit(1);
+          }
         }
+      } catch (_e) {
       }
-    } catch (_e) {
+      const defaultCmdsRoot = path.resolve(callerDir, "app");
+      parserOptions.fileBasedCmds = {
+        enable: true,
+        cmdsRootPath: defaultCmdsRoot
+      };
     }
-    const defaultCmdsRoot = path.resolve(callerDir, "app");
-    parserOptions.fileBasedCmds = {
-      enable: true,
-      cmdsRootPath: defaultCmdsRoot
-    };
-  }
-  const rawArgv = process.argv.slice(2);
-  const autoExit = parserOptions.autoExit !== false;
-  if (!(parserOptions.fileBasedCmds?.enable || command.subCommands && Object.keys(command.subCommands).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 (rawArgv[0] === "help") {
-    await showUsage(command, parserOptions);
-    if (autoExit) process.exit(0);
-    return;
-  }
-  await relinkaConfig;
-  if (checkHelp(rawArgv)) {
-    await showUsage(command, parserOptions);
-    if (autoExit) process.exit(0);
-    return;
-  }
-  if (checkVersion(rawArgv)) {
-    if (command.meta?.name) {
+    const rawArgv = process.argv.slice(2);
+    const autoExit = parserOptions.autoExit !== false;
+    if (!(parserOptions.fileBasedCmds?.enable || command.commands && Object.keys(command.commands).length > 0 || command.run)) {
       relinka(
-        "info",
-        `${command.meta?.name} ${command.meta?.version ? `v${command.meta?.version}` : ""}`
+        "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 (autoExit) process.exit(0);
-    return;
-  }
-  const fileBasedEnabled = parserOptions.fileBasedCmds?.enable;
-  if (fileBasedEnabled && rawArgv.length > 0 && !isFlag(rawArgv[0])) {
-    const [subName, ...subCmdArgv] = rawArgv;
-    try {
-      if (typeof command.setup === "function") await command.setup();
-      await runFileBasedSubCmd(
-        subName,
-        subCmdArgv,
-        parserOptions.fileBasedCmds,
-        parserOptions,
-        command.cleanup
-      );
+    if (rawArgv[0] === "help") {
+      await showUsage(command, parserOptions);
       if (autoExit) process.exit(0);
       return;
-    } catch (err) {
-      relinka("error", "Error loading file-based subcommand:", err.message);
-      if (autoExit) process.exit(1);
-      throw err;
     }
-  }
-  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) {
-        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 subcommand ${key}:`, err);
+    await relinkaConfig;
+    if (checkHelp(rawArgv)) {
+      await showUsage(command, parserOptions);
+      if (autoExit) process.exit(0);
+      return;
+    }
+    if (checkVersion(rawArgv)) {
+      if (command.meta?.name) {
+        relinka(
+          "log",
+          `${command.meta?.name} ${command.meta?.version ? `v${command.meta?.version}` : ""}`
+        );
       }
+      if (autoExit) process.exit(0);
+      return;
     }
-    if (subSpec) {
+    const fileBasedEnabled = parserOptions.fileBasedCmds?.enable;
+    if (fileBasedEnabled && rawArgv.length > 0 && !isFlag(rawArgv[0])) {
+      const [subName, ...subCmdArgv] = rawArgv;
       try {
-        if (typeof command.setup === "function") await command.setup();
-        await runSubCommand(
-          subSpec,
+        if (typeof command.onCmdStart === "function")
+          await command.onCmdStart();
+        await runFileBasedSubCmd(
+          subName,
           subCmdArgv,
+          parserOptions.fileBasedCmds,
           parserOptions,
-          command.cleanup
+          command.onCmdEnd
         );
         if (autoExit) process.exit(0);
         return;
       } catch (err) {
-        relinka("error", "Error running subcommand:", err.message);
+        relinka("error", "Error loading file-based subcommand:", err.message);
         if (autoExit) process.exit(1);
         throw err;
       }
     }
-  }
-  if (typeof command.setup === "function") await command.setup();
-  try {
-    await runCommandWithArgs(command, rawArgv, parserOptions);
+    if (!fileBasedEnabled && command.commands && rawArgv.length > 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) {
+        try {
+          if (typeof command.onCmdStart === "function")
+            await command.onCmdStart();
+          await runSubCommand(
+            subSpec,
+            subCmdArgv,
+            parserOptions,
+            command.onCmdEnd
+          );
+          if (autoExit) process.exit(0);
+          return;
+        } catch (err) {
+          relinka("error", "Error running subcommand:", err.message);
+          if (autoExit) process.exit(1);
+          throw err;
+        }
+      }
+    }
+    try {
+      await runCommandWithArgs(command, rawArgv, parserOptions);
+    } finally {
+    }
+    await relinkaShutdown();
   } finally {
-    if (typeof command.cleanup === "function") await command.cleanup();
+    if (typeof command.onLauncherEnd === "function")
+      await command.onLauncherEnd();
   }
-  await relinkaShutdown();
 }
 function checkHelp(argv) {
   return argv.includes("--help") || argv.includes("-h");
@@ -392,7 +421,7 @@ async function loadSubCommand(spec) {
   }
   throw new Error("Subcommand import did not return a valid command");
 }
-async function runFileBasedSubCmd(subName, argv, fileCmdOpts, parserOptions, parentCleanup) {
+async function runFileBasedSubCmd(subName, argv, fileCmdOpts, parserOptions, parentFinish) {
   const subPathDir = path.join(fileCmdOpts.cmdsRootPath, subName);
   let importPath;
   const possibleFiles = [
@@ -447,15 +476,15 @@ Info for this CLI's developer: No valid command directory found, expected: ${exp
   try {
     await runCommandWithArgs(subCommand, argv, parserOptions);
   } finally {
-    if (typeof parentCleanup === "function") await parentCleanup();
+    if (typeof parentFinish === "function") await parentFinish();
   }
 }
-async function runSubCommand(spec, argv, parserOptions, parentCleanup) {
+async function runSubCommand(spec, argv, parserOptions, parentFinish) {
   const subCommand = await loadSubCommand(spec);
   try {
     await runCommandWithArgs(subCommand, argv, parserOptions);
   } finally {
-    if (typeof parentCleanup === "function") await parentCleanup();
+    if (typeof parentFinish === "function") await parentFinish();
   }
 }
 async function runCommandWithArgs(command, argv, parserOptions) {
@@ -540,7 +569,7 @@ async function runCommandWithArgs(command, argv, parserOptions) {
     if (command.run) {
       await command.run(ctx);
     } else {
-      const isDispatcher = parserOptions.fileBasedCmds?.enable || command.subCommands && Object.keys(command.subCommands).length > 0;
+      const isDispatcher = parserOptions.fileBasedCmds?.enable || command.commands && Object.keys(command.commands).length > 0;
       const noSubcommandArgInCurrentCall = !argv.some((arg) => !isFlag(arg));
       if (isDispatcher && noSubcommandArgInCurrentCall) {
         relinka("warn", "Please specify a command");
@@ -608,3 +637,74 @@ function renderPositional(args) {
 export function defineArgs(args) {
   return args;
 }
+export async function runCmd(command, argv = [], parserOptions = {}) {
+  const booleanKeys = Object.keys(command.args || {}).filter(
+    (k) => command.args[k].type === "boolean"
+  );
+  const defaultMap = {};
+  for (const [argKey, def] of Object.entries(command.args || {})) {
+    if (def.default !== void 0) {
+      if (def.type === "array" && typeof def.default === "string") {
+        defaultMap[argKey] = [def.default];
+      } else {
+        defaultMap[argKey] = def.default;
+      }
+    }
+  }
+  const mergedParserOptions = {
+    ...parserOptions,
+    boolean: [...parserOptions.boolean || [], ...booleanKeys],
+    defaults: { ...defaultMap, ...parserOptions.defaults || {} }
+  };
+  const parsed = reliArgParser(argv, mergedParserOptions);
+  debugLog("Parsed arguments (runCmd):", parsed);
+  const finalArgs = {};
+  const positionalKeys = Object.keys(command.args || {}).filter(
+    (k) => command.args[k].type === "positional"
+  );
+  const leftoverPositionals = [...parsed._ || []];
+  for (let i = 0; i < positionalKeys.length; i++) {
+    const key = positionalKeys[i];
+    const def = command.args?.[key];
+    const val = leftoverPositionals[i];
+    if (val == null && def.required) {
+      throw new Error(`Missing required positional argument: <${key}>`);
+    }
+    finalArgs[key] = val != null ? castArgValue(def, val, key) : def.default;
+  }
+  const otherKeys = Object.keys(command.args || {}).filter(
+    (k) => command.args[k].type !== "positional"
+  );
+  for (const key of otherKeys) {
+    const def = command.args?.[key];
+    let rawVal = parsed[key];
+    if (def.type === "array" && rawVal !== void 0 && !Array.isArray(rawVal)) {
+      rawVal = [rawVal];
+    }
+    const valueOrDefault = rawVal ?? defaultMap[key];
+    if (valueOrDefault == null && def.required) {
+      throw new Error(`Missing required argument: --${key}`);
+    }
+    finalArgs[key] = castArgValue(def, rawVal, key);
+    if (def.type === "array" && def.options && finalArgs[key]) {
+      const values = finalArgs[key];
+      const invalidOptions = values.filter(
+        (v) => def.options && !def.options.includes(v)
+      );
+      if (invalidOptions.length > 0) {
+        throw new Error(
+          `Invalid choice(s) for --${key}: ${invalidOptions.join(", ")}. Allowed options: ${def.options.join(", ")}`
+        );
+      }
+    }
+  }
+  const ctx = {
+    args: finalArgs,
+    raw: argv
+  };
+  if (typeof command.run === "function") {
+    await command.run(ctx);
+  } else {
+    throw new Error("Command has no run() handler.");
+  }
+}

package/bin/components/msg-fmt/messages.js

@@ -21,7 +21,10 @@ export const symbols = {
   step_active: u("\u25C6", "\u2666"),
   step_error: u("\u{1F5F4}", "x"),
   info: u("\u2139", "i"),
-  success: u("\u2705", "\u2713")
+  log: u("\u2502", "|"),
+  success: u("\u2705", "\u2713"),
+  warn: u("\u26A0", "!"),
+  error: u("\u274C", "x")
 };
 function wrapThenStyle(input, wrap, typographyName, colorName, variantName, borderColor) {
   if (!input) return "";
@@ -309,8 +312,8 @@ export function msgUndoAll() {
 }
 export function printLineBar(text, indent = 2) {
   if (text === "") {
-    relinka("info", re.dim("\u2502"));
+    relinka("log", re.dim("\u2502"));
   } else {
-    relinka("info", `${re.dim("\u2502")}${" ".repeat(indent)}${text}`);
+    relinka("log", `${re.dim("\u2502")}${" ".repeat(indent)}${text}`);
   }
 }

package/bin/components/select/multiselect-prompt.js

@@ -86,7 +86,7 @@ function renderPromptUI(params) {
     uiLineCount++;
   }
   if (debug) {
-    relinka("info", "", { optionsCount: options.length });
+    relinka("log", "", { optionsCount: options.length });
   }
   return uiLineCount;
 }

package/bin/components/select/select-prompt.js

@@ -104,7 +104,7 @@ async function renderPromptUI(params) {
     uiLineCount++;
   }
   if (debug) {
-    relinka("info", "", { optionsCount: options.length });
+    relinka("log", "", { optionsCount: options.length });
   }
   return uiLineCount;
 }

package/bin/components/select/toggle-prompt.js

@@ -59,7 +59,7 @@ function renderTogglePrompt(params) {
   msg({ type: "M_NULL", title: displayString });
   uiLineCount++;
   if (debug) {
-    relinka("info", "", {
+    relinka("log", "", {
       selectedIndex,
       displayOptions: options
     });

package/bin/components/st-end/start.js

@@ -50,9 +50,9 @@ export async function startPrompt({
   }
   if (clearConsole) {
     relinka("clear", "");
-    relinka("info", "");
+    relinka("log", "");
   } else {
-    relinka("info", "");
+    relinka("log", "");
   }
   msg({
     type: "M_START",

package/bin/components/visual/ascii-art/ascii-art.js

@@ -9,5 +9,5 @@ export async function createAsciiArt({
     relinka("clear", "");
   }
   const asciiArt = figlet.textSync(message, { font });
-  relinka("info", asciiArt);
+  relinka("log", asciiArt);
 }