@reliverse/dler 1.7.91 → 1.7.93

package/bin/app/memory/cmd.js

@@ -0,0 +1,26 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { getOrCreateReliverseMemory } from "../utils/reliverseMemory.js";
+export default defineCommand({
+  meta: {
+    name: "memory",
+    description: "Displays the data stored in rseory",
+    hidden: true
+  },
+  run: async () => {
+    const memory = await getOrCreateReliverseMemory();
+    relinka("info", "Current memory values:");
+    console.log({
+      code: memory.code === "" ? "" : "exists",
+      key: memory.key === "" ? "" : "exists",
+      githubKey: memory.githubKey === "" ? "" : "exists",
+      vercelKey: memory.vercelKey === "" ? "" : "exists",
+      name: memory.name ?? "",
+      email: memory.email ?? "",
+      githubUsername: memory.githubUsername ?? "",
+      vercelTeamSlug: memory.vercelTeamSlug ?? "",
+      vercelTeamId: memory.vercelTeamId ?? ""
+    });
+    process.exit(0);
+  }
+});

package/bin/app/memory/memory-impl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@reliverse/rempts").Command<import("@reliverse/rempts").EmptyArgs>;
+export default _default;

package/bin/app/memory/memory-impl.js

@@ -0,0 +1,26 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { getOrCreateReliverseMemory } from "../utils/reliverseMemory.js";
+export default defineCommand({
+  meta: {
+    name: "memory",
+    description: "Displays the data stored in rseory",
+    hidden: true
+  },
+  run: async () => {
+    const memory = await getOrCreateReliverseMemory();
+    relinka("info", "Current memory values:");
+    console.log({
+      code: memory.code === "" ? "" : "exists",
+      key: memory.key === "" ? "" : "exists",
+      githubKey: memory.githubKey === "" ? "" : "exists",
+      vercelKey: memory.vercelKey === "" ? "" : "exists",
+      name: memory.name ?? "",
+      email: memory.email ?? "",
+      githubUsername: memory.githubUsername ?? "",
+      vercelTeamSlug: memory.vercelTeamSlug ?? "",
+      vercelTeamId: memory.vercelTeamId ?? ""
+    });
+    process.exit(0);
+  }
+});

package/bin/app/merge/cmd.js

@@ -3,31 +3,30 @@ import { glob } from "@reliverse/reglob";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import {
+  confirmPrompt,
+  defineArgs,
   defineCommand,
   inputPrompt,
-  confirmPrompt,
-  multiselectPrompt,
-  defineArgs
+  multiselectPrompt
 } from "@reliverse/rempts";
-import MagicString from "magic-string";
-import { Bundle } from "magic-string";
+import MagicString, { 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 { getCommentPrefix } from "../../libs/sdk/sdk-impl/utils/comments.js";
-import { createPerfTimer, getElapsedPerfTime } from "../../libs/sdk/sdk-impl/utils/utils-perf.js";
+import { isBinaryExt } from "../utils/binary.js";
+import { getCommentPrefix } from "../utils/comments.js";
+import { createPerfTimer, getElapsedPerfTime } from "../utils/utils-perf.js";
 import {
-  checkPermissions,
   checkFileSize,
-  handleError,
-  validateFileExists,
+  checkPermissions,
+  handleCtxError,
   sanitizeInput,
-  validateMergeOperation,
   setFileSizeLimits,
-  validatePath,
+  validateContent,
+  validateFileExists,
   validateFileType,
-  validateContent
-} from "../../libs/sdk/sdk-impl/utils/utils-security.js";
+  validateMergeOperation,
+  validatePath
+} from "../utils/utils-security.js";
 const DEFAULT_IGNORES = ["**/.git/**", "**/node_modules/**"];
 const DEFAULT_SEPARATOR_RAW = "\\n\\n";
 const normalizeGlobPattern = (pattern) => {
@@ -95,7 +94,7 @@ const collectFiles = async (include, extraIgnore, recursive, sortBy, depth) => {
     }
     return filtered;
   } catch (error) {
-    handleError(error, "collectFiles");
+    handleCtxError(error, "collectFiles");
     return [];
   }
 };
