@reliverse/rempts 1.7.24 → 1.7.25

package/bin/components/launcher/run-command.js

@@ -8,58 +8,71 @@ const jiti = createJiti(import.meta.url, {
   fsCache: true,
   sourceMaps: true
 });
+const COMMAND_EXTENSIONS = [".ts", ".js"];
+const COMMAND_FILENAMES = ["cmd.ts", "cmd.js"];
+const getCallerDirectory = () => {
+  const stack = new Error().stack?.split("\n") ?? [];
+  for (const line of stack) {
+    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
+    if (match?.[1] && !match[1].includes("run-command")) {
+      return dirname(match[1]);
+    }
+  }
+  return process.cwd();
+};
+const tryLoadCommand = async (path) => {
+  if (!await fs.pathExists(path)) return null;
+  try {
+    relinka("verbose", `Attempting to load command from: ${path}`);
+    const cmd = await jiti.import(path, { default: true });
+    relinka("verbose", `Successfully loaded command from: ${path}`);
+    return cmd;
+  } catch {
+    relinka("verbose", `Failed to load ${path} as a command file`);
+    return null;
+  }
+};
+const generateCandidatePaths = async (resolvedPath) => {
+  if (!await fs.pathExists(resolvedPath)) {
+    return COMMAND_EXTENSIONS.map((ext) => `${resolvedPath}${ext}`);
+  }
+  if (await fs.isDirectory(resolvedPath)) {
+    return COMMAND_FILENAMES.map((filename) => resolve(resolvedPath, filename));
+  }
+  return [resolvedPath];
+};
+const createCommandNotFoundError = (cmdPath, searchedPaths) => new Error(
+  `No command file found for "${cmdPath}". Expected to find either:
+  - A valid command file at the specified path
+  - A directory containing cmd.ts or cmd.js  
+  - A file path that can be resolved with .ts or .js extension
+Searched paths: ${searchedPaths.join(", ")}
+Please ensure one of these exists and exports a default command.`
+);
+const createLoadError = (cmdPath, originalError) => new Error(
+  `Failed to load command from "${cmdPath}"
+For developers: Ensure the command file:
+  - Exists and is accessible
+  - Exports a default command (e.g., export default defineCommand({...}))
+  - Is a valid TypeScript/JavaScript module
+Original error: ${originalError instanceof Error ? originalError.message : String(originalError)}`
+);
 export async function loadCommand(cmdPath) {
   try {
-    const err = new Error();
-    const stack = err.stack?.split("\n");
-    let callerFile;
-    if (stack) {
-      for (const line of stack) {
-        const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-        if (match?.[1] && !match[1].includes("run-command")) {
-          callerFile = match[1];
-          break;
-        }
-      }
-    }
-    const callerDir = callerFile ? dirname(callerFile) : process.cwd();
+    const callerDir = getCallerDirectory();
     const normalizedPath = cmdPath.replace(/^\.\//, "");
     const resolvedPath = resolve(callerDir, normalizedPath);
-    if (!resolvedPath.endsWith("cmd.ts") && !resolvedPath.endsWith("cmd.js")) {
-      const possiblePaths = [
-        resolve(resolvedPath, "cmd.ts"),
-        resolve(resolvedPath, "cmd.js")
-      ];
-      for (const path of possiblePaths) {
-        if (await fs.pathExists(path)) {
-          relinka("verbose", `Loading command from: ${path}`);
-          const cmd2 = await jiti.import(path, { default: true });
-          relinka("verbose", `Successfully loaded command from: ${path}`);
-          return cmd2;
-        }
-      }
-      throw new Error(
-        `No command file found in ${resolvedPath}. Expected to find either:
-  - ${possiblePaths[0]}
-  - ${possiblePaths[1]}
-Please ensure one of these files exists and exports a default command.`
-      );
+    const candidatePaths = await generateCandidatePaths(resolvedPath);
+    for (const path of candidatePaths) {
+      const command = await tryLoadCommand(path);
+      if (command) return command;
     }
-    relinka("verbose", `Loading command from: ${resolvedPath}`);
-    const cmd = await jiti.import(resolvedPath, { default: true });
-    relinka("verbose", `Successfully loaded command from: ${resolvedPath}`);
-    return cmd;
+    throw createCommandNotFoundError(cmdPath, candidatePaths);
   } catch (error) {
     if (error instanceof Error && error.message.includes("No command file found")) {
       throw error;
     }
     relinka("error", `Failed to load command from ${cmdPath}:`, error);
-    throw new Error(
-      `Failed to load command from ${cmdPath}:
-  - Make sure the file exists and is accessible
-  - Ensure the file exports a default command
-  - Check that the file is a valid TypeScript/JavaScript module
-Original error: ${error instanceof Error ? error.message : String(error)}`
-    );
+    throw createLoadError(cmdPath, error);
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
     "@figliolia/chalk-animation": "^1.0.4",
-    "@reliverse/pathkit": "^1.2.1",
+    "@reliverse/pathkit": "^1.3.3",
     "@reliverse/reliarg": "^1.0.3",
     "@reliverse/relico": "^1.1.2",
     "@reliverse/relifso": "^1.4.5",
@@ -29,7 +29,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.24",
+  "version": "1.7.25",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",