@reliverse/dler 1.7.16 → 1.7.17

package/bin/app/merge/cmd.js

@@ -14,6 +14,7 @@ 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 { getCommentPrefix } from "../../libs/sdk/sdk-impl/utils/comments.js";
 import { createPerfTimer, getElapsedPerfTime } from "../../libs/sdk/sdk-impl/utils/utils-perf.js";
 import {
   checkPermissions,
@@ -21,44 +22,13 @@ import {
   handleError,
   validateFileExists,
   sanitizeInput,
-  validateMergeOperation
+  validateMergeOperation,
+  setFileSizeLimits,
+  validatePath,
+  validateFileType,
+  validateContent
 } from "../../libs/sdk/sdk-impl/utils/utils-security.js";
 const DEFAULT_IGNORES = ["**/.git/**", "**/node_modules/**"];
-const COMMENT_MAP = {
-  js: "// ",
-  jsx: "// ",
-  ts: "// ",
-  tsx: "// ",
-  c: "// ",
-  cpp: "// ",
-  h: "// ",
-  java: "// ",
-  go: "// ",
-  kt: "// ",
-  swift: "// ",
-  rs: "// ",
-  cs: "// ",
-  json: "// ",
-  proto: "// ",
-  dart: "// ",
-  py: "# ",
-  rb: "# ",
-  sh: "# ",
-  pl: "# ",
-  r: "# ",
-  yml: "# ",
-  yaml: "# ",
-  sql: "-- ",
-  lua: "-- ",
-  css: "/* ",
-  scss: "/* ",
-  less: "/* ",
-  html: "<!-- ",
-  htm: "<!-- ",
-  xml: "<!-- ",
-  md: "<!-- "
-};
-const DEFAULT_COMMENT = "// ";
 const DEFAULT_SEPARATOR_RAW = "\\n\\n";
 const normalizeGlobPattern = (pattern) => {
   const sanitizedPattern = sanitizeInput(pattern);
@@ -82,12 +52,22 @@ const collectFiles = async (include, extraIgnore, recursive, sortBy, depth) => {
       onlyFiles: true,
       deep: recursive ? void 0 : 1
     });
+    const validFiles = [];
+    let binaryFilesDetected = false;
     for (const file of files) {
       await validateFileExists(file, "merge");
       await checkFileSize(file);
       await checkPermissions(file, "read");
+      if (await isBinaryExt(file)) {
+        binaryFilesDetected = true;
+        continue;
+      }
+      validFiles.push(file);
+    }
+    if (binaryFilesDetected) {
+      relinka("info", "Binary files were detected and skipped");
     }
-    let filtered = [...new Set(files)];
+    let filtered = [...new Set(validFiles)];
     if (depth > 0) {
       const fileGroups = /* @__PURE__ */ new Map();
       for (const file of filtered) {
@@ -97,7 +77,10 @@ const collectFiles = async (include, extraIgnore, recursive, sortBy, depth) => {
         if (!fileGroups.has(groupKey)) {
           fileGroups.set(groupKey, []);
         }
-        fileGroups.get(groupKey)?.push(file);
+        const group = fileGroups.get(groupKey);
+        if (group) {
+          group.push(file);
+        }
       }
       filtered = Array.from(fileGroups.values()).flat();
     }
@@ -120,6 +103,7 @@ const writeResult = async (sections, _separator, toFile, toStdout, dryRun, backu
   try {
     const bundle = new Bundle();
     for (const section of sections) {
+      validateContent(section, "text");
       bundle.addSource({
         content: new MagicString(section)
       });
@@ -144,6 +128,8 @@ const writeResult = async (sections, _separator, toFile, toStdout, dryRun, backu
     }
     if (!dryRun) {
       await checkPermissions(sanitizedPath, "write");
+      validatePath(sanitizedPath, process.cwd());
+      validateFileType("text");
       await fs.writeFile(sanitizedPath, finalContent, "utf8");
       if (generateSourceMap) {
         const map = bundle.generateMap({
@@ -227,107 +213,14 @@ ${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;
-        }
-      }
-    }
-    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");
-  }
-};
-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",
-    version: "1.0.0",
+    version: "1.2.1",
     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" },
     ignore: { type: "array", description: "Extra ignore patterns" },
@@ -336,6 +229,14 @@ export default defineCommand({
       default: "txt",
       description: "Fallback extension when output path is omitted"
     },
+    "max-file-size": {
+      type: "number",
+      description: "Maximum size of a single file in bytes (default: 10MB)"
+    },
+    "max-merge-size": {
+      type: "number",
+      description: "Maximum total size of all files to merge in bytes (default: 100MB)"
+    },
     stdout: { type: "boolean", description: "Print to stdout" },
     noPath: {
       type: "boolean",
@@ -423,42 +324,27 @@ export default defineCommand({
       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"
-    },
-    "template-whitelabel": {
-      type: "string",
-      description: "Custom prefix to use instead of 'DLER' in template generation",
-      default: "DLER",
-      dependencies: ["as-template"]
-    },
-    "template-update": {
-      type: "string",
-      description: "Update specific template in existing mock template file",
-      dependencies: ["as-template"]
-    },
-    "template-multi": {
+    verbose: {
       type: "boolean",
-      description: "Create multiple templates based on directory structure (default: true)",
-      default: true,
-      dependencies: ["as-template"]
+      description: "Enable verbose logging"
     },
-    "template-per-file": {
+    force: {
       type: "boolean",
-      description: "Create separate files for each template with an aggregator (default: false)",
-      default: false,
-      dependencies: ["as-template", "template-multi"]
+      description: "Overwrite or delete existing paths when conflicts are detected (default: true)",
+      default: true
     }
   }),
   async run({ args }) {
     try {
       const timer = createPerfTimer();
       const interactive = args.interactive ?? false;
-      const isDev = args.dev ?? false;
-      const whitelabel = args["template-whitelabel"] ?? "DLER";
       const depth = args.depth ?? 0;
+      const verbose = args.verbose ?? false;
+      const force = args.force ?? true;
+      if (verbose) {
+        relinka("log", "Verbose logging enabled");
+        relinka("log", `Force mode: ${force ? "enabled" : "disabled"}`);
+      }
       let include = args.s ?? [];
       if (include.length === 0) {
         const raw = await maybePrompt(
@@ -547,10 +433,10 @@ export default defineCommand({
       const header = args.header;
       const footer = args.footer;
       const selectFiles = args["select-files"] ?? false;
-      const asTemplate = args["as-template"] ?? false;
+      setFileSizeLimits(args["max-file-size"], args["max-merge-size"]);
       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)");
+        throw new Error("No files matched given patterns");
       }
       if (selectFiles && interactive) {
         const selected = await multiselectPrompt({
@@ -565,312 +451,9 @@ export default defineCommand({
           throw new Error("No files selected for merging");
         }
       }
-      if (args["template-update"]) {
-        if (!outFile) {
-          throw new Error("Output file path required for template update");
-        }
-        const templateName = args["template-update"];
-        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;
-                  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}"`);
-          }
-          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;
-      }
-      if (asTemplate) {
-        const timer2 = {
-          startTime: performance.now(),
-          pausedAt: null,
-          pausedDuration: 0
-        };
-        const templateMulti = args["template-multi"] ?? true;
-        const templatePerFile = args["template-per-file"] ?? false;
-        if (!outFile) {
-          outFile = templatePerFile ? "templates/index.ts" : "templates.ts";
-        } else if (!outFile.endsWith(".ts")) {
-          outFile = `${outFile}.ts`;
-        }
-        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);
-          }
-          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"}`
-                    );
-                  }
-                }
-              } 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 {
-                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");
-              }
-              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);
-            }
-          }
-          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: {}
-            }
-          };
-          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 (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");
-          }
-        }
-        const elapsed2 = getElapsedPerfTime(timer2);
-        relinka(
-          "success",
-          `Successfully ${dryRun ? "would generate" : "generated"} template file(s) (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;
+        return getCommentPrefix(filePath, forceComment, customComment);
       };
       if (outFile && await fs.pathExists(outFile) && (await fs.stat(outFile)).isDirectory()) {
         await writeFilesPreserveStructure(

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

@@ -1,7 +1,7 @@
+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 { join, resolve } from "node:path";
 import { readPackageJSON } from "pkg-types";
 import { glob } from "tinyglobby";
 const NODE_MODULES = [

package/bin/app/migrate/codemods/fs-relifso.d.ts

@@ -1,8 +1,8 @@
-type MigrationResult = {
+interface MigrationResult {
     file: string;
     success: boolean;
     message: string;
     changes?: string[];
-};
+}
 export declare function migrateFsToRelifso(dryRun?: boolean): Promise<MigrationResult[]>;
 export {};

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 { join, extname } from "node:path";
 async function getAllTsFiles(dir) {
   const files = [];
   try {

package/bin/app/migrate/codemods/nodenext-bundler.d.ts

@@ -1,9 +1,9 @@
-type MigrationResult = {
+interface MigrationResult {
     file: string;
     success: boolean;
     message: string;
     changes?: string[];
-};
+}
 export declare function migrateToNodeNext(dryRun?: boolean): Promise<MigrationResult[]>;
 export declare function migrateToBundler(dryRun?: boolean): Promise<MigrationResult[]>;
 export declare function migrateModuleResolution(target: "nodenext" | "bundler", dryRun?: boolean): Promise<MigrationResult[]>;

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

@@ -1,7 +1,7 @@
 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 { join, extname } from "node:path";
 async function getAllTsFiles(dir) {
   const files = [];
   try {

package/bin/app/migrate/codemods/path-pathkit.d.ts

@@ -1,8 +1,8 @@
-type MigrationResult = {
+interface MigrationResult {
     file: string;
     success: boolean;
     message: string;
     changes?: string[];
-};
+}
 export declare function migratePathToPathkit(dryRun?: boolean): Promise<MigrationResult[]>;
 export {};

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 { join, extname } from "node:path";
 async function getAllTsFiles(dir) {
   const files = [];
   try {