@reliverse/dler 1.7.0 → 1.7.2

package/bin/libs/sdk/sdk-impl/{check/rules/missing-deps.js → rules/reliverse/missing-deps/deps-mod.js}

@@ -1,5 +1,5 @@
-import { analyzeDependencies } from "./deps/analyzer.js";
-import { IGNORE_PATTERNS } from "../../constants.js";
+import { IGNORE_PATTERNS } from "../../../constants.js";
+import { analyzeDependencies } from "./analyzer.js";
 export async function checkMissingDependencies(options) {
   const startTime = Date.now();
   const issues = [];

package/bin/libs/sdk/sdk-impl/{check/rules/deps → rules/reliverse/missing-deps}/deps-types.d.ts

@@ -23,4 +23,6 @@ export type DependencyResult = {
     allDependencies: string[];
     listedDependencies: string[];
     builtinModules: string[];
+    devOnlyDependencies: string[];
+    duplicateDependencies: string[];
 };

package/bin/libs/sdk/sdk-impl/{check/rules/deps → rules/reliverse/missing-deps}/filesystem.js

@@ -1,6 +1,6 @@
 import fs from "@reliverse/relifso";
-import { glob } from "glob";
 import path from "node:path";
+import { glob } from "tinyglobby";
 export const findSourceFiles = async (directory, ignorePatterns) => {
   const pattern = `${directory}/**/*.{js,jsx,ts,tsx}`;
   const defaultIgnores = [
@@ -16,8 +16,7 @@ export const findSourceFiles = async (directory, ignorePatterns) => {
   const allIgnores = [...defaultIgnores, ...ignorePatterns];
   return await glob(pattern, {
     ignore: allIgnores,
-    absolute: true,
-    nodir: true
+    absolute: true
   });
 };
 export const readFile = async (filePath) => {

package/bin/libs/sdk/sdk-impl/rules/reliverse/missing-deps/formatter.js

@@ -0,0 +1,113 @@
+import { re } from "@reliverse/relico";
+export const formatOutput = (result, options) => {
+  if (options.json) {
+    return JSON.stringify(result, null, 2);
+  }
+  let output = "";
+  output += re.bluePastel("\nMissing Dependencies Finder Results\n");
+  output += re.gray("---------------------------------------\n\n");
+  output += re.bold("Statistics:\n");
+  output += `${re.gray("\u2022 ")}Total dependencies found: ${result.allDependencies.length}
+`;
+  output += `${re.gray("\u2022 ")}Listed in package.json: ${result.listedDependencies.length}
+`;
+  output += `${re.gray("\u2022 ")}Missing from package.json: ${result.missingDependencies.length}
+`;
+  if (options.builtins) {
+    output += `${re.gray("\u2022 ")}Node.js built-in modules: ${result.builtinModules.length}
+`;
+  }
+  output += `${re.gray("\u2022 ")}Dev-only dependencies used in production: ${result.devOnlyDependencies.length}
+`;
+  output += `${re.gray("\u2022 ")}Duplicate dependencies: ${result.duplicateDependencies.length}
+`;
+  output += "\n";
+  if (result.duplicateDependencies.length > 0) {
+    output += re.yellowPastel("\u26A0\uFE0F  Duplicate Dependencies Found:\n");
+    output += re.yellow(
+      "These packages are listed in both dependencies and devDependencies.\n"
+    );
+    output += re.yellow(
+      "This can cause confusion and potential issues. Consider keeping them in only one section.\n\n"
+    );
+    for (const dep of result.duplicateDependencies) {
+      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
+`;
+    }
+    output += "\n";
+  }
+  if (result.devOnlyDependencies.length > 0) {
+    output += re.yellowPastel(
+      "\u26A0\uFE0F  Dev-only Dependencies Used in Production Code:\n"
+    );
+    output += re.yellow(
+      "These packages are only in devDependencies but are imported in your code.\n"
+    );
+    output += re.yellow(
+      "They will cause errors in production after bundling!\n\n"
+    );
+    for (const dep of result.devOnlyDependencies) {
+      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
+`;
+    }
+    output += "\n";
+    output += re.gray("To fix, move these to dependencies:\n");
+    output += re.cyan(
+      `npm install ${result.devOnlyDependencies.join(" ")} --save
+`
+    );
+  }
+  if (result.missingDependencies.length > 0) {
+    output += re.redPastel("Missing Dependencies:\n");
+    for (const dep of result.missingDependencies) {
+      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
+`;
+    }
+    output += "\n";
+    output += re.gray("To install, run:\n");
+    output += re.cyan(
+      `npm install ${result.missingDependencies.join(" ")}
+`
+    );
+  } else {
+    output += re.greenPastel("No missing dependencies found! \u{1F389}\n\n");
+  }
+  if (options.builtins && result.builtinModules.length > 0) {
+    output += re.bluePastel("Node.js Built-in Modules Used:\n");
+    for (const dep of result.builtinModules) {
+      output += `${re.gray("\u2022 ")}${re.blue(dep)}
+`;
+    }
+    output += "\n";
+  }
+  if (options.showAll) {
+    output += re.bold("All Dependencies:\n");
+    output += re.gray(
+      "(\u2713 = listed in package.json, \u2717 = missing, \u26A0\uFE0F = dev-only, \u{1F504} = duplicate)\n"
+    );
+    for (const dep of result.allDependencies) {
+      const isListed = result.listedDependencies.includes(dep);
+      const isBuiltin = result.builtinModules.includes(dep);
+      const isDevOnly = result.devOnlyDependencies.includes(dep);
+      const isDuplicate = result.duplicateDependencies.includes(dep);
+      if (isDuplicate) {
+        output += `${re.gray("\u2022 ")}${re.yellow("\u{1F504} ")}${re.yellow(dep)}${re.gray(" (duplicate)")}
+`;
+      } else if (isListed && !isDevOnly) {
+        output += `${re.gray("\u2022 ") + re.green("\u2713 ") + dep}
+`;
+      } else if (isBuiltin) {
+        output += `${re.gray("\u2022 ")}${re.blue("\u26A1 ")}${dep}${re.gray(" (built-in)")}
+`;
+      } else if (isDevOnly) {
+        output += `${re.gray("\u2022 ")}${re.yellow("\u26A0\uFE0F ")}${re.yellow(dep)}${re.gray(" (dev-only)")}
+`;
+      } else {
+        output += `${re.gray("\u2022 ")}${re.red("\u2717 ")}${re.yellow(dep)}
+`;
+      }
+    }
+    output += "\n";
+  }
+  return output;
+};

package/bin/libs/sdk/sdk-impl/rules/reliverse/no-index-files/no-index-files.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RulesCheckOptions } from "../../../../sdk-types.js";
+export declare function checkNoIndexFiles(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/rules/reliverse/no-index-files/no-index-files.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { glob } from "tinyglobby";
+export async function checkNoIndexFiles(options) {
+  const { directory } = options;
+  const startTime = Date.now();
+  const indexFiles = await glob("**/index.{ts,js}", {
+    cwd: directory,
+    ignore: ["node_modules/**", "dist/**", ".git/**"]
+  });
+  const issues = [];
+  const stats = {
+    filesChecked: indexFiles.length,
+    importsChecked: 0,
+    timeElapsed: Date.now() - startTime
+  };
+  for (const file of indexFiles) {
+    const fullPath = path.join(directory, file);
+    const dirName = path.basename(path.dirname(file));
+    issues.push({
+      type: "no-index-files",
+      file: fullPath,
+      line: 1,
+      message: `Avoid using index.{ts,js} file names. Use descriptive names like mod.{ts,js} or ${dirName}-mod.{ts,js} instead. This reduces confusion, especially since TypeScript can resolve index files implicitly depending on the module resolution strategy.`
+    });
+  }
+  return {
+    success: issues.length === 0,
+    issues,
+    stats
+  };
+}

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/package-json-health}/package-json-health.d.ts

@@ -1,2 +1,2 @@
-import type { CheckResult } from "../../../sdk-types.js";
+import type { CheckResult } from "../../../../sdk-types.js";
 export declare function checkPackageJsonHealth(): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/rules/reliverse/path-extensions/path-extensions.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RulesCheckOptions } from "../../../../sdk-types.js";
+export declare function checkPathExtensions(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/path-extensions}/path-extensions.js

@@ -4,11 +4,11 @@ import { relinka } from "@reliverse/relinka";
 import {
   ALLOWED_IMPORT_EXTENSIONS,
   STRICT_IMPORT_EXTENSIONS
-} from "../check-consts.js";
+} from "../../rules-consts.js";
 import {
   getAllFiles,
   getLineNumber
-} from "../check-utils.js";
+} from "../../rules-utils.js";
 function getAllowedImportExtensions(directory, strict) {
   if (strict) {
     return STRICT_IMPORT_EXTENSIONS[directory];

package/bin/libs/sdk/sdk-impl/rules/reliverse/self-include/self-include.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RulesCheckOptions } from "../../../../sdk-types.js";
+export declare function checkSelfInclude(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/self-include}/self-include.js

@@ -1,11 +1,11 @@
 import { getFileImportsExports, extname } from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
+import { loadConfig } from "../../../cfg/load.js";
 import {
   getAllFiles,
   getLineNumber
-} from "../check-utils.js";
-import { loadConfig } from "../../config/load.js";
+} from "../../rules-utils.js";
 export async function checkSelfInclude(options) {
   const startTime = Date.now();
   const issues = [];

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/tsconfig-health}/tsconfig-health.d.ts

@@ -1,2 +1,2 @@
-import type { CheckResult } from "../../../sdk-types.js";
+import type { CheckResult } from "../../../../sdk-types.js";
 export declare function checkTsConfigHealth(): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/check-mod.js → rules/rules-mod.js}

@@ -22,6 +22,7 @@ export function displayCheckResults(checkType, directory, result) {
       (i) => i.type === "dler-config-health"
     );
     const selfIncludeIssues = issues.filter((i) => i.type === "self-include");
+    const noIndexIssues = issues.filter((i) => i.type === "no-index-files");
     if (fileIssues.length > 0) {
       relinka("error", `  file extension issues (${fileIssues.length}):`);
       for (const issue of fileIssues.slice(0, 10)) {
@@ -79,6 +80,15 @@ export function displayCheckResults(checkType, directory, result) {
         relinka("error", `    ... and ${selfIncludeIssues.length - 10} more`);
       }
     }
+    if (noIndexIssues.length > 0) {
+      relinka("error", `  index file issues (${noIndexIssues.length}):`);
+      for (const issue of noIndexIssues.slice(0, 10)) {
+        relinka("error", `    ${issue.file}: ${issue.message}`);
+      }
+      if (noIndexIssues.length > 10) {
+        relinka("error", `    ... and ${noIndexIssues.length - 10} more`);
+      }
+    }
     relinka(
       "info",
       `  stats: ${stats.filesChecked} files, ${stats.importsChecked} imports, ${stats.timeElapsed}ms`

package/bin/libs/sdk/sdk-impl/{check/check-utils.d.ts → rules/rules-utils.d.ts}

@@ -1,4 +1,4 @@
-import type { AllowedFileExtensionsType } from "./check-consts";
+import type { AllowedFileExtensionsType } from "./rules-consts";
 export declare function validateDirectory(dir: string): Promise<boolean>;
 export declare function shouldIgnoreFile(filePath: string): boolean;
 export declare function getAllFiles(dir: AllowedFileExtensionsType, onProgress?: (current: number, total: number, file: string) => void): Promise<string[]>;

package/bin/libs/sdk/sdk-impl/utils/utils-pkg-json-libs.js

@@ -103,9 +103,12 @@ async function library_getlibPkgKeepDeps(libName, originalDeps, outDirBin, isJsr
     const devDeps = originalDeps === originalPkg.devDependencies;
     const patterns = /* @__PURE__ */ new Set();
     const addPatterns = /* @__PURE__ */ new Set();
+    const negPatterns = /* @__PURE__ */ new Set();
     for (const pattern of config.filterDepsPatterns.global) {
       if (pattern.startsWith("+")) {
         addPatterns.add(pattern.slice(1));
+      } else if (pattern.startsWith("!")) {
+        negPatterns.add(pattern.slice(1));
       } else {
         patterns.add(pattern);
       }
@@ -114,6 +117,8 @@ async function library_getlibPkgKeepDeps(libName, originalDeps, outDirBin, isJsr
       for (const pattern of config.filterDepsPatterns["dist-npm"]) {
         if (pattern.startsWith("+")) {
           addPatterns.add(pattern.slice(1));
+        } else if (pattern.startsWith("!")) {
+          negPatterns.add(pattern.slice(1));
         } else {
           patterns.add(pattern);
         }
@@ -123,6 +128,8 @@ async function library_getlibPkgKeepDeps(libName, originalDeps, outDirBin, isJsr
       for (const pattern of config.filterDepsPatterns["dist-jsr"]) {
         if (pattern.startsWith("+")) {
           addPatterns.add(pattern.slice(1));
+        } else if (pattern.startsWith("!")) {
+          negPatterns.add(pattern.slice(1));
         } else {
           patterns.add(pattern);
         }
@@ -134,6 +141,8 @@ async function library_getlibPkgKeepDeps(libName, originalDeps, outDirBin, isJsr
         for (const pattern of libPatterns.npm) {
           if (pattern.startsWith("+")) {
             addPatterns.add(pattern.slice(1));
+          } else if (pattern.startsWith("!")) {
+            negPatterns.add(pattern.slice(1));
           } else {
             patterns.add(pattern);
           }
@@ -143,6 +152,8 @@ async function library_getlibPkgKeepDeps(libName, originalDeps, outDirBin, isJsr
         for (const pattern of libPatterns.jsr) {
           if (pattern.startsWith("+")) {
             addPatterns.add(pattern.slice(1));
+          } else if (pattern.startsWith("!")) {
+            negPatterns.add(pattern.slice(1));
           } else {
             patterns.add(pattern);
           }
@@ -151,8 +162,16 @@ async function library_getlibPkgKeepDeps(libName, originalDeps, outDirBin, isJsr
     }
     const result2 = Object.entries(originalDeps).reduce(
       (acc, [k, v]) => {
+        const depNameLower = k.toLowerCase();
+        const isNegated = Array.from(negPatterns).some(
+          (pattern) => depNameLower.includes(pattern.toLowerCase())
+        );
+        if (isNegated) {
+          acc[k] = v;
+          return acc;
+        }
         const shouldExclude = devDeps || Array.from(patterns).some(
-          (pattern) => k.toLowerCase().includes(pattern.toLowerCase())
+          (pattern) => depNameLower.includes(pattern.toLowerCase())
         );
         if (!shouldExclude) {
           acc[k] = v;
@@ -257,7 +276,9 @@ async function library_writeJsrPackageJSON(libName, outDirBin, pkgJsonDir, origi
       "package.json",
       "README.md",
       "LICENSE"
-    ]
+    ],
+    main: `./bin/${path.basename(libsList[libName].libMainFile)}`,
+    module: `./bin/${path.basename(libsList[libName].libMainFile)}`
   });
   const pkgPath = path.join(pkgJsonDir, "package.json");
   await fs.ensureDir(path.dirname(pkgPath));
@@ -300,7 +321,7 @@ async function library_writeNpmLibPackageJSON(libName, outDirBin, pkgJsonDir, or
       libName
     ),
     exports: {
-      ".": `./bin/${libsList[libName].libMainFile.replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`
+      ".": `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`
     },
     files: config.publishArtifacts?.global || [
       "bin",
@@ -308,8 +329,8 @@ async function library_writeNpmLibPackageJSON(libName, outDirBin, pkgJsonDir, or
       "README.md",
       "LICENSE"
     ],
-    main: `./bin/${libsList[libName].libMainFile.replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
-    module: `./bin/${libsList[libName].libMainFile.replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
+    main: `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
+    module: `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
     publishConfig: { access: "public" }
   });
   const pkgPath = path.join(pkgJsonDir, "package.json");

package/bin/libs/sdk/sdk-types.d.ts

@@ -851,7 +851,7 @@ export type PerfTimer = {
 /** Options common to both NPM and JSR build targets */
 /** Options specific to the transpilation/bundling process */
 type DirectoryType = "src" | "dist-npm" | "dist-jsr" | "dist-libs/npm" | "dist-libs/jsr";
-export type FileCheckOptions = {
+export type RulesCheckOptions = {
     directory: DirectoryType;
     strict: boolean;
     moduleResolution: "bundler" | "nodenext";
@@ -865,7 +865,7 @@ export type FileCheckOptions = {
     depth?: number;
 };
 export type CheckIssue = {
-    type: "file-extension" | "path-extension" | "missing-dependency" | "builtin-module" | "dler-config-health" | "self-include" | "tsconfig-health";
+    type: "file-extension" | "path-extension" | "missing-dependency" | "builtin-module" | "dler-config-health" | "self-include" | "tsconfig-health" | "no-index-files";
     message: string;
     file: string;
     line?: number;

package/bin/mod.d.ts

@@ -1 +1 @@
-export { defineConfig } from "./libs/sdk/sdk-impl/config/define";
+export { defineConfig } from "./libs/sdk/sdk-impl/cfg/define";

package/bin/mod.js

@@ -1 +1 @@
-export { defineConfig } from "./libs/sdk/sdk-impl/config/define.js";
+export { defineConfig } from "./libs/sdk/sdk-impl/cfg/define.js";

package/package.json

@@ -13,12 +13,10 @@
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/pluginutils": "^5.1.4",
-    "chalk": "^5.4.1",
     "defu": "^6.1.4",
     "esbuild": "^0.25.5",
     "execa": "^9.6.0",
     "fix-dts-default-cjs-exports": "^1.0.1",
-    "glob": "^11.0.2",
     "hookable": "^5.5.3",
     "jiti": "^2.4.2",
     "magic-string": "^0.30.17",
@@ -41,7 +39,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "keywords": [
     "reliverse",
     "cli",

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

@@ -1,11 +0,0 @@
-declare const _default: import("@reliverse/rempts").Command<{
-    dev: {
-        type: "boolean";
-        description: string;
-    };
-    cwd: {
-        type: "string";
-        description: string;
-    };
-}>;
-export default _default;

package/bin/app/relifso/cmd.js

@@ -1,47 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { defineCommand, runCmd, selectPrompt } from "@reliverse/rempts";
-import { getCmdRelifsoInit, getCmdRelifsoRename } from "../cmds.js";
-export default defineCommand({
-  meta: {
-    name: "relifso",
-    description: "Runs the Relifso helper interactive menu (displays list of available commands)"
-  },
-  args: {
-    dev: {
-      type: "boolean",
-      description: "Runs the CLI in dev mode"
-    },
-    cwd: {
-      type: "string",
-      description: "The working directory to run the CLI in"
-    }
-  },
-  run: async ({ args }) => {
-    const isDev = args.dev;
-    relinka("verbose", `Running in ${isDev ? "dev" : "prod"} mode`);
-    const cmd = await selectPrompt({
-      title: "Select a command",
-      options: [
-        {
-          value: "init",
-          label: "Initialize files"
-        },
-        {
-          value: "rename-prepare",
-          label: "My project is a bootstrapper CLI (apply rename optimizations)"
-        },
-        {
-          value: "rename-prepare-revert",
-          label: "Revert rename CLI files optimizations"
-        }
-      ]
-    });
-    if (cmd === "init") {
-      await runCmd(await getCmdRelifsoInit(), []);
-    } else if (cmd === "rename-prepare") {
-      await runCmd(await getCmdRelifsoRename(), ["--prepareMyCLI"]);
-    } else if (cmd === "rename-prepare-revert") {
-      await runCmd(await getCmdRelifsoRename(), ["--prepareMyCLI", "--revert"]);
-    }
-  }
-});

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

@@ -1,18 +0,0 @@
-declare const _default: import("@reliverse/rempts").Command<{
-    input: {
-        type: "string";
-        required: true;
-        description: string;
-    };
-    from: {
-        type: "string";
-        required: true;
-        description: string;
-    };
-    to: {
-        type: "string";
-        required: true;
-        description: string;
-    };
-}>;
-export default _default;

package/bin/app/relinka/cmd.js

@@ -1,149 +0,0 @@
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-export default defineCommand({
-  meta: {
-    name: "relinka",
-    version: "1.0.0",
-    description: "Convert between different logging formats (console, consola method/object, relinka function/method/object)."
-  },
-  args: defineArgs({
-    input: {
-      type: "string",
-      required: true,
-      description: "Input file or directory path"
-    },
-    from: {
-      type: "string",
-      required: true,
-      description: "Source format (console, consolaMethod, consolaObject, relinkaFunction, relinkaMethod, relinkaObject)"
-    },
-    to: {
-      type: "string",
-      required: true,
-      description: "Target format (console, consolaMethod, consolaObject, relinkaFunction, relinkaMethod, relinkaObject)"
-    }
-  }),
-  async run({ args }) {
-    const { input, from, to } = args;
-    if (!await fs.pathExists(input)) {
-      relinka("error", `\u274C Input path does not exist: ${input}`);
-      return;
-    }
-    let content = await fs.readFile(input, "utf-8");
-    let changes = false;
-    const levels = [
-      "log",
-      "info",
-      "warn",
-      "error",
-      "debug",
-      "verbose",
-      "success",
-      "ready",
-      "start",
-      "box",
-      "trace"
-    ];
-    const getSourcePattern = (level, format) => {
-      switch (format) {
-        case "console":
-          return new RegExp(`console\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
-        case "consolaMethod":
-          if (level === "box") {
-            return /consola\.box\(\s*{\s*title:\s*"([^"]*)",\s*message:\s*"([^"]*)"\s*\}\s*\)/g;
-          }
-          return new RegExp(`consola\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
-        case "consolaObject":
-          return new RegExp(
-            `consola\\({level:\\s*"${level}",\\s*message:\\s*(.*?)(?:,\\s*title:\\s*"([^"]*)")?\\s*\\}\\)`,
-            "g"
-          );
-        case "relinkaFunction":
-          return new RegExp(
-            `relinka\\("${level}",\\s*(.*?)(?:,\\s*(.*))?\\)`,
-            "g"
-          );
-        case "relinkaMethod":
-          return new RegExp(`relinka\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
-        case "relinkaObject":
-          return new RegExp(
-            `relinka\\({level:\\s*"${level}",\\s*message:\\s*(.*?)(?:,\\s*title:\\s*"([^"]*)")?\\s*\\}\\)`,
-            "g"
-          );
-        default:
-          throw new Error(`Invalid source format: ${format}`);
-      }
-    };
-    const createReplacement = (level, message, title, args2) => {
-      switch (to) {
-        case "console":
-          return `console.${level}(${message}${args2 ? `, ${args2}` : ""})`;
-        case "consolaMethod":
-          if (level === "box" && title) {
-            return `consola.box({ title: "${title}", message: "${message}" })`;
-          }
-          return `consola.${level}(${message}${args2 ? `, ${args2}` : ""})`;
-        case "consolaObject": {
-          const obj = {
-            level: `"${level}"`,
-            message,
-            ...title && { title: `"${title}"` },
-            ...args2 && { args: `[${args2}]` }
-          };
-          return `consola(${JSON.stringify(obj).replace(/"([^"]+)":/g, "$1:")})`;
-        }
-        case "relinkaFunction":
-          if (level === "box" && title) {
-            return `relinka("${level}", "${title}\\n${message}"${args2 ? `, ${args2}` : ""})`;
-          }
-          return `relinka("${level}", ${message}${args2 ? `, ${args2}` : ""})`;
-        case "relinkaMethod":
-          if (level === "box" && title) {
-            return `relinka.${level}("${title}\\n${message}"${args2 ? `, ${args2}` : ""})`;
-          }
-          return `relinka.${level}(${message}${args2 ? `, ${args2}` : ""})`;
-        case "relinkaObject": {
-          const obj = {
-            level: `"${level}"`,
-            message,
-            ...title && { title: `"${title}"` },
-            ...args2 && { args: `[${args2}]` }
-          };
-          return `relinka(${JSON.stringify(obj).replace(/"([^"]+)":/g, "$1:")})`;
-        }
-        default:
-          throw new Error(`Invalid target format: ${to}`);
-      }
-    };
-    for (const level of levels) {
-      const pattern = getSourcePattern(level, from);
-      const newContent = content.replace(
-        pattern,
-        (_, message, titleOrArgs, args2) => {
-          changes = true;
-          if ((from === "consolaMethod" || from === "relinkaMethod") && level === "box") {
-            return createReplacement(level, message, titleOrArgs, args2);
-          }
-          return createReplacement(level, message, void 0, titleOrArgs);
-        }
-      );
-      if (newContent !== content) {
-        content = newContent;
-        relinka(
-          "log",
-          `\u2705 Converted ${level} calls from ${from} to ${to} format`
-        );
-      }
-    }
-    if (!changes) {
-      relinka("warn", "\u26A0\uFE0F No matching calls found to convert");
-    } else {
-      await fs.writeFile(input, content, "utf-8");
-      relinka(
-        "success",
-        "\u2728 Successfully converted all logging calls to the target format"
-      );
-    }
-  }
-});