relizy 0.2.5-beta.11 → 0.2.5-beta.12

package/dist/shared/{relizy.DLoE22sp.mjs → relizy.PGChVRhn.mjs}

@@ -1,2452 +1,2479 @@
 import { logger, execPromise } from '@maz-ui/node';
-import process$1, { exit } from 'node:process';
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import path, { join, relative } from 'node:path';
-import { upperFirst, formatJson } from '@maz-ui/utils';
-import { setupDotenv, loadConfig } from 'c12';
-import { formatCompareChanges, formatReference, resolveRepoConfig, getRepoConfig, createGithubRelease, getGitDiff, parseCommits } from 'changelogen';
-import { defu } from 'defu';
+import { getGitDiff, parseCommits, formatCompareChanges, formatReference, resolveRepoConfig, getRepoConfig, createGithubRelease } from 'changelogen';
 import fastGlob from 'fast-glob';
 import { confirm, input } from '@inquirer/prompts';
+import { upperFirst, formatJson } from '@maz-ui/utils';
 import * as semver from 'semver';
+import { execSync } from 'node:child_process';
+import process$1, { exit } from 'node:process';
+import { setupDotenv, loadConfig } from 'c12';
+import { defu } from 'defu';
 import { convert } from 'convert-gitmoji';
 import { fetch as fetch$1 } from 'node-fetch-native';
 
