@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/utils/codemods/convertDefinitions.js

@@ -0,0 +1,42 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { glob } from "tinyglobby";
+export async function convertTypeDefinitions(projectPath, targetStyle) {
+  relinka("info", `Converting type definitions to ${targetStyle} style in ${projectPath}`);
+  const files = await glob("**/*.{ts,tsx}", {
+    cwd: path.resolve(projectPath)
+  });
+  for (const file of files) {
+    const filePath = path.join(projectPath, file);
+    const content = await fs.readFile(filePath, "utf-8");
+    let updatedContent = content;
+    if (targetStyle === "type") {
+      updatedContent = content.replace(
+        /interface\s+(\w+)(\s*extends\s*[^{]+)?\s*{([^}]*)}/g,
+        (_match, name, extends_, body) => {
+          const extendsClause = extends_ ? extends_.replace("extends", "&") : "";
+          return `type ${name} = ${extendsClause}{${body}}`;
+        }
+      );
+    } else {
+      updatedContent = content.replace(
+        /type\s+(\w+)\s*=\s*(?:{([^}]*)}|(\w+))/g,
+        (match, name, objectBody, simpleType) => {
+          if (simpleType) {
+            return match;
+          }
+          return `interface ${name} {${objectBody}}`;
+        }
+      );
+      updatedContent = updatedContent.replace(
+        /interface\s+(\w+)\s*{\s*}\s*&\s*(\w+)/g,
+        "interface $1 extends $2"
+      );
+    }
+    if (content !== updatedContent) {
+      await fs.writeFile(filePath, updatedContent, "utf-8");
+      relinka("info", `Updated type definitions in ${filePath}`);
+    }
+  }
+}

package/bin/app/utils/codemods/convertImportStyle.d.ts

@@ -0,0 +1 @@
+export declare function convertImportStyle(projectPath: string, targetStyle: "import" | "require"): Promise<void>;

package/bin/app/utils/codemods/convertImportStyle.js

@@ -0,0 +1,30 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { glob } from "tinyglobby";
+export async function convertImportStyle(projectPath, targetStyle) {
+  relinka("info", `Converting to ${targetStyle} style in ${projectPath}`);
+  const files = await glob("**/*.{js,jsx,ts,tsx}", {
+    cwd: path.resolve(projectPath)
+  });
+  for (const file of files) {
+    const filePath = path.join(projectPath, file);
+    const content = await fs.readFile(filePath, "utf-8");
+    let updatedContent = content;
+    if (targetStyle === "import") {
+      updatedContent = content.replace(
+        /(?:const|let|var)\s*{\s*([^}]+)}\s*=\s*require\(['"]([^'"]+)['"]\)/g,
+        'import { $1 } from "$2"'
+      ).replace(
+        /(?:const|let|var)\s+(\w+)\s*=\s*require\(['"]([^'"]+)['"]\)/g,
+        'import $1 from "$2"'
+      );
+    } else {
+      updatedContent = content.replace(/import\s*{\s*([^}]+)}\s*from\s*['"]([^'"]+)['"]/g, "const { $1 } = require('$2')").replace(/import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g, "const $1 = require('$2')");
+    }
+    if (content !== updatedContent) {
+      await fs.writeFile(filePath, updatedContent, "utf-8");
+      relinka("info", `Updated import style in ${filePath}`);
+    }
+  }
+}

package/bin/app/utils/codemods/convertJsToTs.d.ts

@@ -0,0 +1 @@
+export declare function convertJsToTs(cwd: string): Promise<void>;

package/bin/app/utils/codemods/convertJsToTs.js