@@ -146,7 +145,7 @@ const writeResult = async (sections, _separator, toFile, toStdout, dryRun, backu
       }
     }
   } catch (error) {
-    handleError(error, "writeResult");
+    handleCtxError(error, "writeResult");
   }
 };
 const writeFilesPreserveStructure = async (files, outDir, preserveStructure, increment, concurrency, dryRun, backup) => {
@@ -198,7 +197,7 @@ const writeFilesPreserveStructure = async (files, outDir, preserveStructure, inc
       { concurrency }
     );
   } catch (error) {
-    handleError(error, "writeFilesPreserveStructure");
+    handleCtxError(error, "writeFilesPreserveStructure");
   }
 };
 const processSection = (raw, rel, prefix, pathAbove, injectPath) => {

package/bin/app/migrate/codemods/anything-bun.js

@@ -1,7 +1,7 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join, resolve } from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
-import { existsSync } from "node:fs";
-import { mkdir, writeFile, readFile } from "node:fs/promises";
 import { readPackageJSON } from "pkg-types";
 import { glob } from "tinyglobby";
 const NODE_MODULES = [

package/bin/app/migrate/codemods/commander-rempts.js

@@ -1,5 +1,5 @@
 import { glob } from "tinyglobby";
-import { Project, Node, ScriptTarget, ModuleKind, SyntaxKind } from "ts-morph";
+import { ModuleKind, Node, Project, ScriptTarget, SyntaxKind } from "ts-morph";
 function parseCommanderFlags(flags) {
   const parts = flags.split(/[\s,]+/).filter(Boolean);
   let longName = "";
@@ -26,7 +26,7 @@ function parseCommanderFlags(flags) {
   return { longName, shortName, takesValue };
 }
 function getDefaultValueText(node) {
-  if (!node) return void 0;
+  if (!node) return;
   if (Node.isLiteralExpression(node)) {
     return node.getText();
   }
@@ -145,7 +145,7 @@ function extractCommandInfo(node, sourceFile) {
     }
     return info;
   }
-  return void 0;
+  return;
 }
 function handleActionMethod(node, info, sourceFile) {
   const [actionArg] = node.getArguments();

package/bin/app/migrate/codemods/console-relinka.js

@@ -1,6 +1,6 @@
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { selectPrompt, inputPrompt } from "@reliverse/rempts";
+import { inputPrompt, selectPrompt } from "@reliverse/rempts";
 export async function consoleToRelinka(input, from, to) {
   const finalInput = input ?? await inputPrompt({
     title: "Enter input file or directory path",

package/bin/app/migrate/codemods/fs-relifso.js

@@ -1,6 +1,6 @@
-import { join, extname } from "@reliverse/pathkit";
 import { existsSync } from "node:fs";
-import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { extname, join } from "@reliverse/pathkit";
 async function getAllTsFiles(dir) {
   const files = [];
   try {

package/bin/app/migrate/codemods/nodenext-bundler.js

@@ -1,7 +1,6 @@
-import { getFileImportsExports } from "@reliverse/pathkit";
-import { join, extname } from "@reliverse/pathkit";
 import { existsSync } from "node:fs";
-import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { extname, getFileImportsExports, join } from "@reliverse/pathkit";
 async function getAllTsFiles(dir) {
   const files = [];
   try {

package/bin/app/migrate/codemods/path-pathkit.js

@@ -1,6 +1,6 @@
-import { join, extname } from "@reliverse/pathkit";
 import { existsSync } from "node:fs";
-import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { extname, join } from "@reliverse/pathkit";
 async function getAllTsFiles(dir) {
   const files = [];
   try {

package/bin/app/migrate/codemods/readdir-glob.js

@@ -1,6 +1,6 @@
-import { join, extname } from "@reliverse/pathkit";
 import { existsSync } from "node:fs";
-import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { extname, join } from "@reliverse/pathkit";
 async function getAllTsFiles(dir) {
   const files = [];
   try {

package/bin/app/mkdist/cmd.js

@@ -1,8 +1,8 @@
 import { resolve } from "@reliverse/pathkit";
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerBuild } from "../build/impl.js";
-import { mkdist } from "../../libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/make.js";
-import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/prepare.js";
+import { mkdist } from "../build/providers/mkdist/mkdist-impl/make.js";
+import { ensureDlerConfig } from "../config/prepare.js";
 export default defineCommand({
   meta: {
     name: "mkdist",

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

@@ -0,0 +1,41 @@
+/**
+ * Generates rse config files for multiple projects
+ */
+declare const _default: import("@reliverse/rempts").Command<{
+    ts: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    dev: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    jsonc: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    nocache: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    fresh: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    typesPath: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    _: {
+        type: "array";
+        description: string;
+        required: false;
+    };
+}>;
+export default _default;

package/bin/app/mrse/cmd.js

@@ -0,0 +1,395 @@
+import path from "@reliverse/pathkit";
+import fs, { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import { parseJSONC } from "confbox";
+import { execaCommand } from "execa";
+import { jsonrepair } from "jsonrepair";
+import { builders, loadFile, writeFile } from "magicast";
+import { generateRseConfig } from "../config/cfg-create.js";
+import { UNKNOWN_VALUE } from "../config/constants.js";
+import {
+  downloadFileFromGitHub,
+  ensureEnvCacheDir,
+  getEnvCacheDir,
+  getEnvCachePath,
+  logVerbose
+} from "./mrse-impl.js";
+export default defineCommand({
+  meta: {
+    name: "mrse",
+    description: "Generate rse config files for multiple projects",
+    hidden: true
+  },
+  args: {
+    ts: {
+      type: "boolean",
+      description: "Generate TypeScript config files (default is JSONC)",
+      default: false
+    },
+    dev: {
+      type: "boolean",
+      description: "Generate configs in development mode",
+      default: false
+    },
+    jsonc: {
+      type: "boolean",
+      description: "Generate JSONC config files (default)",
+      default: true
+    },
+    nocache: {
+      type: "boolean",
+      description: "Disable caching of downloaded .env.example files",
+      default: false
+    },
+    fresh: {
+      type: "boolean",
+      description: "Redownload all cached .env.example files, ignoring existing cache",
+      default: false
+    },
+    typesPath: {
+      type: "string",
+      description: "Custom path to type definitions for TypeScript configs",
+      default: "../src/libs/sdk/sdk-mod"
+    },
+    _: {
+      type: "array",
+      description: "Names of projects to generate configs for",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const useJsonc = !args.ts;
+    const projectNames = args._ || [];
+    const devFlag = args.dev === true;
+    const isDev = devFlag || process.env.NODE_ENV === "development";
+    const cacheFlag = !args.nocache;
+    const freshFlag = args.fresh === true;
+    logVerbose("Parsed arguments:", args);
+    logVerbose("Project names:", projectNames);
+    logVerbose("Format:", useJsonc ? "JSONC" : "TypeScript");
+    logVerbose("Dev mode:", isDev);
+    logVerbose("Using cache:", cacheFlag);
+    logVerbose("Fresh mode:", freshFlag);
+    if (freshFlag) {
+      relinka("info", "Fresh mode enabled: Will redownload all cached .env.example files");
+    }
+    const cwd = process.cwd();
+    const mrseFolderPath = path.join(cwd, ".config", "mrse");
+    await ensuredir(mrseFolderPath);
+    const mrseFileName = useJsonc ? "mreliverse.jsonc" : "mreliverse.ts";
+    const mrsePath = path.join(cwd, ".config", mrseFileName);
+    const mrseExists = await fs.pathExists(mrsePath);
+    const oppositeFormatFileName = useJsonc ? "mreliverse.ts" : "mreliverse.jsonc";
+    const oppositeFormatPath = path.join(cwd, ".config", oppositeFormatFileName);
+    const oppositeFormatExists = await fs.pathExists(oppositeFormatPath);
+    if (!mrseExists && oppositeFormatExists) {
+      relinka(
+        "error",
+        `Cannot generate ${mrseFileName} when ${oppositeFormatFileName} already exists. Please delete ${oppositeFormatFileName} first or use the appropriate format flag.`
+      );
+      process.exit(1);
+    }
+    let genCfgData = [];
+    const existingFiles = await fs.readdir(mrseFolderPath);
+    const hasJsoncFiles = existingFiles.some(
+      (file) => file.endsWith(".jsonc") && file !== "mreliverse.jsonc"
+    );
+    const hasTsFiles = existingFiles.some(
+      (file) => file.endsWith(".ts") && file !== "mreliverse.ts"
+    );
+    if (useJsonc && hasTsFiles || !useJsonc && hasJsoncFiles) {
+      const currentFormat = useJsonc ? "JSONC" : "TypeScript";
+      const existingFormat = useJsonc ? "TypeScript" : "JSONC";
+      relinka(
+        "error",
+        `Cannot generate ${currentFormat} files when ${existingFormat} files already exist in the mrse folder. Please use --${useJsonc ? "ts" : "jsonc"} flag to match your existing configuration format.`
+      );
+      process.exit(1);
+    }
+    if (!mrseExists) {
+      relinka("info", `Generating ${mrseFileName} file...`);
+      let mrseContent = "";
+      if (useJsonc) {
+        mrseContent = `{
+  // @reliverse/rse mrse mode
+  // \u{1F449} ${isDev ? "`bun dev:mrse`" : "`rse mrse`"}
+  "genCfg": [
+    {
+      "projectName": "project1",
+      "projectTemplate": "blefnk/relivator-nextjs-template",
+      "getEnvExample": true
+    },
+    {
+      "projectName": "project2",
+      "projectTemplate": "blefnk/relivator-nextjs-template",
+      "getEnvExample": true
+    },
+    {
+      "projectName": "project3",
+      "projectTemplate": "blefnk/relivator-nextjs-template",
+      "getEnvExample": true
+    }
+  ]
+}`;
+      } else {
+        mrseContent = `// @reliverse/rse mrse mode
+// \u{1F449} ${isDev ? "`bun dev:mrse`" : "`rse mrse`"}
+type GenCfg = {
+  projectName: string;
+  projectTemplate: string;
+  getEnvExample: boolean;
+  projectPath?: string;
+};
+export const genCfg: GenCfg[] = [
+  {
+    projectName: "project1",
+    projectTemplate: "blefnk/relivator-nextjs-template",
+    getEnvExample: true,
+  },
+  {
+    projectName: "project2",
+    projectTemplate: "blefnk/relivator-nextjs-template",
+    getEnvExample: true,
+  },
+  {
+    projectName: "project3",
+    projectTemplate: "blefnk/relivator-nextjs-template",
+    getEnvExample: true,
+  },
+];
+`;
+      }
+      if (useJsonc) {
+        await fs.writeFile(mrsePath, mrseContent);
+      } else {
+        try {
+          const mod = builders.raw(mrseContent);
+          await writeFile(mod, mrsePath);
+        } catch {
+          await fs.writeFile(mrsePath, mrseContent);
+        }
+      }
+      relinka("success", `Generated ${mrseFileName} in .config folder`);
+      genCfgData = [
+        {
+          projectName: "project1",
+          projectTemplate: "blefnk/relivator-nextjs-template",
+          getEnvExample: true
+        },
+        {
+          projectName: "project2",
+          projectTemplate: "blefnk/relivator-nextjs-template",
+          getEnvExample: true
+        },
+        {
+          projectName: "project3",
+          projectTemplate: "blefnk/relivator-nextjs-template",
+          getEnvExample: true
+        }
+      ];
+      if (projectNames.length === 0) {
+        relinka("info", "No project names specified. Only generated the config file.");
+        return;
+      }
+    } else {
+      relinka("info", `Using existing ${mrseFileName} file`);
+      try {
+        if (useJsonc) {
+          const fileContent = await fs.readFile(mrsePath, "utf-8");
+          try {
+            const parsedData = parseJSONC(fileContent);
+            genCfgData = parsedData.genCfg || [];
+          } catch (parseError) {
+            relinka(
+              "warn",
+              `JSONC parsing failed, attempting to repair the file: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+            );
+            try {
+              const commentStrippedContent = fileContent.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+              const repairedJson = jsonrepair(commentStrippedContent);
+              const parsedData = JSON.parse(repairedJson);
+              genCfgData = parsedData.genCfg || [];
+              relinka("success", "JSON repaired successfully");
+            } catch (repairError) {
+              relinka(
+                "error",
+                `Failed to repair JSON: ${repairError instanceof Error ? repairError.message : String(repairError)}`
+              );
+              throw new Error("Unable to parse or repair the JSON configuration file");
+            }
+          }
+        } else {
+          try {
+            const mod = await loadFile(mrsePath);
+            if (mod.exports && mod.exports.genCfg) {
+              genCfgData = JSON.parse(JSON.stringify(mod.exports.genCfg));
+            } else {
+              relinka("warn", "The mreliverse.ts file does not export a 'genCfg' array");
+              genCfgData = [];
+            }
+          } catch (error) {
+            relinka(
+              "error",
+              `Error loading TypeScript file: ${error instanceof Error ? error.message : String(error)}`
+            );
+            genCfgData = [];
+          }
+        }
+        logVerbose("Loaded mrse data:", genCfgData);
+      } catch (error) {
+        relinka(
+          "error",
+          `Error parsing ${mrseFileName}: ${error instanceof Error ? error.message : String(error)}`
+        );
+        relinka("warn", "Continuing with empty configuration");
+        genCfgData = [];
+      }
+    }
+    let projectsToProcess = [];
+    if (projectNames.length > 0) {
+      const matchingProjects = projectNames.filter(
+        (name) => genCfgData.some((cfg) => cfg.projectName === name)
+      );
+      if (matchingProjects.length > 0) {
+        projectsToProcess = matchingProjects;
+        relinka("info", `Found ${matchingProjects.length} matching projects in ${mrseFileName}`);
+      } else {
+        projectsToProcess = projectNames;
+      }
+    } else if (mrseExists) {
+      projectsToProcess = genCfgData.map((cfg) => cfg.projectName);
+      relinka("info", `Processing all ${projectsToProcess.length} projects from ${mrseFileName}`);
+    }
+    if (projectsToProcess.length === 0) {
+      relinka(
+        "info",
+        "No projects to process. Either specify project names or populate the gen.cfg file."
+      );
+      return;
+    }
+    if (cacheFlag && genCfgData.some((cfg) => cfg.getEnvExample && cfg.projectTemplate)) {
+      await ensureEnvCacheDir();
+      logVerbose(`Env cache directory: ${getEnvCacheDir()}`);
+    }
+    let generatedCount = 0;
+    let envFilesDownloaded = 0;
+    let envFilesFromCache = 0;
+    let envFilesRefreshed = 0;
+    for (const projectName of projectsToProcess) {
+      relinka("verbose", `Generating config for project: ${projectName}`);
+      try {
+        const projectConfig = genCfgData.find((cfg) => cfg.projectName === projectName);
+        logVerbose(`Found config for ${projectName}:`, projectConfig);
+        if (projectConfig?.getEnvExample && projectConfig?.projectTemplate) {
+          const cachePath = getEnvCachePath(projectConfig.projectTemplate);
+          const cacheExists = cacheFlag && await fs.pathExists(cachePath);
+          if (cacheExists && !freshFlag) {
+            relinka(
+              "info",
+              `Using cached .env.example for ${projectName} from ${projectConfig.projectTemplate}`
+            );
+            const envFilePath = path.join(mrseFolderPath, `${projectName}.env`);
+            await fs.copy(cachePath, envFilePath);
+            relinka("success", `Created ${projectName}.env from cache`);
+            envFilesFromCache++;
+          } else {
+            const isRefreshing = freshFlag && cacheExists;
+            if (isRefreshing) {
+              relinka(
+                "info",
+                `Refreshing .env.example for ${projectName} from ${projectConfig.projectTemplate}`
+              );
+            } else {
+              relinka(
+                "info",
+                `Downloading .env.example for ${projectName} from ${projectConfig.projectTemplate}`
+              );
+            }
+            const envContent = await downloadFileFromGitHub(
+              projectConfig.projectTemplate,
+              ".env.example",
+              "main",
+              cacheFlag,
+              freshFlag
+            );
+            if (envContent) {
+              const envFilePath = path.join(mrseFolderPath, `${projectName}.env`);
+              await fs.writeFile(envFilePath, envContent);
+              if (isRefreshing) {
+                relinka("success", `Refreshed and saved ${projectName}.env`);
+                envFilesRefreshed++;
+              } else {
+                relinka("success", `Downloaded and saved ${projectName}.env`);
+                envFilesDownloaded++;
+              }
+            } else {
+              relinka("warn", `Could not download .env.example for ${projectName}`);
+            }
+          }
+        }
+        const configFileName = useJsonc ? `${projectName}.jsonc` : `${projectName}.ts`;
+        const configPath = path.join(mrseFolderPath, configFileName);
+        const fileExists = await fs.pathExists(configPath);
+        logVerbose(`File ${configPath} already exists: ${fileExists}`);
+        if (fileExists) {
+          relinka("warn", `Skipping ${projectName} - file already exists: ${configFileName}`);
+          continue;
+        }
+        const githubUsername = UNKNOWN_VALUE;
+        const skipInstallPrompt = !useJsonc && isDev;
+        let customTypeImportPath;
+        if (!useJsonc && isDev) {
+          customTypeImportPath = args.typesPath;
+        }
+        logVerbose("Using custom type import path:", customTypeImportPath);
+        await generateRseConfig({
+          projectName,
+          frontendUsername: UNKNOWN_VALUE,
+          deployService: "vercel",
+          primaryDomain: `https://${projectName}.vercel.app`,
+          projectPath: projectConfig?.projectPath || cwd,
+          githubUsername,
+          isDev,
+          customOutputPath: mrseFolderPath,
+          customFilename: configFileName,
+          skipInstallPrompt,
+          ...customTypeImportPath ? { customPathToTypes: customTypeImportPath } : {},
+          // Override project config fields
+          ...projectConfig?.projectTemplate ? { projectTemplate: projectConfig.projectTemplate } : {},
+          overrides: {}
+        });
+        relinka("success", `Generated ${configFileName} in mrse folder`);
+        generatedCount++;
+      } catch (error) {
+        relinka(
+          "error",
+          `Failed to generate config for ${projectName}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (generatedCount > 0 || envFilesDownloaded > 0 || envFilesFromCache > 0 || envFilesRefreshed > 0) {
+      if (generatedCount > 0) {
+        relinka("success", `Generated ${generatedCount} configs in the mrse folder.`);
+      }
+      if (envFilesDownloaded > 0) {
+        relinka("success", `Downloaded ${envFilesDownloaded} .env files from templates.`);
+      }
+      if (envFilesFromCache > 0) {
+        relinka("success", `Used ${envFilesFromCache} .env files from cache.`);
+      }
+      if (envFilesRefreshed > 0) {
+        relinka("success", `Refreshed ${envFilesRefreshed} .env files from templates.`);
+      }
+    } else {
+      relinka("info", "No new files were generated.");
+    }
+    if (isDev) {
+      await fs.copy(path.join(cwd, "schema.json"), path.join(mrseFolderPath, "schema.json"));
+      await execaCommand("bunx biome check --write .", {
+        cwd: mrseFolderPath,
+        stdio: "inherit"
+      });
+    }
+  }
+});