@reliverse/rempts 1.7.65 → 2.2.7

package/dist/launcher/registry.js

@@ -0,0 +1,42 @@
+let cachedRegistry = null;
+export const getRegistry = () => cachedRegistry;
+export const setRegistry = (registry) => {
+  cachedRegistry = registry;
+};
+export const clearRegistry = () => {
+  cachedRegistry = null;
+};
+export const resolveCommand = (registry, cmdNameOrAlias) => {
+  const resolvedName = registry.aliases.get(cmdNameOrAlias) ?? cmdNameOrAlias;
+  return resolvedName;
+};
+export const resolveCommandChain = (registry, cmdChain) => {
+  if (cmdChain.length === 0) {
+    throw new Error("Empty command chain");
+  }
+  if (cmdChain.length === 1) {
+    const cmdName = resolveCommand(registry, cmdChain[0]);
+    const node = registry.hierarchy.get(cmdName);
+    if (!node) {
+      throw new Error(`Command not found: ${cmdChain[0]}`);
+    }
+    return { fullPath: [cmdName] };
+  }
+  const parentName = resolveCommand(registry, cmdChain[0]);
+  const childName = resolveCommand(registry, cmdChain[1]);
+  const parentNode = registry.hierarchy.get(parentName);
+  const childNode = registry.hierarchy.get(childName);
+  if (!parentNode) {
+    throw new Error(`Parent command not found: ${cmdChain[0]}`);
+  }
+  if (!childNode || childNode.parent !== parentName) {
+    throw new Error(
+      `Sub-command not found: ${cmdChain[1]} under ${cmdChain[0]}`
+    );
+  }
+  return {
+    parent: parentNode,
+    child: childNode,
+    fullPath: [parentName, childName]
+  };
+};

package/dist/launcher/types.d.ts

@@ -0,0 +1,78 @@
+interface BaseArg {
+    description?: string;
+    aliases?: string[];
+    positional?: boolean;
+}
+type StringArg = BaseArg & {
+    type: "string";
+    required?: boolean;
+    default?: string;
+    allowed?: string[];
+    validate?: (value: string) => boolean | string;
+};
+type BooleanArg = BaseArg & {
+    type: "boolean";
+    required?: boolean;
+    default?: boolean;
+    allowed?: boolean[];
+};
+type NumberArg = BaseArg & {
+    type: "number";
+    required?: boolean;
+    default?: number;
+    allowed?: number[];
+    validate?: (value: number) => boolean | string;
+};
+export type CmdArgDefinition = StringArg | BooleanArg | NumberArg;
+export type CmdArgsSchema = Record<string, CmdArgDefinition>;
+export interface CmdMeta {
+    name: string;
+    description?: string;
+    version?: string;
+    aliases?: string[];
+    examples?: string[];
+}
+export interface CmdDefinition<T extends CmdArgsSchema = CmdArgsSchema> {
+    handler: CmdHandler<T>;
+    args: T;
+    meta: CmdMeta;
+}
+export type CmdHandler<T extends CmdArgsSchema = CmdArgsSchema> = (context: {
+    args: ParsedArgs<T>;
+    parentArgs?: ParsedArgs<any>;
+}) => Promise<void> | void;
+type InferArgType<T extends CmdArgDefinition> = T["type"] extends "string" ? string : T["type"] extends "number" ? number : boolean;
+type InferArgValue<T extends CmdArgDefinition> = T extends {
+    required: true;
+} ? InferArgType<T> : T extends {
+    default: any;
+} ? InferArgType<T> : InferArgType<T> | undefined;
+export type ParsedArgs<T extends CmdArgsSchema> = {
+    [K in keyof T]: InferArgValue<T[K]>;
+};
+export type CmdLoader = () => Promise<CmdDefinition>;
+export type CmdRegistry = Map<string, CmdLoader>;
+export interface CmdMetadata {
+    name: string;
+    description?: string;
+    aliases?: string[];
+    version?: string;
+    examples?: string[];
+}
+export interface CmdNode {
+    name: string;
+    path: string;
+    depth: number;
+    parent?: string;
+    children: Map<string, CmdNode>;
+    loader: CmdLoader;
+    metadata: () => Promise<CmdMetadata>;
+}
+export interface DiscoveryResult {
+    registry: CmdRegistry;
+    aliases: Map<string, string>;
+    metadata: Map<string, () => Promise<CmdMetadata>>;
+    hierarchy: Map<string, CmdNode>;
+    rootCommands: Set<string>;
+}
+export {};