@@ -0,0 +1,99 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { readPackageJSON, writePackageJSON } from "pkg-types";
+import { tsconfigJson } from "../../config/constants.js";
+function generateTypeDefinitions(content) {
+  let result = content;
+  result = result.replace(
+    /function\s+(\w+)\s*\((.*?)\)/g,
+    (_, name, params) => {
+      const typedParams = params.split(",").map((p) => p.trim()).filter(Boolean).map((p) => `${p}: any`);
+      return `function ${name}(${typedParams.join(", ")})`;
+    }
+  );
+  result = result.replace(/function\s+(\w+)\s*\((.*?)\)\s*{/g, (match) => `${match}: any`);
+  result = result.replace(
+    /(const|let|var)\s+(\w+)\s*=/g,
+    (_, dec, name) => `${dec} ${name}: any =`
+  );
+  result = result.replace(/class\s+(\w+)\s*{([^}]+)}/g, (_, name, body) => {
+    const typedBody = body.replace(
+      /(\w+)\s*=/g,
+      (_2, propName) => `${propName}: any =`
+    );
+    return `class ${name} {${typedBody}}`;
+  });
+  result = result.replace(
+    /const\s+(\w+)\s*=\s*{([^}]+)}/g,
+    (_, name, props) => {
+      const interfaceProps = props.split(",").map((p) => p.trim()).filter(Boolean).map((p) => {
+        const [propName] = p.split(":");
+        return `  ${propName}: any;`;
+      });
+      return `interface ${name}Type {
+${interfaceProps.join("\n")}
+}
+const ${name}: ${name}Type = {${props}}`;
+    }
+  );
+  return result;
+}
+export async function convertJsToTs(cwd) {
+  const jsFiles = await fs.readdir(cwd, { recursive: true });
+  const jsFilePaths = jsFiles.filter((file) => typeof file === "string").filter(
+    (file) => file.endsWith(".js") && !file.endsWith(".config.js") && !file.endsWith(".test.js") && !file.includes("node_modules")
+  );
+  for (const jsFile of jsFilePaths) {
+    const fullPath = path.join(cwd, jsFile);
+    const tsFile = jsFile.replace(/\.js$/, ".ts");
+    const tsPath = path.join(cwd, tsFile);
+    try {
+      const content = await fs.readFile(fullPath, "utf-8");
+      const tsContent = generateTypeDefinitions(content);
+      await fs.writeFile(tsPath, tsContent);
+      relinka("success", `Converted ${jsFile} to TypeScript`);
+      await fs.remove(fullPath);
+    } catch (error) {
+      relinka(
+        "error",
+        `Failed to convert ${jsFile}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const tsconfigPath = path.join(cwd, tsconfigJson);
+  if (!await fs.pathExists(tsconfigPath)) {
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2020",
+        module: "ESNext",
+        moduleResolution: "node",
+        esModuleInterop: true,
+        strict: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        outDir: "dist"
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist"]
+    };
+    await fs.writeJson(tsconfigPath, tsconfig, { spaces: 2 });
+    relinka("success", "Created tsconfig.json");
+  }
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (await fs.pathExists(packageJsonPath)) {
+    const packageJson = await readPackageJSON(packageJsonPath);
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      typescript: "latest",
+      "@types/node": "latest"
+    };
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      build: "tsc",
+      "type-check": "tsc --noEmit"
+    };
+    await writePackageJSON(packageJsonPath, packageJson);
+    relinka("success", "Updated package.json with TypeScript configuration");
+  }
+}

package/bin/app/utils/codemods/convertQuoteStyle.d.ts

@@ -0,0 +1 @@
+export declare function convertQuoteStyle(projectPath: string, targetQuoteStyle: "single" | "double"): Promise<void>;

package/bin/app/utils/codemods/convertQuoteStyle.js

@@ -0,0 +1,31 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { glob } from "tinyglobby";
+export async function convertQuoteStyle(projectPath, targetQuoteStyle) {
+  relinka("info", `Converting quotes to ${targetQuoteStyle} quotes in ${projectPath}`);
+  const files = await glob("**/*.{js,jsx,ts,tsx}", {
+    cwd: path.resolve(projectPath)
+  });
+  for (const file of files) {
+    const filePath = path.join(projectPath, file);
+    const content = await fs.readFile(filePath, "utf-8");
+    const updatedContent = content.replace(
+      /(['"])((?:\\\1|(?!\1).)*?)\1/g,
+      (_match, _quote, content2) => {
+        const targetQuote = targetQuoteStyle === "single" ? "'" : '"';
+        const escapedContent = content2.replace(new RegExp(targetQuote, "g"), `\\${targetQuote}`);
+        const otherQuote = targetQuoteStyle === "single" ? '"' : "'";
+        const unescapedContent = escapedContent.replace(
+          new RegExp(`\\\\${otherQuote}`, "g"),
+          otherQuote
+        );
+        return `${targetQuote}${unescapedContent}${targetQuote}`;
+      }
+    );
+    if (content !== updatedContent) {
+      await fs.writeFile(filePath, updatedContent, "utf-8");
+      relinka("info", `Updated quotes in ${filePath}`);
+    }
+  }
+}

package/bin/app/utils/codemods/convertRuntime.d.ts

@@ -0,0 +1 @@
+export declare function convertRuntime(projectPath: string, targetRuntime: "bun" | "deno"): Promise<void>;

package/bin/app/utils/codemods/convertRuntime.js

@@ -0,0 +1,116 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { destr } from "destr";
+import { glob } from "tinyglobby";
+import { tsconfigJson } from "../../config/constants.js";
+const RUNTIME_REPLACEMENTS = {
+  bun: {
+    // Node.js fs to Bun's fs
+    'import fs from "@reliverse/relifso"': 'import { readFile, writeFile, readdir, mkdir, stat } from "@reliverse/relifso"',
+    'import fs from "fs/promises"': 'import { readFile, writeFile, readdir, mkdir, stat } from "@reliverse/relifso"',
+    "import { promises as fs }": 'import { readFile, writeFile, readdir, mkdir, stat } from "@reliverse/relifso"',
+    // Node.js path to Bun's path
+    'import path from "path"': 'import { join, resolve, dirname, basename } from "path"',
+    // Node.js crypto to Bun's crypto
+    'import crypto from "uncrypto"': 'import { crypto } from "bun"',
+    // Node.js buffer to Bun's buffer
+    "import { Buffer }": "// Bun has Buffer globally available",
+    // Node.js process to Bun's process
+    "process.env": "Bun.env",
+    "process.cwd()": "import.meta.dir"
+  },
+  deno: {
+    // Node.js fs to Deno's fs
+    'import fs from "@reliverse/relifso"': 'import * as fs from "https://deno.land/std/fs/mod.ts"',
+    'import fs from "fs/promises"': 'import * as fs from "https://deno.land/std/fs/mod.ts"',
+    "import { promises as fs }": 'import * as fs from "https://deno.land/std/fs/mod.ts"',
+    // Node.js path to Deno's path
+    'import path from "path"': 'import * as path from "https://deno.land/std/path/mod.ts"',
+    // Node.js crypto to Deno's crypto
+    'import crypto from "uncrypto"': 'import * as crypto from "https://deno.land/std/crypto/mod.ts"',
+    // Node.js buffer to Deno's buffer
+    "import { Buffer }": 'import { Buffer } from "https://deno.land/std/io/buffer.ts"',
+    // Node.js process to Deno
+    "process.env": "Deno.env.toObject()",
+    "process.cwd()": "Deno.cwd()"
+  }
+};
+export async function convertRuntime(projectPath, targetRuntime) {
+  relinka("info", `Converting Node.js code to ${targetRuntime} in ${projectPath}`);
+  const files = await glob("**/*.{js,jsx,ts,tsx}", {
+    cwd: path.resolve(projectPath)
+  });
+  const runtimeReplacements = RUNTIME_REPLACEMENTS[targetRuntime];
+  for (const file of files) {
+    const filePath = path.join(projectPath, file);
+    const content = await fs.readFile(filePath, "utf-8");
+    let updatedContent = content;
+    for (const [nodePattern, runtimePattern] of Object.entries(runtimeReplacements)) {
+      updatedContent = updatedContent.replace(
+        new RegExp(nodePattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+        runtimePattern
+      );
+    }
+    if (targetRuntime === "bun") {
+      if (file === "package.json") {
+        const packageJson = destr(updatedContent);
+        if (packageJson?.scripts) {
+          for (const [key, value] of Object.entries(packageJson.scripts)) {
+            if (typeof value === "string") {
+              packageJson.scripts[key] = value.replace(/^node\s/, "bun ").replace(/^ts-node\s/, "bun ");
+            }
+          }
+          updatedContent = JSON.stringify(packageJson, null, 2);
+        }
+      }
+    }
+    if (targetRuntime === "deno") {
+      if (file === "package.json") {
+        await fs.writeFile(
+          path.join(projectPath, "deno.json"),
+          JSON.stringify(
+            {
+              compilerOptions: {
+                allowJs: true,
+                lib: ["deno.window"]
+              },
+              importMap: "import_map.json"
+            },
+            null,
+            2
+          )
+        );
+        const packageJson = destr(content);
+        const importMap = {
+          imports: {}
+        };
+        if (packageJson?.dependencies) {
+          for (const dep of Object.keys(packageJson.dependencies)) {
+            importMap.imports[dep] = `https://esm.sh/${dep}`;
+          }
+        }
+        await fs.writeFile(
+          path.join(projectPath, "import_map.json"),
+          JSON.stringify(importMap, null, 2)
+        );
+      }
+    }
+    if (content !== updatedContent) {
+      await fs.writeFile(filePath, updatedContent, "utf-8");
+      relinka("info", `Updated runtime code in ${filePath}`);
+    }
+  }
+  if (targetRuntime === "bun") {
+    const tsconfigPath = path.join(projectPath, tsconfigJson);
+    if (await fs.pathExists(tsconfigPath)) {
+      const tsconfig = destr(await fs.readFile(tsconfigPath, "utf-8"));
+      tsconfig.compilerOptions = {
+        ...tsconfig.compilerOptions,
+        types: [...tsconfig.compilerOptions?.types ?? [], "bun-types"]
+      };
+      await fs.writeJSON(tsconfigPath, tsconfig, { spaces: 2 });
+    }
+  }
+  relinka("success", `Converted project to ${targetRuntime}`);
+}

