@reliverse/rempts 1.7.65 → 2.2.7

package/cleanup.mjs

@@ -0,0 +1,33 @@
+import { suffix } from "bun:ffi";
+import fs from "node:fs";
+
+const releasePath = new URL("./release", import.meta.url).pathname;
+
+// Check if release directory exists
+if (!fs.existsSync(releasePath)) {
+  console.log("Release directory does not exist, nothing to clean up.");
+  process.exit(0);
+}
+
+const files = fs.readdirSync(releasePath);
+
+const { platform, arch } = process;
+let filename;
+
+if (arch === "x64") {
+  filename = `rempts-${platform}-amd64.${suffix}`;
+} else {
+  filename = `rempts-${platform}-${arch}.${suffix}`;
+}
+
+files.forEach((file) => {
+  if (file !== filename) {
+    const filePath = `./release/${file}`;
+    try {
+      fs.unlinkSync(filePath);
+      console.log(`Removed: ${file}`);
+    } catch (error) {
+      console.warn(`Failed to remove ${file}:`, error.message);
+    }
+  }
+});

package/dist/cancel.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Custom error class for prompt cancellations
+ */
+export declare class PromptCancelledError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Throws a PromptCancelledError to signal that user cancelled the prompt
+ * @param message - Optional custom cancellation message
+ */
+export declare function cancel(message?: string): never;
+/**
+ * Checks if an error is a cancellation error from a prompt
+ * @param error - The error to check
+ * @returns `true` if the error is a cancellation, `false` otherwise
+ */
+export declare function isCancel(error: unknown): error is PromptCancelledError;
+/**
+ * Exits the process with exit code 0 after logging a cancellation message
+ * @param message - The message to log before exiting (default: "Operation cancelled")
+ */
+export declare function exitCancelled(message?: string): never;
+/**
+ * Sets up a global handler for unhandled PromptCancelledError
+ * This ensures that if a developer doesn't explicitly handle cancellations,
+ * the app will exit cleanly instead of crashing.
+ *
+ * Call this once at the start of your application if you want automatic
+ * cancellation handling.
+ */
+export declare function setupAutoCancelHandler(): void;

package/dist/cancel.js

@@ -0,0 +1,28 @@
+export class PromptCancelledError extends Error {
+  constructor(message = "Cancelled") {
+    super(message);
+    this.name = "PromptCancelledError";
+  }
+}
+export function cancel(message = "Cancelled") {
+  throw new PromptCancelledError(message);
+}
+export function isCancel(error) {
+  return error instanceof PromptCancelledError;
+}
+export function exitCancelled(message = "Operation cancelled") {
+  console.log(message);
+  process.exit(0);
+}
+export function setupAutoCancelHandler() {
+  process.on("unhandledRejection", (reason) => {
+    if (reason instanceof PromptCancelledError) {
+      exitCancelled("Operation cancelled");
+    }
+  });
+  process.on("uncaughtException", (error) => {
+    if (error instanceof PromptCancelledError) {
+      exitCancelled("Operation cancelled");
+    }
+  });
+}

package/dist/ffi.d.ts

@@ -0,0 +1 @@
+export declare const symbols: any;

package/dist/ffi.js

