@reliverse/dler 1.7.68 → 1.7.70

package/bin/app/update/cmd.js

@@ -1,8 +1,9 @@
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts";
 import { $ } from "bun";
+import { lookpath } from "lookpath";
 import pMap from "p-map";
 import { readPackageJSON } from "pkg-types";
 import semver from "semver";
@@ -52,6 +53,220 @@ async function getLatestVersion(packageName) {
     }
   }
 }
+async function getGlobalPackages(packageManager) {
+  try {
+    let result;
+    if (packageManager === "npm") {
+      result = await $`npm list -g --depth=0 --json`.json();
+    } else if (packageManager === "yarn") {
+      try {
+        result = await $`yarn global list --json`.json();
+      } catch {
+        result = await $`yarn global list`.text();
+        const packages2 = {};
+        const lines = result.split("\n");
+        for (const line of lines) {
+          const match = line.match(/^(.+)@([^@]+)$/);
+          if (match) {
+            packages2[match[1]] = match[2];
+          }
+        }
+        return packages2;
+      }
+    } else if (packageManager === "pnpm") {
+      result = await $`pnpm list -g --depth=0 --json`.json();
+    } else if (packageManager === "bun") {
+      result = await $`bun pm ls -g --json`.json();
+    } else {
+      throw new Error(`Unsupported package manager: ${packageManager}`);
+    }
+    const dependencies = result?.dependencies || {};
+    const packages = {};
+    for (const [name, info] of Object.entries(dependencies)) {
+      if (info && typeof info === "object" && "version" in info) {
+        packages[name] = info.version;
+      }
+    }
+    return packages;
+  } catch (error) {
+    relinka("warn", `Failed to get global packages for ${packageManager}: ${error}`);
+    return {};
+  }
+}
+async function updateGlobalPackage(packageManager, packageName) {
+  try {
+    if (packageManager === "npm") {
+      await $`npm install -g ${packageName}@latest`;
+    } else if (packageManager === "yarn") {
+      await $`yarn global add ${packageName}@latest`;
+    } else if (packageManager === "pnpm") {
+      await $`pnpm add -g ${packageName}@latest`;
+    } else if (packageManager === "bun") {
+      await $`bun install -g ${packageName}@latest`;
+    } else {
+      throw new Error(`Unsupported package manager: ${packageManager}`);
+    }
+    return true;
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to update global package ${packageName} with ${packageManager}: ${error}`
+    );
+    return false;
+  }
+}
+async function handleGlobalUpdates(args) {
+  const packageManagers = ["bun", "npm", "yarn", "pnpm"];
+  const availablePackageManagers = [];
+  for (const pm of packageManagers) {
+    if (await lookpath(pm)) {
+      availablePackageManagers.push(pm);
+    }
+  }
+  if (availablePackageManagers.length === 0) {
+    relinka("error", "No supported package managers found");
+    return process.exit(1);
+  }
+  relinka("info", `Found package managers: ${availablePackageManagers.join(", ")}`);
+  const allGlobalPackages = {};
+  for (const pm of availablePackageManagers) {
+    const packages = await getGlobalPackages(pm);
+    for (const [name, version] of Object.entries(packages)) {
+      if (!allGlobalPackages[name] || semver.gt(version, allGlobalPackages[name].version)) {
+        allGlobalPackages[name] = { version, packageManager: pm };
+      }
+    }
+  }
+  const globalPackageNames = Object.keys(allGlobalPackages);
+  if (globalPackageNames.length === 0) {
+    relinka("warn", "No global packages found");
+    return;
+  }
+  let filteredPackages = [];
+  if (args.name && args.name.length > 0) {
+    filteredPackages = args.name.filter((pkg) => pkg in allGlobalPackages);
+    const notFound = args.name.filter((pkg) => !(pkg in allGlobalPackages));
+    if (notFound.length > 0) {
+      relinka("warn", `Global packages not found: ${notFound.join(", ")}`);
+    }
+  } else {
+    const ignoreList = args.ignore || [];
+    filteredPackages = globalPackageNames.filter((pkg) => !ignoreList.includes(pkg));
+  }
+  if (filteredPackages.length === 0) {
+    relinka("warn", "No global packages to update");
+    return;
+  }
+  relinka("info", `Checking ${filteredPackages.length} global packages for updates...`);
+  const results = await pMap(
+    filteredPackages,
+    async (packageName) => {
+      const globalPackage = allGlobalPackages[packageName];
+      if (!globalPackage) {
+        return {
+          package: packageName,
+          currentVersion: "unknown",
+          latestVersion: "unknown",
+          updated: false,
+          error: "Package not found in global packages",
+          location: "global"
+        };
+      }
+      try {
+        const latest = await getLatestVersion(packageName);
+        const needsUpdate = semver.gt(latest, globalPackage.version);
+        return {
+          package: packageName,
+          currentVersion: globalPackage.version,
+          latestVersion: latest,
+          updated: needsUpdate,
+          location: `global (${globalPackage.packageManager})`
+        };
+      } catch (error) {
+        return {
+          package: packageName,
+          currentVersion: globalPackage.version,
+          latestVersion: globalPackage.version,
+          updated: false,
+          error: error instanceof Error ? error.message : String(error),
+          location: `global (${globalPackage.packageManager})`
+        };
+      }
+    },
+    { concurrency: args.concurrency }
+  );
+  let toUpdate = results.filter((r) => r.updated && !r.error);
+  const errors = results.filter((r) => r.error);
+  const upToDate = results.filter((r) => !r.updated && !r.error);
+  if (errors.length > 0) {
+    relinka("warn", `Failed to check ${errors.length} global packages:`);
+    for (const error of errors) {
+      relinka("warn", `  ${error.package} (${error.location}): ${error.error}`);
+    }
+  }
+  if (upToDate.length > 0) {
+    relinka("success", `${upToDate.length} global packages are up to date`);
+  }
+  if (toUpdate.length === 0) {
+    relinka("success", "All global packages are up to date");
+    return;
+  }
+  relinka("info", `${toUpdate.length} global packages can be updated:`);
+  for (const update of toUpdate) {
+    relinka(
+      "log",
+      `  ${update.package} (${update.location}): ${update.currentVersion} \u2192 ${update.latestVersion}`
+    );
+  }
+  if (args.interactive) {
+    const allGlobalPackages2 = [
+      ...toUpdate.map((pkg) => ({ ...pkg, canUpdate: true, isUpToDate: false, hasError: false })),
+      ...upToDate.map((pkg) => ({ ...pkg, canUpdate: false, isUpToDate: true, hasError: false })),
+      ...errors.map((pkg) => ({ ...pkg, canUpdate: false, isUpToDate: false, hasError: true }))
+    ];
+    const selectedPackages = await multiselectPrompt({
+      title: "Select global packages to update",
+      options: [
+        { label: "Exit", value: "exit" },
+        ...allGlobalPackages2.map((pkg) => {
+          let label = `${pkg.package} (${pkg.location})`;
+          if (pkg.canUpdate) {
+            label += `: ${pkg.currentVersion} \u2192 ${pkg.latestVersion}`;
+          } else if (pkg.isUpToDate) {
+            label += `: ${pkg.currentVersion} (up-to-date)`;
+          } else if (pkg.hasError) {
+            label += `: ${pkg.currentVersion} (has errors)`;
+          }
+          return {
+            label,
+            value: pkg.package,
+            disabled: !pkg.canUpdate,
+            hint: pkg.hasError ? pkg.error : void 0
+          };
+        })
+      ]
+    });
+    if (selectedPackages.length === 0 || selectedPackages.includes("exit")) {
+      relinka("info", "Exiting global update process");
+      return;
+    }
+    const actualSelectedPackages = selectedPackages.filter((pkg) => pkg !== "exit");
+    toUpdate = toUpdate.filter((update) => actualSelectedPackages.includes(update.package));
+    relinka("info", `Updating ${actualSelectedPackages.length} selected global packages...`);
+  }
+  if (args["dry-run"]) {
+    relinka("info", "Dry run mode - no changes were made");
+    return;
+  }
+  let successCount = 0;
+  for (const update of toUpdate) {
+    const globalPackage = allGlobalPackages[update.package];
+    if (globalPackage && await updateGlobalPackage(globalPackage.packageManager, update.package)) {
+      successCount++;
+    }
+  }
+  relinka("success", `Successfully updated ${successCount}/${toUpdate.length} global packages`);
+}
 export default defineCommand({
   meta: {
     name: "update",
@@ -117,10 +332,24 @@ export default defineCommand({
       description: "Skip the install step after updating dependencies",
       default: false,
       alias: "no-i"
+    },
+    global: {
+      type: "boolean",
+      description: "Update global packages instead of local dependencies",
+      default: false,
+      alias: "g"
+    },
+    interactive: {
+      type: "boolean",
+      description: "Interactively select which dependencies to update",
+      default: false
     }
   }),
   async run({ args }) {
     try {
+      if (args.global) {
+        return await handleGlobalUpdates(args);
+      }
       const packageJsonPath = path.resolve(process.cwd(), "package.json");
       if (!await fs.pathExists(packageJsonPath)) {
         relinka("error", "No package.json found in current directory");
@@ -288,7 +517,7 @@ export default defineCommand({
         },
         { concurrency: args.concurrency }
       );
-      const toUpdate = results.filter((r) => r.updated && !r.error);
+      let toUpdate = results.filter((r) => r.updated && !r.error);
       const errors = results.filter((r) => r.error);
       const upToDate = results.filter((r) => !r.updated && !r.error && r.semverCompatible);
       if (errors.length > 0) {
@@ -315,6 +544,52 @@ export default defineCommand({
           `  ${update.package} (${update.location}): ${update.currentVersion} \u2192 ${update.latestVersion}`
         );
       }
+      if (args.interactive) {
+        const allPackages = [
+          ...toUpdate.map((pkg) => ({
+            ...pkg,
+            canUpdate: true,
+            isUpToDate: false,
+            hasError: false
+          })),
+          ...upToDate.map((pkg) => ({
+            ...pkg,
+            canUpdate: false,
+            isUpToDate: true,
+            hasError: false
+          })),
+          ...errors.map((pkg) => ({ ...pkg, canUpdate: false, isUpToDate: false, hasError: true }))
+        ];
+        const selectedPackages = await multiselectPrompt({
+          title: "Select dependencies to update",
+          options: [
+            { label: "Exit", value: "exit" },
+            ...allPackages.map((pkg) => {
+              let label = `${pkg.package} (${pkg.location})`;
+              if (pkg.canUpdate) {
+                label += `: ${pkg.currentVersion} \u2192 ${pkg.latestVersion}`;
+              } else if (pkg.isUpToDate) {
+                label += `: ${pkg.currentVersion} (up-to-date)`;
+              } else if (pkg.hasError) {
+                label += `: ${pkg.currentVersion} (has errors)`;
+              }
+              return {
+                label,
+                value: pkg.package,
+                disabled: !pkg.canUpdate,
+                hint: pkg.hasError ? pkg.error : void 0
+              };
+            })
+          ]
+        });
+        if (selectedPackages.length === 0 || selectedPackages.includes("exit")) {
+          relinka("info", "Exiting update process");
+          return;
+        }
+        const actualSelectedPackages = selectedPackages.filter((pkg) => pkg !== "exit");
+        toUpdate = toUpdate.filter((update) => actualSelectedPackages.includes(update.package));
+        relinka("info", `Updating ${actualSelectedPackages.length} selected dependencies...`);
+      }
       if (args["dry-run"]) {
         relinka("info", "Dry run mode - no changes were made");
         return;

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

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

package/bin/app/upgrade/cmd.js

@@ -0,0 +1,295 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts";
+import { lookpath } from "lookpath";
+import { readPackageJSON } from "pkg-types";
+import { x } from "../../libs/sdk/sdk-impl/utils/exec/exec-mod.js";
+import { detectPackageManager } from "../../libs/sdk/sdk-impl/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", disabled: true },
+          ...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,
+              value: name,
+              disabled: isUpToDate,
+              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("log", `  \u2713 ${r.tool}${r.message ? ` - ${r.message}` : ""}`));
+    }
+    if (upToDate.length > 0) {
+      relinka("info", `${upToDate.length} tools already up-to-date:`);
+      upToDate.forEach((r) => relinka("log", `  \u2022 ${r.tool}${r.message ? ` - ${r.message}` : ""}`));
+    }
+    if (notFound.length > 0) {
+      relinka("warn", `${notFound.length} tools not installed (skipped):`);
+      notFound.forEach((r) => relinka("log", `  - ${r.tool}`));
+    }
+    if (errors.length > 0) {
+      relinka("error", `${errors.length} tools had errors:`);
+      errors.forEach((r) => relinka("log", `  \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) };
+  }
+}