@reliverse/rempts 1.7.48 → 1.7.49

package/dist-npm/bin/mod.mjs

@@ -3120,18 +3120,12 @@ const jiti = createJiti(import.meta.url, {
 const COMMAND_EXTENSIONS = [".ts", ".js"];
 const COMMAND_FILENAMES = ["cmd.ts", "cmd.js"];
 const getCallerDirectory = async () => {
-  if (process$1.env._REMPTS_CALLER_DIR) {
-    if (process$1.env.NODE_ENV === "development") {
-      relinka("verbose", `Using explicit caller directory: ${process$1.env._REMPTS_CALLER_DIR}`);
-    }
-    return process$1.env._REMPTS_CALLER_DIR;
-  }
   const stack = new Error().stack?.split("\n") ?? [];
   const cwd = process$1.cwd();
   if (process$1.env.NODE_ENV === "development") {
-    relinka("verbose", "Stack trace for getCallerDirectory:");
+    relinka("log", "Stack trace for getCallerDirectory:");
     stack.forEach((line, index) => {
-      relinka("verbose", `  [${index}]: ${line.trim()}`);
+      relinka("log", `  [${index}]: ${line.trim()}`);
     });
   }
   for (const line of stack) {
@@ -3139,7 +3133,7 @@ const getCallerDirectory = async () => {
     if (match?.[1]) {
       const filePath = match[1];
       if (process$1.env.NODE_ENV === "development") {
-        relinka("verbose", `Checking file path: ${filePath}`);
+        relinka("log", `Checking file path: ${filePath}`);
       }
       if (!filePath.includes("node_modules") && !filePath.includes("command-runner") && !filePath.includes("command-typed") && !filePath.includes("launcher-mod") && !filePath.includes("launcher-types") && !filePath.endsWith("mod.mjs") && // Skip compiled output
       !filePath.endsWith("mod.js") && // Skip compiled output
@@ -3154,7 +3148,7 @@ const getCallerDirectory = async () => {
               if (await fs.pathExists(packageJsonPath)) {
                 packageRoot = currentDir2;
                 if (process$1.env.NODE_ENV === "development") {
-                  relinka("verbose", `Found package.json at: ${packageRoot}`);
+                  relinka("log", `Found package.json at: ${packageRoot}`);
                 }
                 const cwdPackageJsonPath = resolve(cwd, "package.json");
                 if (await fs.pathExists(cwdPackageJsonPath)) {
@@ -3163,21 +3157,21 @@ const getCallerDirectory = async () => {
                     const cwdPackage = JSON.parse(await fs.readFile(cwdPackageJsonPath, "utf-8"));
                     if (callerPackage.name !== cwdPackage.name || callerPackage.version !== cwdPackage.version) {
                       if (process$1.env.NODE_ENV === "development") {
-                        relinka("verbose", `Using caller package root: ${packageRoot} (${callerPackage.name}@${callerPackage.version})`);
+                        relinka("log", `Using caller package root: ${packageRoot} (${callerPackage.name}@${callerPackage.version})`);
                       }
                       return packageRoot;
                     }
                   } catch {
                     if (resolve(packageRoot) !== resolve(cwd)) {
                       if (process$1.env.NODE_ENV === "development") {
-                        relinka("verbose", `Using caller package root (different path): ${packageRoot}`);
+                        relinka("log", `Using caller package root (different path): ${packageRoot}`);
                       }
                       return packageRoot;
                     }
                   }
                 } else {
                   if (process$1.env.NODE_ENV === "development") {
-                    relinka("verbose", `Using caller package root (no CWD package.json): ${packageRoot}`);
+                    relinka("log", `Using caller package root (no CWD package.json): ${packageRoot}`);
                   }
                   return packageRoot;
                 }
@@ -3191,7 +3185,7 @@ const getCallerDirectory = async () => {
           const resolvedCwd = resolve(cwd);
           if (resolvedFileDir !== resolvedCwd && !resolvedFileDir.startsWith(resolvedCwd)) {
             if (process$1.env.NODE_ENV === "development") {
-              relinka("verbose", `Using caller directory (different from CWD): ${fileDir}`);
+              relinka("log", `Using caller directory (different from CWD): ${fileDir}`);
             }
             return packageRoot || fileDir;
           }
@@ -3207,13 +3201,13 @@ const getCallerDirectory = async () => {
       const filePath = match[1];
       if (filePath.includes("node_modules")) {
         try {
-          const nodeModulesMatch = filePath.match(/(.+\/node_modules\/(?:@[^\/]+\/[^\/]+|[^\/]+))/);
+          const nodeModulesMatch = filePath.match(/(.+\/node_modules\/[^\/]+)/);
           if (nodeModulesMatch?.[1]) {
             const packageDir = nodeModulesMatch[1];
             const packageJsonPath = resolve(packageDir, "package.json");
             if (await fs.pathExists(packageJsonPath)) {
               if (process$1.env.NODE_ENV === "development") {
-                relinka("verbose", `Found command package in node_modules: ${packageDir}`);
+                relinka("log", `Found command package in node_modules: ${packageDir}`);
               }
               return packageDir;
             }
@@ -3230,7 +3224,7 @@ const getCallerDirectory = async () => {
       const packageJsonPath = resolve(currentDir, "package.json");
       if (await fs.pathExists(packageJsonPath)) {
         if (process$1.env.NODE_ENV === "development") {
-          relinka("verbose", `Found package.json at: ${currentDir}`);
+          relinka("log", `Found package.json at: ${currentDir}`);
         }
         return currentDir;
       }
@@ -3239,17 +3233,38 @@ const getCallerDirectory = async () => {
     currentDir = dirname(currentDir);
   }
   if (process$1.env.NODE_ENV === "development") {
-    relinka("verbose", `No suitable caller found, using cwd: ${cwd}`);
+    relinka("log", `No suitable caller found, using cwd: ${cwd}`);
   }
   return process$1.cwd();
 };
+const getNodeModulesPackageDirsFromStack = async () => {
+  const stack = new Error().stack?.split("\n") ?? [];
+  const packageDirs = /* @__PURE__ */ new Set();
+  for (const line of stack) {
+    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
+    if (!match?.[1]) continue;
+    const filePath = match[1];
+    if (!filePath.includes("node_modules")) continue;
+    try {
+      const nodeModulesMatch = filePath.match(/(.+\\node_modules\\(?:@[^\\/]+\\)?[^\\/]+)|(.+\/node_modules\/(?:@[^\/]+\/)?[^\/]+)/);
+      const packageDir = (nodeModulesMatch?.[1] || nodeModulesMatch?.[2])?.trim();
+      if (!packageDir) continue;
+      const packageJsonPath = resolve(packageDir, "package.json");
+      if (await fs.pathExists(packageJsonPath)) {
+        packageDirs.add(packageDir);
+      }
+    } catch {
+    }
+  }
+  return Array.from(packageDirs);
+};
 const tryLoadCommand = async (path) => {
   if (!await fs.pathExists(path)) return null;
   try {
     const cmd = await jiti.import(path, { default: true });
     return cmd;
   } catch {
-    relinka("verbose", `Failed to load ${path} as a command file`);
+    relinka("log", `Failed to load ${path} as a command file`);
     return null;
   }
 };
@@ -3350,42 +3365,51 @@ async function loadCommand(cmdPath) {
     const normalizedPath = cmdPath.replace(/^\.\//, "");
     const resolvedPath = resolve(callerDir, normalizedPath);
     if (process$1.env.NODE_ENV === "development") {
-      relinka("verbose", `Loading command: ${cmdPath}`);
-      relinka("verbose", `Caller directory: ${callerDir}`);
-      relinka("verbose", `Normalized path: ${normalizedPath}`);
-      relinka("verbose", `Resolved path: ${resolvedPath}`);
-    }
-    const candidatePaths = await generateCandidatePaths(resolvedPath);
-    if (process$1.env.NODE_ENV === "development") {
-      relinka("verbose", `Candidate paths: ${candidatePaths.join(", ")}`);
-    }
-    for (const path of candidatePaths) {
-      const command = await tryLoadCommand(path);
-      if (command) {
-        if (process$1.env.NODE_ENV === "development") {
-          relinka("verbose", `Successfully loaded command from: ${path}`);
+      relinka("log", `Loading command: ${cmdPath}`);
+      relinka("log", `Caller directory: ${callerDir}`);
+      relinka("log", `Normalized path: ${normalizedPath}`);
+      relinka("log", `Resolved path: ${resolvedPath}`);
+    }
+    const searchedPaths = [];
+    const baseDirs = [callerDir];
+    const stackPackageDirs = await getNodeModulesPackageDirsFromStack();
+    for (const dir of stackPackageDirs) {
+      if (!baseDirs.includes(dir)) baseDirs.push(dir);
+    }
+    for (const baseDir of baseDirs) {
+      const alternativePaths = await generateAlternativePaths(cmdPath, baseDir);
+      if (process$1.env.NODE_ENV === "development") {
+        relinka("log", `Trying alternative paths in base ${baseDir}: ${alternativePaths.join(", ")}`);
+      }
+      searchedPaths.push(...alternativePaths);
+      for (const path of alternativePaths) {
+        const command = await tryLoadCommand(path);
+        if (command) {
+          if (process$1.env.NODE_ENV === "development") {
+            relinka("log", `Successfully loaded command from alternative path: ${path}`);
+          }
+          return command;
         }
-        return command;
       }
     }
-    let allSearchedPaths = [...candidatePaths];
-    if (callerDir !== process$1.cwd()) {
-      const alternativePaths = await generateAlternativePaths(cmdPath, callerDir);
-      allSearchedPaths.push(...alternativePaths);
+    const looksLikeExplicitPath = /[\\\/]|\.ts$|\.js$/.test(normalizedPath);
+    if (looksLikeExplicitPath) {
+      const candidatePaths = await generateCandidatePaths(resolvedPath);
       if (process$1.env.NODE_ENV === "development") {
-        relinka("verbose", `Trying alternative paths: ${alternativePaths.join(", ")}`);
+        relinka("log", `Candidate paths: ${candidatePaths.join(", ")}`);
       }
-      for (const path of alternativePaths) {
+      searchedPaths.push(...candidatePaths);
+      for (const path of candidatePaths) {
         const command = await tryLoadCommand(path);
         if (command) {
           if (process$1.env.NODE_ENV === "development") {
-            relinka("verbose", `Successfully loaded command from alternative path: ${path}`);
+            relinka("log", `Successfully loaded command from: ${path}`);
           }
           return command;
         }
       }
     }
-    throw createCommandNotFoundError(cmdPath, allSearchedPaths);
+    throw createCommandNotFoundError(cmdPath, searchedPaths);
   } catch (error) {
     if (error instanceof Error && error.message.includes("No command file found")) {
       throw error;
@@ -6453,9 +6477,8 @@ function argsToStringArray(args) {
 }
 async function createCallCmd() {
   return async function callCmd(cmdName, args) {
-    const originalCaller = await getOriginalCallerDirectory();
     try {
-      const command = await loadCommandWithCaller(cmdName, originalCaller);
+      const command = await loadCommand(cmdName);
       const stringArgs = args ? argsToStringArray(args) : [];
       await runCmd(command, stringArgs);
     } catch (error) {
@@ -6466,8 +6489,7 @@ async function createCallCmd() {
 }
 async function createGetTypedCmd() {
   return async function getTypedCmd(cmdName) {
-    const originalCaller = await getOriginalCallerDirectory();
-    const command = await loadCommandWithCaller(cmdName, originalCaller);
+    const command = await loadCommand(cmdName);
     return {
       command,
       run: async (args) => {
@@ -6478,9 +6500,8 @@ async function createGetTypedCmd() {
   };
 }
 async function callCmdImpl(cmdName, args) {
-  const originalCaller = await getOriginalCallerDirectory();
   try {
-    const command = await loadCommandWithCaller(cmdName, originalCaller);
+    const command = await loadCommand(cmdName);
     const stringArgs = args ? argsToStringArray(args) : [];
     await runCmd(command, stringArgs);
   } catch (error) {
@@ -6488,89 +6509,8 @@ async function callCmdImpl(cmdName, args) {
     throw error;
   }
 }
-async function getOriginalCallerDirectory() {
-  const stack = new Error().stack?.split("\n") ?? [];
-  const cwd = process.cwd();
-  for (const line of stack) {
-    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-    if (match?.[1]) {
-      const filePath = match[1];
-      if (!filePath.includes("node_modules") && !filePath.includes("command-runner") && !filePath.includes("command-typed") && // Skip this current file
-      !filePath.includes("launcher-mod") && !filePath.includes("launcher-types") && !filePath.endsWith("mod.mjs") && !filePath.endsWith("mod.js") && !filePath.endsWith("mod.ts")) {
-        try {
-          const fileDir = dirname(filePath);
-          let currentDir = fileDir;
-          while (currentDir !== dirname(currentDir)) {
-            try {
-              const packageJsonPath = resolve(currentDir, "package.json");
-              if (await fs.pathExists(packageJsonPath)) {
-                const cwdPackageJsonPath = resolve(cwd, "package.json");
-                if (await fs.pathExists(cwdPackageJsonPath)) {
-                  try {
-                    const callerPackage = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
-                    const cwdPackage = JSON.parse(await fs.readFile(cwdPackageJsonPath, "utf-8"));
-                    if (callerPackage.name !== cwdPackage.name) {
-                      return currentDir;
-                    }
-                  } catch {
-                    if (resolve(currentDir) !== resolve(cwd)) {
-                      return currentDir;
-                    }
-                  }
-                } else {
-                  return currentDir;
-                }
-                break;
-              }
-            } catch {
-            }
-            currentDir = dirname(currentDir);
-          }
-        } catch {
-          continue;
-        }
-      }
-    }
-  }
-  for (const line of stack) {
-    const match = /\((.*):(\d+):(\d+)\)/.exec(line) || /at (.*):(\d+):(\d+)/.exec(line);
-    if (match?.[1]) {
-      const filePath = match[1];
-      if (filePath.includes("node_modules")) {
-        try {
-          const nodeModulesMatch = filePath.match(/(.+\/node_modules\/(?:@[^\/]+\/[^\/]+|[^\/]+))/);
-          if (nodeModulesMatch?.[1]) {
-            const packageDir = nodeModulesMatch[1];
-            const packageJsonPath = resolve(packageDir, "package.json");
-            if (await fs.pathExists(packageJsonPath)) {
-              return packageDir;
-            }
-          }
-        } catch {
-          continue;
-        }
-      }
-    }
-  }
-  return cwd;
-}
-async function loadCommandWithCaller(cmdPath, callerDir) {
-  const originalEnvVar = process.env._REMPTS_CALLER_DIR;
-  process.env._REMPTS_CALLER_DIR = callerDir;
-  try {
-    const command = await loadCommand(cmdPath);
-    return command;
-  } finally {
-    if (originalEnvVar !== void 0) {
-      process.env._REMPTS_CALLER_DIR = originalEnvVar;
-    } else {
-      delete process.env._REMPTS_CALLER_DIR;
-    }
-  }
-}
 async function getTypedCmdImpl(cmdName) {
-  const originalCaller = await getOriginalCallerDirectory();
-  const command = await loadCommandWithCaller(cmdName, originalCaller);
+  const command = await loadCommand(cmdName);
   return {
     command,
     run: async (args) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@reliverse/rempts",
   "author": "reliverse",
-  "version": "1.7.48",
+  "version": "1.7.49",
   "type": "module",
   "license": "MIT",
   "main": "./dist-npm/bin/mod.mjs",