@@ -0,0 +1,165 @@
+import { dlopen, FFIType, suffix } from "bun:ffi";
+import { existsSync } from "node:fs";
+import path from "node:path";
+const { platform, arch } = process;
+function getBinaryLocation() {
+  let filename;
+  if (arch === "x64") {
+    filename = `../release/rempts-${platform}-amd64.${suffix}`;
+  } else {
+    filename = `../release/rempts-${platform}-${arch}.${suffix}`;
+  }
+  return Bun.fileURLToPath(new URL(filename, import.meta.url));
+}
+let cachedSymbols;
+function loadSymbols() {
+  if (cachedSymbols) {
+    return cachedSymbols;
+  }
+  const location = getBinaryLocation();
+  if (!existsSync(location)) {
+    const releaseDir = path.dirname(location);
+    const expectedFile = path.basename(location);
+    let errorMessage = `
+\u274C Native binary not found! (Did you have Docker launched?)
+
+`;
+    errorMessage += `Expected file: ${location}
+
+`;
+    if (!existsSync(releaseDir)) {
+      errorMessage += `The release directory does not exist: ${releaseDir}
+
+`;
+    } else {
+      errorMessage += `The release directory exists but the binary is missing.
+`;
+      errorMessage += `Expected: ${expectedFile}
+
+`;
+    }
+    errorMessage += `To fix this, run:
+`;
+    errorMessage += `  bun run build
+
+`;
+    errorMessage += `Or use native build (no Docker):
+`;
+    errorMessage += `  bun run build --provider native
+`;
+    throw new Error(errorMessage);
+  }
+  try {
+    cachedSymbols = dlopen(location, {
+      CreateSelection: {
+        args: [
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.int,
+          FFIType.bool,
+          FFIType.ptr,
+          FFIType.ptr
+        ],
+        returns: FFIType.ptr
+      },
+      CreatePrompt: {
+        args: [
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.bool,
+          FFIType.int
+        ],
+        returns: FFIType.ptr
+      },
+      CreateMultiselect: {
+        args: [
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.int,
+          FFIType.bool,
+          FFIType.ptr,
+          FFIType.ptr
+        ],
+        returns: FFIType.ptr
+      },
+      CreateConfirm: {
+        args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr],
+        returns: FFIType.ptr
+      },
+      CreateGroupMultiselect: {
+        args: [
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.int,
+          FFIType.bool,
+          FFIType.bool,
+          FFIType.ptr,
+          FFIType.ptr,
+          FFIType.int
+        ],
+        returns: FFIType.ptr
+      },
+      FreeString: {
+        args: [FFIType.ptr],
+        returns: FFIType.void
+      }
+    }).symbols;
+  } catch (error) {
+    let errorMessage = `
+\u274C Failed to load native binary!
+
+`;
+    errorMessage += `File: ${location}
+`;
+    errorMessage += `Error: ${error.message || error}
+
+`;
+    if (error.code === "ERR_DLOPEN_FAILED" || error.errno === 126) {
+      errorMessage += `This usually means:
+`;
+      errorMessage += `  \u2022 The binary is corrupted or incomplete
+`;
+      errorMessage += `  \u2022 Missing dependencies (DLLs, shared libraries)
+`;
+      errorMessage += `  \u2022 Architecture mismatch
+
+`;
+      errorMessage += `Try rebuilding:
+`;
+      errorMessage += `  bun run build
+`;
+    } else {
+      errorMessage += `Please rebuild the native binaries:
+`;
+      errorMessage += `  bun run build
+`;
+    }
+    throw new Error(errorMessage);
+  }
+  return cachedSymbols;
+}
+export const symbols = new Proxy({}, {
+  get(_target, prop) {
+    const symbols2 = loadSymbols();
+    return symbols2[prop];
+  },
+  has(_target, prop) {
+    const symbols2 = loadSymbols();
+    return prop in symbols2;
+  },
+  ownKeys(_target) {
+    const symbols2 = loadSymbols();
+    return Object.keys(symbols2);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    const symbols2 = loadSymbols();
+    return Object.getOwnPropertyDescriptor(symbols2, prop);
+  }
+});

package/dist/group.d.ts

