@reliverse/dler 1.7.2 → 1.7.3

package/bin/app/migrate/cmd.d.ts

@@ -1,4 +1,9 @@
 declare const _default: import("@reliverse/rempts").Command<{
+    interactive: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
     codemod: {
         type: "string";
         description: string;

package/bin/app/migrate/cmd.js

@@ -1,5 +1,5 @@
 import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { confirmPrompt, defineArgs, defineCommand } from "@reliverse/rempts";
 import { migrateAnythingToBun } from "./codemods/anything-bun.js";
 import { consoleToRelinka } from "./codemods/console-relinka.js";
 import { migrateFsToRelifso } from "./codemods/fs-relifso.js";
@@ -13,6 +13,11 @@ export default defineCommand({
     description: "Migrate between different libraries and usages"
   },
   args: defineArgs({
+    interactive: {
+      type: "boolean",
+      description: "Interactive mode",
+      default: true
+    },
     codemod: {
       type: "string",
       description: "The migration to perform (anything-bun | path-pathkit | fs-relifso | nodenext-bundler | readdir-glob | console-relinka)"
@@ -50,6 +55,17 @@ export default defineCommand({
     }
   }),
   async run({ args }) {
+    if (args.interactive) {
+      const confidence = await confirmPrompt({
+        title: `This is an experimental feature and probably may broke some things.
+It will be improved in the future.
+Are you sure you want to migrate files in ${args.project}?`,
+        defaultValue: false
+      });
+      if (!confidence) {
+        throw new Error("Migration cancelled");
+      }
+    }
     if (args.codemod === "anything-bun") {
       relinka("log", "Migrating to Bun...");
       await migrateAnythingToBun({

package/bin/app/rempts/{cmdsTs/cmd.d.ts → cmd.d.ts}

@@ -1,4 +1,17 @@
 declare const _default: import("@reliverse/rempts").Command<{
+    init: {
+        type: "string";
+        description: string;
+    };
+    overwrite: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    customCmdsRoot: {
+        type: "string";
+        description: string;
+    };
     outFile: {
         type: "string";
         description: string;
@@ -8,9 +21,5 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "array";
         description: string;
     };
-    overwrite: {
-        type: "boolean";
-        description: string;
-    };
 }>;
 export default _default;

package/bin/app/rempts/cmd.js

@@ -0,0 +1,304 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { createJiti } from "jiti";
+export default defineCommand({
+  meta: {
+    name: "rempts",
+    version: "1.0.0",
+    description: "Scaffold new CLI commands and generate a command exports file (this file allows you to run your commands programmatically)."
+  },
+  args: defineArgs({
+    init: {
+      type: "string",
+      description: "Names of commands to initialize (space-separated or quoted)"
+    },
+    overwrite: {
+      type: "boolean",
+      description: "Overwrite existing commands and exports file",
+      default: true
+    },
+    customCmdsRoot: {
+      type: "string",
+      description: "Root directory for custom commands"
+    },
+    outFile: {
+      type: "string",
+      description: "Output file path for exports (relative to workspace root)",
+      default: "src/app/cmds.ts"
+    },
+    cmdDirs: {
+      type: "array",
+      description: "Command directories to scan (relative to src/app)"
+    }
+  }),
+  async run({ args }) {
+    let cmdsRoot = args.customCmdsRoot;
+    let cliFilePath = "";
+    let didInit = false;
+    if (args.init) {
+      let cmdNames = [];
+      if (Array.isArray(args.init)) {
+        cmdNames = args.init;
+      } else if (typeof args.init === "string") {
+        cmdNames = args.init.split(/\s+/).filter(Boolean);
+      }
+      if (cmdNames.length === 1) {
+        const argv = process.argv;
+        const initIndex = argv.findIndex((arg) => arg === "--init");
+        if (initIndex !== -1 && initIndex + 1 < argv.length) {
+          const additionalArgs = [];
+          for (let i = initIndex + 2; i < argv.length; i++) {
+            const arg = argv[i];
+            if (arg?.startsWith("--")) break;
+            if (arg && !arg.startsWith("-")) {
+              additionalArgs.push(arg);
+            } else {
+              break;
+            }
+          }
+          if (additionalArgs.length > 0 && cmdNames[0]) {
+            cmdNames = [cmdNames[0], ...additionalArgs];
+          }
+        }
+      }
+      if (cmdNames.length === 0) {
+        relinka("error", "No command names provided");
+        return;
+      }
+      if (!cmdsRoot) {
+        const defaultCmdsRoot = path.resolve("src/app");
+        if (await fs.pathExists(defaultCmdsRoot)) {
+          cmdsRoot = defaultCmdsRoot;
+        } else {
+          const { cmdsRoot: configCmdsRoot, cliFile } = await handleDlerConfig();
+          cmdsRoot = configCmdsRoot;
+          cliFilePath = cliFile;
+        }
+      } else {
+        cmdsRoot = path.resolve(cmdsRoot);
+      }
+      relinka(
+        "info",
+        `\u{1F680} Creating ${cmdNames.length} command(s): ${cmdNames.join(", ")}`
+      );
+      for (const cmdName of cmdNames) {
+        const dirPath = path.join(cmdsRoot, cmdName);
+        const filePath = path.join(dirPath, "cmd.ts");
+        if (await fs.pathExists(filePath) && !args.overwrite) {
+          relinka(
+            "warn",
+            `Command "${cmdName}" already exists. Use --overwrite to overwrite.`
+          );
+          continue;
+        }
+        await fs.ensureDir(dirPath);
+        const content = generateCommandTemplate(cmdName);
+        await fs.writeFile(filePath, content, "utf-8");
+        relinka("log", `\u2705 Created new command: ${filePath}`);
+      }
+      if (cliFilePath) {
+        relinka(
+          "info",
+          "\u{1F4E6} Make sure you have @reliverse/rempts installed: bun add @reliverse/rempts"
+        );
+      }
+      didInit = true;
+    }
+    if (!args.init) {
+      const root2 = path.resolve("src/app");
+      const outPath2 = path.resolve(args.outFile ?? "src/app/cmds.ts");
+      const cmdDirs2 = (args.cmdDirs ?? []).length > 0 ? args.cmdDirs ?? [] : await findCommandDirs(root2);
+      if (cmdDirs2.length === 0) {
+        relinka(
+          "warn",
+          "No command directories found with cmd.ts or cmd.js files. Nothing to generate."
+        );
+        return;
+      }
+      if (await fs.pathExists(outPath2) && !args.overwrite) {
+        relinka(
+          "warn",
+          `\u274C File "${outPath2}" already exists. Use --overwrite to overwrite.`
+        );
+        return;
+      }
+      const exports2 = generateExports(cmdDirs2);
+      await fs.ensureDir(path.dirname(outPath2));
+      await fs.writeFile(outPath2, exports2, "utf-8");
+      relinka("success", `\u2705 Generated command exports at: ${outPath2}`);
+      relinka(
+        "log",
+        `Found ${cmdDirs2.length} command(s): ${cmdDirs2.join(", ")}`
+      );
+      return;
+    }
+    const root = path.resolve("src/app");
+    const outPath = path.resolve(args.outFile ?? "src/app/cmds.ts");
+    if (await fs.pathExists(outPath) && !args.overwrite) {
+      relinka(
+        "warn",
+        `\u274C File "${outPath}" already exists. Use --overwrite to overwrite.`
+      );
+      return;
+    }
+    const cmdDirs = (args.cmdDirs ?? []).length > 0 ? args.cmdDirs ?? [] : await findCommandDirs(root);
+    if (cmdDirs.length === 0) {
+      relinka(
+        "warn",
+        "No command directories found with cmd.ts or cmd.js files."
+      );
+      return;
+    }
+    const exports = generateExports(cmdDirs);
+    await fs.ensureDir(path.dirname(outPath));
+    await fs.writeFile(outPath, exports, "utf-8");
+    relinka("success", `\u2705 Generated command exports at: ${outPath}`);
+    relinka("log", `Found ${cmdDirs.length} command(s): ${cmdDirs.join(", ")}`);
+    if (didInit) {
+      relinka(
+        "log",
+        `Usage example:
+import { getCmdName } from "../cmds.js";
+const cmd = await getCmdName();
+await runCmd(cmd, [
+  // String arguments
+  "--name=my-project",
+  "--path=./src",
+  // Boolean flags
+  "--force",
+  "--no-cache",
+  // Number values
+  "--port=3000",
+  // Array values
+  "--files=file1.ts,file2.ts",
+  // Positional arguments (must come last)
+  "--build=src/1.ts src/2.ts",
+]);`
+      );
+    }
+  }
+});
+async function handleDlerConfig() {
+  const dlerConfigPath = path.resolve(".config/dler.ts");
+  let cmdsRoot = "src/app";
+  let cliFilePath = "";
+  try {
+    const jiti = createJiti(import.meta.url);
+    const dlerConfig = await jiti.import(dlerConfigPath, {
+      default: true
+    });
+    const coreIsCLI = dlerConfig?.coreIsCLI;
+    if (!coreIsCLI?.enabled || !coreIsCLI?.scripts) {
+      cliFilePath = await ensureCliFile("src/cli.ts");
+      cmdsRoot = "src/app";
+    } else {
+      const firstScript = Object.values(coreIsCLI.scripts)[0];
+      const scriptPath = path.resolve(firstScript);
+      if (await fs.pathExists(scriptPath)) {
+        const content = await fs.readFile(scriptPath, "utf-8");
+        if (content.includes("@reliverse/rempts")) {
+          if (content.includes("runMain")) {
+            const cmdsRootMatch = content.match(
+              /cmdsRootPath:\s*["']([^"']+)["']/
+            );
+            if (cmdsRootMatch?.[1]) {
+              cmdsRoot = path.resolve(cmdsRootMatch[1]);
+            }
+          }
+        } else {
+          relinka("warn", `${scriptPath} doesn't use @reliverse/rempts`);
+          cmdsRoot = "src/app";
+        }
+      } else {
+        cliFilePath = await ensureCliFile(scriptPath);
+        cmdsRoot = "src/app";
+      }
+    }
+  } catch {
+    cliFilePath = await ensureCliFile("src/cli.ts");
+    cmdsRoot = "src/app";
+  }
+  return { cmdsRoot: path.resolve(cmdsRoot), cliFile: cliFilePath };
+}
+async function ensureCliFile(filePath) {
+  const resolvedPath = path.resolve(filePath);
+  if (!await fs.pathExists(resolvedPath)) {
+    await fs.ensureDir(path.dirname(resolvedPath));
+    await fs.writeFile(resolvedPath, cliTemplate, "utf-8");
+    relinka("log", `\u2705 Created CLI entry file: ${resolvedPath}`);
+    return resolvedPath;
+  }
+  return "";
+}
+async function findCommandDirs(root) {
+  const cmdDirs = [];
+  async function scan(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const hasCmdTs = await fs.pathExists(path.join(fullPath, "cmd.ts"));
+        const hasCmdJs = await fs.pathExists(path.join(fullPath, "cmd.js"));
+        if (hasCmdTs || hasCmdJs) {
+          const relPath = path.relative(root, fullPath);
+          cmdDirs.push(relPath);
+        }
+        await scan(fullPath);
+      }
+    }
+  }
+  await scan(root);
+  return cmdDirs;
+}
+function generateExports(cmdDirs) {
+  const lines = [
+    "// this file is auto-(re)generated by `dler rempts`",
+    "",
+    'import type { Command } from "@reliverse/rempts";',
+    "",
+    'import { loadCommand } from "@reliverse/rempts";',
+    ""
+  ];
+  for (const dir of cmdDirs) {
+    const funcName = "get" + dir.split(/[/\\]/).map(
+      (part) => part.charAt(0).toUpperCase() + part.slice(1).replace(/[^a-zA-Z0-9]/g, "")
+    ).join("") + "Cmd";
+    lines.push(
+      `export const ${funcName} = async (): Promise<Command> => loadCommand("${dir}");`,
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+function generateCommandTemplate(cmdName) {
+  return `import { defineCommand, defineArgs } from "@reliverse/rempts";
+export default defineCommand({
+  meta: {
+    name: "${cmdName}",
+    version: "1.0.0",
+    description: "Describe what ${cmdName} command does.",
+  },
+  args: defineArgs({
+    exampleArg: {
+      type: "string",
+      default: "defaultValue",
+      description: "An example argument",
+    },
+  }),
+  async run({ args }) {
+    console.log("Command '${cmdName}' executed.");
+    console.log("Received args:", args);
+  },
+});
+`;
+}
+const cliTemplate = `import { defineCommand, runMain } from "@reliverse/rempts";
+await runMain(
+  defineCommand({
+    // empty object activates file-based
+    // commands in the src/app directory
+  }),
+);
+`;

package/bin/cli.js

@@ -8,12 +8,7 @@ import {
   runCmd as remptsRunCmd
 } from "@reliverse/rempts";
 import { promptAggCommand } from "./app/agg/run.js";
-import {
-  getCmdBuild,
-  getCmdPub,
-  getCmdRelifsoInit,
-  getCmdRelifsoRename
-} from "./app/cmds.js";
+import { getBuildCmd, getPubCmd, getInitCmd, getRenameCmd } from "./app/cmds.js";
 import { showEndPrompt, showStartPrompt } from "./libs/sdk/sdk-impl/cfg/info.js";
 const INTERACTIVE_CMDS = ["agg", "build", "pub"];
 async function runCmd(cmdPromise, args) {
@@ -79,15 +74,15 @@ Available interactive commands: ${INTERACTIVE_CMDS.join(", ")}`
     if (cmdToRun === "agg") {
       await promptAggCommand();
     } else if (cmdToRun === "build") {
-      await runCmd(getCmdBuild(), [`--dev=${args.dev}`]);
+      await runCmd(getBuildCmd(), [`--dev=${args.dev}`]);
     } else if (cmdToRun === "pub") {
-      await runCmd(getCmdPub(), [`--dev=${args.dev}`]);
+      await runCmd(getPubCmd(), [`--dev=${args.dev}`]);
     } else if (cmdToRun === "init") {
-      await runCmd(getCmdRelifsoInit(), []);
+      await runCmd(getInitCmd(), []);
     } else if (cmdToRun === "rename-prepare") {
-      await runCmd(getCmdRelifsoRename(), ["--prepareMyCLI"]);
+      await runCmd(getRenameCmd(), ["--prepareMyCLI"]);
     } else if (cmdToRun === "rename-prepare-revert") {
-      await runCmd(getCmdRelifsoRename(), ["--prepareMyCLI", "--revert"]);
+      await runCmd(getRenameCmd(), ["--prepareMyCLI", "--revert"]);
     }
     relinka("log", " ");
     await showEndPrompt();

package/bin/libs/sdk/sdk-impl/cfg/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.2";
+const version = "1.7.3";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/package.json

@@ -6,7 +6,7 @@
     "@reliverse/relico": "^1.1.2",
     "@reliverse/relifso": "^1.3.1",
     "@reliverse/relinka": "^1.4.7",
-    "@reliverse/rempts": "^1.7.12",
+    "@reliverse/rempts": "^1.7.17",
     "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-commonjs": "^28.0.3",
     "@rollup/plugin-json": "^6.1.0",
@@ -39,7 +39,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "keywords": [
     "reliverse",
     "cli",

package/bin/app/deps/cmd.d.ts

@@ -1,45 +0,0 @@
-declare const _default: import("@reliverse/rempts").Command<{
-    directory: {
-        type: "string";
-        description: string;
-        default: string;
-    };
-    all: {
-        type: "boolean";
-        description: string;
-    };
-    ignore: {
-        type: "string";
-        description: string;
-    };
-    json: {
-        type: "boolean";
-        description: string;
-    };
-    builtins: {
-        type: "boolean";
-        description: string;
-    };
-    dev: {
-        type: "boolean";
-        description: string;
-    };
-    peer: {
-        type: "boolean";
-        description: string;
-    };
-    optional: {
-        type: "boolean";
-        description: string;
-    };
-    fix: {
-        type: "boolean";
-        description: string;
-    };
-    depth: {
-        type: "number";
-        description: string;
-        default: number;
-    };
-}>;
-export default _default;

package/bin/app/deps/cmd.js

@@ -1,84 +0,0 @@
-import path from "@reliverse/pathkit";
-import { re } from "@reliverse/relico";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { analyzeDependencies } from "../../libs/sdk/sdk-impl/rules/reliverse/missing-deps/analyzer.js";
-import { formatOutput } from "../../libs/sdk/sdk-impl/rules/reliverse/missing-deps/formatter.js";
-export default defineCommand({
-  meta: {
-    name: "deps",
-    version: "1.0.0",
-    description: "Find dependencies used but not listed in package.json"
-  },
-  args: defineArgs({
-    directory: {
-      type: "string",
-      description: "directory to scan (defaults to current directory)",
-      default: "."
-    },
-    all: {
-      type: "boolean",
-      description: "show all dependencies (both listed and not listed)"
-    },
-    ignore: {
-      type: "string",
-      description: "comma-separated patterns to ignore"
-    },
-    json: {
-      type: "boolean",
-      description: "output in JSON format"
-    },
-    builtins: {
-      type: "boolean",
-      description: "include Node.js built-in modules in the output"
-    },
-    dev: {
-      type: "boolean",
-      description: "check devDependencies instead of dependencies"
-    },
-    peer: {
-      type: "boolean",
-      description: "check peerDependencies instead of dependencies"
-    },
-    optional: {
-      type: "boolean",
-      description: "check optionalDependencies instead of dependencies"
-    },
-    fix: {
-      type: "boolean",
-      description: "automatically add missing dependencies to package.json"
-    },
-    depth: {
-      type: "number",
-      description: "maximum directory depth to scan (0 for unlimited)",
-      default: 0
-    }
-  }),
-  async run({ args }) {
-    try {
-      const directory = path.resolve(args.directory);
-      const ignorePatterns = args.ignore ? args.ignore.split(",") : [];
-      const options = {
-        directory,
-        showAll: args.all,
-        ignorePatterns,
-        json: args.json,
-        builtins: args.builtins,
-        dev: args.dev,
-        peer: args.peer,
-        optional: args.optional,
-        fix: args.fix,
-        depth: args.depth
-      };
-      console.log(re.gray(`Scanning directory: ${directory}`));
-      const result = await analyzeDependencies(options);
-      const output = formatOutput(result, options);
-      console.log(output);
-      if (result.missingDependencies.length > 0) {
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error("Error:", error);
-      process.exit(1);
-    }
-  }
-});