package/dist/launcher/validator.d.ts

@@ -0,0 +1,3 @@
+import type { CmdArgDefinition, CmdArgsSchema } from "./types.js";
+export declare const validateArgValue: (argName: string, value: unknown, definition: CmdArgDefinition) => boolean;
+export declare const validateRequiredArgs: (args: Record<string, unknown>, schema: CmdArgsSchema) => void;

package/dist/launcher/validator.js

@@ -0,0 +1,39 @@
+import { ArgumentValidationError } from "./errors.js";
+export const validateArgValue = (argName, value, definition) => {
+  const expectedType = definition.type === "boolean" ? "boolean" : definition.type === "number" ? "number" : "string";
+  if (typeof value !== expectedType) {
+    throw new ArgumentValidationError(
+      argName,
+      `Expected ${expectedType}, got ${typeof value}`
+    );
+  }
+  if ("allowed" in definition && definition.allowed) {
+    if (!definition.allowed.includes(value)) {
+      const allowedValues = definition.allowed.map((v) => typeof v === "string" ? `"${v}"` : String(v)).join(", ");
+      throw new ArgumentValidationError(
+        argName,
+        `Value must be one of: ${allowedValues}. Got: ${typeof value === "string" ? `"${value}"` : value}`
+      );
+    }
+  }
+  if ("validate" in definition && definition.validate) {
+    const result = definition.validate(value);
+    if (result !== true) {
+      throw new ArgumentValidationError(
+        argName,
+        typeof result === "string" ? result : "Validation failed"
+      );
+    }
+  }
+  return true;
+};
+export const validateRequiredArgs = (args, schema) => {
+  for (const [key, def] of Object.entries(schema)) {
+    if (def.required && !(key in args)) {
+      throw new ArgumentValidationError(
+        key,
+        `Required argument "${key}" is missing`
+      );
+    }
+  }
+};

package/dist/mod.d.ts

@@ -0,0 +1,6 @@
+export * from "./cancel.js";
+export * from "./group.js";
+export * from "./launcher/mod.js";
+export * from "./prompt.js";
+export * from "./selection.js";
+export * from "./spinner.js";

package/dist/mod.js

@@ -0,0 +1,6 @@
+export * from "./cancel.js";
+export * from "./group.js";
+export * from "./launcher/mod.js";
+export * from "./prompt.js";
+export * from "./selection.js";
+export * from "./spinner.js";

package/dist/prompt.d.ts

@@ -0,0 +1,13 @@
+export type InputPromptOptions = {
+    message: string;
+    title?: string;
+    charLimit?: number;
+    required?: boolean;
+    echoMode?: "normal" | "password" | "none";
+    validateOkPrefix?: string;
+    validateErrPrefix?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => boolean | string | null | undefined;
+};
+export declare function inputPrompt(options: InputPromptOptions): Promise<string>;

package/dist/prompt.js

@@ -0,0 +1,53 @@
+import { ptr } from "bun:ffi";
+import { cancel } from "./cancel.js";
+import { symbols } from "./ffi.js";
+import { encode, toStringFromPtr } from "./utils.js";
+function formatPromptText(title, message) {
+  if (title && message) {
+    return `${title}
+\x1B[2m${message}\x1B[0m`;
+  }
+  return message ?? title ?? "";
+}
+export async function inputPrompt(options) {
+  const defaultValue = options.defaultValue;
+  const initialValue = options.initialValue;
+  const originalPromptText = formatPromptText(options.title, options.message);
+  let promptText = originalPromptText;
+  let currentDefaultValue = defaultValue;
+  let currentInitialValue = initialValue;
+  while (true) {
+    const returnedPtr = symbols.CreatePrompt(
+      ptr(encode(promptText)),
+      ptr(encode(options.echoMode || "normal")),
+      ptr(encode(options.validateOkPrefix || "")),
+      ptr(encode(options.validateErrPrefix || "")),
+      ptr(encode(currentDefaultValue || "")),
+      ptr(encode(currentInitialValue || "")),
+      options.required ?? true,
+      options.charLimit || 0
+    );
+    const { value, error } = JSON.parse(toStringFromPtr(returnedPtr));
+    if (error !== "") {
+      if (error === "Cancelled") {
+        if (options.required ?? true) {
+          cancel(error);
+        }
+        return "";
+      }
+      throw new Error(error);
+    }
+    if (!options.validate) {
+      return value;
+    }
+    const validationResult = options.validate(value);
+    if (validationResult === true || validationResult === null || validationResult === void 0) {
+      return value;
+    }
+    const errorMessage = typeof validationResult === "string" ? validationResult : "Invalid input";
+    promptText = `${originalPromptText}
+\u274C ${errorMessage}`;
+    currentDefaultValue = void 0;
+    currentInitialValue = void 0;
+  }
+}

