@reliverse/dler 1.4.2 → 1.4.4

package/bin/app.d.ts

@@ -0,0 +1 @@
+export declare const FILL_ISSUE = "If you believe this is an error, please fill in the issue on https://github.com/reliverse/dler/issues";

package/bin/app.js

@@ -0,0 +1 @@
+export const FILL_ISSUE = "If you believe this is an error, please fill in the issue on https://github.com/reliverse/dler/issues";

package/bin/impl.js

@@ -1,19 +1,19 @@
+import { bumpHandler, setBumpDisabled } from "@reliverse/bleump";
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { processLibraryFlow } from "./libs/sdk/sdk-impl/library-flow.js";
 import { processRegularFlow } from "./libs/sdk/sdk-impl/regular-flow.js";
-import { bumpHandler } from "./libs/sdk/sdk-impl/utils/utils-bump.js";
 import { removeDistFolders } from "./libs/sdk/sdk-impl/utils/utils-clean.js";
 import { PROJECT_ROOT } from "./libs/sdk/sdk-impl/utils/utils-consts.js";
 import { handleDlerError } from "./libs/sdk/sdk-impl/utils/utils-error.js";
 import { finalizeBuild } from "./libs/sdk/sdk-impl/utils/utils-info.js";
 import { createPerfTimer } from "./libs/sdk/sdk-impl/utils/utils-perf.js";
 import { loadConfig } from "./load.js";