package/bin/app/utils/codemods/convertToMonorepo.d.ts

@@ -0,0 +1,2 @@
+import type { MonorepoType } from "../../types/mod.js";
+export declare function convertToMonorepo(projectPath: string, type: MonorepoType, packages?: string[], sharedPackages?: string[]): Promise<void>;

package/bin/app/utils/codemods/convertToMonorepo.js

@@ -0,0 +1,137 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { readPackageJSON, writePackageJSON } from "pkg-types";
+import { tsconfigJson } from "../../config/constants.js";
+const MONOREPO_CONFIGS = {
+  turborepo: {
+    "turbo.json": {
+      $schema: "https://turbo.build/schema.json",
+      globalDependencies: ["**/.env.*local"],
+      pipeline: {
+        build: {
+          dependsOn: ["^build"],
+          outputs: ["dist/**", ".next/**", "!.next/cache/**"]
+        },
+        lint: {},
+        dev: {
+          cache: false,
+          persistent: true
+        }
+      }
+    }
+  },
+  moonrepo: {
+    "moon.yml": `
+workspace:
+  extends: 'typescript'
+  projects:
+    - 'apps/*'
+    - 'packages/*'
+`
+  },
+  "bun-workspaces": {
+    "package.json": {
+      workspaces: ["apps/*", "packages/*"]
+    }
+  },
+  "pnpm-workspaces": {
+    "pnpm-workspace.yaml": `
+packages:
+  - 'apps/*'
+  - 'packages/*'
+`
+  }
+};
+export async function convertToMonorepo(projectPath, type, packages = [], sharedPackages = []) {
+  relinka("info", `Converting to ${type} monorepo in ${projectPath}`);
+  await fs.mkdir(path.join(projectPath, "apps"), { recursive: true });
+  await fs.mkdir(path.join(projectPath, "packages"), { recursive: true });
+  const packageJson = await readPackageJSON(path.join(projectPath, "package.json"));
+  if (!packageJson.workspaces) {
+    await fs.move(path.join(projectPath, "src"), path.join(projectPath, "apps", "web", "src"), {
+      overwrite: true
+    });
+    await fs.move(
+      path.join(projectPath, "package.json"),
+      path.join(projectPath, "apps", "web", "package.json"),
+      { overwrite: true }
+    );
+    const commonFiles = [
+      tsconfigJson,
+      "eslint.config.js",
+      ".prettierrc",
+      "next.config.js",
+      "postcss.config.js",
+      "tailwind.config.js"
+    ];
+    for (const file of commonFiles) {
+      if (await fs.pathExists(path.join(projectPath, file))) {
+        await fs.move(path.join(projectPath, file), path.join(projectPath, "apps", "web", file), {
+          overwrite: true
+        });
+      }
+    }
+  }
+  const rootPackageJson = {
+    name: `${packageJson.name}-monorepo`,
+    private: true,
+    scripts: {
+      build: type === "turborepo" ? "turbo run build" : "bun run --cwd apps/web build",
+      dev: type === "turborepo" ? "turbo run dev" : "bun run --cwd apps/web dev",
+      lint: type === "turborepo" ? "turbo run lint" : "bun run --cwd apps/web lint"
+    }
+  };
+  await writePackageJSON(path.join(projectPath, "package.json"), rootPackageJson);
+  const configs = MONOREPO_CONFIGS[type];
+  for (const [filename, content] of Object.entries(configs)) {
+    const filePath = path.join(projectPath, filename);
+    if (typeof content === "string") {
+      await fs.writeFile(filePath, content);
+    } else {
+      await fs.writeJSON(filePath, content, { spaces: 2 });
+    }
+  }
+  for (const pkg of packages) {
+    const pkgPath = path.join(projectPath, "apps", pkg);
+    await fs.mkdir(pkgPath, { recursive: true });
+    await writePackageJSON(path.join(pkgPath, "package.json"), {
+      name: `@${packageJson.name}/${pkg}`,
+      version: "0.0.0",
+      private: true
+    });
+  }
+  for (const pkg of sharedPackages) {
+    const pkgPath = path.join(projectPath, "packages", pkg);
+    await fs.mkdir(pkgPath, { recursive: true });
+    await writePackageJSON(path.join(pkgPath, "package.json"), {
+      name: `@${packageJson.name}/${pkg}`,
+      version: "0.0.0",
+      main: "./src/index.ts",
+      types: "./src/index.ts",
+      private: true
+    });
+    await fs.mkdir(path.join(pkgPath, "src"), { recursive: true });
+    await fs.writeFile(path.join(pkgPath, "src", "index.ts"), "export {};\n");
+  }
+  const rootTsConfig = {
+    compilerOptions: {
+      module: "esnext",
+      moduleResolution: "bundler",
+      target: "esnext",
+      lib: ["dom", "dom.iterable", "esnext"],
+      strict: true,
+      skipLibCheck: true,
+      jsx: "preserve"
+    },
+    references: [
+      { path: "apps/web" },
+      ...packages.map((pkg) => ({ path: `apps/${pkg}` })),
+      ...sharedPackages.map((pkg) => ({ path: `packages/${pkg}` }))
+    ]
+  };
+  await fs.writeJSON(path.join(projectPath, tsconfigJson), rootTsConfig, {
+    spaces: 2
+  });
+  relinka("success", `Converted to ${type} monorepo`);
+}

