@reliverse/rempts 1.7.46 → 1.7.48

package/dist-npm/bin/mod.mjs

@@ -3120,6 +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") {
@@ -3135,22 +3141,82 @@ const getCallerDirectory = async () => {
       if (process$1.env.NODE_ENV === "development") {
         relinka("verbose", `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.includes("mod.mjs") && // Skip compiled output
-      !filePath.includes("mod.js") && // Skip compiled output
-      !filePath.includes("mod.ts")) {
+      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
+      !filePath.endsWith("mod.ts")) {
         try {
           const fileDir = dirname(filePath);
+          let currentDir2 = fileDir;
+          let packageRoot = null;
+          while (currentDir2 !== dirname(currentDir2)) {
+            try {
+              const packageJsonPath = resolve(currentDir2, "package.json");
+              if (await fs.pathExists(packageJsonPath)) {
+                packageRoot = currentDir2;
+                if (process$1.env.NODE_ENV === "development") {
+                  relinka("verbose", `Found package.json at: ${packageRoot}`);
+                }
+                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 || callerPackage.version !== cwdPackage.version) {
+                      if (process$1.env.NODE_ENV === "development") {
+                        relinka("verbose", `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}`);
+                      }
+                      return packageRoot;
+                    }
+                  }
+                } else {
+                  if (process$1.env.NODE_ENV === "development") {
+                    relinka("verbose", `Using caller package root (no CWD package.json): ${packageRoot}`);
+                  }
+                  return packageRoot;
+                }
+                break;
+              }
+            } catch {
+            }
+            currentDir2 = dirname(currentDir2);
+          }
           const resolvedFileDir = resolve(fileDir);
           const resolvedCwd = resolve(cwd);
-          if (process$1.env.NODE_ENV === "development") {
-            relinka(
-              "verbose",
-              `File dir: ${fileDir}, resolved: ${resolvedFileDir}, cwd: ${resolvedCwd}`
-            );
-          }
           if (resolvedFileDir !== resolvedCwd && !resolvedFileDir.startsWith(resolvedCwd)) {
-            relinka("verbose", `Using caller directory: ${fileDir}`);
-            return fileDir;
+            if (process$1.env.NODE_ENV === "development") {
+              relinka("verbose", `Using caller directory (different from CWD): ${fileDir}`);
+            }
+            return packageRoot || fileDir;
+          }
+        } 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)) {
+              if (process$1.env.NODE_ENV === "development") {
+                relinka("verbose", `Found command package in node_modules: ${packageDir}`);
+              }
+              return packageDir;
+            }
           }
         } catch {
           continue;
@@ -3163,33 +3229,18 @@ const getCallerDirectory = async () => {
     try {
       const packageJsonPath = resolve(currentDir, "package.json");
       if (await fs.pathExists(packageJsonPath)) {
-        relinka("verbose", `Found package.json at: ${currentDir}`);
+        if (process$1.env.NODE_ENV === "development") {
+          relinka("verbose", `Found package.json at: ${currentDir}`);
+        }
         return currentDir;
       }
     } catch {
     }
     currentDir = dirname(currentDir);
   }
-  try {
-    const possibleCommandPaths = [
-      resolve(cwd, "src", "build", "cmd.ts"),
-      resolve(cwd, "src", "build", "cmd.js"),
-      resolve(cwd, "src-ts", "build", "cmd.ts"),
-      resolve(cwd, "src-ts", "build", "cmd.js"),
-      resolve(cwd, "build", "cmd.ts"),
-      resolve(cwd, "build", "cmd.js"),
-      resolve(cwd, "app", "build", "cmd.ts"),
-      resolve(cwd, "app", "build", "cmd.js")
-    ];
-    for (const path of possibleCommandPaths) {
-      if (await fs.pathExists(path)) {
-        relinka("verbose", `Found command file at: ${path}, using cwd: ${cwd}`);
-        return cwd;
-      }
-    }
-  } catch {
+  if (process$1.env.NODE_ENV === "development") {
+    relinka("verbose", `No suitable caller found, using cwd: ${cwd}`);
   }
-  relinka("verbose", `No suitable caller found, using cwd: ${cwd}`);
   return process$1.cwd();
 };
 const tryLoadCommand = async (path) => {
@@ -3211,6 +3262,69 @@ const generateCandidatePaths = async (resolvedPath) => {
   }
   return [resolvedPath];
 };
+const generateAlternativePaths = async (cmdPath, callerDir) => {
+  const normalizedCmdPath = cmdPath.replace(/^\.\//, "");
+  const paths = [];
+  const commonCommandLocations = [
+    // Direct command file
+    resolve(callerDir, `${normalizedCmdPath}.ts`),
+    resolve(callerDir, `${normalizedCmdPath}.js`),
+    // Command in cmd subdirectory
+    resolve(callerDir, normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, normalizedCmdPath, "cmd.js"),
+    // Command in app subdirectory
+    resolve(callerDir, "app", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "app", normalizedCmdPath, "cmd.js"),
+    // Command in src subdirectory
+    resolve(callerDir, "src", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "src", normalizedCmdPath, "cmd.js"),
+    // Command in src/app subdirectory
+    resolve(callerDir, "src", "app", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "src", "app", normalizedCmdPath, "cmd.js"),
+    // Command in src-ts subdirectory
+    resolve(callerDir, "src-ts", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "src-ts", normalizedCmdPath, "cmd.js"),
+    // Command in src-ts/app subdirectory (for dler-like structures)
+    resolve(callerDir, "src-ts", "app", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "src-ts", "app", normalizedCmdPath, "cmd.js"),
+    // Command in lib subdirectory
+    resolve(callerDir, "lib", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "lib", normalizedCmdPath, "cmd.js"),
+    // Command in lib/app subdirectory
+    resolve(callerDir, "lib", "app", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "lib", "app", normalizedCmdPath, "cmd.js"),
+    // Command in dist subdirectory (compiled)
+    resolve(callerDir, "dist", normalizedCmdPath, "cmd.js"),
+    resolve(callerDir, "dist", "app", normalizedCmdPath, "cmd.js"),
+    // Command in bin subdirectory
+    resolve(callerDir, "bin", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "bin", normalizedCmdPath, "cmd.js"),
+    // Command in bin/app subdirectory (common for CLI tools)
+    resolve(callerDir, "bin", "app", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "bin", "app", normalizedCmdPath, "cmd.js"),
+    // Command in commands subdirectory
+    resolve(callerDir, "commands", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "commands", normalizedCmdPath, "cmd.js"),
+    // Command in cli subdirectory
+    resolve(callerDir, "cli", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "cli", normalizedCmdPath, "cmd.js"),
+    // Command in cli/commands subdirectory
+    resolve(callerDir, "cli", "commands", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "cli", "commands", normalizedCmdPath, "cmd.js"),
+    // Command in tools subdirectory
+    resolve(callerDir, "tools", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "tools", normalizedCmdPath, "cmd.js"),
+    // Command in scripts subdirectory
+    resolve(callerDir, "scripts", normalizedCmdPath, "cmd.ts"),
+    resolve(callerDir, "scripts", normalizedCmdPath, "cmd.js")
+  ];
+  for (const path of commonCommandLocations) {
+    if (await fs.pathExists(path)) {
+      paths.push(path);
+    }
+  }
+  return paths;
+};
 const createCommandNotFoundError = (cmdPath, searchedPaths) => new Error(
   `No command file found for "${cmdPath}". Expected to find either:
   - A valid command file at the specified path
@@ -3254,7 +3368,24 @@ async function loadCommand(cmdPath) {
         return command;
       }
     }
-    throw createCommandNotFoundError(cmdPath, candidatePaths);
+    let allSearchedPaths = [...candidatePaths];
+    if (callerDir !== process$1.cwd()) {
+      const alternativePaths = await generateAlternativePaths(cmdPath, callerDir);
+      allSearchedPaths.push(...alternativePaths);
+      if (process$1.env.NODE_ENV === "development") {
+        relinka("verbose", `Trying alternative paths: ${alternativePaths.join(", ")}`);
+      }
+      for (const path of alternativePaths) {
+        const command = await tryLoadCommand(path);
+        if (command) {
+          if (process$1.env.NODE_ENV === "development") {
+            relinka("verbose", `Successfully loaded command from alternative path: ${path}`);
+          }
+          return command;
+        }
+      }
+    }
+    throw createCommandNotFoundError(cmdPath, allSearchedPaths);
   } catch (error) {
     if (error instanceof Error && error.message.includes("No command file found")) {
       throw error;
@@ -6322,8 +6453,9 @@ function argsToStringArray(args) {
 }
 async function createCallCmd() {
   return async function callCmd(cmdName, args) {
+    const originalCaller = await getOriginalCallerDirectory();
     try {
-      const command = await loadCommand(cmdName);
+      const command = await loadCommandWithCaller(cmdName, originalCaller);
       const stringArgs = args ? argsToStringArray(args) : [];
       await runCmd(command, stringArgs);
     } catch (error) {
@@ -6334,7 +6466,8 @@ async function createCallCmd() {
 }
 async function createGetTypedCmd() {
   return async function getTypedCmd(cmdName) {
-    const command = await loadCommand(cmdName);
+    const originalCaller = await getOriginalCallerDirectory();
+    const command = await loadCommandWithCaller(cmdName, originalCaller);
     return {
       command,
       run: async (args) => {
@@ -6345,8 +6478,9 @@ async function createGetTypedCmd() {
   };
 }
 async function callCmdImpl(cmdName, args) {
+  const originalCaller = await getOriginalCallerDirectory();
   try {
-    const command = await loadCommand(cmdName);
+    const command = await loadCommandWithCaller(cmdName, originalCaller);
     const stringArgs = args ? argsToStringArray(args) : [];
     await runCmd(command, stringArgs);
   } catch (error) {
@@ -6354,8 +6488,89 @@ 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 command = await loadCommand(cmdName);
+  const originalCaller = await getOriginalCallerDirectory();
+  const command = await loadCommandWithCaller(cmdName, originalCaller);
   return {
     command,
     run: async (args) => {

package/package.json

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