@reliverse/dler 1.7.153 → 2.0.1

package/bin/impl/update/impl.js

@@ -1,142 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import pMap from "p-map";
-import { glob } from "tinyglobby";
-import { detectPackageManager } from "../utils/pm/pm-detect.js";
-import {
-  applyVersionUpdate,
-  checkPackageUpdate,
-  collectTargetDependencies,
-  prepareDependenciesForUpdate,
-  runInstallCommand
-} from "./utils.js";
-export async function validatePackageJson() {
-  const packageJsonPath = path.resolve(process.cwd(), "package.json");
-  if (!await fs.pathExists(packageJsonPath)) {
-    relinka("error", "No package.json found in current directory");
-    process.exit(1);
-  }
-  return packageJsonPath;
-}
-export async function prepareAllUpdateCandidates() {
-  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");
-    return { packageJsonFiles: [], fileDepsMap: /* @__PURE__ */ new Map() };
-  }
-  relinka("verbose", `Found ${packageJsonFiles.length} package.json files`);
-  const fileDepsMap = /* @__PURE__ */ new Map();
-  for (const packageJsonPath of packageJsonFiles) {
-    try {
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
-      const { map } = collectTargetDependencies(packageJson);
-      fileDepsMap.set(packageJsonPath, map);
-    } catch (error) {
-      relinka(
-        "warn",
-        `Failed to process ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  relinka("verbose", `Processing ${packageJsonFiles.length} package.json files`);
-  return { packageJsonFiles, fileDepsMap };
-}
-export async function checkPackageUpdatesForFile(fileDepsMap, args) {
-  const options = {
-    allowMajor: !!args.allowMajor,
-    savePrefix: "^",
-    // Use default prefix
-    concurrency: args.concurrency || 5
-  };
-  const candidates = prepareDependenciesForUpdate(fileDepsMap, args);
-  if (candidates.length === 0) {
-    return [];
-  }
-  return await pMap(
-    candidates,
-    async (dep) => {
-      const depInfo = fileDepsMap[dep];
-      if (!depInfo?.versionSpec) {
-        return {
-          package: dep,
-          currentVersion: "unknown",
-          latestVersion: "unknown",
-          updated: false,
-          error: "Current version not found",
-          semverCompatible: false,
-          location: "unknown"
-        };
-      }
-      return checkPackageUpdate(dep, depInfo.versionSpec, depInfo.locations, options);
-    },
-    { concurrency: args.concurrency || 5 }
-  );
-}
-export async function updatePackageJsonFileDirectly(packageJsonPath, fileDepsMap, updatesToApply, savePrefix, fieldsToIgnore = []) {
-  if (updatesToApply.length === 0) return 0;
-  try {
-    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
-    const updatedPackageJson = { ...packageJson };
-    for (const update of updatesToApply) {
-      const depInfo = fileDepsMap[update.package];
-      if (!depInfo) continue;
-      const locations = depInfo.locations || /* @__PURE__ */ new Set();
-      const shouldIgnore = Array.from(locations).some(
-        (location) => fieldsToIgnore.includes(String(location))
-      );
-      if (shouldIgnore) {
-        continue;
-      }
-      let newVersion;
-      if (locations.has("peerDependencies")) {
-        const currentVersion = String(fileDepsMap[update.package]?.versionSpec || "");
-        if (currentVersion.startsWith(">=")) {
-          newVersion = `>=${update.latestVersion}`;
-        } else {
-          newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
-        }
-      } else {
-        newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
-      }
-      applyVersionUpdate(updatedPackageJson, update.package, newVersion, locations);
-    }
-    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
-    return updatesToApply.length;
-  } catch (error) {
-    relinka(
-      "warn",
-      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return 0;
-  }
-}
-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 {
-    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`);
-  }
-}

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