package/bin/app/utils/codemods/removeComments.d.ts

@@ -0,0 +1 @@
+export declare function removeComments(cwd: string): Promise<void>;

package/bin/app/utils/codemods/removeComments.js

@@ -0,0 +1,13 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { glob } from "tinyglobby";
+export async function removeComments(cwd) {
+  const files = await glob("**/*.{js,jsx,ts,tsx}", { cwd });
+  for (const file of files) {
+    const content = await fs.readFile(path.join(cwd, file), "utf-8");
+    const withoutComments = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*/g, "").replace(/^\s*[\r\n]/gm, "");
+    await fs.writeFile(path.join(cwd, file), withoutComments);
+  }
+  relinka("success", "Removed comments from all TypeScript/JavaScript files");
+}

package/bin/app/utils/codemods/removeUnusedDeps.d.ts

@@ -0,0 +1 @@
+export declare function getUnusedDependencies(cwd: string, ignoredDeps?: string[]): Promise<string[]>;

package/bin/app/utils/codemods/removeUnusedDeps.js

@@ -0,0 +1,29 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { destr } from "destr";
+import { glob } from "tinyglobby";
+export async function getUnusedDependencies(cwd, ignoredDeps = []) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  const packageJson = destr(await fs.readFile(packageJsonPath, "utf-8"));
+  const allDeps = {
+    ...packageJson.dependencies ?? {},
+    ...packageJson.devDependencies ?? {}
+  };
+  const files = await glob("**/*.{js,jsx,ts,tsx}", { cwd });
+  const imports = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const content = await fs.readFile(path.join(cwd, file), "utf-8");
+    const importMatches = content.matchAll(/from ['"]([^'"]+)['"]/g);
+    for (const match of importMatches) {
+      const [, pkg] = match;
+      if (pkg && !pkg.startsWith(".") && !pkg.startsWith("~/")) {
+        imports.add(pkg.split("/")[0]);
+      }
+    }
+  }
+  return Object.keys(allDeps).filter(
+    (dep) => !imports.has(dep) && !ignoredDeps.some(
+      (pattern) => pattern.startsWith("/") ? new RegExp(pattern.slice(1, -1)).test(dep) : pattern === dep
+    )
+  );
+}