-async function executeHook(hook, config, dryRun, params) {
-  const hookInput = config.hooks?.[hook];
-  if (!hookInput) {
-    logger.debug(`Hook ${hook} not found`);
-    return;
-  }
-  if (typeof hookInput === "function") {
-    logger.info(`Executing hook ${hook}`);
-    const result = await hookInput(config, dryRun, params);
-    if (result)
-      logger.debug(`Hook ${hook} returned: ${result}`);
-    logger.info(`Hook ${hook} executed`);
-    return result;
+function getPackageDependencies({
+  packagePath,
+  allPackageNames,
+  dependencyTypes
+}) {
+  const packageJsonPath = join(packagePath, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return [];
   }
-  if (typeof hookInput === "string") {
-    logger.info(`Executing hook ${hook}`);
-    const result = await execPromise(hookInput, {
-      logLevel: config.logLevel,
-      cwd: config.cwd,
-      noStderr: true,
-      noStdout: true
-    });
-    if (result)
-      logger.debug(`Hook ${hook} returned: ${result}`);
-    logger.info(`Hook ${hook} executed`);
-    return result;
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const deps = [];
+  const allDeps = {
+    ...dependencyTypes?.includes("dependencies") ? packageJson.dependencies : {},
+    ...dependencyTypes?.includes("peerDependencies") ? packageJson.peerDependencies : {},
+    ...dependencyTypes?.includes("devDependencies") ? packageJson.devDependencies : {}
+  };
+  for (const depName of Object.keys(allDeps)) {
+    if (allPackageNames.has(depName)) {
+      deps.push(depName);
+    }
   }
+  return deps;
 }
-function isInCI() {
-  return Boolean(
-    process.env.CI === "true" || process.env.CONTINUOUS_INTEGRATION === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.GITHUB_WORKFLOW || process.env.GITLAB_CI === "true" || process.env.CIRCLECI === "true" || process.env.TRAVIS === "true" || process.env.JENKINS_HOME || process.env.JENKINS_URL || process.env.BUILD_ID || process.env.TF_BUILD === "True" || process.env.AZURE_PIPELINES === "true" || process.env.TEAMCITY_VERSION || process.env.BITBUCKET_BUILD_NUMBER || process.env.DRONE === "true" || process.env.APPVEYOR === "True" || process.env.APPVEYOR === "true" || process.env.BUILDKITE === "true" || process.env.CODEBUILD_BUILD_ID || process.env.NETLIFY === "true" || process.env.VERCEL === "1" || process.env.HEROKU_TEST_RUN_ID || process.env.BUDDY === "true" || process.env.SEMAPHORE === "true" || process.env.CF_BUILD_ID || process.env.bamboo_buildKey || process.env.BUILD_ID && process.env.PROJECT_ID || process.env.SCREWDRIVER === "true" || process.env.STRIDER === "true"
+function getDependentsOf({
+  allPackages,
+  packageName
+}) {
+  return allPackages.filter(
+    (pkg) => pkg.dependencies.includes(packageName)
   );
 }
-function getCIName() {
-  if (process.env.GITHUB_ACTIONS === "true")
-    return "GitHub Actions";
-  if (process.env.GITLAB_CI === "true")
-    return "GitLab CI";
-  if (process.env.CIRCLECI === "true")
-    return "CircleCI";
-  if (process.env.TRAVIS === "true")
-    return "Travis CI";
-  if (process.env.JENKINS_HOME || process.env.JENKINS_URL)
-    return "Jenkins";
-  if (process.env.TF_BUILD === "True")
-    return "Azure Pipelines";
-  if (process.env.TEAMCITY_VERSION)
-    return "TeamCity";
-  if (process.env.BITBUCKET_BUILD_NUMBER)
-    return "Bitbucket Pipelines";
-  if (process.env.DRONE === "true")
-    return "Drone";
-  if (process.env.APPVEYOR)
-    return "AppVeyor";
-  if (process.env.BUILDKITE === "true")
-    return "Buildkite";
-  if (process.env.CODEBUILD_BUILD_ID)
-    return "AWS CodeBuild";
-  if (process.env.NETLIFY === "true")
-    return "Netlify";
-  if (process.env.VERCEL === "1")
-    return "Vercel";
-  if (process.env.HEROKU_TEST_RUN_ID)
-    return "Heroku CI";
-  if (process.env.BUDDY === "true")
-    return "Buddy";
-  if (process.env.SEMAPHORE === "true")
-    return "Semaphore";
-  if (process.env.CF_BUILD_ID)
-    return "Codefresh";
-  if (process.env.bamboo_buildKey)
-    return "Bamboo";
-  if (process.env.BUILD_ID && process.env.PROJECT_ID)
-    return "Google Cloud Build";
-  if (process.env.SCREWDRIVER === "true")
-    return "Screwdriver";
-  if (process.env.STRIDER === "true")
-    return "Strider";
-  if (process.env.CI === "true")
-    return "Unknown CI";
-  return null;
-}
-async function executeFormatCmd({
-  config,
-  dryRun
+function expandPackagesToBumpWithDependents({
+  allPackages,
+  packagesWithCommits
 }) {
-  if (config.changelog?.formatCmd) {
-    logger.info("Running format command");
-    logger.debug(`Running format command: ${config.changelog.formatCmd}`);
-    try {
-      if (!dryRun) {
-        await execPromise(config.changelog.formatCmd, {
-          noStderr: true,
-          noStdout: true,
-          logLevel: config.logLevel,
-          cwd: config.cwd
-        });
-        logger.info("Format completed");
-      } else {
-        logger.log("[dry-run] exec format command: ", config.changelog.formatCmd);
+  const result = /* @__PURE__ */ new Map();
+  logger.debug(`Expanding packages to bump: ${packagesWithCommits.length} packages with commits, ${allPackages.length} total packages`);
+  for (const pkg of packagesWithCommits) {
+    const packageToBump = {
+      ...pkg,
+      reason: "commits"
+    };
+    result.set(pkg.name, packageToBump);
+  }
+  const toProcess = [...packagesWithCommits.map((p) => p.name)];
+  const processed = /* @__PURE__ */ new Set();
+  while (toProcess.length > 0) {
+    const currentPkgName = toProcess.shift();
+    if (!currentPkgName || processed.has(currentPkgName)) {
+      continue;
+    }
+    processed.add(currentPkgName);
+    const dependents = getDependentsOf({
+      packageName: currentPkgName,
+      allPackages
+    });
+    for (const dependent of dependents) {
+      if (!result.has(dependent.name)) {
+        const currentChain = result.get(currentPkgName)?.dependencyChain || [];
+        const chain = [...currentChain, currentPkgName];
+        const packageBase = allPackages.find((p) => p.name === dependent.name);
+        if (packageBase) {
+          const packageToBump = {
+            ...packageBase,
+            reason: "dependency",
+            dependencyChain: chain
+          };
+          result.set(dependent.name, packageToBump);
+          toProcess.push(dependent.name);
+          logger.debug(`${dependent.name} will be bumped (depends on ${chain.join(" \u2192 ")})`);
+        }
       }
-    } catch (error) {
-      throw new Error(`Format command failed: ${error}`);
     }
-  } else {
-    logger.debug("No format command specified");
   }
+  return Array.from(result.values());
 }
-async function executeBuildCmd({
-  config,
-  dryRun
-}) {
-  if (config.publish?.buildCmd) {
-    logger.info("Running build command");
-    logger.debug(`Running build command: ${config.publish.buildCmd}`);
-    if (!dryRun) {
-      await execPromise(config.publish.buildCmd, {
-        noStderr: true,
-        noStdout: true,
-        logLevel: config.logLevel,
-        cwd: config.cwd
-      });
-      logger.info("Build completed");
-    } else {
-      logger.log("[dry-run] exec build command: ", config.publish.buildCmd);
+function topologicalSort(packages) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const packageMap = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    packageMap.set(pkg.name, pkg);
+  }
+  function visit(pkgName, path = []) {
+    logger.debug(`Visiting ${pkgName}, path: ${path.join(" \u2192 ")}, visiting: ${Array.from(visiting).join(", ")}`);
+    if (visiting.has(pkgName)) {
+      const cycle = [...path, pkgName];
+      logger.warn(`Circular dependency detected: ${cycle.join(" \u2192 ")}`);
+      return;
     }
-  } else {
-    logger.debug("No build command specified");
+    if (visited.has(pkgName)) {
+      logger.debug(`${pkgName} already visited globally, skipping`);
+      return;
+    }
+    visiting.add(pkgName);
+    logger.debug(`Added ${pkgName} to visiting set`);
+    const pkg = packageMap.get(pkgName);
+    if (!pkg) {
+      logger.debug(`Package ${pkgName} not found in packageMap`);
+      visiting.delete(pkgName);
+      return;
+    }
+    logger.debug(`${pkgName} has dependencies: ${pkg.dependencies.join(", ")}`);
+    for (const depName of pkg.dependencies) {
+      visit(depName, [...path, pkgName]);
+    }
+    visiting.delete(pkgName);
+    visited.add(pkgName);
+    sorted.push(pkg);
+    logger.debug(`Finished visiting ${pkgName}`);
   }
-}
-function isBumpedPackage(pkg) {
-  return "oldVersion" in pkg && !!pkg.oldVersion;
-}
-
-function getGitStatus(cwd) {
-  return execSync("git status --porcelain", {
-    cwd,
-    encoding: "utf8"
-  }).trim();
-}
-function checkGitStatusIfDirty() {
-  logger.debug("Checking git status");
-  const dirty = getGitStatus();
-  if (dirty) {
-    logger.debug("git status:", `
-${dirty.trim().split("\n").map((line) => line.trim()).join("\n")}`);
-    const error = `Git status is dirty!
-
-Please commit or stash your changes before bumping or use --no-clean flag. 
-
-Unstaged files:
-
- ${dirty.trim()}`;
-    throw new Error(error);
+  for (const pkg of packages) {
+    visit(pkg.name);
   }
+  return sorted;
 }
-async function fetchGitTags(cwd) {
-  logger.debug("Fetching git tags from remote");
-  try {
-    await execPromise("git fetch --tags", { cwd, noStderr: true, noStdout: true, noSuccess: true });
-    logger.debug("Git tags fetched successfully");
-  } catch (error) {
-    logger.fail("Failed to fetch some git tags from remote (tags might already exist locally)", error);
-    logger.info("Continuing with local tags");
+
+function readPackageJson(packagePath) {
+  const packageJsonPath = join(packagePath, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    logger.fail(`package.json not found at ${packageJsonPath}`);
+    return;
+  }
+  if (!statSync(packagePath).isDirectory()) {
+    logger.fail(`Not a directory: ${packagePath}`);
+    return;
+  }
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  if (!packageJson.name || !packageJson.version) {
+    throw new Error(`Invalid package.json at ${packagePath} - missing name or version`);
   }
+  return {
+    name: packageJson.name,
+    version: packageJson.version,
+    private: packageJson.private || false,
+    path: packagePath
+  };
 }
-function detectGitProvider(cwd = process.cwd()) {
+async function getRootPackage({
+  config,
+  force,
+  from,
+  to,
+  suffix,
+  changelog
+}) {
   try {
-    const remoteUrl = execSync("git remote get-url origin", {
-      cwd,
-      encoding: "utf8"
-    }).trim();
-    if (remoteUrl.includes("github.com")) {
-      return "github";
+    const packageJson = readPackageJson(config.cwd);
+    if (!packageJson) {
+      throw new Error("Failed to read root package.json");
     }
-    if (remoteUrl.includes("gitlab.com") || remoteUrl.includes("gitlab")) {
-      return "gitlab";
+    const commits = await getPackageCommits({
+      pkg: packageJson,
+      from,
+      to,
+      config,
+      changelog
+    });
+    let newVersion;
+    if (config.monorepo?.versionMode !== "independent") {
+      const releaseType = determineReleaseType({
+        currentVersion: packageJson.version,
+        commits,
+        releaseType: config.bump.type,
+        preid: config.bump.preid,
+        types: config.types,
+        force
+      });
+      if (!releaseType) {
+        logger.fail("No commits require a version bump");
+        process.exit(0);
+      }
+      newVersion = getPackageNewVersion({
+        currentVersion: packageJson.version,
+        releaseType,
+        preid: config.bump.preid,
+        suffix
+      });
     }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function parseGitRemoteUrl(remoteUrl) {
-  const sshRegex = /git@[\w.-]+:([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
-  const httpsRegex = /https?:\/\/[\w.-]+\/([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
-  const sshMatch = remoteUrl.match(sshRegex);
-  if (sshMatch) {
     return {
-      owner: sshMatch[1],
-      repo: sshMatch[2]
+      ...packageJson,
+      path: config.cwd,
+      fromTag: from,
+      commits,
+      newVersion
     };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(errorMessage);
   }
-  const httpsMatch = remoteUrl.match(httpsRegex);
-  if (httpsMatch) {
-    return {
-      owner: httpsMatch[1],
-      repo: httpsMatch[2]
-    };
+}
+function readPackages({
+  cwd,
+  patterns,
+  ignorePackageNames
+}) {
+  const packages = [];
+  const foundPaths = /* @__PURE__ */ new Set();
+  const patternsSet = new Set(patterns);
+  if (!patterns)
+    patternsSet.add(".");
+  logger.debug(`Read package.json files from patterns: ${patternsSet.values()}`);
+  for (const pattern of patternsSet) {
+    try {
+      const matches = fastGlob.sync(pattern, {
+        cwd,
+        onlyDirectories: true,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+      });
+      for (const matchPath of matches) {
+        if (foundPaths.has(matchPath))
+          continue;
+        const packageBase = readPackageJson(matchPath);
+        if (!packageBase || packageBase.private || ignorePackageNames?.includes(packageBase.name))
+          continue;
+        foundPaths.add(matchPath);
+        packages.push({
+          ...packageBase,
+          path: matchPath
+        });
+      }
+    } catch (error) {
+      logger.error(error);
+    }
   }
-  return null;
+  return packages;
 }
-async function createCommitAndTags({
+function getPackageReleaseType({
+  pkg,
   config,
-  noVerify,
-  bumpedPackages,
-  newVersion,
-  dryRun,
-  logLevel
+  force
 }) {
-  const internalConfig = config || await loadRelizyConfig();
-  try {
-    await executeHook("before:commit-and-tag", internalConfig, dryRun ?? false);
-    const filePatternsToAdd = [
-      "package.json",
-      "lerna.json",
-      "CHANGELOG.md",
-      "**/CHANGELOG.md",
-      "**/package.json"
-    ];
-    logger.start("Start commit and tag");
-    logger.debug("Adding files to git staging area...");
-    for (const pattern of filePatternsToAdd) {
-      if (pattern === "lerna.json" && !hasLernaJson(internalConfig.cwd)) {
-        logger.verbose(`Skipping lerna.json as it doesn't exist`);
+  const releaseType = config.bump.type;
+  if (force) {
+    return determineReleaseType({
+      currentVersion: pkg.version,
+      commits: pkg.commits,
+      releaseType,
+      preid: config.bump.preid,
+      types: config.types,
+      force
+    });
+  }
+  if (pkg.reason === "dependency") {
+    if (isStableReleaseType(releaseType))
+      return "patch";
+    if (isPrerelease(pkg.version))
+      return "prerelease";
+    return "prepatch";
+  }
+  return determineReleaseType({
+    currentVersion: pkg.version,
+    commits: pkg.commits,
+    releaseType,
+    preid: config.bump.preid,
+    types: config.types,
+    force
+  });
+}
+async function getPackages({
+  patterns,
+  config,
+  suffix,
+  force
+}) {
+  const readedPackages = readPackages({
+    cwd: config.cwd,
+    patterns,
+    ignorePackageNames: config.monorepo?.ignorePackageNames
+  });
+  const packages = /* @__PURE__ */ new Map();
+  const foundPaths = /* @__PURE__ */ new Set();
+  const patternsSet = new Set(patterns);
+  if (!patterns)
+    patternsSet.add(".");
+  logger.debug(`Getting packages from patterns: ${patternsSet.values()}`);
+  for (const pattern of patternsSet) {
+    const matches = fastGlob.sync(pattern, {
+      cwd: config.cwd,
+      onlyDirectories: true,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+    });
+    for (const matchPath of matches) {
+      if (foundPaths.has(matchPath))
+        continue;
+      const packageBase = readPackageJson(matchPath);
+      if (!packageBase) {
+        logger.debug(`Failed to read package.json at ${matchPath} - ignored`);
         continue;
       }
-      if ((pattern === "lerna.json" || pattern === "CHANGELOG.md") && !existsSync(join(internalConfig.cwd, pattern))) {
-        logger.verbose(`Skipping ${pattern} as it doesn't exist`);
+      if (packageBase.private) {
+        logger.debug(`${packageBase.name} is private and will be ignored`);
         continue;
       }
-      if (dryRun) {
-        logger.info(`[dry-run] git add ${pattern}`);
+      if (config.monorepo?.ignorePackageNames?.includes(packageBase.name)) {
+        logger.debug(`${packageBase.name} ignored by config (monorepo.ignorePackageNames)`);
         continue;
       }
-      try {
-        logger.debug(`git add ${pattern}`);
-        execSync(`git add ${pattern}`);
-      } catch {
+      if (!packageBase.version) {
+        logger.warn(`${packageBase.name} has no version and will be ignored`);
+        continue;
       }
-    }
-    const rootPackage = readPackageJson(internalConfig.cwd);
-    if (!rootPackage) {
-      throw new Error("Failed to read root package.json");
-    }
-    newVersion = newVersion || rootPackage.version;
-    const versionForMessage = internalConfig.monorepo?.versionMode === "independent" ? bumpedPackages?.map((pkg) => getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version })).join(", ") || "unknown" : newVersion || "unknown";
-    const commitMessage = internalConfig.templates.commitMessage?.replaceAll("{{newVersion}}", versionForMessage) || `chore(release): bump version to ${versionForMessage}`;
-    const noVerifyFlag = noVerify ? "--no-verify " : "";
-    logger.debug(`No verify: ${noVerify}`);
-    if (dryRun) {
-      logger.info(`[dry-run] git commit ${noVerifyFlag}-m "${commitMessage}"`);
-    } else {
-      logger.debug(`Executing: git commit ${noVerifyFlag}-m "${commitMessage}"`);
-      await execPromise(`git commit ${noVerifyFlag}-m "${commitMessage}"`, {
-        logLevel,
-        noStderr: true,
-        noStdout: true,
-        cwd: internalConfig.cwd
+      const { from, to } = await resolveTags({
+        config,
+        step: "bump",
+        pkg: packageBase,
+        newVersion: void 0
+      });
+      const commits = await getPackageCommits({
+        pkg: packageBase,
+        from,
+        to,
+        config,
+        changelog: false
+      });
+      foundPaths.add(matchPath);
+      const dependencies = getPackageDependencies({
+        packagePath: matchPath,
+        allPackageNames: new Set(readedPackages.map((p) => p.name)),
+        dependencyTypes: config.bump?.dependencyTypes
+      });
+      packages.set(packageBase.name, {
+        ...packageBase,
+        path: matchPath,
+        fromTag: from,
+        dependencies,
+        commits,
+        reason: commits.length > 0 ? "commits" : void 0,
+        dependencyChain: void 0,
+        newVersion: void 0
       });
-      logger.success(`Committed: ${commitMessage}${noVerify ? " (--no-verify)" : ""}`);
-    }
-    const signTags = internalConfig.signTags ? "-s" : "";
-    logger.debug(`Sign tags: ${internalConfig.signTags}`);
-    const createdTags = [];
-    if (internalConfig.monorepo?.versionMode === "independent" && bumpedPackages && bumpedPackages.length > 0 && internalConfig.release.gitTag) {
-      logger.debug(`Creating ${bumpedPackages.length} independent package tags`);
-      for (const pkg of bumpedPackages) {
-        if (!pkg.newVersion) {
-          continue;
-        }
-        const tagName = getIndependentTag({ version: pkg.newVersion, name: pkg.name });
-        const tagMessage = internalConfig.templates?.tagMessage?.replaceAll("{{newVersion}}", pkg.newVersion) || tagName;
-        if (dryRun) {
-          logger.info(`[dry-run] git tag ${signTags} -a ${tagName} -m "${tagMessage}"`);
-        } else {
-          const cmd = `git tag ${signTags} -a ${tagName} -m "${tagMessage}"`;
-          logger.debug(`Executing: ${cmd}`);
-          try {
-            await execPromise(cmd, {
-              logLevel,
-              noStderr: true,
-              noStdout: true,
-              cwd: internalConfig.cwd
-            });
-            logger.debug(`Tag created: ${tagName}`);
-          } catch (error) {
-            logger.error(`Failed to create tag ${tagName}:`, error);
-            throw error;
-          }
-        }
-        createdTags.push(tagName);
-      }
-      logger.success(`Created ${createdTags.length} tags for independent packages, ${createdTags.join(", ")}`);
-    } else if (internalConfig.release.gitTag) {
-      const tagName = internalConfig.templates.tagBody?.replaceAll("{{newVersion}}", newVersion);
-      const tagMessage = internalConfig.templates?.tagMessage?.replaceAll("{{newVersion}}", newVersion) || tagName;
-      if (dryRun) {
-        logger.info(`[dry-run] git tag ${signTags} -a ${tagName} -m "${tagMessage}"`);
-      } else {
-        const cmd = `git tag ${signTags} -a ${tagName} -m "${tagMessage}"`;
-        logger.debug(`Executing: ${cmd}`);
-        try {
-          await execPromise(cmd, {
-            logLevel,
-            noStderr: true,
-            noStdout: true,
-            cwd: internalConfig.cwd
-          });
-          logger.debug(`Tag created: ${tagName}`);
-        } catch (error) {
-          logger.error(`Failed to create tag ${tagName}:`, error);
-          throw error;
-        }
-      }
-      createdTags.push(tagName);
     }
-    logger.debug("Created Tags:", createdTags.join(", "));
-    logger.success("Commit and tag completed!");
-    await executeHook("success:commit-and-tag", internalConfig, dryRun ?? false);
-    return createdTags;
-  } catch (error) {
-    logger.error("Error committing and tagging:", error);
-    await executeHook("error:commit-and-tag", internalConfig, dryRun ?? false);
-    throw error;
-  }
-}
-async function pushCommitAndTags({ config, dryRun, logLevel, cwd }) {
-  logger.start("Start push changes and tags");
-  const command = config.release.gitTag ? "git push --follow-tags" : "git push";
-  if (dryRun) {
-    logger.info(`[dry-run] ${command}`);
-  } else {
-    logger.debug(`Executing: ${command}`);
-    await execPromise(command, { noStderr: true, noStdout: true, logLevel, cwd });
   }
-  logger.success("Pushing changes and tags completed!");
-}
-function getFirstCommit(cwd) {
-  const result = execSync(
-    "git rev-list --max-parents=0 HEAD",
-    {
-      cwd,
-      encoding: "utf8"
-    }
-  );
-  return result.trim();
-}
-function getCurrentGitBranch(cwd) {
-  const result = execSync("git rev-parse --abbrev-ref HEAD", {
-    cwd,
-    encoding: "utf8"
+  const packagesArray = Array.from(packages.values());
+  const packagesWithCommits = packagesArray.filter((p) => p.commits.length > 0);
+  const expandedPackages = expandPackagesToBumpWithDependents({
+    allPackages: packagesArray,
+    packagesWithCommits
   });
-  return result.trim();
+  for (const pkg of expandedPackages) {
+    packages.set(pkg.name, pkg);
+  }
+  for (const pkg of Array.from(packages.values())) {
+    const releaseType = getPackageReleaseType({
+      pkg,
+      config,
+      force
+    });
+    const newVersion = releaseType ? getPackageNewVersion({
+      currentVersion: pkg.version,
+      releaseType,
+      preid: config.bump.preid,
+      suffix
+    }) : void 0;
+    const graduating = releaseType && isGraduating(pkg.version, releaseType) || isChangedPreid(pkg.version, config.bump.preid);
+    packages.set(pkg.name, {
+      ...pkg,
+      newVersion,
+      reason: pkg.reason || releaseType && graduating && "graduation" || void 0
+    });
+  }
+  const packagesToBump = Array.from(packages.values()).filter((p) => p.reason || force);
+  if (packagesToBump.length === 0) {
+    logger.debug("No packages to bump");
+    return [];
+  }
+  return packagesToBump;
 }
-function getCurrentGitRef(cwd) {
-  const branch = getCurrentGitBranch(cwd);
-  return branch || "HEAD";
+function isAllowedCommit({
+  commit,
+  type,
+  changelog
+}) {
+  if (commit.type === "chore" && ["deps", "release"].includes(commit.scope) && !commit.isBreaking) {
+    return false;
+  }
+  if (typeof type === "object") {
+    return !!type.semver || changelog && !!type.title;
+  }
+  if (typeof type === "boolean") {
+    return type;
+  }
+  return false;
 }
-
-async function generateMarkDown({
-  commits,
-  config,
+async function getPackageCommits({
+  pkg,
   from,
   to,
-  isFirstCommit
+  config,
+  changelog
 }) {
-  const typeGroups = groupBy(commits, "type");
-  const markdown = [];
-  const breakingChanges = [];
-  const updatedConfig = {
+  logger.debug(`Analyzing commits for ${pkg.name} since ${from} to ${to}`);
+  const changelogConfig = {
     ...config,
     from,
     to
   };
-  const versionTitle = updatedConfig.to;
-  const changelogTitle = `${updatedConfig.from}...${updatedConfig.to}`;
-  markdown.push("", `## ${changelogTitle}`, "");
-  if (updatedConfig.repo && updatedConfig.from && versionTitle) {
-    const formattedCompareLink = formatCompareChanges(versionTitle, {
-      ...updatedConfig,
-      from: isFirstCommit ? getFirstCommit(updatedConfig.cwd) : updatedConfig.from
-    });
-    markdown.push(formattedCompareLink);
+  const rawCommits = await getGitDiff(from, to, changelogConfig.cwd);
+  const allCommits = parseCommits(rawCommits, changelogConfig);
+  const hasBreakingChanges = allCommits.some((commit) => commit.isBreaking);
+  logger.debug(`Has breaking changes: ${hasBreakingChanges}`);
+  const rootPackage = readPackageJson(changelogConfig.cwd);
+  if (!rootPackage) {
+    throw new Error("Failed to read root package.json");
   }
-  for (const type in updatedConfig.types) {
-    const group = typeGroups[type];
-    if (!group || group.length === 0) {
-      continue;
-    }
-    if (typeof updatedConfig.types[type] === "boolean") {
-      continue;
+  const commits = allCommits.filter((commit) => {
+    const type = changelogConfig?.types[commit.type];
+    if (!isAllowedCommit({ commit, type, changelog })) {
+      return false;
     }
-    markdown.push("", `### ${updatedConfig.types[type]?.title}`, "");
-    for (const commit of group.reverse()) {
-      const line = formatCommit(commit, updatedConfig);
-      markdown.push(line);
-      if (commit.isBreaking) {
-        breakingChanges.push(line);
-      }
+    if (pkg.path === changelogConfig.cwd || pkg.name === rootPackage.name) {
+      return true;
     }
+    const packageRelativePath = relative(changelogConfig.cwd, pkg.path);
+    const scopeMatches = commit.scope === pkg.name;
+    const bodyContainsPath = commit.body.includes(packageRelativePath);
+    return scopeMatches || bodyContainsPath;
+  });
+  logger.debug(`Found ${commits.length} commit(s) for ${pkg.name} from ${from} to ${to}`);
+  if (commits.length > 0) {
+    logger.debug(`${pkg.name}: ${commits.length} commit(s) found`);
+  } else {
+    logger.debug(`${pkg.name}: No commits found`);
   }
-  if (breakingChanges.length > 0) {
-    markdown.push("", "#### \u26A0\uFE0F Breaking Changes", "", ...breakingChanges);
+  return commits;
+}
+function hasLernaJson(rootDir) {
+  const lernaJsonPath = join(rootDir, "lerna.json");
+  return existsSync(lernaJsonPath);
+}
+
+async function executeHook(hook, config, dryRun, params) {
+  const hookInput = config.hooks?.[hook];
+  if (!hookInput) {
+    logger.debug(`Hook ${hook} not found`);
+    return;
   }
-  const _authors = /* @__PURE__ */ new Map();
-  for (const commit of commits) {
-    if (!commit.author) {
-      continue;
-    }
-    const name = formatName(commit.author.name);
-    if (!name || name.includes("[bot]")) {
-      continue;
-    }
-    if (updatedConfig.excludeAuthors && updatedConfig.excludeAuthors.some(
-      (v) => name.includes(v) || commit.author.email?.includes(v)
-    )) {
-      continue;
-    }
-    if (_authors.has(name)) {
-      const entry = _authors.get(name);
-      entry?.email.add(commit.author.email);
-    } else {
-      _authors.set(name, { email: /* @__PURE__ */ new Set([commit.author.email]), name });
-    }
-  }
-  if (updatedConfig.repo?.provider === "github") {
-    await Promise.all(
-      [..._authors.keys()].map(async (authorName) => {
-        const meta = _authors.get(authorName);
-        if (!meta) {
-          return;
-        }
-        for (const data of [...meta.email, meta.name]) {
-          const { user } = await fetch$1(`https://ungh.cc/users/find/${data}`).then((r) => r.json()).catch(() => ({ user: null }));
-          if (user) {
-            meta.github = user.username;
-            break;
-          }
-        }
-      })
-    );
+  if (typeof hookInput === "function") {
+    logger.info(`Executing hook ${hook}`);
+    const result = await hookInput(config, dryRun, params);
+    if (result)
+      logger.debug(`Hook ${hook} returned: ${result}`);
+    logger.info(`Hook ${hook} executed`);
+    return result;
   }
-  const authors = [..._authors.entries()].map((e) => ({
-    name: e[0],
-    ...e[1]
-  }));
-  if (authors.length > 0 && !updatedConfig.noAuthors) {
-    markdown.push(
-      "",
-      "### \u2764\uFE0F Contributors",
-      "",
-      ...authors.map((i) => {
-        const _email = [...i.email].find(
-          (e) => !e.includes("noreply.github.com")
-        );
-        const email = updatedConfig.hideAuthorEmail !== true && _email ? ` <${_email}>` : "";
-        const github = i.github ? ` ([@${i.github}](https://github.com/${i.github}))` : "";
-        return `- ${i.name}${github || email || ""}`;
-      })
-    );
+  if (typeof hookInput === "string") {
+    logger.info(`Executing hook ${hook}`);
+    const result = await execPromise(hookInput, {
+      logLevel: config.logLevel,
+      cwd: config.cwd,
+      noStderr: true,
+      noStdout: true
+    });
+    if (result)
+      logger.debug(`Hook ${hook} returned: ${result}`);
+    logger.info(`Hook ${hook} executed`);
+    return result;
   }
-  const result = convert(markdown.join("\n").trim(), true);
-  return result;
 }
-function getCommitBody(commit) {
-  if (!commit.body) {
-    return "";
-  }
-  const lines = commit.body.split("\n");
-  const contentLines = lines.filter((line) => {
-    const trimmedLine = line.trim();
-    if (!trimmedLine) {
-      return false;
-    }
-    const isFileLine = /^[AMDTUXB](?:\d{3})?\s+/.test(trimmedLine) || /^[RCM]\d{3}\s+/.test(trimmedLine);
-    return !isFileLine;
-  });
-  if (contentLines.length === 0) {
-    return "";
-  }
-  const indentedBody = contentLines.map((line) => `  ${line}`).join("\n");
-  return `
-
-${indentedBody}
-`;
+function isInCI() {
+  return Boolean(
+    process.env.CI === "true" || process.env.CONTINUOUS_INTEGRATION === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.GITHUB_WORKFLOW || process.env.GITLAB_CI === "true" || process.env.CIRCLECI === "true" || process.env.TRAVIS === "true" || process.env.JENKINS_HOME || process.env.JENKINS_URL || process.env.BUILD_ID || process.env.TF_BUILD === "True" || process.env.AZURE_PIPELINES === "true" || process.env.TEAMCITY_VERSION || process.env.BITBUCKET_BUILD_NUMBER || process.env.DRONE === "true" || process.env.APPVEYOR === "True" || process.env.APPVEYOR === "true" || process.env.BUILDKITE === "true" || process.env.CODEBUILD_BUILD_ID || process.env.NETLIFY === "true" || process.env.VERCEL === "1" || process.env.HEROKU_TEST_RUN_ID || process.env.BUDDY === "true" || process.env.SEMAPHORE === "true" || process.env.CF_BUILD_ID || process.env.bamboo_buildKey || process.env.BUILD_ID && process.env.PROJECT_ID || process.env.SCREWDRIVER === "true" || process.env.STRIDER === "true"
+  );
 }
-function formatCommit(commit, config) {
-  const body = config.changelog.includeCommitBody ? getCommitBody(commit) : "";
-  return `- ${commit.scope ? `**${commit.scope.trim()}:** ` : ""}${commit.isBreaking ? "\u26A0\uFE0F  " : ""}${upperFirst(commit.description)}${formatReferences(commit.references, config)}${body}`;
+function getCIName() {
+  if (process.env.GITHUB_ACTIONS === "true")
+    return "GitHub Actions";
+  if (process.env.GITLAB_CI === "true")
+    return "GitLab CI";
+  if (process.env.CIRCLECI === "true")
+    return "CircleCI";
+  if (process.env.TRAVIS === "true")
+    return "Travis CI";
+  if (process.env.JENKINS_HOME || process.env.JENKINS_URL)
+    return "Jenkins";
+  if (process.env.TF_BUILD === "True")
+    return "Azure Pipelines";
+  if (process.env.TEAMCITY_VERSION)
+    return "TeamCity";
+  if (process.env.BITBUCKET_BUILD_NUMBER)
+    return "Bitbucket Pipelines";
+  if (process.env.DRONE === "true")
+    return "Drone";
+  if (process.env.APPVEYOR)
+    return "AppVeyor";
+  if (process.env.BUILDKITE === "true")
+    return "Buildkite";
+  if (process.env.CODEBUILD_BUILD_ID)
+    return "AWS CodeBuild";
+  if (process.env.NETLIFY === "true")
+    return "Netlify";
+  if (process.env.VERCEL === "1")
+    return "Vercel";
+  if (process.env.HEROKU_TEST_RUN_ID)
+    return "Heroku CI";
+  if (process.env.BUDDY === "true")
+    return "Buddy";
+  if (process.env.SEMAPHORE === "true")
+    return "Semaphore";
+  if (process.env.CF_BUILD_ID)
+    return "Codefresh";
+  if (process.env.bamboo_buildKey)
+    return "Bamboo";
+  if (process.env.BUILD_ID && process.env.PROJECT_ID)
+    return "Google Cloud Build";
+  if (process.env.SCREWDRIVER === "true")
+    return "Screwdriver";
+  if (process.env.STRIDER === "true")
+    return "Strider";
+  if (process.env.CI === "true")
+    return "Unknown CI";
+  return null;
 }
-function formatReferences(references, config) {
-  const pr = references.filter((ref) => ref.type === "pull-request");
-  const issue = references.filter((ref) => ref.type === "issue");
-  if (pr.length > 0 || issue.length > 0) {
-    return ` (${[...pr, ...issue].map((ref) => formatReference(ref, config.repo)).join(", ")})`;
-  }
-  if (references.length > 0) {
-    return ` (${formatReference(references[0], config.repo)})`;
+async function executeFormatCmd({
+  config,
+  dryRun
+}) {
+  if (config.changelog?.formatCmd) {
+    logger.info("Running format command");
+    logger.debug(`Running format command: ${config.changelog.formatCmd}`);
+    try {
+      if (!dryRun) {
+        await execPromise(config.changelog.formatCmd, {
+          noStderr: true,
+          noStdout: true,
+          logLevel: config.logLevel,
+          cwd: config.cwd
+        });
+        logger.info("Format completed");
+      } else {
+        logger.log("[dry-run] exec format command: ", config.changelog.formatCmd);
+      }
+    } catch (error) {
+      throw new Error(`Format command failed: ${error}`);
+    }
+  } else {
+    logger.debug("No format command specified");
   }
-  return "";
-}
-function formatName(name = "") {
-  return name.split(" ").map((p) => upperFirst(p.trim())).join(" ");
 }
-function groupBy(items, key) {
-  const groups = {};
-  for (const item of items) {
-    groups[item[key]] = groups[item[key]] || [];
-    groups[item[key]]?.push(item);
+async function executeBuildCmd({
+  config,
+  dryRun
+}) {
+  if (config.publish?.buildCmd) {
+    logger.info("Running build command");
+    logger.debug(`Running build command: ${config.publish.buildCmd}`);
+    if (!dryRun) {
+      await execPromise(config.publish.buildCmd, {
+        noStderr: true,
+        noStdout: true,
+        logLevel: config.logLevel,
+        cwd: config.cwd
+      });
+      logger.info("Build completed");
+    } else {
+      logger.log("[dry-run] exec build command: ", config.publish.buildCmd);
+    }
+  } else {
+    logger.debug("No build command specified");
   }
-  return groups;
 }
-
-function fromTagIsFirstCommit(fromTag, cwd) {
-  return fromTag === getFirstCommit(cwd);
+function isBumpedPackage(pkg) {
+  return "oldVersion" in pkg && !!pkg.oldVersion;
 }
-async function generateChangelog({
-  pkg,
+async function getPackagesOrBumpedPackages({
   config,
-  dryRun,
-  newVersion
+  bumpResult,
+  suffix,
+  force
 }) {
-  let fromTag = config.from || pkg.fromTag || getFirstCommit(config.cwd);
-  const isFirstCommit = fromTagIsFirstCommit(fromTag, config.cwd);
-  if (isFirstCommit) {
-    fromTag = config.monorepo?.versionMode === "independent" ? getIndependentTag({ version: "0.0.0", name: pkg.name }) : config.templates.tagBody.replace("{{newVersion}}", "0.0.0");
-  }
-  newVersion = newVersion || pkg.newVersion;
-  let toTag = config.to;
-  if (!toTag && newVersion) {
-    toTag = config.monorepo?.versionMode === "independent" ? getIndependentTag({ version: newVersion, name: pkg.name }) : config.templates.tagBody.replace("{{newVersion}}", newVersion);
+  if (bumpResult?.bumpedPackages && bumpResult.bumpedPackages.length > 0) {
+    return bumpResult.bumpedPackages;
   }
-  if (!toTag) {
-    throw new Error(`No tag found for ${pkg.name}`);
+  return await getPackages({
+    config,
+    patterns: config.monorepo?.packages,
+    suffix,
+    force
+  });
+}
+
+function getGitStatus(cwd) {
+  return execSync("git status --porcelain", {
+    cwd,
+    encoding: "utf8"
+  }).trim();
+}
+function checkGitStatusIfDirty() {
+  logger.debug("Checking git status");
+  const dirty = getGitStatus();
+  if (dirty) {
+    logger.debug("git status:", `
+${dirty.trim().split("\n").map((line) => line.trim()).join("\n")}`);
+    const error = `Git status is dirty!
+
+Please commit or stash your changes before bumping or use --no-clean flag. 
+
+Unstaged files:
+
+ ${dirty.trim()}`;
+    throw new Error(error);
   }
-  logger.debug(`Generating changelog for ${pkg.name} - from ${fromTag} to ${toTag}`);
+}
+async function fetchGitTags(cwd) {
+  logger.debug("Fetching git tags from remote");
   try {
-    config = {
-      ...config,
-      from: fromTag,
-      to: toTag
-    };
-    const generatedChangelog = await generateMarkDown({
-      commits: pkg.commits,
-      config,
-      from: fromTag,
-      isFirstCommit,
-      to: toTag
-    });
-    let changelog = generatedChangelog;
-    if (pkg.commits.length === 0) {
-      changelog = `${changelog}
-
-${config.templates.emptyChangelogContent}`;
-    }
-    const changelogResult = await executeHook("generate:changelog", config, dryRun, {
-      commits: pkg.commits,
-      changelog
-    });
-    changelog = changelogResult || changelog;
-    logger.verbose(`Output changelog for ${pkg.name}:
-${changelog}`);
-    logger.debug(`Changelog generated for ${pkg.name} (${pkg.commits.length} commits)`);
-    logger.verbose(`Final changelog for ${pkg.name}:
-
-${changelog}
-
-`);
-    if (dryRun) {
-      logger.info(`[dry-run] ${pkg.name} - Generate changelog ${fromTag}...${toTag}`);
-    }
-    return changelog;
-  } catch (error) {
-    throw new Error(`Error generating changelog for ${pkg.name} (${fromTag}...${toTag}): ${error}`);
-  }
-}
-function writeChangelogToFile({
-  cwd,
-  pkg,
-  changelog,
-  dryRun = false
-}) {
-  const changelogPath = join(pkg.path, "CHANGELOG.md");
-  let existingChangelog = "";
-  if (existsSync(changelogPath)) {
-    existingChangelog = readFileSync(changelogPath, "utf8");
-  }
-  const lines = existingChangelog.split("\n");
-  const titleIndex = lines.findIndex((line) => line.startsWith("# "));
-  let updatedChangelog;
-  if (titleIndex !== -1) {
-    const beforeTitle = lines.slice(0, titleIndex + 1);
-    const afterTitle = lines.slice(titleIndex + 1);
-    updatedChangelog = [...beforeTitle, "", changelog, "", ...afterTitle].join("\n");
-  } else {
-    const title = "# Changelog\n";
-    updatedChangelog = `${title}
-${changelog}
-${existingChangelog}`;
-  }
-  if (dryRun) {
-    const relativeChangelogPath = relative(cwd, changelogPath);
-    logger.info(`[dry-run] ${pkg.name} - Write changelog to ${relativeChangelogPath}`);
-  } else {
-    logger.debug(`Writing changelog to ${changelogPath}`);
-    writeFileSync(changelogPath, updatedChangelog, "utf8");
-    logger.info(`Changelog updated for ${pkg.name} (${"newVersion" in pkg && pkg.newVersion || pkg.version})`);
-  }
-}
-
-function getDefaultConfig() {
-  return {
-    cwd: process$1.cwd(),
-    types: {
-      feat: { title: "\u{1F680} Enhancements", semver: "minor" },
-      perf: { title: "\u{1F525} Performance", semver: "patch" },
-      fix: { title: "\u{1FA79} Fixes", semver: "patch" },
-      refactor: { title: "\u{1F485} Refactors", semver: "patch" },
-      docs: { title: "\u{1F4D6} Documentation", semver: "patch" },
-      build: { title: "\u{1F4E6} Build", semver: "patch" },
-      types: { title: "\u{1F30A} Types", semver: "patch" },
-      chore: { title: "\u{1F3E1} Chore" },
-      examples: { title: "\u{1F3C0} Examples" },
-      test: { title: "\u2705 Tests" },
-      style: { title: "\u{1F3A8} Styles" },
-      ci: { title: "\u{1F916} CI" }
-    },
-    templates: {
-      commitMessage: "chore(release): bump version to {{newVersion}}",
-      tagMessage: "Bump version to {{newVersion}}",
-      tagBody: "v{{newVersion}}",
-      emptyChangelogContent: "No relevant changes for this release"
-    },
-    excludeAuthors: [],
-    noAuthors: false,
-    bump: {
-      type: "release",
-      clean: true,
-      dependencyTypes: ["dependencies"],
-      yes: false
-    },
-    changelog: {
-      rootChangelog: true,
-      includeCommitBody: true
-    },
-    publish: {
-      private: false,
-      args: []
-    },
-    tokens: {
-      gitlab: process$1.env.RELIZY_GITLAB_TOKEN || process$1.env.GITLAB_TOKEN || process$1.env.GITLAB_API_TOKEN || process$1.env.CI_JOB_TOKEN,
-      github: process$1.env.RELIZY_GITHUB_TOKEN || process$1.env.GITHUB_TOKEN || process$1.env.GH_TOKEN
-    },
-    scopeMap: {},
-    release: {
-      commit: true,
-      publish: true,
-      changelog: true,
-      push: true,
-      clean: true,
-      providerRelease: true,
-      noVerify: false
-    },
-    logLevel: "default",
-    safetyCheck: true
-  };
-}
-function setupLogger(logLevel) {
-  if (logLevel) {
-    logger.setLevel(logLevel);
-    logger.debug(`Log level set to: ${logLevel}`);
-  }
-}
-async function resolveConfig(config, cwd) {
-  if (!config.repo) {
-    const resolvedRepoConfig = await resolveRepoConfig(cwd);
-    config.repo = {
-      ...resolvedRepoConfig,
-      provider: resolvedRepoConfig.provider
-    };
-  }
-  if (typeof config.repo === "string") {
-    const resolvedRepoConfig = getRepoConfig(config.repo);
-    config.repo = {
-      ...resolvedRepoConfig,
-      provider: resolvedRepoConfig.provider
-    };
-  }
-  return config;
-}
-async function loadRelizyConfig(options) {
-  const cwd = options?.overrides?.cwd ?? process$1.cwd();
-  const configName = options?.configName ?? "relizy";
-  await setupDotenv({ cwd });
-  const defaultConfig = getDefaultConfig();
-  const overridesConfig = defu(options?.overrides, options?.baseConfig);
-  const results = await loadConfig({
-    cwd,
-    name: configName,
-    packageJson: true,
-    defaults: defaultConfig,
-    overrides: overridesConfig
-  });
-  if (!results._configFile) {
-    logger.debug(`No config file found with name "${configName}" - using standalone mode`);
-    if (options?.configName) {
-      logger.error(`No config file found with name "${configName}"`);
-      process$1.exit(1);
-    }
-  }
-  setupLogger(options?.overrides?.logLevel || results.config.logLevel);
-  logger.verbose("User config:", formatJson(results.config.changelog));
-  const resolvedConfig = await resolveConfig(results.config, cwd);
-  logger.debug("Resolved config:", formatJson(resolvedConfig));
-  return resolvedConfig;
-}
-function defineConfig(config) {
-  return config;
-}
-
-function getPackageDependencies({
-  packagePath,
-  allPackageNames,
-  dependencyTypes
-}) {
-  const packageJsonPath = join(packagePath, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return [];
-  }
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-  const deps = [];
-  const allDeps = {
-    ...dependencyTypes?.includes("dependencies") ? packageJson.dependencies : {},
-    ...dependencyTypes?.includes("peerDependencies") ? packageJson.peerDependencies : {},
-    ...dependencyTypes?.includes("devDependencies") ? packageJson.devDependencies : {}
-  };
-  for (const depName of Object.keys(allDeps)) {
-    if (allPackageNames.has(depName)) {
-      deps.push(depName);
-    }
-  }
-  return deps;
-}
-function getDependentsOf({
-  allPackages,
-  packageName
-}) {
-  return allPackages.filter(
-    (pkg) => pkg.dependencies.includes(packageName)
-  );
-}
-function expandPackagesToBumpWithDependents({
-  allPackages,
-  packagesWithCommits
-}) {
-  const result = /* @__PURE__ */ new Map();
-  logger.debug(`Expanding packages to bump: ${packagesWithCommits.length} packages with commits, ${allPackages.length} total packages`);
-  for (const pkg of packagesWithCommits) {
-    const packageToBump = {
-      ...pkg,
-      reason: "commits"
-    };
-    result.set(pkg.name, packageToBump);
-  }
-  const toProcess = [...packagesWithCommits.map((p) => p.name)];
-  const processed = /* @__PURE__ */ new Set();
-  while (toProcess.length > 0) {
-    const currentPkgName = toProcess.shift();
-    if (!currentPkgName || processed.has(currentPkgName)) {
-      continue;
-    }
-    processed.add(currentPkgName);
-    const dependents = getDependentsOf({
-      packageName: currentPkgName,
-      allPackages
-    });
-    for (const dependent of dependents) {
-      if (!result.has(dependent.name)) {
-        const currentChain = result.get(currentPkgName)?.dependencyChain || [];
-        const chain = [...currentChain, currentPkgName];
-        const packageBase = allPackages.find((p) => p.name === dependent.name);
-        if (packageBase) {
-          const packageToBump = {
-            ...packageBase,
-            reason: "dependency",
-            dependencyChain: chain
-          };
-          result.set(dependent.name, packageToBump);
-          toProcess.push(dependent.name);
-          logger.debug(`${dependent.name} will be bumped (depends on ${chain.join(" \u2192 ")})`);
-        }
-      }
-    }
-  }
-  return Array.from(result.values());
-}
-function topologicalSort(packages) {
-  const sorted = [];
-  const visited = /* @__PURE__ */ new Set();
-  const visiting = /* @__PURE__ */ new Set();
-  const packageMap = /* @__PURE__ */ new Map();
-  for (const pkg of packages) {
-    packageMap.set(pkg.name, pkg);
-  }
-  function visit(pkgName, path = []) {
-    logger.debug(`Visiting ${pkgName}, path: ${path.join(" \u2192 ")}, visiting: ${Array.from(visiting).join(", ")}`);
-    if (visiting.has(pkgName)) {
-      const cycle = [...path, pkgName];
-      logger.warn(`Circular dependency detected: ${cycle.join(" \u2192 ")}`);
-      return;
-    }
-    if (visited.has(pkgName)) {
-      logger.debug(`${pkgName} already visited globally, skipping`);
-      return;
-    }
-    visiting.add(pkgName);
-    logger.debug(`Added ${pkgName} to visiting set`);
-    const pkg = packageMap.get(pkgName);
-    if (!pkg) {
-      logger.debug(`Package ${pkgName} not found in packageMap`);
-      visiting.delete(pkgName);
-      return;
-    }
-    logger.debug(`${pkgName} has dependencies: ${pkg.dependencies.join(", ")}`);
-    for (const depName of pkg.dependencies) {
-      visit(depName, [...path, pkgName]);
-    }
-    visiting.delete(pkgName);
-    visited.add(pkgName);
-    sorted.push(pkg);
-    logger.debug(`Finished visiting ${pkgName}`);
-  }
-  for (const pkg of packages) {
-    visit(pkg.name);
-  }
-  return sorted;
-}
-
-async function githubIndependentMode({
-  config,
-  dryRun,
-  bumpResult,
-  force,
-  suffix
-}) {
-  const repoConfig = config.repo;
-  if (!repoConfig) {
-    throw new Error("No repository configuration found. Please check your changelog config.");
-  }
-  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  if (!config.tokens.github && !config.repo?.token) {
-    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
-  }
-  const packages = bumpResult?.bumped && bumpResult?.bumpedPackages || await getPackages({
-    suffix,
-    patterns: config.monorepo?.packages,
-    config,
-    force
-  });
-  logger.info(`Creating ${packages.length} GitHub release(s)`);
-  const postedReleases = [];
-  for (const pkg of packages) {
-    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
-    const from = config.from || pkg.fromTag;
-    const to = config.to || getIndependentTag({ version: newVersion, name: pkg.name });
-    if (!from) {
-      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
-      continue;
-    }
-    const toTag = dryRun ? "HEAD" : to;
-    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${toTag}`);
-    const changelog = await generateChangelog({
-      pkg,
-      config,
-      dryRun,
-      newVersion
-    });
-    const releaseBody = changelog.split("\n").slice(2).join("\n");
-    const release = {
-      tag_name: to,
-      name: to,
-      body: releaseBody,
-      prerelease: isPrerelease(newVersion)
-    };
-    logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
-    if (dryRun) {
-      logger.info(`[dry-run] Publish GitHub release for ${to}`);
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: release.prerelease
-      });
-    } else {
-      logger.debug(`Publishing release ${to} to GitHub...`);
-      await createGithubRelease({
-        ...config,
-        from,
-        to,
-        repo: repoConfig
-      }, release);
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: release.prerelease
-      });
-    }
-  }
-  if (postedReleases.length === 0) {
-    logger.warn("No releases created");
-  } else {
-    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitHub!`);
-  }
-  return postedReleases;
-}
-async function githubUnified({
-  config,
-  dryRun,
-  rootPackage,
-  bumpResult
-}) {
-  const repoConfig = config.repo;
-  if (!repoConfig) {
-    throw new Error("No repository configuration found. Please check your changelog config.");
-  }
-  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  if (!config.tokens.github && !config.repo?.token) {
-    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
-  }
-  const to = config.to || config.templates.tagBody.replace("{{newVersion}}", bumpResult?.bumped && bumpResult.newVersion || rootPackage.version);
-  const changelog = await generateChangelog({
-    pkg: rootPackage,
-    config,
-    dryRun,
-    newVersion: bumpResult?.newVersion || rootPackage.version
-  });
-  const releaseBody = changelog.split("\n").slice(2).join("\n");
-  const release = {
-    tag_name: to,
-    name: to,
-    body: releaseBody,
-    prerelease: isPrerelease(to)
-  };
-  logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
-  logger.debug("Release details:", formatJson({
-    tag_name: release.tag_name,
-    name: release.name,
-    prerelease: release.prerelease
-  }));
-  if (dryRun) {
-    logger.info("[dry-run] Publish GitHub release for", release.tag_name);
-  } else {
-    logger.debug("Publishing release to GitHub...");
-    await createGithubRelease({
-      ...config,
-      from: bumpResult?.bumped && bumpResult.fromTag || "v0.0.0",
-      to,
-      repo: repoConfig
-    }, release);
-  }
-  logger.success(`Release ${to} published to GitHub!`);
-  return [{
-    name: to,
-    tag: to,
-    version: to,
-    prerelease: release.prerelease
-  }];
-}
-async function github(options) {
-  try {
-    const dryRun = options.dryRun ?? false;
-    logger.debug(`Dry run: ${dryRun}`);
-    const config = await loadRelizyConfig({
-      configName: options.configName,
-      baseConfig: options.config,
-      overrides: {
-        from: options.from,
-        to: options.to,
-        logLevel: options.logLevel,
-        tokens: {
-          github: options.token
-        }
-      }
-    });
-    if (config.monorepo?.versionMode === "independent") {
-      return await githubIndependentMode({
-        config,
-        dryRun,
-        bumpResult: options.bumpResult,
-        force: options.force ?? false,
-        suffix: options.suffix
-      });
-    }
-    const rootPackageBase = readPackageJson(config.cwd);
-    if (!rootPackageBase) {
-      throw new Error("Failed to read root package.json");
-    }
-    const { from, to } = await resolveTags({
-      config,
-      step: "provider-release",
-      newVersion: options.bumpResult?.newVersion || rootPackageBase.version,
-      pkg: rootPackageBase
-    });
-    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
-      config,
-      force: options.force ?? false,
-      suffix: options.suffix,
-      changelog: true,
-      from,
-      to
-    });
-    return await githubUnified({
-      config,
-      dryRun,
-      rootPackage,
-      bumpResult: options.bumpResult
-    });
+    await execPromise("git fetch --tags", { cwd, noStderr: true, noStdout: true, noSuccess: true });
+    logger.debug("Git tags fetched successfully");
   } catch (error) {
-    logger.error("Error publishing GitHub release:", error);
-    throw error;
+    logger.fail("Failed to fetch some git tags from remote (tags might already exist locally)", error);
+    logger.info("Continuing with local tags");
   }
 }
-
-async function createGitlabRelease({
-  config,
-  release,
-  dryRun
-}) {
-  const token = config.tokens.gitlab || config.repo?.token;
-  if (!token && !dryRun) {
-    throw new Error(
-      "No GitLab token found. Set GITLAB_TOKEN or CI_JOB_TOKEN environment variable or configure tokens.gitlab"
-    );
-  }
-  const repoConfig = config.repo?.repo;
-  if (!repoConfig) {
-    throw new Error("No repository URL found in config");
-  }
-  logger.debug(`Parsed repository URL: ${repoConfig}`);
-  const projectPath = encodeURIComponent(repoConfig);
-  const gitlabDomain = config.repo?.domain || "gitlab.com";
-  const apiUrl = `https://${gitlabDomain}/api/v4/projects/${projectPath}/releases`;
-  logger.info(`Creating GitLab release at: ${apiUrl}`);
-  const payload = {
-    tag_name: release.tag_name,
-    name: release.name || release.tag_name,
-    description: release.description || "",
-    ref: release.ref || "main"
-  };
+function detectGitProvider(cwd = process.cwd()) {
   try {
-    if (dryRun) {
-      logger.info("[dry-run] GitLab release:", formatJson(payload));
-      return {
-        tag_name: release.tag_name,
-        name: release.name || release.tag_name,
-        description: release.description || "",
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        released_at: (/* @__PURE__ */ new Date()).toISOString(),
-        _links: {
-          self: `${apiUrl}/${encodeURIComponent(release.tag_name)}`
-        }
-      };
+    const remoteUrl = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf8"
+    }).trim();
+    if (remoteUrl.includes("github.com")) {
+      return "github";
     }
-    logger.debug(`POST GitLab release to ${apiUrl} with payload: ${formatJson(payload)}`);
-    const response = await fetch(apiUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "PRIVATE-TOKEN": token || ""
-      },
-      body: JSON.stringify(payload)
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`GitLab API error (${response.status}): ${errorText}`);
+    if (remoteUrl.includes("gitlab.com") || remoteUrl.includes("gitlab")) {
+      return "gitlab";
     }
-    const result = await response.json();
-    logger.debug(`Created GitLab release: ${result._links.self}`);
-    return result;
-  } catch (error) {
-    logger.error("Failed to create GitLab release:", error);
-    throw error;
+    return null;
+  } catch {
+    return null;
   }
 }
-async function gitlabIndependentMode({
+function parseGitRemoteUrl(remoteUrl) {
+  const sshRegex = /git@[\w.-]+:([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
+  const httpsRegex = /https?:\/\/[\w.-]+\/([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
+  const sshMatch = remoteUrl.match(sshRegex);
+  if (sshMatch) {
+    return {
+      owner: sshMatch[1],
+      repo: sshMatch[2]
+    };
+  }
+  const httpsMatch = remoteUrl.match(httpsRegex);
+  if (httpsMatch) {
+    return {
+      owner: httpsMatch[1],
+      repo: httpsMatch[2]
+    };
+  }
+  return null;
+}
+async function createCommitAndTags({
   config,
+  noVerify,
+  bumpedPackages,
+  newVersion,
   dryRun,
-  bumpResult,
-  suffix,
-  force
+  logLevel
 }) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const packages = bumpResult?.bumped && bumpResult?.bumpedPackages || await getPackages({
-    patterns: config.monorepo?.packages,
-    config,
-    suffix,
-    force
-  });
-  logger.info(`Creating ${packages.length} GitLab release(s) for independent packages`);
-  logger.debug("Getting current branch...");
-  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
-    noSuccess: true,
-    noStdout: true,
-    logLevel: config.logLevel,
-    cwd: config.cwd
-  });
-  const postedReleases = [];
-  for (const pkg of packages) {
-    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
-    const from = config.from || pkg.fromTag;
-    const to = getIndependentTag({ version: newVersion, name: pkg.name });
-    if (!from) {
-      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
-      continue;
+  const internalConfig = config || await loadRelizyConfig();
+  try {
+    await executeHook("before:commit-and-tag", internalConfig, dryRun ?? false);
+    const filePatternsToAdd = [
+      "package.json",
+      "lerna.json",
+      "CHANGELOG.md",
+      "**/CHANGELOG.md",
+      "**/package.json"
+    ];
+    logger.start("Start commit and tag");
+    logger.debug("Adding files to git staging area...");
+    for (const pattern of filePatternsToAdd) {
+      if (pattern === "lerna.json" && !hasLernaJson(internalConfig.cwd)) {
+        logger.verbose(`Skipping lerna.json as it doesn't exist`);
+        continue;
+      }
+      if ((pattern === "lerna.json" || pattern === "CHANGELOG.md") && !existsSync(join(internalConfig.cwd, pattern))) {
+        logger.verbose(`Skipping ${pattern} as it doesn't exist`);
+        continue;
+      }
+      if (dryRun) {
+        logger.info(`[dry-run] git add ${pattern}`);
+        continue;
+      }
+      try {
+        logger.debug(`git add ${pattern}`);
+        execSync(`git add ${pattern}`);
+      } catch {
+      }
     }
-    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${to}`);
-    const changelog = await generateChangelog({
-      pkg,
-      config,
-      dryRun,
-      newVersion
-    });
-    if (!changelog) {
-      logger.warn(`No changelog found for ${pkg.name}`);
-      continue;
+    const rootPackage = readPackageJson(internalConfig.cwd);
+    if (!rootPackage) {
+      throw new Error("Failed to read root package.json");
     }
-    const releaseBody = changelog.split("\n").slice(2).join("\n");
-    const release = {
-      tag_name: to,
-      name: to,
-      description: releaseBody,
-      ref: currentBranch.trim()
-    };
-    logger.debug(`Creating release for ${to} (ref: ${release.ref})`);
+    newVersion = newVersion || rootPackage.version;
+    const versionForMessage = internalConfig.monorepo?.versionMode === "independent" ? bumpedPackages?.map((pkg) => getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version })).join(", ") || "unknown" : newVersion || "unknown";
+    const commitMessage = internalConfig.templates.commitMessage?.replaceAll("{{newVersion}}", versionForMessage) || `chore(release): bump version to ${versionForMessage}`;
+    const noVerifyFlag = noVerify ? "--no-verify " : "";
+    logger.debug(`No verify: ${noVerify}`);
     if (dryRun) {
-      logger.info(`[dry-run] Publish GitLab release for ${to}`);
+      logger.info(`[dry-run] git commit ${noVerifyFlag}-m "${commitMessage}"`);
     } else {
-      logger.debug(`Publishing release ${to} to GitLab...`);
-      await createGitlabRelease({
-        config,
-        release,
-        dryRun
-      });
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: isPrerelease(newVersion)
+      logger.debug(`Executing: git commit ${noVerifyFlag}-m "${commitMessage}"`);
+      await execPromise(`git commit ${noVerifyFlag}-m "${commitMessage}"`, {
+        logLevel,
+        noStderr: true,
+        noStdout: true,
+        cwd: internalConfig.cwd
       });
+      logger.success(`Committed: ${commitMessage}${noVerify ? " (--no-verify)" : ""}`);
     }
-  }
-  if (postedReleases.length === 0) {
-    logger.warn("No releases created");
-  } else {
-    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitLab!`);
-  }
-  return postedReleases;
-}
-async function gitlabUnified({
-  config,
-  dryRun,
-  rootPackage,
-  bumpResult
-}) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const to = config.templates.tagBody.replace("{{newVersion}}", rootPackage.newVersion || rootPackage.version);
-  const changelog = await generateChangelog({
-    pkg: rootPackage,
-    config,
-    dryRun,
-    newVersion: bumpResult?.newVersion || rootPackage.version
-  });
-  const releaseBody = changelog.split("\n").slice(2).join("\n");
-  logger.debug("Getting current branch...");
-  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
-    noSuccess: true,
-    noStdout: true,
-    logLevel: config.logLevel,
-    cwd: config.cwd
-  });
-  const release = {
-    tag_name: to,
-    name: to,
-    description: releaseBody,
-    ref: currentBranch.trim()
-  };
-  logger.info(`Creating release for ${to} (ref: ${release.ref})`);
-  logger.debug("Release details:", formatJson({
-    tag_name: release.tag_name,
-    name: release.name,
-    ref: release.ref
-  }));
-  if (dryRun) {
-    logger.info("[dry-run] Publish GitLab release for", release.tag_name);
-  } else {
-    logger.debug("Publishing release to GitLab...");
-    await createGitlabRelease({
-      config,
-      release,
-      dryRun
-    });
-  }
-  logger.success(`Release ${to} published to GitLab!`);
-  return [{
-    name: to,
-    tag: to,
-    version: to,
-    prerelease: isPrerelease(rootPackage.version)
-  }];
-}
-async function gitlab(options = {}) {
-  try {
-    const dryRun = options.dryRun ?? false;
-    logger.debug(`Dry run: ${dryRun}`);
-    const config = await loadRelizyConfig({
-      configName: options.configName,
-      baseConfig: options.config,
-      overrides: {
-        from: options.from,
-        to: options.to,
-        logLevel: options.logLevel,
-        tokens: {
-          gitlab: options.token
+    const signTags = internalConfig.signTags ? "-s" : "";
+    logger.debug(`Sign tags: ${internalConfig.signTags}`);
+    const createdTags = [];
+    if (internalConfig.monorepo?.versionMode === "independent" && bumpedPackages && bumpedPackages.length > 0 && internalConfig.release.gitTag) {
+      logger.debug(`Creating ${bumpedPackages.length} independent package tags`);
+      for (const pkg of bumpedPackages) {
+        if (!pkg.newVersion) {
+          continue;
+        }
+        const tagName = getIndependentTag({ version: pkg.newVersion, name: pkg.name });
+        const tagMessage = internalConfig.templates?.tagMessage?.replaceAll("{{newVersion}}", pkg.newVersion) || tagName;
+        if (dryRun) {
+          logger.info(`[dry-run] git tag ${signTags} -a ${tagName} -m "${tagMessage}"`);
+        } else {
+          const cmd = `git tag ${signTags} -a ${tagName} -m "${tagMessage}"`;
+          logger.debug(`Executing: ${cmd}`);
+          try {
+            await execPromise(cmd, {
+              logLevel,
+              noStderr: true,
+              noStdout: true,
+              cwd: internalConfig.cwd
+            });
+            logger.debug(`Tag created: ${tagName}`);
+          } catch (error) {
+            logger.error(`Failed to create tag ${tagName}:`, error);
+            throw error;
+          }
         }
+        createdTags.push(tagName);
       }
-    });
-    if (config.monorepo?.versionMode === "independent") {
-      return await gitlabIndependentMode({
-        config,
-        dryRun,
-        bumpResult: options.bumpResult,
-        suffix: options.suffix,
-        force: options.force ?? false
-      });
-    }
-    const rootPackageBase = readPackageJson(config.cwd);
-    if (!rootPackageBase) {
-      throw new Error("Failed to read root package.json");
+      logger.success(`Created ${createdTags.length} tags for independent packages, ${createdTags.join(", ")}`);
+    } else if (internalConfig.release.gitTag) {
+      const tagName = internalConfig.templates.tagBody?.replaceAll("{{newVersion}}", newVersion);
+      const tagMessage = internalConfig.templates?.tagMessage?.replaceAll("{{newVersion}}", newVersion) || tagName;
+      if (dryRun) {
+        logger.info(`[dry-run] git tag ${signTags} -a ${tagName} -m "${tagMessage}"`);
+      } else {
+        const cmd = `git tag ${signTags} -a ${tagName} -m "${tagMessage}"`;
+        logger.debug(`Executing: ${cmd}`);
+        try {
+          await execPromise(cmd, {
+            logLevel,
+            noStderr: true,
+            noStdout: true,
+            cwd: internalConfig.cwd
+          });
+          logger.debug(`Tag created: ${tagName}`);
+        } catch (error) {
+          logger.error(`Failed to create tag ${tagName}:`, error);
+          throw error;
+        }
+      }
+      createdTags.push(tagName);
     }
-    const { from, to } = await resolveTags({
-      config,
-      step: "provider-release",
-      newVersion: options.bumpResult?.newVersion || rootPackageBase.version,
-      pkg: rootPackageBase
-    });
-    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
-      config,
-      force: options.force ?? false,
-      suffix: options.suffix,
-      changelog: true,
-      from,
-      to
-    });
-    logger.debug(`Root package: ${getIndependentTag({ name: rootPackage.name, version: rootPackage.newVersion || rootPackage.version })}`);
-    return await gitlabUnified({
-      config,
-      dryRun,
-      rootPackage,
-      bumpResult: options.bumpResult
-    });
+    logger.debug("Created Tags:", createdTags.join(", "));
+    logger.success("Commit and tag completed!");
+    await executeHook("success:commit-and-tag", internalConfig, dryRun ?? false);
+    return createdTags;
   } catch (error) {
-    logger.error("Error publishing GitLab release:", error);
+    logger.error("Error committing and tagging:", error);
+    await executeHook("error:commit-and-tag", internalConfig, dryRun ?? false);
     throw error;
   }
 }
+async function pushCommitAndTags({ config, dryRun, logLevel, cwd }) {
+  logger.start("Start push changes and tags");
+  const command = config.release.gitTag ? "git push --follow-tags" : "git push";
+  if (dryRun) {
+    logger.info(`[dry-run] ${command}`);
+  } else {
+    logger.debug(`Executing: ${command}`);
+    await execPromise(command, { noStderr: true, noStdout: true, logLevel, cwd });
+  }
+  logger.success("Pushing changes and tags completed!");
+}
+function getFirstCommit(cwd) {
+  const result = execSync(
+    "git rev-list --max-parents=0 HEAD",
+    {
+      cwd,
+      encoding: "utf8"
+    }
+  );
+  return result.trim();
+}
+function getCurrentGitBranch(cwd) {
+  const result = execSync("git rev-parse --abbrev-ref HEAD", {
+    cwd,
+    encoding: "utf8"
+  });
+  return result.trim();
+}
+function getCurrentGitRef(cwd) {
+  const branch = getCurrentGitBranch(cwd);
+  return branch || "HEAD";
+}
 
-function determineSemverChange(commits, types) {
-  let [hasMajor, hasMinor, hasPatch] = [false, false, false];
-  for (const commit of commits) {
-    const commitType = types[commit.type];
-    if (!commitType) {
+async function generateMarkDown({
+  commits,
+  config,
+  from,
+  to,
+  isFirstCommit
+}) {
+  const typeGroups = groupBy(commits, "type");
+  const markdown = [];
+  const breakingChanges = [];
+  const updatedConfig = {
+    ...config,
+    from,
+    to
+  };
+  const versionTitle = updatedConfig.to;
+  const changelogTitle = `${updatedConfig.from}...${updatedConfig.to}`;
+  markdown.push("", `## ${changelogTitle}`, "");
+  if (updatedConfig.repo && updatedConfig.from && versionTitle) {
+    const formattedCompareLink = formatCompareChanges(versionTitle, {
+      ...updatedConfig,
+      from: isFirstCommit ? getFirstCommit(updatedConfig.cwd) : updatedConfig.from
+    });
+    markdown.push(formattedCompareLink);
+  }
+  for (const type in updatedConfig.types) {
+    const group = typeGroups[type];
+    if (!group || group.length === 0) {
       continue;
     }
-    const semverType = commitType.semver;
-    if (semverType === "major" || commit.isBreaking) {
-      hasMajor = true;
-    } else if (semverType === "minor") {
-      hasMinor = true;
-    } else if (semverType === "patch") {
-      hasPatch = true;
+    if (typeof updatedConfig.types[type] === "boolean") {
+      continue;
+    }
+    markdown.push("", `### ${updatedConfig.types[type]?.title}`, "");
+    for (const commit of group.reverse()) {
+      const line = formatCommit(commit, updatedConfig);
+      markdown.push(line);
+      if (commit.isBreaking) {
+        breakingChanges.push(line);
+      }
     }
   }
-  return hasMajor ? "major" : hasMinor ? "minor" : hasPatch ? "patch" : void 0;
-}
-function detectReleaseTypeFromCommits(commits, types) {
-  return determineSemverChange(commits, types);
-}
-function validatePrereleaseDowngrade(currentVersion, targetPreid, configuredType) {
-  if (configuredType !== "prerelease" || !targetPreid || !isPrerelease(currentVersion)) {
-    return;
+  if (breakingChanges.length > 0) {
+    markdown.push("", "#### \u26A0\uFE0F Breaking Changes", "", ...breakingChanges);
   }
-  const testVersion = semver.inc(currentVersion, "prerelease", targetPreid);
-  const isNotUpgrade = testVersion && !semver.gt(testVersion, currentVersion);
-  if (isNotUpgrade) {
-    throw new Error(`Unable to graduate from ${currentVersion} to ${testVersion}, it's not a valid prerelease`);
+  const _authors = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    if (!commit.author) {
+      continue;
+    }
+    const name = formatName(commit.author.name);
+    if (!name || name.includes("[bot]")) {
+      continue;
+    }
+    if (updatedConfig.excludeAuthors && updatedConfig.excludeAuthors.some(
+      (v) => name.includes(v) || commit.author.email?.includes(v)
+    )) {
+      continue;
+    }
+    if (_authors.has(name)) {
+      const entry = _authors.get(name);
+      entry?.email.add(commit.author.email);
+    } else {
+      _authors.set(name, { email: /* @__PURE__ */ new Set([commit.author.email]), name });
+    }
   }
-}
-function handleStableVersionWithReleaseType(commits, types, force) {
-  if (!commits?.length && !force) {
-    logger.debug('No commits found for stable version with "release" type, skipping bump');
-    return void 0;
+  if (updatedConfig.repo?.provider === "github") {
+    await Promise.all(
+      [..._authors.keys()].map(async (authorName) => {
+        const meta = _authors.get(authorName);
+        if (!meta) {
+          return;
+        }
+        for (const data of [...meta.email, meta.name]) {
+          const { user } = await fetch$1(`https://ungh.cc/users/find/${data}`).then((r) => r.json()).catch(() => ({ user: null }));
+          if (user) {
+            meta.github = user.username;
+            break;
+          }
+        }
+      })
+    );
   }
-  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
-  if (!detectedType && !force) {
-    logger.debug("No significant commits found, skipping bump");
-    return void 0;
+  const authors = [..._authors.entries()].map((e) => ({
+    name: e[0],
+    ...e[1]
+  }));
+  if (authors.length > 0 && !updatedConfig.noAuthors) {
+    markdown.push(
+      "",
+      "### \u2764\uFE0F Contributors",
+      "",
+      ...authors.map((i) => {
+        const _email = [...i.email].find(
+          (e) => !e.includes("noreply.github.com")
+        );
+        const email = updatedConfig.hideAuthorEmail !== true && _email ? ` <${_email}>` : "";
+        const github = i.github ? ` ([@${i.github}](https://github.com/${i.github}))` : "";
+        return `- ${i.name}${github || email || ""}`;
+      })
+    );
   }
-  logger.debug(`Auto-detected release type from commits: ${detectedType}`);
-  return detectedType;
+  const result = convert(markdown.join("\n").trim(), true);
+  return result;
 }
-function handleStableVersionWithPrereleaseType(commits, types, force) {
-  if (!commits?.length && !force) {
-    logger.debug('No commits found for stable version with "prerelease" type, skipping bump');
-    return void 0;
+function getCommitBody(commit) {
+  if (!commit.body) {
+    return "";
   }
-  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
-  if (!detectedType) {
-    logger.debug("No significant commits found, using prepatch as default");
-    return "prepatch";
+  const lines = commit.body.split("\n");
+  const contentLines = lines.filter((line) => {
+    const trimmedLine = line.trim();
+    if (!trimmedLine) {
+      return false;
+    }
+    const isFileLine = /^[AMDTUXB](?:\d{3})?\s+/.test(trimmedLine) || /^[RCM]\d{3}\s+/.test(trimmedLine);
+    return !isFileLine;
+  });
+  if (contentLines.length === 0) {
+    return "";
   }
-  const prereleaseType = `pre${detectedType}`;
-  logger.debug(`Auto-detected prerelease type from commits: ${prereleaseType}`);
-  return prereleaseType;
+  const indentedBody = contentLines.map((line) => `  ${line}`).join("\n");
+  return `
+
+${indentedBody}
+`;
 }
-function handlePrereleaseVersionToStable(currentVersion) {
-  logger.debug(`Graduating from prerelease ${currentVersion} to stable release`);
-  return "release";
+function formatCommit(commit, config) {
+  const body = config.changelog.includeCommitBody ? getCommitBody(commit) : "";
+  return `- ${commit.scope ? `**${commit.scope.trim()}:** ` : ""}${commit.isBreaking ? "\u26A0\uFE0F  " : ""}${upperFirst(commit.description)}${formatReferences(commit.references, config)}${body}`;
 }
-function handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force }) {
-  const currentPreid = getPreid(currentVersion);
-  const hasChangedPreid = preid && currentPreid && currentPreid !== preid;
-  if (hasChangedPreid) {
-    const testVersion = semver.inc(currentVersion, "prerelease", preid);
-    if (!testVersion) {
-      throw new Error(`Unable to change preid from ${currentPreid} to ${preid} for version ${currentVersion}`);
-    }
-    const isUpgrade = semver.gt(testVersion, currentVersion);
-    if (!isUpgrade) {
-      throw new Error(`Unable to change preid from ${currentVersion} to ${testVersion}, it's not a valid upgrade (cannot downgrade from ${currentPreid} to ${preid})`);
-    }
-    return "prerelease";
+function formatReferences(references, config) {
+  const pr = references.filter((ref) => ref.type === "pull-request");
+  const issue = references.filter((ref) => ref.type === "issue");
+  if (pr.length > 0 || issue.length > 0) {
+    return ` (${[...pr, ...issue].map((ref) => formatReference(ref, config.repo)).join(", ")})`;
   }
-  if (!commits?.length && !force) {
-    logger.debug("No commits found for prerelease version, skipping bump");
-    return void 0;
+  if (references.length > 0) {
+    return ` (${formatReference(references[0], config.repo)})`;
   }
-  logger.debug(`Incrementing prerelease version: ${currentVersion}`);
-  return "prerelease";
+  return "";
 }
-function handleExplicitReleaseType({
-  releaseType,
-  currentVersion
-}) {
-  const isCurrentPrerelease = isPrerelease(currentVersion);
-  const isGraduatingToStable = isCurrentPrerelease && isStableReleaseType(releaseType);
-  if (isGraduatingToStable) {
-    logger.debug(`Graduating from prerelease ${currentVersion} to stable with type: ${releaseType}`);
-  } else {
-    logger.debug(`Using explicit release type: ${releaseType}`);
+function formatName(name = "") {
+  return name.split(" ").map((p) => upperFirst(p.trim())).join(" ");
+}
+function groupBy(items, key) {
+  const groups = {};
+  for (const item of items) {
+    groups[item[key]] = groups[item[key]] || [];
+    groups[item[key]]?.push(item);
   }
-  return releaseType;
+  return groups;
 }
-function determineReleaseType({
-  currentVersion,
-  commits,
-  releaseType,
-  preid,
-  types,
-  force
+
+function fromTagIsFirstCommit(fromTag, cwd) {
+  return fromTag === getFirstCommit(cwd);
+}
+async function generateChangelog({
+  pkg,
+  config,
+  dryRun,
+  newVersion
 }) {
-  if (releaseType === "release" && preid) {
-    throw new Error('You cannot use a "release" type with a "preid", to use a preid you must use a "prerelease" type');
-  }
-  validatePrereleaseDowngrade(currentVersion, preid, releaseType);
-  if (force) {
-    logger.debug(`Force flag enabled, using configured type: ${releaseType}`);
-    return releaseType;
-  }
-  const isCurrentPrerelease = isPrerelease(currentVersion);
-  if (!isCurrentPrerelease) {
-    if (releaseType === "release") {
-      return handleStableVersionWithReleaseType(commits, types, force);
-    }
-    if (releaseType === "prerelease") {
-      return handleStableVersionWithPrereleaseType(commits, types, force);
-    }
-    return handleExplicitReleaseType({ releaseType, currentVersion });
+  let fromTag = config.from || pkg.fromTag || getFirstCommit(config.cwd);
+  const isFirstCommit = fromTagIsFirstCommit(fromTag, config.cwd);
+  if (isFirstCommit) {
+    fromTag = config.monorepo?.versionMode === "independent" ? getIndependentTag({ version: "0.0.0", name: pkg.name }) : config.templates.tagBody.replace("{{newVersion}}", "0.0.0");
   }
-  if (releaseType === "release") {
-    return handlePrereleaseVersionToStable(currentVersion);
+  let toTag = config.to;
+  if (!toTag) {
+    toTag = config.monorepo?.versionMode === "independent" ? getIndependentTag({ version: newVersion, name: pkg.name }) : config.templates.tagBody.replace("{{newVersion}}", newVersion);
   }
-  if (releaseType === "prerelease") {
-    return handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force });
+  if (!toTag) {
+    throw new Error(`No tag found for ${pkg.name}`);
   }
-  return handleExplicitReleaseType({ releaseType, currentVersion });
-}
-function writeVersion(pkgPath, version, dryRun = false) {
-  const packageJsonPath = join(pkgPath, "package.json");
+  logger.debug(`Generating changelog for ${pkg.name} - from ${fromTag} to ${toTag}`);
   try {
-    logger.debug(`Writing ${version} to ${pkgPath}`);
-    const content = readFileSync(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(content);
-    const oldVersion = packageJson.version;
-    packageJson.version = version;
+    config = {
+      ...config,
+      from: fromTag,
+      to: toTag
+    };
+    const generatedChangelog = await generateMarkDown({
+      commits: pkg.commits,
+      config,
+      from: fromTag,
+      isFirstCommit,
+      to: toTag
+    });
+    let changelog = generatedChangelog;
+    if (pkg.commits.length === 0) {
+      changelog = `${changelog}
+
+${config.templates.emptyChangelogContent}`;
+    }
+    const changelogResult = await executeHook("generate:changelog", config, dryRun, {
+      commits: pkg.commits,
+      changelog
+    });
+    changelog = changelogResult || changelog;
+    logger.verbose(`Output changelog for ${pkg.name}:
+${changelog}`);
+    logger.debug(`Changelog generated for ${pkg.name} (${pkg.commits.length} commits)`);
+    logger.verbose(`Final changelog for ${pkg.name}:
+
+${changelog}
+
+`);
     if (dryRun) {
-      logger.info(`[dry-run] Updated ${packageJson.name}: ${oldVersion} \u2192 ${version}`);
-      return;
+      logger.info(`[dry-run] ${pkg.name} - Generate changelog ${fromTag}...${toTag}`);
     }
-    writeFileSync(packageJsonPath, `${formatJson(packageJson)}
-`, "utf8");
-    logger.info(`Updated ${packageJson.name}: ${oldVersion} \u2192 ${version}`);
+    return changelog;
   } catch (error) {
-    throw new Error(`Unable to write version to ${packageJsonPath}: ${error}`);
+    throw new Error(`Error generating changelog for ${pkg.name} (${fromTag}...${toTag}): ${error}`);
   }
 }
-function getPackageNewVersion({
-  currentVersion,
-  releaseType,
-  preid,
-  suffix
+function writeChangelogToFile({
+  cwd,
+  pkg,
+  changelog,
+  dryRun = false
 }) {
-  let newVersion = semver.inc(currentVersion, releaseType, preid);
-  if (!newVersion) {
-    throw new Error(`Unable to bump version "${currentVersion}" with release type "${releaseType}"
-
-You should use an explicit release type (use flag: --major, --minor, --patch, --premajor, --preminor, --prepatch, --prerelease)`);
-  }
-  if (isPrereleaseReleaseType(releaseType) && suffix) {
-    newVersion = newVersion.replace(/\.(\d+)$/, `.${suffix}`);
-  }
-  const isValidVersion = semver.gt(newVersion, currentVersion);
-  if (!isValidVersion) {
-    throw new Error(`Unable to bump version "${currentVersion}" to "${newVersion}", new version is not greater than current version`);
+  const changelogPath = join(pkg.path, "CHANGELOG.md");
+  let existingChangelog = "";
+  if (existsSync(changelogPath)) {
+    existingChangelog = readFileSync(changelogPath, "utf8");
   }
-  if (isGraduating(currentVersion, releaseType)) {
-    logger.info(`Graduating from prerelease ${currentVersion} to stable ${newVersion}`);
+  const lines = existingChangelog.split("\n");
+  const titleIndex = lines.findIndex((line) => line.startsWith("# "));
+  let updatedChangelog;
+  if (titleIndex !== -1) {
+    const beforeTitle = lines.slice(0, titleIndex + 1);
+    const afterTitle = lines.slice(titleIndex + 1);
+    updatedChangelog = [...beforeTitle, "", changelog, "", ...afterTitle].join("\n");
+  } else {
+    const title = "# Changelog\n";
+    updatedChangelog = `${title}
+${changelog}
+${existingChangelog}`;
   }
-  if (isChangedPreid(currentVersion, preid)) {
-    logger.debug(`Graduating from ${getPreid(currentVersion)} to ${preid}`);
+  if (dryRun) {
+    const relativeChangelogPath = relative(cwd, changelogPath);
+    logger.info(`[dry-run] ${pkg.name} - Write changelog to ${relativeChangelogPath}`);
+  } else {
+    logger.debug(`Writing changelog to ${changelogPath}`);
+    writeFileSync(changelogPath, updatedChangelog, "utf8");
+    logger.info(`Changelog updated for ${pkg.name} (${"newVersion" in pkg && pkg.newVersion || pkg.version})`);
   }
-  return newVersion;
 }
-function updateLernaVersion({
-  rootDir,
-  versionMode,
-  version,
-  dryRun = false
-}) {
-  const lernaJsonExists = hasLernaJson(rootDir);
-  if (!lernaJsonExists) {
-    return;
+
+function getDefaultConfig() {
+  return {
+    cwd: process$1.cwd(),
+    types: {
+      feat: { title: "\u{1F680} Enhancements", semver: "minor" },
+      perf: { title: "\u{1F525} Performance", semver: "patch" },
+      fix: { title: "\u{1FA79} Fixes", semver: "patch" },
+      refactor: { title: "\u{1F485} Refactors", semver: "patch" },
+      docs: { title: "\u{1F4D6} Documentation", semver: "patch" },
+      build: { title: "\u{1F4E6} Build", semver: "patch" },
+      types: { title: "\u{1F30A} Types", semver: "patch" },
+      chore: { title: "\u{1F3E1} Chore" },
+      examples: { title: "\u{1F3C0} Examples" },
+      test: { title: "\u2705 Tests" },
+      style: { title: "\u{1F3A8} Styles" },
+      ci: { title: "\u{1F916} CI" }
+    },
+    templates: {
+      commitMessage: "chore(release): bump version to {{newVersion}}",
+      tagMessage: "Bump version to {{newVersion}}",
+      tagBody: "v{{newVersion}}",
+      emptyChangelogContent: "No relevant changes for this release"
+    },
+    excludeAuthors: [],
+    noAuthors: false,
+    bump: {
+      type: "release",
+      clean: true,
+      dependencyTypes: ["dependencies"],
+      yes: false
+    },
+    changelog: {
+      rootChangelog: true,
+      includeCommitBody: true
+    },
+    publish: {
+      private: false,
+      args: []
+    },
+    tokens: {
+      gitlab: process$1.env.RELIZY_GITLAB_TOKEN || process$1.env.GITLAB_TOKEN || process$1.env.GITLAB_API_TOKEN || process$1.env.CI_JOB_TOKEN,
+      github: process$1.env.RELIZY_GITHUB_TOKEN || process$1.env.GITHUB_TOKEN || process$1.env.GH_TOKEN
+    },
+    scopeMap: {},
+    release: {
+      commit: true,
+      publish: true,
+      changelog: true,
+      push: true,
+      clean: true,
+      providerRelease: true,
+      noVerify: false,
+      gitTag: true
+    },
+    logLevel: "default",
+    safetyCheck: true
+  };
+}
+function setupLogger(logLevel) {
+  if (logLevel) {
+    logger.setLevel(logLevel);
+    logger.debug(`Log level set to: ${logLevel}`);
   }
-  const lernaJsonPath = join(rootDir, "lerna.json");
-  if (!existsSync(lernaJsonPath)) {
-    return;
+}
+async function resolveConfig(config, cwd) {
+  if (!config.repo) {
+    const resolvedRepoConfig = await resolveRepoConfig(cwd);
+    config.repo = {
+      ...resolvedRepoConfig,
+      provider: resolvedRepoConfig.provider
+    };
   }
-  try {
-    logger.debug("Updating lerna.json version");
-    const content = readFileSync(lernaJsonPath, "utf8");
-    const lernaJson = JSON.parse(content);
-    const oldVersion = lernaJson.version;
-    if (lernaJson.version === "independent" || versionMode === "independent") {
-      logger.debug("Lerna version is independent or version mode is independent, skipping update");
-      return;
-    }
-    lernaJson.version = version;
-    if (dryRun) {
-      logger.info(`[dry-run] update lerna.json: ${oldVersion} \u2192 ${version}`);
-      return;
-    }
-    writeFileSync(lernaJsonPath, `${formatJson(lernaJson)}
-`, "utf8");
-    logger.success(`Updated lerna.json: ${oldVersion} \u2192 ${version}`);
-  } catch (error) {
-    logger.fail(`Unable to update lerna.json: ${error}`);
+  if (typeof config.repo === "string") {
+    const resolvedRepoConfig = getRepoConfig(config.repo);
+    config.repo = {
+      ...resolvedRepoConfig,
+      provider: resolvedRepoConfig.provider
+    };
   }
+  return config;
 }
-function extractVersionFromPackageTag(tag) {
-  const atIndex = tag.lastIndexOf("@");
-  if (atIndex === -1) {
-    return null;
+async function loadRelizyConfig(options) {
+  const cwd = options?.overrides?.cwd ?? process$1.cwd();
+  const configName = options?.configName ?? "relizy";
+  await setupDotenv({ cwd });
+  const defaultConfig = getDefaultConfig();
+  const overridesConfig = defu(options?.overrides, options?.baseConfig);
+  const results = await loadConfig({
+    cwd,
+    name: configName,
+    packageJson: true,
+    defaults: defaultConfig,
+    overrides: overridesConfig
+  });
+  if (!results._configFile) {
+    logger.debug(`No config file found with name "${configName}" - using standalone mode`);
+    if (options?.configName) {
+      logger.error(`No config file found with name "${configName}"`);
+      process$1.exit(1);
+    }
   }
-  return tag.slice(atIndex + 1);
-}
-function isPrerelease(version) {
-  if (!version)
-    return false;
-  const prerelease = semver.prerelease(version);
-  return prerelease ? prerelease.length > 0 : false;
-}
-function isStableReleaseType(releaseType) {
-  const stableTypes = ["release", "major", "minor", "patch"];
-  return stableTypes.includes(releaseType);
-}
-function isPrereleaseReleaseType(releaseType) {
-  const prereleaseTypes = ["prerelease", "premajor", "preminor", "prepatch"];
-  return prereleaseTypes.includes(releaseType);
+  setupLogger(options?.overrides?.logLevel || results.config.logLevel);
+  logger.verbose("User config:", formatJson(results.config.changelog));
+  const resolvedConfig = await resolveConfig(results.config, cwd);
+  logger.debug("Resolved config:", formatJson(resolvedConfig));
+  return resolvedConfig;
 }
-function isGraduating(currentVersion, releaseType) {
-  return isPrerelease(currentVersion) && isStableReleaseType(releaseType);
+function defineConfig(config) {
+  return config;
 }
-function getPreid(version) {
-  if (!version)
-    return null;
-  const prerelease = semver.prerelease(version);
-  if (!prerelease || prerelease.length === 0) {
-    return null;
+
+async function githubIndependentMode({
+  config,
+  dryRun,
+  bumpResult,
+  force,
+  suffix
+}) {
+  const repoConfig = config.repo;
+  if (!repoConfig) {
+    throw new Error("No repository configuration found. Please check your changelog config.");
   }
-  return prerelease[0];
-}
-function isChangedPreid(currentVersion, targetPreid) {
-  if (!targetPreid || !isPrerelease(currentVersion)) {
-    return false;
+  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github && !config.repo?.token) {
+    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
   }
-  const currentPreid = getPreid(currentVersion);
-  if (!currentPreid) {
-    return false;
+  const packages = await getPackagesOrBumpedPackages({
+    config,
+    bumpResult,
+    suffix,
+    force
+  });
+  logger.info(`Creating ${packages.length} GitHub release(s)`);
+  const postedReleases = [];
+  for (const pkg of packages) {
+    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
+    const from = config.from || pkg.fromTag;
+    const to = config.to || getIndependentTag({ version: newVersion, name: pkg.name });
+    if (!from) {
+      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
+      continue;
+    }
+    const toTag = dryRun ? "HEAD" : to;
+    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${toTag}`);
+    const changelog = await generateChangelog({
+      pkg,
+      config,
+      dryRun,
+      newVersion
+    });
+    const releaseBody = changelog.split("\n").slice(2).join("\n");
+    const release = {
+      tag_name: to,
+      name: to,
+      body: releaseBody,
+      prerelease: isPrerelease(newVersion)
+    };
+    logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
+    if (dryRun) {
+      logger.info(`[dry-run] Publish GitHub release for ${to}`);
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: newVersion,
+        prerelease: release.prerelease
+      });
+    } else {
+      logger.debug(`Publishing release ${to} to GitHub...`);
+      await createGithubRelease({
+        ...config,
+        from,
+        to,
+        repo: repoConfig
+      }, release);
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: newVersion,
+        prerelease: release.prerelease
+      });
+    }
   }
-  return currentPreid !== targetPreid;
-}
-function getBumpedPackageIndependently({
-  pkg,
-  dryRun
-}) {
-  logger.debug(`Analyzing ${pkg.name}`);
-  const currentVersion = pkg.version || "0.0.0";
-  const newVersion = pkg.newVersion;
-  if (!newVersion) {
-    return { bumped: false };
+  if (postedReleases.length === 0) {
+    logger.warn("No releases created");
+  } else {
+    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitHub!`);
   }
-  logger.debug(`Bumping ${pkg.name} from ${currentVersion} to ${newVersion}`);
-  writeVersion(pkg.path, newVersion, dryRun);
-  return { bumped: true, newVersion, oldVersion: currentVersion };
+  return postedReleases;
 }
-function displayRootAndLernaUpdates({
-  versionMode,
-  currentVersion,
-  newVersion,
+async function githubUnified({
+  config,
   dryRun,
-  lernaJsonExists
+  rootPackage,
+  bumpResult
 }) {
-  if (versionMode !== "independent" && currentVersion && newVersion) {
-    logger.log(`${dryRun ? "[dry-run] " : ""}Root package.json: ${currentVersion} \u2192 ${newVersion}`);
-    logger.log("");
-    if (lernaJsonExists) {
-      logger.log(`${dryRun ? "[dry-run] " : ""}lerna.json: ${currentVersion} \u2192 ${newVersion}`);
-      logger.log("");
-    }
+  const repoConfig = config.repo;
+  if (!repoConfig) {
+    throw new Error("No repository configuration found. Please check your changelog config.");
   }
-}
-function displayUnifiedModePackages({
-  packages,
-  newVersion,
-  force
-}) {
-  logger.log(`${packages.length} package(s):`);
-  packages.forEach((pkg) => {
-    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
+  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github && !config.repo?.token) {
+    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+  }
+  const newVersion = bumpResult?.newVersion || rootPackage.version;
+  const to = config.to || config.templates.tagBody.replace("{{newVersion}}", newVersion);
+  const changelog = await generateChangelog({
+    pkg: rootPackage,
+    config,
+    dryRun,
+    newVersion
   });
-  logger.log("");
-}
-function displaySelectiveModePackages({
-  packages,
-  newVersion,
-  force
-}) {
-  if (force) {
-    logger.log(`${packages.length} package(s):`);
-    packages.forEach((pkg) => {
-      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (force)`);
-    });
-    logger.log("");
+  const releaseBody = changelog.split("\n").slice(2).join("\n");
+  const release = {
+    tag_name: to,
+    name: to,
+    body: releaseBody,
+    prerelease: isPrerelease(to)
+  };
+  logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
+  logger.debug("Release details:", formatJson({
+    tag_name: release.tag_name,
+    name: release.name,
+    prerelease: release.prerelease
+  }));
+  if (dryRun) {
+    logger.info("[dry-run] Publish GitHub release for", release.tag_name);
   } else {
-    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
-    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
-    const packagesAsGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation");
-    if (packagesWithCommits.length > 0) {
-      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
-      packagesWithCommits.forEach((pkg) => {
-        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-    if (packagesAsDependents.length > 0) {
-      logger.log(`${packagesAsDependents.length} dependent package(s):`);
-      packagesAsDependents.forEach((pkg) => {
-        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-    if (packagesAsGraduation.length > 0) {
-      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
-      packagesAsGraduation.forEach((pkg) => {
-        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
+    logger.debug("Publishing release to GitHub...");
+    await createGithubRelease({
+      ...config,
+      from: bumpResult?.bumped && bumpResult.fromTag || "v0.0.0",
+      to,
+      repo: repoConfig
+    }, release);
   }
+  logger.success(`Release ${to} published to GitHub!`);
+  return [{
+    name: to,
+    tag: to,
+    version: to,
+    prerelease: release.prerelease
+  }];
 }
-function displayIndependentModePackages({
-  packages,
-  force
-}) {
-  if (force) {
-    logger.log(`${packages.length} package(s):`);
-    packages.forEach((pkg) => {
-      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (force)`);
+async function github(options) {
+  try {
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const config = await loadRelizyConfig({
+      configName: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        from: options.from,
+        to: options.to,
+        logLevel: options.logLevel,
+        tokens: {
+          github: options.token
+        }
+      }
     });
-    logger.log("");
-  } else {
-    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
-    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
-    const packagesAsGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation");
-    if (packagesWithCommits.length > 0) {
-      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
-      packagesWithCommits.forEach((pkg) => {
-        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-    if (packagesAsDependents.length > 0) {
-      logger.log(`${packagesAsDependents.length} dependent package(s):`);
-      packagesAsDependents.forEach((pkg) => {
-        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
+    if (config.monorepo?.versionMode === "independent") {
+      return await githubIndependentMode({
+        config,
+        dryRun,
+        bumpResult: options.bumpResult,
+        force: options.force ?? false,
+        suffix: options.suffix
       });
-      logger.log("");
     }
-    if (packagesAsGraduation.length > 0) {
-      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
-      packagesAsGraduation.forEach((pkg) => {
-        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
+    const rootPackageBase = readPackageJson(config.cwd);
+    if (!rootPackageBase) {
+      throw new Error("Failed to read root package.json");
     }
+    const newVersion = options.bumpResult?.newVersion || rootPackageBase.version;
+    const { from, to } = await resolveTags({
+      config,
+      step: "provider-release",
+      newVersion,
+      pkg: rootPackageBase
+    });
+    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
+      config,
+      force: options.force ?? false,
+      suffix: options.suffix,
+      changelog: true,
+      from,
+      to
+    });
+    return await githubUnified({
+      config,
+      dryRun,
+      rootPackage,
+      bumpResult: options.bumpResult
+    });
+  } catch (error) {
+    logger.error("Error publishing GitHub release:", error);
+    throw error;
   }
 }
-async function confirmBump({
-  versionMode,
+
+async function createGitlabRelease({
   config,
-  packages,
-  force,
-  currentVersion,
-  newVersion,
+  release,
   dryRun
 }) {
-  if (packages.length === 0) {
-    logger.debug("No packages to bump");
-    return;
+  const token = config.tokens.gitlab || config.repo?.token;
+  if (!token && !dryRun) {
+    throw new Error(
+      "No GitLab token found. Set GITLAB_TOKEN or CI_JOB_TOKEN environment variable or configure tokens.gitlab"
+    );
   }
-  const lernaJsonExists = hasLernaJson(config.cwd);
-  logger.log("");
-  logger.info(`${dryRun ? "[dry-run] " : ""}The following packages will be updated:
-`);
-  displayRootAndLernaUpdates({
-    versionMode,
-    currentVersion,
-    newVersion,
-    lernaJsonExists,
-    dryRun
-  });
-  if (versionMode === "unified") {
-    if (!newVersion) {
-      throw new Error("Cannot confirm bump in unified mode without a new version");
+  const repoConfig = config.repo?.repo;
+  if (!repoConfig) {
+    throw new Error("No repository URL found in config");
+  }
+  logger.debug(`Parsed repository URL: ${repoConfig}`);
+  const projectPath = encodeURIComponent(repoConfig);
+  const gitlabDomain = config.repo?.domain || "gitlab.com";
+  const apiUrl = `https://${gitlabDomain}/api/v4/projects/${projectPath}/releases`;
+  logger.info(`Creating GitLab release at: ${apiUrl}`);
+  const payload = {
+    tag_name: release.tag_name,
+    name: release.name || release.tag_name,
+    description: release.description || "",
+    ref: release.ref || "main"
+  };
+  try {
+    if (dryRun) {
+      logger.info("[dry-run] GitLab release:", formatJson(payload));
+      return {
+        tag_name: release.tag_name,
+        name: release.name || release.tag_name,
+        description: release.description || "",
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        released_at: (/* @__PURE__ */ new Date()).toISOString(),
+        _links: {
+          self: `${apiUrl}/${encodeURIComponent(release.tag_name)}`
+        }
+      };
     }
-    displayUnifiedModePackages({ packages, newVersion, force });
-  } else if (versionMode === "selective") {
-    if (!newVersion) {
-      throw new Error("Cannot confirm bump in selective mode without a new version");
+    logger.debug(`POST GitLab release to ${apiUrl} with payload: ${formatJson(payload)}`);
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PRIVATE-TOKEN": token || ""
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`GitLab API error (${response.status}): ${errorText}`);
     }
-    displaySelectiveModePackages({ packages, newVersion, force });
-  } else if (versionMode === "independent") {
-    displayIndependentModePackages({ packages, force });
+    const result = await response.json();
+    logger.debug(`Created GitLab release: ${result._links.self}`);
+    return result;
+  } catch (error) {
+    logger.error("Failed to create GitLab release:", error);
+    throw error;
   }
-  try {
-    const confirmed = await confirm({
-      message: `${dryRun ? "[dry-run] " : ""}Do you want to proceed with these version updates?`,
-      default: true
+}
+async function gitlabIndependentMode({
+  config,
+  dryRun,
+  bumpResult,
+  suffix,
+  force
+}) {
+  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  const packages = await getPackagesOrBumpedPackages({
+    config,
+    bumpResult,
+    suffix,
+    force
+  });
+  logger.info(`Creating ${packages.length} GitLab release(s) for independent packages`);
+  logger.debug("Getting current branch...");
+  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
+    noSuccess: true,
+    noStdout: true,
+    logLevel: config.logLevel,
+    cwd: config.cwd
+  });
+  const postedReleases = [];
+  for (const pkg of packages) {
+    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
+    const from = config.from || pkg.fromTag;
+    const to = getIndependentTag({ version: newVersion, name: pkg.name });
+    if (!from) {
+      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
+      continue;
+    }
+    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${to}`);
+    const changelog = await generateChangelog({
+      pkg,
+      config,
+      dryRun,
+      newVersion
     });
-    if (!confirmed) {
-      logger.log("");
-      logger.fail("Bump refused");
-      process.exit(0);
+    if (!changelog) {
+      logger.warn(`No changelog found for ${pkg.name}`);
+      continue;
     }
-  } catch (error) {
-    const userHasExited = error instanceof Error && error.name === "ExitPromptError";
-    if (userHasExited) {
-      logger.log("");
-      logger.fail("Bump cancelled");
-      process.exit(0);
+    const releaseBody = changelog.split("\n").slice(2).join("\n");
+    const release = {
+      tag_name: to,
+      name: to,
+      description: releaseBody,
+      ref: currentBranch.trim()
+    };
+    logger.debug(`Creating release for ${to} (ref: ${release.ref})`);
+    if (dryRun) {
+      logger.info(`[dry-run] Publish GitLab release for ${to}`);
+    } else {
+      logger.debug(`Publishing release ${to} to GitLab...`);
+      await createGitlabRelease({
+        config,
+        release,
+        dryRun
+      });
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: newVersion,
+        prerelease: isPrerelease(newVersion)
+      });
     }
-    logger.fail("Error while confirming bump");
-    process.exit(1);
   }
-  logger.log("");
+  if (postedReleases.length === 0) {
+    logger.warn("No releases created");
+  } else {
+    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitLab!`);
+  }
+  return postedReleases;
 }
-function getBumpedIndependentPackages({
-  packages,
-  dryRun
+async function gitlabUnified({
+  config,
+  dryRun,
+  rootPackage,
+  bumpResult
 }) {
-  const bumpedPackages = [];
-  for (const pkgToBump of packages) {
-    logger.debug(`Bumping ${pkgToBump.name} from ${pkgToBump.version} to ${pkgToBump.newVersion} (reason: ${pkgToBump.reason})`);
-    const result = getBumpedPackageIndependently({
-      pkg: pkgToBump,
+  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  const newVersion = bumpResult?.newVersion || rootPackage.newVersion || rootPackage.version;
+  const to = config.templates.tagBody.replace("{{newVersion}}", newVersion);
+  const changelog = await generateChangelog({
+    pkg: rootPackage,
+    config,
+    dryRun,
+    newVersion
+  });
+  const releaseBody = changelog.split("\n").slice(2).join("\n");
+  logger.debug("Getting current branch...");
+  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
+    noSuccess: true,
+    noStdout: true,
+    logLevel: config.logLevel,
+    cwd: config.cwd
+  });
+  const release = {
+    tag_name: to,
+    name: to,
+    description: releaseBody,
+    ref: currentBranch.trim()
+  };
+  logger.info(`Creating release for ${to} (ref: ${release.ref})`);
+  logger.debug("Release details:", formatJson({
+    tag_name: release.tag_name,
+    name: release.name,
+    ref: release.ref
+  }));
+  if (dryRun) {
+    logger.info("[dry-run] Publish GitLab release for", release.tag_name);
+  } else {
+    logger.debug("Publishing release to GitLab...");
+    await createGitlabRelease({
+      config,
+      release,
       dryRun
     });
-    if (result.bumped) {
-      bumpedPackages.push({
-        ...pkgToBump,
-        version: result.oldVersion
+  }
+  logger.success(`Release ${to} published to GitLab!`);
+  return [{
+    name: to,
+    tag: to,
+    version: to,
+    prerelease: isPrerelease(newVersion)
+  }];
+}
+async function gitlab(options = {}) {
+  try {
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const config = await loadRelizyConfig({
+      configName: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        from: options.from,
+        to: options.to,
+        logLevel: options.logLevel,
+        tokens: {
+          gitlab: options.token
+        }
+      }
+    });
+    if (config.monorepo?.versionMode === "independent") {
+      return await gitlabIndependentMode({
+        config,
+        dryRun,
+        bumpResult: options.bumpResult,
+        suffix: options.suffix,
+        force: options.force ?? false
       });
     }
+    const rootPackageBase = readPackageJson(config.cwd);
+    if (!rootPackageBase) {
+      throw new Error("Failed to read root package.json");
+    }
+    const newVersion = options.bumpResult?.newVersion || rootPackageBase.version;
+    const { from, to } = await resolveTags({
+      config,
+      step: "provider-release",
+      newVersion,
+      pkg: rootPackageBase
+    });
+    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
+      config,
+      force: options.force ?? false,
+      suffix: options.suffix,
+      changelog: true,
+      from,
+      to
+    });
+    logger.debug(`Root package: ${getIndependentTag({ name: rootPackage.name, version: newVersion })}`);
+    return await gitlabUnified({
+      config,
+      dryRun,
+      rootPackage,
+      bumpResult: options.bumpResult
+    });
+  } catch (error) {
+    logger.error("Error publishing GitLab release:", error);
+    throw error;
   }
-  return bumpedPackages;
 }
 
-function getIndependentTag({ version, name }) {
-  return `${name}@${version}`;
+function isGraduatingToStableBetweenVersion(version, newVersion) {
+  const isSameBase = semver.major(version) === semver.major(newVersion) && semver.minor(version) === semver.minor(newVersion) && semver.patch(version) === semver.patch(newVersion);
+  const fromPrerelease = semver.prerelease(version) !== null;
+  const toStable = semver.prerelease(newVersion) === null;
+  return isSameBase && fromPrerelease && toStable;
 }
-async function getLastStableTag({ logLevel, cwd }) {
-  const { stdout } = await execPromise(
-    `git tag --sort=-creatordate | grep -E '^[^0-9]*[0-9]+\\.[0-9]+\\.[0-9]+$' | head -n 1`,
-    {
-      logLevel,
-      noStderr: true,
-      noStdout: true,
-      noSuccess: true,
-      cwd
+function determineSemverChange(commits, types) {
+  let [hasMajor, hasMinor, hasPatch] = [false, false, false];
+  for (const commit of commits) {
+    const commitType = types[commit.type];
+    if (!commitType) {
+      continue;
     }
-  );
-  const lastTag = stdout.trim();
-  logger.debug("Last stable tag:", lastTag || "No stable tags found");
-  return lastTag;
+    const semverType = commitType.semver;
+    if (semverType === "major" || commit.isBreaking) {
+      hasMajor = true;
+    } else if (semverType === "minor") {
+      hasMinor = true;
+    } else if (semverType === "patch") {
+      hasPatch = true;
+    }
+  }
+  return hasMajor ? "major" : hasMinor ? "minor" : hasPatch ? "patch" : void 0;
 }
-async function getLastTag({ logLevel, cwd }) {
-  const { stdout } = await execPromise(`git tag --sort=-creatordate | head -n 1`, {
-    logLevel,
-    noStderr: true,
-    noStdout: true,
-    noSuccess: true,
-    cwd
-  });
-  const lastTag = stdout.trim();
-  logger.debug("Last tag:", lastTag || "No tags found");
-  return lastTag;
+function detectReleaseTypeFromCommits(commits, types) {
+  return determineSemverChange(commits, types);
 }
-function getLastRepoTag(options) {
-  if (options?.onlyStable) {
-    return getLastStableTag({ logLevel: options?.logLevel, cwd: options?.cwd });
+function validatePrereleaseDowngrade(currentVersion, targetPreid, configuredType) {
+  if (configuredType !== "prerelease" || !targetPreid || !isPrerelease(currentVersion)) {
+    return;
+  }
+  const testVersion = semver.inc(currentVersion, "prerelease", targetPreid);
+  const isNotUpgrade = testVersion && !semver.gt(testVersion, currentVersion);
+  if (isNotUpgrade) {
+    throw new Error(`Unable to graduate from ${currentVersion} to ${testVersion}, it's not a valid prerelease`);
   }
-  return getLastTag({ logLevel: options?.logLevel, cwd: options?.cwd });
 }
-async function getLastPackageTag({
-  packageName,
-  onlyStable,
-  logLevel,
-  cwd
-}) {
-  try {
-    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
-    let grepPattern;
-    if (onlyStable) {
-      grepPattern = `^${escapedPackageName}@[0-9]+\\.[0-9]+\\.[0-9]+$`;
-    } else {
-      grepPattern = `^${escapedPackageName}@`;
-    }
-    const { stdout } = await execPromise(
-      `git tag --sort=-creatordate | grep -E '${grepPattern}' | sed -n '1p'`,
-      {
-        logLevel,
-        noStderr: true,
-        noStdout: true,
-        noSuccess: true,
-        cwd
-      }
-    );
-    const tag = stdout.trim();
-    return tag || null;
-  } catch {
-    return null;
+function handleStableVersionWithReleaseType(commits, types, force) {
+  if (!commits?.length && !force) {
+    logger.debug('No commits found for stable version with "release" type, skipping bump');
+    return void 0;
+  }
+  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
+  if (!detectedType && !force) {
+    logger.debug("No significant commits found, skipping bump");
+    return void 0;
+  }
+  logger.debug(`Auto-detected release type from commits: ${detectedType}`);
+  return detectedType;
+}
+function handleStableVersionWithPrereleaseType(commits, types, force) {
+  if (!commits?.length && !force) {
+    logger.debug('No commits found for stable version with "prerelease" type, skipping bump');
+    return void 0;
+  }
+  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
+  if (!detectedType) {
+    logger.debug("No significant commits found, using prepatch as default");
+    return "prepatch";
   }
+  const prereleaseType = `pre${detectedType}`;
+  logger.debug(`Auto-detected prerelease type from commits: ${prereleaseType}`);
+  return prereleaseType;
 }
-async function resolveFromTagIndependent({
-  cwd,
-  packageName,
-  graduating,
-  logLevel
-}) {
-  const lastPackageTag = await getLastPackageTag({
-    packageName,
-    onlyStable: graduating,
-    logLevel
-  });
-  if (!lastPackageTag) {
-    return getFirstCommit(cwd);
-  }
-  return lastPackageTag;
+function handlePrereleaseVersionToStable(currentVersion) {
+  logger.debug(`Graduating from prerelease ${currentVersion} to stable release`);
+  return "release";
 }
-async function resolveFromTagUnified({
-  config,
-  graduating,
-  logLevel
-}) {
-  const from = await getLastRepoTag({ onlyStable: graduating, logLevel }) || getFirstCommit(config.cwd);
-  return from;
+function handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force }) {
+  const currentPreid = getPreid(currentVersion);
+  const hasChangedPreid = preid && currentPreid && currentPreid !== preid;
+  if (hasChangedPreid) {
+    const testVersion = semver.inc(currentVersion, "prerelease", preid);
+    if (!testVersion) {
+      throw new Error(`Unable to change preid from ${currentPreid} to ${preid} for version ${currentVersion}`);
+    }
+    const isUpgrade = semver.gt(testVersion, currentVersion);
+    if (!isUpgrade) {
+      throw new Error(`Unable to change preid from ${currentVersion} to ${testVersion}, it's not a valid upgrade (cannot downgrade from ${currentPreid} to ${preid})`);
+    }
+    return "prerelease";
+  }
+  if (!commits?.length && !force) {
+    logger.debug("No commits found for prerelease version, skipping bump");
+    return void 0;
+  }
+  logger.debug(`Incrementing prerelease version: ${currentVersion}`);
+  return "prerelease";
 }
-async function resolveFromTag({
-  config,
-  versionMode,
-  step,
-  packageName,
-  graduating,
-  logLevel
+function handleExplicitReleaseType({
+  releaseType,
+  currentVersion
 }) {
-  let from;
-  if (versionMode === "independent") {
-    if (!packageName) {
-      throw new Error("Package name is required for independent version mode");
-    }
-    from = await resolveFromTagIndependent({
-      cwd: config.cwd,
-      packageName,
-      graduating,
-      logLevel
-    });
+  const isCurrentPrerelease = isPrerelease(currentVersion);
+  const isGraduatingToStable = isCurrentPrerelease && isStableReleaseType(releaseType);
+  if (isGraduatingToStable) {
+    logger.debug(`Graduating from prerelease ${currentVersion} to stable with type: ${releaseType}`);
   } else {
-    from = await resolveFromTagUnified({
-      config,
-      graduating,
-      logLevel
-    });
+    logger.debug(`Using explicit release type: ${releaseType}`);
   }
-  logger.debug(`[${versionMode}](${step}) Using from tag: ${from}`);
-  return config.from || from;
+  return releaseType;
 }
-function resolveToTag({
-  config,
-  versionMode,
-  newVersion,
-  step,
-  packageName
+function determineReleaseType({
+  currentVersion,
+  commits,
+  releaseType,
+  preid,
+  types,
+  force
 }) {
-  const isUntaggedStep = step === "bump" || step === "changelog";
-  let to;
-  if (isUntaggedStep) {
-    to = getCurrentGitRef(config.cwd);
-  } else if (versionMode === "independent") {
-    if (!packageName) {
-      throw new Error("Package name is required for independent version mode");
+  if (releaseType === "release" && preid) {
+    throw new Error('You cannot use a "release" type with a "preid", to use a preid you must use a "prerelease" type');
+  }
+  validatePrereleaseDowngrade(currentVersion, preid, releaseType);
+  if (force) {
+    logger.debug(`Force flag enabled, using configured type: ${releaseType}`);
+    return releaseType;
+  }
+  const isCurrentPrerelease = isPrerelease(currentVersion);
+  if (!isCurrentPrerelease) {
+    if (releaseType === "release") {
+      return handleStableVersionWithReleaseType(commits, types, force);
     }
-    if (!newVersion) {
-      throw new Error("New version is required for independent version mode");
+    if (releaseType === "prerelease") {
+      return handleStableVersionWithPrereleaseType(commits, types, force);
     }
-    to = getIndependentTag({ version: newVersion, name: packageName });
-  } else {
-    to = newVersion ? config.templates.tagBody.replace("{{newVersion}}", newVersion) : getCurrentGitRef(config.cwd);
+    return handleExplicitReleaseType({ releaseType, currentVersion });
   }
-  logger.debug(`[${versionMode}](${step}) Using to tag: ${to}`);
-  return config.to || to;
+  if (releaseType === "release") {
+    return handlePrereleaseVersionToStable(currentVersion);
+  }
+  if (releaseType === "prerelease") {
+    return handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force });
+  }
+  return handleExplicitReleaseType({ releaseType, currentVersion });
 }
-async function resolveTags({
-  config,
-  step,
-  pkg,
-  newVersion
-}) {
-  const versionMode = config.monorepo?.versionMode || "standalone";
-  const logLevel = config.logLevel;
-  logger.debug(`[${versionMode}](${step}) Resolving tags`);
-  const releaseType = config.bump.type;
-  const from = await resolveFromTag({
-    config,
-    versionMode,
-    step,
-    packageName: pkg.name,
-    graduating: isGraduating(pkg.version, releaseType),
-    logLevel
-  });
-  const to = resolveToTag({
-    config,
-    versionMode,
-    newVersion,
-    step,
-    packageName: pkg.name
-  });
-  logger.debug(`[${versionMode}](${step}) Using tags: ${from} \u2192 ${to}`);
-  return { from, to };
+function writeVersion(pkgPath, newVersion, dryRun = false) {
+  const packageJsonPath = join(pkgPath, "package.json");
+  try {
+    logger.debug(`Writing ${newVersion} to ${pkgPath}`);
+    const content = readFileSync(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(content);
+    const oldVersion = packageJson.version;
+    packageJson.version = newVersion;
+    if (dryRun) {
+      logger.info(`[dry-run] Updated ${packageJson.name}: ${oldVersion} \u2192 ${newVersion}`);
+      return;
+    }
+    writeFileSync(packageJsonPath, `${formatJson(packageJson)}
+`, "utf8");
+    logger.info(`Updated ${packageJson.name}: ${oldVersion} \u2192 ${newVersion}`);
+  } catch (error) {
+    throw new Error(`Unable to write version to ${packageJsonPath}: ${error}`);
+  }
 }
+function getPackageNewVersion({
+  currentVersion,
+  releaseType,
+  preid,
+  suffix
+}) {
+  let newVersion = semver.inc(currentVersion, releaseType, preid);
+  if (!newVersion) {
+    throw new Error(`Unable to bump version "${currentVersion}" with release type "${releaseType}"
 
-let sessionOtp;
-function detectPackageManager(cwd = process.cwd()) {
+You should use an explicit release type (use flag: --major, --minor, --patch, --premajor, --preminor, --prepatch, --prerelease)`);
+  }
+  if (isPrereleaseReleaseType(releaseType) && suffix) {
+    newVersion = newVersion.replace(/\.(\d+)$/, `.${suffix}`);
+  }
+  const isValidVersion = semver.gt(newVersion, currentVersion);
+  if (!isValidVersion) {
+    throw new Error(`Unable to bump version "${currentVersion}" to "${newVersion}", new version is not greater than current version`);
+  }
+  if (isGraduating(currentVersion, releaseType)) {
+    logger.info(`Graduating from prerelease ${currentVersion} to stable ${newVersion}`);
+  }
+  if (isChangedPreid(currentVersion, preid)) {
+    logger.debug(`Graduating from ${getPreid(currentVersion)} to ${preid}`);
+  }
+  return newVersion;
+}
+function updateLernaVersion({
+  rootDir,
+  versionMode,
+  version,
+  dryRun = false
+}) {
+  const lernaJsonExists = hasLernaJson(rootDir);
+  if (!lernaJsonExists) {
+    return;
+  }
+  const lernaJsonPath = join(rootDir, "lerna.json");
+  if (!existsSync(lernaJsonPath)) {
+    return;
+  }
   try {
-    const packageJsonPath = join(cwd, "package.json");
-    if (existsSync(packageJsonPath)) {
-      try {
-        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-        const pmField = packageJson.packageManager;
-        if (typeof pmField === "string") {
-          const pmName = pmField.split("@")[0];
-          if (["npm", "pnpm", "yarn", "bun"].includes(pmName)) {
-            logger.debug(`Detected package manager from package.json: ${pmName}`);
-            return pmName;
-          }
-        }
-      } catch (e) {
-        const errorString = e instanceof Error ? e.message : String(e);
-        logger.debug(`Failed to parse package.json: ${errorString}`);
-      }
-    }
-    const lockFiles = {
-      pnpm: "pnpm-lock.yaml",
-      yarn: "yarn.lock",
-      npm: "package-lock.json",
-      bun: "bun.lockb"
-    };
-    for (const [manager, file] of Object.entries(lockFiles)) {
-      if (existsSync(join(cwd, file))) {
-        logger.debug(`Detected package manager from lockfile: ${manager}`);
-        return manager;
-      }
+    logger.debug("Updating lerna.json version");
+    const content = readFileSync(lernaJsonPath, "utf8");
+    const lernaJson = JSON.parse(content);
+    const oldVersion = lernaJson.version;
+    if (lernaJson.version === "independent" || versionMode === "independent") {
+      logger.debug("Lerna version is independent or version mode is independent, skipping update");
+      return;
     }
-    const ua = process.env.npm_config_user_agent;
-    if (ua) {
-      const match = /(pnpm|yarn|npm|bun)/.exec(ua);
-      if (match) {
-        logger.debug(`Detected package manager from user agent: ${match[1]}`);
-        return match[1];
-      }
+    lernaJson.version = version;
+    if (dryRun) {
+      logger.info(`[dry-run] update lerna.json: ${oldVersion} \u2192 ${version}`);
+      return;
     }
-    logger.debug("No package manager detected, defaulting to npm");
-    return "npm";
+    writeFileSync(lernaJsonPath, `${formatJson(lernaJson)}
+`, "utf8");
+    logger.success(`Updated lerna.json: ${oldVersion} \u2192 ${version}`);
   } catch (error) {
-    logger.fail(`Error detecting package manager: ${error}, defaulting to npm`);
-    return "npm";
+    logger.fail(`Unable to update lerna.json: ${error}`);
   }
 }
-function determinePublishTag(version, configTag) {
-  let tag = "latest";
-  if (configTag) {
-    tag = configTag;
-  }
-  if (isPrerelease(version) && !configTag) {
-    logger.warn('You are about to publish a "prerelease" version with the "latest" tag. To avoid mistake, the tag is set to "next"');
-    tag = "next";
-  }
-  if (isPrerelease(version) && configTag === "latest") {
-    logger.warn('Please note, you are about to publish a "prerelease" version with the "latest" tag.');
+function extractVersionFromPackageTag(tag) {
+  const atIndex = tag.lastIndexOf("@");
+  if (atIndex === -1) {
+    return null;
   }
-  return tag;
+  return tag.slice(atIndex + 1);
 }
-function getPackagesToPublishInSelectiveMode(sortedPackages, rootVersion) {
-  const packagesToPublish = [];
-  for (const pkg of sortedPackages) {
-    const pkgJsonPath = join(pkg.path, "package.json");
-    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-    if (pkgJson.version === rootVersion) {
-      packagesToPublish.push(pkg);
-    }
-  }
-  return packagesToPublish;
+function isPrerelease(version) {
+  if (!version)
+    return false;
+  const prerelease = semver.prerelease(version);
+  return prerelease ? prerelease.length > 0 : false;
 }
-async function getPackagesToPublishInIndependentMode(sortedPackages, config) {
-  const packagesToPublish = [];
-  for (const pkg of sortedPackages) {
-    const { from, to } = await resolveTags({
-      config,
-      step: "publish",
-      pkg,
-      newVersion: pkg.version
-    });
-    if (pkg.commits.length > 0) {
-      packagesToPublish.push(pkg);
-      logger.debug(`${pkg.name}: ${pkg.commits.length} commit(s) since ${from} \u2192 ${to}`);
-    }
-  }
-  return packagesToPublish;
+function isStableReleaseType(releaseType) {
+  const stableTypes = ["release", "major", "minor", "patch"];
+  return stableTypes.includes(releaseType);
 }
-function isYarnBerry() {
-  return existsSync(path.join(process.cwd(), ".yarnrc.yml"));
+function isPrereleaseReleaseType(releaseType) {
+  const prereleaseTypes = ["prerelease", "premajor", "preminor", "prepatch"];
+  return prereleaseTypes.includes(releaseType);
 }
-function getCommandArgs({
-  packageManager,
-  tag,
-  config,
-  otp
-}) {
-  const args = ["publish", "--tag", tag];
-  if (packageManager === "pnpm") {
-    args.push("--no-git-checks");
-  } else if (packageManager === "yarn") {
-    args.push("--non-interactive");
-    if (isYarnBerry())
-      args.push("--no-git-checks");
-  } else if (packageManager === "npm") {
-    args.push("--yes");
+function isGraduating(currentVersion, releaseType) {
+  return isPrerelease(currentVersion) && isStableReleaseType(releaseType);
+}
+function getPreid(version) {
+  if (!version)
+    return null;
+  const prerelease = semver.prerelease(version);
+  if (!prerelease || prerelease.length === 0) {
+    return null;
   }
-  const registry = config.publish.registry;
-  if (registry) {
-    args.push("--registry", registry);
+  return prerelease[0];
+}
+function isChangedPreid(currentVersion, targetPreid) {
+  if (!targetPreid || !isPrerelease(currentVersion)) {
+    return false;
   }
-  const access = config.publish.access;
-  if (access) {
-    args.push("--access", access);
+  const currentPreid = getPreid(currentVersion);
+  if (!currentPreid) {
+    return false;
   }
-  const finalOtp = otp ?? sessionOtp ?? config.publish.otp;
-  if (finalOtp) {
-    args.push("--otp", finalOtp);
+  return currentPreid !== targetPreid;
+}
+function getBumpedPackageIndependently({
+  pkg,
+  dryRun
+}) {
+  logger.debug(`Analyzing ${pkg.name}`);
+  const currentVersion = pkg.version || "0.0.0";
+  const newVersion = pkg.newVersion;
+  if (!newVersion) {
+    return { bumped: false };
   }
-  return args;
+  logger.debug(`Bumping ${pkg.name} from ${currentVersion} to ${newVersion}`);
+  writeVersion(pkg.path, newVersion, dryRun);
+  return { bumped: true, newVersion, oldVersion: currentVersion };
 }
-function isOtpError(error) {
-  if (typeof error !== "object" || error === null)
-    return false;
-  const errorMessage = "message" in error && typeof error.message === "string" ? error.message.toLowerCase() : "";
-  return errorMessage.includes("otp") || errorMessage.includes("one-time password") || errorMessage.includes("eotp");
+function displayRootAndLernaUpdates({
+  versionMode,
+  currentVersion,
+  newVersion,
+  dryRun,
+  lernaJsonExists
+}) {
+  if (versionMode !== "independent" && currentVersion && newVersion) {
+    logger.log(`${dryRun ? "[dry-run] " : ""}Root package.json: ${currentVersion} \u2192 ${newVersion}`);
+    logger.log("");
+    if (lernaJsonExists) {
+      logger.log(`${dryRun ? "[dry-run] " : ""}lerna.json: ${currentVersion} \u2192 ${newVersion}`);
+      logger.log("");
+    }
+  }
 }
-function promptOtpWithTimeout(timeout = 9e4) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error("OTP input timeout"));
-    }, timeout);
-    input({
-      message: "This operation requires a one-time password (OTP). Please enter your OTP:"
-    }).then((otp) => {
-      clearTimeout(timer);
-      resolve(otp);
-    }).catch((error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
+function displayUnifiedModePackages({
+  packages,
+  newVersion,
+  force
+}) {
+  logger.log(`${packages.length} package(s):`);
+  packages.forEach((pkg) => {
+    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
   });
+  logger.log("");
 }
-async function handleOtpError() {
-  if (isInCI()) {
-    logger.error("OTP required but running in CI environment. Please provide OTP via config or `--otp` flag");
-    throw new Error("OTP required in CI environment");
+function displaySelectiveModePackages({
+  packages,
+  newVersion,
+  force
+}) {
+  if (force) {
+    logger.log(`${packages.length} package(s):`);
+    packages.forEach((pkg) => {
+      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (force)`);
+    });
+    logger.log("");
+  } else {
+    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
+    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
+    const packagesAsGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation");
+    if (packagesWithCommits.length > 0) {
+      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
+      packagesWithCommits.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsDependents.length > 0) {
+      logger.log(`${packagesAsDependents.length} dependent package(s):`);
+      packagesAsDependents.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsGraduation.length > 0) {
+      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
+      packagesAsGraduation.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
   }
-  logger.warn("Publish failed: OTP required");
-  try {
-    const otp = await promptOtpWithTimeout();
-    logger.debug("OTP received, retrying publish...");
-    return otp;
-  } catch (promptError) {
-    logger.error("Failed to get OTP:", promptError);
-    throw promptError;
+}
+function displayIndependentModePackages({
+  packages,
+  force
+}) {
+  if (force) {
+    logger.log(`${packages.length} package(s):`);
+    packages.forEach((pkg) => {
+      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (force)`);
+    });
+    logger.log("");
+  } else {
+    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
+    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
+    const packagesAsGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation");
+    if (packagesWithCommits.length > 0) {
+      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
+      packagesWithCommits.forEach((pkg) => {
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsDependents.length > 0) {
+      logger.log(`${packagesAsDependents.length} dependent package(s):`);
+      packagesAsDependents.forEach((pkg) => {
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsGraduation.length > 0) {
+      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
+      packagesAsGraduation.forEach((pkg) => {
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
   }
 }
-async function executePublishCommand({
-  command,
-  packageNameAndVersion,
-  pkg,
+async function confirmBump({
+  versionMode,
   config,
+  packages,
+  force,
+  currentVersion,
+  newVersion,
   dryRun
 }) {
-  logger.debug(`Executing publish command (${command}) in ${pkg.path}`);
-  if (dryRun) {
-    logger.info(`[dry-run] ${packageNameAndVersion}: Run ${command}`);
+  if (packages.length === 0) {
+    logger.debug("No packages to bump");
     return;
   }
-  const { stdout } = await execPromise(command, {
-    noStderr: true,
-    noStdout: true,
-    logLevel: config.logLevel,
-    cwd: pkg.path
+  const lernaJsonExists = hasLernaJson(config.cwd);
+  logger.log("");
+  logger.info(`${dryRun ? "[dry-run] " : ""}The following packages will be updated:
+`);
+  displayRootAndLernaUpdates({
+    versionMode,
+    currentVersion,
+    newVersion,
+    lernaJsonExists,
+    dryRun
   });
-  if (stdout) {
-    logger.debug(stdout);
+  if (versionMode === "unified") {
+    if (!newVersion) {
+      throw new Error("Cannot confirm bump in unified mode without a new version");
+    }
+    displayUnifiedModePackages({ packages, newVersion, force });
+  } else if (versionMode === "selective") {
+    if (!newVersion) {
+      throw new Error("Cannot confirm bump in selective mode without a new version");
+    }
+    displaySelectiveModePackages({ packages, newVersion, force });
+  } else if (versionMode === "independent") {
+    displayIndependentModePackages({ packages, force });
   }
-  logger.info(`Published ${packageNameAndVersion}`);
+  try {
+    const confirmed = await confirm({
+      message: `${dryRun ? "[dry-run] " : ""}Do you want to proceed with these version updates?`,
+      default: true
+    });
+    if (!confirmed) {
+      logger.log("");
+      logger.fail("Bump refused");
+      process.exit(0);
+    }
+  } catch (error) {
+    const userHasExited = error instanceof Error && error.name === "ExitPromptError";
+    if (userHasExited) {
+      logger.log("");
+      logger.fail("Bump cancelled");
+      process.exit(0);
+    }
+    logger.fail("Error while confirming bump");
+    process.exit(1);
+  }
+  logger.log("");
 }
-async function publishPackage({
-  pkg,
-  config,
-  packageManager,
+function getBumpedIndependentPackages({
+  packages,
   dryRun
 }) {
-  const tag = determinePublishTag(pkg.version, config.publish.tag);
-  const packageNameAndVersion = getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version });
-  const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
-  logger.debug(`Building publish command for ${pkg.name}`);
-  let dynamicOtp;
-  const maxAttempts = 2;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      const args = getCommandArgs({
-        packageManager,
-        tag,
-        config,
-        otp: dynamicOtp
-      });
-      const command = `${baseCommand} ${args.join(" ")}`;
-      logger.debug(`Publishing ${packageNameAndVersion} with tag '${tag}' with command: ${command}`);
-      process.chdir(pkg.path);
-      await executePublishCommand({
-        command,
-        packageNameAndVersion,
-        pkg,
-        config,
-        dryRun
+  const bumpedPackages = [];
+  for (const pkgToBump of packages) {
+    logger.debug(`Bumping ${pkgToBump.name} from ${pkgToBump.version} to ${pkgToBump.newVersion} (reason: ${pkgToBump.reason})`);
+    const result = getBumpedPackageIndependently({
+      pkg: pkgToBump,
+      dryRun
+    });
+    if (result.bumped) {
+      bumpedPackages.push({
+        ...pkgToBump,
+        version: result.oldVersion
       });
-      if (dynamicOtp && !sessionOtp) {
-        sessionOtp = dynamicOtp;
-        logger.debug("OTP stored for session");
-      }
-      return;
-    } catch (error) {
-      if (isOtpError(error) && attempt < maxAttempts - 1) {
-        dynamicOtp = await handleOtpError();
-      } else {
-        logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
-        throw error;
-      }
-    } finally {
-      process.chdir(config.cwd);
     }
   }
+  return bumpedPackages;
 }
 
-function readPackageJson(packagePath) {
-  const packageJsonPath = join(packagePath, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    logger.fail(`package.json not found at ${packageJsonPath}`);
-    return;
-  }
-  if (!statSync(packagePath).isDirectory()) {
-    logger.fail(`Not a directory: ${packagePath}`);
-    return;
-  }
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  if (!packageJson.name || !packageJson.version) {
-    throw new Error(`Invalid package.json at ${packagePath}`);
-  }
-  return {
-    name: packageJson.name,
-    version: packageJson.version,
-    private: packageJson.private || false,
-    path: packagePath
-  };
+function getIndependentTag({ version, name }) {
+  return `${name}@${version}`;
 }
-async function getRootPackage({
-  config,
-  force,
-  from,
-  to,
-  suffix,
-  changelog
-}) {
-  try {
-    const packageJson = readPackageJson(config.cwd);
-    if (!packageJson) {
-      throw new Error("Failed to read root package.json");
-    }
-    const commits = await getPackageCommits({
-      pkg: packageJson,
-      from,
-      to,
-      config,
-      changelog
-    });
-    let newVersion;
-    if (config.monorepo?.versionMode !== "independent") {
-      const releaseType = determineReleaseType({
-        currentVersion: packageJson.version,
-        commits,
-        releaseType: config.bump.type,
-        preid: config.bump.preid,
-        types: config.types,
-        force
-      });
-      if (!releaseType) {
-        logger.fail("No commits require a version bump");
-        process.exit(0);
-      }
-      newVersion = getPackageNewVersion({
-        currentVersion: packageJson.version,
-        releaseType,
-        preid: config.bump.preid,
-        suffix
-      });
+async function getLastStableTag({ logLevel, cwd }) {
+  const { stdout } = await execPromise(
+    `git tag --sort=-creatordate | grep -E '^[^0-9]*[0-9]+\\.[0-9]+\\.[0-9]+$' | head -n 1`,
+    {
+      logLevel,
+      noStderr: true,
+      noStdout: true,
+      noSuccess: true,
+      cwd
     }
-    return {
-      ...packageJson,
-      path: config.cwd,
-      fromTag: from,
-      commits,
-      newVersion
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(errorMessage);
+  );
+  const lastTag = stdout.trim();
+  logger.debug("Last stable tag:", lastTag || "No stable tags found");
+  return lastTag;
+}
+async function getLastTag({ logLevel, cwd }) {
+  const { stdout } = await execPromise(`git tag --sort=-creatordate | head -n 1`, {
+    logLevel,
+    noStderr: true,
+    noStdout: true,
+    noSuccess: true,
+    cwd
+  });
+  const lastTag = stdout.trim();
+  logger.debug("Last tag:", lastTag || "No tags found");
+  return lastTag;
+}
+function getLastRepoTag(options) {
+  if (options?.onlyStable) {
+    return getLastStableTag({ logLevel: options?.logLevel, cwd: options?.cwd });
   }
+  return getLastTag({ logLevel: options?.logLevel, cwd: options?.cwd });
 }
-function readPackages({
-  cwd,
-  patterns,
-  ignorePackageNames
+async function getLastPackageTag({
+  packageName,
+  onlyStable,
+  logLevel,
+  cwd
 }) {
-  const packages = [];
-  const foundPaths = /* @__PURE__ */ new Set();
-  const patternsSet = new Set(patterns);
-  if (!patterns)
-    patternsSet.add(".");
-  logger.debug(`Read package.json files from patterns: ${patternsSet.values()}`);
-  for (const pattern of patternsSet) {
-    try {
-      const matches = fastGlob.sync(pattern, {
-        cwd,
-        onlyDirectories: true,
-        absolute: true,
-        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
-      });
-      for (const matchPath of matches) {
-        if (foundPaths.has(matchPath))
-          continue;
-        const packageBase = readPackageJson(matchPath);
-        if (!packageBase || packageBase.private || ignorePackageNames?.includes(packageBase.name))
-          continue;
-        foundPaths.add(matchPath);
-        packages.push({
-          ...packageBase,
-          path: matchPath
-        });
-      }
-    } catch (error) {
-      logger.error(error);
+  try {
+    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
+    let grepPattern;
+    if (onlyStable) {
+      grepPattern = `^${escapedPackageName}@[0-9]+\\.[0-9]+\\.[0-9]+$`;
+    } else {
+      grepPattern = `^${escapedPackageName}@`;
     }
+    const { stdout } = await execPromise(
+      `git tag --sort=-creatordate | grep -E '${grepPattern}' | sed -n '1p'`,
+      {
+        logLevel,
+        noStderr: true,
+        noStdout: true,
+        noSuccess: true,
+        cwd
+      }
+    );
+    const tag = stdout.trim();
+    return tag || null;
+  } catch {
+    return null;
   }
-  return packages;
 }
-function getPackageReleaseType({
-  pkg,
+async function resolveFromTagIndependent({
+  cwd,
+  packageName,
+  graduating,
+  logLevel
+}) {
+  const lastPackageTag = await getLastPackageTag({
+    packageName,
+    onlyStable: graduating,
+    logLevel
+  });
+  if (!lastPackageTag) {
+    return getFirstCommit(cwd);
+  }
+  return lastPackageTag;
+}
+async function resolveFromTagUnified({
   config,
-  force
+  graduating,
+  logLevel
 }) {
-  const releaseType = config.bump.type;
-  if (force) {
-    return determineReleaseType({
-      currentVersion: pkg.version,
-      commits: pkg.commits,
-      releaseType,
-      preid: config.bump.preid,
-      types: config.types,
-      force
+  const from = await getLastRepoTag({ onlyStable: graduating, logLevel }) || getFirstCommit(config.cwd);
+  return from;
+}
+async function resolveFromTag({
+  config,
+  versionMode,
+  step,
+  packageName,
+  graduating,
+  logLevel
+}) {
+  let from;
+  if (versionMode === "independent") {
+    if (!packageName) {
+      throw new Error("Package name is required for independent version mode");
+    }
+    from = await resolveFromTagIndependent({
+      cwd: config.cwd,
+      packageName,
+      graduating,
+      logLevel
+    });
+  } else {
+    from = await resolveFromTagUnified({
+      config,
+      graduating,
+      logLevel
     });
   }
-  if (pkg.reason === "dependency") {
-    if (isStableReleaseType(releaseType))
-      return "patch";
-    if (isPrerelease(pkg.version))
-      return "prerelease";
-    return "prepatch";
+  logger.debug(`[${versionMode}](${step}) Using from tag: ${from}`);
+  return config.from || from;
+}
+function resolveToTag({
+  config,
+  versionMode,
+  newVersion,
+  step,
+  packageName
+}) {
+  const isUntaggedStep = step === "bump" || step === "changelog";
+  let to;
+  if (isUntaggedStep) {
+    to = getCurrentGitRef(config.cwd);
+  } else if (versionMode === "independent") {
+    if (!packageName) {
+      throw new Error("Package name is required for independent version mode");
+    }
+    if (!newVersion) {
+      throw new Error("New version is required for independent version mode");
+    }
+    to = getIndependentTag({ version: newVersion, name: packageName });
+  } else {
+    to = newVersion ? config.templates.tagBody.replace("{{newVersion}}", newVersion) : getCurrentGitRef(config.cwd);
   }
-  return determineReleaseType({
-    currentVersion: pkg.version,
-    commits: pkg.commits,
-    releaseType,
-    preid: config.bump.preid,
-    types: config.types,
-    force
-  });
+  logger.debug(`[${versionMode}](${step}) Using to tag: ${to}`);
+  return config.to || to;
 }
-async function getPackages({
-  patterns,
+async function resolveTags({
   config,
-  suffix,
-  force
+  step,
+  pkg,
+  newVersion
 }) {
-  const readedPackages = readPackages({
-    cwd: config.cwd,
-    patterns,
-    ignorePackageNames: config.monorepo?.ignorePackageNames
+  const versionMode = config.monorepo?.versionMode || "standalone";
+  const logLevel = config.logLevel;
+  logger.debug(`[${versionMode}](${step}) Resolving tags`);
+  const releaseType = config.bump.type;
+  const graduating = typeof newVersion === "string" ? isGraduatingToStableBetweenVersion(pkg.version, newVersion) : isGraduating(pkg.version, releaseType);
+  const from = await resolveFromTag({
+    config,
+    versionMode,
+    step,
+    packageName: pkg.name,
+    graduating,
+    logLevel
   });
-  const packages = /* @__PURE__ */ new Map();
-  const foundPaths = /* @__PURE__ */ new Set();
-  const patternsSet = new Set(patterns);
-  if (!patterns)
-    patternsSet.add(".");
-  logger.debug(`Getting packages from patterns: ${patternsSet.values()}`);
-  for (const pattern of patternsSet) {
-    const matches = fastGlob.sync(pattern, {
-      cwd: config.cwd,
-      onlyDirectories: true,
-      absolute: true,
-      ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
-    });
-    for (const matchPath of matches) {
-      if (foundPaths.has(matchPath))
-        continue;
-      const packageBase = readPackageJson(matchPath);
-      if (!packageBase) {
-        logger.debug(`Failed to read package.json at ${matchPath} - ignored`);
-        continue;
-      }
-      if (packageBase.private) {
-        logger.debug(`${packageBase.name} is private and will be ignored`);
-        continue;
+  const to = resolveToTag({
+    config,
+    versionMode,
+    newVersion,
+    step,
+    packageName: pkg.name
+  });
+  logger.debug(`[${versionMode}](${step}) Using tags: ${from} \u2192 ${to}`);
+  return { from, to };
+}
+
+let sessionOtp;
+function detectPackageManager(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = join(cwd, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        const pmField = packageJson.packageManager;
+        if (typeof pmField === "string") {
+          const pmName = pmField.split("@")[0];
+          if (["npm", "pnpm", "yarn", "bun"].includes(pmName)) {
+            logger.debug(`Detected package manager from package.json: ${pmName}`);
+            return pmName;
+          }
+        }
+      } catch (e) {
+        const errorString = e instanceof Error ? e.message : String(e);
+        logger.debug(`Failed to parse package.json: ${errorString}`);
       }
-      if (config.monorepo?.ignorePackageNames?.includes(packageBase.name)) {
-        logger.debug(`${packageBase.name} ignored by config (monorepo.ignorePackageNames)`);
-        continue;
+    }
+    const lockFiles = {
+      pnpm: "pnpm-lock.yaml",
+      yarn: "yarn.lock",
+      npm: "package-lock.json",
+      bun: "bun.lockb"
+    };
+    for (const [manager, file] of Object.entries(lockFiles)) {
+      if (existsSync(join(cwd, file))) {
+        logger.debug(`Detected package manager from lockfile: ${manager}`);
+        return manager;
       }
-      if (!packageBase.version) {
-        logger.warn(`${packageBase.name} has no version and will be ignored`);
-        continue;
+    }
+    const ua = process.env.npm_config_user_agent;
+    if (ua) {
+      const match = /(pnpm|yarn|npm|bun)/.exec(ua);
+      if (match) {
+        logger.debug(`Detected package manager from user agent: ${match[1]}`);
+        return match[1];
       }
-      const { from, to } = await resolveTags({
-        config,
-        step: "bump",
-        pkg: packageBase,
-        newVersion: void 0
-      });
-      const commits = await getPackageCommits({
-        pkg: packageBase,
-        from,
-        to,
-        config,
-        changelog: false
-      });
-      foundPaths.add(matchPath);
-      const dependencies = getPackageDependencies({
-        packagePath: matchPath,
-        allPackageNames: new Set(readedPackages.map((p) => p.name)),
-        dependencyTypes: config.bump?.dependencyTypes
-      });
-      packages.set(packageBase.name, {
-        ...packageBase,
-        path: matchPath,
-        fromTag: from,
-        dependencies,
-        commits,
-        reason: commits.length > 0 ? "commits" : void 0,
-        dependencyChain: void 0,
-        newVersion: void 0
-      });
     }
+    logger.debug("No package manager detected, defaulting to npm");
+    return "npm";
+  } catch (error) {
+    logger.fail(`Error detecting package manager: ${error}, defaulting to npm`);
+    return "npm";
+  }
+}
+function determinePublishTag(version, configTag) {
+  let tag = "latest";
+  if (configTag) {
+    tag = configTag;
+  }
+  if (isPrerelease(version) && !configTag) {
+    logger.warn('You are about to publish a "prerelease" version with the "latest" tag. To avoid mistake, the tag is set to "next"');
+    tag = "next";
   }
-  const packagesArray = Array.from(packages.values());
-  const packagesWithCommits = packagesArray.filter((p) => p.commits.length > 0);
-  const expandedPackages = expandPackagesToBumpWithDependents({
-    allPackages: packagesArray,
-    packagesWithCommits
-  });
-  for (const pkg of expandedPackages) {
-    packages.set(pkg.name, pkg);
+  if (isPrerelease(version) && configTag === "latest") {
+    logger.warn('Please note, you are about to publish a "prerelease" version with the "latest" tag.');
   }
-  for (const pkg of Array.from(packages.values())) {
-    const releaseType = getPackageReleaseType({
-      pkg,
+  return tag;
+}
+function getPackagesToPublishInSelectiveMode(sortedPackages, rootVersion) {
+  const packagesToPublish = [];
+  for (const pkg of sortedPackages) {
+    const pkgJsonPath = join(pkg.path, "package.json");
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    if (pkgJson.version === rootVersion) {
+      packagesToPublish.push(pkg);
+    }
+  }
+  return packagesToPublish;
+}
+async function getPackagesToPublishInIndependentMode(sortedPackages, config) {
+  const packagesToPublish = [];
+  for (const pkg of sortedPackages) {
+    const { from, to } = await resolveTags({
       config,
-      force
-    });
-    const newVersion = releaseType ? getPackageNewVersion({
-      currentVersion: pkg.version,
-      releaseType,
-      preid: config.bump.preid,
-      suffix
-    }) : void 0;
-    const graduating = releaseType && isGraduating(pkg.version, releaseType) || isChangedPreid(pkg.version, config.bump.preid);
-    packages.set(pkg.name, {
-      ...pkg,
-      newVersion,
-      reason: pkg.reason || releaseType && graduating && "graduation" || void 0
+      step: "publish",
+      pkg,
+      newVersion: pkg.newVersion || pkg.version
     });
+    if (pkg.commits.length > 0) {
+      packagesToPublish.push(pkg);
+      logger.debug(`${pkg.name}: ${pkg.commits.length} commit(s) since ${from} \u2192 ${to}`);
+    }
   }
-  const packagesToBump = Array.from(packages.values()).filter((p) => p.reason || force);
-  if (packagesToBump.length === 0) {
-    logger.debug("No packages to bump");
-    return [];
-  }
-  return packagesToBump;
+  return packagesToPublish;
 }
-function isAllowedCommit({
-  commit,
-  type,
-  changelog
+function isYarnBerry() {
+  return existsSync(path.join(process.cwd(), ".yarnrc.yml"));
+}
+function getCommandArgs({
+  packageManager,
+  tag,
+  config,
+  otp
 }) {
-  if (commit.type === "chore" && ["deps", "release"].includes(commit.scope) && !commit.isBreaking) {
-    return false;
+  const args = ["publish", "--tag", tag];
+  if (packageManager === "pnpm") {
+    args.push("--no-git-checks");
+  } else if (packageManager === "yarn") {
+    args.push("--non-interactive");
+    if (isYarnBerry())
+      args.push("--no-git-checks");
+  } else if (packageManager === "npm") {
+    args.push("--yes");
   }
-  if (typeof type === "object") {
-    return !!type.semver || changelog && !!type.title;
+  const registry = config.publish.registry;
+  if (registry) {
+    args.push("--registry", registry);
   }
-  if (typeof type === "boolean") {
-    return type;
+  const access = config.publish.access;
+  if (access) {
+    args.push("--access", access);
   }
-  return false;
+  const finalOtp = otp ?? sessionOtp ?? config.publish.otp;
+  if (finalOtp) {
+    args.push("--otp", finalOtp);
+  }
+  return args;
 }
-async function getPackageCommits({
+function isOtpError(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const errorMessage = "message" in error && typeof error.message === "string" ? error.message.toLowerCase() : "";
+  return errorMessage.includes("otp") || errorMessage.includes("one-time password") || errorMessage.includes("eotp");
+}
+function promptOtpWithTimeout(timeout = 9e4) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("OTP input timeout"));
+    }, timeout);
+    input({
+      message: "This operation requires a one-time password (OTP). Please enter your OTP:"
+    }).then((otp) => {
+      clearTimeout(timer);
+      resolve(otp);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+async function handleOtpError() {
+  if (isInCI()) {
+    logger.error("OTP required but running in CI environment. Please provide OTP via config or `--otp` flag");
+    throw new Error("OTP required in CI environment");
+  }
+  logger.warn("Publish failed: OTP required");
+  try {
+    const otp = await promptOtpWithTimeout();
+    logger.debug("OTP received, retrying publish...");
+    return otp;
+  } catch (promptError) {
+    logger.error("Failed to get OTP:", promptError);
+    throw promptError;
+  }
+}
+async function executePublishCommand({
+  command,
+  packageNameAndVersion,
   pkg,
-  from,
-  to,
   config,
-  changelog
+  dryRun
 }) {
-  logger.debug(`Analyzing commits for ${pkg.name} since ${from} to ${to}`);
-  const changelogConfig = {
-    ...config,
-    from,
-    to
-  };
-  const rawCommits = await getGitDiff(from, to, changelogConfig.cwd);
-  const allCommits = parseCommits(rawCommits, changelogConfig);
-  const hasBreakingChanges = allCommits.some((commit) => commit.isBreaking);
-  logger.debug(`Has breaking changes: ${hasBreakingChanges}`);
-  const rootPackage = readPackageJson(changelogConfig.cwd);
-  if (!rootPackage) {
-    throw new Error("Failed to read root package.json");
+  logger.debug(`Executing publish command (${command}) in ${pkg.path}`);
+  if (dryRun) {
+    logger.info(`[dry-run] ${packageNameAndVersion}: Run ${command}`);
+    return;
   }
-  const commits = allCommits.filter((commit) => {
-    const type = changelogConfig?.types[commit.type];
-    if (!isAllowedCommit({ commit, type, changelog })) {
-      return false;
-    }
-    if (pkg.path === changelogConfig.cwd || pkg.name === rootPackage.name) {
-      return true;
-    }
-    const packageRelativePath = relative(changelogConfig.cwd, pkg.path);
-    const scopeMatches = commit.scope === pkg.name;
-    const bodyContainsPath = commit.body.includes(packageRelativePath);
-    return scopeMatches || bodyContainsPath;
+  const { stdout } = await execPromise(command, {
+    noStderr: true,
+    noStdout: true,
+    logLevel: config.logLevel,
+    cwd: pkg.path
   });
-  logger.debug(`Found ${commits.length} commit(s) for ${pkg.name} from ${from} to ${to}`);
-  if (commits.length > 0) {
-    logger.debug(`${pkg.name}: ${commits.length} commit(s) found`);
-  } else {
-    logger.debug(`${pkg.name}: No commits found`);
+  if (stdout) {
+    logger.debug(stdout);
   }
-  return commits;
+  logger.info(`Published ${packageNameAndVersion}`);
 }
-function hasLernaJson(rootDir) {
-  const lernaJsonPath = join(rootDir, "lerna.json");
-  return existsSync(lernaJsonPath);
+async function publishPackage({
+  pkg,
+  config,
+  packageManager,
+  dryRun
+}) {
+  const tag = determinePublishTag(pkg.newVersion || pkg.version, config.publish.tag);
+  const packageNameAndVersion = getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version });
+  const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
+  logger.debug(`Building publish command for ${pkg.name}`);
+  let dynamicOtp;
+  const maxAttempts = 2;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const args = getCommandArgs({
+        packageManager,
+        tag,
+        config,
+        otp: dynamicOtp
+      });
+      const command = `${baseCommand} ${args.join(" ")}`;
+      logger.debug(`Publishing ${packageNameAndVersion} with tag '${tag}' with command: ${command}`);
+      process.chdir(pkg.path);
+      await executePublishCommand({
+        command,
+        packageNameAndVersion,
+        pkg,
+        config,
+        dryRun
+      });
+      if (dynamicOtp && !sessionOtp) {
+        sessionOtp = dynamicOtp;
+        logger.debug("OTP stored for session");
+      }
+      return;
+    } catch (error) {
+      if (isOtpError(error) && attempt < maxAttempts - 1) {
+        dynamicOtp = await handleOtpError();
+      } else {
+        logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
+        throw error;
+      }
+    } finally {
+      process.chdir(config.cwd);
+    }
+  }
 }
 
 async function bumpUnifiedMode({
@@ -2744,22 +2771,6 @@ async function bump(options = {}) {
   }
 }
 
-async function getPackagesToGenerateChangelogFor({
-  config,
-  bumpResult,
-  suffix,
-  force
-}) {
-  if (bumpResult?.bumpedPackages && bumpResult.bumpedPackages.length > 0) {
-    return bumpResult.bumpedPackages;
-  }
-  return await getPackages({
-    config,
-    patterns: config.monorepo?.packages,
-    suffix,
-    force
-  });
-}
 async function generateIndependentRootChangelog({
   packages,
   config,
@@ -2819,10 +2830,11 @@ async function generateSimpleRootChangelog({
   if (!rootPackageRead) {
     throw new Error("Failed to read root package.json");
   }
+  const newVersion = bumpResult?.newVersion || rootPackageRead.version;
   const { from, to } = await resolveTags({
     config,
     step: "changelog",
-    newVersion: void 0,
+    newVersion,
     pkg: rootPackageRead
   });
   const fromTag = bumpResult?.fromTag || from;
@@ -2835,7 +2847,6 @@ async function generateSimpleRootChangelog({
     to
   });
   logger.debug(`Generating ${rootPackage.name} changelog (${fromTag}...${to})`);
-  const newVersion = bumpResult?.newVersion || rootPackage.version;
   const rootChangelog = await generateChangelog({
     pkg: rootPackage,
     config,
@@ -2876,7 +2887,7 @@ async function changelog(options = {}) {
     logger.start("Start generating changelogs");
     if (config.changelog?.rootChangelog && config.monorepo) {
       if (config.monorepo.versionMode === "independent") {
-        const packages2 = await getPackagesToGenerateChangelogFor({
+        const packages2 = await getPackagesOrBumpedPackages({
           config,
           bumpResult: options.bumpResult,
           suffix: options.suffix,
@@ -2900,27 +2911,28 @@ async function changelog(options = {}) {
       logger.debug("Skipping root changelog generation");
     }
     logger.debug("Generating package changelogs...");
-    const packages = options.bumpResult?.bumpedPackages ? options.bumpResult.bumpedPackages : await getPackages({
+    const packages = await getPackagesOrBumpedPackages({
       config,
-      patterns: config.monorepo?.packages,
+      bumpResult: options.bumpResult,
       suffix: options.suffix,
       force: options.force ?? false
     });
     logger.debug(`Processing ${packages.length} package(s)`);
     let generatedCount = 0;
     for await (const pkg of packages) {
+      const newVersion = options.bumpResult?.bumpedPackages?.find((p) => p.name === pkg.name)?.newVersion || pkg.newVersion || pkg.version;
       const { from, to } = await resolveTags({
         config,
         step: "changelog",
         pkg,
-        newVersion: void 0
+        newVersion
       });
       logger.debug(`Processing ${pkg.name} (${from}...${to})`);
       const changelog2 = await generateChangelog({
         pkg,
         config,
         dryRun,
-        newVersion: options.bumpResult?.bumpedPackages?.find((p) => p.name === pkg.name)?.newVersion
+        newVersion
       });
       if (changelog2) {
         writeChangelogToFile({
@@ -3064,9 +3076,9 @@ async function publish(options = {}) {
       throw new Error("Failed to read root package.json");
     }
     logger.start("Start publishing packages");
-    const packages = options.bumpedPackages || await getPackages({
+    const packages = await getPackagesOrBumpedPackages({
       config,
-      patterns: config.publish.packages ?? config.monorepo?.packages,
+      bumpResult: options.bumpResult,
       suffix: options.suffix,
       force: options.force ?? false
     });
@@ -3259,7 +3271,7 @@ async function release(options = {}) {
         tag: config.publish.tag,
         access: config.publish.access,
         otp: config.publish.otp,
-        bumpedPackages: bumpResult.bumpedPackages,
+        bumpResult,
         dryRun,
         config,
         configName: options.configName,
@@ -3314,4 +3326,4 @@ Git provider: ${provider}`);
   }
 }
 
-export { writeVersion as $, createGitlabRelease as A, gitlab as B, detectPackageManager as C, determinePublishTag as D, getPackagesToPublishInSelectiveMode as E, getPackagesToPublishInIndependentMode as F, publishPackage as G, readPackageJson as H, getRootPackage as I, readPackages as J, getPackages as K, getPackageCommits as L, hasLernaJson as M, getIndependentTag as N, getLastStableTag as O, getLastTag as P, getLastRepoTag as Q, getLastPackageTag as R, resolveTags as S, executeHook as T, isInCI as U, getCIName as V, executeFormatCmd as W, executeBuildCmd as X, isBumpedPackage as Y, determineSemverChange as Z, determineReleaseType as _, providerRelease as a, getPackageNewVersion as a0, updateLernaVersion as a1, extractVersionFromPackageTag as a2, isPrerelease as a3, isStableReleaseType as a4, isPrereleaseReleaseType as a5, isGraduating as a6, getPreid as a7, isChangedPreid as a8, getBumpedPackageIndependently as a9, confirmBump as aa, getBumpedIndependentPackages as ab, bump as b, changelog as c, publish as d, getDefaultConfig as e, defineConfig as f, generateChangelog as g, getPackageDependencies as h, getDependentsOf as i, expandPackagesToBumpWithDependents as j, getGitStatus as k, loadRelizyConfig as l, checkGitStatusIfDirty as m, fetchGitTags as n, detectGitProvider as o, providerReleaseSafetyCheck as p, parseGitRemoteUrl as q, release as r, createCommitAndTags as s, topologicalSort as t, pushCommitAndTags as u, getFirstCommit as v, writeChangelogToFile as w, getCurrentGitBranch as x, getCurrentGitRef as y, github as z };
+export { determineSemverChange as $, createGitlabRelease as A, gitlab as B, detectPackageManager as C, determinePublishTag as D, getPackagesToPublishInSelectiveMode as E, getPackagesToPublishInIndependentMode as F, publishPackage as G, readPackageJson as H, getRootPackage as I, readPackages as J, getPackages as K, getPackageCommits as L, hasLernaJson as M, getIndependentTag as N, getLastStableTag as O, getLastTag as P, getLastRepoTag as Q, getLastPackageTag as R, resolveTags as S, executeHook as T, isInCI as U, getCIName as V, executeFormatCmd as W, executeBuildCmd as X, isBumpedPackage as Y, getPackagesOrBumpedPackages as Z, isGraduatingToStableBetweenVersion as _, providerRelease as a, determineReleaseType as a0, writeVersion as a1, getPackageNewVersion as a2, updateLernaVersion as a3, extractVersionFromPackageTag as a4, isPrerelease as a5, isStableReleaseType as a6, isPrereleaseReleaseType as a7, isGraduating as a8, getPreid as a9, isChangedPreid as aa, getBumpedPackageIndependently as ab, confirmBump as ac, getBumpedIndependentPackages as ad, bump as b, changelog as c, publish as d, getDefaultConfig as e, defineConfig as f, generateChangelog as g, getPackageDependencies as h, getDependentsOf as i, expandPackagesToBumpWithDependents as j, getGitStatus as k, loadRelizyConfig as l, checkGitStatusIfDirty as m, fetchGitTags as n, detectGitProvider as o, providerReleaseSafetyCheck as p, parseGitRemoteUrl as q, release as r, createCommitAndTags as s, topologicalSort as t, pushCommitAndTags as u, getFirstCommit as v, writeChangelogToFile as w, getCurrentGitBranch as x, getCurrentGitRef as y, github as z };