relizy 0.2.4 → 0.2.5-beta.1

package/dist/shared/{relizy.ukhs2-Vt.mjs → relizy.DYn3rUjq.mjs}

@@ -1,11 +1,11 @@
 import { logger, execPromise } from '@maz-ui/node';
 import { execSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync, statSync } from 'node:fs';
-import path, { join } from 'node:path';
+import path, { join, relative } from 'node:path';
 import process$1 from 'node:process';
 import { upperFirst, formatJson } from '@maz-ui/utils';
 import { setupDotenv, loadConfig } from 'c12';
-import { formatCompareChanges, formatReference, resolveRepoConfig, getRepoConfig, createGithubRelease, getGitDiff, parseCommits, determineSemverChange } from 'changelogen';
+import { formatCompareChanges, formatReference, resolveRepoConfig, getRepoConfig, createGithubRelease, getGitDiff, parseCommits } from 'changelogen';
 import { defu } from 'defu';
 import fastGlob from 'fast-glob';
 import { confirm, input } from '@inquirer/prompts';
@@ -13,154 +13,6 @@ import * as semver from 'semver';
 import { convert } from 'convert-gitmoji';
 import { fetch as fetch$1 } from 'node-fetch-native';
 
-async function generateMarkDown({
-  commits,
-  config,
-  from,
-  to
-}) {
-  const typeGroups = groupBy(commits, "type");
-  const markdown = [];
-  const breakingChanges = [];
-  const updatedConfig = {
-    ...config,
-    from,
-    to
-  };
-  const versionTitle = updatedConfig.to;
-  markdown.push("", `## ${versionTitle || `${updatedConfig.from || ""}...${updatedConfig.to}`}`, "");
-  if (updatedConfig.repo && updatedConfig.from && versionTitle) {
-    const formattedCompareLink = formatCompareChanges(versionTitle, updatedConfig);
-    markdown.push(formattedCompareLink);
-  }
-  for (const type in updatedConfig.types) {
-    const group = typeGroups[type];
-    if (!group || group.length === 0) {
-      continue;
-    }
-    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);
-      }
-    }
-  }
-  if (breakingChanges.length > 0) {
-    markdown.push("", "#### \u26A0\uFE0F Breaking Changes", "", ...breakingChanges);
-  }
-  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 });
-    }
-  }
-  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 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 || ""}`;
-      })
-    );
-  }
-  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 = /^[AMDRC]\s+/.test(trimmedLine);
-    const R100 = /R100\s+/.test(trimmedLine);
-    return !isFileLine && !R100;
-  });
-  if (contentLines.length === 0) {
-    return "";
-  }
-  const indentedBody = contentLines.map((line) => `  ${line}`).join("\n");
-  return `
-
-${indentedBody}
-`;
-}
-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 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)})`;
-  }
-  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);
-  }
-  return groups;
-}
-
 async function executeHook(hook, config, dryRun, params) {
   const hookInput = config.hooks?.[hook];
   if (!hookInput) {
@@ -291,23 +143,406 @@ async function executeBuildCmd({
     logger.debug("No build command specified");
   }
 }
+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);
+  }
+}
+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 detectGitProvider(cwd = process.cwd()) {
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf8"
+    }).trim();
+    if (remoteUrl.includes("github.com")) {
+      return "github";
+    }
+    if (remoteUrl.includes("gitlab.com") || remoteUrl.includes("gitlab")) {
+      return "gitlab";
+    }
+    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]
+    };
+  }
+  const httpsMatch = remoteUrl.match(httpsRegex);
+  if (httpsMatch) {
+    return {
+      owner: httpsMatch[1],
+      repo: httpsMatch[2]
+    };
+  }
+  return null;
+}
+async function createCommitAndTags({
+  config,
+  noVerify,
+  bumpedPackages,
+  newVersion,
+  dryRun,
+  logLevel
+}) {
+  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 {
+      }
+    }
+    const rootPackage = readPackageJson(internalConfig.cwd);
+    newVersion = newVersion || rootPackage.version;
+    const versionForMessage = internalConfig.monorepo?.versionMode === "independent" ? bumpedPackages?.map((pkg) => getIndependentTag(pkg)).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
+      });
+      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) {
+      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 {
+      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({ dryRun, logLevel, cwd }) {
+  logger.start("Start push changes and tags");
+  if (dryRun) {
+    logger.info("[dry-run] git push --follow-tags");
+  } else {
+    logger.debug("Executing: git push --follow-tags");
+    await execPromise("git push --follow-tags", { 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";
+}
+
+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;
+    }
+    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);
+      }
+    }
+  }
+  if (breakingChanges.length > 0) {
+    markdown.push("", "#### \u26A0\uFE0F Breaking Changes", "", ...breakingChanges);
+  }
+  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 });
+    }
+  }
+  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 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 || ""}`;
+      })
+    );
+  }
+  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 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 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)})`;
+  }
+  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);
+  }
+  return groups;
+}
 
 function fromTagIsFirstCommit(fromTag, cwd) {
   return fromTag === getFirstCommit(cwd);
 }
 async function generateChangelog({
   pkg,
-  commits,
   config,
-  from,
-  dryRun
+  dryRun,
+  newVersion
 }) {
-  let fromTag = config.from || (config.monorepo?.versionMode === "independent" ? `${pkg.name}@${pkg.currentVersion}` : config.templates.tagBody.replace("{{newVersion}}", pkg.currentVersion)) || from;
+  let fromTag = config.from || pkg.fromTag || getFirstCommit(config.cwd);
   const isFirstCommit = fromTagIsFirstCommit(fromTag, config.cwd);
   if (isFirstCommit) {
-    fromTag = config.monorepo?.versionMode === "independent" ? `${pkg.name}@0.0.0` : config.templates.tagBody.replace("{{newVersion}}", "0.0.0");
+    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 (!toTag) {
+    throw new Error(`No tag found for ${pkg.name}`);
   }
-  const toTag = config.to || (config.monorepo?.versionMode === "independent" ? `${pkg.name}@${pkg.version}` : config.templates.tagBody.replace("{{newVersion}}", pkg.version));
   logger.debug(`Generating changelog for ${pkg.name} - from ${fromTag} to ${toTag}`);
   try {
     config = {
@@ -316,25 +551,26 @@ async function generateChangelog({
       to: toTag
     };
     const generatedChangelog = await generateMarkDown({
-      commits,
+      commits: pkg.commits,
       config,
       from: fromTag,
+      isFirstCommit,
       to: toTag
     });
     let changelog = generatedChangelog;
-    if (commits.length === 0) {
+    if (pkg.commits.length === 0) {
       changelog = `${changelog}
 
 ${config.templates.emptyChangelogContent}`;
     }
     const changelogResult = await executeHook("generate:changelog", config, dryRun, {
-      commits,
+      commits: pkg.commits,
       changelog
     });
     changelog = changelogResult || changelog;
     logger.verbose(`Output changelog for ${pkg.name}:
 ${changelog}`);
-    logger.debug(`Changelog generated for ${pkg.name} (${commits.length} commits)`);
+    logger.debug(`Changelog generated for ${pkg.name} (${pkg.commits.length} commits)`);
     logger.verbose(`Final changelog for ${pkg.name}:
 
 ${changelog}
@@ -349,6 +585,7 @@ ${changelog}
   }
 }
 function writeChangelogToFile({
+  cwd,
   pkg,
   changelog,
   dryRun = false
@@ -372,11 +609,12 @@ ${changelog}
 ${existingChangelog}`;
   }
   if (dryRun) {
-    logger.info(`[dry-run] ${pkg.name} - Write changelog to ${changelogPath}`);
+    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}`);
+    logger.info(`Changelog updated for ${pkg.name} (${"newVersion" in pkg && pkg.newVersion || pkg.version})`);
   }
 }
 
@@ -398,8 +636,8 @@ function getDefaultConfig() {
       ci: { title: "\u{1F916} CI" }
     },
     templates: {
-      commitMessage: "chore(release): bump version to v{{newVersion}}",
-      tagMessage: "Bump version to v{{newVersion}}",
+      commitMessage: "chore(release): bump version to {{newVersion}}",
+      tagMessage: "Bump version to {{newVersion}}",
       tagBody: "v{{newVersion}}",
       emptyChangelogContent: "No relevant changes for this release"
     },
@@ -490,7 +728,11 @@ function defineConfig(config) {
   return config;
 }
 
-function getPackageDependencies(packagePath, allPackageNames, dependencyTypes) {
+function getPackageDependencies({
+  packagePath,
+  allPackageNames,
+  dependencyTypes
+}) {
   const packageJsonPath = join(packagePath, "package.json");
   if (!existsSync(packageJsonPath)) {
     return [];
@@ -509,32 +751,26 @@ function getPackageDependencies(packagePath, allPackageNames, dependencyTypes) {
   }
   return deps;
 }
-function getPackagesWithDependencies(packages, dependencyTypes) {
-  const allPackageNames = new Set(packages.map((p) => p.name));
-  return packages.map((pkg) => ({
-    ...pkg,
-    dependencies: getPackageDependencies(pkg.path, allPackageNames, dependencyTypes)
-  }));
-}
-function getDependentsOf(packageName, allPackages) {
+function getDependentsOf({
+  allPackages,
+  packageName
+}) {
   return allPackages.filter(
     (pkg) => pkg.dependencies.includes(packageName)
   );
 }
 function expandPackagesToBumpWithDependents({
-  packagesWithCommits,
   allPackages,
-  dependencyTypes
+  packagesWithCommits
 }) {
-  const packagesWithDeps = getPackagesWithDependencies(allPackages, dependencyTypes);
   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) {
-    result.set(pkg.name, {
+    const packageToBump = {
       ...pkg,
-      reason: "commits",
-      commits: pkg.commits
-    });
+      reason: "commits"
+    };
+    result.set(pkg.name, packageToBump);
   }
   const toProcess = [...packagesWithCommits.map((p) => p.name)];
   const processed = /* @__PURE__ */ new Set();
@@ -544,19 +780,22 @@ function expandPackagesToBumpWithDependents({
       continue;
     }
     processed.add(currentPkgName);
-    const dependents = getDependentsOf(currentPkgName, packagesWithDeps);
+    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 packageInfo = allPackages.find((p) => p.name === dependent.name);
-        if (packageInfo) {
-          result.set(dependent.name, {
-            ...packageInfo,
+        const packageBase = allPackages.find((p) => p.name === dependent.name);
+        if (packageBase) {
+          const packageToBump = {
+            ...packageBase,
             reason: "dependency",
-            dependencyChain: chain,
-            commits: []
-          });
+            dependencyChain: chain
+          };
+          result.set(dependent.name, packageToBump);
           toProcess.push(dependent.name);
           logger.debug(`${dependent.name} will be bumped (depends on ${chain.join(" \u2192 ")})`);
         }
@@ -577,7 +816,7 @@ function topologicalSort(packages) {
     if (visited.has(pkgName))
       return;
     if (visiting.has(pkgName)) {
-      logger.warn(`Circular dependency detected involving ${pkgName}`);
+      logger.fail(`Circular dependency detected involving ${pkgName}`);
       return;
     }
     visiting.add(pkgName);
@@ -597,229 +836,12 @@ function topologicalSort(packages) {
   return sorted;
 }
 
-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);
-  }
-}
-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.warn("Failed to fetch some git tags from remote (tags might already exist locally)", error);
-    logger.info("Continuing with local tags");
-  }
-}
-function detectGitProvider(cwd = process.cwd()) {
-  try {
-    const remoteUrl = execSync("git remote get-url origin", {
-      cwd,
-      encoding: "utf8"
-    }).trim();
-    if (remoteUrl.includes("github.com")) {
-      return "github";
-    }
-    if (remoteUrl.includes("gitlab.com") || remoteUrl.includes("gitlab")) {
-      return "gitlab";
-    }
-    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]
-    };
-  }
-  const httpsMatch = remoteUrl.match(httpsRegex);
-  if (httpsMatch) {
-    return {
-      owner: httpsMatch[1],
-      repo: httpsMatch[2]
-    };
-  }
-  return null;
-}
-async function createCommitAndTags({
-  config,
-  noVerify,
-  bumpedPackages,
-  newVersion,
-  dryRun,
-  logLevel
-} = {}) {
-  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 {
-      }
-    }
-    const rootPackage = getRootPackage(internalConfig.cwd);
-    newVersion = newVersion || rootPackage.version;
-    const versionForMessage = internalConfig.monorepo?.versionMode === "independent" ? bumpedPackages?.map((pkg) => `${pkg.name}@${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
-      });
-      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) {
-      logger.debug(`Creating ${bumpedPackages.length} independent package tags`);
-      for (const pkg of bumpedPackages) {
-        const tagName = `${pkg.name}@${pkg.version}`;
-        const tagMessage = internalConfig.templates?.tagMessage?.replaceAll("{{newVersion}}", pkg.version || "") || 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 {
-      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({ dryRun, logLevel, cwd }) {
-  logger.start("Start push changes and tags");
-  if (dryRun) {
-    logger.info("[dry-run] git push --follow-tags");
-  } else {
-    logger.debug("Executing: git push --follow-tags");
-    await execPromise("git push --follow-tags", { 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";
-}
-
 async function githubIndependentMode({
   config,
   dryRun,
-  bumpedPackages
+  bumpResult,
+  force,
+  suffix
 }) {
   const repoConfig = config.repo;
   if (!repoConfig) {
@@ -829,42 +851,36 @@ async function githubIndependentMode({
   if (!config.tokens.github && !config.repo?.token) {
     throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
   }
-  const packages = bumpedPackages || getPackages({
-    cwd: config.cwd,
+  const packages = bumpResult?.bumped && bumpResult?.bumpedPackages || await getPackages({
+    suffix,
     patterns: config.monorepo?.packages,
-    ignorePackageNames: config.monorepo?.ignorePackageNames
+    config,
+    force
   });
   logger.info(`Creating ${packages.length} GitHub release(s)`);
   const postedReleases = [];
   for (const pkg of packages) {
-    const to = `${pkg.name}@${pkg.version}`;
-    const from = pkg.fromTag;
+    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 fromTag found for ${pkg.name}, skipping release`);
+      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 commits = await getPackageCommits({
-      pkg,
-      to: toTag,
-      from,
-      config,
-      changelog: true
-    });
     const changelog = await generateChangelog({
       pkg,
-      commits,
       config,
-      from,
-      dryRun
+      dryRun,
+      newVersion
     });
     const releaseBody = changelog.split("\n").slice(2).join("\n");
     const release = {
       tag_name: to,
       name: to,
       body: releaseBody,
-      prerelease: isPrerelease(pkg.version)
+      prerelease: isPrerelease(newVersion)
     };
     logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
     if (dryRun) {
@@ -872,7 +888,7 @@ async function githubIndependentMode({
       postedReleases.push({
         name: pkg.name,
         tag: release.tag_name,
-        version: pkg.version,
+        version: newVersion,
         prerelease: release.prerelease
       });
     } else {
@@ -886,7 +902,7 @@ async function githubIndependentMode({
       postedReleases.push({
         name: pkg.name,
         tag: release.tag_name,
-        version: pkg.version,
+        version: newVersion,
         prerelease: release.prerelease
       });
     }
@@ -912,21 +928,12 @@ async function githubUnified({
   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.templates.tagBody.replace("{{newVersion}}", bumpResult?.newVersion || rootPackage.version);
-  const toTag = dryRun ? getCurrentGitRef(config.cwd) : to;
-  const commits = await getPackageCommits({
-    pkg: rootPackage,
-    config,
-    from: bumpResult?.fromTag || getFirstCommit(config.cwd),
-    to: toTag,
-    changelog: true
-  });
+  const to = config.to || config.templates.tagBody.replace("{{newVersion}}", bumpResult?.bumped && bumpResult.newVersion || rootPackage.version);
   const changelog = await generateChangelog({
     pkg: rootPackage,
-    commits,
     config,
-    from: bumpResult?.fromTag || "v0.0.0",
-    dryRun
+    dryRun,
+    newVersion: bumpResult?.newVersion || rootPackage.version
   });
   const releaseBody = changelog.split("\n").slice(2).join("\n");
   const release = {
@@ -947,7 +954,7 @@ async function githubUnified({
     logger.debug("Publishing release to GitHub...");
     await createGithubRelease({
       ...config,
-      from: bumpResult?.fromTag || "v0.0.0",
+      from: bumpResult?.bumped && bumpResult.fromTag || "v0.0.0",
       to,
       repo: repoConfig
     }, release);
@@ -960,7 +967,7 @@ async function githubUnified({
     prerelease: release.prerelease
   }];
 }
-async function github(options = {}) {
+async function github(options) {
   try {
     const dryRun = options.dryRun ?? false;
     logger.debug(`Dry run: ${dryRun}`);
@@ -976,18 +983,30 @@ async function github(options = {}) {
         }
       }
     });
-    if (!options.bumpResult?.bumped) {
-      logger.warn("No bump result found, skipping release");
-      return [];
-    }
     if (config.monorepo?.versionMode === "independent") {
-      return await githubIndependentMode({ config, dryRun, bumpedPackages: options.bumpResult.bumpedPackages });
-    }
-    let rootPackage = getRootPackage(config.cwd);
-    const foundedRootPackage = options.bumpResult.bumpedPackages.find((pkg) => pkg.path === rootPackage.path);
-    if (foundedRootPackage) {
-      rootPackage = foundedRootPackage;
+      return await githubIndependentMode({
+        config,
+        dryRun,
+        bumpResult: options.bumpResult,
+        force: options.force ?? false,
+        suffix: options.suffix
+      });
     }
+    const rootPackageBase = readPackageJson(config.cwd);
+    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,
@@ -1064,13 +1083,16 @@ async function createGitlabRelease({
 async function gitlabIndependentMode({
   config,
   dryRun,
-  bumpedPackages
+  bumpResult,
+  suffix,
+  force
 }) {
   logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const packages = bumpedPackages || getPackages({
-    cwd: config.cwd,
+  const packages = bumpResult?.bumped && bumpResult?.bumpedPackages || await getPackages({
     patterns: config.monorepo?.packages,
-    ignorePackageNames: config.monorepo?.ignorePackageNames
+    config,
+    suffix,
+    force
   });
   logger.info(`Creating ${packages.length} GitLab release(s) for independent packages`);
   logger.debug("Getting current branch...");
@@ -1082,26 +1104,19 @@ async function gitlabIndependentMode({
   });
   const postedReleases = [];
   for (const pkg of packages) {
-    const to = `${pkg.name}@${pkg.version}`;
-    const from = pkg.fromTag;
+    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 fromTag found for ${pkg.name}, skipping release`);
+      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
       continue;
     }
     logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${to}`);
-    const commits = await getPackageCommits({
-      pkg,
-      config,
-      from,
-      to,
-      changelog: true
-    });
     const changelog = await generateChangelog({
       pkg,
-      commits,
       config,
-      from,
-      dryRun
+      dryRun,
+      newVersion
     });
     if (!changelog) {
       logger.warn(`No changelog found for ${pkg.name}`);
@@ -1114,335 +1129,186 @@ async function gitlabIndependentMode({
       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: pkg.version,
-        prerelease: isPrerelease(pkg.version)
-      });
-    }
-  }
-  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,
-  fromTag,
-  oldVersion
-}) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const to = config.templates.tagBody.replace("{{newVersion}}", rootPackage.version);
-  const commits = await getPackageCommits({
-    pkg: rootPackage,
-    config,
-    from: fromTag || getFirstCommit(config.cwd),
-    to,
-    changelog: true
-  });
-  logger.debug(`Found ${commits.length} commit(s)`);
-  const changelog = await generateChangelog({
-    pkg: rootPackage,
-    commits,
-    config,
-    from: fromTag || oldVersion || "v0.0.0",
-    dryRun
-  });
-  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
-        }
-      }
-    });
-    if (!options.bumpResult?.bumped) {
-      logger.warn("No bump result found, skipping release");
-      return [];
-    }
-    if (config.monorepo?.versionMode === "independent") {
-      return await gitlabIndependentMode({
-        config,
-        dryRun,
-        bumpedPackages: options.bumpResult.bumpedPackages
-      });
-    }
-    const rootPackage = getRootPackage(process.cwd());
-    logger.debug(`Root package: ${rootPackage.name}@${rootPackage.version}`);
-    return await gitlabUnified({
-      config,
-      dryRun,
-      rootPackage,
-      fromTag: options.bumpResult.fromTag,
-      oldVersion: options.bumpResult.oldVersion
-    });
-  } catch (error) {
-    logger.error("Error publishing GitLab release:", error);
-    throw error;
-  }
-}
-
-function getPackageInfo(packagePath, ignorePackageNames) {
-  const packageJsonPath = join(packagePath, "package.json");
-  if (!existsSync(packageJsonPath))
-    return null;
-  if (!statSync(packagePath).isDirectory())
-    return null;
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    if (packageJson.private) {
-      logger.debug(`${packageJson.name} is private and will be ignored`);
-      return null;
-    }
-    if (ignorePackageNames?.includes(packageJson.name)) {
-      logger.debug(`${packageJson.name} ignored by config monorepo.ignorePackageNames`);
-      return null;
-    }
-    if (!packageJson.version) {
-      logger.warn(`${packageJson.name} has no version and will be ignored`);
-      return null;
-    }
-    return {
-      name: packageJson.name,
-      currentVersion: packageJson.version,
-      path: packagePath,
-      version: packageJson.version
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.warn(`Unable to read ${packageJsonPath}:`, errorMessage);
-    return null;
-  }
-}
-function getPackages({
-  cwd,
-  patterns,
-  ignorePackageNames
-}) {
-  const packages = [];
-  const foundPaths = /* @__PURE__ */ new Set();
-  if (!patterns)
-    patterns = ["."];
-  logger.debug(`Getting packages from patterns: ${patterns.join(", ")}`);
-  for (const pattern of patterns) {
-    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 packageInfo = getPackageInfo(matchPath, ignorePackageNames);
-        if (packageInfo) {
-          foundPaths.add(matchPath);
-          packages.push(packageInfo);
-        }
-      }
-    } catch (error) {
-      logger.error(`Unable to match pattern "${pattern}":`, error);
-    }
-  }
-  return packages;
-}
-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 getPackageCommits({
-  pkg,
-  from,
-  to,
-  config,
-  changelog
-}) {
-  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 = getRootPackage(changelogConfig.cwd);
-  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 = pkg.path.replace(`${changelogConfig.cwd}/`, "");
-    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`);
-  }
-  return commits;
-}
-function getRootPackage(rootDir) {
-  const packageJsonPath = join(rootDir, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    throw new Error(`package.json not found at ${packageJsonPath}`);
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    return {
-      name: packageJson.name,
-      currentVersion: packageJson.version || "0.0.0",
-      path: rootDir,
-      version: packageJson.version || "0.0.0"
-    };
-  } catch (error) {
-    throw new Error(`Unable to read ${packageJsonPath}: ${error}`);
+    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)
+      });
+    }
   }
+  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 hasLernaJson(rootDir) {
-  const lernaJsonPath = join(rootDir, "lerna.json");
-  return existsSync(lernaJsonPath);
-}
-async function getPackageToBump({
-  packages,
+async function gitlabUnified({
   config,
-  from,
-  to
+  dryRun,
+  rootPackage,
+  bumpResult
 }) {
-  const packagesWithCommits = [];
-  for (const pkg of packages) {
-    const commits = await getPackageCommits({
-      pkg,
-      from,
-      to,
+  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,
-      changelog: false
+      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 graduating = isGraduating(pkg.version, config.bump.type) || isChangedPreid(pkg.version, config.bump.preid);
-    if (commits.length > 0 || graduating) {
-      packagesWithCommits.push({ ...pkg, commits });
+    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);
+    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(rootPackage)}`);
+    return await gitlabUnified({
+      config,
+      dryRun,
+      rootPackage,
+      bumpResult: options.bumpResult
+    });
+  } catch (error) {
+    logger.error("Error publishing GitLab release:", error);
+    throw error;
   }
-  const allPackagesToBump = expandPackagesToBumpWithDependents({
-    allPackages: packages,
-    packagesWithCommits,
-    dependencyTypes: config.bump?.dependencyTypes
-  });
-  return allPackagesToBump;
 }
 
-function detectReleaseTypeFromCommits(commits, config) {
-  return determineSemverChange(commits, config);
+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 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;
+}
+function detectReleaseTypeFromCommits(commits, types) {
+  return determineSemverChange(commits, types);
 }
 function validatePrereleaseDowngrade(currentVersion, targetPreid, configuredType) {
   if (configuredType !== "prerelease" || !targetPreid || !isPrerelease(currentVersion)) {
     return;
   }
   const testVersion = semver.inc(currentVersion, "prerelease", targetPreid);
-  if (testVersion && !semver.gt(testVersion, currentVersion)) {
+  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`);
   }
 }
-function handleStableVersionWithReleaseType(commits, config, force) {
+function handleStableVersionWithReleaseType(commits, types, force) {
   if (!commits?.length && !force) {
     logger.debug('No commits found for stable version with "release" type, skipping bump');
-    return null;
+    return void 0;
   }
-  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, config) : null;
+  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
   if (!detectedType && !force) {
     logger.debug("No significant commits found, skipping bump");
-    return null;
+    return void 0;
   }
   logger.debug(`Auto-detected release type from commits: ${detectedType}`);
   return detectedType;
 }
-function handleStableVersionWithPrereleaseType(commits, config, force) {
+function handleStableVersionWithPrereleaseType(commits, types, force) {
   if (!commits?.length && !force) {
     logger.debug('No commits found for stable version with "prerelease" type, skipping bump');
-    return null;
+    return void 0;
   }
-  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, config) : null;
+  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
   if (!detectedType) {
     logger.debug("No significant commits found, using prepatch as default");
     return "prepatch";
@@ -1455,83 +1321,73 @@ function handlePrereleaseVersionToStable(currentVersion) {
   logger.debug(`Graduating from prerelease ${currentVersion} to stable release`);
   return "release";
 }
-function handlePrereleaseVersionWithPrereleaseType(currentVersion, targetPreid, commits, config, force) {
+function handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force }) {
   const currentPreid = getPreid(currentVersion);
-  const hasChangedPreid = targetPreid && currentPreid && currentPreid !== targetPreid;
+  const hasChangedPreid = preid && currentPreid && currentPreid !== preid;
   if (hasChangedPreid) {
-    const testVersion = semver.inc(currentVersion, "prerelease", targetPreid);
+    const testVersion = semver.inc(currentVersion, "prerelease", preid);
     if (!testVersion) {
-      throw new Error(`Unable to change preid from ${currentPreid} to ${targetPreid} for version ${currentVersion}`);
+      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 ${targetPreid})`);
+      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 null;
+    return void 0;
   }
   logger.debug(`Incrementing prerelease version: ${currentVersion}`);
   return "prerelease";
 }
-function handleExplicitReleaseType(configuredType, currentVersion) {
+function handleExplicitReleaseType({
+  releaseType,
+  currentVersion
+}) {
   const isCurrentPrerelease = isPrerelease(currentVersion);
-  const isGraduatingToStable = isCurrentPrerelease && isStableReleaseType(configuredType);
+  const isGraduatingToStable = isCurrentPrerelease && isStableReleaseType(releaseType);
   if (isGraduatingToStable) {
-    logger.debug(`Graduating from prerelease ${currentVersion} to stable with type: ${configuredType}`);
+    logger.debug(`Graduating from prerelease ${currentVersion} to stable with type: ${releaseType}`);
   } else {
-    logger.debug(`Using explicit release type: ${configuredType}`);
+    logger.debug(`Using explicit release type: ${releaseType}`);
   }
-  return configuredType;
+  return releaseType;
 }
 function determineReleaseType({
   currentVersion,
-  from,
-  to,
   commits,
-  config,
+  releaseType,
+  preid,
+  types,
   force
 }) {
-  const configWithRange = {
-    ...config,
-    from,
-    to
-  };
-  const configuredType = configWithRange.bump.type;
-  const targetPreid = configWithRange.bump.preid;
-  if (configuredType === "release" && targetPreid) {
+  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, targetPreid, configuredType);
+  validatePrereleaseDowngrade(currentVersion, preid, releaseType);
   if (force) {
-    logger.debug(`Force flag enabled, using configured type: ${configuredType}`);
-    return configuredType;
+    logger.debug(`Force flag enabled, using configured type: ${releaseType}`);
+    return releaseType;
   }
   const isCurrentPrerelease = isPrerelease(currentVersion);
   if (!isCurrentPrerelease) {
-    if (configuredType === "release") {
-      return handleStableVersionWithReleaseType(commits, configWithRange, force);
+    if (releaseType === "release") {
+      return handleStableVersionWithReleaseType(commits, types, force);
     }
-    if (configuredType === "prerelease") {
-      return handleStableVersionWithPrereleaseType(commits, configWithRange, force);
+    if (releaseType === "prerelease") {
+      return handleStableVersionWithPrereleaseType(commits, types, force);
     }
-    return handleExplicitReleaseType(configuredType, currentVersion);
+    return handleExplicitReleaseType({ releaseType, currentVersion });
   }
-  if (configuredType === "release") {
+  if (releaseType === "release") {
     return handlePrereleaseVersionToStable(currentVersion);
   }
-  if (configuredType === "prerelease") {
-    return handlePrereleaseVersionWithPrereleaseType(
-      currentVersion,
-      targetPreid,
-      commits,
-      configWithRange,
-      force
-    );
+  if (releaseType === "prerelease") {
+    return handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force });
   }
-  return handleExplicitReleaseType(configuredType, currentVersion);
+  return handleExplicitReleaseType({ releaseType, currentVersion });
 }
 function writeVersion(pkgPath, version, dryRun = false) {
   const packageJsonPath = join(pkgPath, "package.json");
@@ -1552,33 +1408,32 @@ function writeVersion(pkgPath, version, dryRun = false) {
     throw new Error(`Unable to write version to ${packageJsonPath}: ${error}`);
   }
 }
-function bumpPackageVersion({
+function getPackageNewVersion({
   currentVersion,
   releaseType,
   preid,
   suffix
 }) {
-  try {
-    let newVersion = semver.inc(currentVersion, releaseType, preid);
-    if (!newVersion) {
-      throw new Error(`Unable to bump version "${currentVersion}" with release type "${releaseType}"
+  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`);
-    }
-    if (isGraduating(currentVersion, releaseType)) {
-      logger.info(`Graduating from prerelease ${currentVersion} to stable ${newVersion}`);
-    }
-    return newVersion;
-  } catch (error) {
-    throw new Error(`Unable to bump version: ${error}`);
   }
+  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.info(`Graduating from ${getPreid(currentVersion)} to ${preid}`);
+  }
+  return newVersion;
 }
 function updateLernaVersion({
   rootDir,
@@ -1612,7 +1467,7 @@ function updateLernaVersion({
 `, "utf8");
     logger.success(`Updated lerna.json: ${oldVersion} \u2192 ${version}`);
   } catch (error) {
-    logger.warn(`Unable to update lerna.json: ${error}`);
+    logger.fail(`Unable to update lerna.json: ${error}`);
   }
 }
 function extractVersionFromPackageTag(tag) {
@@ -1658,13 +1513,16 @@ function isChangedPreid(currentVersion, targetPreid) {
   }
   return currentPreid !== targetPreid;
 }
-function bumpPackageIndependently({
+function getBumpedPackageIndependently({
   pkg,
   dryRun
 }) {
   logger.debug(`Analyzing ${pkg.name}`);
   const currentVersion = pkg.version || "0.0.0";
-  const newVersion = pkg.version;
+  const newVersion = pkg.newVersion;
+  if (!newVersion) {
+    return { bumped: false };
+  }
   logger.debug(`Bumping ${pkg.name} from ${currentVersion} to ${newVersion}`);
   writeVersion(pkg.path, newVersion, dryRun);
   return { bumped: true, newVersion, oldVersion: currentVersion };
@@ -1690,9 +1548,9 @@ function displayUnifiedModePackages({
   newVersion,
   force
 }) {
-  logger.log(`${packages.length} package(s)${force ? " (force)" : ""}:`);
+  logger.log(`${packages.length} package(s):`);
   packages.forEach((pkg) => {
-    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion}`);
+    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
   });
   logger.log("");
 }
@@ -1702,14 +1560,15 @@ function displaySelectiveModePackages({
   force
 }) {
   if (force) {
-    logger.log(`${packages.length} package(s) (force):`);
+    logger.log(`${packages.length} package(s):`);
     packages.forEach((pkg) => {
-      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion}`);
+      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) => {
@@ -1724,33 +1583,47 @@ function displaySelectiveModePackages({
       });
       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}`);
+      });
+      logger.log("");
+    }
   }
 }
 function displayIndependentModePackages({
   packages,
-  force,
-  dryRun
+  force
 }) {
   if (force) {
-    logger.log(`${dryRun ? "[dry-run] " : ""}${packages.length} package(s) (force):`);
+    logger.log(`${packages.length} package(s):`);
     packages.forEach((pkg) => {
-      logger.log(`  \u2022 ${pkg.name}: ${pkg.currentVersion} \u2192 ${pkg.version}`);
+      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(`${dryRun ? "[dry-run] " : ""}${packagesWithCommits.length} package(s) with commits:`);
+      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
       packagesWithCommits.forEach((pkg) => {
-        logger.log(`  \u2022 ${pkg.name}: ${pkg.currentVersion} \u2192 ${pkg.version}`);
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion}`);
       });
       logger.log("");
     }
     if (packagesAsDependents.length > 0) {
-      logger.log(`${dryRun ? "[dry-run] " : ""}${packagesAsDependents.length} dependent package(s):`);
+      logger.log(`${packagesAsDependents.length} dependent package(s):`);
       packagesAsDependents.forEach((pkg) => {
-        logger.log(`  \u2022 ${pkg.name}: ${pkg.currentVersion} \u2192 ${pkg.version}`);
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion}`);
+      });
+      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}`);
       });
       logger.log("");
     }
@@ -1765,6 +1638,10 @@ async function confirmBump({
   newVersion,
   dryRun
 }) {
+  if (packages.length === 0) {
+    logger.debug("No packages to bump");
+    return;
+  }
   const lernaJsonExists = hasLernaJson(config.cwd);
   logger.log("");
   logger.info(`${dryRun ? "[dry-run] " : ""}The following packages will be updated:
@@ -1776,220 +1653,100 @@ async function confirmBump({
     lernaJsonExists,
     dryRun
   });
-  if (versionMode === "unified" && newVersion) {
+  if (versionMode === "unified") {
+    if (!newVersion) {
+      logger.error("Cannot confirm bump in unified mode without a new version");
+      process.exit(1);
+    }
     displayUnifiedModePackages({ packages, newVersion, force });
-  } else if (versionMode === "selective" && newVersion) {
+  } else if (versionMode === "selective") {
+    if (!newVersion) {
+      logger.error("Cannot confirm bump in selective mode without a new version");
+      process.exit(1);
+    }
     displaySelectiveModePackages({ packages, newVersion, force });
   } else if (versionMode === "independent") {
-    displayIndependentModePackages({ packages, force, dryRun });
+    displayIndependentModePackages({ packages, force });
   }
   try {
     const confirmed = await confirm({
       message: `${dryRun ? "[dry-run] " : ""}Do you want to proceed with these version updates?`,
       default: true
     });
-    if (!confirmed) {
-      logger.warn("Bump cancelled by user");
-      process.exit(0);
-    }
-  } catch {
-    logger.error("Error while confirming bump");
-    process.exit(1);
-  }
-  logger.log("");
-}
-async function findPackagesWithCommits({
-  packages,
-  config,
-  force
-}) {
-  const packagesWithCommits = [];
-  logger.debug(`Checking for commits in ${packages.length} package(s)`);
-  for (const pkg of packages) {
-    const { from, to } = await resolveTags({
-      config,
-      versionMode: "independent",
-      step: "bump",
-      currentVersion: pkg.version,
-      newVersion: void 0,
-      pkg,
-      logLevel: config.logLevel
-    });
-    const commits = await getPackageCommits({
-      pkg,
-      from,
-      to,
-      config,
-      changelog: false
-    });
-    if (commits.length <= 0 && !force) {
-      logger.debug(`${pkg.name}: No commits found, skipping`);
-      continue;
-    }
-    packagesWithCommits.push({ ...pkg, commits });
-    logger.debug(`${pkg.name}: ${commits.length} commit(s)`);
-  }
-  return packagesWithCommits;
-}
-async function calculatePackageNewVersion({
-  pkg,
-  config,
-  force,
-  suffix
-}) {
-  const releaseType = config.bump.type;
-  const { from, to } = await resolveTags({
-    config,
-    versionMode: "independent",
-    step: "bump",
-    currentVersion: pkg.version,
-    newVersion: void 0,
-    pkg,
-    logLevel: config.logLevel
-  });
-  const forcedBump = pkg.reason === "dependency";
-  let forcedBumpType;
-  if (forcedBump) {
-    if (isStableReleaseType(releaseType)) {
-      forcedBumpType = "patch";
-    } else {
-      forcedBumpType = isPrerelease(pkg.version) ? "prerelease" : "prepatch";
-    }
-  }
-  const commits = pkg.commits?.length > 0 ? pkg.commits : await getPackageCommits({
-    pkg,
-    from,
-    to,
-    config,
-    changelog: false
-  });
-  let calculatedReleaseType = null;
-  if (forcedBumpType) {
-    calculatedReleaseType = forcedBumpType;
-  } else if (commits.length === 0 && !force) {
-    return null;
-  } else {
-    calculatedReleaseType = determineReleaseType({ from, to, commits, config, force, currentVersion: pkg.version });
-    if (!calculatedReleaseType) {
-      return null;
-    }
-  }
-  const currentVersion = pkg.version || "0.0.0";
-  const newVersion = bumpPackageVersion({
-    currentVersion,
-    releaseType: calculatedReleaseType,
-    preid: config.bump.preid,
-    suffix
-  });
-  return {
-    name: pkg.name,
-    path: pkg.path,
-    currentVersion,
-    version: newVersion,
-    fromTag: from,
-    reason: pkg.reason,
-    commits,
-    dependencyChain: pkg.dependencyChain
-  };
-}
-async function calculateNewVersionsForPackages({
-  allPackagesToBump,
-  config,
-  force,
-  suffix
-}) {
-  const packagesWithNewVersions = [];
-  for (const pkgToBump of allPackagesToBump) {
-    const packageWithNewVersion = await calculatePackageNewVersion({
-      pkg: pkgToBump,
-      config,
-      force,
-      suffix
-    });
-    if (packageWithNewVersion) {
-      packagesWithNewVersions.push(packageWithNewVersion);
-    }
-  }
-  return packagesWithNewVersions;
-}
-async function findPackagesWithCommitsAndCalculateVersions({
-  packages,
-  config,
-  force,
-  suffix
-}) {
-  const packagesWithCommits = await findPackagesWithCommits({
-    packages,
-    config,
-    force
-  });
-  if (packagesWithCommits.length === 0) {
-    return [];
+    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);
   }
-  const allPackagesToBump = expandPackagesToBumpWithDependents({
-    allPackages: packages,
-    packagesWithCommits,
-    dependencyTypes: config.bump.dependencyTypes
-  });
-  logger.debug(`Total packages to bump (including dependents): ${allPackagesToBump.length}`);
-  const packagesWithNewVersions = await calculateNewVersionsForPackages({
-    allPackagesToBump,
-    config,
-    force,
-    suffix
-  });
-  logger.debug(`Found ${packagesWithNewVersions.length} package(s) to bump`);
-  return packagesWithNewVersions;
+  logger.log("");
 }
-function bumpIndependentPackages({
+function getBumpedIndependentPackages({
   packages,
   dryRun
 }) {
   const bumpedPackages = [];
   for (const pkgToBump of packages) {
-    logger.debug(`Bumping ${pkgToBump.name} from ${pkgToBump.currentVersion} to ${pkgToBump.version} (reason: ${pkgToBump.reason})`);
-    const result = bumpPackageIndependently({
+    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.newVersion
+        version: result.oldVersion
       });
     }
   }
   return bumpedPackages;
 }
 
-async function getLastRepoTag(options) {
-  let lastTag = null;
-  if (options?.onlyStable) {
-    const { stdout: stdout2 } = await execPromise(
-      `git tag --sort=-creatordate | grep -E '^[^0-9]*[0-9]+\\.[0-9]+\\.[0-9]+$' | head -n 1`,
-      {
-        logLevel: options?.logLevel,
-        noStderr: true,
-        noStdout: true,
-        noSuccess: true,
-        cwd: options?.cwd
-      }
-    );
-    lastTag = stdout2.trim();
-    logger.debug("Last stable tag:", lastTag || "No stable tags found");
-    return lastTag;
-  }
+function getIndependentTag({ version, name }) {
+  return `${name}@${version}`;
+}
+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
+    }
+  );
+  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: options?.logLevel,
+    logLevel,
     noStderr: true,
     noStdout: true,
     noSuccess: true,
-    cwd: options?.cwd
+    cwd
   });
-  lastTag = stdout.trim();
+  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 });
+}
 async function getLastPackageTag({
   packageName,
   onlyStable,
@@ -2020,88 +1777,111 @@ async function getLastPackageTag({
     return null;
   }
 }
-async function resolveTagsIndependent({
+async function resolveFromTagIndependent({
   cwd,
-  pkg,
+  packageName,
   graduating,
-  newVersion,
-  step,
   logLevel
 }) {
-  let to;
-  if (step === "bump") {
-    to = getCurrentGitRef(cwd);
-  } else {
-    to = newVersion ? `${pkg.name}@${newVersion}` : getCurrentGitRef(cwd);
-  }
   const lastPackageTag = await getLastPackageTag({
-    packageName: pkg.name,
+    packageName,
     onlyStable: graduating,
     logLevel
   });
   if (!lastPackageTag) {
-    const from = await getLastRepoTag({ logLevel }) || getFirstCommit(cwd);
-    return { from, to };
+    return getFirstCommit(cwd);
   }
-  return { from: lastPackageTag, to };
+  return lastPackageTag;
 }
-async function resolveTagsUnified({
+async function resolveFromTagUnified({
   config,
-  newVersion,
   graduating,
-  step,
   logLevel
 }) {
-  let to;
-  if (step === "bump") {
-    to = getCurrentGitRef(config.cwd);
-  } else {
-    to = newVersion ? config.templates.tagBody.replace("{{newVersion}}", newVersion) : getCurrentGitRef(config.cwd);
-  }
   const from = await getLastRepoTag({ onlyStable: graduating, logLevel }) || getFirstCommit(config.cwd);
-  return { from, to };
+  return from;
 }
-async function resolveTags({
+async function resolveFromTag({
   config,
   versionMode,
   step,
-  pkg,
-  currentVersion,
-  newVersion,
+  packageName,
+  graduating,
   logLevel
 }) {
-  logger.debug(`[${versionMode}](${step}) Resolving tags`);
-  const graduating = currentVersion && isGraduating(currentVersion, config.bump.type) || false;
-  const newTags = newVersion && config.templates.tagBody.replace("{{newVersion}}", newVersion) || null;
-  if (config.from) {
-    const tags2 = {
-      from: config.from,
-      to: config.to || newTags || getCurrentGitRef(config.cwd)
-    };
-    logger.debug(`[${versionMode}](${step}) Using specified tags: ${tags2.from} \u2192 ${tags2.to}`);
-    return tags2;
-  }
+  let from;
   if (versionMode === "independent") {
-    const tags2 = await resolveTagsIndependent({
+    if (!packageName) {
+      throw new Error("Package name is required for independent version mode");
+    }
+    from = await resolveFromTagIndependent({
       cwd: config.cwd,
-      pkg,
+      packageName,
+      graduating,
+      logLevel
+    });
+  } else {
+    from = await resolveFromTagUnified({
+      config,
       graduating,
-      newVersion,
-      step,
       logLevel
     });
-    logger.debug(`[${versionMode}](${step}) Using tags: ${tags2.from} \u2192 ${tags2.to}`);
-    return tags2;
   }
-  const tags = await resolveTagsUnified({
+  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);
+  }
+  logger.debug(`[${versionMode}](${step}) Using to tag: ${to}`);
+  return config.to || to;
+}
+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,
-    newVersion,
-    graduating,
+    versionMode,
     step,
+    packageName: pkg.name,
+    graduating: isGraduating(pkg.version, releaseType),
     logLevel
   });
-  logger.debug(`[${versionMode}](${step}) Using tags: ${tags.from} \u2192 ${tags.to}`);
-  return tags;
+  const to = resolveToTag({
+    config,
+    versionMode,
+    newVersion,
+    step,
+    packageName: pkg.name
+  });
+  logger.debug(`[${versionMode}](${step}) Using tags: ${from} \u2192 ${to}`);
+  return { from, to };
 }
 
 let sessionOtp;
@@ -2120,7 +1900,8 @@ function detectPackageManager(cwd = process.cwd()) {
           }
         }
       } catch (e) {
-        logger.warn(`Failed to parse package.json: ${e.message}`);
+        const errorString = e instanceof Error ? e.message : String(e);
+        logger.debug(`Failed to parse package.json: ${errorString}`);
       }
     }
     const lockFiles = {
@@ -2146,7 +1927,7 @@ function detectPackageManager(cwd = process.cwd()) {
     logger.debug("No package manager detected, defaulting to npm");
     return "npm";
   } catch (error) {
-    logger.warn(`Error detecting package manager: ${error}, defaulting to npm`);
+    logger.fail(`Error detecting package manager: ${error}, defaulting to npm`);
     return "npm";
   }
 }
@@ -2180,23 +1961,13 @@ async function getPackagesToPublishInIndependentMode(sortedPackages, config) {
   for (const pkg of sortedPackages) {
     const { from, to } = await resolveTags({
       config,
-      versionMode: "independent",
       step: "publish",
       pkg,
-      newVersion: pkg.version,
-      currentVersion: void 0,
-      logLevel: config.logLevel
-    });
-    const commits = await getPackageCommits({
-      pkg,
-      from,
-      to,
-      config,
-      changelog: false
+      newVersion: pkg.version
     });
-    if (commits.length > 0) {
+    if (pkg.commits.length > 0) {
       packagesToPublish.push(pkg);
-      logger.debug(`${pkg.name}: ${commits.length} commit(s) since ${from} \u2192 ${to}`);
+      logger.debug(`${pkg.name}: ${pkg.commits.length} commit(s) since ${from} \u2192 ${to}`);
     }
   }
   return packagesToPublish;
@@ -2301,7 +2072,7 @@ async function publishPackage({
   dryRun
 }) {
   const tag = determinePublishTag(pkg.version, config.publish.tag);
-  const packageNameAndVersion = `${pkg.name}@${pkg.version}`;
+  const packageNameAndVersion = getIndependentTag(pkg);
   const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
   logger.debug(`Building publish command for ${pkg.name}`);
   let dynamicOtp;
@@ -2342,198 +2113,412 @@ async function publishPackage({
   }
 }
 
+function readPackageJson(packagePath) {
+  const packageJsonPath = join(packagePath, "package.json");
+  if (!existsSync(packageJsonPath))
+    throw new Error(`package.json not found at ${packageJsonPath}`);
+  if (!statSync(packagePath).isDirectory())
+    throw new Error(`Not a directory: ${packagePath}`);
+  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
+  };
+}
+async function getRootPackage({
+  config,
+  force,
+  from,
+  to,
+  suffix,
+  changelog
+}) {
+  try {
+    const packageJson = readPackageJson(config.cwd);
+    const commits = await getPackageCommits({
+      pkg: packageJson,
+      from,
+      to,
+      config,
+      changelog
+    });
+    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);
+    }
+    const newVersion = getPackageNewVersion({
+      currentVersion: packageJson.version,
+      releaseType,
+      preid: config.bump.preid,
+      suffix
+    });
+    return {
+      ...packageJson,
+      path: config.cwd,
+      fromTag: from,
+      commits,
+      newVersion
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(errorMessage);
+  }
+}
+function readPackages({
+  cwd,
+  patterns,
+  ignorePackageNames
+}) {
+  const packages = [];
+  const foundPaths = /* @__PURE__ */ new Set();
+  if (!patterns)
+    patterns = ["."];
+  logger.debug(`Getting packages from patterns: ${patterns.join(", ")}`);
+  for (const pattern of patterns) {
+    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 packages;
+}
+function getPackageReleaseType({
+  pkg,
+  config,
+  force
+}) {
+  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();
+  if (!patterns)
+    patterns = ["."];
+  logger.debug(`Getting packages from patterns: ${patterns.join(", ")}`);
+  const patternsSet = new Set(patterns);
+  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.private) {
+        logger.debug(`${packageBase.name} is private and will be ignored`);
+        continue;
+      }
+      if (config.monorepo?.ignorePackageNames?.includes(packageBase.name)) {
+        logger.debug(`${packageBase.name} ignored by config (monorepo.ignorePackageNames)`);
+        continue;
+      }
+      if (!packageBase.version) {
+        logger.warn(`${packageBase.name} has no version and will be ignored`);
+        continue;
+      }
+      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
+      });
+    }
+  }
+  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);
+  }
+  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 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 getPackageCommits({
+  pkg,
+  from,
+  to,
+  config,
+  changelog
+}) {
+  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);
+  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;
+  });
+  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`);
+  }
+  return commits;
+}
+function hasLernaJson(rootDir) {
+  const lernaJsonPath = join(rootDir, "lerna.json");
+  return existsSync(lernaJsonPath);
+}
+
 async function bumpUnifiedMode({
   config,
-  packages,
   dryRun,
   force,
   suffix
 }) {
   logger.debug("Starting bump in unified mode");
-  const rootPackage = getRootPackage(config.cwd);
-  const currentVersion = rootPackage.version;
+  const rootPackageBase = readPackageJson(config.cwd);
   const { from, to } = await resolveTags({
     config,
-    versionMode: "unified",
     step: "bump",
     newVersion: void 0,
-    pkg: void 0,
-    currentVersion,
-    logLevel: config.logLevel
+    pkg: rootPackageBase
   });
-  logger.debug(`Bump from ${from} to ${to}`);
-  const commits = await getPackageCommits({
-    pkg: rootPackage,
+  const rootPackage = await getRootPackage({
+    config,
+    force,
     from,
     to,
-    config,
+    suffix,
     changelog: false
   });
-  logger.debug(`Found ${commits.length} commits since ${from}`);
-  const releaseType = determineReleaseType({
-    from,
-    to,
-    currentVersion,
-    commits,
+  const currentVersion = rootPackage.version;
+  const newVersion = rootPackage.newVersion;
+  if (!newVersion) {
+    throw new Error(`Could not determine a new version for ${rootPackage.name} (root)`);
+  }
+  logger.debug(`Bump from ${from} to ${to}`);
+  logger.debug(`${currentVersion} \u2192 ${newVersion} (${config.monorepo?.versionMode || "standalone"} mode)`);
+  const packages = await getPackages({
     config,
+    patterns: config.monorepo?.packages,
+    suffix,
     force
   });
-  if (!releaseType) {
-    logger.debug("No commits require a version bump");
-    return { bumped: false };
-  }
-  if (config.bump.type && force) {
-    logger.debug(`Using specified release type: ${releaseType}`);
-  } else {
-    logger.debug(`Detected release type from commits: ${releaseType}`);
-  }
-  const newVersion = bumpPackageVersion({
-    currentVersion,
-    releaseType,
-    preid: config.bump.preid,
-    suffix
-  });
-  logger.debug(`${currentVersion} \u2192 ${newVersion} (unified mode)`);
-  const allPackages = [rootPackage, ...packages];
   if (!config.bump.yes) {
     await confirmBump({
       versionMode: "unified",
-      config,
       packages,
+      config,
       force,
       currentVersion,
       newVersion,
       dryRun
     });
   } else {
-    logger.info(`${allPackages.length === 1 ? allPackages[0].name : allPackages.length} package(s) bumped from ${currentVersion} to ${newVersion} (unified mode)`);
+    logger.info(`${packages.length === 1 ? packages[0].name : packages.length} package(s) bumped from ${currentVersion} to ${newVersion} (${config.monorepo?.versionMode || "standalone"} mode)`);
   }
-  for (const pkg of allPackages) {
+  for (const pkg of [rootPackage, ...packages]) {
     writeVersion(pkg.path, newVersion, dryRun);
   }
-  if (newVersion) {
-    updateLernaVersion({
-      rootDir: config.cwd,
-      versionMode: config.monorepo?.versionMode,
-      version: newVersion,
-      dryRun
-    });
-  }
+  updateLernaVersion({
+    rootDir: config.cwd,
+    versionMode: config.monorepo?.versionMode,
+    version: newVersion,
+    dryRun
+  });
   if (!dryRun) {
-    logger.info(`All ${allPackages.length} package(s) bumped to ${newVersion}`);
+    logger.info(`All ${packages.length} package(s) bumped to ${newVersion}`);
   }
   return {
     bumped: true,
     oldVersion: currentVersion,
     fromTag: from,
     newVersion,
+    rootPackage,
     bumpedPackages: packages.map((pkg) => ({
       ...pkg,
-      currentVersion: pkg.version,
-      version: newVersion,
-      fromTag: from
+      oldVersion: pkg.version,
+      newVersion,
+      fromTag: from,
+      reason: "commits"
     }))
   };
 }
-async function bumpIndependentMode({
-  config,
-  packages,
-  dryRun,
-  force,
-  suffix
-}) {
-  logger.debug("Starting bump in independent mode");
-  const packagesWithNewVersions = await findPackagesWithCommitsAndCalculateVersions({
-    packages,
-    config,
-    force,
-    suffix
-  });
-  if (packagesWithNewVersions.length === 0) {
-    logger.debug("No packages have commits");
-    return { bumped: false };
-  }
-  if (!config.bump.yes) {
-    await confirmBump({
-      versionMode: "independent",
-      config,
-      packages: packagesWithNewVersions,
-      force,
-      dryRun
-    });
-  } else {
-    const bumpedByCommits2 = packagesWithNewVersions.filter((p) => p.reason === "commits").length;
-    const bumpedByDependency2 = packagesWithNewVersions.length - bumpedByCommits2;
-    logger.info(
-      `${bumpedByCommits2 + bumpedByDependency2} package(s) will be bumped independently (${bumpedByCommits2} from commits, ${bumpedByDependency2} from dependencies)`
-    );
-  }
-  const bumpedPackages = bumpIndependentPackages({
-    packages: packagesWithNewVersions,
-    dryRun
-  });
-  const bumpedByCommits = bumpedPackages.filter(
-    (p) => packagesWithNewVersions.find((pkg) => pkg.name === p.name)?.reason === "commits"
-  ).length;
-  const bumpedByDependency = bumpedPackages.length - bumpedByCommits;
-  if (bumpedPackages.length === 0) {
-    logger.debug("No packages were bumped");
-  } else {
-    logger.info(
-      `${dryRun ? "[dry-run] " : ""}${bumpedPackages.length} package(s) bumped independently (${bumpedByCommits} from commits, ${bumpedByDependency} from dependencies)`
-    );
-  }
-  return {
-    bumped: bumpedPackages.length > 0,
-    bumpedPackages
-  };
-}
 async function bumpSelectiveMode({
   config,
-  packages,
   dryRun,
   force,
   suffix
 }) {
   logger.debug("Starting bump in selective mode");
-  const rootPackage = getRootPackage(config.cwd);
-  const currentVersion = rootPackage.version;
+  const rootPackageBase = readPackageJson(config.cwd);
   const { from, to } = await resolveTags({
     config,
-    versionMode: "selective",
     step: "bump",
-    currentVersion,
-    newVersion: void 0,
-    pkg: void 0,
-    logLevel: config.logLevel
+    pkg: rootPackageBase,
+    newVersion: void 0
   });
-  logger.debug(`Bump from ${from} to ${to}`);
-  const commits = await getPackageCommits({
-    pkg: rootPackage,
+  const rootPackage = await getRootPackage({
+    config,
+    force,
     from,
     to,
-    config,
+    suffix,
     changelog: false
   });
-  const releaseType = determineReleaseType({ from, to, commits, config, force, currentVersion });
-  if (!releaseType) {
-    logger.debug("No commits require a version bump");
-    return { bumped: false };
-  }
-  const newVersion = bumpPackageVersion({
-    currentVersion,
-    releaseType,
-    preid: config.bump.preid,
-    suffix
-  });
+  const currentVersion = rootPackage.version;
+  const newVersion = rootPackage.newVersion;
+  logger.debug(`Bump from ${currentVersion} to ${newVersion}`);
   logger.debug("Determining packages to bump...");
-  const packagesToBump = force ? packages : await getPackageToBump({
-    packages,
-    from,
-    to,
-    config
+  const packages = await getPackages({
+    config,
+    patterns: config.monorepo?.packages,
+    suffix,
+    force
   });
-  if (packagesToBump.length === 0) {
+  if (packages.length === 0) {
     logger.debug("No packages have commits, skipping bump");
     return { bumped: false };
   }
@@ -2541,7 +2526,7 @@ async function bumpSelectiveMode({
     await confirmBump({
       versionMode: "selective",
       config,
-      packages: packagesToBump,
+      packages,
       force,
       currentVersion,
       newVersion,
@@ -2549,18 +2534,18 @@ async function bumpSelectiveMode({
     });
   } else {
     if (force) {
-      logger.info(`${packagesToBump.length} package(s) bumped to ${newVersion} (force)`);
+      logger.info(`${packages.length} package(s) bumped to ${newVersion} (force)`);
     } else {
-      const bumpedByCommits = packagesToBump.filter((p) => "reason" in p && p.reason === "commits").length;
-      const bumpedByDependency = packagesToBump.filter((p) => "reason" in p && p.reason === "dependency").length;
+      const bumpedByCommits = packages.filter((p) => "reason" in p && p.reason === "commits").length;
+      const bumpedByDependency = packages.filter((p) => "reason" in p && p.reason === "dependency").length;
+      const bumpedByGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation").length;
       logger.info(
-        `${currentVersion} \u2192 ${newVersion} (selective mode: ${bumpedByCommits} with commits, ${bumpedByDependency} as dependents)`
+        `${currentVersion} \u2192 ${newVersion} (selective mode: ${bumpedByCommits} with commits, ${bumpedByDependency} as dependents, ${bumpedByGraduation} from graduation)`
       );
     }
   }
-  logger.debug(`Writing version to ${packagesToBump.length} package(s)`);
-  writeVersion(rootPackage.path, newVersion, dryRun);
-  for (const pkg of packagesToBump) {
+  logger.debug(`Writing version to ${packages.length} package(s)`);
+  for (const pkg of [rootPackage, ...packages]) {
     writeVersion(pkg.path, newVersion, dryRun);
   }
   updateLernaVersion({
@@ -2571,19 +2556,76 @@ async function bumpSelectiveMode({
   });
   if (!dryRun) {
     logger.info(
-      `${packagesToBump.length} package(s) bumped to ${newVersion} (${packages.length - packagesToBump.length} skipped)`
+      `${packages.length} package(s) bumped to ${newVersion}`
     );
   }
   return {
     bumped: true,
     oldVersion: currentVersion,
+    rootPackage,
     fromTag: from,
     newVersion,
-    bumpedPackages: packagesToBump.map((pkg) => ({
+    bumpedPackages: packages.map((pkg) => ({
       ...pkg,
-      currentVersion: pkg.version,
-      version: newVersion,
-      fromTag: from
+      oldVersion: pkg.version,
+      fromTag: from,
+      newVersion
+    }))
+  };
+}
+async function bumpIndependentMode({
+  config,
+  dryRun,
+  suffix,
+  force
+}) {
+  logger.debug("Starting bump in independent mode");
+  const packagesToBump = await getPackages({
+    config,
+    patterns: config.monorepo?.packages,
+    suffix,
+    force
+  });
+  if (packagesToBump.length === 0) {
+    logger.debug("No packages have commits");
+    return { bumped: false };
+  }
+  if (!config.bump.yes) {
+    await confirmBump({
+      versionMode: "independent",
+      config,
+      packages: packagesToBump,
+      force,
+      dryRun
+    });
+  } else {
+    const bumpedByCommits2 = packagesToBump.filter((p) => p.reason === "commits").length;
+    const bumpedByDependency2 = packagesToBump.filter((p) => p.reason === "dependency").length;
+    const bumpedByGraduation = packagesToBump.filter((p) => p.reason === "graduation").length;
+    logger.info(
+      `${bumpedByCommits2 + bumpedByDependency2 + bumpedByGraduation} package(s) will be bumped independently (${bumpedByCommits2} from commits, ${bumpedByDependency2} from dependencies, ${bumpedByGraduation} from graduation)`
+    );
+  }
+  const bumpedPackages = getBumpedIndependentPackages({
+    packages: packagesToBump,
+    dryRun
+  });
+  const bumpedByCommits = bumpedPackages.filter(
+    (p) => packagesToBump.find((pkg) => pkg.name === p.name)?.reason === "commits"
+  ).length;
+  const bumpedByDependency = bumpedPackages.length - bumpedByCommits;
+  if (bumpedPackages.length === 0) {
+    logger.debug("No packages were bumped");
+  } else {
+    logger.info(
+      `${dryRun ? "[dry-run] " : ""}${bumpedPackages.length} package(s) bumped independently (${bumpedByCommits} from commits, ${bumpedByDependency} from dependencies)`
+    );
+  }
+  return {
+    bumped: bumpedPackages.length > 0,
+    bumpedPackages: bumpedPackages.map((pkg) => ({
+      ...pkg,
+      oldVersion: pkg.version
     }))
   };
 }
@@ -2613,7 +2655,7 @@ async function bump(options = {}) {
     }
     await fetchGitTags(config.cwd);
     logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
-    const packages = getPackages({
+    const packages = readPackages({
       cwd: config.cwd,
       patterns: config.monorepo?.packages,
       ignorePackageNames: config.monorepo?.ignorePackageNames
@@ -2622,7 +2664,6 @@ async function bump(options = {}) {
     let result;
     const payload = {
       config,
-      packages,
       dryRun,
       force,
       suffix: options.suffix
@@ -2651,17 +2692,20 @@ async function bump(options = {}) {
   }
 }
 
-function getPackagesToGenerateChangelogFor({
+async function getPackagesToGenerateChangelogFor({
   config,
-  bumpedPackages
+  bumpResult,
+  suffix,
+  force
 }) {
-  if (bumpedPackages && bumpedPackages.length > 0) {
-    return bumpedPackages;
+  if (bumpResult?.bumpedPackages && bumpResult.bumpedPackages.length > 0) {
+    return bumpResult.bumpedPackages;
   }
-  return getPackages({
-    cwd: config.cwd,
-    ignorePackageNames: config.monorepo?.ignorePackageNames,
-    patterns: config.monorepo?.packages
+  return await getPackages({
+    config,
+    patterns: config.monorepo?.packages,
+    suffix,
+    force
   });
 }
 async function generateIndependentRootChangelog({
@@ -2674,39 +2718,16 @@ async function generateIndependentRootChangelog({
     return;
   }
   logger.debug("Generating aggregated root changelog for independent mode");
-  const rootPackage = getRootPackage(config.cwd);
   const packageChangelogs = [];
   for (const pkg of packages) {
-    const { from, to } = await resolveTags({
-      config,
-      versionMode: "independent",
-      step: "changelog",
-      currentVersion: pkg.version,
-      newVersion: void 0,
-      pkg,
-      logLevel: config.logLevel
-    });
-    const lastTag = from;
-    logger.debug(`Generating changelog for ${pkg.name} (${lastTag}...${to})`);
-    const commits = await getPackageCommits({
-      pkg,
-      from: lastTag,
-      to,
-      config,
-      changelog: true
-    });
     const changelog2 = await generateChangelog({
-      config,
       pkg,
-      commits,
-      from: lastTag,
-      dryRun
+      config,
+      dryRun,
+      newVersion: isBumpedPackage(pkg) && pkg.newVersion || pkg.version
     });
     if (changelog2) {
-      const cleanedChangelog = changelog2.split("\n").slice(2).join("\n");
-      packageChangelogs.push(`## ${pkg.name}@${pkg.version}
-
-${cleanedChangelog}`);
+      packageChangelogs.push(changelog2);
     }
   }
   if (packageChangelogs.length === 0) {
@@ -2718,7 +2739,9 @@ ${cleanedChangelog}`);
 
 ${packageChangelogs.join("\n\n")}`;
   logger.verbose(`Aggregated root changelog: ${aggregatedChangelog}`);
+  const rootPackage = readPackageJson(config.cwd);
   writeChangelogToFile({
+    cwd: config.cwd,
     pkg: rootPackage,
     changelog: aggregatedChangelog,
     dryRun
@@ -2727,41 +2750,43 @@ ${packageChangelogs.join("\n\n")}`;
 }
 async function generateSimpleRootChangelog({
   config,
-  dryRun
+  dryRun,
+  force,
+  suffix,
+  bumpResult
 }) {
   if (!config.changelog?.rootChangelog) {
     logger.debug("Skipping root changelog generation");
     return;
   }
   logger.debug("Generating simple root changelog");
-  const rootPackage = getRootPackage(config.cwd);
+  const rootPackageRead = readPackageJson(config.cwd);
   const { from, to } = await resolveTags({
     config,
-    versionMode: config.monorepo?.versionMode || "unified",
     step: "changelog",
-    currentVersion: rootPackage.version,
     newVersion: void 0,
-    pkg: void 0,
-    logLevel: config.logLevel
+    pkg: rootPackageRead
   });
-  logger.debug(`Generating root changelog (${from}...${to})`);
-  logger.debug(`Root package: ${rootPackage.name} at ${rootPackage.path}`);
-  const rootCommits = await getPackageCommits({
-    pkg: rootPackage,
-    from,
-    to,
+  const fromTag = bumpResult?.fromTag || from;
+  const rootPackage = bumpResult?.rootPackage || await getRootPackage({
     config,
-    changelog: true
+    force,
+    suffix,
+    changelog: true,
+    from: fromTag,
+    to
   });
+  logger.debug(`Generating ${rootPackage.name} changelog (${fromTag}...${to})`);
+  const newVersion = bumpResult?.newVersion || rootPackage.version;
   const rootChangelog = await generateChangelog({
     pkg: rootPackage,
-    commits: rootCommits,
     config,
-    from,
-    dryRun
+    dryRun,
+    newVersion
   });
   if (rootChangelog) {
     writeChangelogToFile({
+      cwd: config.cwd,
       changelog: rootChangelog,
       pkg: rootPackage,
       dryRun
@@ -2791,56 +2816,57 @@ async function changelog(options = {}) {
   try {
     await executeHook("before:changelog", config, dryRun);
     logger.start("Start generating changelogs");
-    const packages = getPackagesToGenerateChangelogFor({
-      config,
-      bumpedPackages: options.bumpedPackages
-    });
     if (config.changelog?.rootChangelog && config.monorepo) {
       if (config.monorepo.versionMode === "independent") {
+        const packages2 = await getPackagesToGenerateChangelogFor({
+          config,
+          bumpResult: options.bumpResult,
+          suffix: options.suffix,
+          force: options.force ?? false
+        });
         await generateIndependentRootChangelog({
-          packages,
+          packages: packages2,
           config,
           dryRun
         });
       } else {
         await generateSimpleRootChangelog({
           config,
-          dryRun
+          dryRun,
+          bumpResult: options.bumpResult,
+          suffix: options.suffix,
+          force: options.force ?? false
         });
       }
     } else {
       logger.debug("Skipping root changelog generation");
     }
     logger.debug("Generating package changelogs...");
+    const packages = options.bumpResult?.bumpedPackages ? options.bumpResult.bumpedPackages : await getPackages({
+      config,
+      patterns: config.monorepo?.packages,
+      suffix: options.suffix,
+      force: options.force ?? false
+    });
     logger.debug(`Processing ${packages.length} package(s)`);
     let generatedCount = 0;
     for await (const pkg of packages) {
       const { from, to } = await resolveTags({
         config,
-        versionMode: config.monorepo?.versionMode || "unified",
         step: "changelog",
-        currentVersion: pkg.version,
-        newVersion: void 0,
         pkg,
-        logLevel: config.logLevel
+        newVersion: void 0
       });
       logger.debug(`Processing ${pkg.name} (${from}...${to})`);
-      const commits = await getPackageCommits({
-        pkg,
-        from,
-        to,
-        config,
-        changelog: true
-      });
       const changelog2 = await generateChangelog({
         pkg,
-        commits,
         config,
-        from,
-        dryRun
+        dryRun,
+        newVersion: options.bumpResult?.bumpedPackages?.find((p) => p.name === pkg.name)?.newVersion
       });
       if (changelog2) {
         writeChangelogToFile({
+          cwd: config.cwd,
           pkg,
           changelog: changelog2,
           dryRun
@@ -2889,7 +2915,7 @@ async function providerRelease(options = {}) {
     configName: options.configName,
     baseConfig: options.config,
     overrides: {
-      from: options.from || (options.bumpResult?.bumped === true ? options.bumpResult.fromTag : void 0),
+      from: options.from,
       to: options.to,
       tokens: {
         github: options.token,
@@ -2903,12 +2929,12 @@ async function providerRelease(options = {}) {
   logger.debug(`Dry run: ${dryRun}`);
   logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
   try {
-    await executeHook("before:provider-release", config, dryRun);
     const detectedProvider = options.provider || detectGitProvider();
     providerReleaseSafetyCheck({ config, provider: detectedProvider });
+    await executeHook("before:provider-release", config, dryRun);
     logger.start("Start provider release");
     if (!detectedProvider) {
-      logger.warn("Unable to detect Git provider. Skipping release publication.");
+      logger.fail("Unable to detect Git provider. Skipping release publication.");
       throw new Error("Unable to detect Git provider");
     } else {
       logger.info(
@@ -2917,19 +2943,21 @@ async function providerRelease(options = {}) {
     }
     let postedReleases = [];
     const payload = {
-      from: config.from,
+      from: config.from || options.bumpResult?.fromTag,
       to: config.to,
       dryRun,
       config,
       logLevel: config.logLevel,
-      bumpResult: options.bumpResult
+      bumpResult: options.bumpResult,
+      force: options.force ?? false,
+      suffix: options.suffix
     };
     if (detectedProvider === "github") {
       postedReleases = await github(payload);
     } else if (detectedProvider === "gitlab") {
       postedReleases = await gitlab(payload);
     } else {
-      logger.warn(`Unsupported Git provider: ${detectedProvider}`);
+      logger.error(`Unsupported Git provider: ${detectedProvider}`);
     }
     await executeHook("success:provider-release", config, dryRun);
     return {
@@ -2973,17 +3001,17 @@ async function publish(options = {}) {
   }
   try {
     await executeHook("before:publish", config, dryRun);
+    const rootPackage = readPackageJson(config.cwd);
     logger.start("Start publishing packages");
-    const packages = options.bumpedPackages || getPackages({
-      cwd: config.cwd,
+    const packages = options.bumpedPackages || await getPackages({
+      config,
       patterns: config.publish.packages ?? config.monorepo?.packages,
-      ignorePackageNames: config.monorepo?.ignorePackageNames
+      suffix: options.suffix,
+      force: options.force ?? false
     });
-    const rootPackage = getRootPackage(config.cwd);
     logger.debug(`Found ${packages.length} package(s)`);
     logger.debug("Building dependency graph and sorting...");
-    const packagesWithDeps = getPackagesWithDependencies(packages, config.bump.dependencyTypes);
-    const sortedPackages = topologicalSort(packagesWithDeps);
+    const sortedPackages = topologicalSort(packages);
     let publishedPackages = packages || [];
     if (publishedPackages.length === 0 && config.monorepo?.versionMode === "independent") {
       logger.debug("Determining packages to publish in independent mode...");
@@ -3000,7 +3028,7 @@ async function publish(options = {}) {
       logger.info(`Publishing ${publishedPackages.length} package(s) (unified mode)`);
     }
     if (publishedPackages.length === 0) {
-      logger.warn("No packages need to be published");
+      logger.fail("No packages need to be published");
       return;
     }
     await executeBuildCmd({
@@ -3009,7 +3037,7 @@ async function publish(options = {}) {
     });
     for (const pkg of sortedPackages) {
       if (publishedPackages.some((p) => p.name === pkg.name)) {
-        logger.debug(`Publishing ${pkg.name}@${pkg.version}...`);
+        logger.debug(`Publishing ${getIndependentTag(pkg)}...`);
         await publishPackage({
           pkg,
           config,
@@ -3104,7 +3132,8 @@ async function release(options = {}) {
       config,
       force,
       clean: config.release.clean,
-      configName: options.configName
+      configName: options.configName,
+      suffix: options.suffix
     });
     if (!bumpResult.bumped) {
       logger.debug("No packages bumped");
@@ -3118,10 +3147,12 @@ async function release(options = {}) {
         dryRun,
         formatCmd: config.changelog.formatCmd,
         rootChangelog: config.changelog.rootChangelog,
-        bumpedPackages: bumpResult.bumpedPackages,
+        bumpResult,
         config,
         logLevel: config.logLevel,
-        configName: options.configName
+        configName: options.configName,
+        force,
+        suffix: options.suffix
       });
     } else {
       logger.info("Skipping changelog generation (--no-changelog)");
@@ -3164,7 +3195,9 @@ async function release(options = {}) {
         bumpedPackages: bumpResult.bumpedPackages,
         dryRun,
         config,
-        configName: options.configName
+        configName: options.configName,
+        suffix: options.suffix,
+        force
       });
     } else {
       logger.info("Skipping publish (--no-publish)");
@@ -3184,7 +3217,9 @@ async function release(options = {}) {
           config,
           logLevel: config.logLevel,
           bumpResult,
-          configName: options.configName
+          configName: options.configName,
+          force,
+          suffix: options.suffix
         });
         provider = response.detectedProvider;
         postedReleases = response.postedReleases;
@@ -3195,7 +3230,7 @@ async function release(options = {}) {
       logger.info("Skipping release (--no-provider-release)");
     }
     const publishedPackageCount = publishResponse?.publishedPackages.length ?? 0;
-    const versionDisplay = config.monorepo?.versionMode === "independent" ? `${bumpResult.bumpedPackages.length} packages bumped independently` : bumpResult.newVersion || getRootPackage(config.cwd).version;
+    const versionDisplay = config.monorepo?.versionMode === "independent" ? `${bumpResult.bumpedPackages.length} packages bumped independently` : bumpResult.newVersion || readPackageJson(config.cwd).version;
     logger.box(`Release workflow completed!
 
 Version: ${versionDisplay}
@@ -3212,4 +3247,4 @@ Git provider: ${provider}`);
   }
 }
 
-export { isStableReleaseType as $, github as A, createGitlabRelease as B, gitlab as C, getPackages as D, getPackageCommits as E, getRootPackage as F, hasLernaJson as G, getPackageToBump as H, detectPackageManager as I, determinePublishTag as J, getPackagesToPublishInSelectiveMode as K, getPackagesToPublishInIndependentMode as L, publishPackage as M, getLastRepoTag as N, getLastPackageTag as O, resolveTags as P, executeHook as Q, isInCI as R, getCIName as S, executeFormatCmd as T, executeBuildCmd as U, determineReleaseType as V, writeVersion as W, bumpPackageVersion as X, updateLernaVersion as Y, extractVersionFromPackageTag as Z, isPrerelease as _, providerRelease as a, isPrereleaseReleaseType as a0, isGraduating as a1, getPreid as a2, isChangedPreid as a3, bumpPackageIndependently as a4, confirmBump as a5, findPackagesWithCommitsAndCalculateVersions as a6, bumpIndependentPackages as a7, bump as b, changelog as c, publish as d, getDefaultConfig as e, defineConfig as f, generateChangelog as g, getPackageDependencies as h, getPackagesWithDependencies as i, getDependentsOf as j, expandPackagesToBumpWithDependents as k, loadRelizyConfig as l, getGitStatus as m, checkGitStatusIfDirty as n, fetchGitTags as o, providerReleaseSafetyCheck as p, detectGitProvider as q, release as r, parseGitRemoteUrl as s, topologicalSort as t, createCommitAndTags as u, pushCommitAndTags as v, writeChangelogToFile as w, getFirstCommit as x, getCurrentGitBranch as y, getCurrentGitRef as z };
+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 };