package/bin/app/utils/codemods/replaceImportSymbol.d.ts

@@ -0,0 +1 @@
+export declare function replaceImportSymbol(projectPath: string, toSymbol: string): Promise<void>;

package/bin/app/utils/codemods/replaceImportSymbol.js

@@ -0,0 +1,57 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { glob } from "tinyglobby";
+async function detectCurrentImportSymbol(projectPath) {
+  const commonSymbols = ["@", "~", "#", "$", "@src", "@app"];
+  const files = await glob("**/*.{js,jsx,ts,tsx}", {
+    cwd: path.resolve(projectPath)
+  });
+  const symbolCounts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const filePath = path.join(projectPath, file);
+    const content = await fs.readFile(filePath, "utf-8");
+    for (const symbol of commonSymbols) {
+      const importRegex = new RegExp(`(from|import)\\s+(['"])${symbol}/`, "g");
+      const matches = content.match(importRegex);
+      if (matches) {
+        symbolCounts.set(symbol, (symbolCounts.get(symbol) ?? 0) + matches.length);
+      }
+    }
+  }
+  let mostUsedSymbol = null;
+  let maxCount = 0;
+  symbolCounts.forEach((count, symbol) => {
+    if (count > maxCount) {
+      maxCount = count;
+      mostUsedSymbol = symbol;
+    }
+  });
+  return mostUsedSymbol;
+}
+export async function replaceImportSymbol(projectPath, toSymbol) {
+  const fromSymbol = await detectCurrentImportSymbol(projectPath);
+  if (!fromSymbol) {
+    relinka("warn", "No common import symbol detected in the project. No changes will be made.");
+    return;
+  }
+  relinka("info", `Replacing import symbol "${fromSymbol}" with "${toSymbol}" in ${projectPath}`);
+  const files = await glob("**/*.{js,jsx,ts,tsx}", {
+    cwd: path.resolve(projectPath)
+  });
+  for (const file of files) {
+    const filePath = path.join(projectPath, file);
+    const content = await fs.readFile(filePath, "utf-8");
+    const updatedContent = content.replace(
+      new RegExp(`from (['"])${fromSymbol}([^'"]*?)\\1`, "g"),
+      (_match, quote, path2) => `from ${quote}${toSymbol}${path2}${quote}`
+    ).replace(
+      new RegExp(`import (['"])${fromSymbol}([^'"]*?)\\1`, "g"),
+      (_match, quote, path2) => `import ${quote}${toSymbol}${path2}${quote}`
+    );
+    if (content !== updatedContent) {
+      await fs.writeFile(filePath, updatedContent, "utf-8");
+      relinka("info", `Updated imports in ${filePath}`);
+    }
+  }
+}

package/bin/app/utils/codemods/replaceWithModern.d.ts

@@ -0,0 +1 @@
+export declare function replaceWithModern(projectPath: string): Promise<void>;