@reliverse/rempts 1.7.47 → 1.7.49

package/dist-npm/bin/mod.mjs

@@ -3123,9 +3123,9 @@ const getCallerDirectory = async () => {
   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) {
@@ -3133,42 +3133,83 @@ 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.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("log", `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("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("log", `Using caller package root (different path): ${packageRoot}`);
+                      }
+                      return packageRoot;
+                    }
+                  }
+                } else {
+                  if (process$1.env.NODE_ENV === "development") {
+                    relinka("log", `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("log", `Using caller directory (different from CWD): ${fileDir}`);
+            }
+            return packageRoot || fileDir;
           }
-          if (resolvedFileDir === resolvedCwd) {
-            let currentDir2 = fileDir;
-            while (currentDir2 !== dirname(currentDir2)) {
-              try {
-                const packageJsonPath = resolve(currentDir2, "package.json");
-                if (await fs.pathExists(packageJsonPath)) {
-                  const cwdPackageJsonPath = resolve(cwd, "package.json");
-                  if (await fs.pathExists(cwdPackageJsonPath)) {
-                    const callerPackageJson = await fs.readFile(packageJsonPath, "utf-8");
-                    const cwdPackageJson = await fs.readFile(cwdPackageJsonPath, "utf-8");
-                    if (callerPackageJson !== cwdPackageJson) {
-                      relinka("verbose", `Found different package.json at: ${currentDir2}, using caller directory: ${fileDir}`);
-                      return fileDir;
-                    }
-                  }
-                  break;
-                }
-              } catch {
+        } 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("log", `Found command package in node_modules: ${packageDir}`);
               }
-              currentDir2 = dirname(currentDir2);
+              return packageDir;
             }
           }
         } catch {
@@ -3182,34 +3223,40 @@ 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("log", `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;
+  if (process$1.env.NODE_ENV === "development") {
+    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 {
     }
-  } catch {
   }
-  relinka("verbose", `No suitable caller found, using cwd: ${cwd}`);
-  return process$1.cwd();
+  return Array.from(packageDirs);
 };
 const tryLoadCommand = async (path) => {
   if (!await fs.pathExists(path)) return null;
@@ -3217,7 +3264,7 @@ const tryLoadCommand = async (path) => {
     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;
   }
 };
@@ -3246,15 +3293,45 @@ const generateAlternativePaths = async (cmdPath, callerDir) => {
     // 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")
+    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)) {
@@ -3288,40 +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;
       }
     }
-    if (callerDir !== process$1.cwd()) {
-      const alternativePaths = await generateAlternativePaths(cmdPath, callerDir);
+    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, candidatePaths);
+    throw createCommandNotFoundError(cmdPath, searchedPaths);
   } catch (error) {
     if (error instanceof Error && error.message.includes("No command file found")) {
       throw error;

package/package.json

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