@@ -0,0 +1,16 @@
+import { PromptCancelledError } from "./cancel.js";
+type MaybePromise<T> = T | Promise<T>;
+export interface GroupPromptContext<TResult extends Record<string, unknown>, TKey extends keyof TResult> {
+    key: TKey;
+    results: Readonly<Partial<TResult>>;
+}
+export type GroupPromptHandler<TResult extends Record<string, unknown>, TKey extends keyof TResult> = (context: GroupPromptContext<TResult, TKey>) => MaybePromise<TResult[TKey]>;
+export type GroupPromptHandlers<TResult extends Record<string, unknown>> = {
+    [K in keyof TResult]: GroupPromptHandler<TResult, K>;
+};
+export interface GroupPromptOptions {
+    onCancel?: (error: PromptCancelledError) => MaybePromise<void>;
+}
+export declare function groupPrompt<TResult extends Record<string, unknown>>(handlers: GroupPromptHandlers<TResult>, options?: GroupPromptOptions): Promise<TResult>;
+export declare const group: typeof groupPrompt;
+export {};

package/dist/group.js

@@ -0,0 +1,22 @@
+import { PromptCancelledError } from "./cancel.js";
+export async function groupPrompt(handlers, options) {
+  const results = {};
+  const keys = Object.keys(handlers);
+  for (const key of keys) {
+    const handler = handlers[key];
+    try {
+      const value = await handler({
+        key,
+        results
+      });
+      results[key] = value;
+    } catch (error) {
+      if (error instanceof PromptCancelledError && options?.onCancel) {
+        await options.onCancel(error);
+      }
+      throw error;
+    }
+  }
+  return results;
+}
+export const group = groupPrompt;

package/dist/launcher/command.d.ts

@@ -0,0 +1,8 @@
+import type { CmdArgsSchema, CmdDefinition, CmdHandler, CmdMeta } from "./types.js";
+export declare const defineArgs: <const T extends CmdArgsSchema>(args: T) => T;
+export interface DefineCommandOptions<Args extends CmdArgsSchema, Meta extends CmdMeta> {
+    meta: Meta;
+    args: Args;
+    run: CmdHandler<Args>;
+}
+export declare const defineCommand: <const Args extends CmdArgsSchema, const Meta extends CmdMeta>({ meta, args, run, }: DefineCommandOptions<Args, Meta>) => CmdDefinition<Args>;

package/dist/launcher/command.js

@@ -0,0 +1,10 @@
+export const defineArgs = (args) => args;
+export const defineCommand = ({
+  meta,
+  args,
+  run
+}) => ({
+  handler: run,
+  args,
+  meta
+});

package/dist/launcher/discovery.d.ts

@@ -0,0 +1,3 @@
+import type { CmdDefinition, DiscoveryResult } from "./types.js";
+export declare const discoverCommands: (cmdsDir: string, baseDir?: string, verbose?: boolean) => Promise<DiscoveryResult>;
+export declare const validateCommandStructure: (definition: unknown) => definition is CmdDefinition;

package/dist/launcher/discovery.js

