@reliverse/dler 1.7.151 → 1.7.153

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

@@ -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<"bun" | "npm" | "yarn" | "pnpm">;
+export declare function getPackageManager(): Promise<"npm" | "yarn" | "pnpm" | "bun">;
 export declare function getEnvFiles(cwd: string): Promise<string[]>;
 export declare function updateEnvs({ envs, files, isCommented, }: {
     /**

package/bin/impl/build/impl.d.ts

@@ -1,11 +1,12 @@
 import type { ReliverseConfig } from "../schema/mod.js";
 import type { PerfTimer } from "../types/mod.js";
+import type { WorkspacePackage } from "../utils/workspace-utils.js";
 /**
  * Main entry point for the rse build process.
  * Handles building for both main project and libraries.
  * @see `src/impl/pub/impl.ts` for pub main function implementation.
  */
-export declare function dlerBuild({ flow, timer, isDev, config, debugOnlyCopyNonBuildFiles, debugDontCopyNonBuildFiles, disableOwnSpinner, }: {
+export declare function dlerBuild({ flow, timer, isDev, config, debugOnlyCopyNonBuildFiles, debugDontCopyNonBuildFiles, disableOwnSpinner, workspacePackages, enableCache, depsOnly, showGraph, cleanCacheFlag, }: {
     flow: "build" | "pub";
     timer: PerfTimer;
     isDev: boolean;
@@ -13,6 +14,11 @@ export declare function dlerBuild({ flow, timer, isDev, config, debugOnlyCopyNon
     debugOnlyCopyNonBuildFiles?: boolean;
     debugDontCopyNonBuildFiles?: boolean;
     disableOwnSpinner?: boolean;
+    workspacePackages?: WorkspacePackage[] | null;
+    enableCache?: boolean;
+    depsOnly?: boolean;
+    showGraph?: boolean;
+    cleanCacheFlag?: boolean;
 }): Promise<{
     timer: PerfTimer;
     effectiveConfig: any;

package/bin/impl/build/impl.js

@@ -9,6 +9,17 @@ import { PROJECT_ROOT } from "../config/constants.js";
 import { getConfigDler } from "../config/load.js";
 import { removeDistFolders } from "../utils/utils-clean.js";
 import { handleDlerError } from "../utils/utils-error-cwd.js";
+import { sortPackagesByDependencies } from "../utils/workspace-utils.js";
+import {
+  cachePackageOutput,
+  cleanCache,
+  DependencyGraph,
+  findMonorepo,
+  hashPackage,
+  isPackageCached,
+  readMonorepoPackageJson,
+  restorePackageCache
+} from "../../mod.js";
 import { createCompletionTexts } from "../utils/finish-text.js";
 import { dlerPostBuild, wrapper_CopyNonBuildFiles } from "./postbuild.js";
 import { dlerPreBuild } from "./prebuild.js";
@@ -19,7 +30,12 @@ export async function dlerBuild({
   config,
   debugOnlyCopyNonBuildFiles,
   debugDontCopyNonBuildFiles,
-  disableOwnSpinner
+  disableOwnSpinner,
+  workspacePackages,
+  enableCache,
+  depsOnly,
+  showGraph,
+  cleanCacheFlag
 }) {
   let effectiveConfig = config;
   let shouldShowSpinner = false;
@@ -28,6 +44,118 @@ export async function dlerBuild({
     if (!effectiveConfig) {
       effectiveConfig = await getConfigDler();
     }
+    let monorepo = null;
+    let dependencyGraph = null;
+    if (enableCache || depsOnly || showGraph || cleanCacheFlag) {
+      monorepo = await findMonorepo();
+      if (monorepo) {
+        relinka("verbose", `Monorepo detected at: ${monorepo.root}`);
+        if (cleanCacheFlag) {
+          await cleanCache(monorepo);
+          relinka("log", "\u2713 Cache cleaned");
+        }
+        const { globby } = await import("globby");
+        const packageJsonGlobs = monorepo.packageGlobs.map((glob) => `${glob}/package.json`);
+        const matches = await globby(packageJsonGlobs, { cwd: monorepo.root, absolute: true });
+        const packages = [];
+        for (const packageJsonPath of matches) {
+          const pkg = await readMonorepoPackageJson(packageJsonPath);
+          if (pkg) {
+            packages.push(pkg);
+          }
+        }
+        dependencyGraph = new DependencyGraph(packages);
+        if (showGraph) {
+          dependencyGraph.print();
+        }
+        if (depsOnly) {
+          const activePackage = dependencyGraph.findActivePackage();
+          if (activePackage) {
+            const dependencies = dependencyGraph.getPackageDependenciesBuildOrder(activePackage.name);
+            relinka("info", `Building dependencies for ${activePackage.name}: ${dependencies.map((p) => p.name).join(", ")}`);
+            for (const pkg of dependencies) {
+              await buildCachedPackage(pkg, monorepo, enableCache || false);
+            }
+            relinka("log", "\u2713 Dependencies built");
+            return;
+          } else {
+            relinka("warn", "Not in a package directory, cannot determine dependencies");
+          }
+        }
+      } else {
+        relinka("warn", "Monorepo features requested but no monorepo detected");
+      }
+    }
+    if (workspacePackages && workspacePackages.length > 0) {
+      relinka("info", `Building ${workspacePackages.length} workspace package(s)`);
+      relinka("verbose", `Workspace packages: ${workspacePackages.map((p) => p.name).join(", ")}`);
+      const sortedPackages = sortPackagesByDependencies(workspacePackages);
+      for (const pkg of sortedPackages) {
+        relinka("info", `Building package: ${pkg.name}`);
+        const packageConfig = {
+          ...effectiveConfig,
+          // Override package-specific settings
+          projectName: pkg.name,
+          projectAuthor: "reliverse",
+          projectDescription: "Dler plugin for code migration and modernization codemods",
+          projectLicense: "MIT",
+          coreEntrySrcDir: path.join(pkg.path, "src"),
+          // Assume src dir in package
+          coreEntryFile: "mod.ts",
+          // Default entry file for workspace packages
+          // Override dist directories to be package-specific
+          distNpmDirName: path.join("dist-workspace", pkg.name, "npm"),
+          distJsrDirName: path.join("dist-workspace", pkg.name, "jsr"),
+          libsDirDist: path.join("dist-workspace", pkg.name, "libs"),
+          // Ensure it's treated as a library, not CLI
+          coreIsCLI: { enabled: false, scripts: {} },
+          // Use ESM format for workspace packages
+          transpileFormat: "esm",
+          transpileTarget: "node",
+          // Keep readable for libraries
+          transpileMinify: false,
+          transpileSourcemap: "none",
+          // Use package-specific package.json
+          corePackageJsonPath: pkg.packageJsonPath
+        };
+        await regular_buildFlow(timer, isDev, packageConfig);
+        await library_buildFlow(timer, isDev, packageConfig);
+        await binary_buildFlow(timer, isDev, packageConfig);
+        const distPackageJsonPath = path.join(packageConfig.distNpmDirName, "package.json");
+        relinka("verbose", `Copying package.json from ${pkg.packageJsonPath} to ${distPackageJsonPath}`);
+        await fs.copy(pkg.packageJsonPath, distPackageJsonPath);
+        const packageJsonContent = await fs.readFile(distPackageJsonPath, "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        packageJson.main = "./bin/mod.js";
+        packageJson.types = "./bin/mod.d.ts";
+        packageJson.exports = {
+          ".": {
+            "types": "./bin/mod.d.ts",
+            "default": "./bin/mod.js"
+          }
+        };
+        packageJson.files = ["bin"];
+        packageJson.module = "./bin/mod.js";
+        packageJson.publishConfig = { access: "public" };
+        if (!packageJson.homepage) {
+          packageJson.homepage = "https://docs.reliverse.org/cli";
+        }
+        if (!packageJson.bugs) {
+          packageJson.bugs = {
+            email: "blefnk@gmail.com",
+            url: `https://github.com/reliverse/dler/issues`
+          };
+        }
+        if (!packageJson.devDependencies) {
+          packageJson.devDependencies = {};
+        }
+        await fs.writeFile(distPackageJsonPath, JSON.stringify(packageJson, null, 2));
+        relinka("verbose", `Updated package.json paths to point to bin directory`);
+        relinka("success", `Successfully built package: ${pkg.name}`);
+      }
+      relinka("success", `Successfully built all ${workspacePackages.length} workspace package(s)`);
+      relinka("info", "Building main project and libraries...");
+    }
     shouldShowSpinner = effectiveConfig.displayBuildPubLogs === false && !disableOwnSpinner;
     const buildSteps = [
       "Loading configuration",
@@ -102,3 +230,35 @@ export async function dlerBuild({
     handleDlerError(error);
   }
 }
+async function buildCachedPackage(pkg, monorepo, enableCache) {
+  if (!pkg.buildScript) {
+    relinka("log", `\u2713 ${pkg.name}: Nothing to build`);
+    return;
+  }
+  relinka("log", `\u25D0 ${pkg.name}: ${pkg.buildScript}`);
+  if (enableCache) {
+    const { packageHash } = await hashPackage(pkg);
+    if (await isPackageCached(monorepo, pkg, packageHash) && pkg.config.cache) {
+      await restorePackageCache(monorepo, pkg, packageHash);
+      relinka("log", `\u2713 ${pkg.name}: Cached!`);
+      return;
+    }
+    const { execaCommand } = await import("execa");
+    const args = [...monorepo.packageManager.runCmd, "build"];
+    await execaCommand(args.join(" "), {
+      cwd: pkg.dir,
+      env: { ...process.env, INSIDE_DLER: "true" }
+    });
+    if (pkg.config.cache) {
+      await cachePackageOutput(monorepo, pkg, packageHash);
+    }
+  } else {
+    const { execaCommand } = await import("execa");
+    const args = [...monorepo.packageManager.runCmd, "build"];
+    await execaCommand(args.join(" "), {
+      cwd: pkg.dir,
+      env: { ...process.env, INSIDE_DLER: "true" }
+    });
+  }
+  relinka("log", `\u2713 ${pkg.name}: Built`);
+}

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

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

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

@@ -56,14 +56,14 @@ export declare const AddonsSchema: z.ZodEnum<{
 export type Addons = z.infer<typeof AddonsSchema>;
 export declare const ExamplesSchema: z.ZodEnum<{
     none: "none";
-    ai: "ai";
     todo: "todo";
+    ai: "ai";
 }>;
 export type Examples = z.infer<typeof ExamplesSchema>;
 export declare const PackageManagerSchema: z.ZodEnum<{
-    bun: "bun";
     npm: "npm";
     pnpm: "pnpm";
+    bun: "bun";
 }>;
 export type PackageManager = z.infer<typeof PackageManagerSchema>;
 export declare const DatabaseSetupSchema: z.ZodEnum<{

package/bin/impl/pub/impl.d.ts

@@ -1,8 +1,13 @@
 import type { ReliverseConfig } from "../schema/mod.js";
 import type { PerfTimer } from "../types/mod.js";
+import type { WorkspacePackage } from "../utils/workspace-utils.js";
 /**
  * Main entry point for the rse build and publish process.
  * Handles building and publishing for both main project and libraries.
  * @see `src/impl/build/impl.ts` for build main function implementation.
  */
-export declare function dlerPub(timer: PerfTimer, isDev: boolean, config?: ReliverseConfig): Promise<void>;
+export declare function dlerPub(timer: PerfTimer, isDev: boolean, config?: ReliverseConfig, workspacePackages?: WorkspacePackage[] | null, options?: {
+    enableCache?: boolean;
+    showGraph?: boolean;
+    cleanCacheFlag?: boolean;
+}): Promise<void>;

package/bin/impl/pub/impl.js

@@ -1,4 +1,6 @@
 import { bumpHandler, isBumpDisabled, setBumpDisabledValueTo } from "@reliverse/bleump";
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { createMultiStepSpinner } from "@reliverse/rempts";
 import { dlerBuild } from "../build/impl.js";
@@ -7,8 +9,52 @@ import { regular_pubFlow } from "../build/regular-flow.js";
 import { getConfigDler } from "../config/load.js";
 import { finalizeBuild, finalizePub } from "../utils/finalize.js";
 import { handleDlerError } from "../utils/utils-error-cwd.js";
+import { sortPackagesByDependencies } from "../utils/workspace-utils.js";
+import {
+  cleanCache,
+  DependencyGraph,
+  findMonorepo,
+  readMonorepoPackageJson
+} from "../../mod.js";
 import { createCompletionTexts } from "../utils/finish-text.js";
-export async function dlerPub(timer, isDev, config) {
+async function bumpWorkspacePackages(workspacePackages, rootVersion, bumpMode) {
+  if (!workspacePackages || workspacePackages.length === 0) {
+    return;
+  }
+  relinka("verbose", `Checking workspace packages for version bumping (root version: ${rootVersion})`);
+  for (const pkg of workspacePackages) {
+    try {
+      const packageJsonContent = await fs.readFile(pkg.packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageJsonContent);
+      if (packageJson.version === rootVersion) {
+        relinka("info", `Bumping version for workspace package: ${pkg.name} (${packageJson.version} -> ${getNextVersion(packageJson.version, bumpMode)})`);
+        packageJson.version = getNextVersion(packageJson.version, bumpMode);
+        await fs.writeFile(pkg.packageJsonPath, JSON.stringify(packageJson, null, 2));
+        relinka("success", `Successfully bumped ${pkg.name} to version ${packageJson.version}`);
+      } else {
+        relinka("verbose", `Skipping ${pkg.name} (version ${packageJson.version} doesn't match root version ${rootVersion})`);
+      }
+    } catch (error) {
+      relinka("warn", `Failed to bump version for ${pkg.name}: ${error}`);
+    }
+  }
+}
+function getNextVersion(currentVersion, bumpMode) {
+  const parts = currentVersion.split(".").map(Number);
+  const major = parts[0] || 0;
+  const minor = parts[1] || 0;
+  const patch = parts[2] || 0;
+  switch (bumpMode) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+    default:
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+export async function dlerPub(timer, isDev, config, workspacePackages, options) {
   let effectiveConfig = config;
   let shouldShowSpinner = false;
   let multiStepSpinner = null;
@@ -16,6 +62,124 @@ export async function dlerPub(timer, isDev, config) {
     if (!effectiveConfig) {
       effectiveConfig = await getConfigDler();
     }
+    let monorepo = null;
+    let dependencyGraph = null;
+    if (options?.enableCache || options?.showGraph || options?.cleanCacheFlag) {
+      monorepo = await findMonorepo();
+      if (monorepo) {
+        relinka("verbose", `Monorepo detected at: ${monorepo.root}`);
+        if (options.cleanCacheFlag) {
+          await cleanCache(monorepo);
+          relinka("log", "\u2713 Cache cleaned");
+        }
+        const { globby } = await import("globby");
+        const packageJsonGlobs = monorepo.packageGlobs.map((glob) => `${glob}/package.json`);
+        const matches = await globby(packageJsonGlobs, { cwd: monorepo.root, absolute: true });
+        const packages = [];
+        for (const packageJsonPath of matches) {
+          const pkg = await readMonorepoPackageJson(packageJsonPath);
+          if (pkg) {
+            packages.push(pkg);
+          }
+        }
+        dependencyGraph = new DependencyGraph(packages);
+        if (options.showGraph) {
+          dependencyGraph.print();
+        }
+      } else {
+        relinka("warn", "Monorepo features requested but no monorepo detected");
+      }
+    }
+    if (workspacePackages && workspacePackages.length > 0) {
+      relinka("info", `Publishing ${workspacePackages.length} workspace package(s)`);
+      const sortedPackages = sortPackagesByDependencies(workspacePackages);
+      for (const pkg of sortedPackages) {
+        relinka("info", `Processing package: ${pkg.name}`);
+        const packageConfig = {
+          ...effectiveConfig,
+          // Override package-specific settings
+          projectName: pkg.name,
+          projectAuthor: "reliverse",
+          projectDescription: "Dler plugin for code migration and modernization codemods",
+          projectLicense: "MIT",
+          coreEntrySrcDir: path.join(pkg.path, "src"),
+          // Assume src dir in package
+          coreEntryFile: "mod.ts",
+          // Default entry file for workspace packages
+          // Override dist directories to be package-specific
+          distNpmDirName: path.join("dist-workspace", pkg.name, "npm"),
+          distJsrDirName: path.join("dist-workspace", pkg.name, "jsr"),
+          libsDirDist: path.join("dist-workspace", pkg.name, "libs"),
+          // Ensure it's treated as a library, not CLI
+          coreIsCLI: { enabled: false, scripts: {} },
+          // Use ESM format for workspace packages
+          transpileFormat: "esm",
+          transpileTarget: "node",
+          // Keep readable for libraries
+          transpileMinify: false,
+          transpileSourcemap: "none",
+          // Use package-specific package.json
+          corePackageJsonPath: pkg.packageJsonPath
+        };
+        await dlerBuild({
+          flow: "pub",
+          timer,
+          isDev,
+          config: packageConfig,
+          debugOnlyCopyNonBuildFiles: false,
+          debugDontCopyNonBuildFiles: false,
+          disableOwnSpinner: true,
+          enableCache: options?.enableCache,
+          showGraph: false,
+          // Already shown above if requested
+          cleanCacheFlag: false
+          // Already cleaned above if requested
+        });
+        const distPackageJsonPath = path.join(packageConfig.distNpmDirName, "package.json");
+        relinka(
+          "verbose",
+          `Copying package.json from ${pkg.packageJsonPath} to ${distPackageJsonPath}`
+        );
+        await fs.copy(pkg.packageJsonPath, distPackageJsonPath);
+        const packageJsonContent = await fs.readFile(distPackageJsonPath, "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        packageJson.main = "./bin/mod.js";
+        packageJson.types = "./bin/mod.d.ts";
+        packageJson.exports = {
+          ".": {
+            types: "./bin/mod.d.ts",
+            default: "./bin/mod.js"
+          }
+        };
+        packageJson.files = ["bin"];
+        packageJson.module = "./bin/mod.js";
+        packageJson.publishConfig = { access: "public" };
+        if (!packageJson.homepage) {
+          packageJson.homepage = "https://docs.reliverse.org/cli";
+        }
+        if (!packageJson.bugs) {
+          packageJson.bugs = {
+            email: "blefnk@gmail.com",
+            url: `https://github.com/reliverse/dler/issues`
+          };
+        }
+        if (!packageJson.devDependencies) {
+          packageJson.devDependencies = {};
+        }
+        await fs.writeFile(distPackageJsonPath, JSON.stringify(packageJson, null, 2));
+        relinka("verbose", `Updated package.json paths to point to bin directory`);
+        if (!effectiveConfig.commonPubPause) {
+          await regular_pubFlow(timer, isDev, packageConfig);
+          await library_pubFlow(timer, isDev, packageConfig);
+        }
+        relinka("success", `Successfully published package: ${pkg.name}`);
+      }
+      relinka(
+        "success",
+        `Successfully published all ${workspacePackages.length} workspace package(s)`
+      );
+      relinka("info", "Publishing main project and libraries...");
+    }
     shouldShowSpinner = effectiveConfig.displayBuildPubLogs === false;
     const pubSteps = effectiveConfig.commonPubPause ? ["Loading configuration", "Version bumping", "Building project", "Finalizing"] : [
       "Loading configuration",
@@ -29,6 +193,15 @@ export async function dlerPub(timer, isDev, config) {
     const bumpIsDisabled = await isBumpDisabled();
     if (!bumpIsDisabled && !effectiveConfig.commonPubPause) {
       try {
+        if (workspacePackages && workspacePackages.length > 0) {
+          const rootPackageJson = await fs.readFile("package.json", "utf-8");
+          const rootPackage = JSON.parse(rootPackageJson);
+          await bumpWorkspacePackages(
+            workspacePackages,
+            rootPackage.version,
+            effectiveConfig.bumpMode
+          );
+        }
         await bumpHandler(
           effectiveConfig.bumpMode,
           false,
@@ -41,7 +214,7 @@ export async function dlerPub(timer, isDev, config) {
       }
     }
     if (multiStepSpinner) multiStepSpinner.nextStep();
-    const { effectiveConfig: buildConfig } = await dlerBuild({
+    const buildResult = await dlerBuild({
       flow: "pub",
       timer,
       isDev,
@@ -51,6 +224,7 @@ export async function dlerPub(timer, isDev, config) {
       disableOwnSpinner: true
       // disable build's spinner if pub is showing one
     });
+    const buildConfig = buildResult?.effectiveConfig || effectiveConfig;
     if (multiStepSpinner) multiStepSpinner.nextStep();
     if (effectiveConfig.commonPubPause) {
       await finalizeBuild(shouldShowSpinner, timer, effectiveConfig.commonPubPause, "pub");

package/bin/impl/schema/mod.d.ts

@@ -99,6 +99,80 @@ export interface ReliverseConfig {
         packages?: string[];
         sharedPackages?: string[];
     };
+    /**
+     * Configuration for workspace auto-detection and management.
+     * Enables automatic discovery and processing of workspace packages.
+     */
+    monorepoWorkspaces?: {
+        /**
+         * When `true`, enables workspace auto-detection for build and publish commands.
+         * When `false`, workspace detection is disabled and commands work on the main project only.
+         *
+         * @default true
+         */
+        enabled: boolean;
+        /**
+         * When `true`, automatically discovers publishable packages from workspace configuration.
+         * When `false`, packages must be manually configured in libsList.
+         *
+         * @default true
+         */
+        autoDiscoverPackages: boolean;
+        /**
+         * Controls the order in which packages are processed:
+         * - `dependency`: Packages are processed in dependency order (dependencies first)
+         * - `parallel`: All packages are processed in parallel (faster but may fail if dependencies aren't met)
+         *
+         * @default "dependency"
+         */
+        buildOrder: "dependency" | "parallel";
+        /**
+         * Additional glob patterns to include packages beyond workspace configuration.
+         * These patterns are merged with the workspace patterns from package.json.
+         *
+         * @example ["examples/*", "tools/*"]
+         * @default []
+         */
+        includePatterns: string[];
+        /**
+         * Glob patterns to exclude packages from processing.
+         * Useful for excluding test packages or development tools.
+         *
+         * @example ["examples/*", "test-*"]
+         * @default []
+         */
+        excludePatterns: string[];
+    };
+    /**
+     * Configuration for monorepo caching features.
+     * Enables smart caching to skip rebuilding unchanged packages.
+     */
+    monorepoCache?: {
+        /**
+         * When `true`, enables smart caching for monorepo packages.
+         * Packages are only rebuilt if their source files have changed.
+         *
+         * @default false
+         */
+        enabled: boolean;
+        /**
+         * Output directory for cached builds.
+         * Each package's build output is cached in a subdirectory.
+         *
+         * @default "dist"
+         */
+        outDir: string;
+        /**
+         * Glob patterns for files to include in cache hash calculation.
+         * Only changes to these files will trigger a rebuild.
+         */
+        include: string[];
+        /**
+         * Glob patterns for files to exclude from cache hash calculation.
+         * Changes to these files will not trigger a rebuild.
+         */
+        exclude: string[];
+    };
     ignoreDependencies?: string[];
     customRules?: Record<string, unknown>;
     multipleRepoCloneMode?: boolean;
@@ -1118,6 +1192,72 @@ export declare const defineConfig: (userConfig?: Partial<ReliverseConfig>) => {
         packages?: string[];
         sharedPackages?: string[];
     };
+    monorepoWorkspaces?: {
+        /**
+         * When `true`, enables workspace auto-detection for build and publish commands.
+         * When `false`, workspace detection is disabled and commands work on the main project only.
+         *
+         * @default true
+         */
+        enabled: boolean;
+        /**
+         * When `true`, automatically discovers publishable packages from workspace configuration.
+         * When `false`, packages must be manually configured in libsList.
+         *
+         * @default true
+         */
+        autoDiscoverPackages: boolean;
+        /**
+         * Controls the order in which packages are processed:
+         * - `dependency`: Packages are processed in dependency order (dependencies first)
+         * - `parallel`: All packages are processed in parallel (faster but may fail if dependencies aren't met)
+         *
+         * @default "dependency"
+         */
+        buildOrder: "dependency" | "parallel";
+        /**
+         * Additional glob patterns to include packages beyond workspace configuration.
+         * These patterns are merged with the workspace patterns from package.json.
+         *
+         * @example ["examples/*", "tools/*"]
+         * @default []
+         */
+        includePatterns: string[];
+        /**
+         * Glob patterns to exclude packages from processing.
+         * Useful for excluding test packages or development tools.
+         *
+         * @example ["examples/*", "test-*"]
+         * @default []
+         */
+        excludePatterns: string[];
+    };
+    monorepoCache?: {
+        /**
+         * When `true`, enables smart caching for monorepo packages.
+         * Packages are only rebuilt if their source files have changed.
+         *
+         * @default false
+         */
+        enabled: boolean;
+        /**
+         * Output directory for cached builds.
+         * Each package's build output is cached in a subdirectory.
+         *
+         * @default "dist"
+         */
+        outDir: string;
+        /**
+         * Glob patterns for files to include in cache hash calculation.
+         * Only changes to these files will trigger a rebuild.
+         */
+        include: string[];
+        /**
+         * Glob patterns for files to exclude from cache hash calculation.
+         * Changes to these files will not trigger a rebuild.
+         */
+        exclude: string[];
+    };
     ignoreDependencies?: string[];
     customRules?: Record<string, unknown>;
     multipleRepoCloneMode?: boolean;

package/bin/impl/schema/mod.js

@@ -239,6 +239,28 @@ export const DEFAULT_CONFIG_RELIVERSE = {
     packages: [],
     sharedPackages: []
   },
+  // Monorepo Workspaces Configuration
+  monorepoWorkspaces: {
+    enabled: true,
+    autoDiscoverPackages: true,
+    buildOrder: "dependency",
+    includePatterns: [],
+    excludePatterns: []
+  },
+  // Monorepo Cache Configuration
+  monorepoCache: {
+    enabled: false,
+    outDir: "dist",
+    include: ["src/**/*"],
+    exclude: [
+      "**/__tests__/**",
+      "**/__mocks__/**",
+      "**/*.test.*",
+      "**/e2e/**",
+      "**/dist/**",
+      "**/.output/**"
+    ]
+  },
   // List dependencies to exclude from checks
   ignoreDependencies: [],
   // Provide custom rules for Rse AI