@reliverse/dler 1.7.14 → 1.7.16

package/README.md

@@ -356,6 +356,10 @@ merges multiple files into a single file. The command is built for both CI and i
 - includes backup functionality
 - validates file permissions and sizes
 - enforces output path conflict detection
+- supports template generation with TypeScript type definitions
+- handles both single file and directory output modes
+- implements interactive prompts via `@reliverse/rempts`
+- provides reporting with logging via `@reliverse/relinka`
 
 **usage examples:**
 
@@ -371,8 +375,49 @@ bun dler merge --s "src/templates" --d "templates/my-template.ts" --as-template
 
 # update mock template:
 bun dler merge --s "src/templates" --d "templates/my-template.ts" --as-template --update-template REACT_DLER_TEMPLATE
+
+# generate multiple templates based on directory structure:
+bun dler merge --s "src/templates" --d "templates" --as-template --template-multi --depth 2
+
+# create separate files for each template with an aggregator:
+bun dler merge --s "src/templates" --d "templates/index.ts" --as-template --template-per-file
 ```
 
+**arguments:**
+
+- `--s`: Input glob patterns (array)
+- `--d`: Output file path or directory
+- `--ignore`: Extra ignore patterns (array)
+- `--format`: Fallback extension when output path is omitted (default: "txt")
+- `--stdout`: Print to stdout
+- `--noPath`: Don't inject relative path below each file
+- `--pathAbove`: Print file path above each file's content (default: true)
+- `--separator`: Custom separator (default: "\n\n")
+- `--comment`: Custom comment prefix (e.g. '# ')
+- `--forceComment`: Force custom comment prefix for all file types
+- `--batch`: Disable interactive prompts (CI/non-interactive mode)
+- `--recursive`: Recursively process all files in subdirectories (default: true)
+- `--preserveStructure`: Preserve source directory structure in output (default: true)
+- `--increment`: Attach an incrementing index to each output filename
+- `--concurrency`: Number of concurrent file operations (default: 8)
+- `--sort`: Sort files by: name, path, mtime, none (default: path)
+- `--dryRun`: Show what would be done, but don't write files
+- `--backup`: Backup output files before overwriting
+- `--dedupe`: Remove duplicate file contents in merge
+- `--header`: Header text to add at the start of merged output
+- `--footer`: Footer text to add at the end of merged output
+- `--select-files`: Prompt for file selection before merging
+- `--interactive`: Enable interactive mode with prompts
+- `--as-template`: Generate a TypeScript file with template structure
+- `--custom-template-name`: Custom template name when using --as-template
+- `--template-multi`: Create multiple templates based on directory structure (default: true)
+- `--depth`: Depth level to start processing from (default: 0)
+- `--template-per-file`: Create separate files for each template with an aggregator (default: false)
+- `--whitelabel`: Custom prefix to use instead of 'DLER' in template generation (default: "DLER")
+- `--sourcemap`: Generate source map for the merged output
+- `--update-template`: Update specific template in existing mock template file
+- `--dev`: Generate template for development
+
 **implementation details:**
 
 - uses `magic-string` for efficient string manipulation and source map generation

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

@@ -101,26 +101,40 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "boolean";
         description: string;
     };
+    depth: {
+        type: "number";
+        description: string;
+        default: number;
+    };
+    sourcemap: {
+        type: "boolean";
+        description: string;
+    };
     "as-template": {
         type: "boolean";
         description: string;
     };
-    "custom-template-name": {
+    "template-whitelabel": {
         type: "string";
         description: string;
+        default: string;
+        dependencies: string[];
     };
-    whitelabel: {
+    "template-update": {
         type: "string";
         description: string;
-        default: string;
+        dependencies: string[];
     };
-    sourcemap: {
+    "template-multi": {
         type: "boolean";
         description: string;
+        default: true;
+        dependencies: string[];
     };
-    "update-template": {
-        type: "string";
+    "template-per-file": {
+        type: "boolean";
         description: string;
+        default: false;
         dependencies: string[];
     };
 }>;

package/bin/app/merge/cmd.js

@@ -73,7 +73,7 @@ const maybePrompt = async (interactive, value, promptFn) => {
   if (!interactive || value !== void 0) return value;
   return promptFn();
 };
-const collectFiles = async (include, extraIgnore, recursive, sortBy) => {
+const collectFiles = async (include, extraIgnore, recursive, sortBy, depth) => {
   try {
     const normalizedInclude = include.map(normalizeGlobPattern);
     const files = await glob(normalizedInclude, {
@@ -88,6 +88,19 @@ const collectFiles = async (include, extraIgnore, recursive, sortBy) => {
       await checkPermissions(file, "read");
     }
     let filtered = [...new Set(files)];
+    if (depth > 0) {
+      const fileGroups = /* @__PURE__ */ new Map();
+      for (const file of filtered) {
+        const relPath = path.relative(process.cwd(), file);
+        const parts = relPath.split(path.sep);
+        const groupKey = parts.slice(0, depth).join(path.sep);
+        if (!fileGroups.has(groupKey)) {
+          fileGroups.set(groupKey, []);
+        }
+        fileGroups.get(groupKey)?.push(file);
+      }
+      filtered = Array.from(fileGroups.values()).flat();
+    }
     if (sortBy === "name") {
       filtered.sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
     } else if (sortBy === "path") {
@@ -263,6 +276,49 @@ const updateTemplateInFile = async (templateName, templateContent, targetFile, d
     handleError(error, "updateTemplateInFile");
   }
 };
+const generateTemplateContent = (template, templateConstName, templateKey, whitelabel, isDev) => {
+  return `import type { Template } from "${isDev ? "~/libs/sdk/sdk-types" : "@reliverse/dler-sdk"}";
+${(() => {
+    const files = template.config.files;
+    if (!files) return "";
+    const hasPackageJson = Object.values(files).some(
+      (f) => f.type === "json" && f.content
+    );
+    const hasTSConfig = Object.values(files).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}":`;
+    }
+  )};
+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}",
+};`;
+};
+const generateAggregatorContent = (templateNames, whitelabel, isDev) => {
+  return `import type { Template } from "${isDev ? "~/libs/sdk/sdk-types" : "@reliverse/dler-sdk"}";
+${templateNames.map((name) => `import { ${name}, ${whitelabel}_TEMPLATES as ${name}_TEMPLATES, ${whitelabel}_TEMPLATE_NAMES as ${name}_TEMPLATE_NAMES, ${whitelabel.toLowerCase()}TemplatesMap as ${name.toLowerCase()}TemplatesMap } from "./${name}";`).join("\n")}
+export const ${whitelabel}_TEMPLATES = {
+${templateNames.map((name) => `  ...${name}_TEMPLATES,`).join("\n")}
+} as const;
+export type ${whitelabel}_TEMPLATE_NAMES = ${templateNames.map((name) => `${name}_TEMPLATE_NAMES`).join(" | ")};
+export const ${whitelabel.toLowerCase()}TemplatesMap: Record<string, ${whitelabel}_TEMPLATE_NAMES> = {
+${templateNames.map((name) => `  ...${name.toLowerCase()}TemplatesMap,`).join("\n")}
+};`;
+};
 export default defineCommand({
   meta: {
     name: "merge",
@@ -270,6 +326,7 @@ export default defineCommand({
     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: defineArgs({
+    /* ===== GENERAL ARGS ===== */
     dev: { type: "boolean", description: "Generate template for development" },
     s: { type: "array", description: "Input glob patterns" },
     d: { type: "string", description: "Output file path or directory" },
@@ -357,36 +414,51 @@ export default defineCommand({
       type: "boolean",
       description: "Enable interactive mode with prompts (default: false)"
     },
+    depth: {
+      type: "number",
+      description: "Depth level to start processing from (default: 0)",
+      default: 0
+    },
+    sourcemap: {
+      type: "boolean",
+      description: "Generate source map for the merged output"
+    },
+    /* ===== TEMPLATE GENERATION ARGS ===== */
     "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: {
+    "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"
+      default: "DLER",
+      dependencies: ["as-template"]
     },
-    "update-template": {
+    "template-update": {
       type: "string",
       description: "Update specific template in existing mock template file",
       dependencies: ["as-template"]
+    },
+    "template-multi": {
+      type: "boolean",
+      description: "Create multiple templates based on directory structure (default: true)",
+      default: true,
+      dependencies: ["as-template"]
+    },
+    "template-per-file": {
+      type: "boolean",
+      description: "Create separate files for each template with an aggregator (default: false)",
+      default: false,
+      dependencies: ["as-template", "template-multi"]
     }
   }),
   async run({ args }) {
-    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";
+      const whitelabel = args["template-whitelabel"] ?? "DLER";
+      const depth = args.depth ?? 0;
       let include = args.s ?? [];
       if (include.length === 0) {
         const raw = await maybePrompt(
@@ -476,7 +548,7 @@ export default defineCommand({
       const footer = args.footer;
       const selectFiles = args["select-files"] ?? false;
       const asTemplate = args["as-template"] ?? false;
-      let files = await collectFiles(include, ignore, recursive, sortBy);
+      let files = await collectFiles(include, ignore, recursive, sortBy, depth);
       if (files.length === 0) {
         throw new Error("No text files matched given patterns (binary/media files are skipped)");
       }
@@ -493,11 +565,11 @@ export default defineCommand({
           throw new Error("No files selected for merging");
         }
       }
-      if (args["update-template"]) {
+      if (args["template-update"]) {
         if (!outFile) {
           throw new Error("Output file path required for template update");
         }
-        const templateName = args["update-template"];
+        const templateName = args["template-update"];
         const templateData = {
           name: templateName.replace(/_DLER_TEMPLATE$/, "").replace(/_/g, " ").toLowerCase(),
           // Convert REACT_DLER_TEMPLATE to "react"
@@ -519,31 +591,35 @@ export default defineCommand({
               if (ext === "json") {
                 const jsonContent = JSON.parse(fileContent);
                 if (fileName === "package.json") {
-                  content = {
-                    ...jsonContent
-                  };
+                  content = jsonContent;
+                  type = "json";
+                  const magic = new MagicString(JSON.stringify(jsonContent, null, 2));
+                  magic.append(" satisfies PackageJson");
+                  content = magic.toString();
                 } else if (fileName === "tsconfig.json") {
-                  content = {
-                    ...jsonContent
-                  };
+                  content = jsonContent;
+                  type = "json";
+                  const magic = new MagicString(JSON.stringify(jsonContent, null, 2));
+                  magic.append(" satisfies TSConfig");
+                  content = magic.toString();
                 } else {
                   content = jsonContent;
+                  type = "json";
                 }
-                type = "json";
               } else {
                 content = fileContent;
                 type = "text";
               }
             } catch (error) {
               type = "binary";
-              if (asTemplate || args["update-template"]) {
+              if (asTemplate || args["template-update"]) {
                 relinka(
                   "warn",
                   `Skipped file "${relPath}" due to error: ${error instanceof Error ? error.message : "unknown error"}`
                 );
               }
             }
-          } else if (asTemplate || args["update-template"]) {
+          } else if (asTemplate || args["template-update"]) {
             relinka("warn", `Skipped binary file "${relPath}"`);
           }
           templateData.config.files[relPath] = {
@@ -579,114 +655,215 @@ export default defineCommand({
           pausedAt: null,
           pausedDuration: 0
         };
+        const templateMulti = args["template-multi"] ?? true;
+        const templatePerFile = args["template-per-file"] ?? false;
         if (!outFile) {
-          outFile = "template.ts";
+          outFile = templatePerFile ? "templates/index.ts" : "templates.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: {}
+        const baseDir = path.dirname(outFile);
+        if (templateMulti) {
+          const fileGroups = /* @__PURE__ */ new Map();
+          const templateDepth = depth;
+          for (const file of files) {
+            const relPath = path.relative(process.cwd(), file);
+            const parts = relPath.split(path.sep);
+            const groupKey = parts.slice(0, templateDepth + 1).join(path.sep);
+            if (!fileGroups.has(groupKey)) {
+              fileGroups.set(groupKey, []);
+            }
+            fileGroups.get(groupKey)?.push(file);
           }
-        };
-        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;
+          const templateNames = [];
+          for (const [groupKey, groupFiles] of fileGroups) {
+            const templateName = groupKey.split(path.sep).pop() || groupKey;
+            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(),
+              description: `Template generated from ${groupFiles.length} files in ${groupKey}`,
+              config: {
+                files: {}
+              }
+            };
+            for (const file of groupFiles) {
+              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;
+                      type = "json";
+                      const magic = new MagicString(JSON.stringify(jsonContent, null, 2));
+                      magic.append(" satisfies PackageJson");
+                      content = magic.toString();
+                    } else if (fileName === "tsconfig.json") {
+                      content = jsonContent;
+                      type = "json";
+                      const magic = new MagicString(JSON.stringify(jsonContent, null, 2));
+                      magic.append(" satisfies TSConfig");
+                      content = magic.toString();
+                    } else {
+                      content = jsonContent;
+                      type = "json";
+                    }
+                  } else {
+                    content = fileContent;
+                    type = "text";
+                  }
+                } catch (error) {
+                  type = "binary";
+                  if (asTemplate || args["template-update"]) {
+                    relinka(
+                      "warn",
+                      `Skipped file "${relPath}" due to error: ${error instanceof Error ? error.message : "unknown error"}`
+                    );
+                  }
                 }
-                type = "json";
+              } else if (asTemplate || args["template-update"]) {
+                relinka("warn", `Skipped binary file "${relPath}"`);
+              }
+              template.config.files[relPath] = {
+                content,
+                type
+              };
+            }
+            const templateContent = generateTemplateContent(
+              template,
+              templateConstName,
+              templateKey,
+              whitelabel,
+              isDev
+            );
+            if (templatePerFile) {
+              const templateFileName = `${templateKey}.ts`;
+              const templateFilePath = path.join(baseDir, templateFileName);
+              if (dryRun) {
+                relinka("verbose", `[DRY RUN] Would write template file: ${templateFilePath}`);
               } else {
-                content = fileContent;
-                type = "text";
+                await fs.ensureDir(path.dirname(templateFilePath));
+                if (backup && await fs.pathExists(templateFilePath)) {
+                  const backupPath = `${templateFilePath}.${Date.now()}.bak`;
+                  await fs.copyFile(templateFilePath, backupPath);
+                }
+                await fs.writeFile(templateFilePath, templateContent, "utf8");
               }
-            } catch (error) {
-              type = "binary";
-              if (asTemplate || args["update-template"]) {
-                relinka(
-                  "warn",
-                  `Skipped file "${relPath}" due to error: ${error instanceof Error ? error.message : "unknown error"}`
-                );
+              templateNames.push(templateKey);
+            } else {
+              if (!dryRun) {
+                await fs.ensureDir(path.dirname(outFile));
+                if (backup && await fs.pathExists(outFile)) {
+                  const backupPath = `${outFile}.${Date.now()}.bak`;
+                  await fs.copyFile(outFile, backupPath);
+                }
+                await fs.appendFile(outFile, templateContent + "\n\n", "utf8");
               }
+              templateNames.push(templateKey);
             }
-          } else if (asTemplate || args["update-template"]) {
-            relinka("warn", `Skipped binary file "${relPath}"`);
           }
-          template.config.files[relPath] = {
-            content,
-            type
+          if (templatePerFile) {
+            const aggregatorContent = generateAggregatorContent(templateNames, whitelabel, isDev);
+            if (dryRun) {
+              relinka("verbose", `[DRY RUN] Would write aggregator file: ${outFile}`);
+            } else {
+              await fs.ensureDir(path.dirname(outFile));
+              if (backup && await fs.pathExists(outFile)) {
+                const backupPath = `${outFile}.${Date.now()}.bak`;
+                await fs.copyFile(outFile, backupPath);
+              }
+              await fs.writeFile(outFile, aggregatorContent, "utf8");
+            }
+          }
+        } else {
+          const templateName = 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(),
+            description: `Template generated from ${files.length} files`,
+            config: {
+              files: {}
+            }
           };
-        }
-        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
+          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;
+                    type = "json";
+                    const magic = new MagicString(JSON.stringify(jsonContent, null, 2));
+                    magic.append(" satisfies PackageJson");
+                    content = magic.toString();
+                  } else if (fileName === "tsconfig.json") {
+                    content = jsonContent;
+                    type = "json";
+                    const magic = new MagicString(JSON.stringify(jsonContent, null, 2));
+                    magic.append(" satisfies TSConfig");
+                    content = magic.toString();
+                  } else {
+                    content = jsonContent;
+                    type = "json";
+                  }
+                } else {
+                  content = fileContent;
+                  type = "text";
+                }
+              } catch (error) {
+                type = "binary";
+                if (asTemplate || args["template-update"]) {
+                  relinka(
+                    "warn",
+                    `Skipped file "${relPath}" due to error: ${error instanceof Error ? error.message : "unknown error"}`
+                  );
+                }
+              }
+            } else if (asTemplate || args["template-update"]) {
+              relinka("warn", `Skipped binary file "${relPath}"`);
+            }
+            template.config.files[relPath] = {
+              content,
+              type
+            };
+          }
+          const templateContent = generateTemplateContent(
+            template,
+            templateConstName,
+            templateKey,
+            whitelabel,
+            isDev
           );
-          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);
+          if (dryRun) {
+            relinka("verbose", `[DRY RUN] Would write template file: ${outFile}`);
+          } else {
+            await fs.ensureDir(path.dirname(outFile));
+            if (backup && await fs.pathExists(outFile)) {
+              const backupPath = `${outFile}.${Date.now()}.bak`;
+              await fs.copyFile(outFile, backupPath);
+            }
+            await fs.writeFile(outFile, templateContent, "utf8");
+          }
         }
-        await fs.writeFile(outFile, tsContent, "utf8");
         const elapsed2 = getElapsedPerfTime(timer2);
         relinka(
           "success",
-          `Successfully ${dryRun ? "would generate" : "generated"} template file "${outFile}" (in ${prettyMilliseconds(elapsed2)})`
+          `Successfully ${dryRun ? "would generate" : "generated"} template file(s) (in ${prettyMilliseconds(elapsed2)})`
         );
         return;
       }

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

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

package/bin/libs/sdk/sdk-impl/pub/pub-library.js

@@ -8,6 +8,7 @@ export async function library_publishLibrary(effectivePubRegistry, libName, npmO
   switch (effectivePubRegistry) {
     case "jsr":
       relinka("log", `Publishing lib ${libName} to JSR only...`);
+      relinka("null", "");
       await library_pubToJsr(
         jsrOutDir,
         distJsrDryRun,
@@ -21,10 +22,12 @@ export async function library_publishLibrary(effectivePubRegistry, libName, npmO
       break;
     case "npm":
       relinka("log", `Publishing lib ${libName} to NPM only...`);
+      relinka("null", "");
       await library_pubToNpm(npmOutDir, distJsrDryRun, distJsrFailOnWarn, libName, isDev, timer);
       break;
     case "npm-jsr": {
       relinka("log", `Publishing lib ${libName} to both NPM and JSR...`);
+      relinka("null", "");
       const publishTasks = [
         () => library_pubToNpm(npmOutDir, distJsrDryRun, distJsrFailOnWarn, libName, isDev, timer),
         () => library_pubToJsr(
@@ -54,6 +57,7 @@ async function library_pubToJsr(libOutDir, distJsrDryRun, distJsrFailOnWarn, dis
     if (timer) pausePerfTimer(timer);
     await withWorkingDirectory(libOutDir, async () => {
       relinka("log", `Publishing lib ${libName} to JSR from ${libOutDir}`);
+      relinka("null", "");
       const command = [
         "bun x jsr publish",
         distJsrDryRun ? "--dry-run" : "",
@@ -62,8 +66,9 @@ async function library_pubToJsr(libOutDir, distJsrDryRun, distJsrFailOnWarn, dis
         distJsrSlowTypes ? "--allow-slow-types" : ""
       ].filter(Boolean).join(" ");
       await execaCommand(command, { stdio: "inherit" });
+      relinka("null", "");
       relinka(
-        "success",
+        "log",
         `Successfully ${distJsrDryRun ? "validated" : "published"} lib ${libName} to JSR registry`
       );
     });
@@ -79,10 +84,12 @@ async function library_pubToNpm(libOutDir, distJsrDryRun, _distJsrFailOnWarn, li
     if (timer) pausePerfTimer(timer);
     await withWorkingDirectory(libOutDir, async () => {
       relinka("log", `Publishing lib ${libName} to NPM from ${libOutDir}`);
+      relinka("null", "");
       const command = ["bun publish", distJsrDryRun ? "--dry-run" : ""].filter(Boolean).join(" ");
       await execaCommand(command, { stdio: "inherit" });
+      relinka("null", "");
       relinka(
-        "success",
+        "log",
         `Successfully ${distJsrDryRun ? "validated" : "published"} lib ${libName} to NPM registry`
       );
     });
@@ -90,7 +97,5 @@ async function library_pubToNpm(libOutDir, distJsrDryRun, _distJsrFailOnWarn, li
   } catch (error) {
     if (timer) resumePerfTimer(timer);
     throw error;
-  } finally {
-    relinka("verbose", `Exiting library_pubToNpm for lib: ${libName}`);
   }
 }

package/bin/libs/sdk/sdk-impl/pub/pub-regular.js

@@ -20,10 +20,8 @@ export async function regular_pubToJsr(distJsrDryRun, distJsrFailOnWarn, _isDev,
         ].filter(Boolean).join(" ");
         relinka("verbose", `Running publish command: ${command}`);
         await execaCommand(command, { stdio: "inherit" });
-        relinka(
-          "success",
-          `Successfully ${distJsrDryRun ? "validated" : "published"} to JSR registry`
-        );
+        relinka("null", "");
+        relinka("log", `Successfully ${distJsrDryRun ? "validated" : "published"} to JSR registry`);
       });
       if (timer) resumePerfTimer(timer);
     }
@@ -42,10 +40,8 @@ export async function regular_pubToNpm(distJsrDryRun, _isDev, commonPubPause, di
         const command = ["bun publish", distJsrDryRun ? "--dry-run" : ""].filter(Boolean).join(" ");
         relinka("verbose", `Running publish command: ${command}`);
         await execaCommand(command, { stdio: "inherit" });
-        relinka(
-          "success",
-          `Successfully ${distJsrDryRun ? "validated" : "published"} to NPM registry`
-        );
+        relinka("null", "");
+        relinka("log", `Successfully ${distJsrDryRun ? "validated" : "published"} to NPM registry`);
       });
       if (timer) resumePerfTimer(timer);
     }

package/bin/libs/sdk/sdk-impl/utils/utils-error-cwd.js

@@ -20,7 +20,7 @@ export async function withWorkingDirectory(transpileTargetDir, fn) {
   const originalDir = process.cwd();
   try {
     process.chdir(transpileTargetDir);
-    relinka("info", `CWD (current working directory): ${originalDir} -> ${transpileTargetDir}`);
+    relinka("log", `CWD (current working directory): ${originalDir} -> ${transpileTargetDir}`);
     const result = await fn();
     return result;
   } catch (error) {
@@ -29,7 +29,7 @@ export async function withWorkingDirectory(transpileTargetDir, fn) {
     throw error;
   } finally {
     process.chdir(originalDir);
-    relinka("info", `CWD (current working directory): ${transpileTargetDir} -> ${originalDir}`);
+    relinka("log", `CWD (current working directory): ${transpileTargetDir} -> ${originalDir}`);
   }
 }
 export async function validateDevCwd(isDev, paths, cliName, cliOrg = "") {

package/package.json

@@ -6,7 +6,7 @@
     "@reliverse/relico": "^1.1.2",
     "@reliverse/relifso": "^1.4.5",
     "@reliverse/relinka": "^1.4.7",
-    "@reliverse/rempts": "^1.7.18",
+    "@reliverse/rempts": "^1.7.19",
     "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-commonjs": "^28.0.3",
     "@rollup/plugin-json": "^6.1.0",
@@ -44,7 +44,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.14",
+  "version": "1.7.16",
   "keywords": [
     "reliverse",
     "cli",

package/bin/templates/App.css

@@ -1,31 +0,0 @@
-#root {
-  max-width: 1280px;
-  margin: 0 auto;
-  padding: 2rem;
-  text-align: center;
-}
-
-.card {
-  padding: 2em;
-}
-
-button {
-  border-radius: 8px;
-  border: 1px solid transparent;
-  padding: 0.6em 1.2em;
-  font-size: 1em;
-  font-weight: 500;
-  font-family: inherit;
-  background-color: #1a1a1a;
-  cursor: pointer;
-  transition: border-color 0.25s;
-}
-
-button:hover {
-  border-color: #646cff;
-}
-
-button:focus,
-button:focus-visible {
-  outline: 4px auto -webkit-focus-ring-color;
-}

package/bin/templates/App.tsx

@@ -1,21 +0,0 @@
-import { useState } from "react";
-import "./App.css";
-
-function App() {
-  const [count, setCount] = useState(0);
-
-  return (
-    // @ts-expect-error mock
-    <div className="App">
-      {/* @ts-expect-error mock */}
-      <h1>React TSX App</h1>
-      {/* @ts-expect-error mock */}
-      <div className="card">
-        {/* @ts-expect-error mock */}
-        <button onClick={() => setCount((count: number) => count + 1)}>count is {count}</button>
-      </div>
-    </div>
-  );
-}
-
-export default App;

package/bin/templates/DOCS.md

@@ -1,31 +0,0 @@
-# React TSX Project
-
-A modern React project with TypeScript and Vite.
-
-## Features
-
-- React 19 with TypeScript
-- Vite for fast development and building
-- Modern CSS with CSS modules support
-- Hot Module Replacement (HMR)
-- ESLint and Prettier configuration
-
-## Getting Started
-
-1. Install dependencies:
-
-   ```bash
-   npm install
-   ```
-
-2. Start development server:
-
-   ```bash
-   npm run dev
-   ```
-
-3. Build for production:
-
-   ```bash
-   npm run build
-   ```

package/bin/templates/globals.css

@@ -1,27 +0,0 @@
-:root {
-  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
-  line-height: 1.5;
-  font-weight: 400;
-
-  color-scheme: light dark;
-  color: rgba(255, 255, 255, 0.87);
-  background-color: #242424;
-
-  font-synthesis: none;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-body {
-  margin: 0;
-  display: flex;
-  place-items: center;
-  min-width: 320px;
-  min-height: 100vh;
-}
-
-h1 {
-  font-size: 3.2em;
-  line-height: 1.1;
-}

package/bin/templates/hello/world.ts

@@ -1 +0,0 @@
-console.log("Hello, world!");

package/bin/templates/index.html

@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>React TSX App</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

package/bin/templates/main.tsx

@@ -1,11 +0,0 @@
-import React from "react";
-// @ts-expect-error mock
-import ReactDOM from "react-dom/client";
-import App from "./App";
-import "./index.css";
-
-ReactDOM.createRoot(document.getElementById("root")!).render(
-  <React.StrictMode>
-    <App />
-  </React.StrictMode>,
-);