@@ -0,0 +1,207 @@
+import { statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import pMap from "@reliverse/mapkit";
+import { Glob } from "bun";
+import { CommandLoadError } from "./errors.js";
+const createLazyMetadataLoader = (filePath, cmdName) => {
+  return async () => {
+    try {
+      const module = await import(filePath);
+      const definition = module.default;
+      if (!definition || !definition.meta) {
+        throw new Error("Invalid command definition");
+      }
+      return {
+        name: definition.meta.name,
+        description: definition.meta.description,
+        aliases: definition.meta.aliases,
+        version: definition.meta.version,
+        examples: definition.meta.examples
+      };
+    } catch (error) {
+      throw new CommandLoadError(cmdName, error);
+    }
+  };
+};
+const resolveCommandsDirectory = (baseDir, cmdsDir, verbose) => {
+  if (verbose) {
+    console.debug(`\u{1F50D} Resolving commands directory:`);
+    console.debug(`   baseDir: ${baseDir}`);
+    console.debug(`   cmdsDir: ${cmdsDir}`);
+  }
+  if (cmdsDir.startsWith("/") || cmdsDir.includes("\\")) {
+    const resolved = join(baseDir, cmdsDir);
+    if (verbose) {
+      console.debug(`   Using absolute path: ${resolved}`);
+    }
+    return resolved;
+  }
+  const parentDir = dirname(baseDir);
+  const parentSrcPath = join(parentDir, "src", cmdsDir);
+  try {
+    const srcStats = statSync(parentSrcPath);
+    if (srcStats.isDirectory()) {
+      if (verbose) {
+        console.debug(
+          `   \u2705 Found: ${parentSrcPath} (parent src - development)`
+        );
+      }
+      return parentSrcPath;
+    }
+  } catch {
+    if (verbose) {
+      console.debug(`   \u274C Not found: ${parentSrcPath}`);
+    }
+  }
+  const parentDistPath = join(parentDir, "dist", cmdsDir);
+  try {
+    const distStats = statSync(parentDistPath);
+    if (distStats.isDirectory()) {
+      if (verbose) {
+        console.debug(
+          `   \u2705 Found: ${parentDistPath} (parent dist - production)`
+        );
+      }
+      return parentDistPath;
+    }
+  } catch {
+    if (verbose) {
+      console.debug(`   \u274C Not found: ${parentDistPath}`);
+    }
+  }
+  const srcPath = join(baseDir, "src", cmdsDir);
+  try {
+    const srcStats = statSync(srcPath);
+    if (srcStats.isDirectory()) {
+      if (verbose) {
+        console.debug(`   \u2705 Found: ${srcPath} (development)`);
+      }
+      return srcPath;
+    }
+  } catch {
+    if (verbose) {
+      console.debug(`   \u274C Not found: ${srcPath}`);
+    }
+  }
+  const distPath = join(baseDir, "dist", cmdsDir);
+  try {
+    const distStats = statSync(distPath);
+    if (distStats.isDirectory()) {
+      if (verbose) {
+        console.debug(`   \u2705 Found: ${distPath} (production)`);
+      }
+      return distPath;
+    }
+  } catch {
+    if (verbose) {
+      console.debug(`   \u274C Not found: ${distPath}`);
+    }
+  }
+  const fallbackPath = join(baseDir, cmdsDir);
+  try {
+    const fallbackStats = statSync(fallbackPath);
+    if (fallbackStats.isDirectory()) {
+      if (verbose) {
+        console.debug(`   \u2705 Found: ${fallbackPath} (fallback)`);
+      }
+      return fallbackPath;
+    }
+  } catch {
+    if (verbose) {
+      console.debug(`   \u274C Not found: ${fallbackPath}`);
+    }
+  }
+  throw new Error(
+    `Commands directory not found. Checked: ${srcPath}, ${distPath}, ${fallbackPath}`
+  );
+};
+export const discoverCommands = async (cmdsDir, baseDir, verbose) => {
+  const registry = /* @__PURE__ */ new Map();
+  const aliases = /* @__PURE__ */ new Map();
+  const metadata = /* @__PURE__ */ new Map();
+  const hierarchy = /* @__PURE__ */ new Map();
+  const rootCommands = /* @__PURE__ */ new Set();
+  const glob = new Glob("**/cmd.{ts,js}");
+  const actualBaseDir = baseDir || process.cwd();
+  if (verbose) {
+    console.debug(`
+\u{1F50D} Discovering commands:`);
+    console.debug(`   actualBaseDir: ${actualBaseDir}`);
+  }
+  const resolvedCommandsDir = resolveCommandsDirectory(
+    actualBaseDir,
+    cmdsDir,
+    verbose
+  );
+  if (verbose) {
+    console.debug(`   resolvedCommandsDir: ${resolvedCommandsDir}`);
+  }
+  const files = await Array.fromAsync(glob.scan(resolvedCommandsDir));
+  if (verbose) {
+    console.debug(`   Found ${files.length} command files`);
+  }
+  const fileData = await pMap(
+    files,
+    async (file) => {
+      const pathParts = file.split(/[/\\]/);
+      const cmdName = pathParts[pathParts.length - 2];
+      const filePath = `${resolvedCommandsDir}/${file}`;
+      const depth = pathParts.length - 1;
+      const parent = depth > 1 ? pathParts[0] : void 0;
+      const fullPath = pathParts.slice(0, -1).join("/");
+      return {
+        cmdName,
+        filePath,
+        depth,
+        parent,
+        fullPath
+      };
+    },
+    { concurrency: 10 }
+    // Limit concurrency to avoid overwhelming filesystem
+  );
+  for (const { cmdName, filePath, depth, parent, fullPath } of fileData) {
+    const loader = async () => {
+      try {
+        const module = await import(filePath);
+        const definition = module.default;
+        if (!definition || typeof definition.handler !== "function") {
+          throw new Error("Invalid command definition");
+        }
+        return definition;
+      } catch (error) {
+        throw new CommandLoadError(cmdName, error);
+      }
+    };
+    const lazyMetadataLoader = createLazyMetadataLoader(filePath, cmdName);
+    metadata.set(cmdName, lazyMetadataLoader);
+    registry.set(cmdName, loader);
+    const cmdNode = {
+      name: cmdName,
+      path: fullPath,
+      depth,
+      parent,
+      children: /* @__PURE__ */ new Map(),
+      loader,
+      metadata: metadata.get(cmdName)
+    };
+    hierarchy.set(cmdName, cmdNode);
+    if (depth === 1) {
+      rootCommands.add(cmdName);
+    }
+  }
+  for (const [cmdName, node] of hierarchy) {
+    if (node.parent) {
+      const parentNode = hierarchy.get(node.parent);
+      if (parentNode) {
+        parentNode.children.set(cmdName, node);
+      }
+    }
+  }
+  return { registry, aliases, metadata, hierarchy, rootCommands };
+};
+export const validateCommandStructure = (definition) => {
+  if (typeof definition !== "object" || definition === null) return false;
+  const def = definition;
+  return typeof def.handler === "function" && typeof def.args === "object" && def.args !== null && typeof def.meta === "object" && def.meta !== null && typeof def.meta.name === "string";
+};

package/dist/launcher/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class LauncherError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare class CommandNotFoundError extends LauncherError {
+    constructor(cmdName: string, availableCmds: string[]);
+}
+export declare class ArgumentValidationError extends LauncherError {
+    argName: string;
+    reason: string;
+    constructor(argName: string, reason: string);
+}
+export declare class CommandLoadError extends LauncherError {
+    constructor(cmdName: string, cause: unknown);
+}

package/dist/launcher/errors.js

@@ -0,0 +1,31 @@
+export class LauncherError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "LauncherError";
+  }
+}
+export class CommandNotFoundError extends LauncherError {
+  constructor(cmdName, availableCmds) {
+    super(
+      `Command "${cmdName}" not found. Available commands: ${availableCmds.join(", ")}`,
+      "CMD_NOT_FOUND"
+    );
+    this.name = "CommandNotFoundError";
+  }
+}
+export class ArgumentValidationError extends LauncherError {
+  constructor(argName, reason) {
+    super(`Invalid argument "${argName}": ${reason}`, "ARG_VALIDATION_ERROR");
+    this.argName = argName;
+    this.reason = reason;
+    this.name = "ArgumentValidationError";
+  }
+}
+export class CommandLoadError extends LauncherError {
+  constructor(cmdName, cause) {
+    super(`Failed to load command "${cmdName}"`, "CMD_LOAD_ERROR");
+    this.name = "CommandLoadError";
+    this.cause = cause;
+  }
+}

package/dist/launcher/help.d.ts

@@ -0,0 +1,3 @@
+import type { CmdDefinition, DiscoveryResult } from "./types.js";
+export declare const generateCommandHelp: (definition: CmdDefinition) => Promise<string>;
+export declare const generateGlobalHelp: (registry: DiscoveryResult) => Promise<string>;