@@ -1,87 +0,0 @@
-import { type PackageManager } from "../utils/dependencies/getUserPkgManager.js";
-export interface UpdateResult {
-    package: string;
-    currentVersion: string;
-    latestVersion: string;
-    updated: boolean;
-    error?: string;
-    semverCompatible?: boolean;
-    location?: string;
-}
-export interface DependencyInfo {
-    versionSpec: string;
-    locations: Set<string>;
-}
-export interface PackageCheckOptions {
-    allowMajor: boolean;
-    savePrefix: string;
-    concurrency: number;
-}
-/**
- * Check if a dependency is an npm alias (e.g., "npm:package-name@version")
- */
-export declare function isNpmAlias(versionSpec: string): boolean;
-/**
- * Check if a dependency is a workspace dependency (e.g., "workspace:*")
- */
-export declare function isWorkspaceDependency(versionSpec: string): boolean;
-export declare function isCatalogReference(versionSpec: string): boolean;
-export declare function isNonSemverSpecifier(versionSpec: string): boolean;
-/**
- * Check if a version update is semver-compatible with the current version range
- * Note: Returns false for exact versions (handled separately in checkPackageUpdate)
- */
-export declare function isSemverCompatible(currentVersionRange: string, latestVersion: string): boolean;
-/**
- * Collect ALL dependencies from package.json.
- * Returns a map of dependency name to its version and all locations where it appears.
- */
-export declare function collectTargetDependencies(pkg: any): {
-    map: Record<string, DependencyInfo>;
-};
-/**
- * Apply a version update into all relevant places in package.json for a dependency.
- */
-export declare function applyVersionUpdate(pkg: any, depName: string, newVersion: string, locations: Set<string>): void;
-/**
- * Fallback function to fetch package version directly from npm registry
- */
-export declare function fetchVersionFromRegistry(packageName: string): Promise<string>;
-/**
- * Get latest version of a package
- */
-export declare function getLatestVersion(packageName: string): Promise<string>;
-/**
- * Check if a package needs updating and get update information
- *
- * Update behavior:
- * - Gets latest version from registry (not just semver-compatible)
- * - Exact versions (1.0.0): Always allow updates to latest
- * - Prefixed versions (^1.0.0, ~1.0.0): Updates to latest if allowMajor=true (default)
- * - When allowMajor=false: Only allows updates within semver range
- */
-export declare function checkPackageUpdate(packageName: string, versionSpec: string, locations: Set<string>, options: PackageCheckOptions): Promise<UpdateResult>;
-/**
- * Filter and prepare dependencies for updating with glob pattern support
- */
-export declare function prepareDependenciesForUpdate(allDepsMap: Record<string, DependencyInfo>, args: any): string[];
-/**
- * Update a single package.json file with new dependency versions
- */
-export declare function updatePackageJsonFile(packageJsonPath: string, dependencies: Record<string, DependencyInfo>, updatesToApply: UpdateResult[], savePrefix: string, fieldsToIgnore?: string[]): Promise<number>;
-/**
- * Display update results in a structured, file-by-file format
- */
-export declare function displayStructuredUpdateResults(results: UpdateResult[], packageJsonFiles: string[], fileDepsMap: Map<string, Record<string, any>>, showDetails?: boolean): void;
-/**
- * Run install command for the detected package manager
- */
-export declare function runInstallCommand(packageManager: any): Promise<void>;
-export declare function getPmOptions(): Promise<{
-    pmOptions: {
-        label: string;
-        value: PackageManager;
-        hint?: string;
-    }[];
-    defaultValue: any;
-}>;

package/bin/impl/update/utils.js

