@reliverse/dler 1.7.2 → 1.7.4

package/bin/app/copy/cmd.js

@@ -1,8 +1,14 @@
 import { relinka } from "@reliverse/relinka";
 import { defineCommand, selectPrompt, inputPrompt } from "@reliverse/rempts";
 import { copyFile, access, mkdir } from "node:fs/promises";
-import { join, dirname } from "node:path";
+import { join, dirname, basename } from "node:path";
+import pMap from "p-map";
+import prettyMilliseconds from "pretty-ms";
 import { glob } from "tinyglobby";
+import {
+  createPerfTimer,
+  getElapsedPerfTime
+} from "../../libs/sdk/sdk-impl/utils/utils-perf.js";
 async function fileExists(path) {
   try {
     await access(path);
@@ -11,12 +17,6 @@ async function fileExists(path) {
     return false;
   }
 }
-async function safeCopy(source, destination) {
-  if (await fileExists(destination)) {
-    throw new Error(`Destination file already exists: ${destination}`);
-  }
-  await copyFile(source, destination);
-}
 async function ensureDir(path) {
   try {
     await access(path);
@@ -31,11 +31,11 @@ export default defineCommand({
     description: "Copy files and directories"
   },
   args: {
-    source: {
+    s: {
       type: "string",
       description: "Source file or directory to copy (supports glob patterns)"
     },
-    destination: {
+    d: {
       type: "string",
       description: "Destination path for the copy operation"
     },
@@ -44,27 +44,33 @@ export default defineCommand({
       description: "Recursively process all files in subdirectories (default: true)",
       default: true
     },
-    force: {
-      type: "boolean",
-      description: "Overwrite existing files (default: false)",
-      default: false
-    },
     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
     }
   },
   async run({ args }) {
     const {
-      source,
-      destination,
+      s,
+      d,
       recursive = true,
-      force = false,
-      preserveStructure = true
+      preserveStructure = true,
+      increment = false,
+      concurrency = 8
     } = args;
-    let finalSource = source;
-    let finalDestination = destination;
+    let finalSource = s;
+    let finalDestination = d;
     if (!finalSource) {
       finalSource = await inputPrompt({
         title: "Enter source file or directory (supports glob patterns)",
@@ -78,7 +84,7 @@ export default defineCommand({
       });
     }
     if (!finalSource || !finalDestination) {
-      relinka("error", "Usage: dler copy <source> <destination>");
+      relinka("error", "Usage: dler copy --s <source> --d <destination>");
       process.exit(1);
     }
     try {
@@ -103,37 +109,61 @@ export default defineCommand({
           return;
         }
       }
-      for (const file of files) {
-        let destPath;
-        if (preserveStructure) {
-          const match = file.match(/packages\/([^/]+)\/lib\/(.*)/);
-          if (match?.[1] && match?.[2]) {
-            const packageName = match[1];
-            const relativePath = match[2];
-            destPath = join(finalDestination, packageName, relativePath);
+      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 = join(finalDestination, packageName, relativePath);
+            } else {
+              destPath = join(finalDestination, file);
+            }
           } else {
-            destPath = join(finalDestination, file);
+            destPath = join(finalDestination, basename(file));
+          }
+          if (increment) {
+            const dir = dirname(destPath);
+            const base = 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 = join(dir, newBase);
+            }
+            dirMap.set(base, count + 1);
           }
-        } else {
-          destPath = join(finalDestination, file);
-        }
-        try {
           await ensureDir(dirname(destPath));
-          if (force) {
-            await copyFile(file, destPath);
-          } else {
-            await safeCopy(file, destPath);
+          if (await fileExists(destPath)) {
+            throw new Error(`Destination file already exists: ${destPath}`);
           }
+          await copyFile(file, destPath);
           relinka("log", `Copied '${file}' to '${destPath}'`);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          relinka("error", `Error copying '${file}': ${errorMessage}`);
-          if (!force) {
-            process.exit(1);
-          }
-        }
-      }
-      relinka("log", `Successfully copied ${files.length} file(s)`);
+        },
+        { 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}`);

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

@@ -7,5 +7,18 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "string";
         description: string;
     };
+    files: {
+        type: "positional";
+        description: string;
+        default: string;
+    };
+    comment: {
+        type: "string";
+        description: string;
+    };
+    tscPaths: {
+        type: "string";
+        description: string;
+    };
 }>;
 export default _default;

package/bin/app/inject/cmd.js

@@ -1,35 +1,47 @@
 import { relinka } from "@reliverse/relinka";
-import { defineCommand, runCmd, selectPrompt } from "@reliverse/rempts";
-import { getCmdInjectExpect } from "../cmds.js";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { useTsExpectError } from "./impl.js";
 export default defineCommand({
   meta: {
-    name: "cli",
-    description: "Runs the Inject command interactive menu (displays list of available commands)"
+    name: "expect",
+    version: "1.0.0",
+    description: "Inject `@ts-expect-error` above lines where TS errors occur"
   },
-  args: {
+  args: defineArgs({
     dev: {
       type: "boolean",
-      description: "Runs the CLI in dev mode"
+      description: "Run the CLI in dev mode"
     },
     cwd: {
       type: "string",
       description: "The working directory to run the CLI in"
+    },
+    files: {
+      type: "positional",
+      description: `'auto' or path(s) to line references file(s)`,
+      default: "auto"
+    },
+    comment: {
+      type: "string",
+      description: "Override the comment line to insert. Default is `// @ts-expect-error TODO: fix ts`"
+    },
+    tscPaths: {
+      type: "string",
+      description: "Optional: specify path(s) to restrict TSC processing (only effective when using 'auto')"
     }
-  },
-  run: async ({ args }) => {
-    const isDev = args.dev;
-    relinka("verbose", `Running in ${isDev ? "dev" : "prod"} mode`);
-    const cmd = await selectPrompt({
-      title: "Select a command",
-      options: [
-        {
-          value: "ts-expect-error",
-          label: "Inject `@ts-expect-error` above lines where TS errors occur"
-        }
-      ]
-    });
-    if (cmd === "ts-expect-error") {
-      await runCmd(await getCmdInjectExpect(), []);
+  }),
+  async run({ args }) {
+    if (args.dev) {
+      relinka("verbose", "Using dev mode");
     }
+    let pathsTsc = args.tscPaths;
+    if (pathsTsc === void 0 && args.files === "auto") {
+      pathsTsc = "./tsconfig.json";
+    }
+    await useTsExpectError({
+      files: [args.files],
+      comment: args.comment,
+      tscPaths: [pathsTsc]
+    });
   }
 });

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

@@ -1,14 +1,14 @@
 declare const _default: import("@reliverse/rempts").Command<{
-    in: {
+    s: {
         type: "array";
         description: string;
     };
-    ignore: {
-        type: "array";
+    d: {
+        type: "string";
         description: string;
     };
-    out: {
-        type: "string";
+    ignore: {
+        type: "array";
         description: string;
     };
     format: {
@@ -24,6 +24,11 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "boolean";
         description: string;
     };
+    pathAbove: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
     separator: {
         type: "string";
         description: string;
@@ -40,5 +45,58 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "boolean";
         description: string;
     };
+    recursive: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    preserveStructure: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    increment: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    concurrency: {
+        type: "number";
+        description: string;
+        default: number;
+    };
+    sort: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    dryRun: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    backup: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    dedupe: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    header: {
+        type: "string";
+        description: string;
+    };
+    footer: {
+        type: "string";
+        description: string;
+    };
+    interactive: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
 }>;
 export default _default;

package/bin/app/merge/cmd.js

@@ -1,7 +1,19 @@
 import path from "@reliverse/pathkit";
 import { glob } from "@reliverse/reglob";
 import fs from "@reliverse/relifso";
-import { defineCommand, inputPrompt, confirmPrompt } from "@reliverse/rempts";
+import { relinka } from "@reliverse/relinka";
+import {
+  defineCommand,
+  inputPrompt,
+  confirmPrompt,
+  multiselectPrompt
+} from "@reliverse/rempts";
+import pMap from "p-map";
+import prettyMilliseconds from "pretty-ms";
+import {
+  createPerfTimer,
+  getElapsedPerfTime
+} from "../../libs/sdk/sdk-impl/utils/utils-perf.js";
 const DEFAULT_IGNORES = ["**/.git/**", "**/node_modules/**"];
 const BINARY_EXTS = [
   "png",
@@ -85,24 +97,28 @@ const maybePrompt = async (batch, value, promptFn) => {
   if (batch || value !== void 0) return value;
   return promptFn();
 };
-const collectFiles = async (include, extraIgnore) => {
+const collectFiles = async (include, extraIgnore, recursive, sortBy) => {
   const files = await glob(include, {
     ignore: [...DEFAULT_IGNORES, ...extraIgnore],
-    absolute: true
+    absolute: true,
+    onlyFiles: true,
+    deep: recursive ? void 0 : 1
   });
-  return [...new Set(files)].filter((f) => !isBinaryExt(f)).sort();
-};
-const readSections = async (files, injectPath, getPrefix) => {
-  const cwd = process.cwd();
-  const reads = files.map(async (f) => {
-    const raw = await fs.readFile(f, "utf8");
-    if (!injectPath) return raw;
-    const rel = path.relative(cwd, f);
-    return `${ensureTrailingNL(raw)}${getPrefix(f)}${rel}`;
-  });
-  return Promise.all(reads);
+  let filtered = [...new Set(files)].filter((f) => !isBinaryExt(f));
+  if (sortBy === "name") {
+    filtered.sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+  } else if (sortBy === "path") {
+    filtered.sort();
+  } else if (sortBy === "mtime") {
+    filtered = await pMap(
+      filtered,
+      async (f) => ({ f, mtime: (await fs.stat(f)).mtimeMs }),
+      { concurrency: 8 }
+    ).then((arr) => arr.sort((a, b) => a.mtime - b.mtime).map((x) => x.f));
+  }
+  return filtered;
 };
-const writeResult = async (sections, separator, toFile, toStdout) => {
+const writeResult = async (sections, separator, toFile, toStdout, dryRun, backup) => {
   const content = `${sections.join(separator)}
 `;
   if (toStdout || !toFile) {
@@ -111,18 +127,65 @@ const writeResult = async (sections, separator, toFile, toStdout) => {
   }
   const dir = path.dirname(toFile);
   if (dir && dir !== ".") await fs.ensureDir(dir);
-  await fs.writeFile(toFile, content, "utf8");
+  if (backup && await fs.pathExists(toFile)) {
+    const backupPath = `${toFile}.${Date.now()}.bak`;
+    await fs.copyFile(toFile, backupPath);
+  }
+  if (!dryRun) {
+    await fs.writeFile(toFile, content, "utf8");
+  }
+};
+const writeFilesPreserveStructure = async (files, outDir, preserveStructure, increment, concurrency, dryRun, backup) => {
+  const cwd = process.cwd();
+  const fileNameCounts = /* @__PURE__ */ new Map();
+  await pMap(
+    files,
+    async (file) => {
+      const relPath = preserveStructure ? path.relative(cwd, file) : path.basename(file);
+      let destPath = path.join(outDir, relPath);
+      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 fs.ensureDir(path.dirname(destPath));
+      if (backup && await fs.pathExists(destPath)) {
+        const backupPath = `${destPath}.${Date.now()}.bak`;
+        await fs.copyFile(destPath, backupPath);
+      }
+      if (!dryRun) {
+        await fs.copyFile(file, destPath);
+      }
+    },
+    { concurrency }
+  );
 };
 export default defineCommand({
   meta: {
-    name: "remege",
+    name: "merge",
     version: "1.0.0",
-    description: "Merge text files with optional commented path footer, skips binaries/media, built for CI & interactive use."
+    description: "Merge text files with optional commented path header/footer, skips binaries/media, built for CI & interactive use. Supports copy-like patterns and advanced options."
   },
   args: {
-    in: { type: "array", description: "Input glob patterns" },
+    s: { type: "array", description: "Input glob patterns" },
+    d: { type: "string", description: "Output file path or directory" },
     ignore: { type: "array", description: "Extra ignore patterns" },
-    out: { type: "string", description: "Output file path" },
     format: {
       type: "string",
       default: "txt",
@@ -133,6 +196,11 @@ export default defineCommand({
       type: "boolean",
       description: "Don't inject relative path below each file"
     },
+    pathAbove: {
+      type: "boolean",
+      description: "Print file path above each file's content (default: true)",
+      default: true
+    },
     separator: {
       type: "string",
       description: `Custom separator (default ${DEFAULT_SEPARATOR_RAW})`
@@ -148,11 +216,65 @@ export default defineCommand({
     batch: {
       type: "boolean",
       description: "Disable interactive prompts (CI/non-interactive mode)"
+    },
+    recursive: {
+      type: "boolean",
+      description: "Recursively process all files in subdirectories (default: true)",
+      default: true
+    },
+    preserveStructure: {
+      type: "boolean",
+      description: "Preserve source directory structure in output (default: true)",
+      default: true
+    },
+    increment: {
+      type: "boolean",
+      description: "Attach an incrementing index to each output filename if set (default: false)",
+      default: false
+    },
+    concurrency: {
+      type: "number",
+      description: "Number of concurrent file operations (default: 8)",
+      default: 8
+    },
+    sort: {
+      type: "string",
+      description: "Sort files by: name, path, mtime, none (default: path)",
+      default: "path"
+    },
+    dryRun: {
+      type: "boolean",
+      description: "Show what would be done, but don't write files",
+      default: false
+    },
+    backup: {
+      type: "boolean",
+      description: "Backup output files before overwriting",
+      default: false
+    },
+    dedupe: {
+      type: "boolean",
+      description: "Remove duplicate file contents in merge",
+      default: false
+    },
+    header: {
+      type: "string",
+      description: "Header text to add at the start of merged output"
+    },
+    footer: {
+      type: "string",
+      description: "Footer text to add at the end of merged output"
+    },
+    interactive: {
+      type: "boolean",
+      description: "Prompt for file selection before merging",
+      default: false
     }
   },
   async run({ args }) {
+    const timer = createPerfTimer();
     const batch = Boolean(args.batch);
-    let include = args.in ?? [];
+    let include = args.s ?? [];
     if (include.length === 0) {
       const raw = await maybePrompt(
         batch,
@@ -197,6 +319,7 @@ export default defineCommand({
     }
     const forceComment = args.forceComment ?? false;
     const injectPath = !args.noPath;
+    const pathAbove = args.pathAbove ?? true;
     const sepRaw = args.separator ?? await maybePrompt(
       batch,
       void 0,
@@ -207,7 +330,7 @@ export default defineCommand({
     ) ?? DEFAULT_SEPARATOR_RAW;
     const separator = unescape(sepRaw);
     let stdoutFlag = args.stdout ?? false;
-    let outFile = args.out;
+    let outFile = args.d;
     if (!stdoutFlag && !outFile && !batch) {
       stdoutFlag = await confirmPrompt({
         title: "Print result to stdout?",
@@ -227,18 +350,90 @@ export default defineCommand({
         }
       }
     }
-    const files = await collectFiles(include, ignore);
+    const recursive = args.recursive ?? true;
+    const preserveStructure = args.preserveStructure ?? true;
+    const increment = args.increment ?? false;
+    const concurrency = args.concurrency ?? 8;
+    const sortBy = args.sort;
+    const dryRun = args.dryRun ?? false;
+    const backup = args.backup ?? false;
+    const dedupe = args.dedupe ?? false;
+    const header = args.header;
+    const footer = args.footer;
+    const interactive = args.interactive ?? false;
+    let files = await collectFiles(include, ignore, recursive, sortBy);
     if (files.length === 0) {
       throw new Error(
         "No text files matched given patterns (binary/media files are skipped)"
       );
     }
+    if (interactive && !batch) {
+      const selected = await multiselectPrompt({
+        title: "Select files to merge",
+        options: files.map((f) => ({
+          label: path.relative(process.cwd(), f),
+          value: f
+        }))
+      });
+      files = Array.isArray(selected) ? selected : [selected];
+      if (files.length === 0) {
+        throw new Error("No files selected for merging");
+      }
+    }
     const getPrefix = (filePath) => {
       if (forceComment && customComment) return customComment;
       const ext = path.extname(filePath).slice(1).toLowerCase();
       return COMMENT_MAP[ext] ?? customComment ?? DEFAULT_COMMENT;
     };
-    const sections = await readSections(files, injectPath, getPrefix);
-    await writeResult(sections, separator, outFile, stdoutFlag);
+    if (outFile && await fs.pathExists(outFile) && (await fs.stat(outFile)).isDirectory()) {
+      await writeFilesPreserveStructure(
+        files,
+        outFile,
+        preserveStructure,
+        increment,
+        concurrency,
+        dryRun,
+        backup
+      );
+      return;
+    }
+    const cwd = process.cwd();
+    const seen = /* @__PURE__ */ new Set();
+    const sections = await pMap(
+      files,
+      async (f) => {
+        const raw = await fs.readFile(f, "utf8");
+        if (dedupe) {
+          const hash = raw.trim();
+          if (seen.has(hash)) return null;
+          seen.add(hash);
+        }
+        const rel = path.relative(cwd, f);
+        const prefix = getPrefix(f);
+        let section = raw;
+        if (pathAbove) {
+          section = `${prefix}${rel}
+${section}`;
+        }
+        if (injectPath) {
+          section = `${ensureTrailingNL(section)}${prefix}${rel}`;
+        }
+        return section;
+      },
+      { concurrency }
+    );
+    const filteredSections = sections.filter(Boolean);
+    if (header) filteredSections.unshift(header);
+    if (footer) filteredSections.push(footer);
+    await writeResult(
+      filteredSections,
+      separator,
+      outFile,
+      stdoutFlag,
+      dryRun,
+      backup
+    );
+    const elapsed = getElapsedPerfTime(timer);
+    relinka("success", `Merge completed in ${prettyMilliseconds(elapsed)}`);
   }
 });