@reliverse/dler 1.7.139 → 1.7.141

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

@@ -1,5 +1,5 @@
 export declare const PROJECT_ROOT: string;
-export declare const cliVersion = "1.7.139";
+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.139";
+const version = "1.7.141";
 export const cliVersion = version;
 export const cliName = "@reliverse/rse";
 export const rseName = "@reliverse/rse";

package/bin/impl/config/prepare.js

@@ -230,7 +230,7 @@ function generateJsoncConfig(isDev, pkgDescription) {
   "bumpSet": "${DEFAULT_CONFIG_RELIVERSE.bumpSet}",
   // Common configuration
   "commonPubPause": ${pausePublishValue},
-  "commonPubRegistry": ${DEFAULT_CONFIG_RELIVERSE.commonPubRegistry},
+  "commonPubRegistry": "npm",
   "commonVerbose": ${verboseValue},
   "displayBuildPubLogs": ${DEFAULT_CONFIG_RELIVERSE.displayBuildPubLogs},
   // Core configuration
@@ -551,7 +551,7 @@ function generateConfig(isDev, pkgDescription, configKind = "ts", usePackageImpo
     "",
     "  // Common configuration",
     "  commonPubPause: " + pausePublishValue + ",",
-    "  commonPubRegistry: " + DEFAULT_CONFIG_RELIVERSE.commonPubRegistry + ",",
+    `  commonPubRegistry: "npm",`,
     "  commonVerbose: " + verboseValue + ",",
     "  displayBuildPubLogs: " + DEFAULT_CONFIG_RELIVERSE.displayBuildPubLogs + ",",
     "",

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

@@ -10,18 +10,18 @@ export type Database = z.infer<typeof DatabaseSchema>;
 export declare const ORMSchema: z.ZodEnum<{
     none: "none";
     drizzle: "drizzle";
-    prisma: "prisma";
     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<{
@@ -56,8 +56,8 @@ export declare const AddonsSchema: z.ZodEnum<{
 export type Addons = z.infer<typeof AddonsSchema>;
 export declare const ExamplesSchema: z.ZodEnum<{
     none: "none";
-    todo: "todo";
     ai: "ai";
+    todo: "todo";
 }>;
 export type Examples = z.infer<typeof ExamplesSchema>;
 export declare const PackageManagerSchema: z.ZodEnum<{

package/bin/impl/providers/reliverse-stack/rs-impl.d.ts

@@ -14,7 +14,7 @@ export type BrowserRepoOption = "reliverse/template-browser-extension" | "unknow
 export declare function configureBrowserExtension(): Promise<{
     displayName: string;
     description: string;
-    features: ("commands" | "webview" | "language" | "themes")[];
+    features: ("webview" | "language" | "commands" | "themes")[];
     activation: "onCommand" | "onLanguage" | "startup";
     publisher: string;
 }>;
@@ -24,7 +24,7 @@ export declare function configureBrowserExtension(): Promise<{
 export declare function configureVSCodeExtension(): Promise<{
     displayName: string;
     description: string;
-    features: ("commands" | "webview" | "language" | "themes")[];
+    features: ("webview" | "language" | "commands" | "themes")[];
     activation: "onCommand" | "onLanguage" | "startup";
     publisher: string;
 }>;

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

@@ -1,43 +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<{
+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 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 updateAllPackageJsonFiles(packageJsonFiles: string[], toUpdate: UpdateResult[], savePrefix: string): Promise<number>;
+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,38 +19,68 @@ 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";
+export async function prepareAllUpdateCandidates(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");
+    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);
+      const candidates2 = prepareDependenciesForUpdate(map, args);
+      for (const [dep, info] of Object.entries(map)) {
+        if (!allDepsMap[dep]) {
+          allDepsMap[dep] = { ...info, locations: new Set(info.locations) };
+        } else {
+          for (const location of info.locations) {
+            allDepsMap[dep].locations.add(location);
+          }
+          allDepsMap[dep].versionSpec = info.versionSpec;
+        }
+      }
+      for (const candidate of candidates2) {
+        allCandidates.add(candidate);
+      }
+    } catch (error) {
+      relinka(
+        "warn",
+        `Failed to process ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
-  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);
+  const candidates = Array.from(allCandidates);
   if (candidates.length === 0) {
-    relinka("warn", "No dependencies to update based on provided filters");
-    return { candidates: [], allDepsMap };
+    relinka("warn", "No dependencies to update");
+    return { candidates: [], allDepsMap: {}, packageJsonFiles };
   }
-  return { candidates, allDepsMap };
+  relinka("verbose", `Processing ${packageJsonFiles.length} package.json files`);
+  return { candidates, allDepsMap, 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(
@@ -137,225 +103,49 @@ 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)`;
+export async function updateAllPackageJsonFiles(packageJsonFiles, toUpdate, savePrefix) {
+  if (packageJsonFiles.length === 0 || toUpdate.length === 0) {
+    return 0;
+  }
+  let totalUpdated = 0;
+  for (const packageJsonPath of packageJsonFiles) {
+    try {
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+      const { map: fileDepsMap } = collectTargetDependencies(packageJson);
+      const fileSpecificUpdates = toUpdate.filter((update) => fileDepsMap[update.package]);
+      if (fileSpecificUpdates.length > 0) {
+        const updated = await updatePackageJsonFile(
+          packageJsonPath,
+          fileDepsMap,
+          fileSpecificUpdates,
+          savePrefix
+        );
+        totalUpdated += updated;
+        if (updated > 0) {
+          const relativePath = path.relative(process.cwd(), packageJsonPath);
+          relinka("verbose", `Updated ${updated} dependencies in ${relativePath}`);
         }
-        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 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`);
+      }
+    } catch (error) {
+      relinka(
+        "warn",
+        `Failed to process ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
+  return totalUpdated;
 }
-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!");
-}