@reliverse/dler 1.7.59 → 1.7.61

package/LICENSES

@@ -13,5 +13,8 @@ See LICENSE file for full license text.
 NOTICES
 
 Some parts of this project are based on and significantly adapt:
+- https://github.com/unjs/nypm/tree/b13ca2f – MIT © Pooya Parsa (pi0)
 - https://github.com/unjs/unbuild/tree/a6570a5 – MIT © Pooya Parsa (pi0)
 - https://github.com/unjs/mkdist/tree/a7f029d – MIT © Pooya Parsa (pi0), Daniel Roe (danielroe)
+- https://github.com/moxystudio/node-cross-spawn/tree/77cd97f – MIT © MOXY (hello@moxy.studio)
+- https://github.com/tinylibs/tinyexec/tree/daa2945 – MIT © Tinylibs

package/README.md

@@ -156,7 +156,7 @@ if you run just `dler` — it will display a list of commands which you can laun
 
 ## **available commands**
 
-[build](#1-build) — [pub](#2-pub) — [agg](#3-agg) — [check](#4-check) — [conv](#5-conv) — [copy](#6-copy) — [init](#7-init) — [inject](#8-inject) — [libs](#9-libs) — [merge](#10-merge) — [migrate](#11-migrate) — [rempts](#12-rempts) — [rename](#13-rename) — [spell](#14-magic) — [split](#15-split) — [pack](#16-pack)
+[build](#1-build) — [pub](#2-pub) — [agg](#3-agg) — [check](#4-check) — [conv](#5-conv) — [fs](#6-fs) — [init](#7-init) — [inject](#8-inject) — [libs](#9-libs) — [merge](#10-merge) — [migrate](#11-migrate) — [rempts](#12-rempts) — [x](#13-x) — [spell](#14-magic) — [split](#15-split) — [pack](#16-pack)
 
 ### 1. `build`
 
@@ -187,7 +187,7 @@ dler > "agg"
 dler agg --input <dir> --out <file> [options]
 ```
 
-**usage example**: if you're exploring the example [playground](#playground), you can try the following:
+**usage example**: if you're exploring the example [playground](#0-try-the-playground), you can try the following:
 
 1. open [src/libs/sdk/sdk-mod.ts](https://github.com/reliverse/dler/blob/main/src/libs/sdk/sdk-mod.ts) in your ide.
 2. press `ctrl+a`, then `backspace`. run the command below and watch the magic happen:
@@ -322,14 +322,17 @@ deep imports like `dep/some/file` or `@org/dep/some/thing` are always resolved t
 
 not yet documented.
 
-### 6. `copy`
+### 6. `fs`
 
 ```bash
 # simple example:
-bun dler copy --s "src/**/*.ts" --d "dist"
+bun dler fs --mode copy --s "src/**/*.ts" --d "dist"
+bun dler fs --mode rm --target "node_modules"
+bun dler fs --mode rename --source "index.ts" --destination "index.ts.bak"
 
 # advanced example:
-bun dler copy --s ".temp/packages/*/lib/**/*" --d "src/libs/sdk/sdk-impl/rules/external"
+bun dler fs --mode copy --s ".temp/packages/*/lib/**/*" --d "src/libs/sdk/sdk-impl/rules/external"
+bun dler fs --mode rm --target "**/node_modules"
 ```
 
 ### 7. `init`
@@ -623,10 +626,12 @@ bun dler rempts
 bun dler rempts --init cmd1 cmd2
 ```
 
-### 13. `rename`
+### 13. `x`
+
+`dler x` — your package manager — refined.
 
 ```bash
-bun dler rename ...
+bun dler x ...
 ```
 
 ### 14. `magic`

package/bin/app/build/prebuild.js

@@ -26,8 +26,7 @@ const createToolRunner = () => ({
   "dler-check": {
     name: "Dler Check",
     async run() {
-      const checkCmd = await getCheckCmd();
-      await runCmd(checkCmd, ["--no-exit", "--no-progress"]);
+      await runCmd(await getCheckCmd(), ["--no-exit", "--no-progress"]);
     }
   }
 });

package/bin/app/{copy → fs}/cmd.d.ts

@@ -1,11 +1,30 @@
 declare const _default: import("@reliverse/rempts").Command<{
-    s: {
+    mode: {
         type: "string";
         description: string;
+        allowed: string[];
+        required: true;
     };
-    d: {
+    target: {
         type: "string";
         description: string;
+        required: true;
+        alias: string;
+    };
+    nonInteractive: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    source: {
+        type: "string";
+        description: string;
+        alias: string;
+    };
+    destination: {
+        type: "string";
+        description: string;
+        alias: string;
     };
     recursive: {
         type: "boolean";
@@ -32,5 +51,17 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         default: false;
     };
+    prepareMyCLI: {
+        type: "boolean";
+        description: string;
+    };
+    revert: {
+        type: "boolean";
+        description: string;
+    };
+    useDtsTxtForPrepareMyCLI: {
+        type: "boolean";
+        description: string;
+    };
 }>;
 export default _default;

package/bin/app/fs/cmd.js

@@ -0,0 +1,302 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand, inputPrompt, selectPrompt } from "@reliverse/rempts";
+import pMap from "p-map";
+import prettyMilliseconds from "pretty-ms";
+import { glob } from "tinyglobby";
+import { prepareCLIFiles, safeRename } from "../../libs/sdk/sdk-impl/utils/fs-rename.js";
+import { createPerfTimer, getElapsedPerfTime } from "../../libs/sdk/sdk-mod.js";
+async function fileExists(path2) {
+  try {
+    await fs.access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path2) {
+  try {
+    await fs.access(path2);
+  } catch {
+    await fs.mkdir(path2, { recursive: true });
+  }
+}
+export default defineCommand({
+  meta: {
+    name: "rm",
+    version: "1.1.0",
+    description: "COPY or REMOVE or RENAME a file, directory, or glob pattern recursively. Usage example: `dler fs --mode rm --target '**/node_modules'`"
+  },
+  args: defineArgs({
+    mode: {
+      type: "string",
+      description: "Mode to use: copy, rm, rename",
+      allowed: ["copy", "rm", "rename"],
+      required: true
+    },
+    target: {
+      type: "string",
+      description: "Path or glob pattern to the file(s) or directory(ies) to complete the operation.",
+      required: true,
+      alias: "t"
+    },
+    nonInteractive: {
+      type: "boolean",
+      description: "Disable interactive prompts and require all arguments to be provided via flags.",
+      default: false
+    },
+    source: {
+      type: "string",
+      description: "Source file or directory to complete the operation (supports glob patterns)",
+      alias: "s"
+    },
+    destination: {
+      type: "string",
+      description: "Destination path for the operation",
+      alias: "d"
+    },
+    recursive: {
+      type: "boolean",
+      description: "Recursively process all files in subdirectories (default: true)",
+      default: true
+    },
+    preserveStructure: {
+      type: "boolean",
+      description: "Preserve source directory structure in destination (default: true)",
+      default: true
+    },
+    increment: {
+      type: "boolean",
+      description: "Attach an incrementing index to each destination filename before the extension if set (default: true)",
+      default: true
+    },
+    concurrency: {
+      type: "number",
+      description: "Number of concurrent copy operations (default: 8)",
+      default: 8
+    },
+    gitignore: {
+      type: "boolean",
+      description: "Ignore files and directories specified in .gitignore",
+      default: false
+    },
+    prepareMyCLI: {
+      type: "boolean",
+      description: "Prepare CLI by renaming files"
+    },
+    revert: {
+      type: "boolean",
+      description: "Revert renamed files back to original names"
+    },
+    useDtsTxtForPrepareMyCLI: {
+      type: "boolean",
+      description: "Use .d.ts.txt extension for .d.ts files in prepareMyCLI mode (default: false)"
+    }
+  }),
+  async run({ args }) {
+    const {
+      mode,
+      nonInteractive,
+      source,
+      destination,
+      recursive = true,
+      preserveStructure = true,
+      increment = false,
+      concurrency = 8,
+      gitignore = false,
+      prepareMyCLI,
+      revert,
+      useDtsTxtForPrepareMyCLI = false
+    } = args;
+    let { target } = args;
+    if (mode === "rm") {
+      if (!target && !nonInteractive) {
+        target = await inputPrompt({
+          title: "Enter the path or glob pattern to remove:",
+          defaultValue: ""
+        });
+      }
+      if (!target) {
+        relinka("error", "No target path or pattern provided for removal.");
+        return;
+      }
+      let matches = [];
+      try {
+        matches = await glob(target, { dot: true });
+      } catch (error) {
+        relinka("error", `Invalid glob pattern: ${target}`);
+        return;
+      }
+      if (matches.length === 0) {
+        relinka("error", `No files or directories matched: ${target}`);
+        return;
+      }
+      matches.sort((a, b) => b.split(path.sep).length - a.split(path.sep).length);
+      let removedCount = 0;
+      const concurrency2 = 8;
+      await pMap(
+        matches,
+        async (match) => {
+          const resolvedPath = path.resolve(match);
+          try {
+            if (!await fs.pathExists(resolvedPath)) {
+              relinka("warn", `Target does not exist: ${resolvedPath}`);
+              return;
+            }
+            await fs.remove(resolvedPath);
+            relinka("log", `Removed: ${resolvedPath}`);
+            removedCount++;
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            relinka("error", `Failed to remove '${resolvedPath}': ${errorMessage}`);
+          }
+        },
+        { concurrency: concurrency2 }
+      );
+      if (removedCount > 0) {
+        relinka("log", `Successfully removed ${removedCount} item(s) matching: ${target}`);
+      } else {
+        relinka("warn", `No items were removed for pattern: ${target}`);
+      }
+    } else if (mode === "copy") {
+      let finalSource = source;
+      let finalDestination = destination;
+      if (!finalSource) {
+        finalSource = await inputPrompt({
+          title: "Enter source file or directory (supports glob patterns)",
+          placeholder: "e.g., putout/packages/*/lib/**/*"
+        });
+      }
+      if (!finalDestination) {
+        finalDestination = await inputPrompt({
+          title: "Enter destination path",
+          placeholder: "e.g., src/libs/sdk/sdk-impl/rules/putout"
+        });
+      }
+      if (!finalSource || !finalDestination) {
+        relinka("error", "Usage: dler copy --s <source> --d <destination>");
+        process.exit(1);
+      }
+      let ignorePatterns = recursive ? [] : ["**/*"];
+      if (gitignore) {
+        try {
+          const gitignoreContent = await fs.readFile(".gitignore", "utf8");
+          ignorePatterns = ignorePatterns.concat(
+            gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"))
+          );
+        } catch (err) {
+          relinka("error", ".gitignore not found or unreadable, but --gitignore was specified.");
+          process.exit(1);
+        }
+      }
+      try {
+        const files = await glob(finalSource, {
+          dot: true,
+          ignore: ignorePatterns
+        });
+        if (files.length === 0) {
+          relinka("error", `No files found matching pattern: ${finalSource}`);
+          process.exit(1);
+        }
+        if (files.length > 1) {
+          const confirm = await selectPrompt({
+            title: `Found ${files.length} files to copy. Proceed?`,
+            options: [
+              { label: "Yes", value: "yes" },
+              { label: "No", value: "no" }
+            ]
+          });
+          if (confirm === "no") {
+            relinka("log", "Operation cancelled by user");
+            return;
+          }
+        }
+        const timer = createPerfTimer();
+        const fileNameCounts = /* @__PURE__ */ new Map();
+        await pMap(
+          files,
+          async (file) => {
+            let destPath;
+            if (preserveStructure) {
+              const match = file.match(/packages\/([^/]+)\/lib\/(.*)/);
+              if (match?.[1] && match?.[2]) {
+                const packageName = match[1];
+                const relativePath = match[2];
+                destPath = path.join(finalDestination, packageName, relativePath);
+              } else {
+                destPath = path.join(finalDestination, file);
+              }
+            } else {
+              destPath = path.join(finalDestination, path.basename(file));
+            }
+            if (increment) {
+              const dir = path.dirname(destPath);
+              const base = path.basename(destPath);
+              let dirMap = fileNameCounts.get(dir);
+              if (!dirMap) {
+                dirMap = /* @__PURE__ */ new Map();
+                fileNameCounts.set(dir, dirMap);
+              }
+              const count = dirMap.get(base) || 0;
+              if (count > 0) {
+                const extMatch = base.match(/(.*)(\.[^./\\]+)$/);
+                let newBase;
+                if (extMatch) {
+                  newBase = `${extMatch[1]}-${count + 1}${extMatch[2]}`;
+                } else {
+                  newBase = `${base}-${count + 1}`;
+                }
+                destPath = path.join(dir, newBase);
+              }
+              dirMap.set(base, count + 1);
+            }
+            await ensureDir(path.dirname(destPath));
+            if (await fileExists(destPath)) {
+              throw new Error(`Destination file already exists: ${destPath}`);
+            }
+            await fs.copyFile(file, destPath);
+            relinka("log", `Copied '${file}' to '${destPath}'`);
+          },
+          { concurrency, stopOnError: true }
+        );
+        const elapsed = getElapsedPerfTime(timer);
+        relinka(
+          "log",
+          `Successfully copied ${files.length} file(s) in ${prettyMilliseconds(elapsed)}`
+        );
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        relinka("error", `Error during copy operation: ${errorMessage}`);
+        process.exit(1);
+      }
+    } else if (mode === "rename") {
+      if (prepareMyCLI === true) {
+        try {
+          await prepareCLIFiles(revert === true, recursive, useDtsTxtForPrepareMyCLI);
+          relinka("log", "Successfully prepared CLI files");
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          relinka("error", `Error preparing CLI: ${errorMessage}`);
+          process.exit(1);
+        }
+        return;
+      }
+      if (!source || !destination) {
+        relinka(
+          "error",
+          "Usage: dler fs --mode rename --source <source> --destination <destination>"
+        );
+        process.exit(1);
+      }
+      try {
+        await safeRename(source, destination);
+        relinka("log", `Successfully renamed '${source}' to '${destination}'`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        relinka("error", `Error renaming: ${errorMessage}`);
+        process.exit(1);
+      }
+    }
+  }
+});

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

@@ -0,0 +1,92 @@
+/**
+ * USAGE EXAMPLES:
+ * - dler x install package-name - installs a package
+ * - dler x remove package-name - removes a package
+ * - dler x detect - detects the package manager
+ * - dler x dedupe - deduplicates dependencies
+ * - dler x run script-name - runs a script
+ * - dler x exec --target 'bun run build' - executes a command
+ */
+declare const _default: import("@reliverse/rempts").Command<{
+    action: {
+        type: "string";
+        description: string;
+        required: true;
+    };
+    name: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+    dev: {
+        type: "boolean";
+        alias: string;
+        description: string;
+    };
+    global: {
+        type: "boolean";
+        alias: string;
+        description: string;
+    };
+    "frozen-lockfile": {
+        type: "boolean";
+        description: string;
+    };
+    cwd: {
+        type: "string";
+        description: string;
+    };
+    workspace: {
+        type: "boolean";
+        description: string;
+    };
+    silent: {
+        type: "boolean";
+        description: string;
+    };
+    recreateLockFile: {
+        type: "boolean";
+        description: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+    };
+    timeout: {
+        type: "number";
+        description: string;
+    };
+    throwOnError: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    fileType: {
+        type: "string";
+        description: string;
+    };
+    destDir: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    multiple: {
+        type: "boolean";
+        description: string;
+    };
+    parallel: {
+        type: "boolean";
+        description: string;
+    };
+    concurrency: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    linter: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;