+import { FILL_ISSUE } from "./app.js";
 export async function dlerBuild(isDev) {
   const timer = createPerfTimer();
   try {
     const config = await loadConfig();
-    const pausePublishing = config.commonPubPause;
     if (config.logsFreshFile) {
       await fs.remove(path.join(PROJECT_ROOT, config.logsFileName));
     }
@@ -23,13 +23,19 @@ export async function dlerBuild(isDev) {
       config.libsDirDist,
       config.libsList
     );
-    if (!config.bumpDisable) {
-      await bumpHandler(
-        config.bumpMode,
-        config.bumpDisable,
-        config.bumpFilter,
-        config.bumpSet
-      );
+    const disableBump = true;
+    if (!config.commonPubPause) {
+      try {
+        await bumpHandler(
+          config.bumpMode,
+          !disableBump,
+          config.bumpFilter,
+          config.bumpSet
+        );
+        await setBumpDisabled(disableBump, config.commonPubPause);
+      } catch {
+        throw new Error(`Failed to set bump disabled. ${FILL_ISSUE}`);
+      }
     }
     await processRegularFlow(
       timer,
@@ -43,7 +49,7 @@ export async function dlerBuild(isDev) {
       config.coreEntryFile,
       config.distJsrDryRun,
       config.distJsrFailOnWarn,
-      pausePublishing,
+      config.commonPubPause,
       config.distJsrDirName,
       config.distJsrBuilder,
       config.transpileTarget,
@@ -74,7 +80,7 @@ export async function dlerBuild(isDev) {
       config.distJsrFailOnWarn,
       config.libsDirDist,
       config.libsDirSrc,
-      pausePublishing,
+      config.commonPubPause,
       config.commonPubRegistry,
       config.distNpmOutFilesExt,
       config.distNpmBuilder,
@@ -96,7 +102,7 @@ export async function dlerBuild(isDev) {
     );
     await finalizeBuild(
       timer,
-      pausePublishing,
+      config.commonPubPause,
       config.libsList,
       config.distNpmDirName,
       config.distJsrDirName,
@@ -119,13 +125,19 @@ export async function dlerPub(isDev) {
       config.libsDirDist,
       config.libsList
     );
-    if (!config.bumpDisable) {
-      await bumpHandler(
-        config.bumpMode,
-        config.bumpDisable,
-        config.bumpFilter,
-        config.bumpSet
-      );
+    const disableBump = true;
+    if (!config.commonPubPause) {
+      try {
+        await bumpHandler(
+          config.bumpMode,
+          !disableBump,
+          config.bumpFilter,
+          config.bumpSet
+        );
+        await setBumpDisabled(disableBump, config.commonPubPause);
+      } catch {
+        throw new Error(`Failed to set bump disabled. ${FILL_ISSUE}`);
+      }
     }
     await processRegularFlow(
       timer,

package/bin/libs/sdk/sdk-impl/utils/utils-info.js

@@ -1,6 +1,7 @@
+import { setBumpDisabled } from "@reliverse/bleump";
 import { relinka } from "@reliverse/relinka";
 import prettyMilliseconds from "pretty-ms";
-import { setBumpDisabled } from "./utils-bump.js";
+import { FILL_ISSUE } from "../../../../app.js";
 import { removeDistFolders } from "./utils-clean.js";
 import { getElapsedPerfTime } from "./utils-perf.js";
 export async function finalizeBuild(timer, commonPubPause, libsList, distNpmDirName, distJsrDirName, libsDirDist) {
@@ -11,7 +12,11 @@ export async function finalizeBuild(timer, commonPubPause, libsList, distNpmDirN
       libsDirDist,
       libsList
     );
-    await setBumpDisabled(false, commonPubPause);
+    try {
+      await setBumpDisabled(false, commonPubPause);
+    } catch {
+      throw new Error(`Failed to set bump enabled. ${FILL_ISSUE}`);
+    }
   }
   const elapsedTime = getElapsedPerfTime(timer);
   const transpileFormattedTime = prettyMilliseconds(elapsedTime, {

package/bin/libs/sdk/sdk-types.d.ts

@@ -503,6 +503,7 @@ export type MkdistHooks = {
     "mkdist:entry:options": (ctx: BuildContext, entry: MkdistBuildEntry, options: MkdistOptions) => Promise<void> | void;
 };
 type _BaseAndMkdist = BaseBuildEntry & MkdistOptions;
+import type { BumpMode } from "@reliverse/bleump";
 import type { RollupAliasOptions } from "@rollup/plugin-alias";
 import type { RollupCommonJSOptions } from "@rollup/plugin-commonjs";
 import type { RollupJsonOptions } from "@rollup/plugin-json";
@@ -510,7 +511,6 @@ import type { RollupNodeResolveOptions } from "@rollup/plugin-node-resolve";
 import type { RollupReplaceOptions } from "@rollup/plugin-replace";
 import type { RollupOptions as _RollupOptions, OutputOptions, Plugin, RollupBuild } from "rollup";
 import type { Options as RollupDtsOptions } from "rollup-plugin-dts";
-import type { BumpMode } from "./sdk-impl/utils/utils-bump.js";
 export type RollupBuildEntry = BaseBuildEntry & {
     builder: "rollup";
 };

package/package.json

@@ -1,5 +1,6 @@
 {
   "dependencies": {
+    "@reliverse/bleump": "^1.1.1",
     "@reliverse/pathkit": "^1.1.4",
     "@reliverse/reglob": "^1.0.0",
     "@reliverse/relico": "^1.1.2",
@@ -12,7 +13,6 @@
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/pluginutils": "^5.1.4",
-    "@types/semver": "^7.7.0",
     "bun": "^1.2.14",
     "chalk": "^5.4.1",
     "defu": "^6.1.4",
@@ -33,7 +33,6 @@
     "rollup": "^4.41.0",
     "rollup-plugin-dts": "^6.2.1",
     "scule": "^1.3.0",
-    "semver": "^7.7.2",
     "tinyglobby": "^0.2.13",
     "ts-morph": "^26.0.0",
     "untyped": "^2.0.0"
@@ -43,7 +42,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "keywords": [
     "reliverse",
     "cli",

package/bin/libs/sdk/sdk-impl/utils/utils-bump.d.ts

@@ -1,89 +0,0 @@
-/**
- * Supported bump modes for versioning:
- * - patch: 1.2.3 → 1.2.4 (backwards-compatible bug fixes)
- * - minor: 1.2.3 → 1.3.0 (new backwards-compatible features)
- * - major: 1.2.3 → 2.0.0 (breaking changes)
- * - auto: Automatically determine bump type
- * - manual: Set a specific version (requires bumpSet to be set)
- */
-export type BumpMode = "patch" | "minor" | "major" | "auto" | "manual";
-export type FileType = "package.json" | "typescript" | "unknown";
-export type BumpOptions = {
-    dryRun?: boolean;
-    verbose?: boolean;
-    customVersion?: string;
-};
-export type FileAnalysis = {
-    file: string;
-    supported: boolean;
-    detectedVersion: string | null;
-    versionMismatch: boolean;
-    reason: string;
-    fileType: FileType;
-};
-export type VersionInfo = {
-    version: string;
-    name?: string;
-    author?: string;
-};
-export declare const isValidSemver: (version: string) => boolean;
-export declare const parseSemver: (version: string) => [number, number, number];
-export declare const calculateNewVersion: (current: string, bumpType: BumpMode, customVersion?: string, bumpSet?: string) => string;
-export declare const readFileInfo: (filePath: string) => Promise<VersionInfo | null>;
-export declare const getCurrentVersion: (filePath?: string, field?: string) => Promise<string>;
-export declare const getPackageName: (filePath?: string, field?: string) => Promise<string>;
-export declare const getPackageAuthor: (filePath?: string, field?: string) => Promise<string>;
-export declare const analyzeFiles: (files: string[], referenceVersion: string) => Promise<FileAnalysis[]>;
-export type DlerConfig = {
-    bumpDisable?: boolean;
-    bumpFilter?: string[];
-    bumpMode?: BumpMode;
-    bumpSet?: string;
-};
-export declare const getConfigFromDler: () => Promise<{
-    files: string[];
-    bumpDisable?: boolean;
-    bumpMode?: BumpMode;
-    bumpSet?: string;
-}>;
-export declare const getFilesFromConfigOrDefault: () => Promise<string[]>;
-export declare const bumpVersion: (bumpType: BumpMode, files?: string[], options?: BumpOptions, globs?: string[], bumpSet?: string) => Promise<void>;
-export declare const bumpVersionWithAnalysis: (bumpType: BumpMode, files?: string[], options?: BumpOptions, bumpSet?: string) => Promise<void>;
-export declare const compareVersions: (version1: string, version2: string) => number;
-export declare const getLatestVersion: (versions: string[]) => string | null;
-export declare const isPrerelease: (version: string) => boolean;
-export declare const satisfiesRange: (version: string, range: string) => boolean;
-export type BumpConfig = {
-    bumpType: BumpMode;
-    customVersion?: string;
-    dryRun?: boolean;
-    verbose?: boolean;
-};
-export type SessionConfig = {
-    isCI: boolean;
-    isNonInteractive: boolean;
-    mainFile: string;
-    filesToBump: string[];
-    options: {
-        dryRun: boolean;
-        verbose: boolean;
-        customVersion?: string;
-    };
-    bumpType: BumpMode;
-};
-export declare function validateBumpConfig(bumpType: BumpMode, customVersion?: string): void;
-export declare function getDefaultBumpMode(isCI: boolean, isNonInteractive: boolean): BumpMode;
-export declare function handleNonInteractiveSession(config: SessionConfig): Promise<void>;
-export declare function handleInteractiveSession(config: SessionConfig, projectVersion: string): Promise<{
-    supportedFiles: FileAnalysis[];
-    mismatchedFiles: FileAnalysis[];
-    fileAnalysis: FileAnalysis[];
-}>;
-/**
- * Updates the "bumpDisable" flag in the build configuration file.
- */
-export declare function setBumpDisabled(value: boolean, commonPubPause: boolean): Promise<void>;
-/**
- * Handles version bumping using @reliverse/bleump
- */
-export declare function bumpHandler(bumpMode: BumpMode, bumpDisable: boolean, bumpFilter: string[], bumpSet?: string): Promise<void>;

package/bin/libs/sdk/sdk-impl/utils/utils-bump.js

@@ -1,416 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { readFile, writeFile, access } from "node:fs/promises";
-import { join } from "node:path";
-import semver from "semver";
-const PROJECT_ROOT = process.cwd();
-const versionPatterns = {
-  packageJson: /"version"\s*:\s*"([^"]+)"/,
-  typescript: /version\s*[=:]\s*["']([^"']+)["']|version\s*:\s*["']([^"']+)["']\s*,/
-};
-const globToRegex = (pattern) => {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "DOUBLESTAR").replace(/\*/g, "[^/]*").replace(/DOUBLESTAR/g, ".*").replace(/\?/g, "[^/]");
-  return new RegExp(`^${escaped}$`);
-};
-const matchesGlobs = (filePath, globs) => {
-  if (globs.length === 0) return true;
-  return globs.some((glob) => globToRegex(glob).test(filePath));
-};
-export const isValidSemver = (version) => {
-  return semver.valid(version) !== null;
-};
-export const parseSemver = (version) => {
-  const parsed = semver.parse(version);
-  if (!parsed) throw new Error(`invalid semver: ${version}`);
-  return [parsed.major, parsed.minor, parsed.patch];
-};
-export const calculateNewVersion = (current, bumpType, customVersion, bumpSet) => {
-  if (bumpType === "manual") {
-    if (bumpSet) {
-      if (!isValidSemver(bumpSet)) {
-        throw new Error(`invalid bumpSet version: ${bumpSet}`);
-      }
-      return bumpSet;
-    }
-    if (!customVersion) {
-      throw new Error(
-        "either bumpSet (in .config/dler.ts) or --customVersion required when bumpType is 'manual'"
-      );
-    }
-    if (!isValidSemver(customVersion)) {
-      throw new Error(`invalid custom version: ${customVersion}`);
-    }
-    return customVersion;
-  }
-  let releaseType;
-  switch (bumpType) {
-    case "major":
-      releaseType = "major";
-      break;
-    case "minor":
-      releaseType = "minor";
-      break;
-    case "patch":
-    case "auto":
-      releaseType = "patch";
-      break;
-    default:
-      throw new Error(`unknown bump type: ${bumpType}`);
-  }
-  const newVersion = semver.inc(current, releaseType);
-  if (!newVersion) {
-    throw new Error(`failed to bump version ${current} with type ${bumpType}`);
-  }
-  return newVersion;
-};
-const detectFileType = (filePath, content) => {
-  if (filePath.endsWith("package.json")) return "package.json";
-  if (filePath.endsWith(".ts") || filePath.endsWith(".js")) {
-    if (versionPatterns.typescript.test(content)) return "typescript";
-  }
-  return "unknown";
-};
-const extractVersion = (content, fileType) => {
-  switch (fileType) {
-    case "package.json": {
-      const pkgMatch = versionPatterns.packageJson.exec(content);
-      return pkgMatch?.[1] ?? null;
-    }
-    case "typescript": {
-      const tsMatch = versionPatterns.typescript.exec(content);
-      return tsMatch?.[1] ?? tsMatch?.[2] ?? null;
-    }
-    default:
-      return null;
-  }
-};
-export const readFileInfo = async (filePath) => {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    if (filePath.endsWith("package.json")) {
-      const pkg = JSON.parse(content);
-      return {
-        version: pkg.version ?? "",
-        name: pkg.name ?? "",
-        author: pkg.author ?? ""
-      };
-    }
-    const fileType = detectFileType(filePath, content);
-    const version = extractVersion(content, fileType);
-    return version ? { version } : null;
-  } catch {
-    return null;
-  }
-};
-export const getCurrentVersion = async (filePath = "package.json", field = "version") => {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    if (filePath.endsWith("package.json")) {
-      const pkg = JSON.parse(content);
-      const value = pkg[field];
-      if (!value || typeof value !== "string") {
-        throw new Error(`field '${field}' not found in ${filePath}`);
-      }
-      return value;
-    }
-    const pattern = new RegExp(`${field}\\s*[=:]\\s*["']([^"']+)["']`);
-    const match = content.match(pattern);
-    if (!match?.[1]) {
-      throw new Error(`field '${field}' not found in ${filePath}`);
-    }
-    return match[1];
-  } catch (error) {
-    if (error instanceof Error) throw error;
-    throw new Error(`failed to read ${filePath}: ${error}`);
-  }
-};
-export const getPackageName = async (filePath = "package.json", field = "name") => {
-  return getCurrentVersion(filePath, field);
-};
-export const getPackageAuthor = async (filePath = "package.json", field = "author") => {
-  return getCurrentVersion(filePath, field);
-};
-const updateVersionInContent = (content, newVersion, fileType) => {
-  switch (fileType) {
-    case "package.json":
-      return content.replace(
-        versionPatterns.packageJson,
-        `"version": "${newVersion}"`
-      );
-    case "typescript": {
-      return content.replace(versionPatterns.typescript, (match) => {
-        const delimiter = match.includes('"') ? '"' : "'";
-        const operator = match.includes("=") ? "=" : ":";
-        const hasComma = match.includes(",");
-        return `version${operator} ${delimiter}${newVersion}${delimiter}${hasComma ? "," : ""}`;
-      });
-    }
-    default:
-      throw new Error("unsupported file type for version update");
-  }
-};
-export const analyzeFiles = async (files, referenceVersion) => {
-  const results = [];
-  for (const file of files) {
-    try {
-      const content = await readFile(file, "utf-8");
-      const fileType = detectFileType(file, content);
-      const detectedVersion = extractVersion(content, fileType);
-      let supported = fileType !== "unknown";
-      let versionMismatch = false;
-      let reason = "";
-      if (!supported) {
-        reason = "unsupported file type";
-      } else if (!detectedVersion) {
-        reason = "no version field found";
-        supported = false;
-      } else if (!semver.eq(detectedVersion, referenceVersion)) {
-        versionMismatch = true;
-        reason = `version mismatch: found ${detectedVersion}, expected ${referenceVersion}`;
-      } else {
-        reason = "ok";
-      }
-      results.push({
-        file,
-        supported,
-        detectedVersion,
-        versionMismatch,
-        reason,
-        fileType
-      });
-    } catch (error) {
-      results.push({
-        file,
-        supported: false,
-        detectedVersion: null,
-        versionMismatch: false,
-        reason: `read error: ${error}`,
-        fileType: "unknown"
-      });
-    }
-  }
-  return results;
-};
-export const getConfigFromDler = async () => {
-  try {
-    await access(".config/dler.ts");
-    const content = await readFile(".config/dler.ts", "utf-8");
-    const filesMatch = /bumpFilter\s*[:=]\s*\[([\s\S]*?)\]/.exec(content);
-    const bumpDisableMatch = /bumpDisable\s*[:=]\s*(true|false)/.exec(content);
-    const bumpModeMatch = /bumpMode\s*[:=]\s*["']([^"']+)["']/.exec(content);
-    const bumpSetMatch = /bumpSet\s*[:=]\s*["']([^"']+)["']/.exec(content);
-    const files = filesMatch?.[1] ? filesMatch[1].split(",").map((f) => f.trim().replace(/["']/g, "")).filter(Boolean) : ["package.json", ".config/rse.ts"];
-    const bumpDisable = bumpDisableMatch ? bumpDisableMatch[1] === "true" : void 0;
-    const bumpMode = bumpModeMatch?.[1];
-    const bumpSet = bumpSetMatch?.[1];
-    return {
-      files,
-      bumpDisable,
-      bumpMode,
-      bumpSet
-    };
-  } catch {
-    return {
-      files: ["package.json", ".config/rse.ts"]
-    };
-  }
-};
-export const getFilesFromConfigOrDefault = async () => {
-  const config = await getConfigFromDler();
-  return config.files;
-};
-export const bumpVersion = async (bumpType, files = [], options = {}, globs = [], bumpSet) => {
-  const { dryRun = false, verbose = false, customVersion } = options;
-  const currentVersion = await getCurrentVersion();
-  const newVersion = calculateNewVersion(
-    currentVersion,
-    bumpType,
-    customVersion,
-    bumpSet
-  );
-  if (verbose) {
-    relinka("info", `bumping version: ${currentVersion} \u2192 ${newVersion}`);
-  }
-  const filteredFiles = files.filter((file) => matchesGlobs(file, globs));
-  const updateResults = [];
-  for (const file of filteredFiles) {
-    try {
-      const content = await readFile(file, "utf-8");
-      const fileType = detectFileType(file, content);
-      if (fileType === "unknown") {
-        if (verbose) relinka("log", `skipping unsupported file: ${file}`);
-        continue;
-      }
-      const currentFileVersion = extractVersion(content, fileType);
-      if (!currentFileVersion) {
-        if (verbose) relinka("log", `no version found in: ${file}`);
-        continue;
-      }
-      const updatedContent = updateVersionInContent(
-        content,
-        newVersion,
-        fileType
-      );
-      if (dryRun) {
-        relinka("log", `- [dry-run] would update ${file}`);
-        updateResults.push({ file, success: true });
-      } else {
-        await writeFile(file, updatedContent, "utf-8");
-        if (verbose) {
-          relinka("log", `- updated ${file}`);
-        }
-        updateResults.push({ file, success: true });
-      }
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      updateResults.push({ file, success: false, error: errorMsg });
-      if (verbose) {
-        relinka("error", `failed to update ${file}: ${errorMsg}`);
-      }
-    }
-  }
-  const failures = updateResults.filter((r) => !r.success);
-  if (failures.length > 0) {
-    const failedFiles = failures.map((f) => `${f.file}: ${f.error}`).join(", ");
-    throw new Error(`failed to update version in files: ${failedFiles}`);
-  }
-  if (verbose && !dryRun) {
-    relinka(
-      "verbose",
-      `successfully bumped ${updateResults.length} files to version ${newVersion}`
-    );
-  }
-};
-export const bumpVersionWithAnalysis = async (bumpType, files = [], options = {}, bumpSet) => {
-  const currentVersion = await getCurrentVersion();
-  const analysis = await analyzeFiles(files, currentVersion);
-  const supportedFiles = analysis.filter((a) => a.supported).map((a) => a.file);
-  await bumpVersion(bumpType, supportedFiles, options, [], bumpSet);
-};
-export const compareVersions = (version1, version2) => {
-  return semver.compare(version1, version2);
-};
-export const getLatestVersion = (versions) => {
-  const validVersions = versions.filter(isValidSemver);
-  if (validVersions.length === 0) return null;
-  return semver.maxSatisfying(validVersions, "*");
-};
-export const isPrerelease = (version) => {
-  return semver.prerelease(version) !== null;
-};
-export const satisfiesRange = (version, range) => {
-  return semver.satisfies(version, range);
-};
-export function validateBumpConfig(bumpType, customVersion) {
-  if (!["patch", "minor", "major", "auto", "manual"].includes(bumpType)) {
-    throw new Error(`Invalid bump type: ${bumpType}`);
-  }
-  if (bumpType === "manual" && !customVersion) {
-    throw new Error("customVersion is required when using manual bump type");
-  }
-  if (customVersion && !isValidSemver(customVersion)) {
-    throw new Error(`Invalid custom version: ${customVersion}`);
-  }
-}
-export function getDefaultBumpMode(isCI, isNonInteractive) {
-  if (isCI || isNonInteractive) {
-    return "patch";
-  }
-  return "auto";
-}
-export async function handleNonInteractiveSession(config) {
-  const { bumpType, options, filesToBump } = config;
-  validateBumpConfig(bumpType, options.customVersion);
-  try {
-    await bumpVersionWithAnalysis(bumpType, filesToBump, options);
-  } catch (error) {
-    throw new Error(`Failed to bump version: ${error}`);
-  }
-}
-export async function handleInteractiveSession(config, projectVersion) {
-  const { filesToBump } = config;
-  const fileAnalysis = await analyzeFiles(filesToBump, projectVersion);
-  const supportedFiles = fileAnalysis.filter((r) => r.supported);
-  const unsupportedFiles = fileAnalysis.filter((r) => !r.supported);
-  const mismatchedFiles = fileAnalysis.filter((r) => r.versionMismatch);
-  if (supportedFiles.length === 0) {
-    const reasons = unsupportedFiles.map((f) => `${f.file}: ${f.reason}`).join("\n");
-    throw new Error(`No files can be bumped. Analysis results:
-${reasons}`);
-  }
-  if (mismatchedFiles.length > 0) {
-    const mismatches = mismatchedFiles.map(
-      (f) => `${f.file}: found version ${f.detectedVersion} (expected ${projectVersion})`
-    ).join("\n");
-    relinka("warn", "Some files have mismatched versions:");
-    relinka("info", mismatches);
-    throw new Error("Please fix the version mismatches before continuing");
-  }
-  return {
-    supportedFiles,
-    mismatchedFiles,
-    fileAnalysis
-  };
-}
-async function fileExists(filePath) {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function updateDlerConfig(key, value) {
-  const dlerCfgPath = join(PROJECT_ROOT, ".config/dler.ts");
-  if (!await fileExists(dlerCfgPath)) {
-    relinka(
-      "warn",
-      `No .config/dler.ts found to update ${key}. This is not an error, but the ${key} flag will not be updated.`
-    );
-    return;
-  }
-  try {
-    const content = await readFile(dlerCfgPath, "utf-8");
-    const formattedValue = Array.isArray(value) ? `[${value.map((v) => `"${v}"`).join(", ")}]` : typeof value === "string" ? `"${value}"` : value;
-    const pattern = new RegExp(`${key}\\s*[:=]\\s*([^,}\\]]+)`);
-    const updatedContent = content.replace(
-      pattern,
-      `${key}: ${formattedValue}`
-    );
-    await writeFile(dlerCfgPath, updatedContent, "utf-8");
-    relinka(
-      "info",
-      `Successfully updated ${key} to ${formattedValue} in .config/dler.ts`
-    );
-  } catch (error) {
-    relinka(
-      "warn",
-      `Failed to update ${key} in ${dlerCfgPath}. This is not an error, but the ${key} flag will not be updated.`,
-      error
-    );
-  }
-}
-export async function setBumpDisabled(value, commonPubPause) {
-  if (commonPubPause && !value) {
-    return;
-  }
-  await getConfigFromDler();
-  await updateDlerConfig("bumpDisable", value);
-}
-export async function bumpHandler(bumpMode, bumpDisable, bumpFilter, bumpSet) {
-  if (bumpDisable) {
-    relinka("info", "Version bumping is paused");
-    return;
-  }
-  try {
-    const files = bumpFilter.length > 0 ? bumpFilter : ["package.json"];
-    await bumpVersionWithAnalysis(bumpMode, files, {
-      dryRun: false,
-      verbose: true,
-      customVersion: bumpMode === "manual" ? bumpSet : void 0
-    });
-    relinka("success", "Version bump completed successfully");
-  } catch (error) {
-    relinka("error", "Failed to bump version", error);
-    throw error;
-  }
-}