@reliverse/dler 1.7.10 → 1.7.12

package/bin/app/merge/cmd.js

@@ -2,45 +2,28 @@ import path from "@reliverse/pathkit";
 import { glob } from "@reliverse/reglob";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { defineCommand, inputPrompt, confirmPrompt, multiselectPrompt } from "@reliverse/rempts";
+import {
+  defineCommand,
+  inputPrompt,
+  confirmPrompt,
+  multiselectPrompt,
+  defineArgs
+} from "@reliverse/rempts";
+import MagicString from "magic-string";
+import { Bundle } from "magic-string";
 import pMap from "p-map";
 import prettyMilliseconds from "pretty-ms";
+import { isBinaryExt } from "../../libs/sdk/sdk-impl/utils/binary.js";
 import { createPerfTimer, getElapsedPerfTime } from "../../libs/sdk/sdk-impl/utils/utils-perf.js";
+import {
+  checkPermissions,
+  checkFileSize,
+  handleError,
+  validateFileExists,
+  sanitizeInput,
+  validateMergeOperation
+} from "../../libs/sdk/sdk-impl/utils/utils-security.js";
 const DEFAULT_IGNORES = ["**/.git/**", "**/node_modules/**"];
-const BINARY_EXTS = [
-  "png",
-  "jpg",
-  "jpeg",
-  "gif",
-  "bmp",
-  "webp",
-  "svg",
-  "ico",
-  "mp4",
-  "mov",
-  "avi",
-  "mkv",
-  "mp3",
-  "wav",
-  "flac",
-  "ogg",
-  "pdf",
-  "zip",
-  "gz",
-  "tar",
-  "rar",
-  "7z",
-  "exe",
-  "dll",
-  "bin",
-  "woff",
-  "woff2",
-  "ttf",
-  "eot",
-  "class",
-  "jar"
-];
-const BINARY_SET = new Set(BINARY_EXTS);
 const COMMENT_MAP = {
   js: "// ",
   jsx: "// ",
@@ -77,94 +60,208 @@ const COMMENT_MAP = {
 };
 const DEFAULT_COMMENT = "// ";
 const DEFAULT_SEPARATOR_RAW = "\\n\\n";
-const isBinaryExt = (file) => {
-  const ext = path.extname(file).slice(1).toLowerCase();
-  return BINARY_SET.has(ext);
+const normalizeGlobPattern = (pattern) => {
+  const sanitizedPattern = sanitizeInput(pattern);
+  if (!sanitizedPattern.includes("*") && !sanitizedPattern.includes("?") && !sanitizedPattern.endsWith("/")) {
+    return `${sanitizedPattern}/**/*`;
+  }
+  return sanitizedPattern;
 };
-const ensureTrailingNL = (s) => s.endsWith("\n") ? s : `${s}
-`;
-const parseCSV = (s) => s.split(",").map((t) => t.trim()).filter(Boolean);
+const parseCSV = (s) => s.split(",").map((t) => sanitizeInput(t.trim())).filter(Boolean);
 const unescape = (s) => s.replace(/\\n/g, "\n").replace(/\\t/g, "	");
-const maybePrompt = async (batch, value, promptFn) => {
-  if (batch || value !== void 0) return value;
+const maybePrompt = async (interactive, value, promptFn) => {
+  if (!interactive || value !== void 0) return value;
   return promptFn();
 };
 const collectFiles = async (include, extraIgnore, recursive, sortBy) => {
-  const files = await glob(include, {
-    ignore: [...DEFAULT_IGNORES, ...extraIgnore],
-    absolute: true,
-    onlyFiles: true,
-    deep: recursive ? void 0 : 1
-  });
-  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));
+  try {
+    const normalizedInclude = include.map(normalizeGlobPattern);
+    const files = await glob(normalizedInclude, {
+      ignore: [...DEFAULT_IGNORES, ...extraIgnore.map(sanitizeInput)],
+      absolute: true,
+      onlyFiles: true,
+      deep: recursive ? void 0 : 1
+    });
+    for (const file of files) {
+      await validateFileExists(file, "merge");
+      await checkFileSize(file);
+      await checkPermissions(file, "read");
+    }
+    let filtered = [...new Set(files)];
+    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;
+  } catch (error) {
+    handleError(error, "collectFiles");
+    return [];
   }
-  return filtered;
 };
-const writeResult = async (sections, separator, toFile, toStdout, dryRun, backup) => {
-  const content = `${sections.join(separator)}
+const writeResult = async (sections, _separator, toFile, toStdout, dryRun, backup, generateSourceMap = false) => {
+  try {
+    const bundle = new Bundle();
+    for (const section of sections) {
+      bundle.addSource({
+        content: new MagicString(section)
+      });
+    }
+    const content = bundle.toString();
+    const finalContent = `${content}
 `;
-  if (toStdout || !toFile) {
-    process.stdout.write(content);
-    return;
-  }
-  const dir = path.dirname(toFile);
-  if (dir && dir !== ".") await fs.ensureDir(dir);
-  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");
+    if (toStdout || !toFile) {
+      process.stdout.write(finalContent);
+      return;
+    }
+    const sanitizedPath = sanitizeInput(toFile);
+    const dir = path.dirname(sanitizedPath);
+    if (dir && dir !== ".") {
+      await fs.ensureDir(dir);
+      await checkPermissions(dir, "write");
+    }
+    if (backup && await fs.pathExists(sanitizedPath)) {
+      const backupPath = `${sanitizedPath}.${Date.now()}.bak`;
+      await checkPermissions(sanitizedPath, "read");
+      await fs.copyFile(sanitizedPath, backupPath);
+    }
+    if (!dryRun) {
+      await checkPermissions(sanitizedPath, "write");
+      await fs.writeFile(sanitizedPath, finalContent, "utf8");
+      if (generateSourceMap) {
+        const map = bundle.generateMap({
+          file: path.basename(sanitizedPath),
+          source: sanitizedPath,
+          includeContent: true,
+          hires: true
+        });
+        const mapPath = `${sanitizedPath}.map`;
+        await fs.writeFile(mapPath, map.toString(), "utf8");
+        const sourceMapRef = `
+//# sourceMappingURL=${path.basename(mapPath)}`;
+        await fs.appendFile(sanitizedPath, sourceMapRef, "utf8");
+      }
+    }
+  } catch (error) {
+    handleError(error, "writeResult");
   }
 };
 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}`;
+  try {
+    if (!files?.length) {
+      throw new Error("No files provided for merge operation");
+    }
+    const cwd = process.cwd();
+    const fileNameCounts = /* @__PURE__ */ new Map();
+    await validateMergeOperation(files);
+    await pMap(
+      files,
+      async (file) => {
+        const sanitizedFile = sanitizeInput(file);
+        const relPath = preserveStructure ? path.relative(cwd, sanitizedFile) : path.basename(sanitizedFile);
+        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);
           }
-          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 checkPermissions(destPath, "read");
+          await fs.copyFile(destPath, backupPath);
+        }
+        if (!dryRun) {
+          await checkPermissions(destPath, "write");
+          await fs.copyFile(sanitizedFile, destPath);
+        }
+      },
+      { concurrency }
+    );
+  } catch (error) {
+    handleError(error, "writeFilesPreserveStructure");
+  }
+};
+const processSection = (raw, rel, prefix, pathAbove, injectPath) => {
+  const magic = new MagicString(raw);
+  if (pathAbove) {
+    magic.prepend(`${prefix}${rel}
+`);
+  }
+  if (injectPath) {
+    magic.append(`
+${prefix}${rel}`);
+  }
+  return magic.toString();
+};
+const updateTemplateInFile = async (templateName, templateContent, targetFile, dryRun, backup, generateSourceMap = false) => {
+  try {
+    const fileContent = await fs.readFile(targetFile, "utf8");
+    const magic = new MagicString(fileContent);
+    const templateStart = fileContent.indexOf(`export const ${templateName}: Template = {`);
+    if (templateStart === -1) {
+      throw new Error(`Template ${templateName} not found in file ${targetFile}`);
+    }
+    let currentBracketCount = 0;
+    let endIndex = templateStart;
+    for (let i = templateStart; i < fileContent.length; i++) {
+      const char = fileContent[i];
+      if (char === "{") {
+        currentBracketCount++;
+      } else if (char === "}") {
+        currentBracketCount--;
+        if (currentBracketCount === 0) {
+          endIndex = i + 1;
+          break;
         }
-        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 }
-  );
+    }
+    magic.overwrite(templateStart, endIndex, templateContent);
+    if (dryRun) {
+      relinka("verbose", `[DRY RUN] Would update template ${templateName} in ${targetFile}`);
+      return;
+    }
+    if (backup) {
+      const backupPath = `${targetFile}.${Date.now()}.bak`;
+      await fs.copyFile(targetFile, backupPath);
+    }
+    await fs.writeFile(targetFile, magic.toString(), "utf8");
+    if (generateSourceMap) {
+      const map = magic.generateMap({
+        file: path.basename(targetFile),
+        source: targetFile,
+        includeContent: true,
+        hires: true
+      });
+      const mapPath = `${targetFile}.map`;
+      await fs.writeFile(mapPath, map.toString(), "utf8");
+      const sourceMapRef = `
+//# sourceMappingURL=${path.basename(mapPath)}`;
+      await fs.appendFile(targetFile, sourceMapRef, "utf8");
+    }
+  } catch (error) {
+    handleError(error, "updateTemplateInFile");
+  }
 };
 export default defineCommand({
   meta: {
@@ -172,7 +269,8 @@ export default defineCommand({
     version: "1.0.0",
     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: {
+  args: defineArgs({
+    dev: { type: "boolean", description: "Generate template for development" },
     s: { type: "array", description: "Input glob patterns" },
     d: { type: "string", description: "Output file path or directory" },
     ignore: { type: "array", description: "Extra ignore patterns" },
@@ -219,8 +317,7 @@ export default defineCommand({
     },
     increment: {
       type: "boolean",
-      description: "Attach an incrementing index to each output filename if set (default: false)",
-      default: false
+      description: "Attach an incrementing index to each output filename if set (default: false)"
     },
     concurrency: {
       type: "number",
@@ -234,18 +331,15 @@ export default defineCommand({
     },
     dryRun: {
       type: "boolean",
-      description: "Show what would be done, but don't write files",
-      default: false
+      description: "Show what would be done, but don't write files"
     },
     backup: {
       type: "boolean",
-      description: "Backup output files before overwriting",
-      default: false
+      description: "Backup output files before overwriting"
     },
     dedupe: {
       type: "boolean",
-      description: "Remove duplicate file contents in merge",
-      default: false
+      description: "Remove duplicate file contents in merge"
     },
     header: {
       type: "string",
@@ -255,165 +349,399 @@ export default defineCommand({
       type: "string",
       description: "Footer text to add at the end of merged output"
     },
+    "select-files": {
+      type: "boolean",
+      description: "Prompt for file selection before merging"
+    },
     interactive: {
       type: "boolean",
-      description: "Prompt for file selection before merging",
-      default: false
+      description: "Enable interactive mode with prompts (default: false)"
+    },
+    "as-template": {
+      type: "boolean",
+      description: "Generate a TypeScript file with MOCK_TEMPLATES structure"
+    },
+    "custom-template-name": {
+      type: "string",
+      description: "Custom template name when using --as-template"
+    },
+    whitelabel: {
+      type: "string",
+      description: "Custom prefix to use instead of 'DLER' in template generation",
+      default: "DLER"
+    },
+    sourcemap: {
+      type: "boolean",
+      description: "Generate source map for the merged output"
+    },
+    "update-template": {
+      type: "string",
+      description: "Update specific template in existing mock template file",
+      dependencies: ["as-template"]
     }
-  },
+  }),
   async run({ args }) {
-    const timer = createPerfTimer();
-    const batch = Boolean(args.batch);
-    let include = args.s ?? [];
-    if (include.length === 0) {
-      const raw = await maybePrompt(
-        batch,
-        void 0,
-        () => inputPrompt({
-          title: "Input glob patterns (comma separated)",
-          placeholder: "src/**/*.ts, !**/*.test.ts"
-        })
-      );
-      if (raw) include = parseCSV(raw);
-    }
-    if (include.length === 0) throw new Error("No input patterns supplied and prompts disabled");
-    let ignore = args.ignore ?? [];
-    if (ignore.length === 0) {
-      const raw = await maybePrompt(
-        batch,
+    const customTemplateName = args["custom-template-name"];
+    try {
+      const timer = createPerfTimer();
+      const interactive = args.interactive ?? false;
+      const isDev = args.dev ?? false;
+      const whitelabel = args.whitelabel ?? "DLER";
+      let include = args.s ?? [];
+      if (include.length === 0) {
+        const raw = await maybePrompt(
+          interactive,
+          void 0,
+          () => inputPrompt({
+            title: "Input glob patterns (comma separated)",
+            placeholder: "src/**/*.ts, !**/*.test.ts"
+          })
+        );
+        if (raw) include = parseCSV(raw);
+      }
+      if (include.length === 0) {
+        throw new Error("No input patterns supplied and prompts disabled");
+      }
+      let ignore = args.ignore ?? [];
+      if (ignore.length === 0) {
+        const raw = await maybePrompt(
+          interactive,
+          void 0,
+          () => inputPrompt({
+            title: "Ignore patterns (comma separated, blank for none)",
+            placeholder: "**/*.d.ts"
+          })
+        );
+        if (raw) ignore = parseCSV(raw);
+      }
+      let customComment = args.comment;
+      if (customComment === void 0) {
+        const want = await maybePrompt(
+          interactive,
+          void 0,
+          () => confirmPrompt({
+            title: "Provide custom comment prefix?",
+            defaultValue: false
+          })
+        );
+        if (want) {
+          customComment = await inputPrompt({
+            title: "Custom comment prefix (include trailing space if needed)",
+            placeholder: "# "
+          });
+        }
+      }
+      const forceComment = args.forceComment ?? false;
+      const injectPath = !args.noPath;
+      const pathAbove = args.pathAbove ?? true;
+      const sepRaw = args.separator ?? await maybePrompt(
+        interactive,
         void 0,
         () => inputPrompt({
-          title: "Ignore patterns (comma separated, blank for none)",
-          placeholder: "**/*.d.ts"
+          title: "Separator between files (\\n for newline, blank \u2192 blank line)",
+          placeholder: DEFAULT_SEPARATOR_RAW
         })
-      );
-      if (raw) ignore = parseCSV(raw);
-    }
-    let customComment = args.comment;
-    if (customComment === void 0) {
-      const want = await maybePrompt(
-        batch,
-        void 0,
-        () => confirmPrompt({
-          title: "Provide custom comment prefix?",
+      ) ?? DEFAULT_SEPARATOR_RAW;
+      const separator = unescape(sepRaw);
+      let stdoutFlag = args.stdout ?? false;
+      let outFile = args.d;
+      if (!stdoutFlag && !outFile && interactive) {
+        stdoutFlag = await confirmPrompt({
+          title: "Print result to stdout?",
           defaultValue: false
-        })
-      );
-      if (want) {
-        customComment = await inputPrompt({
-          title: "Custom comment prefix (include trailing space if needed)",
-          placeholder: "# "
         });
+        if (!stdoutFlag) {
+          outFile = await inputPrompt({
+            title: "Output file path (blank \u2192 merged.<ext>)",
+            placeholder: ""
+          });
+          if (!outFile) {
+            const ext = await inputPrompt({
+              title: "File extension",
+              placeholder: args.format
+            });
+            outFile = `merged.${(ext || args.format).replace(/^\./, "")}`;
+          }
+        }
       }
-    }
-    const forceComment = args.forceComment ?? false;
-    const injectPath = !args.noPath;
-    const pathAbove = args.pathAbove ?? true;
-    const sepRaw = args.separator ?? await maybePrompt(
-      batch,
-      void 0,
-      () => inputPrompt({
-        title: "Separator between files (\\n for newline, blank \u2192 blank line)",
-        placeholder: DEFAULT_SEPARATOR_RAW
-      })
-    ) ?? DEFAULT_SEPARATOR_RAW;
-    const separator = unescape(sepRaw);
-    let stdoutFlag = args.stdout ?? false;
-    let outFile = args.d;
-    if (!stdoutFlag && !outFile && !batch) {
-      stdoutFlag = await confirmPrompt({
-        title: "Print result to stdout?",
-        defaultValue: false
-      });
-      if (!stdoutFlag) {
-        outFile = await inputPrompt({
-          title: "Output file path (blank \u2192 merged.<ext>)",
-          placeholder: ""
+      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 selectFiles = args["select-files"] ?? false;
+      const asTemplate = args["as-template"] ?? 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 (selectFiles && interactive) {
+        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");
+        }
+      }
+      if (args["update-template"]) {
         if (!outFile) {
-          const ext = await inputPrompt({
-            title: "File extension",
-            placeholder: args.format
-          });
-          outFile = `merged.${(ext || args.format).replace(/^\./, "")}`;
+          throw new Error("Output file path required for template update");
+        }
+        const templateName = args["update-template"];
+        const templateData = {
+          name: templateName.replace(/_DLER_TEMPLATE$/, "").replace(/_/g, " ").toLowerCase(),
+          // Convert REACT_DLER_TEMPLATE to "react"
+          description: `Template generated from ${files.length} files`,
+          config: {
+            files: {}
+          }
+        };
+        for (const file of files) {
+          const relPath = path.relative(process.cwd(), file);
+          const ext = path.extname(file).slice(1).toLowerCase();
+          const isBinary = await isBinaryExt(file);
+          const fileName = path.basename(file).toLowerCase();
+          let content = "";
+          let type = "binary";
+          if (!isBinary) {
+            try {
+              const fileContent = await fs.readFile(file, "utf8");
+              if (ext === "json") {
+                const jsonContent = JSON.parse(fileContent);
+                if (fileName === "package.json") {
+                  content = {
+                    ...jsonContent
+                  };
+                } else if (fileName === "tsconfig.json") {
+                  content = {
+                    ...jsonContent
+                  };
+                } else {
+                  content = jsonContent;
+                }
+                type = "json";
+              } else {
+                content = fileContent;
+                type = "text";
+              }
+            } catch (error) {
+              type = "binary";
+              if (asTemplate || args["update-template"]) {
+                relinka(
+                  "warn",
+                  `Skipped file "${relPath}" due to error: ${error instanceof Error ? error.message : "unknown error"}`
+                );
+              }
+            }
+          } else if (asTemplate || args["update-template"]) {
+            relinka("warn", `Skipped binary file "${relPath}"`);
+          }
+          templateData.config.files[relPath] = {
+            content,
+            type
+          };
         }
+        const templateContent = `export const ${templateName}: Template = ${JSON.stringify(
+          templateData,
+          null,
+          2
+        ).replace(/"([^"]+)":/g, (_, key) => {
+          return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key) ? `${key}:` : `"${key}":`;
+        })};`;
+        await updateTemplateInFile(
+          templateName,
+          templateContent,
+          outFile,
+          dryRun,
+          backup,
+          args.sourcemap
+        );
+        const elapsed2 = getElapsedPerfTime(timer);
+        relinka(
+          "success",
+          `Successfully ${dryRun ? "would update" : "updated"} template "${templateName}" in "${outFile}" (in ${prettyMilliseconds(elapsed2)})`
+        );
+        return;
       }
-    }
-    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");
+      if (asTemplate) {
+        const timer2 = {
+          startTime: performance.now(),
+          pausedAt: null,
+          pausedDuration: 0
+        };
+        if (!outFile) {
+          outFile = "template.ts";
+        } else if (!outFile.endsWith(".ts")) {
+          outFile = `${outFile}.ts`;
+        }
+        const templateName = customTemplateName || path.basename(outFile, ".ts");
+        const templateConstName = templateName.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").replace(/[A-Z]/g, (letter) => `_${letter}`).replace(/^_/, "").toUpperCase() + `_${whitelabel}_TEMPLATE`;
+        const templateKey = templateName.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
+        const template = {
+          name: templateName.toLowerCase(),
+          // Ensure name is lowercase
+          description: `Template generated from ${files.length} files`,
+          config: {
+            files: {}
+          }
+        };
+        for (const file of files) {
+          const relPath = path.relative(process.cwd(), file);
+          const ext = path.extname(file).slice(1).toLowerCase();
+          const isBinary = await isBinaryExt(file);
+          const fileName = path.basename(file).toLowerCase();
+          let content = "";
+          let type = "binary";
+          if (!isBinary) {
+            try {
+              const fileContent = await fs.readFile(file, "utf8");
+              if (ext === "json") {
+                const jsonContent = JSON.parse(fileContent);
+                if (fileName === "package.json") {
+                  content = {
+                    ...jsonContent
+                  };
+                } else if (fileName === "tsconfig.json") {
+                  content = {
+                    ...jsonContent
+                  };
+                } else {
+                  content = jsonContent;
+                }
+                type = "json";
+              } else {
+                content = fileContent;
+                type = "text";
+              }
+            } catch (error) {
+              type = "binary";
+              if (asTemplate || args["update-template"]) {
+                relinka(
+                  "warn",
+                  `Skipped file "${relPath}" due to error: ${error instanceof Error ? error.message : "unknown error"}`
+                );
+              }
+            }
+          } else if (asTemplate || args["update-template"]) {
+            relinka("warn", `Skipped binary file "${relPath}"`);
+          }
+          template.config.files[relPath] = {
+            content,
+            type
+          };
+        }
+        const tsContent = `import type { Template } from "${isDev ? "~/libs/sdk/sdk-types" : "@reliverse/dler-sdk"}";
+${(() => {
+          const files2 = template.config.files;
+          if (!files2) return "";
+          const hasPackageJson = Object.values(files2).some(
+            (f) => f.type === "json" && f.content
+          );
+          const hasTSConfig = Object.values(files2).some(
+            (f) => f.type === "json" && f.content
+          );
+          if (!hasPackageJson && !hasTSConfig) return "";
+          const imports = [];
+          if (hasPackageJson) imports.push("PackageJson");
+          if (hasTSConfig) imports.push("TSConfig");
+          return `import type { ${imports.join(", ")} } from "pkg-types";
+`;
+        })()}
+export const ${templateConstName}: Template = ${JSON.stringify(template, null, 2).replace(/"([^"]+)":/g, (_, key) => {
+          return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key) ? `${key}:` : `"${key}":`;
+        }).replace(/"([^"]+)":/g, (_, key) => {
+          return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key) ? `${key}:` : `"${key}":`;
+        }).replace(/"([^"]+)":/g, (_, key) => {
+          return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key) ? `${key}:` : `"${key}":`;
+        })};
+export const ${whitelabel}_TEMPLATES = {
+  ${templateKey}: ${templateConstName},
+} as const;
+export type ${whitelabel}_TEMPLATE_NAMES = keyof typeof ${whitelabel}_TEMPLATES;
+export const ${whitelabel.toLowerCase()}TemplatesMap: Record<string, ${whitelabel}_TEMPLATE_NAMES> = {
+  ${templateConstName}: "${templateKey}",
+};
+`;
+        if (dryRun) {
+          relinka("verbose", `[DRY RUN] Would write template file: ${outFile}`);
+          return;
+        }
+        const dir = path.dirname(outFile);
+        if (dir && dir !== ".") await fs.ensureDir(dir);
+        if (backup && await fs.pathExists(outFile)) {
+          const backupPath = `${outFile}.${Date.now()}.bak`;
+          await fs.copyFile(outFile, backupPath);
+        }
+        await fs.writeFile(outFile, tsContent, "utf8");
+        const elapsed2 = getElapsedPerfTime(timer2);
+        relinka(
+          "success",
+          `Successfully ${dryRun ? "would generate" : "generated"} template file "${outFile}" (in ${prettyMilliseconds(elapsed2)})`
+        );
+        return;
       }
-    }
-    const getPrefix = (filePath) => {
-      if (forceComment && customComment) return customComment;
-      const ext = path.extname(filePath).slice(1).toLowerCase();
-      return COMMENT_MAP[ext] ?? customComment ?? DEFAULT_COMMENT;
-    };
-    if (outFile && await fs.pathExists(outFile) && (await fs.stat(outFile)).isDirectory()) {
-      await writeFilesPreserveStructure(
+      const getPrefix = (filePath) => {
+        if (forceComment && customComment) return customComment;
+        const ext = path.extname(filePath).slice(1).toLowerCase();
+        return COMMENT_MAP[ext] ?? customComment ?? DEFAULT_COMMENT;
+      };
+      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);
+          return processSection(raw, rel, prefix, pathAbove, injectPath);
+        },
+        { concurrency }
+      );
+      const filteredSections = sections.filter(Boolean);
+      if (header) filteredSections.unshift(header);
+      if (footer) filteredSections.push(footer);
+      await writeResult(
+        filteredSections,
+        separator,
         outFile,
-        preserveStructure,
-        increment,
-        concurrency,
+        stdoutFlag,
         dryRun,
-        backup
+        backup,
+        args.sourcemap
       );
-      return;
+      const elapsed = getElapsedPerfTime(timer);
+      relinka("success", `Merge completed in ${prettyMilliseconds(elapsed)}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      relinka("error", `Error during merge operation: ${errorMessage}`);
+      process.exit(1);
     }
-    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)}`);
   }
 });