@@ -1,448 +0,0 @@
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import rematch from "@reliverse/rematch";
-import { $ } from "bun";
-import path from "path";
-import semver from "semver";
-import {
-  getAllPkgManagers
-} from "../utils/dependencies/getUserPkgManager.js";
-import { latestVersion } from "../utils/pm/pm-meta.js";
-import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
-export function isNpmAlias(versionSpec) {
-  return versionSpec.startsWith("npm:");
-}
-export function isWorkspaceDependency(versionSpec) {
-  return versionSpec.startsWith("workspace:");
-}
-export function isCatalogReference(versionSpec) {
-  return versionSpec.startsWith("catalog:");
-}
-export function isNonSemverSpecifier(versionSpec) {
-  return isNpmAlias(versionSpec) || isWorkspaceDependency(versionSpec) || isCatalogReference(versionSpec) || versionSpec.startsWith("git+") || versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("http:") || versionSpec.startsWith("https:");
-}
-export function isSemverCompatible(currentVersionRange, latestVersion2) {
-  try {
-    if (isNpmAlias(currentVersionRange)) {
-      return false;
-    }
-    if (isWorkspaceDependency(currentVersionRange)) {
-      return false;
-    }
-    if (!currentVersionRange.startsWith("^") && !currentVersionRange.startsWith("~")) {
-      return false;
-    }
-    return semver.satisfies(latestVersion2, currentVersionRange);
-  } catch {
-    return false;
-  }
-}
-export function collectTargetDependencies(pkg) {
-  const map = {};
-  const dependencies = pkg.dependencies || {};
-  const devDependencies = pkg.devDependencies || {};
-  const peerDependencies = pkg.peerDependencies || {};
-  const optionalDependencies = pkg.optionalDependencies || {};
-  for (const dep of Object.keys(dependencies)) {
-    const version = dependencies[dep];
-    if (!version) continue;
-    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-    map[dep].versionSpec = version;
-    map[dep].locations.add("dependencies");
-  }
-  for (const dep of Object.keys(devDependencies)) {
-    const version = devDependencies[dep];
-    if (!version) continue;
-    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-    map[dep].versionSpec = version;
-    map[dep].locations.add("devDependencies");
-  }
-  for (const dep of Object.keys(peerDependencies)) {
-    const version = peerDependencies[dep];
-    if (!version) continue;
-    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-    map[dep].versionSpec = version;
-    map[dep].locations.add("peerDependencies");
-  }
-  for (const dep of Object.keys(optionalDependencies)) {
-    const version = optionalDependencies[dep];
-    if (!version) continue;
-    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-    map[dep].versionSpec = version;
-    map[dep].locations.add("optionalDependencies");
-  }
-  const workspacesCatalog = pkg.workspaces?.catalog || {};
-  for (const dep of Object.keys(workspacesCatalog)) {
-    const version = workspacesCatalog[dep];
-    if (!version) continue;
-    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-    map[dep].versionSpec = version;
-    map[dep].locations.add("catalog");
-  }
-  const workspacesCatalogs = pkg.workspaces?.catalogs || {};
-  for (const catalogName of Object.keys(workspacesCatalogs)) {
-    const catalog = workspacesCatalogs[catalogName] || {};
-    for (const dep of Object.keys(catalog)) {
-      const version = catalog[dep];
-      if (!version) continue;
-      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-      map[dep].versionSpec = version;
-      map[dep].locations.add(`catalogs.${catalogName}`);
-    }
-  }
-  const topLevelCatalog = pkg.catalog || {};
-  for (const dep of Object.keys(topLevelCatalog)) {
-    const version = topLevelCatalog[dep];
-    if (!version) continue;
-    if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-    map[dep].versionSpec = version;
-    map[dep].locations.add("catalog");
-  }
-  const topLevelCatalogs = pkg.catalogs || {};
-  for (const catalogName of Object.keys(topLevelCatalogs)) {
-    const catalog = topLevelCatalogs[catalogName] || {};
-    for (const dep of Object.keys(catalog)) {
-      const version = catalog[dep];
-      if (!version) continue;
-      if (!map[dep]) map[dep] = { versionSpec: version, locations: /* @__PURE__ */ new Set() };
-      map[dep].versionSpec = version;
-      map[dep].locations.add(`catalogs.${catalogName}`);
-    }
-  }
-  return { map };
-}
-export function applyVersionUpdate(pkg, depName, newVersion, locations) {
-  if (locations.has("dependencies")) {
-    if (!pkg.dependencies) pkg.dependencies = {};
-    pkg.dependencies[depName] = newVersion;
-  }
-  if (locations.has("devDependencies")) {
-    if (!pkg.devDependencies) pkg.devDependencies = {};
-    pkg.devDependencies[depName] = newVersion;
-  }
-  if (locations.has("peerDependencies")) {
-    if (!pkg.peerDependencies) pkg.peerDependencies = {};
-    pkg.peerDependencies[depName] = newVersion;
-  }
-  if (locations.has("optionalDependencies")) {
-    if (!pkg.optionalDependencies) pkg.optionalDependencies = {};
-    pkg.optionalDependencies[depName] = newVersion;
-  }
-  const ensureWorkspaces = () => {
-    if (!pkg.workspaces) pkg.workspaces = {};
-  };
-  if (locations.has("catalog")) {
-    ensureWorkspaces();
-    if (!pkg.workspaces.catalog) pkg.workspaces.catalog = {};
-    pkg.workspaces.catalog[depName] = newVersion;
-    if (pkg.catalog) pkg.catalog[depName] = newVersion;
-  }
-  for (const loc of locations) {
-    const match = /^catalogs\.(.+)$/.exec(loc);
-    if (match) {
-      const catalogName = match[1] ?? "";
-      if (!catalogName) continue;
-      ensureWorkspaces();
-      if (!pkg.workspaces.catalogs) pkg.workspaces.catalogs = {};
-      if (!pkg.workspaces.catalogs[catalogName])
-        pkg.workspaces.catalogs[catalogName] = {};
-      pkg.workspaces.catalogs[catalogName][depName] = newVersion;
-      if (pkg.catalogs && pkg.catalogs[catalogName]) {
-        pkg.catalogs[catalogName][depName] = newVersion;
-      }
-    }
-  }
-}
-export async function fetchVersionFromRegistry(packageName) {
-  const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  }
-  const data = await response.json();
-  return data.version;
-}
-export async function getLatestVersion(packageName) {
-  try {
-    return await latestVersion(packageName);
-  } catch (error) {
-    try {
-      return await fetchVersionFromRegistry(packageName);
-    } catch (fallbackError) {
-      throw new Error(`Failed to get latest version for ${packageName}: ${error}`);
-    }
-  }
-}
-export async function checkPackageUpdate(packageName, versionSpec, locations, options) {
-  try {
-    const latest = await getLatestVersion(packageName);
-    const cleanCurrent = versionSpec.replace(/^[\^~]/, "");
-    let isCompatible = isSemverCompatible(versionSpec, latest);
-    const isExact = !versionSpec.startsWith("^") && !versionSpec.startsWith("~");
-    if (isExact || !isCompatible && options.allowMajor) {
-      isCompatible = true;
-    }
-    return {
-      package: packageName,
-      currentVersion: cleanCurrent,
-      latestVersion: latest,
-      updated: latest !== cleanCurrent && isCompatible,
-      semverCompatible: isCompatible,
-      location: Array.from(locations).join(", ")
-    };
-  } catch (error) {
-    return {
-      package: packageName,
-      currentVersion: versionSpec,
-      latestVersion: versionSpec,
-      updated: false,
-      error: error instanceof Error ? error.message : String(error),
-      semverCompatible: false,
-      location: Array.from(locations).join(", ")
-    };
-  }
-}
-export function prepareDependenciesForUpdate(allDepsMap, args) {
-  const depsToUpdate = Object.keys(allDepsMap);
-  let filteredDeps = [];
-  if (args.name && args.name.length > 0) {
-    const namePatterns = args.name;
-    filteredDeps = depsToUpdate.filter((dep) => {
-      return namePatterns.some((pattern) => {
-        if (pattern.includes("*") || pattern.includes("?") || pattern.includes("[") || pattern.includes("{")) {
-          return rematch(pattern, dep);
-        }
-        return dep === pattern;
-      });
-    });
-    const exactMatches = filteredDeps.filter((dep) => namePatterns.includes(dep));
-    const patternMatches = filteredDeps.length - exactMatches.length;
-    if (patternMatches > 0) {
-      relinka(
-        "verbose",
-        `Found ${exactMatches.length} exact matches and ${patternMatches} pattern matches`
-      );
-    }
-    if (filteredDeps.length === 0) {
-      relinka("warn", `No dependencies found matching patterns: ${namePatterns.join(", ")}`);
-    }
-  } else {
-    const ignoreList = args.ignore || [];
-    filteredDeps = depsToUpdate.filter((dep) => {
-      return !ignoreList.some((ignorePattern) => {
-        if (ignorePattern.includes("*") || ignorePattern.includes("?") || ignorePattern.includes("[") || ignorePattern.includes("{")) {
-          return rematch(ignorePattern, dep);
-        }
-        return dep === ignorePattern;
-      });
-    });
-    const ignoredCount = depsToUpdate.length - filteredDeps.length;
-    if (ignoredCount > 0 && ignoreList.length > 0) {
-      relinka("verbose", `Ignored ${ignoredCount} dependencies matching ignore patterns`);
-    }
-  }
-  const ignoreFields = args.ignoreFields || [];
-  if (ignoreFields.length > 0) {
-    filteredDeps = filteredDeps.filter((dep) => {
-      const locations = allDepsMap[dep]?.locations || /* @__PURE__ */ new Set();
-      return !Array.from(locations).some((location) => ignoreFields.includes(location));
-    });
-    const ignoredFieldsCount = depsToUpdate.length - filteredDeps.length;
-    if (ignoredFieldsCount > 0) {
-      relinka(
-        "verbose",
-        `Ignored ${ignoredFieldsCount} dependencies in ignored fields: ${ignoreFields.join(", ")}`
-      );
-    }
-  }
-  return filteredDeps.filter((dep) => {
-    const versionSpec = allDepsMap[dep]?.versionSpec ?? "";
-    if (!versionSpec) return false;
-    if (isNonSemverSpecifier(versionSpec)) return false;
-    return true;
-  });
-}
-export async function updatePackageJsonFile(packageJsonPath, dependencies, updatesToApply, savePrefix, fieldsToIgnore = []) {
-  if (updatesToApply.length === 0) return 0;
-  try {
-    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
-    const updatedPackageJson = { ...packageJson };
-    for (const update of updatesToApply) {
-      const depInfo = dependencies[update.package];
-      if (!depInfo) continue;
-      const locations = depInfo.locations || /* @__PURE__ */ new Set();
-      const shouldIgnore = Array.from(locations).some(
-        (location) => fieldsToIgnore.includes(location)
-      );
-      if (shouldIgnore) {
-        continue;
-      }
-      let newVersion;
-      if (locations.has("peerDependencies")) {
-        const currentVersion = dependencies[update.package]?.versionSpec || "";
-        if (currentVersion.startsWith(">=")) {
-          newVersion = `>=${update.latestVersion}`;
-        } else {
-          newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
-        }
-      } else {
-        newVersion = savePrefix === "none" ? update.latestVersion : `${savePrefix}${update.latestVersion}`;
-      }
-      applyVersionUpdate(updatedPackageJson, update.package, newVersion, locations);
-    }
-    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
-    return updatesToApply.length;
-  } catch (error) {
-    relinka(
-      "warn",
-      `Failed to update ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return 0;
-  }
-}
-export function displayStructuredUpdateResults(results, packageJsonFiles, fileDepsMap, showDetails = false) {
-  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);
-  if (errors.length > 0) {
-    relinka("warn", `Failed to check ${errors.length} dependencies:`);
-    for (const error of errors) {
-      relinka("warn", `  ${error.package} (${error.location}): ${error.error}`);
-    }
-    relinka("log", "");
-  }
-  if (!showDetails) {
-    if (toUpdate.length === 0) {
-      relinka("log", `All ${upToDate.length} dependencies are already up to date`);
-    } else {
-      relinka(
-        "log",
-        `${toUpdate.length} dependencies can be updated across ${packageJsonFiles.length} package.json files`
-      );
-    }
-    return;
-  }
-  const resultsByFile = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    let filePath = "unknown";
-    for (const [pkgPath, deps] of fileDepsMap.entries()) {
-      if (deps[result.package]) {
-        filePath = pkgPath;
-        break;
-      }
-    }
-    if (!resultsByFile.has(filePath)) {
-      resultsByFile.set(filePath, []);
-    }
-    const fileResults = resultsByFile.get(filePath);
-    if (fileResults) {
-      fileResults.push(result);
-    }
-  }
-  for (const [filePath, fileResults] of resultsByFile.entries()) {
-    const relativePath = filePath !== "unknown" ? path.relative(process.cwd(), filePath) : "unknown";
-    relinka("info", `${relativePath}`);
-    const byCategory = /* @__PURE__ */ new Map();
-    for (const result of fileResults) {
-      const category = result.location || "unknown";
-      if (!byCategory.has(category)) {
-        byCategory.set(category, []);
-      }
-      byCategory.get(category).push(result);
-    }
-    const upToDateInFile = fileResults.filter((r) => !r.updated && !r.error && r.semverCompatible);
-    if (upToDateInFile.length > 0) {
-      relinka("log", `  * ${upToDateInFile.length} deps are already up to date`);
-    }
-    const toUpdateInFile = fileResults.filter((r) => r.updated && !r.error);
-    if (toUpdateInFile.length > 0) {
-      relinka("log", `  * ${toUpdateInFile.length} deps can be updated:`);
-      const sortedCategories = Array.from(byCategory.entries()).sort(([a], [b]) => {
-        const order = {
-          catalog: 0,
-          dependencies: 1,
-          devDependencies: 2,
-          peerDependencies: 3,
-          optionalDependencies: 4
-        };
-        const aOrder = order[a] ?? 999;
-        const bOrder = order[b] ?? 999;
-        return aOrder - bOrder;
-      });
-      for (const [category, updates] of sortedCategories) {
-        const categoryUpdates = updates.filter((r) => r.updated && !r.error);
-        if (categoryUpdates.length > 0) {
-          let displayCategory = category;
-          if (category.startsWith("catalogs.")) {
-            displayCategory = `workspaces.${category}`;
-          } else if (category === "catalog") {
-            displayCategory = "workspaces.catalog";
-          }
-          relinka("log", `    - ${displayCategory}:`);
-          for (const update of categoryUpdates) {
-            relinka(
-              "log",
-              `      ${update.package}: ${update.currentVersion} \u2192 ${update.latestVersion}`
-            );
-          }
-        }
-      }
-    }
-    const errorsInFile = fileResults.filter((r) => r.error);
-    if (errorsInFile.length > 0) {
-      relinka("warn", `  * ${errorsInFile.length} deps failed to check:`);
-      for (const error of errorsInFile) {
-        relinka("warn", `    ${error.package}: ${error.error}`);
-      }
-    }
-    relinka("log", "");
-  }
-  if (toUpdate.length === 0) {
-    relinka("log", `All ${upToDate.length} dependencies are already up to date`);
-  } else {
-    relinka(
-      "success",
-      `Summary: ${toUpdate.length} dependencies can be updated across ${packageJsonFiles.length} package.json files`
-    );
-  }
-}
-export async function runInstallCommand(packageManager) {
-  try {
-    switch (packageManager.name) {
-      case "bun":
-        await $`bun install`;
-        break;
-      case "npm":
-        await $`npm install`;
-        break;
-      case "yarn":
-        await $`yarn install`;
-        break;
-      case "pnpm":
-        await $`pnpm install`;
-        break;
-      default:
-        throw new Error(`Unsupported package manager: ${packageManager.name}`);
-    }
-  } catch (error) {
-    relinka("warn", `Failed to run install command for ${packageManager.name}: ${error}`);
-    throw error;
-  }
-}
-export 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 };
-}

package/bin/impl/upload/providers/providers-mod.d.ts

@@ -1,20 +0,0 @@
-import type { Buffer } from "buffer";
-export interface UploadFile {
-    name: string;
-    data: Buffer;
-    type: string;
-}
-export interface UploadResult {
-    url: string;
-    size: number;
-    name: string;
-    uuid?: string;
-    key?: string;
-}
-export declare function uploadToProvider(files: UploadFile[], provider?: string): Promise<UploadResult[]>;
-export declare function getMimeType(filePath: string): string;
-export declare function readFilesFromPaths(filePaths: string[]): Promise<{
-    name: string;
-    data: any;
-    type: string;
-}[]>;