package/dist/selection.d.ts

@@ -0,0 +1,92 @@
+export type SelectionItem<T extends string = string> = {
+    value: T;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+};
+type ExtractValues<T extends readonly SelectionItem[]> = T[number]["value"];
+export type SelectPromptOptions<TOptions extends readonly SelectionItem[] = SelectionItem[]> = {
+    message: string;
+    title?: string;
+    options: TOptions;
+    perPage?: number;
+    headerText?: string;
+    footerText?: string;
+    required?: boolean;
+    autocomplete?: boolean;
+    defaultValue?: string;
+    initialValue?: string;
+};
+export type MultiselectPromptOptions<TOptions extends readonly SelectionItem[] = SelectionItem[]> = {
+    message: string;
+    title?: string;
+    options: TOptions;
+    perPage?: number;
+    headerText?: string;
+    footerText?: string;
+    required?: boolean;
+    autocomplete?: boolean;
+    defaultValue?: string[];
+    initialValue?: string[];
+};
+export type ConfirmPromptOptions = {
+    message: string;
+    title?: string;
+    headerText?: string;
+    footerText?: string;
+    required?: boolean;
+    defaultValue?: boolean;
+    initialValue?: boolean;
+};
+export declare function selectPrompt<T extends string>(options: SelectPromptOptions<readonly SelectionItem<T>[]> & {
+    required: false;
+}): Promise<T | null>;
+export declare function selectPrompt<T extends string>(options: SelectPromptOptions<readonly SelectionItem<T>[]> & {
+    required?: true;
+}): Promise<T>;
+export declare function selectPrompt<const TOptions extends readonly SelectionItem[]>(options: SelectPromptOptions<TOptions> & {
+    required: false;
+}): Promise<ExtractValues<TOptions> | null>;
+export declare function selectPrompt<const TOptions extends readonly SelectionItem[]>(options: SelectPromptOptions<TOptions> & {
+    required?: true;
+}): Promise<ExtractValues<TOptions>>;
+export declare function multiselectPrompt<T extends string>(options: MultiselectPromptOptions<readonly SelectionItem<T>[]> & {
+    required: false;
+}): Promise<T[] | null>;
+export declare function multiselectPrompt<T extends string>(options: MultiselectPromptOptions<readonly SelectionItem<T>[]> & {
+    required?: true;
+}): Promise<T[]>;
+export declare function multiselectPrompt<const TOptions extends readonly SelectionItem[]>(options: MultiselectPromptOptions<TOptions> & {
+    required: false;
+}): Promise<ExtractValues<TOptions>[] | null>;
+export declare function multiselectPrompt<const TOptions extends readonly SelectionItem[]>(options: MultiselectPromptOptions<TOptions> & {
+    required?: true;
+}): Promise<ExtractValues<TOptions>[]>;
+export declare function confirmPrompt(options: ConfirmPromptOptions): Promise<boolean>;
+export type GroupMultiselectPromptOptions<TOptions extends Record<string, readonly SelectionItem[]> = Record<string, readonly SelectionItem[]>> = {
+    message: string;
+    title?: string;
+    options: TOptions;
+    perPage?: number;
+    headerText?: string;
+    footerText?: string;
+    required?: boolean;
+    autocomplete?: boolean;
+    defaultValue?: string[];
+    initialValue?: string[];
+    selectableGroups?: boolean;
+    groupSpacing?: number;
+};
+export declare function groupMultiselectPrompt<T extends string>(options: GroupMultiselectPromptOptions<Record<string, readonly SelectionItem<T>[]>> & {
+    required: false;
+}): Promise<T[] | null>;
+export declare function groupMultiselectPrompt<T extends string>(options: GroupMultiselectPromptOptions<Record<string, readonly SelectionItem<T>[]>> & {
+    required?: true;
+}): Promise<T[]>;
+export declare function groupMultiselectPrompt<const TOptions extends Record<string, readonly SelectionItem[]>>(options: GroupMultiselectPromptOptions<TOptions> & {
+    required: false;
+}): Promise<ExtractValues<TOptions[keyof TOptions]>[] | null>;
+export declare function groupMultiselectPrompt<const TOptions extends Record<string, readonly SelectionItem[]>>(options: GroupMultiselectPromptOptions<TOptions> & {
+    required?: true;
+}): Promise<ExtractValues<TOptions[keyof TOptions]>[]>;
+export {};

