relizy 0.2.8 → 1.0.0-beta.0

package/dist/shared/{relizy.DwP99Z7x.mjs → relizy.C2HlcnZB.mjs}

@@ -1,4 +1,5 @@
 import { logger, execPromise } from '@maz-ui/node';
+import process$1 from 'node:process';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import path, { join, relative } from 'node:path';
 import { getGitDiff, parseCommits, formatCompareChanges, formatReference, resolveRepoConfig, getRepoConfig, createGithubRelease } from 'changelogen';
@@ -7,7 +8,6 @@ import { confirm, input } from '@inquirer/prompts';
 import { upperFirst, formatJson } from '@maz-ui/utils';
 import * as semver from 'semver';
 import { execSync } from 'node:child_process';
-import process$1, { exit } from 'node:process';
 import { setupDotenv, loadConfig } from 'c12';
 import { defu } from 'defu';
 import { convert } from 'convert-gitmoji';
@@ -276,11 +276,11 @@ function getPackageReleaseType({
   });
 }
 async function getPackages({
-  patterns,
   config,
   suffix,
   force
 }) {
+  const patterns = config.monorepo?.packages;
   const readedPackages = readPackages({
     cwd: config.cwd,
     patterns,
@@ -445,14 +445,13 @@ async function getPackageCommits({
     if (!isAllowedCommit({ commit, type, changelog })) {
       return false;
     }
-    const isTracked = isCommitOfTrackedPackages({ commit, config });
-    if ((pkg.path === changelogConfig.cwd || pkg.name === rootPackage.name) && isTracked) {
+    const isTrackedPackage = isCommitOfTrackedPackages({ commit, config });
+    if ((pkg.path === changelogConfig.cwd || pkg.name === rootPackage.name) && isTrackedPackage) {
       return true;
     }
     const packageRelativePath = relative(changelogConfig.cwd, pkg.path);
-    const scopeMatches = commit.scope === pkg.name;
     const bodyContainsPath = commit.body.includes(packageRelativePath);
-    return (scopeMatches || bodyContainsPath) && isTracked;
+    return bodyContainsPath && isTrackedPackage;
   });
   logger.debug(`Found ${commits.length} commit(s) for ${pkg.name} from ${from} to ${to}`);
   if (commits.length > 0) {
@@ -477,7 +476,7 @@ async function executeHook(hook, config, dryRun, params) {
     logger.info(`Executing hook ${hook}`);
     const result = await hookInput(config, dryRun, params);
     if (result)
-      logger.debug(`Hook ${hook} returned: ${result}`);
+      logger.debug(`Hook ${hook} returned: ${typeof result === "object" ? JSON.stringify(result) : result}`);
     logger.info(`Hook ${hook} executed`);
     return result;
   }
@@ -490,62 +489,62 @@ async function executeHook(hook, config, dryRun, params) {
       noStdout: true
     });
     if (result)
-      logger.debug(`Hook ${hook} returned: ${result}`);
+      logger.debug(`Hook ${hook} returned: ${typeof result === "object" ? JSON.stringify(result) : result}`);
     logger.info(`Hook ${hook} executed`);
     return result;
   }
 }
 function isInCI() {
   return Boolean(
-    process.env.CI === "true" || process.env.CONTINUOUS_INTEGRATION === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.GITHUB_WORKFLOW || process.env.GITLAB_CI === "true" || process.env.CIRCLECI === "true" || process.env.TRAVIS === "true" || process.env.JENKINS_HOME || process.env.JENKINS_URL || process.env.BUILD_ID || process.env.TF_BUILD === "True" || process.env.AZURE_PIPELINES === "true" || process.env.TEAMCITY_VERSION || process.env.BITBUCKET_BUILD_NUMBER || process.env.DRONE === "true" || process.env.APPVEYOR === "True" || process.env.APPVEYOR === "true" || process.env.BUILDKITE === "true" || process.env.CODEBUILD_BUILD_ID || process.env.NETLIFY === "true" || process.env.VERCEL === "1" || process.env.HEROKU_TEST_RUN_ID || process.env.BUDDY === "true" || process.env.SEMAPHORE === "true" || process.env.CF_BUILD_ID || process.env.bamboo_buildKey || process.env.BUILD_ID && process.env.PROJECT_ID || process.env.SCREWDRIVER === "true" || process.env.STRIDER === "true"
+    process$1.env.CI === "true" || process$1.env.CONTINUOUS_INTEGRATION === "true" || process$1.env.GITHUB_ACTIONS === "true" || process$1.env.GITHUB_WORKFLOW || process$1.env.GITLAB_CI === "true" || process$1.env.CIRCLECI === "true" || process$1.env.TRAVIS === "true" || process$1.env.JENKINS_HOME || process$1.env.JENKINS_URL || process$1.env.BUILD_ID || process$1.env.TF_BUILD === "True" || process$1.env.AZURE_PIPELINES === "true" || process$1.env.TEAMCITY_VERSION || process$1.env.BITBUCKET_BUILD_NUMBER || process$1.env.DRONE === "true" || process$1.env.APPVEYOR === "True" || process$1.env.APPVEYOR === "true" || process$1.env.BUILDKITE === "true" || process$1.env.CODEBUILD_BUILD_ID || process$1.env.NETLIFY === "true" || process$1.env.VERCEL === "1" || process$1.env.HEROKU_TEST_RUN_ID || process$1.env.BUDDY === "true" || process$1.env.SEMAPHORE === "true" || process$1.env.CF_BUILD_ID || process$1.env.bamboo_buildKey || process$1.env.BUILD_ID && process$1.env.PROJECT_ID || process$1.env.SCREWDRIVER === "true" || process$1.env.STRIDER === "true"
   );
 }
 function getCIName() {
-  if (process.env.GITHUB_ACTIONS === "true")
+  if (process$1.env.GITHUB_ACTIONS === "true")
     return "GitHub Actions";
-  if (process.env.GITLAB_CI === "true")
+  if (process$1.env.GITLAB_CI === "true")
     return "GitLab CI";
-  if (process.env.CIRCLECI === "true")
+  if (process$1.env.CIRCLECI === "true")
     return "CircleCI";
-  if (process.env.TRAVIS === "true")
+  if (process$1.env.TRAVIS === "true")
     return "Travis CI";
-  if (process.env.JENKINS_HOME || process.env.JENKINS_URL)
+  if (process$1.env.JENKINS_HOME || process$1.env.JENKINS_URL)
     return "Jenkins";
-  if (process.env.TF_BUILD === "True")
+  if (process$1.env.TF_BUILD === "True")
     return "Azure Pipelines";
-  if (process.env.TEAMCITY_VERSION)
+  if (process$1.env.TEAMCITY_VERSION)
     return "TeamCity";
-  if (process.env.BITBUCKET_BUILD_NUMBER)
+  if (process$1.env.BITBUCKET_BUILD_NUMBER)
     return "Bitbucket Pipelines";
-  if (process.env.DRONE === "true")
+  if (process$1.env.DRONE === "true")
     return "Drone";
-  if (process.env.APPVEYOR)
+  if (process$1.env.APPVEYOR)
     return "AppVeyor";
-  if (process.env.BUILDKITE === "true")
+  if (process$1.env.BUILDKITE === "true")
     return "Buildkite";
-  if (process.env.CODEBUILD_BUILD_ID)
+  if (process$1.env.CODEBUILD_BUILD_ID)
     return "AWS CodeBuild";
-  if (process.env.NETLIFY === "true")
+  if (process$1.env.NETLIFY === "true")
     return "Netlify";
-  if (process.env.VERCEL === "1")
+  if (process$1.env.VERCEL === "1")
     return "Vercel";
-  if (process.env.HEROKU_TEST_RUN_ID)
+  if (process$1.env.HEROKU_TEST_RUN_ID)
     return "Heroku CI";
-  if (process.env.BUDDY === "true")
+  if (process$1.env.BUDDY === "true")
     return "Buddy";
-  if (process.env.SEMAPHORE === "true")
+  if (process$1.env.SEMAPHORE === "true")
     return "Semaphore";
-  if (process.env.CF_BUILD_ID)
+  if (process$1.env.CF_BUILD_ID)
     return "Codefresh";
-  if (process.env.bamboo_buildKey)
+  if (process$1.env.bamboo_buildKey)
     return "Bamboo";
-  if (process.env.BUILD_ID && process.env.PROJECT_ID)
+  if (process$1.env.BUILD_ID && process$1.env.PROJECT_ID)
     return "Google Cloud Build";
-  if (process.env.SCREWDRIVER === "true")
+  if (process$1.env.SCREWDRIVER === "true")
     return "Screwdriver";
-  if (process.env.STRIDER === "true")
+  if (process$1.env.STRIDER === "true")
     return "Strider";
-  if (process.env.CI === "true")
+  if (process$1.env.CI === "true")
     return "Unknown CI";
   return null;
 }
@@ -611,17 +610,19 @@ async function getPackagesOrBumpedPackages({
   }
   return await getPackages({
     config,
-    patterns: config.monorepo?.packages,
     suffix,
     force
   });
 }
 
-function getGitStatus(cwd) {
-  return execSync("git status --porcelain", {
+function getGitStatus(cwd, trim = true) {
+  const status = execSync("git status --porcelain", {
     cwd,
     encoding: "utf8"
-  }).trim();
+  });
+  if (trim)
+    return status.trim();
+  return status;
 }
 function checkGitStatusIfDirty() {
   logger.debug("Checking git status");
@@ -661,6 +662,9 @@ function detectGitProvider(cwd = process.cwd()) {
     if (remoteUrl.includes("gitlab.com") || remoteUrl.includes("gitlab")) {
       return "gitlab";
     }
+    if (remoteUrl.includes("bitbucket.org") || remoteUrl.includes("bitbucket")) {
+      return "bitbucket";
+    }
     return null;
   } catch {
     return null;
@@ -668,7 +672,7 @@ function detectGitProvider(cwd = process.cwd()) {
 }
 function parseGitRemoteUrl(remoteUrl) {
   const sshRegex = /git@[\w.-]+:([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
-  const httpsRegex = /https?:\/\/[\w.-]+\/([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
+  const httpsRegex = /https?:\/\/[\w.-]+\/(.+?)\/([^/]+?)(?:\.git)?$/;
   const sshMatch = remoteUrl.match(sshRegex);
   if (sshMatch) {
     return {
@@ -685,6 +689,27 @@ function parseGitRemoteUrl(remoteUrl) {
   }
   return null;
 }
+function getModifiedReleaseFilePatterns({ config }) {
+  const gitStatusRaw = getGitStatus(config.cwd, false);
+  if (!gitStatusRaw) {
+    logger.debug("No modified files in git status");
+    return [];
+  }
+  const modifiedFiles = gitStatusRaw.split("\n").filter((line) => line.length > 0).map((line) => {
+    if (line.length < 4)
+      return null;
+    const filename = line.substring(3).trim();
+    return filename || null;
+  }).filter((file) => file !== null);
+  const releaseFiles = modifiedFiles.filter((file) => {
+    const isPackageJson = file === "package.json" || file.endsWith("/package.json");
+    const isChangelog = file === "CHANGELOG.md" || file.endsWith("/CHANGELOG.md");
+    const isLerna = file === "lerna.json";
+    return isPackageJson || isChangelog || isLerna;
+  });
+  logger.debug(`Found ${releaseFiles.length} modified release files:`, releaseFiles.join(", "));
+  return releaseFiles;
+}
 async function createCommitAndTags({
   config,
   noVerify,
@@ -696,13 +721,7 @@ async function createCommitAndTags({
   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"
-    ];
+    const filePatternsToAdd = getModifiedReleaseFilePatterns({ config: internalConfig });
     logger.start("Start commit and tag");
     logger.debug("Adding files to git staging area...");
     for (const pattern of filePatternsToAdd) {
@@ -821,6 +840,47 @@ async function pushCommitAndTags({ config, dryRun, logLevel, cwd }) {
   }
   logger.success("Pushing changes and tags completed!");
 }
+async function rollbackModifiedFiles({
+  config
+}) {
+  const modifiedFiles = getModifiedReleaseFilePatterns({ config });
+  if (modifiedFiles.length === 0) {
+    logger.debug("No modified files to rollback");
+    return;
+  }
+  logger.debug(`Rolling back ${modifiedFiles.length} modified file(s)...`);
+  logger.debug(`Files to rollback: ${modifiedFiles.join(", ")}`);
+  try {
+    const fileList = modifiedFiles.join(" ");
+    logger.debug(`Restoring specific files from HEAD: ${fileList}`);
+    await execPromise(`git checkout HEAD -- ${fileList}`, {
+      cwd: config.cwd,
+      logLevel: config.logLevel,
+      noStderr: true
+    });
+    logger.debug("Checking for untracked release files to remove...");
+    for (const file of modifiedFiles) {
+      const filePath = join(config.cwd, file);
+      if (existsSync(filePath)) {
+        try {
+          execSync(`git ls-files --error-unmatch "${file}"`, {
+            cwd: config.cwd,
+            encoding: "utf8",
+            stdio: "pipe"
+          });
+        } catch {
+          logger.debug(`Removing untracked file: ${file}`);
+          execSync(`rm "${filePath}"`, { cwd: config.cwd });
+        }
+      }
+    }
+    logger.success(`Successfully rolled back ${modifiedFiles.length} release file(s)`);
+  } catch (error) {
+    logger.error("Failed to rollback modified files automatically");
+    logger.warn(`Please manually restore these files: ${modifiedFiles.join(", ")}`);
+    throw error;
+  }
+}
 function getFirstCommit(cwd) {
   const result = execSync(
     "git rev-list --max-parents=0 HEAD",
@@ -848,7 +908,8 @@ async function generateMarkDown({
   config,
   from,
   to,
-  isFirstCommit
+  isFirstCommit,
+  minify
 }) {
   const typeGroups = groupBy(commits, "type");
   const markdown = [];
@@ -861,7 +922,7 @@ async function generateMarkDown({
   const versionTitle = updatedConfig.to;
   const changelogTitle = `${updatedConfig.from}...${updatedConfig.to}`;
   markdown.push("", `## ${changelogTitle}`, "");
-  if (updatedConfig.repo && updatedConfig.from && versionTitle) {
+  if (updatedConfig.repo && updatedConfig.from && versionTitle && !minify) {
     const formattedCompareLink = formatCompareChanges(versionTitle, {
       ...updatedConfig,
       from: isFirstCommit ? getFirstCommit(updatedConfig.cwd) : updatedConfig.from
@@ -878,7 +939,11 @@ async function generateMarkDown({
     }
     markdown.push("", `### ${updatedConfig.types[type]?.title}`, "");
     for (const commit of group.reverse()) {
-      const line = formatCommit(commit, updatedConfig);
+      const line = formatCommit({
+        commit,
+        config: updatedConfig,
+        minify
+      });
       markdown.push(line);
       if (commit.isBreaking) {
         breakingChanges.push(line);
@@ -890,7 +955,7 @@ async function generateMarkDown({
   }
   const _authors = /* @__PURE__ */ new Map();
   for (const commit of commits) {
-    if (!commit.author) {
+    if (!commit.author || minify) {
       continue;
     }
     const name = formatName(commit.author.name);
@@ -970,9 +1035,9 @@ function getCommitBody(commit) {
 ${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 formatCommit({ commit, config, minify }) {
+  const body = config.changelog.includeCommitBody && !minify ? getCommitBody(commit) : "";
+  return `- ${commit.scope ? `**${commit.scope.trim()}:** ` : ""}${commit.isBreaking ? "\u26A0\uFE0F  " : ""}${upperFirst(commit.description)}${minify ? "" : formatReferences(commit.references, config)}${body}`;
 }
 function formatReferences(references, config) {
   const pr = references.filter((ref) => ref.type === "pull-request");
@@ -997,1472 +1062,1500 @@ function groupBy(items, key) {
   return groups;
 }
 
-function fromTagIsFirstCommit(fromTag, cwd) {
-  return fromTag === getFirstCommit(cwd);
+function isGraduatingToStableBetweenVersion(version, newVersion) {
+  const isSameBase = semver.major(version) === semver.major(newVersion) && semver.minor(version) === semver.minor(newVersion) && semver.patch(version) === semver.patch(newVersion);
+  const fromPrerelease = semver.prerelease(version) !== null;
+  const toStable = semver.prerelease(newVersion) === null;
+  return isSameBase && fromPrerelease && toStable;
 }
-async function generateChangelog({
-  pkg,
-  config,
-  dryRun,
-  newVersion
+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);
+  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, types, force) {
+  if (!commits?.length && !force) {
+    logger.debug('No commits found for stable version with "release" type, skipping bump');
+    return void 0;
+  }
+  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
+  if (!detectedType && !force) {
+    logger.debug("No significant commits found, skipping bump");
+    return void 0;
+  }
+  logger.debug(`Auto-detected release type from commits: ${detectedType}`);
+  return detectedType;
+}
+function handleStableVersionWithPrereleaseType(commits, types, force) {
+  if (!commits?.length && !force) {
+    logger.debug('No commits found for stable version with "prerelease" type, skipping bump');
+    return void 0;
+  }
+  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
+  if (!detectedType) {
+    logger.debug("No significant commits found, using prepatch as default");
+    return "prepatch";
+  }
+  const prereleaseType = `pre${detectedType}`;
+  logger.debug(`Auto-detected prerelease type from commits: ${prereleaseType}`);
+  return prereleaseType;
+}
+function handlePrereleaseVersionToStable(currentVersion) {
+  logger.debug(`Graduating from prerelease ${currentVersion} to stable release`);
+  return "release";
+}
+function handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force }) {
+  const currentPreid = getPreid(currentVersion);
+  const hasChangedPreid = preid && currentPreid && currentPreid !== preid;
+  if (hasChangedPreid) {
+    const testVersion = semver.inc(currentVersion, "prerelease", preid);
+    if (!testVersion) {
+      throw new Error(`Unable to change preid from ${currentPreid} to ${preid} for version ${currentVersion}`);
+    }
+    const isUpgrade = semver.gt(testVersion, currentVersion);
+    if (!isUpgrade) {
+      throw new Error(`Unable to change preid from ${currentVersion} to ${testVersion}, it's not a valid upgrade (cannot downgrade from ${currentPreid} to ${preid})`);
+    }
+    return "prerelease";
+  }
+  if (!commits?.length && !force) {
+    logger.debug("No commits found for prerelease version, skipping bump");
+    return void 0;
+  }
+  logger.debug(`Incrementing prerelease version: ${currentVersion}`);
+  return "prerelease";
+}
+function handleExplicitReleaseType({
+  releaseType,
+  currentVersion
 }) {
-  let fromTag = config.from || pkg.fromTag || getFirstCommit(config.cwd);
-  const isFirstCommit = fromTagIsFirstCommit(fromTag, config.cwd);
-  if (isFirstCommit) {
-    fromTag = config.monorepo?.versionMode === "independent" ? getIndependentTag({ version: "0.0.0", name: pkg.name }) : config.templates.tagBody.replace("{{newVersion}}", "0.0.0");
+  const isCurrentPrerelease = isPrerelease(currentVersion);
+  const isGraduatingToStable = isCurrentPrerelease && isStableReleaseType(releaseType);
+  if (isGraduatingToStable) {
+    logger.debug(`Graduating from prerelease ${currentVersion} to stable with type: ${releaseType}`);
+  } else {
+    logger.debug(`Using explicit release type: ${releaseType}`);
   }
-  let toTag = config.to;
-  if (!toTag) {
-    toTag = config.monorepo?.versionMode === "independent" ? getIndependentTag({ version: newVersion, name: pkg.name }) : config.templates.tagBody.replace("{{newVersion}}", newVersion);
+  return releaseType;
+}
+function determineReleaseType({
+  currentVersion,
+  commits,
+  releaseType,
+  preid,
+  types,
+  force
+}) {
+  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');
   }
-  if (!toTag) {
-    throw new Error(`No tag found for ${pkg.name}`);
+  validatePrereleaseDowngrade(currentVersion, preid, releaseType);
+  if (force) {
+    logger.debug(`Force flag enabled, using configured type: ${releaseType}`);
+    return releaseType;
   }
-  logger.debug(`Generating changelog for ${pkg.name} - from ${fromTag} to ${toTag}`);
-  try {
-    config = {
-      ...config,
-      from: fromTag,
-      to: toTag
-    };
-    const generatedChangelog = await generateMarkDown({
-      commits: pkg.commits,
-      config,
-      from: fromTag,
-      isFirstCommit,
-      to: toTag
-    });
-    let changelog = generatedChangelog;
-    if (pkg.commits.length === 0) {
-      changelog = `${changelog}
-
-${config.templates.emptyChangelogContent}`;
+  const isCurrentPrerelease = isPrerelease(currentVersion);
+  if (!isCurrentPrerelease) {
+    if (releaseType === "release") {
+      return handleStableVersionWithReleaseType(commits, types, force);
     }
-    const changelogResult = await executeHook("generate:changelog", config, dryRun, {
-      commits: pkg.commits,
-      changelog
-    });
-    changelog = changelogResult || changelog;
-    logger.verbose(`Output changelog for ${pkg.name}:
-${changelog}`);
-    logger.debug(`Changelog generated for ${pkg.name} (${pkg.commits.length} commits)`);
-    logger.verbose(`Final changelog for ${pkg.name}:
-
-${changelog}
-
-`);
+    if (releaseType === "prerelease") {
+      return handleStableVersionWithPrereleaseType(commits, types, force);
+    }
+    return handleExplicitReleaseType({ releaseType, currentVersion });
+  }
+  if (releaseType === "release") {
+    return handlePrereleaseVersionToStable(currentVersion);
+  }
+  if (releaseType === "prerelease") {
+    return handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force });
+  }
+  return handleExplicitReleaseType({ releaseType, currentVersion });
+}
+function writeVersion(pkgPath, newVersion, dryRun = false) {
+  const packageJsonPath = join(pkgPath, "package.json");
+  try {
+    logger.debug(`Writing ${newVersion} to ${pkgPath}`);
+    const content = readFileSync(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(content);
+    const oldVersion = packageJson.version;
+    packageJson.version = newVersion;
     if (dryRun) {
-      logger.info(`[dry-run] ${pkg.name} - Generate changelog ${fromTag}...${toTag}`);
+      logger.debug(`[dry-run] Updated ${packageJson.name}: ${oldVersion} \u2192 ${newVersion}`);
+      return;
     }
-    return changelog;
+    writeFileSync(packageJsonPath, `${formatJson(packageJson)}
+`, "utf8");
+    logger.debug(`Updated ${packageJson.name}: ${oldVersion} \u2192 ${newVersion}`);
   } catch (error) {
-    throw new Error(`Error generating changelog for ${pkg.name} (${fromTag}...${toTag}): ${error}`);
+    throw new Error(`Unable to write version to ${packageJsonPath}: ${error}`);
   }
 }
-function writeChangelogToFile({
-  cwd,
-  pkg,
-  changelog,
-  dryRun = false
+function getPackageNewVersion({
+  name,
+  currentVersion,
+  releaseType,
+  preid,
+  suffix
 }) {
-  const changelogPath = join(pkg.path, "CHANGELOG.md");
-  let existingChangelog = "";
-  if (existsSync(changelogPath)) {
-    existingChangelog = readFileSync(changelogPath, "utf8");
+  let newVersion = semver.inc(currentVersion, releaseType, preid);
+  if (!newVersion) {
+    throw new Error(`Unable to bump "${name}" version "${currentVersion}" with release type "${releaseType}"
+
+You should use an explicit release type (use flag: --major, --minor, --patch, --premajor, --preminor, --prepatch, --prerelease)`);
   }
-  const lines = existingChangelog.split("\n");
-  const titleIndex = lines.findIndex((line) => line.startsWith("# "));
-  let updatedChangelog;
-  if (titleIndex !== -1) {
-    const beforeTitle = lines.slice(0, titleIndex + 1);
-    const afterTitle = lines.slice(titleIndex + 1);
-    updatedChangelog = [...beforeTitle, "", changelog, "", ...afterTitle].join("\n");
-  } else {
-    const title = "# Changelog\n";
-    updatedChangelog = `${title}
-${changelog}
-${existingChangelog}`;
+  if (isPrereleaseReleaseType(releaseType) && suffix) {
+    newVersion = newVersion.replace(/\.(\d+)$/, `.${suffix}`);
   }
-  if (dryRun) {
-    const relativeChangelogPath = relative(cwd, changelogPath);
-    logger.info(`[dry-run] ${pkg.name} - Write changelog to ${relativeChangelogPath}`);
-  } else {
-    logger.debug(`Writing changelog to ${changelogPath}`);
-    writeFileSync(changelogPath, updatedChangelog, "utf8");
-    logger.info(`Changelog updated for ${pkg.name} (${"newVersion" in pkg && pkg.newVersion || pkg.version})`);
-  }
-}
-
-function getDefaultConfig() {
-  return {
-    cwd: process$1.cwd(),
-    types: {
-      feat: { title: "\u{1F680} Enhancements", semver: "minor" },
-      perf: { title: "\u{1F525} Performance", semver: "patch" },
-      fix: { title: "\u{1FA79} Fixes", semver: "patch" },
-      refactor: { title: "\u{1F485} Refactors", semver: "patch" },
-      docs: { title: "\u{1F4D6} Documentation", semver: "patch" },
-      build: { title: "\u{1F4E6} Build", semver: "patch" },
-      types: { title: "\u{1F30A} Types", semver: "patch" },
-      chore: { title: "\u{1F3E1} Chore" },
-      examples: { title: "\u{1F3C0} Examples" },
-      test: { title: "\u2705 Tests" },
-      style: { title: "\u{1F3A8} Styles" },
-      ci: { title: "\u{1F916} CI" }
-    },
-    templates: {
-      commitMessage: "chore(release): bump version to {{newVersion}}",
-      tagMessage: "Bump version to {{newVersion}}",
-      tagBody: "v{{newVersion}}",
-      emptyChangelogContent: "No relevant changes for this release"
-    },
-    excludeAuthors: [],
-    noAuthors: false,
-    bump: {
-      type: "release",
-      clean: true,
-      dependencyTypes: ["dependencies"],
-      yes: false
-    },
-    changelog: {
-      rootChangelog: true,
-      includeCommitBody: true
-    },
-    publish: {
-      private: false,
-      args: [],
-      safetyCheck: false
-    },
-    tokens: {
-      gitlab: process$1.env.RELIZY_GITLAB_TOKEN || process$1.env.GITLAB_TOKEN || process$1.env.GITLAB_API_TOKEN || process$1.env.CI_JOB_TOKEN,
-      github: process$1.env.RELIZY_GITHUB_TOKEN || process$1.env.GITHUB_TOKEN || process$1.env.GH_TOKEN
-    },
-    scopeMap: {},
-    release: {
-      commit: true,
-      publish: true,
-      changelog: true,
-      push: true,
-      clean: true,
-      providerRelease: true,
-      noVerify: false,
-      gitTag: true
-    },
-    logLevel: "default",
-    safetyCheck: true
-  };
-}
-function setupLogger(logLevel) {
-  if (logLevel) {
-    logger.setLevel(logLevel);
-    logger.debug(`Log level set to: ${logLevel}`);
-  }
-}
-async function resolveConfig(config, cwd) {
-  if (!config.repo) {
-    const resolvedRepoConfig = await resolveRepoConfig(cwd);
-    config.repo = {
-      ...resolvedRepoConfig,
-      provider: resolvedRepoConfig.provider
-    };
+  const isValidVersion = semver.gt(newVersion, currentVersion);
+  if (!isValidVersion) {
+    throw new Error(`Unable to bump "${name}" version "${currentVersion}" to "${newVersion}", new version is not greater than current version`);
   }
-  if (typeof config.repo === "string") {
-    const resolvedRepoConfig = getRepoConfig(config.repo);
-    config.repo = {
-      ...resolvedRepoConfig,
-      provider: resolvedRepoConfig.provider
-    };
+  if (isGraduating(currentVersion, releaseType)) {
+    logger.info(`Graduating "${name}" from prerelease ${currentVersion} to stable ${newVersion}`);
   }
-  return config;
-}
-async function loadRelizyConfig(options) {
-  const cwd = options?.overrides?.cwd ?? process$1.cwd();
-  await setupDotenv({ cwd });
-  const configFile = options?.configFile ?? "relizy";
-  const defaultConfig = getDefaultConfig();
-  const overridesConfig = defu(options?.overrides, options?.baseConfig);
-  const results = await loadConfig({
-    dotenv: true,
-    cwd,
-    name: configFile,
-    packageJson: true,
-    defaults: defaultConfig,
-    overrides: overridesConfig
-  });
-  if (typeof results._configFile !== "string") {
-    logger.debug(`No config file found with name "${configFile}"`);
-    if (options?.configFile) {
-      logger.error(`No config file found with name "${configFile}"`);
-      process$1.exit(1);
-    }
+  if (isChangedPreid(currentVersion, preid)) {
+    logger.debug(`Graduating "${name}" from ${getPreid(currentVersion)} to ${preid}`);
   }
-  setupLogger(options?.overrides?.logLevel || results.config.logLevel);
-  logger.verbose("User config:", formatJson(results.config.changelog));
-  const resolvedConfig = await resolveConfig(results.config, cwd);
-  logger.debug("Resolved config:", formatJson(resolvedConfig));
-  return resolvedConfig;
-}
-function defineConfig(config) {
-  return config;
+  return newVersion;
 }
-
-async function githubIndependentMode({
-  config,
-  dryRun,
-  bumpResult,
-  force,
-  suffix
+function updateLernaVersion({
+  rootDir,
+  versionMode,
+  version,
+  dryRun = false
 }) {
-  const repoConfig = config.repo;
-  if (!repoConfig) {
-    throw new Error("No repository configuration found. Please check your changelog config.");
+  const lernaJsonExists = hasLernaJson(rootDir);
+  if (!lernaJsonExists) {
+    return;
   }
-  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  if (!config.tokens.github && !config.repo?.token) {
-    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+  const lernaJsonPath = join(rootDir, "lerna.json");
+  if (!existsSync(lernaJsonPath)) {
+    return;
   }
-  const packages = await getPackagesOrBumpedPackages({
-    config,
-    bumpResult,
-    suffix,
-    force
-  });
-  logger.info(`Creating ${packages.length} GitHub release(s)`);
-  const postedReleases = [];
-  for (const pkg of packages) {
-    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
-    const from = config.from || pkg.fromTag;
-    const to = config.to || getIndependentTag({ version: newVersion, name: pkg.name });
-    if (!from) {
-      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
-      continue;
+  try {
+    logger.debug("Updating lerna.json version");
+    const content = readFileSync(lernaJsonPath, "utf8");
+    const lernaJson = JSON.parse(content);
+    const oldVersion = lernaJson.version;
+    if (lernaJson.version === "independent" || versionMode === "independent") {
+      logger.debug("Lerna version is independent or version mode is independent, skipping update");
+      return;
     }
-    const toTag = dryRun ? "HEAD" : to;
-    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${toTag}`);
-    const changelog = await generateChangelog({
-      pkg,
-      config,
-      dryRun,
-      newVersion
-    });
-    const releaseBody = changelog.split("\n").slice(2).join("\n");
-    const release = {
-      tag_name: to,
-      name: to,
-      body: releaseBody,
-      prerelease: isPrerelease(newVersion)
-    };
-    logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
+    lernaJson.version = version;
     if (dryRun) {
-      logger.info(`[dry-run] Publish GitHub release for ${to}`);
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: release.prerelease
-      });
-    } else {
-      logger.debug(`Publishing release ${to} to GitHub...`);
-      await createGithubRelease({
-        ...config,
-        from,
-        to,
-        repo: repoConfig
-      }, release);
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: release.prerelease
-      });
+      logger.info(`[dry-run] update lerna.json: ${oldVersion} \u2192 ${version}`);
+      return;
     }
+    writeFileSync(lernaJsonPath, `${formatJson(lernaJson)}
+`, "utf8");
+    logger.success(`Updated lerna.json: ${oldVersion} \u2192 ${version}`);
+  } catch (error) {
+    logger.fail(`Unable to update lerna.json: ${error}`);
   }
-  if (postedReleases.length === 0) {
-    logger.warn("No releases created");
-  } else {
-    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitHub!`);
+}
+function extractVersionFromPackageTag(tag) {
+  const atIndex = tag.lastIndexOf("@");
+  if (atIndex === -1) {
+    return null;
   }
-  return postedReleases;
+  return tag.slice(atIndex + 1);
 }
-async function githubUnified({
-  config,
-  dryRun,
-  rootPackage,
-  bumpResult
-}) {
-  const repoConfig = config.repo;
-  if (!repoConfig) {
-    throw new Error("No repository configuration found. Please check your changelog config.");
+function isPrerelease(version) {
+  if (!version)
+    return false;
+  const prerelease = semver.prerelease(version);
+  return prerelease ? prerelease.length > 0 : false;
+}
+function isStableReleaseType(releaseType) {
+  const stableTypes = ["release", "major", "minor", "patch"];
+  return stableTypes.includes(releaseType);
+}
+function isPrereleaseReleaseType(releaseType) {
+  const prereleaseTypes = ["prerelease", "premajor", "preminor", "prepatch"];
+  return prereleaseTypes.includes(releaseType);
+}
+function isGraduating(currentVersion, releaseType) {
+  return isPrerelease(currentVersion) && isStableReleaseType(releaseType);
+}
+function getPreid(version) {
+  if (!version)
+    return null;
+  const prerelease = semver.prerelease(version);
+  if (!prerelease || prerelease.length === 0) {
+    return null;
   }
-  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  if (!config.tokens.github && !config.repo?.token) {
-    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+  return prerelease[0];
+}
+function isChangedPreid(currentVersion, targetPreid) {
+  if (!targetPreid || !isPrerelease(currentVersion)) {
+    return false;
   }
-  const newVersion = bumpResult?.newVersion || rootPackage.version;
-  const to = config.to || config.templates.tagBody.replace("{{newVersion}}", newVersion);
-  const changelog = await generateChangelog({
-    pkg: rootPackage,
-    config,
-    dryRun,
-    newVersion
+  const currentPreid = getPreid(currentVersion);
+  if (!currentPreid) {
+    return false;
+  }
+  return currentPreid !== targetPreid;
+}
+function getBumpedPackageIndependently({
+  pkg,
+  dryRun
+}) {
+  logger.debug(`Analyzing ${pkg.name}`);
+  const currentVersion = pkg.version || "0.0.0";
+  const newVersion = pkg.newVersion;
+  if (!newVersion) {
+    return { bumped: false };
+  }
+  logger.debug(`Bumping ${pkg.name} from ${currentVersion} to ${newVersion}`);
+  writeVersion(pkg.path, newVersion, dryRun);
+  return { bumped: true, newVersion, oldVersion: currentVersion };
+}
+function displayRootAndLernaUpdates({
+  versionMode,
+  currentVersion,
+  newVersion,
+  dryRun,
+  lernaJsonExists
+}) {
+  if (versionMode !== "independent" && currentVersion && newVersion) {
+    logger.log(`${dryRun ? "[dry-run] " : ""}Root package.json: ${currentVersion} \u2192 ${newVersion}`);
+    logger.log("");
+    if (lernaJsonExists) {
+      logger.log(`${dryRun ? "[dry-run] " : ""}lerna.json: ${currentVersion} \u2192 ${newVersion}`);
+      logger.log("");
+    }
+  }
+}
+function displayUnifiedModePackages({
+  packages,
+  newVersion,
+  force
+}) {
+  logger.log(`${packages.length} package(s):`);
+  packages.forEach((pkg) => {
+    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
   });
-  const releaseBody = changelog.split("\n").slice(2).join("\n");
-  const release = {
-    tag_name: to,
-    name: to,
-    body: releaseBody,
-    prerelease: isPrerelease(to)
-  };
-  logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
-  logger.debug("Release details:", formatJson({
-    tag_name: release.tag_name,
-    name: release.name,
-    prerelease: release.prerelease
-  }));
-  if (dryRun) {
-    logger.info("[dry-run] Publish GitHub release for", release.tag_name);
+  logger.log("");
+}
+function displaySelectiveModePackages({
+  packages,
+  newVersion,
+  force
+}) {
+  if (force) {
+    logger.log(`${packages.length} package(s):`);
+    packages.forEach((pkg) => {
+      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (force)`);
+    });
+    logger.log("");
   } else {
-    logger.debug("Publishing release to GitHub...");
-    await createGithubRelease({
-      ...config,
-      from: bumpResult?.bumped && bumpResult.fromTag || "v0.0.0",
-      to,
-      repo: repoConfig
-    }, release);
+    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
+    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
+    const packagesAsGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation");
+    if (packagesWithCommits.length > 0) {
+      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
+      packagesWithCommits.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsDependents.length > 0) {
+      logger.log(`${packagesAsDependents.length} dependent package(s):`);
+      packagesAsDependents.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsGraduation.length > 0) {
+      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
+      packagesAsGraduation.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
   }
-  logger.success(`Release ${to} published to GitHub!`);
-  return [{
-    name: to,
-    tag: to,
-    version: to,
-    prerelease: release.prerelease
-  }];
 }
-async function github(options) {
-  try {
-    const dryRun = options.dryRun ?? false;
-    logger.debug(`Dry run: ${dryRun}`);
-    const config = await loadRelizyConfig({
-      configFile: options.configName,
-      baseConfig: options.config,
-      overrides: {
-        from: options.from,
-        to: options.to,
-        logLevel: options.logLevel,
-        tokens: {
-          github: options.token
-        }
-      }
+function displayIndependentModePackages({
+  packages,
+  force
+}) {
+  if (force) {
+    logger.log(`${packages.length} package(s):`);
+    packages.forEach((pkg) => {
+      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (force)`);
     });
-    if (config.monorepo?.versionMode === "independent") {
-      return await githubIndependentMode({
-        config,
-        dryRun,
-        bumpResult: options.bumpResult,
-        force: options.force ?? false,
-        suffix: options.suffix
+    logger.log("");
+  } else {
+    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
+    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
+    const packagesAsGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation");
+    if (packagesWithCommits.length > 0) {
+      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
+      packagesWithCommits.forEach((pkg) => {
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
       });
+      logger.log("");
     }
-    const rootPackageBase = readPackageJson(config.cwd);
-    if (!rootPackageBase) {
-      throw new Error("Failed to read root package.json");
+    if (packagesAsDependents.length > 0) {
+      logger.log(`${packagesAsDependents.length} dependent package(s):`);
+      packagesAsDependents.forEach((pkg) => {
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsGraduation.length > 0) {
+      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
+      packagesAsGraduation.forEach((pkg) => {
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
+      });
+      logger.log("");
     }
-    const newVersion = options.bumpResult?.newVersion || rootPackageBase.version;
-    const { from, to } = await resolveTags({
-      config,
-      step: "provider-release",
-      newVersion,
-      pkg: rootPackageBase
-    });
-    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
-      config,
-      force: options.force ?? false,
-      suffix: options.suffix,
-      changelog: true,
-      from,
-      to
-    });
-    return await githubUnified({
-      config,
-      dryRun,
-      rootPackage,
-      bumpResult: options.bumpResult
-    });
-  } catch (error) {
-    logger.error("Error publishing GitHub release:", error);
-    throw error;
   }
 }
-
-async function createGitlabRelease({
+async function confirmBump({
+  versionMode,
   config,
-  release,
+  packages,
+  force,
+  currentVersion,
+  newVersion,
   dryRun
 }) {
-  const token = config.tokens.gitlab || config.repo?.token;
-  if (!token && !dryRun) {
-    throw new Error(
-      "No GitLab token found. Set GITLAB_TOKEN or CI_JOB_TOKEN environment variable or configure tokens.gitlab"
-    );
+  if (packages.length === 0) {
+    logger.debug("No packages to bump");
+    return;
   }
-  const repoConfig = config.repo?.repo;
-  if (!repoConfig) {
-    throw new Error("No repository URL found in config");
+  const lernaJsonExists = hasLernaJson(config.cwd);
+  logger.log("");
+  logger.info(`${dryRun ? "[dry-run] " : ""}The following packages will be updated:
+`);
+  displayRootAndLernaUpdates({
+    versionMode,
+    currentVersion,
+    newVersion,
+    lernaJsonExists,
+    dryRun
+  });
+  if (versionMode === "unified") {
+    if (!newVersion) {
+      throw new Error("Cannot confirm bump in unified mode without a new version");
+    }
+    displayUnifiedModePackages({ packages, newVersion, force });
+  } else if (versionMode === "selective") {
+    if (!newVersion) {
+      throw new Error("Cannot confirm bump in selective mode without a new version");
+    }
+    displaySelectiveModePackages({ packages, newVersion, force });
+  } else if (versionMode === "independent") {
+    displayIndependentModePackages({ packages, force });
   }
-  logger.debug(`Parsed repository URL: ${repoConfig}`);
-  const projectPath = encodeURIComponent(repoConfig);
-  const gitlabDomain = config.repo?.domain || "gitlab.com";
-  const apiUrl = `https://${gitlabDomain}/api/v4/projects/${projectPath}/releases`;
-  logger.info(`Creating GitLab release at: ${apiUrl}`);
-  const payload = {
-    tag_name: release.tag_name,
-    name: release.name || release.tag_name,
-    description: release.description || "",
-    ref: release.ref || "main"
-  };
   try {
-    if (dryRun) {
-      logger.info("[dry-run] GitLab release:", formatJson(payload));
-      return {
-        tag_name: release.tag_name,
-        name: release.name || release.tag_name,
-        description: release.description || "",
-        created_at: (/* @__PURE__ */ new Date()).toISOString(),
-        released_at: (/* @__PURE__ */ new Date()).toISOString(),
-        _links: {
-          self: `${apiUrl}/${encodeURIComponent(release.tag_name)}`
-        }
-      };
-    }
-    logger.debug(`POST GitLab release to ${apiUrl} with payload: ${formatJson(payload)}`);
-    const response = await fetch(apiUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "PRIVATE-TOKEN": token || ""
-      },
-      body: JSON.stringify(payload)
+    const confirmed = await confirm({
+      message: `${dryRun ? "[dry-run] " : ""}Do you want to proceed with these version updates?`,
+      default: true
     });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`GitLab API error (${response.status}): ${errorText}`);
+    if (!confirmed) {
+      logger.log("");
+      logger.fail("Bump refused");
+      process.exit(0);
     }
-    const result = await response.json();
-    logger.debug(`Created GitLab release: ${result._links.self}`);
-    return result;
   } catch (error) {
-    logger.error("Failed to create GitLab release:", error);
-    throw error;
+    const userHasExited = error instanceof Error && error.name === "ExitPromptError";
+    if (userHasExited) {
+      logger.log("");
+      logger.fail("Bump cancelled");
+      process.exit(0);
+    }
+    logger.fail("Error while confirming bump");
+    process.exit(1);
   }
+  logger.log("");
 }
-async function gitlabIndependentMode({
-  config,
-  dryRun,
-  bumpResult,
-  suffix,
-  force
+function getBumpedIndependentPackages({
+  packages,
+  dryRun
 }) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const packages = await getPackagesOrBumpedPackages({
-    config,
-    bumpResult,
-    suffix,
-    force
-  });
-  logger.info(`Creating ${packages.length} GitLab release(s) for independent packages`);
-  logger.debug("Getting current branch...");
-  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
-    noSuccess: true,
-    noStdout: true,
-    logLevel: config.logLevel,
-    cwd: config.cwd
-  });
-  const postedReleases = [];
-  for (const pkg of packages) {
-    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
-    const from = config.from || pkg.fromTag;
-    const to = getIndependentTag({ version: newVersion, name: pkg.name });
-    if (!from) {
-      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
-      continue;
-    }
-    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${to}`);
-    const changelog = await generateChangelog({
-      pkg,
-      config,
-      dryRun,
-      newVersion
+  const bumpedPackages = [];
+  for (const pkgToBump of packages) {
+    logger.debug(`Bumping ${pkgToBump.name} from ${pkgToBump.version} to ${pkgToBump.newVersion} (reason: ${pkgToBump.reason})`);
+    const result = getBumpedPackageIndependently({
+      pkg: pkgToBump,
+      dryRun
     });
-    if (!changelog) {
-      logger.warn(`No changelog found for ${pkg.name}`);
-      continue;
-    }
-    const releaseBody = changelog.split("\n").slice(2).join("\n");
-    const release = {
-      tag_name: to,
-      name: to,
-      description: releaseBody,
-      ref: currentBranch.trim()
-    };
-    logger.debug(`Creating release for ${to} (ref: ${release.ref})`);
-    if (dryRun) {
-      logger.info(`[dry-run] Publish GitLab release for ${to}`);
-    } else {
-      logger.debug(`Publishing release ${to} to GitLab...`);
-      await createGitlabRelease({
-        config,
-        release,
-        dryRun
-      });
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: isPrerelease(newVersion)
+    if (result.bumped) {
+      bumpedPackages.push({
+        ...pkgToBump,
+        version: result.oldVersion
       });
     }
   }
-  if (postedReleases.length === 0) {
-    logger.warn("No releases created");
-  } else {
-    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitLab!`);
+  return bumpedPackages;
+}
+function shouldFilterPrereleaseTags(currentVersion, graduating) {
+  return !isPrerelease(currentVersion) && !graduating;
+}
+function extractVersionFromTag(tag, packageName) {
+  if (!tag) {
+    return null;
   }
-  return postedReleases;
+  if (packageName) {
+    const prefix = `${packageName}@`;
+    if (tag.startsWith(prefix)) {
+      return tag.slice(prefix.length);
+    }
+  }
+  const atIndex = tag.lastIndexOf("@");
+  if (atIndex !== -1) {
+    return tag.slice(atIndex + 1);
+  }
+  if (tag.startsWith("v") && /^v\d/.test(tag)) {
+    return tag.slice(1);
+  }
+  if (/^\d+\.\d+\.\d+/.test(tag)) {
+    return tag;
+  }
+  return null;
 }
-async function gitlabUnified({
-  config,
-  dryRun,
-  rootPackage,
-  bumpResult
-}) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const newVersion = bumpResult?.newVersion || rootPackage.newVersion || rootPackage.version;
-  const to = config.templates.tagBody.replace("{{newVersion}}", newVersion);
-  const changelog = await generateChangelog({
-    pkg: rootPackage,
-    config,
-    dryRun,
-    newVersion
-  });
-  const releaseBody = changelog.split("\n").slice(2).join("\n");
-  logger.debug("Getting current branch...");
-  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
-    noSuccess: true,
+function isTagVersionCompatibleWithCurrent(tagVersion, currentVersion) {
+  try {
+    const tagMajor = semver.major(tagVersion);
+    const currentMajor = semver.major(currentVersion);
+    return tagMajor <= currentMajor;
+  } catch {
+    return false;
+  }
+}
+
+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,
+    noStderr: true,
     noStdout: true,
-    logLevel: config.logLevel,
-    cwd: config.cwd
+    noSuccess: true,
+    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(newVersion)
-  }];
+  const lastTag = stdout.trim();
+  logger.debug("Last tag:", lastTag || "No tags found");
+  return lastTag;
 }
-async function gitlab(options = {}) {
+async function getAllRecentRepoTags(options) {
+  const limit = options?.limit;
   try {
-    const dryRun = options.dryRun ?? false;
-    logger.debug(`Dry run: ${dryRun}`);
-    const config = await loadRelizyConfig({
-      configFile: options.configName,
-      baseConfig: options.config,
-      overrides: {
-        from: options.from,
-        to: options.to,
-        logLevel: options.logLevel,
-        tokens: {
-          gitlab: options.token
-        }
-      }
-    });
-    if (config.monorepo?.versionMode === "independent") {
-      return await gitlabIndependentMode({
-        config,
-        dryRun,
-        bumpResult: options.bumpResult,
-        suffix: options.suffix,
-        force: options.force ?? false
-      });
-    }
-    const rootPackageBase = readPackageJson(config.cwd);
-    if (!rootPackageBase) {
-      throw new Error("Failed to read root package.json");
-    }
-    const newVersion = options.bumpResult?.newVersion || rootPackageBase.version;
-    const { from, to } = await resolveTags({
-      config,
-      step: "provider-release",
-      newVersion,
-      pkg: rootPackageBase
-    });
-    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
-      config,
-      force: options.force ?? false,
-      suffix: options.suffix,
-      changelog: true,
-      from,
-      to
-    });
-    logger.debug(`Root package: ${getIndependentTag({ name: rootPackage.name, version: newVersion })}`);
-    return await gitlabUnified({
-      config,
-      dryRun,
-      rootPackage,
-      bumpResult: options.bumpResult
-    });
-  } catch (error) {
-    logger.error("Error publishing GitLab release:", error);
-    throw error;
+    const { stdout } = await execPromise(
+      `git tag --sort=-creatordate | head -n ${limit}`,
+      {
+        logLevel: options?.logLevel,
+        noStderr: true,
+        noStdout: true,
+        noSuccess: true,
+        cwd: options?.cwd
+      }
+    );
+    const tags = stdout.trim().split("\n").filter((tag) => tag.length > 0);
+    logger.debug(`Retrieved ${tags.length} recent repo tags`);
+    return tags;
+  } catch {
+    return [];
   }
 }
-
-function isGraduatingToStableBetweenVersion(version, newVersion) {
-  const isSameBase = semver.major(version) === semver.major(newVersion) && semver.minor(version) === semver.minor(newVersion) && semver.patch(version) === semver.patch(newVersion);
-  const fromPrerelease = semver.prerelease(version) !== null;
-  const toStable = semver.prerelease(newVersion) === null;
-  return isSameBase && fromPrerelease && toStable;
+async function getAllRecentPackageTags({
+  packageName,
+  limit = 50,
+  logLevel,
+  cwd
+}) {
+  try {
+    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
+    const { stdout } = await execPromise(
+      `git tag --sort=-creatordate | grep -E '^${escapedPackageName}@' | head -n ${limit}`,
+      {
+        logLevel,
+        noStderr: true,
+        noStdout: true,
+        noSuccess: true,
+        cwd
+      }
+    );
+    const tags = stdout.trim().split("\n").filter((tag) => tag.length > 0);
+    logger.debug(`Retrieved ${tags.length} recent tags for package ${packageName}`);
+    return tags;
+  } catch {
+    return [];
+  }
 }
-function determineSemverChange(commits, types) {
-  let [hasMajor, hasMinor, hasPatch] = [false, false, false];
-  for (const commit of commits) {
-    const commitType = types[commit.type];
-    if (!commitType) {
-      continue;
+function filterCompatibleTags({
+  tags,
+  currentVersion,
+  onlyStable,
+  packageName
+}) {
+  const filtered = tags.filter((tag) => {
+    const tagVersion = extractVersionFromTag(tag, packageName);
+    if (!tagVersion) {
+      logger.debug(`Skipping tag ${tag}: cannot extract version`);
+      return false;
     }
-    const semverType = commitType.semver;
-    if (semverType === "major" || commit.isBreaking) {
-      hasMajor = true;
-    } else if (semverType === "minor") {
-      hasMinor = true;
-    } else if (semverType === "patch") {
-      hasPatch = true;
+    if (onlyStable && isPrerelease(tagVersion)) {
+      logger.debug(`Skipping tag ${tag}: prerelease version ${tagVersion} (onlyStable=${onlyStable})`);
+      return false;
     }
-  }
-  return hasMajor ? "major" : hasMinor ? "minor" : hasPatch ? "patch" : void 0;
-}
-function detectReleaseTypeFromCommits(commits, types) {
-  return determineSemverChange(commits, types);
+    if (!isTagVersionCompatibleWithCurrent(tagVersion, currentVersion)) {
+      logger.debug(`Skipping tag ${tag}: version ${tagVersion} has higher major than current ${currentVersion}`);
+      return false;
+    }
+    logger.debug(`Tag ${tag} with version ${tagVersion} is compatible`);
+    return true;
+  });
+  logger.debug(`Filtered ${tags.length} tags down to ${filtered.length} compatible tags`);
+  return filtered;
 }
-function validatePrereleaseDowngrade(currentVersion, targetPreid, configuredType) {
-  if (configuredType !== "prerelease" || !targetPreid || !isPrerelease(currentVersion)) {
-    return;
+function getLastRepoTag(options) {
+  if (options?.currentVersion) {
+    return getLastRepoTagWithFiltering({
+      currentVersion: options.currentVersion,
+      onlyStable: options.onlyStable ?? false,
+      logLevel: options.logLevel,
+      cwd: options.cwd
+    });
   }
-  const testVersion = semver.inc(currentVersion, "prerelease", targetPreid);
-  const isNotUpgrade = testVersion && !semver.gt(testVersion, currentVersion);
-  if (isNotUpgrade) {
-    throw new Error(`Unable to graduate from ${currentVersion} to ${testVersion}, it's not a valid prerelease`);
+  if (options?.onlyStable) {
+    return getLastStableTag({ logLevel: options?.logLevel, cwd: options?.cwd });
   }
+  return getLastTag({ logLevel: options?.logLevel, cwd: options?.cwd });
 }
-function handleStableVersionWithReleaseType(commits, types, force) {
-  if (!commits?.length && !force) {
-    logger.debug('No commits found for stable version with "release" type, skipping bump');
-    return void 0;
+async function getLastRepoTagWithFiltering({
+  currentVersion,
+  onlyStable,
+  logLevel,
+  cwd
+}) {
+  const recentTags = await getAllRecentRepoTags({ limit: 50, logLevel, cwd });
+  if (recentTags.length === 0) {
+    logger.debug("No tags found in repository");
+    return null;
   }
-  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
-  if (!detectedType && !force) {
-    logger.debug("No significant commits found, skipping bump");
-    return void 0;
+  const compatibleTags = filterCompatibleTags({
+    tags: recentTags,
+    currentVersion,
+    onlyStable
+  });
+  if (compatibleTags.length === 0) {
+    logger.debug("No compatible tags found");
+    return null;
   }
-  logger.debug(`Auto-detected release type from commits: ${detectedType}`);
-  return detectedType;
+  const lastTag = compatibleTags[0];
+  logger.debug(`Last compatible repo tag: ${lastTag}`);
+  return lastTag;
 }
-function handleStableVersionWithPrereleaseType(commits, types, force) {
-  if (!commits?.length && !force) {
-    logger.debug('No commits found for stable version with "prerelease" type, skipping bump');
-    return void 0;
-  }
-  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
-  if (!detectedType) {
-    logger.debug("No significant commits found, using prepatch as default");
-    return "prepatch";
+async function getLastPackageTag({
+  packageName,
+  onlyStable,
+  currentVersion,
+  logLevel,
+  cwd
+}) {
+  if (currentVersion) {
+    return getLastPackageTagWithFiltering({
+      packageName,
+      currentVersion,
+      onlyStable: onlyStable ?? false,
+      logLevel,
+      cwd
+    });
   }
-  const prereleaseType = `pre${detectedType}`;
-  logger.debug(`Auto-detected prerelease type from commits: ${prereleaseType}`);
-  return prereleaseType;
-}
-function handlePrereleaseVersionToStable(currentVersion) {
-  logger.debug(`Graduating from prerelease ${currentVersion} to stable release`);
-  return "release";
-}
-function handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force }) {
-  const currentPreid = getPreid(currentVersion);
-  const hasChangedPreid = preid && currentPreid && currentPreid !== preid;
-  if (hasChangedPreid) {
-    const testVersion = semver.inc(currentVersion, "prerelease", preid);
-    if (!testVersion) {
-      throw new Error(`Unable to change preid from ${currentPreid} to ${preid} for version ${currentVersion}`);
-    }
-    const isUpgrade = semver.gt(testVersion, currentVersion);
-    if (!isUpgrade) {
-      throw new Error(`Unable to change preid from ${currentVersion} to ${testVersion}, it's not a valid upgrade (cannot downgrade from ${currentPreid} to ${preid})`);
+  try {
+    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
+    let grepPattern;
+    if (onlyStable) {
+      grepPattern = `^${escapedPackageName}@[0-9]+\\.[0-9]+\\.[0-9]+$`;
+    } else {
+      grepPattern = `^${escapedPackageName}@`;
     }
-    return "prerelease";
-  }
-  if (!commits?.length && !force) {
-    logger.debug("No commits found for prerelease version, skipping bump");
-    return void 0;
+    const { stdout } = await execPromise(
+      `git tag --sort=-creatordate | grep -E '${grepPattern}' | sed -n '1p'`,
+      {
+        logLevel,
+        noStderr: true,
+        noStdout: true,
+        noSuccess: true,
+        cwd
+      }
+    );
+    const tag = stdout.trim();
+    return tag || null;
+  } catch {
+    return null;
   }
-  logger.debug(`Incrementing prerelease version: ${currentVersion}`);
-  return "prerelease";
 }
-function handleExplicitReleaseType({
-  releaseType,
-  currentVersion
+async function getLastPackageTagWithFiltering({
+  packageName,
+  currentVersion,
+  onlyStable,
+  logLevel,
+  cwd
 }) {
-  const isCurrentPrerelease = isPrerelease(currentVersion);
-  const isGraduatingToStable = isCurrentPrerelease && isStableReleaseType(releaseType);
-  if (isGraduatingToStable) {
-    logger.debug(`Graduating from prerelease ${currentVersion} to stable with type: ${releaseType}`);
-  } else {
-    logger.debug(`Using explicit release type: ${releaseType}`);
+  const recentTags = await getAllRecentPackageTags({
+    packageName,
+    limit: 50,
+    logLevel,
+    cwd
+  });
+  if (recentTags.length === 0) {
+    logger.debug(`No tags found for package ${packageName}`);
+    return null;
   }
-  return releaseType;
+  const compatibleTags = filterCompatibleTags({
+    tags: recentTags,
+    currentVersion,
+    onlyStable,
+    packageName
+  });
+  if (compatibleTags.length === 0) {
+    logger.debug(`No compatible tags found for package ${packageName}`);
+    return null;
+  }
+  const lastTag = compatibleTags[0];
+  logger.debug(`Last compatible package tag for ${packageName}: ${lastTag}`);
+  return lastTag;
 }
-function determineReleaseType({
+async function resolveFromTagIndependent({
+  cwd,
+  packageName,
   currentVersion,
-  commits,
-  releaseType,
-  preid,
-  types,
-  force
+  graduating,
+  logLevel
 }) {
-  if (releaseType === "release" && preid) {
-    throw new Error('You cannot use a "release" type with a "preid", to use a preid you must use a "prerelease" type');
-  }
-  validatePrereleaseDowngrade(currentVersion, preid, releaseType);
-  if (force) {
-    logger.debug(`Force flag enabled, using configured type: ${releaseType}`);
-    return releaseType;
-  }
-  const isCurrentPrerelease = isPrerelease(currentVersion);
-  if (!isCurrentPrerelease) {
-    if (releaseType === "release") {
-      return handleStableVersionWithReleaseType(commits, types, force);
-    }
-    if (releaseType === "prerelease") {
-      return handleStableVersionWithPrereleaseType(commits, types, force);
-    }
-    return handleExplicitReleaseType({ releaseType, currentVersion });
-  }
-  if (releaseType === "release") {
-    return handlePrereleaseVersionToStable(currentVersion);
-  }
-  if (releaseType === "prerelease") {
-    return handlePrereleaseVersionWithPrereleaseType({ currentVersion, preid, commits, force });
+  const filterPrereleases = shouldFilterPrereleaseTags(currentVersion, graduating);
+  const onlyStable = graduating || filterPrereleases;
+  const lastPackageTag = await getLastPackageTag({
+    packageName,
+    currentVersion,
+    onlyStable,
+    logLevel,
+    cwd
+  });
+  if (!lastPackageTag) {
+    return getFirstCommit(cwd);
   }
-  return handleExplicitReleaseType({ releaseType, currentVersion });
+  return lastPackageTag;
 }
-function writeVersion(pkgPath, newVersion, dryRun = false) {
-  const packageJsonPath = join(pkgPath, "package.json");
-  try {
-    logger.debug(`Writing ${newVersion} to ${pkgPath}`);
-    const content = readFileSync(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(content);
-    const oldVersion = packageJson.version;
-    packageJson.version = newVersion;
-    if (dryRun) {
-      logger.info(`[dry-run] Updated ${packageJson.name}: ${oldVersion} \u2192 ${newVersion}`);
-      return;
-    }
-    writeFileSync(packageJsonPath, `${formatJson(packageJson)}
-`, "utf8");
-    logger.info(`Updated ${packageJson.name}: ${oldVersion} \u2192 ${newVersion}`);
-  } catch (error) {
-    throw new Error(`Unable to write version to ${packageJsonPath}: ${error}`);
-  }
+async function resolveFromTagUnified({
+  config,
+  currentVersion,
+  graduating,
+  logLevel
+}) {
+  const filterPrereleases = shouldFilterPrereleaseTags(currentVersion, graduating);
+  const onlyStable = graduating || filterPrereleases;
+  const from = await getLastRepoTag({
+    currentVersion,
+    onlyStable,
+    logLevel,
+    cwd: config.cwd
+  }) || getFirstCommit(config.cwd);
+  return from;
 }
-function getPackageNewVersion({
-  name,
+async function resolveFromTag({
+  config,
+  versionMode,
+  step,
+  packageName,
   currentVersion,
-  releaseType,
-  preid,
-  suffix
+  graduating,
+  logLevel
 }) {
-  let newVersion = semver.inc(currentVersion, releaseType, preid);
-  if (!newVersion) {
-    throw new Error(`Unable to bump "${name}" 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 "${name}" version "${currentVersion}" to "${newVersion}", new version is not greater than current version`);
-  }
-  if (isGraduating(currentVersion, releaseType)) {
-    logger.info(`Graduating "${name}" from prerelease ${currentVersion} to stable ${newVersion}`);
-  }
-  if (isChangedPreid(currentVersion, preid)) {
-    logger.debug(`Graduating "${name}" from ${getPreid(currentVersion)} to ${preid}`);
+  let from;
+  if (versionMode === "independent") {
+    if (!packageName) {
+      throw new Error("Package name is required for independent version mode");
+    }
+    from = await resolveFromTagIndependent({
+      cwd: config.cwd,
+      packageName,
+      currentVersion,
+      graduating,
+      logLevel
+    });
+  } else {
+    from = await resolveFromTagUnified({
+      config,
+      currentVersion,
+      graduating,
+      logLevel
+    });
   }
-  return newVersion;
+  logger.debug(`[${versionMode}](${step}) Using from tag: ${from}`);
+  return config.from || from;
 }
-function updateLernaVersion({
-  rootDir,
+function resolveToTag({
+  config,
   versionMode,
-  version,
-  dryRun = false
+  newVersion,
+  step,
+  packageName
 }) {
-  const lernaJsonExists = hasLernaJson(rootDir);
-  if (!lernaJsonExists) {
-    return;
-  }
-  const lernaJsonPath = join(rootDir, "lerna.json");
-  if (!existsSync(lernaJsonPath)) {
-    return;
-  }
-  try {
-    logger.debug("Updating lerna.json version");
-    const content = readFileSync(lernaJsonPath, "utf8");
-    const lernaJson = JSON.parse(content);
-    const oldVersion = lernaJson.version;
-    if (lernaJson.version === "independent" || versionMode === "independent") {
-      logger.debug("Lerna version is independent or version mode is independent, skipping update");
-      return;
+  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");
     }
-    lernaJson.version = version;
-    if (dryRun) {
-      logger.info(`[dry-run] update lerna.json: ${oldVersion} \u2192 ${version}`);
-      return;
+    if (!newVersion) {
+      throw new Error("New version is required for independent version mode");
     }
-    writeFileSync(lernaJsonPath, `${formatJson(lernaJson)}
-`, "utf8");
-    logger.success(`Updated lerna.json: ${oldVersion} \u2192 ${version}`);
-  } catch (error) {
-    logger.fail(`Unable to update lerna.json: ${error}`);
-  }
-}
-function extractVersionFromPackageTag(tag) {
-  const atIndex = tag.lastIndexOf("@");
-  if (atIndex === -1) {
-    return null;
-  }
-  return tag.slice(atIndex + 1);
-}
-function isPrerelease(version) {
-  if (!version)
-    return false;
-  const prerelease = semver.prerelease(version);
-  return prerelease ? prerelease.length > 0 : false;
-}
-function isStableReleaseType(releaseType) {
-  const stableTypes = ["release", "major", "minor", "patch"];
-  return stableTypes.includes(releaseType);
-}
-function isPrereleaseReleaseType(releaseType) {
-  const prereleaseTypes = ["prerelease", "premajor", "preminor", "prepatch"];
-  return prereleaseTypes.includes(releaseType);
-}
-function isGraduating(currentVersion, releaseType) {
-  return isPrerelease(currentVersion) && isStableReleaseType(releaseType);
-}
-function getPreid(version) {
-  if (!version)
-    return null;
-  const prerelease = semver.prerelease(version);
-  if (!prerelease || prerelease.length === 0) {
-    return null;
-  }
-  return prerelease[0];
-}
-function isChangedPreid(currentVersion, targetPreid) {
-  if (!targetPreid || !isPrerelease(currentVersion)) {
-    return false;
-  }
-  const currentPreid = getPreid(currentVersion);
-  if (!currentPreid) {
-    return false;
+    to = getIndependentTag({ version: newVersion, name: packageName });
+  } else {
+    to = newVersion ? config.templates.tagBody.replace("{{newVersion}}", newVersion) : getCurrentGitRef(config.cwd);
   }
-  return currentPreid !== targetPreid;
+  logger.debug(`[${versionMode}](${step}) Using to tag: ${to}`);
+  return config.to || to;
 }
-function getBumpedPackageIndependently({
+async function resolveTags({
+  config,
+  step,
   pkg,
-  dryRun
+  newVersion
 }) {
-  logger.debug(`Analyzing ${pkg.name}`);
-  const currentVersion = pkg.version || "0.0.0";
-  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 };
-}
-function displayRootAndLernaUpdates({
-  versionMode,
-  currentVersion,
-  newVersion,
-  dryRun,
-  lernaJsonExists
-}) {
-  if (versionMode !== "independent" && currentVersion && newVersion) {
-    logger.log(`${dryRun ? "[dry-run] " : ""}Root package.json: ${currentVersion} \u2192 ${newVersion}`);
-    logger.log("");
-    if (lernaJsonExists) {
-      logger.log(`${dryRun ? "[dry-run] " : ""}lerna.json: ${currentVersion} \u2192 ${newVersion}`);
-      logger.log("");
-    }
-  }
-}
-function displayUnifiedModePackages({
-  packages,
-  newVersion,
-  force
-}) {
-  logger.log(`${packages.length} package(s):`);
-  packages.forEach((pkg) => {
-    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
+  const versionMode = config.monorepo?.versionMode || "standalone";
+  const logLevel = config.logLevel;
+  logger.debug(`[${versionMode}](${step}) Resolving tags`);
+  const releaseType = config.bump.type;
+  const graduating = typeof newVersion === "string" ? isGraduatingToStableBetweenVersion(pkg.version, newVersion) : isGraduating(pkg.version, releaseType);
+  const from = await resolveFromTag({
+    config,
+    versionMode,
+    step,
+    packageName: pkg.name,
+    currentVersion: pkg.version,
+    graduating,
+    logLevel
   });
-  logger.log("");
-}
-function displaySelectiveModePackages({
-  packages,
-  newVersion,
-  force
-}) {
-  if (force) {
-    logger.log(`${packages.length} package(s):`);
-    packages.forEach((pkg) => {
-      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (force)`);
-    });
-    logger.log("");
-  } else {
-    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
-    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
-    const packagesAsGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation");
-    if (packagesWithCommits.length > 0) {
-      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
-      packagesWithCommits.forEach((pkg) => {
-        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-    if (packagesAsDependents.length > 0) {
-      logger.log(`${packagesAsDependents.length} dependent package(s):`);
-      packagesAsDependents.forEach((pkg) => {
-        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-    if (packagesAsGraduation.length > 0) {
-      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
-      packagesAsGraduation.forEach((pkg) => {
-        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-  }
+  const to = resolveToTag({
+    config,
+    versionMode,
+    newVersion,
+    step,
+    packageName: pkg.name
+  });
+  logger.debug(`[${versionMode}](${step}) Using tags: ${from} \u2192 ${to}`);
+  return { from, to };
 }
-function displayIndependentModePackages({
-  packages,
-  force
-}) {
-  if (force) {
-    logger.log(`${packages.length} package(s):`);
-    packages.forEach((pkg) => {
-      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (force)`);
-    });
-    logger.log("");
-  } else {
-    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
-    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
-    const packagesAsGraduation = packages.filter((p) => "reason" in p && p.reason === "graduation");
-    if (packagesWithCommits.length > 0) {
-      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
-      packagesWithCommits.forEach((pkg) => {
-        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-    if (packagesAsDependents.length > 0) {
-      logger.log(`${packagesAsDependents.length} dependent package(s):`);
-      packagesAsDependents.forEach((pkg) => {
-        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-    if (packagesAsGraduation.length > 0) {
-      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
-      packagesAsGraduation.forEach((pkg) => {
-        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
-      });
-      logger.log("");
-    }
-  }
+
+function fromTagIsFirstCommit(fromTag, cwd) {
+  return fromTag === getFirstCommit(cwd);
 }
-async function confirmBump({
-  versionMode,
+async function generateChangelog({
+  pkg,
   config,
-  packages,
-  force,
-  currentVersion,
+  dryRun,
   newVersion,
-  dryRun
+  minify
 }) {
-  if (packages.length === 0) {
-    logger.debug("No packages to bump");
-    return;
+  let fromTag = config.from || pkg.fromTag || getFirstCommit(config.cwd);
+  const isFirstCommit = fromTagIsFirstCommit(fromTag, config.cwd);
+  if (isFirstCommit) {
+    fromTag = config.monorepo?.versionMode === "independent" ? getIndependentTag({ version: "0.0.0", name: pkg.name }) : config.templates.tagBody.replace("{{newVersion}}", "0.0.0");
   }
-  const lernaJsonExists = hasLernaJson(config.cwd);
-  logger.log("");
-  logger.info(`${dryRun ? "[dry-run] " : ""}The following packages will be updated:
-`);
-  displayRootAndLernaUpdates({
-    versionMode,
-    currentVersion,
-    newVersion,
-    lernaJsonExists,
-    dryRun
-  });
-  if (versionMode === "unified") {
-    if (!newVersion) {
-      throw new Error("Cannot confirm bump in unified mode without a new version");
-    }
-    displayUnifiedModePackages({ packages, newVersion, force });
-  } else if (versionMode === "selective") {
-    if (!newVersion) {
-      throw new Error("Cannot confirm bump in selective mode without a new version");
-    }
-    displaySelectiveModePackages({ packages, newVersion, force });
-  } else if (versionMode === "independent") {
-    displayIndependentModePackages({ packages, force });
+  let toTag = config.to;
+  if (!toTag) {
+    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}`);
   }
+  logger.debug(`Generating changelog for ${pkg.name} - from ${fromTag} to ${toTag}`);
   try {
-    const confirmed = await confirm({
-      message: `${dryRun ? "[dry-run] " : ""}Do you want to proceed with these version updates?`,
-      default: true
+    config = {
+      ...config,
+      from: fromTag,
+      to: toTag
+    };
+    const generatedChangelog = await generateMarkDown({
+      commits: pkg.commits,
+      config,
+      from: fromTag,
+      isFirstCommit,
+      to: toTag,
+      minify
     });
-    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);
+    let changelog = generatedChangelog;
+    if (pkg.commits.length === 0) {
+      changelog = `${changelog}
+
+${config.templates.emptyChangelogContent}`;
     }
-    logger.fail("Error while confirming bump");
-    process.exit(1);
-  }
-  logger.log("");
-}
-function getBumpedIndependentPackages({
-  packages,
-  dryRun
-}) {
-  const bumpedPackages = [];
-  for (const pkgToBump of packages) {
-    logger.debug(`Bumping ${pkgToBump.name} from ${pkgToBump.version} to ${pkgToBump.newVersion} (reason: ${pkgToBump.reason})`);
-    const result = getBumpedPackageIndependently({
-      pkg: pkgToBump,
-      dryRun
+    const changelogResult = await executeHook("generate:changelog", config, dryRun, {
+      commits: pkg.commits,
+      changelog
     });
-    if (result.bumped) {
-      bumpedPackages.push({
-        ...pkgToBump,
-        version: result.oldVersion
-      });
+    changelog = changelogResult || changelog;
+    logger.verbose(`Output changelog for ${pkg.name}:
+${changelog}`);
+    logger.debug(`Changelog generated for ${pkg.name} (${pkg.commits.length} commits)`);
+    logger.verbose(`Final changelog for ${pkg.name}:
+
+${changelog}
+
+`);
+    if (dryRun) {
+      logger.info(`[dry-run] ${pkg.name} - Generate changelog ${fromTag}...${toTag}`);
     }
+    return changelog;
+  } catch (error) {
+    throw new Error(`Error generating changelog for ${pkg.name} (${fromTag}...${toTag}): ${error}`);
   }
-  return bumpedPackages;
 }
-function shouldFilterPrereleaseTags(currentVersion, graduating) {
-  return !isPrerelease(currentVersion) && !graduating;
-}
-function extractVersionFromTag(tag, packageName) {
-  if (!tag) {
-    return null;
+function writeChangelogToFile({
+  cwd,
+  pkg,
+  changelog,
+  dryRun = false
+}) {
+  const changelogPath = join(pkg.path, "CHANGELOG.md");
+  let existingChangelog = "";
+  if (existsSync(changelogPath)) {
+    existingChangelog = readFileSync(changelogPath, "utf8");
   }
-  if (packageName) {
-    const prefix = `${packageName}@`;
-    if (tag.startsWith(prefix)) {
-      return tag.slice(prefix.length);
-    }
-  }
-  const atIndex = tag.lastIndexOf("@");
-  if (atIndex !== -1) {
-    return tag.slice(atIndex + 1);
-  }
-  if (tag.startsWith("v") && /^v\d/.test(tag)) {
-    return tag.slice(1);
-  }
-  if (/^\d+\.\d+\.\d+/.test(tag)) {
-    return tag;
+  const lines = existingChangelog.split("\n");
+  const titleIndex = lines.findIndex((line) => line.startsWith("# "));
+  let updatedChangelog;
+  if (titleIndex !== -1) {
+    const beforeTitle = lines.slice(0, titleIndex + 1);
+    const afterTitle = lines.slice(titleIndex + 1);
+    updatedChangelog = [...beforeTitle, "", changelog, "", ...afterTitle].join("\n");
+  } else {
+    const title = "# Changelog\n";
+    updatedChangelog = `${title}
+${changelog}
+${existingChangelog}`;
   }
-  return null;
-}
-function isTagVersionCompatibleWithCurrent(tagVersion, currentVersion) {
-  try {
-    const tagMajor = semver.major(tagVersion);
-    const currentMajor = semver.major(currentVersion);
-    return tagMajor <= currentMajor;
-  } catch {
-    return false;
+  if (dryRun) {
+    const relativeChangelogPath = relative(cwd, changelogPath);
+    logger.info(`[dry-run] ${pkg.name} - Write changelog to ${relativeChangelogPath}`);
+  } else {
+    logger.debug(`Writing changelog to ${changelogPath}`);
+    writeFileSync(changelogPath, updatedChangelog, "utf8");
+    logger.info(`Changelog updated for ${pkg.name} (${"newVersion" in pkg && pkg.newVersion || pkg.version})`);
   }
 }
 
-function 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,
-    noStderr: true,
-    noStdout: true,
-    noSuccess: true,
-    cwd
-  });
-  const lastTag = stdout.trim();
-  logger.debug("Last tag:", lastTag || "No tags found");
-  return lastTag;
-}
-async function getAllRecentRepoTags(options) {
-  const limit = options?.limit;
-  try {
-    const { stdout } = await execPromise(
-      `git tag --sort=-creatordate | head -n ${limit}`,
-      {
-        logLevel: options?.logLevel,
-        noStderr: true,
-        noStdout: true,
-        noSuccess: true,
-        cwd: options?.cwd
+function getDefaultConfig() {
+  return {
+    cwd: process$1.cwd(),
+    types: {
+      feat: { title: "\u{1F680} Enhancements", semver: "minor" },
+      perf: { title: "\u{1F525} Performance", semver: "patch" },
+      fix: { title: "\u{1FA79} Fixes", semver: "patch" },
+      refactor: { title: "\u{1F485} Refactors", semver: "patch" },
+      docs: { title: "\u{1F4D6} Documentation", semver: "patch" },
+      build: { title: "\u{1F4E6} Build", semver: "patch" },
+      types: { title: "\u{1F30A} Types", semver: "patch" },
+      chore: { title: "\u{1F3E1} Chore" },
+      examples: { title: "\u{1F3C0} Examples" },
+      test: { title: "\u2705 Tests" },
+      style: { title: "\u{1F3A8} Styles" },
+      ci: { title: "\u{1F916} CI" }
+    },
+    templates: {
+      commitMessage: "chore(release): bump version to {{newVersion}}",
+      tagMessage: "Bump version to {{newVersion}}",
+      tagBody: "v{{newVersion}}",
+      emptyChangelogContent: "No relevant changes for this release",
+      twitterMessage: "\u{1F680} {{projectName}} {{version}} is out!\n\n{{changelog}}\n\n{{releaseUrl}}\n{{changelogUrl}}",
+      slackMessage: void 0
+      // Use rich blocks format by default (no template)
+    },
+    excludeAuthors: [],
+    noAuthors: false,
+    bump: {
+      type: "release",
+      clean: true,
+      dependencyTypes: ["dependencies"],
+      yes: false
+    },
+    changelog: {
+      rootChangelog: true,
+      includeCommitBody: true
+    },
+    publish: {
+      private: false,
+      args: [],
+      token: process$1.env.RELIZY_NPM_TOKEN || process$1.env.NPM_TOKEN || process$1.env.NODE_AUTH_TOKEN,
+      registry: "https://registry.npmjs.org/",
+      safetyCheck: false
+    },
+    tokens: {
+      registry: process$1.env.RELIZY_NPM_TOKEN || process$1.env.NPM_TOKEN || process$1.env.NODE_AUTH_TOKEN,
+      gitlab: process$1.env.RELIZY_GITLAB_TOKEN || process$1.env.GITLAB_TOKEN || process$1.env.GITLAB_API_TOKEN || process$1.env.CI_JOB_TOKEN,
+      github: process$1.env.RELIZY_GITHUB_TOKEN || process$1.env.GITHUB_TOKEN || process$1.env.GH_TOKEN,
+      twitter: {
+        apiKey: process$1.env.RELIZY_TWITTER_API_KEY || process$1.env.TWITTER_API_KEY,
+        apiKeySecret: process$1.env.RELIZY_TWITTER_API_KEY_SECRET || process$1.env.TWITTER_API_KEY_SECRET,
+        accessToken: process$1.env.RELIZY_TWITTER_ACCESS_TOKEN || process$1.env.TWITTER_ACCESS_TOKEN,
+        accessTokenSecret: process$1.env.RELIZY_TWITTER_ACCESS_TOKEN_SECRET || process$1.env.TWITTER_ACCESS_TOKEN_SECRET
+      },
+      slack: process$1.env.RELIZY_SLACK_TOKEN || process$1.env.SLACK_TOKEN
+    },
+    scopeMap: {},
+    release: {
+      commit: true,
+      publish: true,
+      changelog: true,
+      push: true,
+      clean: true,
+      providerRelease: true,
+      noVerify: false,
+      gitTag: true,
+      social: true
+    },
+    social: {
+      twitter: {
+        enabled: false,
+        onlyStable: true
+      },
+      slack: {
+        enabled: false,
+        onlyStable: true
       }
-    );
-    const tags = stdout.trim().split("\n").filter((tag) => tag.length > 0);
-    logger.debug(`Retrieved ${tags.length} recent repo tags`);
-    return tags;
-  } catch {
-    return [];
-  }
+    },
+    logLevel: "default",
+    safetyCheck: true
+  };
 }
-async function getAllRecentPackageTags({
-  packageName,
-  limit = 50,
-  logLevel,
-  cwd
-}) {
-  try {
-    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
-    const { stdout } = await execPromise(
-      `git tag --sort=-creatordate | grep -E '^${escapedPackageName}@' | head -n ${limit}`,
-      {
-        logLevel,
-        noStderr: true,
-        noStdout: true,
-        noSuccess: true,
-        cwd
-      }
-    );
-    const tags = stdout.trim().split("\n").filter((tag) => tag.length > 0);
-    logger.debug(`Retrieved ${tags.length} recent tags for package ${packageName}`);
-    return tags;
-  } catch {
-    return [];
+function setupLogger(logLevel) {
+  if (logLevel) {
+    logger.setLevel(logLevel);
+    logger.debug(`Log level set to: ${logLevel}`);
   }
 }
-function filterCompatibleTags({
-  tags,
-  currentVersion,
-  onlyStable,
-  packageName
-}) {
-  const filtered = tags.filter((tag) => {
-    const tagVersion = extractVersionFromTag(tag, packageName);
-    if (!tagVersion) {
-      logger.debug(`Skipping tag ${tag}: cannot extract version`);
-      return false;
-    }
-    if (onlyStable && isPrerelease(tagVersion)) {
-      logger.debug(`Skipping tag ${tag}: prerelease version ${tagVersion} (onlyStable=${onlyStable})`);
-      return false;
-    }
-    if (!isTagVersionCompatibleWithCurrent(tagVersion, currentVersion)) {
-      logger.debug(`Skipping tag ${tag}: version ${tagVersion} has higher major than current ${currentVersion}`);
-      return false;
-    }
-    logger.debug(`Tag ${tag} with version ${tagVersion} is compatible`);
-    return true;
-  });
-  logger.debug(`Filtered ${tags.length} tags down to ${filtered.length} compatible tags`);
-  return filtered;
-}
-function getLastRepoTag(options) {
-  if (options?.currentVersion) {
-    return getLastRepoTagWithFiltering({
-      currentVersion: options.currentVersion,
-      onlyStable: options.onlyStable ?? false,
-      logLevel: options.logLevel,
-      cwd: options.cwd
-    });
+async function resolveConfig(config, cwd) {
+  if (!config.repo) {
+    const resolvedRepoConfig = await resolveRepoConfig(cwd);
+    config.repo = {
+      ...resolvedRepoConfig,
+      provider: resolvedRepoConfig.provider
+    };
   }
-  if (options?.onlyStable) {
-    return getLastStableTag({ logLevel: options?.logLevel, cwd: options?.cwd });
+  if (typeof config.repo === "string") {
+    const resolvedRepoConfig = getRepoConfig(config.repo);
+    config.repo = {
+      ...resolvedRepoConfig,
+      provider: resolvedRepoConfig.provider
+    };
   }
-  return getLastTag({ logLevel: options?.logLevel, cwd: options?.cwd });
+  return config;
 }
-async function getLastRepoTagWithFiltering({
-  currentVersion,
-  onlyStable,
-  logLevel,
-  cwd
-}) {
-  const recentTags = await getAllRecentRepoTags({ limit: 50, logLevel, cwd });
-  if (recentTags.length === 0) {
-    logger.debug("No tags found in repository");
-    return null;
-  }
-  const compatibleTags = filterCompatibleTags({
-    tags: recentTags,
-    currentVersion,
-    onlyStable
+async function loadRelizyConfig(options) {
+  const cwd = options?.overrides?.cwd ?? process$1.cwd();
+  await setupDotenv({ cwd });
+  const configFile = options?.configFile ?? "relizy";
+  const defaultConfig = getDefaultConfig();
+  const overridesConfig = defu(options?.overrides, options?.baseConfig);
+  const results = await loadConfig({
+    dotenv: true,
+    cwd,
+    name: configFile,
+    packageJson: true,
+    defaults: defaultConfig,
+    overrides: overridesConfig
   });
-  if (compatibleTags.length === 0) {
-    logger.debug("No compatible tags found");
-    return null;
+  if (typeof results._configFile !== "string") {
+    logger.debug(`No config file found with name "${configFile}"`);
+    if (options?.configFile) {
+      logger.error(`No config file found with name "${configFile}"`);
+      process$1.exit(1);
+    }
   }
-  const lastTag = compatibleTags[0];
-  logger.debug(`Last compatible repo tag: ${lastTag}`);
-  return lastTag;
+  setupLogger(options?.overrides?.logLevel || results.config.logLevel);
+  logger.verbose("User config:", formatJson(results.config.changelog));
+  const resolvedConfig = await resolveConfig(results.config, cwd);
+  logger.debug("Resolved config:", formatJson(resolvedConfig));
+  return resolvedConfig;
 }
-async function getLastPackageTag({
-  packageName,
-  onlyStable,
-  currentVersion,
-  logLevel,
-  cwd
+function defineConfig(config) {
+  return config;
+}
+
+async function githubIndependentMode({
+  config,
+  dryRun,
+  bumpResult,
+  force,
+  suffix
 }) {
-  if (currentVersion) {
-    return getLastPackageTagWithFiltering({
-      packageName,
-      currentVersion,
-      onlyStable: onlyStable ?? false,
-      logLevel,
-      cwd
-    });
+  const repoConfig = config.repo;
+  if (!repoConfig) {
+    throw new Error("No repository configuration found. Please check your changelog config.");
   }
-  try {
-    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
-    let grepPattern;
-    if (onlyStable) {
-      grepPattern = `^${escapedPackageName}@[0-9]+\\.[0-9]+\\.[0-9]+$`;
-    } else {
-      grepPattern = `^${escapedPackageName}@`;
+  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github && !config.repo?.token) {
+    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+  }
+  const packages = await getPackagesOrBumpedPackages({
+    config,
+    bumpResult,
+    suffix,
+    force
+  });
+  logger.info(`Creating ${packages.length} GitHub release(s)`);
+  const postedReleases = [];
+  for (const pkg of packages) {
+    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
+    const from = config.from || pkg.fromTag;
+    const to = config.to || getIndependentTag({ version: newVersion, name: pkg.name });
+    if (!from) {
+      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
+      continue;
     }
-    const { stdout } = await execPromise(
-      `git tag --sort=-creatordate | grep -E '${grepPattern}' | sed -n '1p'`,
-      {
-        logLevel,
-        noStderr: true,
-        noStdout: true,
-        noSuccess: true,
-        cwd
-      }
-    );
-    const tag = stdout.trim();
-    return tag || null;
-  } catch {
-    return null;
+    const toTag = dryRun ? "HEAD" : to;
+    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${toTag}`);
+    const changelog = await generateChangelog({
+      pkg,
+      config,
+      dryRun,
+      newVersion
+    });
+    const releaseBody = changelog.split("\n").slice(2).join("\n");
+    const release = {
+      tag_name: to,
+      name: to,
+      body: releaseBody,
+      prerelease: isPrerelease(newVersion)
+    };
+    logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
+    if (dryRun) {
+      logger.info(`[dry-run] Publish GitHub release for ${to}`);
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: newVersion,
+        prerelease: release.prerelease
+      });
+    } else {
+      logger.debug(`Publishing release ${to} to GitHub...`);
+      await createGithubRelease({
+        ...config,
+        from,
+        to,
+        repo: repoConfig
+      }, release);
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: newVersion,
+        prerelease: release.prerelease
+      });
+    }
+  }
+  if (postedReleases.length === 0) {
+    logger.warn("No releases created");
+  } else {
+    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitHub!`);
   }
+  return postedReleases;
 }
-async function getLastPackageTagWithFiltering({
-  packageName,
-  currentVersion,
-  onlyStable,
-  logLevel,
-  cwd
+async function githubUnified({
+  config,
+  dryRun,
+  rootPackage,
+  bumpResult
 }) {
-  const recentTags = await getAllRecentPackageTags({
-    packageName,
-    limit: 50,
-    logLevel,
-    cwd
-  });
-  if (recentTags.length === 0) {
-    logger.debug(`No tags found for package ${packageName}`);
-    return null;
+  const repoConfig = config.repo;
+  if (!repoConfig) {
+    throw new Error("No repository configuration found. Please check your changelog config.");
   }
-  const compatibleTags = filterCompatibleTags({
-    tags: recentTags,
-    currentVersion,
-    onlyStable,
-    packageName
-  });
-  if (compatibleTags.length === 0) {
-    logger.debug(`No compatible tags found for package ${packageName}`);
-    return null;
+  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github && !config.repo?.token) {
+    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
   }
-  const lastTag = compatibleTags[0];
-  logger.debug(`Last compatible package tag for ${packageName}: ${lastTag}`);
-  return lastTag;
-}
-async function resolveFromTagIndependent({
-  cwd,
-  packageName,
-  currentVersion,
-  graduating,
-  logLevel
-}) {
-  const filterPrereleases = shouldFilterPrereleaseTags(currentVersion, graduating);
-  const onlyStable = graduating || filterPrereleases;
-  const lastPackageTag = await getLastPackageTag({
-    packageName,
-    currentVersion,
-    onlyStable,
-    logLevel,
-    cwd
+  const newVersion = bumpResult?.newVersion || rootPackage.version;
+  const to = config.to || config.templates.tagBody.replace("{{newVersion}}", newVersion);
+  const changelog = await generateChangelog({
+    pkg: rootPackage,
+    config,
+    dryRun,
+    newVersion
   });
-  if (!lastPackageTag) {
-    return getFirstCommit(cwd);
+  const releaseBody = changelog.split("\n").slice(2).join("\n");
+  const release = {
+    tag_name: to,
+    name: to,
+    body: releaseBody,
+    prerelease: isPrerelease(to)
+  };
+  logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
+  logger.debug("Release details:", formatJson({
+    tag_name: release.tag_name,
+    name: release.name,
+    prerelease: release.prerelease
+  }));
+  if (dryRun) {
+    logger.info("[dry-run] Publish GitHub release for", release.tag_name);
+  } else {
+    logger.debug("Publishing release to GitHub...");
+    const releaseConfig = {
+      ...config,
+      from: bumpResult?.bumped && bumpResult.fromTag || "v0.0.0",
+      to,
+      repo: repoConfig
+    };
+    await createGithubRelease(releaseConfig, release);
   }
-  return lastPackageTag;
+  logger.success(`Release ${to} published to GitHub!`);
+  return [{
+    name: to,
+    tag: to,
+    version: to,
+    prerelease: release.prerelease
+  }];
 }
-async function resolveFromTagUnified({
-  config,
-  currentVersion,
-  graduating,
-  logLevel
-}) {
-  const filterPrereleases = shouldFilterPrereleaseTags(currentVersion, graduating);
-  const onlyStable = graduating || filterPrereleases;
-  const from = await getLastRepoTag({
-    currentVersion,
-    onlyStable,
-    logLevel,
-    cwd: config.cwd
-  }) || getFirstCommit(config.cwd);
-  return from;
+async function github(options) {
+  logger.debug("Config:", options);
+  try {
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const config = await loadRelizyConfig({
+      configFile: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        from: options.from,
+        to: options.to,
+        logLevel: options.logLevel,
+        tokens: {
+          github: options.token
+        }
+      }
+    });
+    if (config.monorepo?.versionMode === "independent") {
+      return await githubIndependentMode({
+        config,
+        dryRun,
+        bumpResult: options.bumpResult,
+        force: options.force ?? false,
+        suffix: options.suffix
+      });
+    }
+    const rootPackageBase = readPackageJson(config.cwd);
+    if (!rootPackageBase) {
+      throw new Error("Failed to read root package.json");
+    }
+    const newVersion = options.bumpResult?.newVersion || rootPackageBase.version;
+    const { from, to } = await resolveTags({
+      config,
+      step: "provider-release",
+      newVersion,
+      pkg: rootPackageBase
+    });
+    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
+      config,
+      force: options.force ?? false,
+      suffix: options.suffix,
+      changelog: true,
+      from,
+      to
+    });
+    return await githubUnified({
+      config,
+      dryRun,
+      rootPackage,
+      bumpResult: options.bumpResult
+    });
+  } catch (error) {
+    logger.error("Error publishing GitHub release:", error);
+    throw error;
+  }
 }
-async function resolveFromTag({
+
+async function createGitlabRelease({
   config,
-  versionMode,
-  step,
-  packageName,
-  currentVersion,
-  graduating,
-  logLevel
+  release,
+  dryRun
 }) {
-  let from;
-  if (versionMode === "independent") {
-    if (!packageName) {
-      throw new Error("Package name is required for independent version mode");
+  const token = config.tokens.gitlab || config.repo?.token;
+  if (!token && !dryRun) {
+    throw new Error(
+      "No GitLab token found. Set GITLAB_TOKEN or CI_JOB_TOKEN environment variable or configure tokens.gitlab"
+    );
+  }
+  const repoConfig = config.repo?.repo;
+  if (!repoConfig) {
+    throw new Error("No repository URL found in config");
+  }
+  logger.debug(`Parsed repository URL: ${repoConfig}`);
+  const projectPath = encodeURIComponent(repoConfig);
+  const gitlabDomain = config.repo?.domain || "gitlab.com";
+  const apiUrl = `https://${gitlabDomain}/api/v4/projects/${projectPath}/releases`;
+  logger.info(`Creating GitLab release at: ${apiUrl}`);
+  const payload = {
+    tag_name: release.tag_name,
+    name: release.name || release.tag_name,
+    description: release.description || "",
+    ref: release.ref || "main"
+  };
+  try {
+    if (dryRun) {
+      logger.info("[dry-run] GitLab release:", formatJson(payload));
+      return {
+        tag_name: release.tag_name,
+        name: release.name || release.tag_name,
+        description: release.description || "",
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        released_at: (/* @__PURE__ */ new Date()).toISOString(),
+        _links: {
+          self: `${apiUrl}/${encodeURIComponent(release.tag_name)}`
+        }
+      };
     }
-    from = await resolveFromTagIndependent({
-      cwd: config.cwd,
-      packageName,
-      currentVersion,
-      graduating,
-      logLevel
-    });
-  } else {
-    from = await resolveFromTagUnified({
-      config,
-      currentVersion,
-      graduating,
-      logLevel
+    logger.debug(`POST GitLab release to ${apiUrl} with payload: ${formatJson(payload)}`);
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PRIVATE-TOKEN": token || ""
+      },
+      body: JSON.stringify(payload)
     });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`GitLab API error (${response.status}): ${errorText}`);
+    }
+    const result = await response.json();
+    logger.debug(`Created GitLab release: ${result._links.self}`);
+    return result;
+  } catch (error) {
+    logger.error("Failed to create GitLab release:", error);
+    throw error;
   }
-  logger.debug(`[${versionMode}](${step}) Using from tag: ${from}`);
-  return config.from || from;
 }
-function resolveToTag({
+async function gitlabIndependentMode({
   config,
-  versionMode,
-  newVersion,
-  step,
-  packageName
+  dryRun,
+  bumpResult,
+  suffix,
+  force
 }) {
-  const isUntaggedStep = step === "bump" || step === "changelog";
-  let to;
-  if (isUntaggedStep) {
-    to = getCurrentGitRef(config.cwd);
-  } else if (versionMode === "independent") {
-    if (!packageName) {
-      throw new Error("Package name is required for independent version mode");
+  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  const packages = await getPackagesOrBumpedPackages({
+    config,
+    bumpResult,
+    suffix,
+    force
+  });
+  logger.info(`Creating ${packages.length} GitLab release(s) for independent packages`);
+  logger.debug("Getting current branch...");
+  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
+    noSuccess: true,
+    noStdout: true,
+    logLevel: config.logLevel,
+    cwd: config.cwd
+  });
+  const postedReleases = [];
+  for (const pkg of packages) {
+    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
+    const from = config.from || pkg.fromTag;
+    const to = getIndependentTag({ version: newVersion, name: pkg.name });
+    if (!from) {
+      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
+      continue;
     }
-    if (!newVersion) {
-      throw new Error("New version is required for independent version mode");
+    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${to}`);
+    const changelog = await generateChangelog({
+      pkg,
+      config,
+      dryRun,
+      newVersion
+    });
+    if (!changelog) {
+      logger.warn(`No changelog found for ${pkg.name}`);
+      continue;
     }
-    to = getIndependentTag({ version: newVersion, name: packageName });
+    const releaseBody = changelog.split("\n").slice(2).join("\n");
+    const release = {
+      tag_name: to,
+      name: to,
+      description: releaseBody,
+      ref: currentBranch.trim()
+    };
+    logger.debug(`Creating release for ${to} (ref: ${release.ref})`);
+    if (dryRun) {
+      logger.info(`[dry-run] Publish GitLab release for ${to}`);
+    } else {
+      logger.debug(`Publishing release ${to} to GitLab...`);
+      await createGitlabRelease({
+        config,
+        release,
+        dryRun
+      });
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: newVersion,
+        prerelease: isPrerelease(newVersion)
+      });
+    }
+  }
+  if (postedReleases.length === 0) {
+    logger.warn("No releases created");
   } else {
-    to = newVersion ? config.templates.tagBody.replace("{{newVersion}}", newVersion) : getCurrentGitRef(config.cwd);
+    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitLab!`);
   }
-  logger.debug(`[${versionMode}](${step}) Using to tag: ${to}`);
-  return config.to || to;
+  return postedReleases;
 }
-async function resolveTags({
+async function gitlabUnified({
   config,
-  step,
-  pkg,
-  newVersion
+  dryRun,
+  rootPackage,
+  bumpResult
 }) {
-  const versionMode = config.monorepo?.versionMode || "standalone";
-  const logLevel = config.logLevel;
-  logger.debug(`[${versionMode}](${step}) Resolving tags`);
-  const releaseType = config.bump.type;
-  const graduating = typeof newVersion === "string" ? isGraduatingToStableBetweenVersion(pkg.version, newVersion) : isGraduating(pkg.version, releaseType);
-  const from = await resolveFromTag({
+  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  const newVersion = bumpResult?.newVersion || rootPackage.newVersion || rootPackage.version;
+  const to = config.templates.tagBody.replace("{{newVersion}}", newVersion);
+  const changelog = await generateChangelog({
+    pkg: rootPackage,
     config,
-    versionMode,
-    step,
-    packageName: pkg.name,
-    currentVersion: pkg.version,
-    graduating,
-    logLevel
+    dryRun,
+    newVersion
   });
-  const to = resolveToTag({
-    config,
-    versionMode,
-    newVersion,
-    step,
-    packageName: pkg.name
+  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
   });
-  logger.debug(`[${versionMode}](${step}) Using tags: ${from} \u2192 ${to}`);
-  return { from, to };
+  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(newVersion)
+  }];
+}
+async function gitlab(options = {}) {
+  try {
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const config = await loadRelizyConfig({
+      configFile: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        from: options.from,
+        to: options.to,
+        logLevel: options.logLevel,
+        tokens: {
+          gitlab: options.token
+        }
+      }
+    });
+    if (config.monorepo?.versionMode === "independent") {
+      return await gitlabIndependentMode({
+        config,
+        dryRun,
+        bumpResult: options.bumpResult,
+        suffix: options.suffix,
+        force: options.force ?? false
+      });
+    }
+    const rootPackageBase = readPackageJson(config.cwd);
+    if (!rootPackageBase) {
+      throw new Error("Failed to read root package.json");
+    }
+    const newVersion = options.bumpResult?.newVersion || rootPackageBase.version;
+    const { from, to } = await resolveTags({
+      config,
+      step: "provider-release",
+      newVersion,
+      pkg: rootPackageBase
+    });
+    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
+      config,
+      force: options.force ?? false,
+      suffix: options.suffix,
+      changelog: true,
+      from,
+      to
+    });
+    logger.debug(`Root package: ${getIndependentTag({ name: rootPackage.name, version: newVersion })}`);
+    return await gitlabUnified({
+      config,
+      dryRun,
+      rootPackage,
+      bumpResult: options.bumpResult
+    });
+  } catch (error) {
+    logger.error("Error publishing GitLab release:", error);
+    throw error;
+  }
 }
 
 let sessionOtp;
@@ -2570,7 +2663,7 @@ function getCommandArgs({
     args.push("--registry", registry);
   }
   const isPnpmOrNpm = packageManager === "pnpm" || packageManager === "npm";
-  const publishToken = config.publish.token;
+  const publishToken = config.publish.token || config.tokens.registry;
   if (publishToken) {
     if (!registry) {
       logger.warn("Publish token provided but no registry specified");
@@ -2611,7 +2704,18 @@ function isOtpError(error) {
   if (typeof error !== "object" || error === null)
     return false;
   const errorMessage = "message" in error && typeof error.message === "string" ? error.message.toLowerCase() : "";
-  return errorMessage.includes("otp") || errorMessage.includes("one-time password") || errorMessage.includes("eotp");
+  const fullErrorString = String(error).toLowerCase();
+  const searchText = `${errorMessage} ${fullErrorString}`;
+  const otpPatterns = [
+    "otp",
+    "one-time password",
+    "eotp",
+    "two-factor authentication",
+    "2fa",
+    "two factor"
+  ];
+  const isOtp = otpPatterns.some((pattern) => searchText.includes(pattern));
+  return isOtp;
 }
 function promptOtpWithTimeout(timeout = 9e4) {
   return new Promise((resolve, reject) => {
@@ -2640,7 +2744,7 @@ async function handleOtpError() {
     logger.debug("OTP received, retrying publish...");
     return otp;
   } catch (promptError) {
-    logger.error("Failed to get OTP:", promptError);
+    logger.fail("Failed to get OTP");
     throw promptError;
   }
 }
@@ -2663,6 +2767,7 @@ async function executePublishCommand({
     noStderr: true,
     noStdout: true,
     noSuccess: true,
+    noError: true,
     logLevel: config.logLevel,
     cwd: pkg.path
   });
@@ -2743,9 +2848,302 @@ async function publishPackage({
         logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
         throw error;
       }
-    } finally {
-      process.chdir(config.cwd);
+    } finally {
+      process.chdir(config.cwd);
+    }
+  }
+}
+
+function extractChangelogSummary(changelog, maxLength = 150) {
+  if (changelog.trim() === "") {
+    return "";
+  }
+  const cleaned = changelog.split("\n").filter((line) => !line.startsWith("#")).join("\n").trim();
+  let cleanedResult = cleaned;
+  if (cleanedResult.endsWith("?") || cleanedResult.endsWith("!") || cleanedResult.endsWith(".")) {
+    cleanedResult = cleanedResult.slice(0, -1);
+  }
+  const sentences = cleanedResult.split(/[.!?]\s+/);
+  let summary = "";
+  for (const sentence of sentences) {
+    if ((summary + sentence).length > maxLength || sentence.trim() === "") {
+      break;
+    }
+    summary += `${sentence}. `;
+  }
+  return summary.trim() || cleaned.substring(0, maxLength);
+}
+function getReleaseUrl(config, tag) {
+  const repo = config.repo;
+  if (!repo?.domain || !repo?.repo) {
+    return void 0;
+  }
+  const provider = repo.provider || "github";
+  if (provider === "github") {
+    return `https://${repo.domain}/${repo.repo}/releases/tag/${tag}`;
+  } else if (provider === "gitlab") {
+    return `https://${repo.domain}/${repo.repo}/-/releases/${tag}`;
+  } else if (provider === "bitbucket") {
+    return `https://${repo.domain}/${repo.repo}/commits/tag/${tag}`;
+  }
+  return void 0;
+}
+
+function getSlackToken(options) {
+  const { socialCredentials, tokenCredential } = options;
+  const token = socialCredentials?.token || tokenCredential;
+  if (!token) {
+    return null;
+  }
+  return token;
+}
+function formatChangelogForSlack(changelog, maxLength = 500) {
+  let formatted = changelog.replace(/^### (.+)$/gm, "*$1*").replace(/^## (.+)$/gm, "*$1*").replace(/^# (.+)$/gm, "*$1*").replace(/\*\*(.+?)\*\*/g, "*$1*");
+  const linkPattern = /\[([^\]]*)]\(([^)]*)\)/g;
+  formatted = formatted.replace(linkPattern, (_, text, url) => `<${url}|${text}>`);
+  if (formatted.length > maxLength) {
+    formatted = `${formatted.substring(0, maxLength - 3)}...`;
+  }
+  return formatted;
+}
+function formatSlackMessage({ projectName, version, changelog, releaseUrl, changelogUrl, template }) {
+  if (template) {
+    const summary = extractChangelogSummary(changelog, 500);
+    let message = template.replace("{{projectName}}", projectName).replace("{{version}}", version).replace("{{changelog}}", summary);
+    if (releaseUrl) {
+      message = message.replace("{{releaseUrl}}", releaseUrl);
+    } else {
+      message = message.replace("{{releaseUrl}}", "").trim();
+    }
+    if (changelogUrl) {
+      message = message.replace("{{changelogUrl}}", changelogUrl);
+    } else {
+      message = message.replace("{{changelogUrl}}", "").trim();
+    }
+    return [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: message
+        }
+      }
+    ];
+  }
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `\u{1F680} ${projectName} ${version} is out!`,
+        emoji: true
+      }
+    }
+  ];
+  const formattedChangelog = formatChangelogForSlack(changelog, 500);
+  if (formattedChangelog) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: formattedChangelog
+      }
+    });
+  }
+  blocks.push({
+    type: "divider"
+  });
+  const elements = [];
+  if (releaseUrl) {
+    elements.push({
+      type: "button",
+      text: {
+        type: "plain_text",
+        text: "\u{1F4E6} View Release",
+        emoji: true
+      },
+      url: releaseUrl,
+      action_id: "view_release"
+    });
+  }
+  if (changelogUrl) {
+    elements.push({
+      type: "button",
+      text: {
+        type: "plain_text",
+        text: "\u{1F4CB} Full Changelog",
+        emoji: true
+      },
+      url: changelogUrl,
+      action_id: "view_changelog"
+    });
+  }
+  if (elements.length > 0) {
+    blocks.push({
+      type: "actions",
+      elements
+    });
+  }
+  return blocks;
+}
+async function postReleaseToSlack({
+  version,
+  projectName,
+  changelog,
+  releaseUrl,
+  changelogUrl,
+  channel,
+  token,
+  template,
+  dryRun = false
+}) {
+  logger.debug("Preparing Slack post...");
+  const blocks = formatSlackMessage({
+    template,
+    projectName,
+    version,
+    changelog,
+    releaseUrl,
+    changelogUrl
+  });
+  logger.debug(`Message blocks (${blocks.length} blocks)`);
+  if (dryRun) {
+    logger.info("[dry-run] Would post to Slack:", JSON.stringify(blocks, null, 2));
+    return;
+  }
+  try {
+    const { WebClient } = await import('@slack/web-api');
+    const client = new WebClient(token);
+    logger.debug(`Posting message to Slack channel: ${channel}`);
+    const result = await client.chat.postMessage({
+      channel,
+      blocks,
+      text: `${projectName} ${version} is out!`
+      // Fallback text for notifications
+    });
+    logger.success(`Message posted successfully! Channel: ${result.channel}, Timestamp: ${result.ts}`);
+    return result;
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.message?.includes("@slack/web-api")) {
+      logger.error("Slack Web API dependency not found. Please install it with: pnpm add @slack/web-api");
+      throw new Error("Missing dependency: @slack/web-api. Install it with: pnpm add @slack/web-api");
+    }
+    logger.error("Failed to post message:", error.message || error);
+    if (error.data) {
+      logger.error("Slack API error:", error.data.error);
+      switch (error.data.error) {
+        case "channel_not_found":
+          throw new Error("Slack channel not found. Make sure the channel ID or name is correct.");
+        case "not_in_channel":
+          throw new Error("Bot is not in the channel. Invite the bot to the channel first.");
+        case "invalid_auth":
+          throw new Error("Invalid Slack token. Check your credentials.");
+        case "missing_scope":
+          throw new Error('Missing required OAuth scope. The bot needs "chat:write" permission.');
+        default:
+          throw error;
+      }
+    }
+    throw error;
+  }
+}
+
+function getTwitterCredentials({ socialCredentials, tokenCredentials }) {
+  const apiKey = socialCredentials?.apiKey || tokenCredentials?.apiKey;
+  const apiKeySecret = socialCredentials?.apiKeySecret || tokenCredentials?.apiKeySecret;
+  const accessToken = socialCredentials?.accessToken || tokenCredentials?.accessToken;
+  const accessTokenSecret = socialCredentials?.accessTokenSecret || tokenCredentials?.accessTokenSecret;
+  if (!apiKey || !apiKeySecret || !accessToken || !accessTokenSecret) {
+    logger.warn("Twitter is enabled but credentials are missing.");
+    logger.log("Set the following environment variables or configure them in social.twitter.credentials or tokens.twitter:");
+    logger.log("  - TWITTER_API_KEY or RELIZY_TWITTER_API_KEY");
+    logger.log("  - TWITTER_API_KEY_SECRET or RELIZY_TWITTER_API_KEY_SECRET");
+    logger.log("  - TWITTER_ACCESS_TOKEN or RELIZY_TWITTER_ACCESS_TOKEN");
+    logger.log("  - TWITTER_ACCESS_TOKEN_SECRET or RELIZY_TWITTER_ACCESS_TOKEN_SECRET");
+    logger.info("Skipping Twitter post");
+    return null;
+  }
+  return {
+    apiKey,
+    apiKeySecret,
+    accessToken,
+    accessTokenSecret
+  };
+}
+function formatTweetMessage({ template, projectName, version, changelog, releaseUrl, changelogUrl }) {
+  const TWITTER_MAX_LENGTH = 280;
+  const ELLIPSIS = "...";
+  let templateWithValues = template.replace("{{projectName}}", projectName).replace("{{version}}", version);
+  if (releaseUrl) {
+    templateWithValues = templateWithValues.replace("{{releaseUrl}}", releaseUrl);
+  } else {
+    templateWithValues = templateWithValues.replace("{{releaseUrl}}", "");
+  }
+  if (changelogUrl) {
+    templateWithValues = templateWithValues.replace("{{changelogUrl}}", changelogUrl);
+  } else {
+    templateWithValues = templateWithValues.replace("{{changelogUrl}}", "");
+  }
+  const templateWithoutChangelog = templateWithValues.replace("{{changelog}}", "");
+  const availableForChangelog = TWITTER_MAX_LENGTH - templateWithoutChangelog.length;
+  let finalChangelog = changelog;
+  if (changelog.length > availableForChangelog) {
+    const maxLength = Math.max(0, availableForChangelog - ELLIPSIS.length);
+    finalChangelog = changelog.substring(0, maxLength) + ELLIPSIS;
+  }
+  let message = templateWithValues.replace("{{changelog}}", finalChangelog).trim();
+  if (message.length > TWITTER_MAX_LENGTH) {
+    message = message.substring(0, TWITTER_MAX_LENGTH - ELLIPSIS.length) + ELLIPSIS;
+  }
+  return message;
+}
+async function postReleaseToTwitter({
+  version,
+  projectName,
+  changelog,
+  releaseUrl,
+  changelogUrl,
+  credentials,
+  template,
+  dryRun = false
+}) {
+  logger.debug("Preparing Twitter post...");
+  const changelogSummary = extractChangelogSummary(changelog, 150);
+  const message = formatTweetMessage({
+    template,
+    projectName,
+    version,
+    changelog: changelogSummary,
+    releaseUrl,
+    changelogUrl
+  });
+  logger.debug(`Tweet message (${message.length} chars):
+${message}`);
+  if (dryRun) {
+    logger.info("[dry-run] Would post tweet:", message);
+    return;
+  }
+  try {
+    const { TwitterApi } = await import('twitter-api-v2');
+    const client = new TwitterApi({
+      appKey: credentials.apiKey,
+      appSecret: credentials.apiKeySecret,
+      accessToken: credentials.accessToken,
+      accessSecret: credentials.accessTokenSecret
+    });
+    const rwClient = client.readWrite;
+    logger.debug(`Posting tweet: ${message}`);
+    const tweet = await rwClient.v2.tweet(message);
+    logger.info(`Tweet posted successfully! Tweet ID: ${tweet.data.id}`);
+    logger.info(`Tweet URL: https://twitter.com/i/web/status/${tweet.data.id}`);
+    return tweet;
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND" || error.message?.includes("twitter-api-v2")) {
+      logger.error("Twitter API dependency not found. Please install it with: pnpm add twitter-api-v2");
+      throw new Error("Missing dependency: twitter-api-v2. Install it with: pnpm add twitter-api-v2");
     }
+    logger.error("Failed to post tweet:", error.message || error);
+    throw error;
   }
 }
 
@@ -2783,7 +3181,6 @@ async function bumpUnifiedMode({
   logger.debug(`${currentVersion} \u2192 ${newVersion} (${config.monorepo?.versionMode || "standalone"} mode)`);
   const packages = await getPackages({
     config,
-    patterns: config.monorepo?.packages,
     suffix,
     force
   });
@@ -2804,7 +3201,8 @@ async function bumpUnifiedMode({
   } else {
     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 [rootPackage, ...packages]) {
+  const packagesToWrite = [rootPackage, ...packages];
+  for (const pkg of packagesToWrite) {
     writeVersion(pkg.path, newVersion, dryRun);
   }
   updateLernaVersion({
@@ -2865,7 +3263,6 @@ async function bumpSelectiveMode({
   logger.debug("Determining packages to bump...");
   const packages = await getPackages({
     config,
-    patterns: config.monorepo?.packages,
     suffix,
     force
   });
@@ -2896,7 +3293,8 @@ async function bumpSelectiveMode({
     }
   }
   logger.debug(`Writing version to ${packages.length} package(s)`);
-  for (const pkg of [rootPackage, ...packages]) {
+  const packagesToWrite = [rootPackage, ...packages];
+  for (const pkg of packagesToWrite) {
     writeVersion(pkg.path, newVersion, dryRun);
   }
   updateLernaVersion({
@@ -2933,7 +3331,6 @@ async function bumpIndependentMode({
   logger.debug("Starting bump in independent mode");
   const packagesToBump = await getPackages({
     config,
-    patterns: config.monorepo?.packages,
     suffix,
     force
   });
@@ -3005,7 +3402,7 @@ async function bump(options = {}) {
       checkGitStatusIfDirty();
     }
     await fetchGitTags(config.cwd);
-    logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+    logger.debug(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
     const packages = readPackages({
       cwd: config.cwd,
       patterns: config.monorepo?.packages,
@@ -3031,7 +3428,7 @@ async function bump(options = {}) {
       logger.success(`${dryRun ? "[dry-run] " : ""}Version bump completed (${resultLog} package${resultLog === 1 || typeof resultLog === "string" ? "" : "s"} bumped)`);
     } else {
       logger.fail("No packages to bump, no relevant commits found");
-      exit(1);
+      process$1.exit(1);
     }
     await executeHook("success:bump", config, dryRun);
     return result;
@@ -3154,20 +3551,20 @@ async function changelog(options = {}) {
   });
   const dryRun = options.dryRun ?? false;
   logger.debug(`Dry run: ${dryRun}`);
-  logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+  logger.debug(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
   try {
     await executeHook("before:changelog", config, dryRun);
     logger.start("Start generating changelogs");
+    const packages = await getPackagesOrBumpedPackages({
+      config,
+      bumpResult: options.bumpResult,
+      suffix: options.suffix,
+      force: options.force ?? false
+    });
     if (config.changelog?.rootChangelog && config.monorepo) {
       if (config.monorepo.versionMode === "independent") {
-        const packages2 = await getPackagesOrBumpedPackages({
-          config,
-          bumpResult: options.bumpResult,
-          suffix: options.suffix,
-          force: options.force ?? false
-        });
         await generateIndependentRootChangelog({
-          packages: packages2,
+          packages,
           config,
           dryRun
         });
@@ -3184,12 +3581,6 @@ async function changelog(options = {}) {
       logger.debug("Skipping root changelog generation");
     }
     logger.debug("Generating package changelogs...");
-    const packages = await getPackagesOrBumpedPackages({
-      config,
-      bumpResult: options.bumpResult,
-      suffix: options.suffix,
-      force: options.force ?? false
-    });
     logger.debug(`Processing ${packages.length} package(s)`);
     let generatedCount = 0;
     for await (const pkg of packages) {
@@ -3236,22 +3627,28 @@ async function changelog(options = {}) {
 
 function providerReleaseSafetyCheck({ config, provider }) {
   if (!config.safetyCheck || !config.release.providerRelease) {
+    logger.debug("Safety check disabled or provider release disabled");
     return;
   }
+  logger.debug("Start checking provider release config");
   const internalProvider = provider || config.repo?.provider || detectGitProvider();
+  if (internalProvider === "bitbucket") {
+    logger.warn("Bitbucket does not support releases via API");
+    logger.info("Relizy will skip the release creation step for Bitbucket");
+    return;
+  }
   let token;
   if (internalProvider === "github") {
     token = config.tokens?.github || config.repo?.token;
   } else if (internalProvider === "gitlab") {
     token = config.tokens?.gitlab || config.repo?.token;
   } else {
-    logger.error(`[provider-release-safety-check] Unsupported Git provider: ${internalProvider || "unknown"}`);
-    process.exit(1);
+    throw new Error(`Unsupported Git provider: ${internalProvider || "unknown"}`);
   }
   if (!token) {
-    logger.error(`[provider-release-safety-check] No token provided for ${internalProvider || "unknown"} - The release will not be published - Please refer to the documentation: https://louismazel.github.io/relizy/guide/installation#environment-setup`);
-    process.exit(1);
+    throw new Error(`No token provided for ${internalProvider || "unknown"} - The release will not be published - Please refer to the documentation: https://louismazel.github.io/relizy/guide/installation#environment-setup`);
   }
+  logger.info("provider release config checked successfully");
 }
 async function providerRelease(options = {}) {
   const config = await loadRelizyConfig({
@@ -3270,9 +3667,10 @@ async function providerRelease(options = {}) {
   });
   const dryRun = options.dryRun ?? false;
   logger.debug(`Dry run: ${dryRun}`);
-  logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+  logger.debug(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+  let detectedProvider = null;
   try {
-    const detectedProvider = options.provider || detectGitProvider();
+    detectedProvider = options.provider || detectGitProvider();
     providerReleaseSafetyCheck({ config, provider: detectedProvider });
     await executeHook("before:provider-release", config, dryRun);
     logger.start("Start provider release");
@@ -3285,6 +3683,16 @@ async function providerRelease(options = {}) {
       );
     }
     let postedReleases = [];
+    if (detectedProvider === "bitbucket") {
+      logger.warn("\u26A0\uFE0F  Bitbucket does not support releases via API");
+      logger.info("Skipping release creation for Bitbucket");
+      logger.info("Git tags will still be created during the commit step");
+      await executeHook("success:provider-release", config, dryRun);
+      return {
+        detectedProvider,
+        postedReleases: []
+      };
+    }
     const payload = {
       from: config.from || options.bumpResult?.fromTag,
       to: config.to,
@@ -3312,20 +3720,24 @@ async function providerRelease(options = {}) {
       logger.error("Error publishing releases!\n\n", error);
     }
     await executeHook("error:provider-release", config, dryRun);
-    throw error;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      detectedProvider: detectedProvider || "github",
+      postedReleases: [],
+      error: errorMessage
+    };
   }
 }
 
 async function publishSafetyCheck({ config }) {
-  logger.debug("[publish-safety-check] Running publish safety check");
   if (!config.safetyCheck || !config.release.publish || !config.publish.safetyCheck) {
-    logger.debug("[publish-safety-check] Safety check disabled or publish disabled");
+    logger.debug("Safety check disabled or publish disabled");
     return;
   }
+  logger.debug("Start checking auth config to package registry");
   const packageManager = config.publish.packageManager || detectPackageManager(config.cwd);
   if (!packageManager) {
-    logger.error("[publish-safety-check] Unable to detect package manager");
-    process.exit(1);
+    throw new Error("Unable to detect package manager");
   }
   const isPnpmOrNpm = packageManager === "pnpm" || packageManager === "npm";
   if (isPnpmOrNpm) {
@@ -3335,7 +3747,7 @@ async function publishSafetyCheck({ config }) {
       otp: config.publish.otp
     });
     try {
-      logger.debug("[publish-safety-check] Authenticating to package registry...");
+      logger.debug("Authenticating to package registry...");
       await execPromise(authCommand, {
         cwd: config.cwd,
         noStderr: true,
@@ -3343,10 +3755,9 @@ async function publishSafetyCheck({ config }) {
         logLevel: config.logLevel,
         noSuccess: true
       });
-      logger.info("[publish-safety-check] Successfully authenticated to package registry");
+      logger.info("Successfully authenticated to package registry");
     } catch (error) {
-      logger.error("[publish-safety-check] Failed to authenticate to package registry:", error);
-      process.exit(1);
+      throw new Error("Failed to authenticate to package registry", { cause: error });
     }
   }
 }
@@ -3371,7 +3782,7 @@ async function publish(options = {}) {
   logger.debug(`Dry run: ${dryRun}`);
   const packageManager = config.publish.packageManager || detectPackageManager(config.cwd);
   logger.debug(`Package manager: ${packageManager}`);
-  logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+  logger.debug(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
   if (config.publish.registry) {
     logger.debug(`Registry: ${config.publish.registry}`);
   }
@@ -3418,7 +3829,7 @@ async function publish(options = {}) {
       config,
       dryRun
     });
-    for (const pkg of sortedPackages) {
+    for await (const pkg of sortedPackages) {
       if (publishedPackages.some((p) => p.name === pkg.name)) {
         logger.debug(`Publishing ${getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version })}...`);
         await publishPackage({
@@ -3446,6 +3857,286 @@ async function publish(options = {}) {
   }
 }
 
+function socialSafetyCheck({ config }) {
+  const socialMediaDisabled = !config.release.social && !config.social.twitter.enabled && !config.social.slack.enabled;
+  if (!config.safetyCheck || socialMediaDisabled) {
+    logger.debug("Safety check disabled or social disabled");
+    return;
+  }
+  logger.debug("Start checking social config");
+  const errors = {
+    twitter: false,
+    slack: false
+  };
+  const twitterConfig = config.social?.twitter;
+  if (twitterConfig?.enabled) {
+    const credentials = getTwitterCredentials({
+      socialCredentials: twitterConfig.credentials,
+      tokenCredentials: config.tokens?.twitter
+    });
+    if (!credentials) {
+      errors.twitter = true;
+    }
+  }
+  const slackConfig = config.social?.slack;
+  if (slackConfig?.enabled) {
+    const token = getSlackToken({
+      socialCredentials: slackConfig.credentials,
+      tokenCredential: config.tokens?.slack
+    });
+    if (!token) {
+      logger.log("Slack is enabled but credentials are missing.");
+      logger.log("Set the following environment variables or configure them in social.slack.credentials or tokens.slack:");
+      logger.log("  - SLACK_TOKEN or RELIZY_SLACK_TOKEN");
+      errors.slack = true;
+    }
+    if (!slackConfig.channel) {
+      logger.warn("Slack is enabled but no channel is configured.");
+      logger.log('Set the channel in social.slack.channel (e.g., "#releases" or "C1234567890")');
+      errors.slack = true;
+    }
+  }
+  if (errors.twitter || errors.slack) {
+    throw new Error("Social config checked with errors");
+  }
+  logger.info("Social config checked successfully");
+}
+async function handleTwitterPost({
+  config,
+  changelog,
+  dryRun,
+  newVersion,
+  tag
+}) {
+  const twitterConfig = config.social?.twitter;
+  if (!twitterConfig?.enabled) {
+    logger.debug("Twitter posting is disabled in configuration");
+    return { success: true, response: void 0 };
+  }
+  logger.debug("Twitter posting is enabled");
+  try {
+    const credentials = getTwitterCredentials({
+      socialCredentials: twitterConfig.credentials,
+      tokenCredentials: config.tokens?.twitter
+    });
+    if (!credentials) {
+      return { success: false, error: "Twitter credentials not found" };
+    }
+    logger.debug("Credentials found \u2713");
+    logger.debug("Preparing tweet for release");
+    const onlyStable = twitterConfig.onlyStable;
+    if (onlyStable && isPrerelease(newVersion)) {
+      logger.info(`Skipping Twitter post for prerelease version ${newVersion} (social.twitter.onlyStable is enabled)`);
+      return { success: true, response: void 0 };
+    }
+    await executeHook("before:twitter", config, dryRun);
+    try {
+      const rootPackageBase = readPackageJson(config.cwd);
+      if (!rootPackageBase) {
+        throw new Error("Failed to read root package.json");
+      }
+      logger.debug(`Project: ${rootPackageBase.name}`);
+      const releaseUrl = getReleaseUrl(config, tag);
+      logger.debug(`Release URL: ${releaseUrl || "none"}`);
+      const changelogUrl = config.social?.changelogUrl;
+      logger.debug(`Changelog URL: ${changelogUrl || "none"}`);
+      logger.debug(`Changelog generated (${changelog.length} chars)`);
+      const changelogSummary = extractChangelogSummary(changelog, 150);
+      logger.debug(`Changelog summary: ${changelogSummary.substring(0, 50)}...`);
+      const response = await postReleaseToTwitter({
+        template: config.social.twitter.template || config.templates.twitterMessage,
+        version: newVersion,
+        projectName: rootPackageBase.name,
+        changelog: changelogSummary,
+        releaseUrl,
+        changelogUrl,
+        credentials,
+        dryRun
+      });
+      await executeHook("success:twitter", config, dryRun);
+      return { success: true, response };
+    } catch (error) {
+      await executeHook("error:twitter", config, dryRun);
+      logger.error("Error posting to Twitter:", error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return { success: false, error: `Error posting to Twitter: ${errorMessage}` };
+    }
+  } catch (error) {
+    logger.error("Error during Twitter posting:", error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `Error during Twitter posting: ${errorMessage}` };
+  }
+}
+async function handleSlackPost({
+  config,
+  changelog,
+  dryRun,
+  newVersion,
+  tag
+}) {
+  const slackConfig = config.social?.slack;
+  if (!slackConfig?.enabled) {
+    logger.debug("Slack posting is disabled in configuration");
+    return { success: true, response: void 0 };
+  }
+  logger.debug("Slack posting is enabled");
+  try {
+    const token = getSlackToken({
+      socialCredentials: slackConfig.credentials,
+      tokenCredential: config.tokens?.slack
+    });
+    if (!token) {
+      logger.warn("Slack token not found. Set SLACK_TOKEN or RELIZY_SLACK_TOKEN environment variable or configure it in social.slack.credentials or tokens.slack.");
+      logger.info("Skipping Slack post");
+      return { success: false, error: "Slack token not found" };
+    }
+    logger.debug("Token found \u2713");
+    if (!slackConfig.channel) {
+      logger.warn("Slack channel not configured. Set it in social.slack.channel.");
+      logger.info("Skipping Slack post");
+      return { success: false, error: "Slack channel not configured" };
+    }
+    logger.debug(`Channel configured: ${slackConfig.channel}`);
+    logger.debug(`Preparing Slack message for release: ${tag} (${newVersion})`);
+    const onlyStable = slackConfig.onlyStable ?? true;
+    if (onlyStable && isPrerelease(newVersion)) {
+      logger.info(`Skipping Slack post for prerelease version ${newVersion} (social.slack.onlyStable is enabled)`);
+      return { success: true, response: void 0 };
+    }
+    try {
+      await executeHook("before:slack", config, dryRun);
+      const rootPackageBase = readPackageJson(config.cwd);
+      if (!rootPackageBase) {
+        throw new Error("Failed to read root package.json");
+      }
+      logger.debug(`Project: ${rootPackageBase.name}`);
+      const releaseUrl = getReleaseUrl(config, tag);
+      logger.debug(`Release URL: ${releaseUrl || "none"}`);
+      const changelogUrl = config.social?.changelogUrl;
+      logger.debug(`Changelog URL: ${changelogUrl || "none"}`);
+      logger.debug(`Changelog generated (${changelog.length} chars)`);
+      const template = slackConfig.template || config.templates.slackMessage;
+      const response = await postReleaseToSlack({
+        version: newVersion,
+        projectName: rootPackageBase.name,
+        changelog,
+        releaseUrl,
+        changelogUrl,
+        channel: slackConfig.channel,
+        token,
+        template,
+        dryRun
+      });
+      await executeHook("success:slack", config, dryRun);
+      return { success: true, response };
+    } catch (error) {
+      await executeHook("error:slack", config, dryRun);
+      logger.error("Error posting to Slack:", error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return { success: false, error: `Error posting to Slack: ${errorMessage}` };
+    }
+  } catch (error) {
+    logger.error("Error during Slack posting:", error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `Error during Slack posting: ${errorMessage}` };
+  }
+}
+async function social(options = {}) {
+  try {
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const config = await loadRelizyConfig({
+      configFile: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        from: options.from,
+        to: options.to,
+        logLevel: options.logLevel
+      }
+    });
+    logger.debug(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+    socialSafetyCheck({ config });
+    if (!config.release.social && !config.social?.twitter?.enabled && !config.social?.slack?.enabled) {
+      logger.warn("Social media posting is disabled in configuration.");
+      logger.info("Enable it with release.social: true or social.twitter.enabled: true or social.slack.enabled: true");
+      return { results: [], hasErrors: false };
+    }
+    await executeHook("before:social", config, dryRun);
+    const rootPackageRead = readPackageJson(config.cwd);
+    if (!rootPackageRead) {
+      throw new Error("Failed to read root package.json");
+    }
+    const newVersion = options.bumpResult?.newVersion || rootPackageRead.version;
+    const { from, to } = await resolveTags({
+      config,
+      step: "social",
+      newVersion,
+      pkg: rootPackageRead
+    });
+    const fromTag = options.bumpResult?.fromTag || from;
+    const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
+      config,
+      force: false,
+      suffix: void 0,
+      changelog: true,
+      from: fromTag,
+      to
+    });
+    const changelog = await generateChangelog({
+      pkg: rootPackage,
+      config,
+      dryRun,
+      newVersion,
+      minify: true
+    });
+    const twitterResponse = await handleTwitterPost({
+      config,
+      changelog,
+      dryRun,
+      newVersion,
+      tag: to
+    });
+    const slackResponse = await handleSlackPost({
+      config,
+      changelog,
+      dryRun,
+      newVersion,
+      tag: to
+    });
+    const results = [];
+    if (config.social?.twitter?.enabled) {
+      results.push({
+        platform: "twitter",
+        success: twitterResponse.success,
+        error: twitterResponse.success ? void 0 : twitterResponse.error
+      });
+    }
+    if (config.social?.slack?.enabled) {
+      results.push({
+        platform: "slack",
+        success: slackResponse.success,
+        error: slackResponse.success ? void 0 : slackResponse.error
+      });
+    }
+    const hasErrors = results.some((r) => !r.success);
+    if (hasErrors) {
+      await executeHook("error:social", config, dryRun);
+      logger.warn("Some social media posts failed");
+    } else {
+      logger.success("Social media posts completed!");
+      await executeHook("success:social", config, dryRun);
+    }
+    return { results, hasErrors };
+  } catch (error) {
+    logger.error("Error during social media posting:", error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      results: [{ platform: "unknown", success: false, error: errorMessage }],
+      hasErrors: true
+    };
+  }
+}
+
 function getReleaseConfig(options = {}) {
   return loadRelizyConfig({
     configFile: options.configName,
@@ -3483,7 +4174,8 @@ function getReleaseConfig(options = {}) {
         noVerify: options.noVerify,
         providerRelease: options.providerRelease,
         clean: options.clean,
-        gitTag: options.gitTag
+        gitTag: options.gitTag,
+        social: options.social
       },
       safetyCheck: options.safetyCheck
     }
@@ -3496,8 +4188,19 @@ async function releaseSafetyCheck({
   if (!config.safetyCheck) {
     return;
   }
-  providerReleaseSafetyCheck({ config, provider });
-  await publishSafetyCheck({ config });
+  logger.box("Safety checks");
+  logger.start("Start safety checks");
+  try {
+    await Promise.all([
+      providerReleaseSafetyCheck({ config, provider }),
+      publishSafetyCheck({ config }),
+      socialSafetyCheck({ config })
+    ]);
+    logger.success("Safety checks passed");
+  } catch (error) {
+    logger.error("Safety checks failed");
+    throw error;
+  }
 }
 async function release(options = {}) {
   const dryRun = options.dryRun ?? false;
@@ -3510,7 +4213,7 @@ async function release(options = {}) {
   await releaseSafetyCheck({ config, provider: options.provider });
   try {
     await executeHook("before:release", config, dryRun);
-    logger.box("Step 1/6: Bump versions");
+    logger.box("Bump versions");
     const bumpResult = await bump({
       type: config.bump.type,
       preid: config.bump.preid,
@@ -3525,7 +4228,7 @@ async function release(options = {}) {
       logger.debug("No packages bumped");
       return;
     }
-    logger.box("Step 2/6: Generate changelogs");
+    logger.box("Generate changelogs");
     if (config.release.changelog) {
       await changelog({
         from: config.from,
@@ -3543,7 +4246,32 @@ async function release(options = {}) {
     } else {
       logger.info("Skipping changelog generation (--no-changelog)");
     }
-    logger.box("Step 3/6: Commit changes and create tag");
+    logger.box("Publish packages to registry");
+    let publishResponse;
+    if (config.release.publish) {
+      try {
+        publishResponse = await publish({
+          registry: config.publish.registry,
+          tag: config.publish.tag,
+          access: config.publish.access,
+          otp: config.publish.otp,
+          bumpResult,
+          dryRun,
+          config,
+          configName: options.configName,
+          suffix: options.suffix,
+          force,
+          safetyCheck: false
+        });
+      } catch (error) {
+        logger.fail("Publish failed, rolling back modified files...");
+        await rollbackModifiedFiles({ config });
+        throw error;
+      }
+    } else {
+      logger.info("Skipping publish (--no-publish)");
+    }
+    logger.box("Commit changes and create tag");
     let createdTags = [];
     if (config.release.commit) {
       createdTags = await createCommitAndTags({
@@ -3557,7 +4285,7 @@ async function release(options = {}) {
     } else {
       logger.info("Skipping commit and tag (--no-commit)");
     }
-    logger.box("Step 4/6: Push changes and tags");
+    logger.box("Push changes and tags");
     if (config.release.push && config.release.commit) {
       await executeHook("before:push", config, dryRun);
       try {
@@ -3575,60 +4303,77 @@ async function release(options = {}) {
     } else {
       logger.info("Skipping push (--no-push or --no-commit)");
     }
-    logger.box("Step 5/6: Publish packages to registry");
-    let publishResponse;
-    if (config.release.publish) {
-      publishResponse = await publish({
-        registry: config.publish.registry,
-        tag: config.publish.tag,
-        access: config.publish.access,
-        otp: config.publish.otp,
-        bumpResult,
+    let provider = config.repo?.provider;
+    let postedReleases = [];
+    let providerError;
+    logger.box("Publish Git release");
+    if (config.release.providerRelease) {
+      logger.debug(`Provider from config: ${provider}`);
+      const response = await providerRelease({
+        from: config.from,
+        to: config.to,
+        token: options.token,
+        provider,
         dryRun,
         config,
+        logLevel: config.logLevel,
+        bumpResult,
         configName: options.configName,
+        force,
         suffix: options.suffix,
-        force
+        safetyCheck: false
       });
+      provider = response.detectedProvider;
+      postedReleases = response.postedReleases;
+      providerError = response.error;
     } else {
-      logger.info("Skipping publish (--no-publish)");
+      logger.info("Skipping release (--no-provider-release)");
     }
-    let provider = config.repo?.provider;
-    let postedReleases = [];
-    logger.box("Step 6/6: Publish Git release");
-    if (config.release.providerRelease) {
-      logger.debug(`Provider from config: ${provider}`);
-      try {
-        const response = await providerRelease({
-          from: config.from,
-          to: config.to,
-          token: options.token,
-          provider,
-          dryRun,
-          config,
-          logLevel: config.logLevel,
-          bumpResult,
-          configName: options.configName,
-          force,
-          suffix: options.suffix
-        });
-        provider = response.detectedProvider;
-        postedReleases = response.postedReleases;
-      } catch (error) {
-        logger.error("Error during release publication:", error);
-      }
+    logger.box("Post release to social media");
+    let socialResults;
+    if (config.release.social && (config.social?.twitter?.enabled || config.social?.slack?.enabled)) {
+      socialResults = await social({
+        from: config.from,
+        to: config.to,
+        config,
+        configName: options.configName,
+        bumpResult,
+        dryRun,
+        logLevel: config.logLevel,
+        safetyCheck: false
+        // Already checked in releaseSafetyCheck
+      });
     } else {
-      logger.info("Skipping release (--no-provider-release)");
+      logger.info("Skipping social media posts (--no-social or no social media enabled)");
     }
     const publishedPackageCount = publishResponse?.publishedPackages.length ?? 0;
     const versionDisplay = config.monorepo?.versionMode === "independent" ? `${bumpResult.bumpedPackages.length} packages bumped independently` : bumpResult.newVersion || readPackageJson(config.cwd)?.version;
+    let providerDisplay = "Disabled";
+    if (config.release.providerRelease) {
+      if (providerError) {
+        providerDisplay = `Failed: ${providerError}`;
+      } else {
+        providerDisplay = `${postedReleases.length} release${postedReleases.length !== 1 ? "s" : ""}`;
+      }
+    }
+    let socialDisplay = "Disabled";
+    if (config.release.social && socialResults) {
+      if (socialResults.hasErrors) {
+        const failed = socialResults.results.filter((r) => !r.success).map((r) => r.platform);
+        const succeeded = socialResults.results.filter((r) => r.success).map((r) => r.platform);
+        socialDisplay = `${succeeded.length} succeeded, ${failed.length} failed (${failed.join(", ")})`;
+      } else {
+        socialDisplay = `${socialResults.results.length} succeeded`;
+      }
+    }
     logger.box(`Release workflow completed!
 
 Version: ${versionDisplay ?? "Unknown"}
-Tag(s): ${createdTags.length ? createdTags.join(", ") : "No"}
+Tag(s): ${createdTags?.length ? createdTags.join(", ") : "None"}
 Pushed: ${config.release.push ? "Yes" : "Disabled"}
 Published packages: ${config.release.publish ? publishedPackageCount : "Disabled"}
-Published release: ${config.release.providerRelease ? postedReleases.length : "Disabled"}
+Provider release: ${providerDisplay}
+Social media: ${socialDisplay}
 Git provider: ${provider}`);
     await executeHook("success:release", config, dryRun);
   } catch (error) {
@@ -3638,4 +4383,4 @@ Git provider: ${provider}`);
   }
 }
 
-export { getPackagesOrBumpedPackages as $, github as A, createGitlabRelease as B, gitlab as C, detectPackageManager as D, determinePublishTag as E, getPackagesToPublishInSelectiveMode as F, getPackagesToPublishInIndependentMode as G, getAuthCommand as H, publishPackage as I, readPackageJson as J, getRootPackage as K, readPackages as L, getPackages as M, getPackageCommits as N, hasLernaJson as O, getIndependentTag as P, getLastStableTag as Q, getLastTag as R, getLastRepoTag as S, getLastPackageTag as T, resolveTags as U, executeHook as V, isInCI as W, getCIName as X, executeFormatCmd as Y, executeBuildCmd as Z, isBumpedPackage as _, providerRelease as a, isGraduatingToStableBetweenVersion as a0, determineSemverChange as a1, determineReleaseType as a2, writeVersion as a3, getPackageNewVersion as a4, updateLernaVersion as a5, extractVersionFromPackageTag as a6, isPrerelease as a7, isStableReleaseType as a8, isPrereleaseReleaseType as a9, isGraduating as aa, getPreid as ab, isChangedPreid as ac, getBumpedPackageIndependently as ad, confirmBump as ae, getBumpedIndependentPackages as af, shouldFilterPrereleaseTags as ag, extractVersionFromTag as ah, isTagVersionCompatibleWithCurrent as ai, bump as b, changelog as c, publishSafetyCheck as d, publish as e, getDefaultConfig as f, generateChangelog as g, defineConfig as h, getPackageDependencies 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 { getLastTag as $, rollbackModifiedFiles as A, getFirstCommit as B, getCurrentGitBranch as C, getCurrentGitRef as D, github as E, createGitlabRelease as F, gitlab as G, detectPackageManager as H, determinePublishTag as I, getPackagesToPublishInSelectiveMode as J, getPackagesToPublishInIndependentMode as K, getAuthCommand as L, publishPackage as M, readPackageJson as N, getRootPackage as O, readPackages as P, getPackages as Q, getPackageCommits as R, hasLernaJson as S, getSlackToken as T, formatChangelogForSlack as U, formatSlackMessage as V, postReleaseToSlack as W, extractChangelogSummary as X, getReleaseUrl as Y, getIndependentTag as Z, getLastStableTag as _, providerRelease as a, getLastRepoTag as a0, getLastPackageTag as a1, resolveTags as a2, getTwitterCredentials as a3, formatTweetMessage as a4, postReleaseToTwitter as a5, executeHook as a6, isInCI as a7, getCIName as a8, executeFormatCmd as a9, executeBuildCmd as aa, isBumpedPackage as ab, getPackagesOrBumpedPackages as ac, isGraduatingToStableBetweenVersion as ad, determineSemverChange as ae, determineReleaseType as af, writeVersion as ag, getPackageNewVersion as ah, updateLernaVersion as ai, extractVersionFromPackageTag as aj, isPrerelease as ak, isStableReleaseType as al, isPrereleaseReleaseType as am, isGraduating as an, getPreid as ao, isChangedPreid as ap, getBumpedPackageIndependently as aq, confirmBump as ar, getBumpedIndependentPackages as as, shouldFilterPrereleaseTags as at, extractVersionFromTag as au, isTagVersionCompatibleWithCurrent as av, bump as b, changelog as c, publishSafetyCheck as d, publish as e, social as f, generateChangelog as g, getDefaultConfig as h, defineConfig as i, getPackageDependencies as j, getDependentsOf as k, loadRelizyConfig as l, expandPackagesToBumpWithDependents as m, getGitStatus as n, checkGitStatusIfDirty as o, providerReleaseSafetyCheck as p, fetchGitTags as q, release as r, socialSafetyCheck as s, topologicalSort as t, detectGitProvider as u, parseGitRemoteUrl as v, writeChangelogToFile as w, getModifiedReleaseFilePatterns as x, createCommitAndTags as y, pushCommitAndTags as z };