@reliverse/dler 1.7.111 → 1.7.113

package/bin/app/update/migrate/cmd.d.ts

@@ -1,23 +0,0 @@
-declare const _default: import("@reliverse/rempts").Command<{
-    "to-catalog": {
-        type: "boolean";
-        description: string;
-    };
-    "from-catalog": {
-        type: "boolean";
-        description: string;
-    };
-    "remove-catalog": {
-        type: "boolean";
-        description: string;
-    };
-    "dry-run": {
-        type: "boolean";
-        description: string;
-    };
-    interactive: {
-        type: "boolean";
-        description: string;
-    };
-}>;
-export default _default;

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

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

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

@@ -1,50 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { defineCommand, selectPrompt } from "@reliverse/rempts";
-import { execaCommand } from "execa";
-import { cliName } from "../config/constants.js";
-import { getAllPkgManagers } from "../utils/dependencies/getUserPkgManager.js";
-import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
-async function getPmOptions() {
-  const projectPath = getCurrentWorkingDirectory();
-  const detectedPMs = await getAllPkgManagers(projectPath);
-  const detectedPMMap = new Map(detectedPMs.map((pm) => [pm.packageManager, pm.source]));
-  const pmOptions = ["bun", "pnpm", "npm", "yarn"].map((pm) => {
-    const option = {
-      label: pm,
-      value: pm
-    };
-    const source = detectedPMMap.get(pm);
-    if (source && source !== "default") {
-      option.hint = "detected";
-    }
-    return option;
-  });
-  const defaultValue = [...detectedPMMap.keys()][0] ?? "npm";
-  return { pmOptions, defaultValue };
-}
-export default defineCommand({
-  meta: {
-    name: "update",
-    description: "Updates the CLI to the latest version",
-    hidden: false
-  },
-  run: async () => {
-    try {
-      const { pmOptions, defaultValue } = await getPmOptions();
-      const pm = await selectPrompt({
-        title: `Select a package manager to update the ${cliName}`,
-        options: pmOptions,
-        defaultValue
-      });
-      await execaCommand(`${pm} -g update --latest`, { stdio: "inherit" });
-      relinka("success", "Updated successfully!", "You can now use the latest `rse cli` version.");
-    } catch (error) {
-      relinka(
-        "error",
-        "Failed to update @rse",
-        error instanceof Error ? error.message : "Unknown error"
-      );
-    }
-    process.exit(0);
-  }
-});

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

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

package/bin/app/upgrade/cmd.js

