@reliverse/rempts 2.2.9 → 2.3.1

package/templates/monorepo/turbo.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "globalDependencies": ["**/.env.*local"],
+  "pipeline": {
+    "build": {
+      "dependsOn": ["^build"],
+      "outputs": ["dist/**", ".next/**", "!.next/cache/**"]
+    },
+    "test": {
+      "dependsOn": ["build"],
+      "outputs": ["coverage/**"],
+      "cache": false
+    },
+    "lint": {
+      "dependsOn": ["^build"]
+    },
+    "typecheck": {
+      "dependsOn": ["^build"]
+    },
+    "dev": {
+      "cache": false,
+      "persistent": true
+    },
+    "clean": {
+      "cache": false
+    }
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Nazar Kornienko (blefnk), Bleverse, Reliverse
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/cleanup.mjs

@@ -1,33 +0,0 @@
-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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-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

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

package/dist/ffi.js

@@ -1,165 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

package/dist/launcher/discovery.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

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