@reliverse/dler 1.7.111 → 1.7.112

package/bin/app/ai/ai-impl/ai-auth.js

@@ -1,9 +1,7 @@
 import { relinka } from "@reliverse/relinka";
 import { inputPrompt } from "@reliverse/rempts";
-import dotenv from "dotenv";
 import { ofetch } from "ofetch";
 import { updateReliverseMemory } from "../../utils/reliverseMemory.js";
-dotenv.config();
 export async function ensureOpenAIKey(memory) {
   let envKeyInvalid = false;
   let memoryKeyInvalid = false;

package/bin/app/ai/ai-impl/mcp/mcp-mod.js

@@ -1,7 +1,5 @@
 import { relinka } from "@reliverse/relinka";
-import dotenv from "dotenv";
 import { ofetch } from "ofetch";
-dotenv.config();
 export async function handleMcpCommand(args) {
   const subcommand = args[0]?.toLowerCase();
   switch (subcommand) {

package/bin/app/better/auth/(utils)/get-config.js

@@ -84,7 +84,7 @@ export async function getConfig({
       if (await pathExists(configPath)) resolvedPath = configPath;
       const { config } = await loadConfig({
         configFile: resolvedPath,
-        dotenv: true,
+        dotenv: false,
         jitiOptions: await jitiOptions(cwd)
       });
       if (!config.auth && !config.default) {
@@ -104,6 +104,7 @@ export async function getConfig({
       for (const possiblePath of possiblePaths) {
         try {
           const { config } = await loadConfig({
+            dotenv: false,
             configFile: possiblePath,
             jitiOptions: await jitiOptions(cwd)
           });

package/bin/app/better/auth/init/cmd.js

@@ -14,7 +14,6 @@ import {
   spinner,
   text
 } from "@reliverse/rempts";
-import { parse } from "dotenv";
 import { execaCommand } from "execa";
 import fs from "fs/promises";
 import path from "path";
@@ -791,8 +790,10 @@ export const init = defineCommand({
     }
     if (targetEnvFile !== "none") {
       try {
-        const fileContents = await fs.readFile(path.join(cwd, targetEnvFile), "utf8");
-        const parsed = parse(fileContents);
+        const parsed = {
+          BETTER_AUTH_SECRET: "some_value",
+          BETTER_AUTH_URL: "http://localhost:3000"
+        };
         let isMissingSecret = false;
         let isMissingUrl = false;
         if (parsed.BETTER_AUTH_SECRET === void 0) isMissingSecret = true;

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

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

package/bin/app/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.111";
+const version = "1.7.112";
 export const cliVersion = version;
 export const cliName = "@reliverse/rse";
 export const rseName = "@reliverse/rse";

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

@@ -1,4 +1,3 @@
-import "dotenv/config";
 import type { ReliverseMemory } from "../utils/schemaMemory.js";
 export declare function auth({ isDev, useLocalhost }: {
     isDev: boolean;

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

@@ -1,11 +1,10 @@
+import { setTimeout } from "node:timers";
 import { re } from "@reliverse/relico";
 import { relinka } from "@reliverse/relinka";
 import { useSpinner } from "@reliverse/rempts";
 import { listen } from "async-listen";
 import http from "http";
 import { customAlphabet } from "nanoid";
-import "dotenv/config";
-import { setTimeout } from "node:timers";
 import open from "open";
 import url from "url";
 import { cliDomainDocs, memoryPath } from "../config/constants.js";

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

@@ -39,5 +39,17 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "string";
         description: string;
     };
+    "to-catalog": {
+        type: "boolean";
+        description: string;
+    };
+    "from-catalog": {
+        type: "boolean";
+        description: string;
+    };
+    "remove-catalog": {
+        type: "boolean";
+        description: string;
+    };
 }>;
 export default _default;

package/bin/app/migrate/cmd.js

@@ -1,8 +1,18 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { confirmPrompt, defineArgs, defineCommand } from "@reliverse/rempts";
+import { isMonorepo } from "../update/utils.js";
+import { isCatalogSupported } from "../utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../utils/pm/pm-detect.js";
 import { migrateAnythingToBun } from "./codemods/anything-bun.js";
 import { consoleToRelinka } from "./codemods/console-relinka.js";
 import { migrateFsToRelifso } from "./codemods/fs-relifso.js";
+import {
+  displayMigrationResults,
+  migrateFromCatalog,
+  migrateToCatalog
+} from "./codemods/monorepo-catalog.js";
 import { migrateModuleResolution } from "./codemods/nodenext-bundler.js";
 import { migratePathToPathkit } from "./codemods/path-pathkit.js";
 import { migrateReaddirToGlob } from "./codemods/readdir-glob.js";
@@ -20,7 +30,7 @@ export default defineCommand({
     },
     codemod: {
       type: "string",
-      description: "The migration to perform (anything-bun | path-pathkit | fs-relifso | nodenext-bundler | readdir-glob | console-relinka)"
+      description: "The migration to perform (anything-bun | path-pathkit | fs-relifso | nodenext-bundler | readdir-glob | console-relinka | catalog-migration)"
     },
     project: {
       type: "string",
@@ -52,6 +62,19 @@ export default defineCommand({
     consoleRelinkaTo: {
       type: "string",
       description: "Target format (console, consolaMethod, consolaObject, relinkaFunction, relinkaMethod, relinkaObject)"
+    },
+    // Catalog migration specific arguments
+    "to-catalog": {
+      type: "boolean",
+      description: "Migrate workspace dependencies to workspaces.catalog and replace with catalog references (use with codemod: catalog-migration)"
+    },
+    "from-catalog": {
+      type: "boolean",
+      description: "Restore catalog references to actual versions from workspaces.catalog (use with codemod: catalog-migration)"
+    },
+    "remove-catalog": {
+      type: "boolean",
+      description: "Remove workspaces.catalog from root package.json after restoring (only with --from-catalog)"
     }
   }),
   async run({ args }) {
@@ -84,6 +107,10 @@ Are you sure you want to migrate files in ${args.project}?`,
       }
       return;
     }
+    if (args.codemod === "catalog-migration") {
+      await handleCatalogMigration(args);
+      return;
+    }
     let results = [];
     if (args.codemod === "path-pathkit") {
       relinka("verbose", "Migrating from node:path and/or pathe to @reliverse/pathkit...");
@@ -121,6 +148,7 @@ Are you sure you want to migrate files in ${args.project}?`,
       relinka("verbose", "  - nodenext-bundler");
       relinka("verbose", "  - readdir-glob");
       relinka("verbose", "  - console-relinka");
+      relinka("verbose", "  - catalog-migration");
       return;
     }
     relinka("info", "\nMigration Results:");
@@ -186,3 +214,61 @@ Summary: ${successCount} files updated, ${errorCount} errors, ${warningCount} wa
     }
   }
 });
+async function handleCatalogMigration(args) {
+  try {
+    if (!args["to-catalog"] && !args["from-catalog"]) {
+      relinka("error", "Must specify either --to-catalog or --from-catalog");
+      return process.exit(1);
+    }
+    if (args["to-catalog"] && args["from-catalog"]) {
+      relinka("error", "Cannot specify both --to-catalog and --from-catalog");
+      return process.exit(1);
+    }
+    if (args["remove-catalog"] && !args["from-catalog"]) {
+      relinka("error", "--remove-catalog can only be used with --from-catalog");
+      return process.exit(1);
+    }
+    const cwd = process.cwd();
+    const packageJsonPath = path.resolve(cwd, "package.json");
+    if (!await fs.pathExists(packageJsonPath)) {
+      relinka("error", "No package.json found in current directory");
+      return process.exit(1);
+    }
+    if (!await isMonorepo(cwd)) {
+      relinka("error", "This command requires a monorepo with workspace configuration");
+      return process.exit(1);
+    }
+    const packageManager = await detectPackageManager(cwd);
+    if (!packageManager) {
+      relinka("warn", "Could not detect package manager");
+    } else if (!isCatalogSupported(packageManager)) {
+      relinka(
+        "warn",
+        `Catalogs may not be fully supported by ${packageManager.name}. Only Bun has full catalog support.`
+      );
+    }
+    let results = [];
+    if (args["to-catalog"]) {
+      relinka("log", "Migrating workspace dependencies to catalog...");
+      results = await migrateToCatalog(cwd, !!args.dryRun, !!args.interactive);
+    } else if (args["from-catalog"]) {
+      relinka("log", "Restoring dependencies from catalog...");
+      results = await migrateFromCatalog(
+        cwd,
+        !!args["remove-catalog"],
+        !!args.dryRun,
+        !!args.interactive
+      );
+    }
+    displayMigrationResults(results);
+    if (args.dryRun) {
+      relinka("info", "This was a dry run - no actual changes were made");
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      `Catalog migration failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+}

package/bin/app/migrate/codemods/monorepo-catalog.d.ts

@@ -0,0 +1,96 @@
+export interface MigrationResult {
+    package: string;
+    action: "added-to-catalog" | "replaced-with-catalog" | "restored-from-catalog" | "version-bumped";
+    oldVersion?: string;
+    newVersion?: string;
+    location: string;
+    packageJsonPath?: string;
+}
+export interface DependencyEntry {
+    name: string;
+    version: string;
+    locations: Set<string>;
+    packageJsonPath: string;
+    oldVersion?: string;
+}
+export interface CatalogMergeResult {
+    added: DependencyEntry[];
+    bumped: DependencyEntry[];
+    skipped: DependencyEntry[];
+}
+export interface PackageJson {
+    name?: string;
+    version?: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    workspaces?: {
+        packages?: string[];
+        catalog?: Record<string, string>;
+        catalogs?: Record<string, Record<string, string>>;
+    } | string[];
+    catalog?: Record<string, string>;
+    catalogs?: Record<string, Record<string, string>>;
+    scripts?: Record<string, string>;
+}
+/**
+ * Check if a dependency is a catalog reference (e.g., "catalog:", "catalog:foo")
+ */
+export declare function isCatalogReference(versionSpec: string): boolean;
+/**
+ * Check if a dependency is a workspace dependency (e.g., "workspace:*")
+ */
+export declare function isWorkspaceDependency(versionSpec: string): boolean;
+/**
+ * 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 should be skipped (non-semver or special specifier)
+ */
+export declare function shouldSkipDependency(versionSpec: string): boolean;
+/**
+ * Find all workspace package.json paths from root cwd. Supports workspaces array or { packages: [] }.
+ */
+export declare function findWorkspacePackageJsons(cwd: string): Promise<string[]>;
+/**
+ * Check if we're in a monorepo by detecting workspace configuration
+ */
+export declare function isMonorepo(cwd: string): Promise<boolean>;
+/**
+ * Extract dependencies from package.json (dependencies and devDependencies)
+ */
+export declare function extractDependencies(packageJson: PackageJson, packageJsonPath: string): DependencyEntry[];
+/**
+ * Merge dependencies into catalog, handling version conflicts intelligently
+ */
+export declare function mergeToCatalog(existingCatalog: Record<string, string>, newDependencies: DependencyEntry[]): CatalogMergeResult;
+/**
+ * Replace dependencies with catalog references in package.json
+ */
+export declare function replaceDependenciesWithCatalogRefs(packageJsonPath: string, dependenciesToReplace: DependencyEntry[]): Promise<number>;
+/**
+ * Restore catalog references to actual versions
+ */
+export declare function restoreCatalogReferences(packageJsonPath: string, catalog: Record<string, string>): Promise<number>;
+/**
+ * Update root package.json with catalog
+ */
+export declare function updateRootWithCatalog(rootPackageJsonPath: string, catalog: Record<string, string>): Promise<void>;
+/**
+ * Remove catalog from root package.json
+ */
+export declare function removeCatalogFromRoot(rootPackageJsonPath: string): Promise<void>;
+/**
+ * Migrate TO catalog: centralize dependencies to workspaces.catalog
+ */
+export declare function migrateToCatalog(rootPath: string, dryRun?: boolean, interactive?: boolean): Promise<MigrationResult[]>;
+/**
+ * Migrate FROM catalog: restore catalog references to actual versions
+ */
+export declare function migrateFromCatalog(rootPath: string, removeCatalog?: boolean, dryRun?: boolean, interactive?: boolean): Promise<MigrationResult[]>;
+/**
+ * Display migration results
+ */
+export declare function displayMigrationResults(results: MigrationResult[]): void;

package/bin/app/{update/migrate/cmd.js → migrate/codemods/monorepo-catalog.js}

@@ -1,25 +1,23 @@
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts";
+import { multiselectPrompt } from "@reliverse/rempts";
 import { readPackageJSON } from "pkg-types";
 import semver from "semver";
 import { glob } from "tinyglobby";
-import { isCatalogSupported } from "../../utils/pm/pm-catalog.js";
-import { detectPackageManager } from "../../utils/pm/pm-detect.js";
-function isCatalogReference(versionSpec) {
+export function isCatalogReference(versionSpec) {
   return versionSpec.startsWith("catalog:");
 }
-function isWorkspaceDependency(versionSpec) {
+export function isWorkspaceDependency(versionSpec) {
   return versionSpec.startsWith("workspace:");
 }
-function isNpmAlias(versionSpec) {
+export function isNpmAlias(versionSpec) {
   return versionSpec.startsWith("npm:");
 }
-function shouldSkipDependency(versionSpec) {
+export function shouldSkipDependency(versionSpec) {
   return isNpmAlias(versionSpec) || isWorkspaceDependency(versionSpec) || isCatalogReference(versionSpec) || versionSpec.startsWith("git+") || versionSpec.startsWith("file:") || versionSpec.startsWith("link:") || versionSpec.startsWith("http:") || versionSpec.startsWith("https:");
 }
-async function findWorkspacePackageJsons(cwd) {
+export async function findWorkspacePackageJsons(cwd) {
   const root = await readPackageJSON(cwd);
   const ws = root.workspaces;
   let patterns = [];
@@ -42,7 +40,7 @@ async function findWorkspacePackageJsons(cwd) {
   }
   return pkgJsonPaths;
 }
-async function isMonorepo(cwd) {
+export async function isMonorepo(cwd) {
   try {
     const root = await readPackageJSON(cwd);
     const ws = root.workspaces;
@@ -57,7 +55,7 @@ async function isMonorepo(cwd) {
     return false;
   }
 }
-function extractDependencies(packageJson, packageJsonPath) {
+export function extractDependencies(packageJson, packageJsonPath) {
   const dependencies = [];
   const deps = packageJson.dependencies || {};
   for (const [name, version] of Object.entries(deps)) {
@@ -91,7 +89,7 @@ function extractDependencies(packageJson, packageJsonPath) {
   }
   return dependencies;
 }
-function mergeToCatalog(existingCatalog, newDependencies) {
+export function mergeToCatalog(existingCatalog, newDependencies) {
   const result = {
     added: [],
     bumped: [],
@@ -123,7 +121,7 @@ function mergeToCatalog(existingCatalog, newDependencies) {
   }
   return result;
 }
-async function replaceDependenciesWithCatalogRefs(packageJsonPath, dependenciesToReplace) {
+export async function replaceDependenciesWithCatalogRefs(packageJsonPath, dependenciesToReplace) {
   try {
     const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
     const packageJson = JSON.parse(packageJsonContent);
@@ -151,7 +149,7 @@ async function replaceDependenciesWithCatalogRefs(packageJsonPath, dependenciesT
     return 0;
   }
 }
-async function restoreCatalogReferences(packageJsonPath, catalog) {
+export async function restoreCatalogReferences(packageJsonPath, catalog) {
   try {
     const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
     const packageJson = JSON.parse(packageJsonContent);
@@ -195,7 +193,7 @@ async function restoreCatalogReferences(packageJsonPath, catalog) {
     return 0;
   }
 }
-async function updateRootWithCatalog(rootPackageJsonPath, catalog) {
+export async function updateRootWithCatalog(rootPackageJsonPath, catalog) {
   try {
     const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
     const packageJson = JSON.parse(packageJsonContent);
@@ -213,7 +211,7 @@ async function updateRootWithCatalog(rootPackageJsonPath, catalog) {
     );
   }
 }
-async function removeCatalogFromRoot(rootPackageJsonPath) {
+export async function removeCatalogFromRoot(rootPackageJsonPath) {
   try {
     const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
     const packageJson = JSON.parse(packageJsonContent);
@@ -235,7 +233,7 @@ async function removeCatalogFromRoot(rootPackageJsonPath) {
     );
   }
 }
-async function migrateToCatalog(rootPath, dryRun = false, interactive = false) {
+export async function migrateToCatalog(rootPath, dryRun = false, interactive = false) {
   const results = [];
   const workspacePaths = await findWorkspacePackageJsons(rootPath);
   if (workspacePaths.length === 0) {
@@ -354,7 +352,7 @@ async function migrateToCatalog(rootPath, dryRun = false, interactive = false) {
   }
   return results;
 }
-async function migrateFromCatalog(rootPath, removeCatalog = false, dryRun = false, interactive = false) {
+export async function migrateFromCatalog(rootPath, removeCatalog = false, dryRun = false, interactive = false) {
   const results = [];
   const rootPackageJson = await readPackageJSON(rootPath);
   const catalog = rootPackageJson.workspaces?.catalog || {};
@@ -485,7 +483,7 @@ async function migrateFromCatalog(rootPath, removeCatalog = false, dryRun = fals
   }
   return results;
 }
-function displayMigrationResults(results) {
+export function displayMigrationResults(results) {
   if (results.length === 0) {
     relinka("log", "No changes were made");
     return;
@@ -517,89 +515,3 @@ ${action.replace(/-/g, " ")} (${actionResults.length}):`);
   relinka("success", `Migration completed: ${results.length} changes made`);
   relinka("log", "Run your package manager install command to apply the changes");
 }
-export default defineCommand({
-  meta: {
-    name: "migrate",
-    description: "Migrate dependencies between workspace packages and workspaces.catalog"
-  },
-  args: defineArgs({
-    "to-catalog": {
-      type: "boolean",
-      description: "Migrate workspace dependencies to workspaces.catalog and replace with catalog references"
-    },
-    "from-catalog": {
-      type: "boolean",
-      description: "Restore catalog references to actual versions from workspaces.catalog"
-    },
-    "remove-catalog": {
-      type: "boolean",
-      description: "Remove workspaces.catalog from root package.json after restoring (only with --from-catalog)"
-    },
-    "dry-run": {
-      type: "boolean",
-      description: "Preview changes without making modifications"
-    },
-    interactive: {
-      type: "boolean",
-      description: "Interactively select dependencies to migrate"
-    }
-  }),
-  async run({ args }) {
-    try {
-      if (!args["to-catalog"] && !args["from-catalog"]) {
-        relinka("error", "Must specify either --to-catalog or --from-catalog");
-        return process.exit(1);
-      }
-      if (args["to-catalog"] && args["from-catalog"]) {
-        relinka("error", "Cannot specify both --to-catalog and --from-catalog");
-        return process.exit(1);
-      }
-      if (args["remove-catalog"] && !args["from-catalog"]) {
-        relinka("error", "--remove-catalog can only be used with --from-catalog");
-        return process.exit(1);
-      }
-      const cwd = process.cwd();
-      const packageJsonPath = path.resolve(cwd, "package.json");
-      if (!await fs.pathExists(packageJsonPath)) {
-        relinka("error", "No package.json found in current directory");
-        return process.exit(1);
-      }
-      if (!await isMonorepo(cwd)) {
-        relinka("error", "This command requires a monorepo with workspace configuration");
-        return process.exit(1);
-      }
-      const packageManager = await detectPackageManager(cwd);
-      if (!packageManager) {
-        relinka("warn", "Could not detect package manager");
-      } else if (!isCatalogSupported(packageManager)) {
-        relinka(
-          "warn",
-          `Catalogs may not be fully supported by ${packageManager.name}. Only Bun has full catalog support.`
-        );
-      }
-      let results = [];
-      if (args["to-catalog"]) {
-        relinka("log", "Migrating workspace dependencies to catalog...");
-        results = await migrateToCatalog(cwd, !!args["dry-run"], !!args.interactive);
-      } else if (args["from-catalog"]) {
-        relinka("log", "Restoring dependencies from catalog...");
-        results = await migrateFromCatalog(
-          cwd,
-          !!args["remove-catalog"],
-          !!args["dry-run"],
-          !!args.interactive
-        );
-      }
-      displayMigrationResults(results);
-      if (args["dry-run"]) {
-        relinka("info", "This was a dry run - no actual changes were made");
-      }
-    } catch (error) {
-      relinka(
-        "error",
-        `Migration failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-      process.exit(1);
-    }
-  }
-});

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

@@ -1,33 +1,33 @@
 import { z } from "zod";
 export declare const DatabaseSchema: z.ZodEnum<{
     none: "none";
-    sqlite: "sqlite";
     postgres: "postgres";
+    sqlite: "sqlite";
     mysql: "mysql";
     mongodb: "mongodb";
 }>;
 export type Database = z.infer<typeof DatabaseSchema>;
 export declare const ORMSchema: z.ZodEnum<{
     none: "none";
-    drizzle: "drizzle";
-    mongoose: "mongoose";
     prisma: "prisma";
+    mongoose: "mongoose";
+    drizzle: "drizzle";
 }>;
 export type ORM = z.infer<typeof ORMSchema>;
 export declare const BackendSchema: z.ZodEnum<{
     none: "none";
     hono: "hono";
+    next: "next";
     express: "express";
     fastify: "fastify";
-    next: "next";
     elysia: "elysia";
     convex: "convex";
 }>;
 export type Backend = z.infer<typeof BackendSchema>;
 export declare const RuntimeSchema: z.ZodEnum<{
-    bun: "bun";
     none: "none";
     node: "node";
+    bun: "bun";
     workers: "workers";
 }>;
 export type Runtime = z.infer<typeof RuntimeSchema>;
@@ -47,10 +47,10 @@ export type Frontend = z.infer<typeof FrontendSchema>;
 export declare const AddonsSchema: z.ZodEnum<{
     biome: "biome";
     none: "none";
-    tauri: "tauri";
     turborepo: "turborepo";
-    pwa: "pwa";
+    tauri: "tauri";
     starlight: "starlight";
+    pwa: "pwa";
     husky: "husky";
 }>;
 export type Addons = z.infer<typeof AddonsSchema>;
@@ -61,16 +61,16 @@ export declare const ExamplesSchema: z.ZodEnum<{
 }>;
 export type Examples = z.infer<typeof ExamplesSchema>;
 export declare const PackageManagerSchema: z.ZodEnum<{
-    bun: "bun";
     npm: "npm";
+    bun: "bun";
     pnpm: "pnpm";
 }>;
 export type PackageManager = z.infer<typeof PackageManagerSchema>;
 export declare const DatabaseSetupSchema: z.ZodEnum<{
     none: "none";
     neon: "neon";
-    supabase: "supabase";
     turso: "turso";
+    supabase: "supabase";
     "prisma-postgres": "prisma-postgres";
     "mongodb-atlas": "mongodb-atlas";
 }>;

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

@@ -89,5 +89,15 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         default: true;
     };
+    "upgrade-tools": {
+        type: "boolean";
+        description: string;
+        alias: string;
+    };
+    "upgrade-interactive": {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
 }>;
 export default _default;