@reliverse/dler 1.7.140 → 1.7.141

package/bin/impl/auth/impl/init.d.ts

@@ -146,17 +146,17 @@ export declare const optionsSchema: z.ZodObject<{
     cwd: z.ZodString;
     config: z.ZodOptional<z.ZodString>;
     database: z.ZodOptional<z.ZodEnum<{
-        sqlite: "sqlite";
         mysql: "mysql";
-        mssql: "mssql";
+        sqlite: "sqlite";
+        mongodb: "mongodb";
         postgres: "postgres";
+        mssql: "mssql";
         "drizzle:pg": "drizzle:pg";
         "drizzle:mysql": "drizzle:mysql";
         "drizzle:sqlite": "drizzle:sqlite";
         "prisma:postgresql": "prisma:postgresql";
         "prisma:mysql": "prisma:mysql";
         "prisma:sqlite": "prisma:sqlite";
-        mongodb: "mongodb";
     }>>;
     "skip-db": z.ZodOptional<z.ZodBoolean>;
     "skip-plugins": z.ZodOptional<z.ZodBoolean>;
@@ -165,7 +165,7 @@ export declare const optionsSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const outroText = "\uD83E\uDD73 All Done, Happy Hacking!";
 export declare function getLatestNpmVersion(packageName: string): Promise<string>;
-export declare function getPackageManager(): Promise<"pnpm" | "bun" | "npm" | "yarn">;
+export declare function getPackageManager(): Promise<"npm" | "pnpm" | "yarn" | "bun">;
 export declare function getEnvFiles(cwd: string): Promise<string[]>;
 export declare function updateEnvs({ envs, files, isCommented, }: {
     /**

package/bin/impl/config/constants.d.ts

@@ -1,5 +1,5 @@
 export declare const PROJECT_ROOT: string;
-export declare const cliVersion = "1.7.140";
+export declare const cliVersion = "1.7.141";
 export declare const cliName = "@reliverse/rse";
 export declare const rseName = "@reliverse/rse";
 export declare const dlerName = "@reliverse/dler";

package/bin/impl/config/constants.js

@@ -1,7 +1,7 @@
 import os from "node:os";
 import path from "@reliverse/pathkit";
 export const PROJECT_ROOT = path.resolve(process.cwd());
-const version = "1.7.140";
+const version = "1.7.141";
 export const cliVersion = version;
 export const cliName = "@reliverse/rse";
 export const rseName = "@reliverse/rse";

package/bin/impl/providers/better-t-stack/types.d.ts

@@ -1,27 +1,27 @@
 import { z } from "zod";
 export declare const DatabaseSchema: z.ZodEnum<{
     none: "none";
-    sqlite: "sqlite";
     mysql: "mysql";
-    postgres: "postgres";
+    sqlite: "sqlite";
     mongodb: "mongodb";
+    postgres: "postgres";
 }>;
 export type Database = z.infer<typeof DatabaseSchema>;
 export declare const ORMSchema: z.ZodEnum<{
     none: "none";
-    prisma: "prisma";
     drizzle: "drizzle";
     mongoose: "mongoose";
+    prisma: "prisma";
 }>;
 export type ORM = z.infer<typeof ORMSchema>;
 export declare const BackendSchema: z.ZodEnum<{
     none: "none";
     hono: "hono";
     next: "next";
+    convex: "convex";
     express: "express";
     fastify: "fastify";
     elysia: "elysia";
-    convex: "convex";
 }>;
 export type Backend = z.infer<typeof BackendSchema>;
 export declare const RuntimeSchema: z.ZodEnum<{
@@ -34,8 +34,8 @@ export type Runtime = z.infer<typeof RuntimeSchema>;
 export declare const FrontendSchema: z.ZodEnum<{
     none: "none";
     svelte: "svelte";
-    solid: "solid";
     nuxt: "nuxt";
+    solid: "solid";
     next: "next";
     "react-router": "react-router";
     "tanstack-router": "tanstack-router";
@@ -55,15 +55,15 @@ export declare const AddonsSchema: z.ZodEnum<{
 }>;
 export type Addons = z.infer<typeof AddonsSchema>;
 export declare const ExamplesSchema: z.ZodEnum<{
-    ai: "ai";
     none: "none";
+    ai: "ai";
     todo: "todo";
 }>;
 export type Examples = z.infer<typeof ExamplesSchema>;
 export declare const PackageManagerSchema: z.ZodEnum<{
+    npm: "npm";
     pnpm: "pnpm";
     bun: "bun";
-    npm: "npm";
 }>;
 export type PackageManager = z.infer<typeof PackageManagerSchema>;
 export declare const DatabaseSetupSchema: z.ZodEnum<{

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

@@ -1,49 +1,21 @@
-import { type PackageCheckOptions, type UpdateResult } from "./utils";
+import { type UpdateResult } from "./utils";
 interface UpdateArgs {
+    ci?: boolean;
+    cwd?: string;
     name?: string[];
     ignore?: string[];
-    devOnly?: boolean;
-    prodOnly?: boolean;
-    peerOnly?: boolean;
-    optionalOnly?: boolean;
-    catalogsOnly?: boolean;
     dryRun?: boolean;
-    concurrency?: number;
-    withCheckScript?: boolean;
-    linker?: string;
     withInstall?: boolean;
-    global?: boolean;
-    interactive?: boolean;
-    filter?: string[];
-    allWorkspaces?: boolean;
-    rootOnly?: boolean;
-    recursive?: boolean;
-    savePrefix?: string;
     allowMajor?: boolean;
+    concurrency?: number;
 }
-export declare function validateUpdateArgs(args: UpdateArgs): Promise<void>;
-export declare function handleCatalogOnlyUpdate(args: UpdateArgs): Promise<boolean>;
 export declare function validatePackageJson(): Promise<string>;
-export declare function getEffectiveLinker(args: UpdateArgs): Promise<{
-    effectiveLinker: string;
-    linkerSource: string;
-}>;
-export declare function prepareUpdateCandidates(args: UpdateArgs): Promise<{
-    candidates: string[];
-    allDepsMap: Record<string, any>;
-}>;
 export declare function prepareAllUpdateCandidates(args: UpdateArgs): Promise<{
     candidates: string[];
     allDepsMap: Record<string, any>;
     packageJsonFiles: string[];
 }>;
 export declare function checkPackageUpdates(candidates: string[], allDepsMap: Record<string, any>, args: UpdateArgs): Promise<UpdateResult[]>;
-export declare function handleInteractiveSelection(results: UpdateResult[]): Promise<UpdateResult[]>;
-export declare function updateRootPackageJson(packageJsonPath: string, allDepsMap: Record<string, any>, toUpdate: UpdateResult[], savePrefix: string): Promise<number>;
 export declare function updateAllPackageJsonFiles(packageJsonFiles: string[], toUpdate: UpdateResult[], savePrefix: string): Promise<number>;
-export declare function handleRecursiveUpdates(args: UpdateArgs, options: PackageCheckOptions): Promise<number>;
-export declare function handleWorkspaceUpdates(args: UpdateArgs, options: PackageCheckOptions): Promise<number>;
-export declare function displayUpdateSummary(totalUpdated: number, args: UpdateArgs, isMonorepoProject: boolean, shouldUpdateWorkspaces: boolean): void;
-export declare function handleInstallation(args: UpdateArgs, effectiveLinker: string, packageJson: any): Promise<void>;
-export declare function handleToolUpgrades(args: any): Promise<void>;
+export declare function handleInstallation(): Promise<void>;
 export {};

package/bin/impl/update/impl.js

@@ -1,80 +1,16 @@
 import path from "@reliverse/pathkit";
-import { re } from "@reliverse/relico";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { multiselectPrompt } from "@reliverse/rempts";
-import { $ } from "bun";
 import pMap from "p-map";
-import { readPackageJSON } from "pkg-types";
-import { getConfigBunfig } from "../config/load.js";
-import { isCatalogSupported, updateCatalogs } from "../utils/pm/pm-catalog.js";
+import { glob } from "tinyglobby";
 import { detectPackageManager } from "../utils/pm/pm-detect.js";
 import {
   checkPackageUpdate,
   collectTargetDependencies,
-  findAllPackageJsons,
-  findWorkspacePackageJsons,
-  isMonorepo,
   prepareDependenciesForUpdate,
   runInstallCommand,
-  runInstallCommandWithFilter,
-  updatePackageJsonFile,
-  updateWorkspacePackages,
-  upgradeBun,
-  upgradeDlerGlobal,
-  upgradeDlerLocal,
-  upgradeGit,
-  upgradeNode,
-  upgradeNpm,
-  upgradePnpm,
-  upgradeYarn
+  updatePackageJsonFile
 } from "./utils.js";
-export async function validateUpdateArgs(args) {
-  const exclusiveFlags = [
-    args["devOnly"],
-    args["prodOnly"],
-    args["peerOnly"],
-    args["optionalOnly"],
-    args["catalogsOnly"]
-  ];
-  if (exclusiveFlags.filter(Boolean).length > 1) {
-    relinka(
-      "error",
-      "Cannot specify multiple exclusive flags (--dev-only, --prod-only, --peer-only, --optional-only, --catalogs-only)"
-    );
-    process.exit(1);
-  }
-  if (args["allWorkspaces"] && args["rootOnly"]) {
-    relinka("error", "Cannot specify both --all-workspaces and --root-only flags");
-    process.exit(1);
-  }
-  if (args.recursive && (args["allWorkspaces"] || args["rootOnly"])) {
-    relinka(
-      "error",
-      "Cannot use --recursive with --all-workspaces or --root-only flags. Use --no-recursive to disable recursive mode."
-    );
-    process.exit(1);
-  }
-}
-export async function handleCatalogOnlyUpdate(args) {
-  if (!args["catalogsOnly"]) {
-    return false;
-  }
-  const packageManager = await detectPackageManager(process.cwd());
-  if (!packageManager) {
-    relinka("error", "Could not detect package manager");
-    process.exit(1);
-  }
-  if (!isCatalogSupported(packageManager)) {
-    relinka(
-      "error",
-      `Catalogs are not supported by ${packageManager.name}. Only Bun supports catalogs.`
-    );
-    process.exit(1);
-  }
-  await updateCatalogs(process.cwd());
-  return true;
-}
 export async function validatePackageJson() {
   const packageJsonPath = path.resolve(process.cwd(), "package.json");
   if (!await fs.pathExists(packageJsonPath)) {
@@ -83,46 +19,34 @@ export async function validatePackageJson() {
   }
   return packageJsonPath;
 }
-export async function getEffectiveLinker(args) {
-  let effectiveLinker = args.linker || "hoisted";
-  let linkerSource = "CLI default";
-  if (typeof Bun !== "undefined") {
-    const bunfigConfig = await getConfigBunfig();
-    const bunfigLinker = bunfigConfig?.install?.linker;
-    if (bunfigLinker && ["isolated", "hoisted"].includes(bunfigLinker) && args.linker === "hoisted") {
-      effectiveLinker = bunfigLinker;
-      linkerSource = bunfigLinker === "hoisted" ? "bunfig.toml (same as default)" : "bunfig.toml";
-    }
-  }
-  if (args.linker !== "hoisted") {
-    effectiveLinker = args.linker;
-    linkerSource = "CLI override";
-  }
-  relinka("verbose", `Using linker strategy: ${effectiveLinker} (from ${linkerSource})`);
-  return { effectiveLinker, linkerSource };
-}
-export async function prepareUpdateCandidates(args) {
-  const packageJson = await readPackageJSON();
-  const { map: allDepsMap } = collectTargetDependencies(packageJson, args);
-  const candidates = prepareDependenciesForUpdate(allDepsMap, args);
-  if (candidates.length === 0) {
-    relinka("warn", "No dependencies to update based on provided filters");
-    return { candidates: [], allDepsMap };
-  }
-  return { candidates, allDepsMap };
-}
 export async function prepareAllUpdateCandidates(args) {
-  const packageJsonFiles = await determinePackageJsonFiles(args);
+  const packageJsonFiles = await glob("**/package.json", {
+    cwd: process.cwd(),
+    absolute: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/coverage/**",
+      "**/.next/**",
+      "**/.nuxt/**",
+      "**/out/**",
+      "**/target/**",
+      "**/.turbo/**"
+    ]
+  });
   if (packageJsonFiles.length === 0) {
-    relinka("warn", "No package.json files found to process");
+    relinka("warn", "No package.json files found");
     return { candidates: [], allDepsMap: {}, packageJsonFiles: [] };
   }
+  relinka("verbose", `Found ${packageJsonFiles.length} package.json files`);
   const allDepsMap = {};
   const allCandidates = /* @__PURE__ */ new Set();
   for (const packageJsonPath of packageJsonFiles) {
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
-      const { map } = collectTargetDependencies(packageJson, args);
+      const { map } = collectTargetDependencies(packageJson);
       const candidates2 = prepareDependenciesForUpdate(map, args);
       for (const [dep, info] of Object.entries(map)) {
         if (!allDepsMap[dep]) {
@@ -146,41 +70,17 @@ export async function prepareAllUpdateCandidates(args) {
   }
   const candidates = Array.from(allCandidates);
   if (candidates.length === 0) {
-    relinka(
-      "warn",
-      "No dependencies to update based on provided filters across all package.json files"
-    );
+    relinka("warn", "No dependencies to update");
     return { candidates: [], allDepsMap: {}, packageJsonFiles };
   }
+  relinka("verbose", `Processing ${packageJsonFiles.length} package.json files`);
   return { candidates, allDepsMap, packageJsonFiles };
 }
-async function determinePackageJsonFiles(args) {
-  const cwd = process.cwd();
-  const rootPackageJsonPath = path.resolve(cwd, "package.json");
-  const packageJsonFiles = [];
-  if (await fs.pathExists(rootPackageJsonPath)) {
-    packageJsonFiles.push(rootPackageJsonPath);
-  }
-  if (args.recursive) {
-    const allPackageJsons = await findAllPackageJsons(cwd);
-    const otherPackageJsons = allPackageJsons.filter((p) => p !== rootPackageJsonPath);
-    packageJsonFiles.push(...otherPackageJsons);
-    return packageJsonFiles;
-  }
-  const isMonorepoProject = await isMonorepo(cwd);
-  if (args.allWorkspaces) {
-    const workspacePkgJsons = await findWorkspacePackageJsons(cwd);
-    packageJsonFiles.push(...workspacePkgJsons);
-  } else if (!args.rootOnly && isMonorepoProject) {
-    const workspacePkgJsons = await findWorkspacePackageJsons(cwd);
-    packageJsonFiles.push(...workspacePkgJsons);
-  }
-  return packageJsonFiles;
-}
 export async function checkPackageUpdates(candidates, allDepsMap, args) {
   const options = {
-    allowMajor: !!args["allowMajor"],
-    savePrefix: args["savePrefix"],
+    allowMajor: !!args.allowMajor,
+    savePrefix: "^",
+    // Use default prefix
     concurrency: args.concurrency || 5
   };
   return await pMap(
@@ -203,61 +103,6 @@ export async function checkPackageUpdates(candidates, allDepsMap, args) {
     { concurrency: args.concurrency || 5 }
   );
 }
-export async function handleInteractiveSelection(results) {
-  const 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);
-  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("log", "Exiting update process");
-    return [];
-  }
-  const actualSelectedPackages = selectedPackages.filter((pkg) => pkg !== "exit");
-  const filteredToUpdate = toUpdate.filter(
-    (update) => actualSelectedPackages.includes(update.package)
-  );
-  relinka("log", `Updating ${actualSelectedPackages.length} selected dependencies...`);
-  return filteredToUpdate;
-}
-export async function updateRootPackageJson(packageJsonPath, allDepsMap, toUpdate, savePrefix) {
-  return await updatePackageJsonFile(packageJsonPath, allDepsMap, toUpdate, savePrefix);
-}
 export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, savePrefix) {
   if (packageJsonFiles.length === 0 || toUpdate.length === 0) {
     return 0;
@@ -266,7 +111,7 @@ export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, save
   for (const packageJsonPath of packageJsonFiles) {
     try {
       const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
-      const { map: fileDepsMap } = collectTargetDependencies(packageJson, {});
+      const { map: fileDepsMap } = collectTargetDependencies(packageJson);
       const fileSpecificUpdates = toUpdate.filter((update) => fileDepsMap[update.package]);
       if (fileSpecificUpdates.length > 0) {
         const updated = await updatePackageJsonFile(
@@ -290,170 +135,17 @@ export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, save
   }
   return totalUpdated;
 }
-export async function handleRecursiveUpdates(args, options) {
-  const allPackageJsons = await findAllPackageJsons(process.cwd());
-  const rootPackageJsonPath = path.resolve(process.cwd(), "package.json");
-  const otherPackageJsons = allPackageJsons.filter((p) => p !== rootPackageJsonPath);
-  if (otherPackageJsons.length > 0) {
-    relinka(
-      "verbose",
-      `Found ${otherPackageJsons.length} additional package.json files to update recursively`
-    );
-    return await updateWorkspacePackages(otherPackageJsons, args, options);
-  }
-  return 0;
-}
-export async function handleWorkspaceUpdates(args, options) {
-  const isMonorepoProject = await isMonorepo(process.cwd());
-  const shouldUpdateWorkspaces = args["allWorkspaces"] || !args["rootOnly"] && isMonorepoProject;
-  if (shouldUpdateWorkspaces) {
-    const workspacePkgJsons = await findWorkspacePackageJsons(process.cwd());
-    if (workspacePkgJsons.length > 0) {
-      return await updateWorkspacePackages(workspacePkgJsons, args, options);
-    } else if (args["allWorkspaces"]) {
-      relinka("warn", "No workspace packages found but --all-workspaces flag was provided");
-    }
-  } else if (isMonorepoProject) {
-    relinka("log", "Skipping workspace packages due to --root-only flag");
-  }
-  return 0;
-}
-export function displayUpdateSummary(totalUpdated, args, isMonorepoProject, shouldUpdateWorkspaces) {
-  if (args.recursive) {
-    relinka("log", `Updated ${totalUpdated} dependencies across all package.json files`);
-  } else {
-    if (isMonorepoProject && shouldUpdateWorkspaces) {
-      relinka("log", `Updated ${totalUpdated} dependencies across workspace (root + workspaces)`);
-    } else if (isMonorepoProject) {
-      relinka("log", `Updated ${totalUpdated} dependencies in root package.json only`);
-    } else {
-      relinka("log", `Updated ${totalUpdated} dependencies`);
-    }
-  }
-}
-export async function handleInstallation(args, effectiveLinker, packageJson) {
-  if (!args["withInstall"]) {
-    const packageManager2 = await detectPackageManager(process.cwd());
-    const installCommand = packageManager2?.command || "your package manager";
-    relinka(
-      "log",
-      `Install step is skipped by default. Run '${installCommand} install' manually to apply the changes.`
-    );
-    relinka(
-      "log",
-      `(experimental) Next time you can try --withInstall flag to run it automatically.`
-    );
-    return;
-  }
+export async function handleInstallation() {
   const packageManager = await detectPackageManager(process.cwd());
   if (!packageManager) {
     relinka("warn", "Could not detect package manager. Please run install manually.");
     return;
   }
   try {
-    if (args.filter && args.filter.length > 0) {
-      const filterArgs = args.filter.flatMap((filter) => ["--filter", filter]);
-      await runInstallCommandWithFilter(packageManager, effectiveLinker, filterArgs);
-    } else {
-      await runInstallCommand(packageManager, effectiveLinker);
-    }
-    if (packageManager.name === "bun" && packageJson.scripts?.check && args["withCheckScript"]) {
-      await $`bun check`;
-    }
+    await runInstallCommand(packageManager);
+    relinka("log", "Installation completed successfully");
   } catch (error) {
     relinka("warn", `Install failed: ${error instanceof Error ? error.message : String(error)}`);
     relinka("log", `Run '${packageManager.command} install' manually to apply the changes`);
   }
 }
-export async function handleToolUpgrades(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["upgrade-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!");
-}