@@ -1,302 +0,0 @@
-import { re } from "@reliverse/relico";
-import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts";
-import { lookpath } from "lookpath";
-import { readPackageJSON } from "pkg-types";
-import { x } from "../utils/exec/exec-mod.js";
-import { detectPackageManager } from "../utils/pm/pm-detect.js";
-export default defineCommand({
-  meta: {
-    name: "upgrade",
-    version: "1.0.0",
-    description: "Upgrade system development tools"
-  },
-  args: defineArgs({
-    interactive: {
-      type: "boolean",
-      description: "Interactively select which tools to upgrade",
-      default: true
-    }
-  }),
-  async run({ args }) {
-    const toolUpgradeFunctions = [
-      { name: "dler (local)", fn: upgradeDlerLocal },
-      { name: "dler (global)", fn: upgradeDlerGlobal },
-      { name: "git", fn: upgradeGit },
-      { name: "node.js", fn: upgradeNode },
-      { name: "npm", fn: upgradeNpm },
-      { name: "bun", fn: upgradeBun },
-      { name: "yarn", fn: upgradeYarn },
-      { name: "pnpm", fn: upgradePnpm }
-    ];
-    let results = [];
-    if (args.interactive) {
-      const preliminaryResults = await Promise.all(
-        toolUpgradeFunctions.map(async ({ fn }) => await fn())
-      );
-      const availableTools = toolUpgradeFunctions.map((tool, index) => ({
-        ...tool,
-        result: preliminaryResults[index]
-      })).filter(({ result }) => result && result.status !== "not-found");
-      if (availableTools.length === 0) {
-        relinka("warn", "No tools available for upgrade");
-        return;
-      }
-      const selectedTools = await multiselectPrompt({
-        title: "Select tools to upgrade",
-        displayInstructions: true,
-        options: [
-          { label: "Exit", value: "exit" },
-          ...availableTools.map(({ name, result }) => {
-            const isUpToDate = result && result.status === "up-to-date";
-            const hasErrors = result && result.status === "error";
-            const canUpgrade = result && result.status === "upgraded";
-            let label = name;
-            if (isUpToDate) {
-              label += " (up-to-date)";
-            } else if (hasErrors) {
-              label += " (has errors)";
-            } else if (canUpgrade) {
-              label += " (can be upgraded)";
-            }
-            return {
-              label: isUpToDate || hasErrors ? re.gray(label) : label,
-              value: name,
-              disabled: isUpToDate || hasErrors,
-              hint: hasErrors ? result.message : void 0
-            };
-          })
-        ]
-      });
-      if (selectedTools.length === 0 || selectedTools.includes("exit")) {
-        relinka("info", "Exiting upgrade process");
-        return;
-      }
-      const actualSelectedTools = selectedTools.filter((tool) => tool !== "exit");
-      relinka("info", `Upgrading ${actualSelectedTools.length} selected tools...`);
-      for (const toolName of actualSelectedTools) {
-        const tool = availableTools.find((t) => t.name === toolName);
-        if (tool) {
-          const result = await tool.fn();
-          results.push(result);
-        }
-      }
-    } else {
-      results = await Promise.all(toolUpgradeFunctions.map(async ({ fn }) => await fn()));
-    }
-    const upgraded = results.filter((r) => r.status === "upgraded");
-    const upToDate = results.filter((r) => r.status === "up-to-date");
-    const notFound = results.filter((r) => r.status === "not-found");
-    const errors = results.filter((r) => r.status === "error");
-    if (upgraded.length > 0) {
-      relinka("success", `Upgraded ${upgraded.length} tools:`);
-      upgraded.forEach(
-        (r) => relinka("verbose", `  \u2713 ${r.tool}${r.message ? ` - ${r.message}` : ""}`)
-      );
-    }
-    if (upToDate.length > 0) {
-      relinka("info", `${upToDate.length} tools already up-to-date:`);
-      upToDate.forEach(
-        (r) => relinka("verbose", `  \u2022 ${r.tool}${r.message ? ` - ${r.message}` : ""}`)
-      );
-    }
-    if (notFound.length > 0) {
-      relinka("warn", `${notFound.length} tools not installed (skipped):`);
-      notFound.forEach((r) => relinka("verbose", `  - ${r.tool}`));
-    }
-    if (errors.length > 0) {
-      relinka("error", `${errors.length} tools had errors:`);
-      errors.forEach(
-        (r) => relinka("verbose", `  \u2717 ${r.tool}${r.message ? ` - ${r.message}` : ""}`)
-      );
-    }
-    relinka("success", "Upgrade check completed!");
-  }
-});
-async function upgradeDlerLocal() {
-  try {
-    const pkg = await readPackageJSON();
-    const hasDler = pkg.dependencies && "@reliverse/dler" in pkg.dependencies || pkg.devDependencies && "@reliverse/dler" in pkg.devDependencies;
-    if (!hasDler) {
-      return { tool: "dler (local)", status: "not-found" };
-    }
-    const packageManager = await detectPackageManager(process.cwd());
-    if (!packageManager) {
-      return { tool: "dler (local)", status: "error", message: "No package manager detected" };
-    }
-    const { exitCode } = await x(packageManager.command, ["update", "@reliverse/dler"], {
-      nodeOptions: { stdio: "pipe" }
-    });
-    return exitCode === 0 ? { tool: "dler (local)", status: "upgraded", message: `via ${packageManager.command}` } : { tool: "dler (local)", status: "error", message: "Upgrade failed" };
-  } catch (error) {
-    return {
-      tool: "dler (local)",
-      status: "not-found"
-    };
-  }
-}
-async function upgradeDlerGlobal() {
-  try {
-    const dlerPath = await lookpath("dler");
-    if (!dlerPath) {
-      return { tool: "dler (global)", status: "not-found" };
-    }
-    const packageManagers = ["bun", "npm", "yarn", "pnpm"];
-    for (const pm of packageManagers) {
-      const pmPath = await lookpath(pm);
-      if (pmPath) {
-        try {
-          const args = pm === "npm" ? ["install", "-g", "@reliverse/dler@latest"] : pm === "yarn" ? ["global", "add", "@reliverse/dler@latest"] : ["install", "-g", "@reliverse/dler@latest"];
-          const { exitCode } = await x(pm, args, {
-            nodeOptions: { stdio: "pipe" }
-          });
-          if (exitCode === 0) {
-            return { tool: "dler (global)", status: "upgraded", message: `via ${pm}` };
-          }
-        } catch {
-        }
-      }
-    }
-    return { tool: "dler (global)", status: "error", message: "No suitable package manager found" };
-  } catch (error) {
-    return { tool: "dler (global)", status: "error", message: String(error) };
-  }
-}
-async function upgradeGit() {
-  try {
-    const gitPath = await lookpath("git");
-    if (!gitPath) {
-      return { tool: "git", status: "not-found" };
-    }
-    const { stdout } = await x("git", ["--version"], {
-      nodeOptions: { stdio: "pipe" }
-    });
-    return {
-      tool: "git",
-      status: "up-to-date",
-      message: `${stdout.trim()} - manual upgrade required`
-    };
-  } catch (error) {
-    return { tool: "git", status: "error", message: String(error) };
-  }
-}
-async function upgradeNode() {
-  try {
-    const nodePath = await lookpath("node");
-    if (!nodePath) {
-      return { tool: "node.js", status: "not-found" };
-    }
-    const { stdout } = await x("node", ["--version"], {
-      nodeOptions: { stdio: "pipe" }
-    });
-    return {
-      tool: "node.js",
-      status: "up-to-date",
-      message: `${stdout.trim()} - manual upgrade required`
-    };
-  } catch (error) {
-    return { tool: "node.js", status: "error", message: String(error) };
-  }
-}
-async function upgradeNpm() {
-  try {
-    const npmPath = await lookpath("npm");
-    if (!npmPath) {
-      return { tool: "npm", status: "not-found" };
-    }
-    try {
-      const { exitCode, stdout, stderr } = await x("npm", ["install", "-g", "npm@latest"], {
-        nodeOptions: { stdio: "pipe" }
-      });
-      if (exitCode === 0) {
-        const output = (stdout + stderr).toLowerCase();
-        if (output.includes("unchanged") || output.includes("up-to-date") || output.includes("already")) {
-          return { tool: "npm", status: "up-to-date" };
-        }
-        return { tool: "npm", status: "upgraded" };
-      } else {
-        return { tool: "npm", status: "error", message: "Upgrade failed" };
-      }
-    } catch (pipeError) {
-      const { exitCode } = await x("npm", ["install", "-g", "npm@latest"], {
-        nodeOptions: { stdio: "inherit" }
-      });
-      return exitCode === 0 ? { tool: "npm", status: "upgraded" } : { tool: "npm", status: "error", message: "Upgrade failed" };
-    }
-  } catch (error) {
-    return { tool: "npm", status: "error", message: String(error) };
-  }
-}
-async function upgradeBun() {
-  try {
-    const bunPath = await lookpath("bun");
-    if (!bunPath) {
-      return { tool: "bun", status: "not-found" };
-    }
-    const { exitCode, stdout, stderr } = await x("bun", ["upgrade"], {
-      nodeOptions: { stdio: "pipe" }
-    });
-    if (exitCode !== 0) {
-      return { tool: "bun", status: "error", message: "Upgrade failed" };
-    }
-    const output = (stdout + stderr).toLowerCase();
-    if (output.includes("already") || output.includes("up-to-date") || output.includes("latest")) {
-      return { tool: "bun", status: "up-to-date" };
-    }
-    return { tool: "bun", status: "upgraded" };
-  } catch (error) {
-    return { tool: "bun", status: "error", message: String(error) };
-  }
-}
-async function upgradeYarn() {
-  try {
-    const yarnPath = await lookpath("yarn");
-    if (!yarnPath) {
-      return { tool: "yarn", status: "not-found" };
-    }
-    try {
-      const { exitCode: upgradeResult } = await x("yarn", ["self-update"], {
-        nodeOptions: { stdio: "pipe" }
-      });
-      if (upgradeResult === 0) {
-        return { tool: "yarn", status: "upgraded", message: "self-update" };
-      }
-    } catch {
-    }
-    const npmPath = await lookpath("npm");
-    if (npmPath) {
-      const { exitCode } = await x("npm", ["install", "-g", "yarn@latest"], {
-        nodeOptions: { stdio: "pipe" }
-      });
-      return exitCode === 0 ? { tool: "yarn", status: "upgraded", message: "via npm" } : { tool: "yarn", status: "error", message: "Upgrade failed" };
-    }
-    return { tool: "yarn", status: "error", message: "No upgrade method available" };
-  } catch (error) {
-    return { tool: "yarn", status: "error", message: String(error) };
-  }
-}
-async function upgradePnpm() {
-  try {
-    const pnpmPath = await lookpath("pnpm");
-    if (!pnpmPath) {
-      return { tool: "pnpm", status: "not-found" };
-    }
-    try {
-      const { exitCode } = await x("pnpm", ["add", "-g", "pnpm@latest"], {
-        nodeOptions: { stdio: "pipe" }
-      });
-      return exitCode === 0 ? { tool: "pnpm", status: "upgraded" } : { tool: "pnpm", status: "error", message: "Upgrade failed" };
-    } catch {
-      const npmPath = await lookpath("npm");
-      if (npmPath) {
-        const { exitCode } = await x("npm", ["install", "-g", "pnpm@latest"], {
-          nodeOptions: { stdio: "pipe" }
-        });
-        return exitCode === 0 ? { tool: "pnpm", status: "upgraded", message: "via npm" } : { tool: "pnpm", status: "error", message: "Upgrade failed" };
-      }
-      return { tool: "pnpm", status: "error", message: "No upgrade method available" };
-    }
-  } catch (error) {
-    return { tool: "pnpm", status: "error", message: String(error) };
-  }
-}