package/dist/selection.js

@@ -0,0 +1,191 @@
+import { ptr } from "bun:ffi";
+import { cancel } from "./cancel.js";
+import { symbols } from "./ffi.js";
+import { encode, toStringFromPtr } from "./utils.js";
+function formatPromptText(title, message) {
+  if (title && message) {
+    return `${title}
+\x1B[2m${message}\x1B[0m`;
+  }
+  return message ?? title ?? "";
+}
+export async function selectPrompt(options) {
+  const stringifiedItems = JSON.stringify(
+    options.options.map((item) => {
+      return {
+        value: item.value,
+        label: item.label,
+        hint: item.hint ?? "",
+        disabled: item.disabled ?? false
+      };
+    })
+  );
+  const headerText = options.headerText || formatPromptText(options.title, options.message) || "Select an item: ";
+  const returnedPtr = symbols.CreateSelection(
+    ptr(encode(stringifiedItems)),
+    ptr(encode(headerText)),
+    ptr(encode(options.footerText || "")),
+    options.perPage || 5,
+    options.autocomplete ?? true,
+    ptr(encode(options.defaultValue || "")),
+    ptr(encode(options.initialValue || ""))
+  );
+  const { selectedIndex, error } = JSON.parse(toStringFromPtr(returnedPtr));
+  if (error !== "") {
+    if (error === "Cancelled") {
+      if (options.required ?? true) {
+        cancel(error);
+      }
+      return null;
+    }
+    throw new Error(error);
+  }
+  const index = Number(selectedIndex);
+  const selectedOption = options.options[index];
+  if (!selectedOption) {
+    throw new Error("Invalid selection index");
+  }
+  return selectedOption.value;
+}
+export async function multiselectPrompt(options) {
+  const stringifiedItems = JSON.stringify(
+    options.options.map((item) => {
+      return {
+        value: item.value,
+        label: item.label,
+        hint: item.hint ?? "",
+        disabled: item.disabled ?? false
+      };
+    })
+  );
+  const headerText = options.headerText || formatPromptText(options.title, options.message) || "Select items: ";
+  const preselectedValues = options.initialValue ?? options.defaultValue ?? [];
+  const preselectedValuesJson = JSON.stringify(preselectedValues);
+  const initialCursorValue = preselectedValues.length > 0 ? preselectedValues[0] : "";
+  const returnedPtr = symbols.CreateMultiselect(
+    ptr(encode(stringifiedItems)),
+    ptr(encode(headerText)),
+    ptr(encode(options.footerText || "")),
+    options.perPage || 5,
+    options.autocomplete ?? true,
+    ptr(encode(preselectedValuesJson)),
+    ptr(encode(initialCursorValue))
+  );
+  const { selectedIndices, error } = JSON.parse(
+    toStringFromPtr(returnedPtr)
+  );
+  if (error !== "") {
+    if (error === "Cancelled") {
+      if (options.required ?? true) {
+        cancel(error);
+      }
+      return null;
+    }
+    throw new Error(error);
+  }
+  const indices = selectedIndices.map((idx) => Number(idx));
+  const values = indices.map((index) => options.options[index]?.value).filter((value) => value !== void 0);
+  if (values.length !== indices.length) {
+    throw new Error("Invalid selection indices");
+  }
+  return values;
+}
+export async function confirmPrompt(options) {
+  const promptText = formatPromptText(options.title, options.message);
+  const defaultValue = options.defaultValue !== void 0 ? String(options.defaultValue) : "";
+  const initialValue = options.initialValue !== void 0 ? String(options.initialValue) : "";
+  const returnedPtr = symbols.CreateConfirm(
+    ptr(encode(promptText)),
+    ptr(encode(options.headerText || "")),
+    ptr(encode(options.footerText || "")),
+    ptr(encode(defaultValue)),
+    ptr(encode(initialValue))
+  );
+  const { confirmed, error } = JSON.parse(toStringFromPtr(returnedPtr));
+  if (error !== "") {
+    if (error === "Cancelled") {
+      if (options.required ?? true) {
+        cancel(error);
+      }
+      return options.defaultValue ?? false;
+    }
+    throw new Error(error);
+  }
+  if (confirmed === "") {
+    throw new Error("No confirmation received");
+  }
+  return confirmed === "true";
+}
+export async function groupMultiselectPrompt(options) {
+  const flattenedItems = [];
+  const valueToIndexMap = /* @__PURE__ */ new Map();
+  for (const [groupName, groupItems] of Object.entries(options.options)) {
+    flattenedItems.push({
+      value: `__group__${groupName}`,
+      label: groupName,
+      hint: "",
+      disabled: false,
+      isGroupHeader: true,
+      groupName
+    });
+    for (const item of groupItems) {
+      const index = flattenedItems.length;
+      valueToIndexMap.set(item.value, index);
+      flattenedItems.push({
+        ...item,
+        isGroupHeader: false,
+        groupName
+      });
+    }
+  }
+  const stringifiedItems = JSON.stringify(
+    flattenedItems.map((item) => {
+      return {
+        value: item.value,
+        label: item.label,
+        hint: item.hint ?? "",
+        disabled: item.disabled ?? false,
+        isGroupHeader: item.isGroupHeader,
+        groupName: item.groupName
+      };
+    })
+  );
+  const headerText = options.headerText || formatPromptText(options.title, options.message) || "Select items: ";
+  const preselectedValues = options.initialValue ?? options.defaultValue ?? [];
+  const preselectedValuesJson = JSON.stringify(preselectedValues);
+  const initialCursorValue = preselectedValues.length > 0 ? preselectedValues[0] : "";
+  const returnedPtr = symbols.CreateGroupMultiselect(
+    ptr(encode(stringifiedItems)),
+    ptr(encode(headerText)),
+    ptr(encode(options.footerText || "")),
+    options.perPage || 5,
+    options.autocomplete ?? true,
+    options.selectableGroups ?? false,
+    ptr(encode(preselectedValuesJson)),
+    ptr(encode(initialCursorValue)),
+    options.groupSpacing ?? 0
+  );
+  const { selectedIndices, error } = JSON.parse(
+    toStringFromPtr(returnedPtr)
+  );
+  if (error !== "") {
+    if (error === "Cancelled") {
+      if (options.required ?? true) {
+        cancel(error);
+      }
+      return null;
+    }
+    throw new Error(error);
+  }
+  const indices = selectedIndices.map((idx) => Number(idx));
+  const values = indices.map((index) => {
+    const item = flattenedItems[index];
+    return item && !item.isGroupHeader ? item.value : void 0;
+  }).filter(
+    (value) => value !== void 0
+  );
+  if (values.length !== indices.length) {
+    throw new Error("Invalid selection indices");
+  }
+  return values;
+}

package/dist/spinner.d.ts

@@ -0,0 +1,26 @@
+export type SpinnerIndicator = "timer" | "dots";
+export interface SpinnerOptions {
+    text?: string;
+    indicator?: SpinnerIndicator;
+    frames?: string[];
+    delay?: number;
+    onCancel?: () => void;
+    cancelMessage?: string;
+    errorMessage?: string;
+    successText?: string;
+    failText?: string;
+    prefixText?: string;
+    color?: string;
+    hideCursor?: boolean;
+    silent?: boolean;
+    signal?: AbortSignal;
+}
+export interface SpinnerInstance {
+    start(): SpinnerInstance;
+    stop(): SpinnerInstance;
+    succeed(text?: string): SpinnerInstance;
+    fail(text?: string): SpinnerInstance;
+    updateText(text: string): SpinnerInstance;
+}
+export declare function spinnerPrompt(options?: SpinnerOptions): SpinnerInstance;
+export declare function createSpinner(options?: SpinnerOptions): SpinnerInstance;