@reliverse/rempts 1.6.2 → 1.7.0

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

@@ -0,0 +1,610 @@
+import { reliArgParser } from "@reliverse/reliarg";
+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 = [];
+  const positionalKeys = Object.keys(args).filter(
+    (k) => args[k].type === "positional"
+  );
+  positionalKeys.forEach((key) => {
+    const def = args[key];
+    if (def.required || Math.random() > 0.5) {
+      parts.push(String(def.default ?? `<${key}>`));
+    }
+  });
+  const otherKeys = Object.keys(args).filter(
+    (k) => args[k].type !== "positional"
+  );
+  for (const key of otherKeys) {
+    const def = args[key];
+    if (def.required || Math.random() > 0.7) {
+      switch (def.type) {
+        case "boolean":
+          if (def.default === true) {
+            if (Math.random() > 0.5) parts.push(`--no-${key}`);
+          } else {
+            parts.push(`--${key}`);
+          }
+          break;
+        case "string":
+          parts.push(`--${key}=${String(def.default ?? key)}`);
+          break;
+        case "number":
+          parts.push(`--${key}=${String(def.default ?? 42)}`);
+          break;
+        case "array":
+          if (def.options && def.options.length > 0) {
+            parts.push(`--${key}=${String(def.options[0])}`);
+          } else {
+            parts.push(`--${key}=${String(key)}`);
+          }
+          break;
+      }
+    }
+  }
+  return parts.join(" ");
+}
+const isDebugMode = process.argv.includes("--debug");
+function debugLog(...args) {
+  if (isDebugMode) {
+    relinka("info", "[DEBUG]", ...args);
+  }
+}
+function isFlag(str) {
+  return str.startsWith("-");
+}
+export function defineCommand(options) {
+  return {
+    meta: options.meta,
+    args: options.args || {},
+    run: options.run,
+    subCommands: options.subCommands,
+    setup: options.setup,
+    cleanup: options.cleanup
+  };
+}
+let _cachedDefaultCliName;
+let _cachedDefaultCliVersion;
+async function getDefaultCliNameAndVersion() {
+  if (_cachedDefaultCliName)
+    return { name: _cachedDefaultCliName, version: _cachedDefaultCliVersion };
+  try {
+    const pkg = await readPackageJSON();
+    let name = pkg.name || "cli";
+    if (name.startsWith("@")) {
+      name = name.split("/").pop() || name;
+    }
+    _cachedDefaultCliName = name;
+    _cachedDefaultCliVersion = pkg.version;
+    return { name, version: pkg.version };
+  } catch (_e) {
+    return { name: "cli", version: void 0 };
+  }
+}
+export async function showUsage(command, parserOptions = {}, displayNotFoundMessage) {
+  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}` : ""}`);
+  if (parserOptions.metaSettings?.showDescriptionOnMain) {
+    let description = command.meta?.description;
+    if (!description) {
+      try {
+        const pkg = await readPackageJSON();
+        if (pkg.description) description = pkg.description;
+      } catch (_e) {
+      }
+    }
+    if (description) {
+      relinka("log", description);
+    }
+  }
+  const fileCmds = parserOptions.fileBasedCmds;
+  if (fileCmds?.enable) {
+    const usageLine = `Usage: ${cliName} <command> [command's options]`;
+    relinka("log", usageLine);
+    try {
+      const commandsDir = path.resolve(fileCmds.cmdsRootPath);
+      const items = await fs.readdir(commandsDir, {
+        withFileTypes: true
+      });
+      const subCommandNames = [];
+      const subCommandDefs = [];
+      for (const dirent of items) {
+        if (dirent.isDirectory()) {
+          const name = dirent.name;
+          const cmdTs = path.join(commandsDir, name, "cmd.ts");
+          const cmdJs = path.join(commandsDir, name, "cmd.js");
+          let imported;
+          try {
+            if (await fs.pathExists(cmdTs)) {
+              imported = await import(path.resolve(cmdTs));
+            } else if (await fs.pathExists(cmdJs)) {
+              imported = await import(path.resolve(cmdJs));
+            } else {
+              continue;
+            }
+            if (imported.default && !imported.default.meta?.hidden) {
+              subCommandNames.push(name);
+              subCommandDefs.push({ name, def: imported.default });
+            }
+          } catch (err) {
+            debugLog(`Skipping file-based subcommand in ${name}:`, err);
+          }
+        }
+      }
+      if (subCommandDefs.length > 0) {
+        const randomIdx = Math.floor(Math.random() * subCommandDefs.length);
+        const { name: exampleCmd, def: exampleDef } = subCommandDefs[randomIdx];
+        const exampleArgs = buildExampleArgs(exampleDef.args || {});
+        relinka(
+          "log",
+          `Example: ${cliName} ${exampleCmd}${exampleArgs ? ` ${exampleArgs}` : ""}`
+        );
+      }
+      if (subCommandNames.length > 0) {
+        relinka("info", "Available commands (run with `help` to see more):");
+        subCommandDefs.forEach(({ name, def }) => {
+          const desc = def?.meta?.description ?? "";
+          relinka("log", `\u2022 ${name}${desc ? ` | ${desc}` : ""}`);
+        });
+      }
+    } catch (err) {
+      if (displayNotFoundMessage) {
+        relinka(
+          "warn",
+          `No file-based subcommands found in ${fileCmds.cmdsRootPath}`
+        );
+      }
+      debugLog("Error reading file-based commands:", err);
+    }
+  } else {
+    const subCommandNames = [];
+    const subCommandDefs = [];
+    if (command.subCommands) {
+      for (const [name, spec] of Object.entries(command.subCommands)) {
+        try {
+          const cmd = await loadSubCommand(spec);
+          if (!cmd?.meta?.hidden) {
+            const aliasDisplay = cmd.meta.aliases ? ` (aliases: ${cmd.meta.aliases.join(", ")})` : "";
+            subCommandNames.push(`${name}${aliasDisplay}`);
+            subCommandDefs.push({ name, def: cmd });
+          }
+        } catch (err) {
+          debugLog(`Error loading subcommand ${name}:`, err);
+        }
+      }
+    }
+    let usageLine = cliName;
+    if (subCommandNames.length > 0) {
+      usageLine += " <command> [command's options]";
+    } else {
+      usageLine += ` [command's options] ${renderPositional(command.args)}`;
+    }
+    relinka("log", `Usage: ${usageLine}`);
+    if (subCommandDefs.length > 0) {
+      const randomIdx = Math.floor(Math.random() * subCommandDefs.length);
+      const { name: exampleCmd, def: exampleDef } = subCommandDefs[randomIdx];
+      const exampleArgs = buildExampleArgs(exampleDef.args || {});
+      relinka(
+        "log",
+        `Example: ${cliName} ${exampleCmd}${exampleArgs ? ` ${exampleArgs}` : ""}`
+      );
+    }
+    if (subCommandNames.length > 0) {
+      relinka("info", "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", "\u2022 -h, --help    | Show help");
+  relinka("log", "\u2022 -v, --version | Show version");
+  relinka("log", "\u2022 --debug       | Enable debug mode");
+  for (const [key, def] of Object.entries(command.args || {})) {
+    if (def.type === "positional") {
+      relinka(
+        "log",
+        `\u2022 <${key}>   | ${def.description ?? ""}${def.required ? " | required" : ""}`
+      );
+    } else {
+      const parts = [
+        `\u2022 --${key}${"alias" in def && def.alias ? `, -${def.alias}` : ""}`,
+        def.description ?? "",
+        `type=${def.type}`
+      ];
+      if (def.default !== void 0)
+        parts.push(`default=${JSON.stringify(def.default)}`);
+      if (def.required) parts.push("required");
+      if (def.type === "array" && def.options)
+        parts.push(`options: ${def.options.join(", ")}`);
+      relinka("log", parts.filter(Boolean).join(" | "));
+    }
+  }
+}
+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 (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.
+Detected: ${callerFile}
+Main entry: ${mainEntry}
+This can cause recursion or unexpected behavior.`
+          );
+          process.exit(1);
+        }
+      }
+    } catch (_e) {
+    }
+    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) {
+      relinka(
+        "info",
+        `${command.meta?.name} ${command.meta?.version ? `v${command.meta?.version}` : ""}`
+      );
+    }
+    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 (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);
+      }
+    }
+    if (subSpec) {
+      try {
+        if (typeof command.setup === "function") await command.setup();
+        await runSubCommand(
+          subSpec,
+          subCmdArgv,
+          parserOptions,
+          command.cleanup
+        );
+        if (autoExit) process.exit(0);
+        return;
+      } catch (err) {
+        relinka("error", "Error running subcommand:", err.message);
+        if (autoExit) process.exit(1);
+        throw err;
+      }
+    }
+  }
+  if (typeof command.setup === "function") await command.setup();
+  try {
+    await runCommandWithArgs(command, rawArgv, parserOptions);
+  } finally {
+    if (typeof command.cleanup === "function") await command.cleanup();
+  }
+  await relinkaShutdown();
+}
+function checkHelp(argv) {
+  return argv.includes("--help") || argv.includes("-h");
+}
+function checkVersion(argv) {
+  return argv.includes("--version") || argv.includes("-v");
+}
+async function loadSubCommand(spec) {
+  if (typeof spec === "string") {
+    const mod = await import(spec);
+    if (!mod.default) {
+      throw new Error(`Subcommand module "${spec}" has no default export`);
+    }
+    return mod.default;
+  }
+  const imported = await spec();
+  if ("default" in imported && imported.default) {
+    return imported.default;
+  }
+  if (imported) {
+    return imported;
+  }
+  throw new Error("Subcommand import did not return a valid command");
+}
+async function runFileBasedSubCmd(subName, argv, fileCmdOpts, parserOptions, parentCleanup) {
+  const subPathDir = path.join(fileCmdOpts.cmdsRootPath, subName);
+  let importPath;
+  const possibleFiles = [
+    // Only allow cmd.{ts,js} inside the subcommand directory
+    path.join(subPathDir, "cmd.js"),
+    path.join(subPathDir, "cmd.ts")
+  ];
+  const dirExists = await fs.pathExists(subPathDir);
+  let isDirCommand = false;
+  if (dirExists) {
+    const stats = await fs.stat(subPathDir);
+    isDirCommand = stats.isDirectory();
+  }
+  if (isDirCommand) {
+    for (const pattern of possibleFiles) {
+      if (await fs.pathExists(pattern)) {
+        importPath = pattern;
+        break;
+      }
+    }
+    if (!importPath) {
+      const attempted = [subName, ...argv].join(" ");
+      const expectedPath = path.relative(
+        process.cwd(),
+        path.join(fileCmdOpts.cmdsRootPath, subName, "cmd.{ts,js}")
+      );
+      throw new Error(
+        `Unknown command or arguments: ${attempted}
+
+Info for this CLI's developer: No valid command directory found, expected: ${expectedPath}`
+      );
+    }
+  } else {
+    const attempted = [subName, ...argv].join(" ");
+    const expectedPath2 = path.relative(
+      process.cwd(),
+      path.join(fileCmdOpts.cmdsRootPath, subName, "cmd.{ts,js}")
+    );
+    throw new Error(
+      `Unknown command or arguments: ${attempted}
+
+Info for this CLI's developer: No valid command directory found, expected: ${expectedPath2}`
+    );
+  }
+  const imported = await import(path.resolve(importPath));
+  const subCommand = imported.default;
+  if (!subCommand) {
+    throw new Error(
+      `File-based subcommand "${subName}" has no default export or is invalid.`
+    );
+  }
+  try {
+    await runCommandWithArgs(subCommand, argv, parserOptions);
+  } finally {
+    if (typeof parentCleanup === "function") await parentCleanup();
+  }
+}
+async function runSubCommand(spec, argv, parserOptions, parentCleanup) {
+  const subCommand = await loadSubCommand(spec);
+  try {
+    await runCommandWithArgs(subCommand, argv, parserOptions);
+  } finally {
+    if (typeof parentCleanup === "function") await parentCleanup();
+  }
+}
+async function runCommandWithArgs(command, argv, parserOptions) {
+  const autoExit = parserOptions.autoExit !== false;
+  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:", 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) {
+      relinka("error", `Missing required positional argument: <${key}>`);
+      await showUsage(command, parserOptions);
+      if (autoExit) process.exit(1);
+      else 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) {
+      relinka("error", `Missing required argument: --${key}`);
+      await showUsage(command, parserOptions);
+      if (autoExit) process.exit(1);
+      else throw new Error(`Missing required argument: --${key}`);
+    }
+    try {
+      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(", ")}`
+          );
+        }
+      }
+    } catch (err) {
+      relinka("error", String(err));
+      if (autoExit) process.exit(1);
+      else throw err;
+    }
+  }
+  const ctx = {
+    args: finalArgs,
+    raw: argv
+  };
+  try {
+    if (command.run) {
+      await command.run(ctx);
+    } else {
+      const isDispatcher = parserOptions.fileBasedCmds?.enable || command.subCommands && Object.keys(command.subCommands).length > 0;
+      const noSubcommandArgInCurrentCall = !argv.some((arg) => !isFlag(arg));
+      if (isDispatcher && noSubcommandArgInCurrentCall) {
+        relinka("warn", "Please specify a command");
+        await showUsage(command, parserOptions, true);
+        if (autoExit) process.exit(0);
+        return;
+      }
+      const cmdName = command.meta?.name || "unknown";
+      const attempted = argv.length > 0 ? argv.join(" ") : "(no arguments)";
+      relinka("error", `Unknown command or arguments: ${attempted}`);
+      await showUsage(command, parserOptions);
+      if (autoExit) {
+        process.exit(1);
+      } else {
+        throw new Error(`Command "${cmdName}" is not runnable.`);
+      }
+    }
+  } catch (err) {
+    relinka("error", `Error while executing command:
+${String(err)}`);
+    if (autoExit) process.exit(1);
+    else throw err;
+  }
+}
+function castArgValue(def, rawVal, argName) {
+  if (rawVal == null) {
+    if (def.type === "array" && typeof def.default === "string") {
+      return [def.default];
+    }
+    return def.default ?? void 0;
+  }
+  switch (def.type) {
+    case "boolean":
+      if (typeof rawVal === "string") {
+        const lower = rawVal.toLowerCase();
+        if (lower === "true") return true;
+        if (lower === "false") return false;
+      }
+      return Boolean(rawVal);
+    case "string":
+      return typeof rawVal === "string" ? rawVal : String(rawVal);
+    case "number": {
+      const n = Number(rawVal);
+      if (Number.isNaN(n)) {
+        throw new Error(`Invalid number provided for --${argName}: ${rawVal}`);
+      }
+      return n;
+    }
+    case "positional":
+      return String(rawVal);
+    case "array": {
+      const arrVal = Array.isArray(rawVal) ? rawVal : [String(rawVal)];
+      return arrVal.map(String);
+    }
+    default:
+      return rawVal;
+  }
+}
+function renderPositional(args) {
+  const positionalKeys = Object.keys(args || {}).filter(
+    (k) => args[k].type === "positional"
+  );
+  return positionalKeys.map((k) => `<${k}>`).join(" ");
+}
+export function defineArgs(args) {
+  return args;
+}

package/bin/{core-impl → components}/msg-fmt/colors.d.ts

@@ -1,4 +1,4 @@
-import type { ColorName, OutputColor, StandardColor } from "../../core-types.js";
+import type { ColorName, OutputColor, StandardColor } from "../../types.js";
 /**
  * Maps complex colors (gradients, bright, background) to standard terminal colors.
  * Used by ora spinners and other terminal utilities that only support basic colors.

package/bin/{core-impl → components}/msg-fmt/logger.d.ts

@@ -1,4 +1,4 @@
-import type { AllKinds, StreamOptions } from "../../core-types.js";
+import type { AllKinds, StreamOptions } from "../../types.js";
 /**
  * Logs messages with configurable styling and formatting.
  * Doesn't support streaming functionality.

package/bin/{core-impl → components}/msg-fmt/logger.js

@@ -1,7 +1,4 @@
-import {
-  streamText,
-  streamTextWithSpinner
-} from "../utils/stream-text.js";
+import { streamText, streamTextWithSpinner } from "../../utils/stream-text.js";
 import { toSolidColor } from "./colors.js";
 import { msg } from "./messages.js";
 const verboseLogging = false;

package/bin/{core-impl → components}/msg-fmt/mapping.d.ts

@@ -1,3 +1,3 @@
-import type { ColorName, TypographyName } from "../../core-types.js";
+import type { ColorName, TypographyName } from "../../types.js";
 export declare const colorMap: Record<ColorName, (text: string) => string>;
 export declare const typographyMap: Record<TypographyName, (text: string) => string>;

package/bin/{core-impl → components}/msg-fmt/messages.d.ts

@@ -1,4 +1,4 @@
-import type { ColorName, FmtMsgOptions, Symbols } from "../../core-types.js";
+import type { ColorName, FmtMsgOptions, Symbols } from "../../types.js";
 export declare const symbols: Symbols;
 /**
  * Returns a colored vertical bar symbol. Prevents gradient colors for bars.

package/bin/{core-impl → components}/msg-fmt/variants.d.ts

@@ -1,4 +1,4 @@
-import type { ColorName, VariantName } from "../../core-types.js";
+import type { ColorName, VariantName } from "../../types.js";
 export declare const variantMap: {
     doubleBox: typeof createDoubleBox;
 };

package/bin/{core-impl → components}/next-steps/next-steps.d.ts

@@ -1,5 +1,5 @@
-import type { TypographyName, ColorName } from "../../core-types.js";
-import type { VariantName } from "../../core-types.js";
+import type { TypographyName, ColorName } from "../../types.js";
+import type { VariantName } from "../../types.js";
 type NextStepsPromptOptions = {
     title?: string;
     titleColor?: ColorName;

package/bin/{core-impl → components}/number/number-mod.d.ts

@@ -1,4 +1,4 @@
-import type { BorderColorName, ColorName, FmtMsgOptions, TypographyName } from "../../core-types.js";
+import type { BorderColorName, ColorName, FmtMsgOptions, TypographyName } from "../../types.js";
 type VariantName = FmtMsgOptions["titleVariant"];
 type NumberPromptOptions = {
     title: string;

package/bin/{core-impl → components}/select/multiselect-prompt.d.ts

@@ -1,2 +1,2 @@
-import type { MultiselectPromptParams } from "../../core-types.js";
+import type { MultiselectPromptParams } from "../../types.js";
 export declare function multiselectPrompt<T extends string>(params: MultiselectPromptParams<T>): Promise<T[]>;

package/bin/{core-impl → components}/select/multiselect-prompt.js

@@ -4,7 +4,7 @@ import { stdin as input, stdout as output } from "node:process";
 import readline from "node:readline";
 import { msg, symbols } from "../msg-fmt/messages.js";
 import { deleteLastLine } from "../msg-fmt/terminal.js";
-import { completePrompt } from "../utils/prompt-end.js";
+import { completePrompt } from "../../utils/prompt-end.js";
 function isSelectOption(option) {
   return !("separator" in option);
 }

package/bin/{core-impl → components}/select/nummultiselect-prompt.d.ts

@@ -1,4 +1,4 @@
-import type { PromptOptions } from "../../core-types.js";
+import type { PromptOptions } from "../../types.js";
 type NumMultiSelectPromptOptions = PromptOptions & {
     defaultValue?: string[];
 };