@reliverse/dler 1.7.91 → 1.7.93

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>;

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

@@ -0,0 +1,122 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { glob } from "tinyglobby";
+const MODERN_REPLACEMENTS = [
+  // File System
+  {
+    pattern: /import fs from ["']fs["'];/g,
+    replacement: 'import fs from "@reliverse/relifso";',
+    description: "Replace Node.js fs with @reliverse/relifso"
+  },
+  {
+    pattern: /import \* as fs from ["']fs["'];/g,
+    replacement: 'import fs from "@reliverse/relifso";',
+    description: "Replace Node.js fs namespace with @reliverse/relifso"
+  },
+  {
+    pattern: /import \{ promises as fs \} from ["']fs["'];/g,
+    replacement: 'import fs from "@reliverse/relifso";',
+    description: "Replace fs.promises with @reliverse/relifso"
+  },
+  // Path
+  {
+    pattern: /import path from ["']path["'];/g,
+    replacement: 'import path from "@reliverse/pathkit";',
+    description: "Replace Node.js path with pathe"
+  },
+  {
+    pattern: /import \* as path from ["']path["'];/g,
+    replacement: 'import path from "@reliverse/pathkit";',
+    description: "Replace Node.js path namespace with pathe"
+  },
+  // HTTP/HTTPS
+  {
+    pattern: /import https? from ["']https?["'];/g,
+    replacement: 'import { fetch } from "undici";',
+    description: "Replace Node.js http/https with undici"
+  },
+  {
+    pattern: /import axios from ["']axios["'];/g,
+    replacement: 'import { fetch } from "undici";',
+    description: "Replace axios with undici"
+  },
+  // Process
+  {
+    pattern: /process\.env\./g,
+    replacement: "import.meta.env.",
+    description: "Replace process.env with import.meta.env"
+  },
+  {
+    pattern: /process\.cwd\(\)/g,
+    replacement: "import.meta.dir",
+    description: "Replace process.cwd() with import.meta.dir"
+  },
+  // URL
+  {
+    pattern: /import url from ["']url["'];/g,
+    replacement: '// Use URL and URLSearchParams globals instead of "url" module',
+    description: "Replace url module with URL globals"
+  },
+  // Console
+  {
+    pattern: /console\.(log|error|warn|info)/g,
+    replacement: "relinka",
+    description: "Replace console.* with relinka"
+  },
+  // Buffer
+  {
+    pattern: /import \{ Buffer \} from ["']buffer["'];/g,
+    replacement: "// Buffer is available globally",
+    description: "Remove Buffer import (globally available)"
+  },
+  // Events
+  {
+    pattern: /import \{ EventEmitter \} from ["']events["'];/g,
+    replacement: 'import { Emitter } from "mitt";',
+    description: "Replace EventEmitter with mitt"
+  }
+];
+export async function replaceWithModern(projectPath) {
+  relinka("info", "Starting modern replacements...");
+  const files = await glob("**/*.{js,ts,tsx}", {
+    cwd: projectPath,
+    absolute: true,
+    ignore: ["node_modules/**", "dist/**", ".next/**", "build/**", "coverage/**"]
+  });
+  let totalReplacements = 0;
+  const replacementsByFile = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    let content = await fs.readFile(file, "utf8");
+    let fileModified = false;
+    const fileReplacements = /* @__PURE__ */ new Set();
+    for (const { pattern, replacement, description } of MODERN_REPLACEMENTS) {
+      const originalContent = content;
+      content = content.replace(pattern, replacement);
+      if (content !== originalContent) {
+        fileModified = true;
+        totalReplacements++;
+        fileReplacements.add(description);
+      }
+    }
+    if (fileModified) {
+      await fs.writeFile(file, content, "utf8");
+      replacementsByFile.set(file, fileReplacements);
+      relinka("success", `Updated ${file}`);
+    }
+  }
+  if (totalReplacements > 0) {
+    relinka("info", "\nReplacement Summary:");
+    for (const [file, replacements] of replacementsByFile.entries()) {
+      relinka("info", `
+${path.relative(projectPath, file)}:`);
+      for (const description of replacements) {
+        relinka("info", `  - ${description}`);
+      }
+    }
+    relinka("success", `
+Completed ${totalReplacements} replacements.`);
+  } else {
+    relinka("info", "No replacements needed.");
+  }
+}

package/bin/app/utils/createPackageJSON.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a package.json file for a new project using pkg-types
+ * @param projectPath Path where the package.json should be created
+ * @param projectName Name of the project
+ */
+export declare function createPackageJSON(projectPath: string, projectName: string, isLib: boolean): Promise<void>;

package/bin/app/utils/createPackageJSON.js

@@ -0,0 +1,20 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { definePackageJSON, writePackageJSON } from "pkg-types";
+export async function createPackageJSON(projectPath, projectName, isLib) {
+  const packageJson = definePackageJSON({
+    name: projectName,
+    version: "0.1.0",
+    description: `${projectName} is built with \u2764\uFE0F by @rse`,
+    type: "module",
+    ...isLib ? {} : { private: true }
+  });
+  const filename = "package.json";
+  const packageJsonPath = path.join(projectPath, filename);
+  await writePackageJSON(packageJsonPath, packageJson);
+  const content = await fs.readFile(packageJsonPath, "utf-8");
+  const formatted = JSON.stringify(JSON.parse(content), null, 2);
+  await fs.writeFile(packageJsonPath, formatted, "utf-8");
+  relinka("verbose", `Created ${filename} with ${isLib ? "library" : "application"} configuration`);
+}

package/bin/app/utils/decideHelper.d.ts

@@ -0,0 +1,12 @@
+import type { RseConfig } from "../types/mod.js";
+/**
+ * A string literal union for either 'gitBehavior' or 'deployBehavior'
+ */
+type DecisionKey = "gitBehavior" | "deployBehavior";
+/**
+ * This function handles the final "yes/no" decision, taking into account:
+ * - The config's behavior key (autoYes, autoNo, prompt)
+ * - Whether skipPrompts is true
+ */
+export declare function decide(config: RseConfig, behaviorKey: DecisionKey, title: string, content: string | undefined, defaultValue: boolean, skipPrompts: boolean): Promise<boolean>;
+export {};

package/bin/app/utils/decideHelper.js

@@ -0,0 +1,32 @@
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt } from "@reliverse/rempts";
+export async function decide(config, behaviorKey, title, content, defaultValue, skipPrompts) {
+  try {
+    let behavior = config?.[behaviorKey] ?? "prompt";
+    if (skipPrompts && behavior === "prompt") {
+      behavior = "autoYes";
+    }
+    switch (behavior) {
+      case "autoYes":
+        relinka("verbose", `Auto-answering YES to: "${title}"`);
+        return true;
+      case "autoNo":
+        relinka("verbose", `Auto-answering NO to: "${title}"`);
+        return false;
+      // default is "prompt":
+      default:
+        return await confirmPrompt({
+          title,
+          content: content ?? "",
+          defaultValue
+        });
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      "Failed to get decision:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return defaultValue;
+  }
+}

package/bin/app/utils/dependencies/getUserPkgManager.d.ts

@@ -0,0 +1,13 @@
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+export type DetectionSource = "runtime" | "env" | "lockfile" | "config" | "default" | "system" | "global";
+export interface PkgManagerInfo {
+    packageManager: PackageManager;
+    source: DetectionSource;
+    version?: string;
+}
+export interface DetectOptions {
+    cwd?: string;
+    includeGlobalBun?: boolean;
+}
+export declare function getUserPkgManager(projectPath?: string, options?: DetectOptions): Promise<PkgManagerInfo>;
+export declare function getAllPkgManagers(projectPath: string, options?: DetectOptions): Promise<PkgManagerInfo[]>;

package/bin/app/utils/dependencies/getUserPkgManager.js

@@ -0,0 +1,178 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { execa } from "execa";
+const cache = /* @__PURE__ */ new Map();
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkPMVersion(pm, includeGlobalBun = true) {
+  if (pm === "bun" && !includeGlobalBun) return null;
+  const cacheKey = `has_global_${pm}`;
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey);
+  }
+  try {
+    const { stdout } = await execa(pm, ["--version"]);
+    if (/^\d+.\d+.\d+$/.test(stdout)) {
+      cache.set(cacheKey, stdout);
+      return stdout;
+    }
+  } catch (_error) {
+    cache.set(cacheKey, null);
+  }
+  return null;
+}
+async function detectLockFile(projectPath) {
+  const cacheKey = `lockfile_${projectPath}`;
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey);
+  }
+  const lockFiles = await Promise.all([
+    pathExists(path.join(projectPath, "yarn.lock")),
+    pathExists(path.join(projectPath, "package-lock.json")),
+    pathExists(path.join(projectPath, "pnpm-lock.yaml")),
+    pathExists(path.join(projectPath, "bun.lock"))
+  ]);
+  let result = null;
+  const [isYarn, isNpm, isPnpm, isBun] = lockFiles;
+  if (isBun) {
+    const version = await checkPMVersion("bun");
+    result = {
+      packageManager: "bun",
+      source: "lockfile",
+      ...version && { version }
+    };
+  } else if (isPnpm) {
+    const version = await checkPMVersion("pnpm");
+    result = {
+      packageManager: "pnpm",
+      source: "lockfile",
+      ...version && { version }
+    };
+  } else if (isYarn) {
+    const version = await checkPMVersion("yarn");
+    result = {
+      packageManager: "yarn",
+      source: "lockfile",
+      ...version && { version }
+    };
+  } else if (isNpm) {
+    const version = await checkPMVersion("npm");
+    result = {
+      packageManager: "npm",
+      source: "lockfile",
+      ...version && { version }
+    };
+  }
+  cache.set(cacheKey, result);
+  return result;
+}
+async function detectPackageManagers(projectPath, options = {}) {
+  const cacheKey = `detect_${projectPath}_${options.includeGlobalBun}`;
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey);
+  }
+  const detected = [];
+  const lockFileResult = await detectLockFile(projectPath);
+  if (lockFileResult) {
+    detected.push(lockFileResult);
+  }
+  try {
+    const { stdout } = await execa("bun", ["--version"]);
+    if (stdout) {
+      detected.push({
+        packageManager: "bun",
+        source: "runtime",
+        version: stdout.trim()
+      });
+    }
+  } catch {
+  }
+  const pkgManagerUserAgent = process.env.npm_config_user_agent ?? "";
+  if (pkgManagerUserAgent.startsWith("yarn")) {
+    detected.push({ packageManager: "yarn", source: "env" });
+  } else if (pkgManagerUserAgent.startsWith("pnpm")) {
+    detected.push({ packageManager: "pnpm", source: "env" });
+  } else if (pkgManagerUserAgent.startsWith("bun")) {
+    detected.push({ packageManager: "bun", source: "env" });
+  }
+  const configFiles = await Promise.all([
+    pathExists(path.join(projectPath, ".npmrc")),
+    pathExists(path.join(projectPath, ".yarnrc")),
+    pathExists(path.join(projectPath, ".yarnrc.yml")),
+    pathExists(path.join(projectPath, ".pnpmfile.cjs")),
+    pathExists(path.join(projectPath, ".pnpmfile.js")),
+    pathExists(path.join(projectPath, "bunfig.toml"))
+  ]);
+  const [hasNpmrc, hasYarnrc, hasYarnrcYml, hasPnpmfileCjs, hasPnpmfileJs, hasBunConfig] = configFiles;
+  if (hasNpmrc) detected.push({ packageManager: "npm", source: "config" });
+  if (hasYarnrc || hasYarnrcYml) detected.push({ packageManager: "yarn", source: "config" });
+  if (hasPnpmfileCjs || hasPnpmfileJs) detected.push({ packageManager: "pnpm", source: "config" });
+  if (hasBunConfig) detected.push({ packageManager: "bun", source: "config" });
+  const versionChecks = await Promise.all([
+    checkPMVersion("npm"),
+    checkPMVersion("pnpm"),
+    checkPMVersion("yarn"),
+    checkPMVersion("bun", options.includeGlobalBun)
+  ]);
+  const pmList = ["npm", "pnpm", "yarn", "bun"];
+  pmList.forEach((pm, index) => {
+    const version = versionChecks[index];
+    if (version) {
+      detected.push({
+        packageManager: pm,
+        source: "global",
+        version
+      });
+    }
+  });
+  cache.set(cacheKey, detected);
+  return detected;
+}
+export async function getUserPkgManager(projectPath, options = {}) {
+  const defaultPM = {
+    packageManager: "npm",
+    source: "default"
+  };
+  const priorityOrder = ["bun", "pnpm", "yarn", "npm"];
+  if (projectPath) {
+    try {
+      const detected = await detectPackageManagers(projectPath, options);
+      if (detected.length === 0) return defaultPM;
+      return priorityOrder.reduce((selected, pm) => {
+        if (selected) return selected;
+        return detected.find((d) => d.packageManager === pm) ?? null;
+      }, null) ?? detected[0] ?? defaultPM;
+    } catch (error) {
+      console.error("Error detecting package manager:", error);
+      return defaultPM;
+    }
+  }
+  let currentDir = process.cwd();
+  const { root } = path.parse(currentDir);
+  while (currentDir !== root) {
+    const detected = await detectPackageManagers(currentDir, options);
+    if (detected.length > 0) {
+      return priorityOrder.reduce((selected, pm) => {
+        if (selected) return selected;
+        return detected.find((d) => d.packageManager === pm) ?? null;
+      }, null) ?? detected[0] ?? defaultPM;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return defaultPM;
+}
+export async function getAllPkgManagers(projectPath, options = {}) {
+  try {
+    const detected = await detectPackageManagers(projectPath, options);
+    return detected.length > 0 ? detected : [{ packageManager: "npm", source: "default" }];
+  } catch (error) {
+    console.error("Error detecting package managers:", error);
+    return [{ packageManager: "npm", source: "default" }];
+  }
+}

package/bin/app/utils/downloading/downloadI18nFiles.d.ts

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