@reliverse/rempts 1.7.15 → 1.7.16

package/README.md

@@ -662,111 +662,94 @@ export default defineCommand({
 });
 ```
 
-```ts
-// example/launcher/app/minimal/cmd.ts
-
-import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-
-export default defineCommand({
-  meta: {
-    name: "minimal",
-    description: "hello world",
-  },
-  args: defineArgs({
-    name: {
-      type: "string",
-      description: "your name",
-      required: true,
-    },
-  }),
-  run({ args }) {
-    relinka("success", `👋 Hello, ${args.name}!`);
-  },
-});
-```
-
-**Pro Tips & Best Practices**:
+### Loading Commands with `loadCommand`
 
-- Install `dler` globally and run `dler rempts init --cmds` to generate a `src/app/cmds.ts` (custom path is supported) file in your project.
-- You can use any name for the `cmds.ts` file and store it anywhere, but `src/app/cmds.ts` is a good convention you can follow.
-- Use the async function pattern for lazy loading if you have many commands or care about startup performance.
-- Use eager loading (const) for small CLIs or demos where simplicity is preferred.
+The `loadCommand` utility helps you load command files from your filesystem. It automatically handles:
 
-**Lazy Loading (Recommended for Most CLIs)**:
+- Relative paths (both `./build` and `build` work the same)
+- Automatic detection of `cmd.{ts,js}` files
+- Clear error messages when files are not found
 
 ```ts
-// example/launcher/app/cmds.ts
+import { loadCommand } from "@reliverse/rempts";
 
-export async function cmdHooks() {
-  return (await import("./hooks/cmd.js")).default;
-}
+// These are equivalent:
+const cmd1 = await loadCommand("./build");     // Looks for build/cmd.ts or build/cmd.js
+const cmd2 = await loadCommand("build");       // Same as above
+const cmd3 = await loadCommand("./build/cmd"); // Explicit path to cmd file
 
-export async function getCmdFoo() {
-  return (await import("./foo/cmd.js")).default;
-}
-
-// ...more commands
+// You can then use the loaded command with runCmd:
+await runCmd(cmd1, ["--some-flag"]);
 ```
 
-Usage:
-
 ```ts
-// example/prompts/mod.ts
+// src/app/cmds.ts
+export const getBuildCmd = async (): Promise<Command> => loadCommand("./build");
 
-import { cmdHooks } from "@/launcher/app/cmds.js";
+// src/cli.ts
 import { runCmd } from "@reliverse/rempts";
-
-await runCmd(await cmdHooks(), ["--flag"]);
-// OR:
-// const hooksCmd = await cmdHooks();
-// await runCmd(hooksCmd, ["--flag"]);
+import { getBuildCmd } from "./app/cmds";
+await runCmd(await getBuildCmd(), ["--prod"]);
 ```
 
-**Alternative: Eager Loading (All Commands Loaded at Startup)**:
-
-```ts
-// example/launcher/app/cmds.ts
-export const hooksCmd = (await import("./hooks/cmd.js")).default;
-export const fooCmd = (await import("./foo/cmd.js")).default;
-// ...more commands
-```
+**Error Handling:**
+If the command file is not found, you'll get a clear error message:
 
-Usage:
-
-```ts
-import { hooksCmd } from "./cmds.js";
-import { runCmd } from "@reliverse/rempts";
-
-await runCmd(hooksCmd, ["--flag"]);
+```bash
+No command file found in /path/to/build. Expected to find either:
+  - /path/to/build/cmd.ts
+  - /path/to/build/cmd.js
+Please ensure one of these files exists and exports a default command.
 ```
 
-**Programmatic Command Execution with `runCmd`**:
+**Best Practices:**
 
-The `runCmd` utility lets you run a command's `run()` handler with parsed arguments, outside of the full launcher context. This is useful for demos, tests, or custom flows:
+- Use `loadCommand` when you need to load commands from the filesystem
+- Use `runCmd` to execute the loaded command with arguments
+- Keep your command files in a consistent location (e.g., `src/app/yourCmdName/cmd.ts`)
+- Export commands from a central file like `src/app/cmds.ts` for better organization
 
 ```ts
-import { runCmd } from "@reliverse/rempts";
-import { hooksCmd } from "./cmds.js";
+// example/launcher/app/cmds.ts
+import { loadCommand } from "@reliverse/rempts";
 
-await runCmd(hooksCmd, ["--flag"]); // argv as array of strings
-```
+export async function getBuildCmd() {
+  return loadCommand("./build");
+}
 
-Or with lazy loading:
+export async function getDeployCmd() {
+  return loadCommand("./deploy");
+}
 
-```ts
-const hooksCmd = await cmdHooks();
-await runCmd(hooksCmd, ["--flag"]);
+// Usage:
+import { getBuildCmd } from "./cmds";
+const buildCmd = await getBuildCmd();
+await runCmd(buildCmd, ["--prod"]);
 ```
 
-**Note:** `runCmd` only runs the command's `run()` handler and does not handle subcommands, file-based commands, or global hooks. For full CLI behavior, use `runMain`.
-
-**Performance Note:**
+```ts
+// example/launcher/app/minimal/cmd.ts
 
-- Eager loading (`const`) loads all commands at startup, which may impact performance for large CLIs.
-- Lazy loading (`async function`) loads each command only when needed, improving startup time and memory usage.
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
 
-Choose the pattern that best fits your CLI's size and usage!
+export default defineCommand({
+  meta: {
+    name: "minimal",
+    description: "hello world",
+  },
+  args: defineArgs({
+    name: {
+      type: "string",
+      description: "your name",
+      required: true,
+    },
+  }),
+  run({ args }) {
+    relinka("success", `👋 Hello, ${args.name}!`);
+  },
+});
+```
 
 ## Argument Types: Usage Comparison
 

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

@@ -1,7 +1,8 @@
-import { resolve } from "@reliverse/pathkit";
+import { resolve, dirname } from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { createJiti } from "jiti";
+import process from "node:process";
 const jiti = createJiti(import.meta.url, {
   debug: process.env.NODE_ENV === "development",
   fsCache: true,
@@ -9,8 +10,21 @@ const jiti = createJiti(import.meta.url, {
 });
 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 normalizedPath = cmdPath.replace(/^\.\//, "");
-    const resolvedPath = normalizedPath.startsWith("../") ? resolve(process.cwd(), normalizedPath) : resolve(process.cwd(), normalizedPath);
+    const resolvedPath = resolve(callerDir, normalizedPath);
     if (!resolvedPath.endsWith("cmd.ts") && !resolvedPath.endsWith("cmd.js")) {
       const possiblePaths = [
         resolve(resolvedPath, "cmd.ts"),

package/package.json

@@ -29,7 +29,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.15",
+  "version": "1.7.16",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",