relizy 0.3.0 → 1.0.0-beta.0

package/dist/shared/{relizy.B4guss__.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,
@@ -476,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;
   }
@@ -489,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;
 }
@@ -610,7 +610,6 @@ async function getPackagesOrBumpedPackages({
   }
   return await getPackages({
     config,
-    patterns: config.monorepo?.packages,
     suffix,
     force
   });
@@ -663,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;
@@ -670,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 {
@@ -906,7 +908,8 @@ async function generateMarkDown({
   config,
   from,
   to,
-  isFirstCommit
+  isFirstCommit,
+  minify
 }) {
   const typeGroups = groupBy(commits, "type");
   const markdown = [];
@@ -919,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
@@ -936,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);
@@ -948,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);
@@ -1028,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");
@@ -1055,1475 +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})`);
+  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}`);
+  }
+  return newVersion;
 }
-
-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: [],
-      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
-    },
-    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}`);
+function updateLernaVersion({
+  rootDir,
+  versionMode,
+  version,
+  dryRun = false
+}) {
+  const lernaJsonExists = hasLernaJson(rootDir);
+  if (!lernaJsonExists) {
+    return;
   }
-}
-async function resolveConfig(config, cwd) {
-  if (!config.repo) {
-    const resolvedRepoConfig = await resolveRepoConfig(cwd);
-    config.repo = {
-      ...resolvedRepoConfig,
-      provider: resolvedRepoConfig.provider
-    };
+  const lernaJsonPath = join(rootDir, "lerna.json");
+  if (!existsSync(lernaJsonPath)) {
+    return;
   }
-  if (typeof config.repo === "string") {
-    const resolvedRepoConfig = getRepoConfig(config.repo);
-    config.repo = {
-      ...resolvedRepoConfig,
-      provider: resolvedRepoConfig.provider
-    };
+  try {
+    logger.debug("Updating lerna.json version");
+    const content = readFileSync(lernaJsonPath, "utf8");
+    const lernaJson = JSON.parse(content);
+    const oldVersion = lernaJson.version;
+    if (lernaJson.version === "independent" || versionMode === "independent") {
+      logger.debug("Lerna version is independent or version mode is independent, skipping update");
+      return;
+    }
+    lernaJson.version = version;
+    if (dryRun) {
+      logger.info(`[dry-run] update lerna.json: ${oldVersion} \u2192 ${version}`);
+      return;
+    }
+    writeFileSync(lernaJsonPath, `${formatJson(lernaJson)}
+`, "utf8");
+    logger.success(`Updated lerna.json: ${oldVersion} \u2192 ${version}`);
+  } catch (error) {
+    logger.fail(`Unable to update lerna.json: ${error}`);
   }
-  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);
-    }
+function extractVersionFromPackageTag(tag) {
+  const atIndex = tag.lastIndexOf("@");
+  if (atIndex === -1) {
+    return null;
   }
-  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;
+  return tag.slice(atIndex + 1);
 }
-function defineConfig(config) {
-  return config;
+function isPrerelease(version) {
+  if (!version)
+    return false;
+  const prerelease = semver.prerelease(version);
+  return prerelease ? prerelease.length > 0 : false;
 }
-
-async function githubIndependentMode({
-  config,
-  dryRun,
-  bumpResult,
-  force,
-  suffix
-}) {
-  const repoConfig = config.repo;
-  if (!repoConfig) {
-    throw new Error("No repository configuration found. Please check your changelog config.");
-  }
-  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  if (!config.tokens.github && !config.repo?.token) {
-    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+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;
   }
-  const packages = await getPackagesOrBumpedPackages({
-    config,
-    bumpResult,
-    suffix,
-    force
-  });
-  logger.info(`Creating ${packages.length} GitHub release(s)`);
-  const postedReleases = [];
-  for (const pkg of packages) {
-    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
-    const from = config.from || pkg.fromTag;
-    const to = config.to || getIndependentTag({ version: newVersion, name: pkg.name });
-    if (!from) {
-      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
-      continue;
-    }
-    const toTag = dryRun ? "HEAD" : to;
-    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${toTag}`);
-    const changelog = await generateChangelog({
-      pkg,
-      config,
-      dryRun,
-      newVersion
-    });
-    const releaseBody = changelog.split("\n").slice(2).join("\n");
-    const release = {
-      tag_name: to,
-      name: to,
-      body: releaseBody,
-      prerelease: isPrerelease(newVersion)
-    };
-    logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
-    if (dryRun) {
-      logger.info(`[dry-run] Publish GitHub release for ${to}`);
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: release.prerelease
-      });
-    } else {
-      logger.debug(`Publishing release ${to} to GitHub...`);
-      await createGithubRelease({
-        ...config,
-        from,
-        to,
-        repo: repoConfig
-      }, release);
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: release.prerelease
-      });
-    }
+  return prerelease[0];
+}
+function isChangedPreid(currentVersion, targetPreid) {
+  if (!targetPreid || !isPrerelease(currentVersion)) {
+    return false;
   }
-  if (postedReleases.length === 0) {
-    logger.warn("No releases created");
-  } else {
-    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitHub!`);
+  const currentPreid = getPreid(currentVersion);
+  if (!currentPreid) {
+    return false;
   }
-  return postedReleases;
+  return currentPreid !== targetPreid;
 }
-async function githubUnified({
-  config,
-  dryRun,
-  rootPackage,
-  bumpResult
+function getBumpedPackageIndependently({
+  pkg,
+  dryRun
 }) {
-  const repoConfig = config.repo;
-  if (!repoConfig) {
-    throw new Error("No repository configuration found. Please check your changelog config.");
-  }
-  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  if (!config.tokens.github && !config.repo?.token) {
-    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
-  }
-  const 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 releaseBody = changelog.split("\n").slice(2).join("\n");
-  const release = {
-    tag_name: to,
-    name: to,
-    body: releaseBody,
-    prerelease: isPrerelease(to)
-  };
-  logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
-  logger.debug("Release details:", formatJson({
-    tag_name: release.tag_name,
-    name: release.name,
-    prerelease: release.prerelease
-  }));
-  if (dryRun) {
-    logger.info("[dry-run] Publish GitHub release for", release.tag_name);
-  } else {
-    logger.debug("Publishing release to GitHub...");
-    await createGithubRelease({
-      ...config,
-      from: bumpResult?.bumped && bumpResult.fromTag || "v0.0.0",
-      to,
-      repo: repoConfig
-    }, release);
+  logger.debug(`Analyzing ${pkg.name}`);
+  const currentVersion = pkg.version || "0.0.0";
+  const newVersion = pkg.newVersion;
+  if (!newVersion) {
+    return { bumped: false };
   }
-  logger.success(`Release ${to} published to GitHub!`);
-  return [{
-    name: to,
-    tag: to,
-    version: to,
-    prerelease: release.prerelease
-  }];
+  logger.debug(`Bumping ${pkg.name} from ${currentVersion} to ${newVersion}`);
+  writeVersion(pkg.path, newVersion, dryRun);
+  return { bumped: true, newVersion, oldVersion: currentVersion };
 }
-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
-        }
-      }
-    });
-    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");
+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("");
     }
-    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({
-  config,
-  release,
-  dryRun
+function displayUnifiedModePackages({
+  packages,
+  newVersion,
+  force
 }) {
-  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)}`
-        }
-      };
-    }
-    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)
+  logger.log(`${packages.length} package(s):`);
+  packages.forEach((pkg) => {
+    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (${pkg.commits.length} commits) ${force ? "(force)" : ""}`);
+  });
+  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)`);
     });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`GitLab API error (${response.status}): ${errorText}`);
+    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 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;
   }
 }
-async function gitlabIndependentMode({
-  config,
-  dryRun,
-  bumpResult,
-  suffix,
+function displayIndependentModePackages({
+  packages,
   force
 }) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const packages = await getPackagesOrBumpedPackages({
-    config,
-    bumpResult,
-    suffix,
-    force
-  });
-  logger.info(`Creating ${packages.length} GitLab release(s) for independent packages`);
-  logger.debug("Getting current branch...");
-  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
-    noSuccess: true,
-    noStdout: true,
-    logLevel: config.logLevel,
-    cwd: config.cwd
-  });
-  const postedReleases = [];
-  for (const pkg of packages) {
-    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
-    const from = config.from || pkg.fromTag;
-    const to = getIndependentTag({ version: newVersion, name: pkg.name });
-    if (!from) {
-      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
-      continue;
-    }
-    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${to}`);
-    const changelog = await generateChangelog({
-      pkg,
-      config,
-      dryRun,
-      newVersion
+  if (force) {
+    logger.log(`${packages.length} package(s):`);
+    packages.forEach((pkg) => {
+      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} (force)`);
     });
-    if (!changelog) {
-      logger.warn(`No changelog found for ${pkg.name}`);
-      continue;
+    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 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
+    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)" : ""}`);
       });
-      postedReleases.push({
-        name: pkg.name,
-        tag: release.tag_name,
-        version: newVersion,
-        prerelease: isPrerelease(newVersion)
+      logger.log("");
+    }
+    if (packagesAsGraduation.length > 0) {
+      logger.log(`${packagesAsGraduation.length} graduation package(s):`);
+      packagesAsGraduation.forEach((pkg) => {
+        pkg.newVersion && logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${pkg.newVersion} ${force ? "(force)" : ""}`);
       });
+      logger.log("");
     }
   }
-  if (postedReleases.length === 0) {
-    logger.warn("No releases created");
-  } else {
-    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitLab!`);
-  }
-  return postedReleases;
 }
-async function gitlabUnified({
+async function confirmBump({
+  versionMode,
   config,
-  dryRun,
-  rootPackage,
-  bumpResult
+  packages,
+  force,
+  currentVersion,
+  newVersion,
+  dryRun
 }) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const newVersion = bumpResult?.newVersion || rootPackage.newVersion || rootPackage.version;
-  const to = config.templates.tagBody.replace("{{newVersion}}", newVersion);
-  const changelog = await generateChangelog({
-    pkg: rootPackage,
-    config,
-    dryRun,
-    newVersion
-  });
-  const releaseBody = changelog.split("\n").slice(2).join("\n");
-  logger.debug("Getting current branch...");
-  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
-    noSuccess: true,
-    noStdout: true,
-    logLevel: config.logLevel,
-    cwd: config.cwd
-  });
-  const release = {
-    tag_name: to,
-    name: to,
-    description: releaseBody,
-    ref: currentBranch.trim()
-  };
-  logger.info(`Creating release for ${to} (ref: ${release.ref})`);
-  logger.debug("Release details:", formatJson({
-    tag_name: release.tag_name,
-    name: release.name,
-    ref: release.ref
-  }));
-  if (dryRun) {
-    logger.info("[dry-run] Publish GitLab release for", release.tag_name);
-  } else {
-    logger.debug("Publishing release to GitLab...");
-    await createGitlabRelease({
-      config,
-      release,
-      dryRun
-    });
+  if (packages.length === 0) {
+    logger.debug("No packages to bump");
+    return;
   }
-  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 lernaJsonExists = hasLernaJson(config.cwd);
+  logger.log("");
+  logger.info(`${dryRun ? "[dry-run] " : ""}The following packages will be updated:
+`);
+  displayRootAndLernaUpdates({
+    versionMode,
+    currentVersion,
+    newVersion,
+    lernaJsonExists,
+    dryRun
+  });
+  if (versionMode === "unified") {
+    if (!newVersion) {
+      throw new Error("Cannot confirm bump in unified mode without a new version");
     }
-    const 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
+    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 });
+  }
+  try {
+    const confirmed = await confirm({
+      message: `${dryRun ? "[dry-run] " : ""}Do you want to proceed with these version updates?`,
+      default: true
     });
+    if (!confirmed) {
+      logger.log("");
+      logger.fail("Bump refused");
+      process.exit(0);
+    }
   } catch (error) {
-    logger.error("Error publishing 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("");
 }
-
-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;
-}
-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;
+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
+    });
+    if (result.bumped) {
+      bumpedPackages.push({
+        ...pkgToBump,
+        version: result.oldVersion
+      });
     }
   }
-  return hasMajor ? "major" : hasMinor ? "minor" : hasPatch ? "patch" : void 0;
+  return bumpedPackages;
 }
-function detectReleaseTypeFromCommits(commits, types) {
-  return determineSemverChange(commits, types);
+function shouldFilterPrereleaseTags(currentVersion, graduating) {
+  return !isPrerelease(currentVersion) && !graduating;
 }
-function validatePrereleaseDowngrade(currentVersion, targetPreid, configuredType) {
-  if (configuredType !== "prerelease" || !targetPreid || !isPrerelease(currentVersion)) {
-    return;
+function extractVersionFromTag(tag, packageName) {
+  if (!tag) {
+    return null;
   }
-  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 (packageName) {
+    const prefix = `${packageName}@`;
+    if (tag.startsWith(prefix)) {
+      return tag.slice(prefix.length);
+    }
   }
-}
-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 atIndex = tag.lastIndexOf("@");
+  if (atIndex !== -1) {
+    return tag.slice(atIndex + 1);
   }
-  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
-  if (!detectedType && !force) {
-    logger.debug("No significant commits found, skipping bump");
-    return void 0;
+  if (tag.startsWith("v") && /^v\d/.test(tag)) {
+    return tag.slice(1);
   }
-  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;
+  if (/^\d+\.\d+\.\d+/.test(tag)) {
+    return tag;
   }
-  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, types) : void 0;
-  if (!detectedType) {
-    logger.debug("No significant commits found, using prepatch as default");
-    return "prepatch";
+  return null;
+}
+function isTagVersionCompatibleWithCurrent(tagVersion, currentVersion) {
+  try {
+    const tagMajor = semver.major(tagVersion);
+    const currentMajor = semver.major(currentVersion);
+    return tagMajor <= currentMajor;
+  } catch {
+    return false;
   }
-  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 getIndependentTag({ version, name }) {
+  return `${name}@${version}`;
 }
-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})`);
+async function getLastStableTag({ logLevel, cwd }) {
+  const { stdout } = await execPromise(
+    `git tag --sort=-creatordate | grep -E '^[^0-9]*[0-9]+\\.[0-9]+\\.[0-9]+$' | head -n 1`,
+    {
+      logLevel,
+      noStderr: true,
+      noStdout: true,
+      noSuccess: true,
+      cwd
     }
-    return "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";
+  );
+  const lastTag = stdout.trim();
+  logger.debug("Last stable tag:", lastTag || "No stable tags found");
+  return lastTag;
 }
-function handleExplicitReleaseType({
-  releaseType,
-  currentVersion
-}) {
-  const isCurrentPrerelease = isPrerelease(currentVersion);
-  const isGraduatingToStable = isCurrentPrerelease && isStableReleaseType(releaseType);
-  if (isGraduatingToStable) {
-    logger.debug(`Graduating from prerelease ${currentVersion} to stable with type: ${releaseType}`);
-  } else {
-    logger.debug(`Using explicit release type: ${releaseType}`);
+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
+      }
+    );
+    const tags = stdout.trim().split("\n").filter((tag) => tag.length > 0);
+    logger.debug(`Retrieved ${tags.length} recent repo tags`);
+    return tags;
+  } catch {
+    return [];
   }
-  return releaseType;
 }
-function determineReleaseType({
-  currentVersion,
-  commits,
-  releaseType,
-  preid,
-  types,
-  force
+async function getAllRecentPackageTags({
+  packageName,
+  limit = 50,
+  logLevel,
+  cwd
 }) {
-  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 });
+  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 [];
   }
-  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] Updated ${packageJson.name}: ${oldVersion} \u2192 ${newVersion}`);
-      return;
+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;
     }
-    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}`);
+    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
+    });
   }
+  if (options?.onlyStable) {
+    return getLastStableTag({ logLevel: options?.logLevel, cwd: options?.cwd });
+  }
+  return getLastTag({ logLevel: options?.logLevel, cwd: options?.cwd });
 }
-function getPackageNewVersion({
-  name,
+async function getLastRepoTagWithFiltering({
   currentVersion,
-  releaseType,
-  preid,
-  suffix
+  onlyStable,
+  logLevel,
+  cwd
 }) {
-  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}`);
+  const recentTags = await getAllRecentRepoTags({ limit: 50, logLevel, cwd });
+  if (recentTags.length === 0) {
+    logger.debug("No tags found in repository");
+    return null;
   }
-  if (isChangedPreid(currentVersion, preid)) {
-    logger.debug(`Graduating "${name}" from ${getPreid(currentVersion)} to ${preid}`);
+  const compatibleTags = filterCompatibleTags({
+    tags: recentTags,
+    currentVersion,
+    onlyStable
+  });
+  if (compatibleTags.length === 0) {
+    logger.debug("No compatible tags found");
+    return null;
   }
-  return newVersion;
+  const lastTag = compatibleTags[0];
+  logger.debug(`Last compatible repo tag: ${lastTag}`);
+  return lastTag;
 }
-function updateLernaVersion({
-  rootDir,
-  versionMode,
-  version,
-  dryRun = false
+async function getLastPackageTag({
+  packageName,
+  onlyStable,
+  currentVersion,
+  logLevel,
+  cwd
 }) {
-  const lernaJsonExists = hasLernaJson(rootDir);
-  if (!lernaJsonExists) {
-    return;
-  }
-  const lernaJsonPath = join(rootDir, "lerna.json");
-  if (!existsSync(lernaJsonPath)) {
-    return;
+  if (currentVersion) {
+    return getLastPackageTagWithFiltering({
+      packageName,
+      currentVersion,
+      onlyStable: onlyStable ?? false,
+      logLevel,
+      cwd
+    });
   }
   try {
-    logger.debug("Updating lerna.json version");
-    const content = readFileSync(lernaJsonPath, "utf8");
-    const lernaJson = JSON.parse(content);
-    const oldVersion = lernaJson.version;
-    if (lernaJson.version === "independent" || versionMode === "independent") {
-      logger.debug("Lerna version is independent or version mode is independent, skipping update");
-      return;
-    }
-    lernaJson.version = version;
-    if (dryRun) {
-      logger.info(`[dry-run] update lerna.json: ${oldVersion} \u2192 ${version}`);
-      return;
+    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
+    let grepPattern;
+    if (onlyStable) {
+      grepPattern = `^${escapedPackageName}@[0-9]+\\.[0-9]+\\.[0-9]+$`;
+    } else {
+      grepPattern = `^${escapedPackageName}@`;
     }
-    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) {
+    const { stdout } = await execPromise(
+      `git tag --sort=-creatordate | grep -E '${grepPattern}' | sed -n '1p'`,
+      {
+        logLevel,
+        noStderr: true,
+        noStdout: true,
+        noSuccess: true,
+        cwd
+      }
+    );
+    const tag = stdout.trim();
+    return tag || null;
+  } catch {
     return null;
   }
-  return 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) {
+async function getLastPackageTagWithFiltering({
+  packageName,
+  currentVersion,
+  onlyStable,
+  logLevel,
+  cwd
+}) {
+  const recentTags = await getAllRecentPackageTags({
+    packageName,
+    limit: 50,
+    logLevel,
+    cwd
+  });
+  if (recentTags.length === 0) {
+    logger.debug(`No tags found for package ${packageName}`);
     return null;
   }
-  return prerelease[0];
-}
-function isChangedPreid(currentVersion, targetPreid) {
-  if (!targetPreid || !isPrerelease(currentVersion)) {
-    return false;
-  }
-  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 };
+  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(`Bumping ${pkg.name} from ${currentVersion} to ${newVersion}`);
-  writeVersion(pkg.path, newVersion, dryRun);
-  return { bumped: true, newVersion, oldVersion: currentVersion };
+  const lastTag = compatibleTags[0];
+  logger.debug(`Last compatible package tag for ${packageName}: ${lastTag}`);
+  return lastTag;
 }
-function displayRootAndLernaUpdates({
-  versionMode,
+async function resolveFromTagIndependent({
+  cwd,
+  packageName,
   currentVersion,
-  newVersion,
-  dryRun,
-  lernaJsonExists
+  graduating,
+  logLevel
 }) {
-  if (versionMode !== "independent" && currentVersion && newVersion) {
-    logger.log(`${dryRun ? "[dry-run] " : ""}Root package.json: ${currentVersion} \u2192 ${newVersion}`);
-    logger.log("");
-    if (lernaJsonExists) {
-      logger.log(`${dryRun ? "[dry-run] " : ""}lerna.json: ${currentVersion} \u2192 ${newVersion}`);
-      logger.log("");
-    }
+  const filterPrereleases = shouldFilterPrereleaseTags(currentVersion, graduating);
+  const onlyStable = graduating || filterPrereleases;
+  const lastPackageTag = await getLastPackageTag({
+    packageName,
+    currentVersion,
+    onlyStable,
+    logLevel,
+    cwd
+  });
+  if (!lastPackageTag) {
+    return getFirstCommit(cwd);
   }
+  return lastPackageTag;
 }
-function displayUnifiedModePackages({
-  packages,
-  newVersion,
-  force
+async function resolveFromTagUnified({
+  config,
+  currentVersion,
+  graduating,
+  logLevel
 }) {
-  logger.log(`${packages.length} package(s):`);
-  packages.forEach((pkg) => {
-    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} ${force ? "(force)" : ""}`);
-  });
-  logger.log("");
+  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 displaySelectiveModePackages({
-  packages,
-  newVersion,
-  force
+async function resolveFromTag({
+  config,
+  versionMode,
+  step,
+  packageName,
+  currentVersion,
+  graduating,
+  logLevel
 }) {
-  if (force) {
-    logger.log(`${packages.length} package(s):`);
-    packages.forEach((pkg) => {
-      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion} (force)`);
+  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
     });
-    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("");
-    }
+    from = await resolveFromTagUnified({
+      config,
+      currentVersion,
+      graduating,
+      logLevel
+    });
   }
+  logger.debug(`[${versionMode}](${step}) Using from tag: ${from}`);
+  return config.from || from;
 }
-function displayIndependentModePackages({
-  packages,
-  force
+function resolveToTag({
+  config,
+  versionMode,
+  newVersion,
+  step,
+  packageName
 }) {
-  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("");
+  const isUntaggedStep = step === "bump" || step === "changelog";
+  let to;
+  if (isUntaggedStep) {
+    to = getCurrentGitRef(config.cwd);
+  } else if (versionMode === "independent") {
+    if (!packageName) {
+      throw new Error("Package name is required for independent version mode");
     }
-    if (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("");
+    if (!newVersion) {
+      throw new Error("New version is required for independent version mode");
     }
+    to = getIndependentTag({ version: newVersion, name: packageName });
+  } else {
+    to = newVersion ? config.templates.tagBody.replace("{{newVersion}}", newVersion) : getCurrentGitRef(config.cwd);
   }
+  logger.debug(`[${versionMode}](${step}) Using to tag: ${to}`);
+  return config.to || to;
 }
-async function confirmBump({
-  versionMode,
+async function resolveTags({
   config,
-  packages,
-  force,
-  currentVersion,
-  newVersion,
-  dryRun
+  step,
+  pkg,
+  newVersion
 }) {
-  if (packages.length === 0) {
-    logger.debug("No packages to bump");
-    return;
-  }
-  const lernaJsonExists = hasLernaJson(config.cwd);
-  logger.log("");
-  logger.info(`${dryRun ? "[dry-run] " : ""}The following packages will be updated:
-`);
-  displayRootAndLernaUpdates({
+  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
+  });
+  const to = resolveToTag({
+    config,
     versionMode,
-    currentVersion,
     newVersion,
-    lernaJsonExists,
-    dryRun
+    step,
+    packageName: pkg.name
   });
-  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(`[${versionMode}](${step}) Using tags: ${from} \u2192 ${to}`);
+  return { from, to };
+}
+
+function fromTagIsFirstCommit(fromTag, cwd) {
+  return fromTag === getFirstCommit(cwd);
+}
+async function generateChangelog({
+  pkg,
+  config,
+  dryRun,
+  newVersion,
+  minify
+}) {
+  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");
+  }
+  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);
+    let changelog = generatedChangelog;
+    if (pkg.commits.length === 0) {
+      changelog = `${changelog}
+
+${config.templates.emptyChangelogContent}`;
+    }
+    const changelogResult = await executeHook("generate:changelog", config, dryRun, {
+      commits: pkg.commits,
+      changelog
+    });
+    changelog = changelogResult || changelog;
+    logger.verbose(`Output changelog for ${pkg.name}:
+${changelog}`);
+    logger.debug(`Changelog generated for ${pkg.name} (${pkg.commits.length} commits)`);
+    logger.verbose(`Final changelog for ${pkg.name}:
+
+${changelog}
+
+`);
+    if (dryRun) {
+      logger.info(`[dry-run] ${pkg.name} - Generate changelog ${fromTag}...${toTag}`);
     }
+    return changelog;
   } catch (error) {
-    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);
+    throw new Error(`Error generating changelog for ${pkg.name} (${fromTag}...${toTag}): ${error}`);
   }
-  logger.log("");
 }
-function getBumpedIndependentPackages({
-  packages,
-  dryRun
+function writeChangelogToFile({
+  cwd,
+  pkg,
+  changelog,
+  dryRun = false
 }) {
-  const bumpedPackages = [];
-  for (const pkgToBump of packages) {
-    logger.debug(`Bumping ${pkgToBump.name} from ${pkgToBump.version} to ${pkgToBump.newVersion} (reason: ${pkgToBump.reason})`);
-    const result = getBumpedPackageIndependently({
-      pkg: pkgToBump,
-      dryRun
-    });
-    if (result.bumped) {
-      bumpedPackages.push({
-        ...pkgToBump,
-        version: result.oldVersion
-      });
-    }
-  }
-  return bumpedPackages;
-}
-function shouldFilterPrereleaseTags(currentVersion, graduating) {
-  return !isPrerelease(currentVersion) && !graduating;
-}
-function extractVersionFromTag(tag, packageName) {
-  if (!tag) {
-    return null;
-  }
-  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);
+  const changelogPath = join(pkg.path, "CHANGELOG.md");
+  let existingChangelog = "";
+  if (existsSync(changelogPath)) {
+    existingChangelog = readFileSync(changelogPath, "utf8");
   }
-  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;
+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
+      }
+    },
+    logLevel: "default",
+    safetyCheck: true
+  };
 }
-async function getLastTag({ logLevel, cwd }) {
-  const { stdout } = await execPromise(`git tag --sort=-creatordate | head -n 1`, {
-    logLevel,
-    noStderr: true,
-    noStdout: true,
-    noSuccess: true,
-    cwd
-  });
-  const lastTag = stdout.trim();
-  logger.debug("Last tag:", lastTag || "No tags found");
-  return lastTag;
+function setupLogger(logLevel) {
+  if (logLevel) {
+    logger.setLevel(logLevel);
+    logger.debug(`Log level set to: ${logLevel}`);
+  }
 }
-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
-      }
-    );
-    const tags = stdout.trim().split("\n").filter((tag) => tag.length > 0);
-    logger.debug(`Retrieved ${tags.length} recent repo tags`);
-    return tags;
-  } catch {
-    return [];
+async function resolveConfig(config, cwd) {
+  if (!config.repo) {
+    const resolvedRepoConfig = await resolveRepoConfig(cwd);
+    config.repo = {
+      ...resolvedRepoConfig,
+      provider: resolvedRepoConfig.provider
+    };
+  }
+  if (typeof config.repo === "string") {
+    const resolvedRepoConfig = getRepoConfig(config.repo);
+    config.repo = {
+      ...resolvedRepoConfig,
+      provider: resolvedRepoConfig.provider
+    };
   }
+  return config;
 }
-async function 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 [];
+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);
+    }
   }
+  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 filterCompatibleTags({
-  tags,
-  currentVersion,
-  onlyStable,
-  packageName
+function defineConfig(config) {
+  return config;
+}
+
+async function githubIndependentMode({
+  config,
+  dryRun,
+  bumpResult,
+  force,
+  suffix
 }) {
-  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;
+  const repoConfig = config.repo;
+  if (!repoConfig) {
+    throw new Error("No repository configuration found. Please check your changelog config.");
+  }
+  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github && !config.repo?.token) {
+    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+  }
+  const packages = await getPackagesOrBumpedPackages({
+    config,
+    bumpResult,
+    suffix,
+    force
   });
-  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
+  logger.info(`Creating ${packages.length} GitHub release(s)`);
+  const postedReleases = [];
+  for (const pkg of packages) {
+    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
+    const from = config.from || pkg.fromTag;
+    const to = config.to || getIndependentTag({ version: newVersion, name: pkg.name });
+    if (!from) {
+      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
+      continue;
+    }
+    const toTag = dryRun ? "HEAD" : to;
+    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${toTag}`);
+    const changelog = await generateChangelog({
+      pkg,
+      config,
+      dryRun,
+      newVersion
     });
+    const releaseBody = changelog.split("\n").slice(2).join("\n");
+    const release = {
+      tag_name: to,
+      name: to,
+      body: releaseBody,
+      prerelease: isPrerelease(newVersion)
+    };
+    logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
+    if (dryRun) {
+      logger.info(`[dry-run] Publish GitHub release for ${to}`);
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: newVersion,
+        prerelease: release.prerelease
+      });
+    } else {
+      logger.debug(`Publishing release ${to} to GitHub...`);
+      await createGithubRelease({
+        ...config,
+        from,
+        to,
+        repo: repoConfig
+      }, release);
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: newVersion,
+        prerelease: release.prerelease
+      });
+    }
   }
-  if (options?.onlyStable) {
-    return getLastStableTag({ logLevel: options?.logLevel, cwd: options?.cwd });
+  if (postedReleases.length === 0) {
+    logger.warn("No releases created");
+  } else {
+    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitHub!`);
   }
-  return getLastTag({ logLevel: options?.logLevel, cwd: options?.cwd });
+  return postedReleases;
 }
-async function getLastRepoTagWithFiltering({
-  currentVersion,
-  onlyStable,
-  logLevel,
-  cwd
+async function githubUnified({
+  config,
+  dryRun,
+  rootPackage,
+  bumpResult
 }) {
-  const recentTags = await getAllRecentRepoTags({ limit: 50, logLevel, cwd });
-  if (recentTags.length === 0) {
-    logger.debug("No tags found in repository");
-    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
+  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github && !config.repo?.token) {
+    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+  }
+  const newVersion = bumpResult?.newVersion || rootPackage.version;
+  const to = config.to || config.templates.tagBody.replace("{{newVersion}}", newVersion);
+  const changelog = await generateChangelog({
+    pkg: rootPackage,
+    config,
+    dryRun,
+    newVersion
   });
-  if (compatibleTags.length === 0) {
-    logger.debug("No compatible tags found");
-    return null;
+  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);
   }
-  const lastTag = compatibleTags[0];
-  logger.debug(`Last compatible repo tag: ${lastTag}`);
-  return lastTag;
+  logger.success(`Release ${to} published to GitHub!`);
+  return [{
+    name: to,
+    tag: to,
+    version: to,
+    prerelease: release.prerelease
+  }];
 }
-async function getLastPackageTag({
-  packageName,
-  onlyStable,
-  currentVersion,
-  logLevel,
-  cwd
-}) {
-  if (currentVersion) {
-    return getLastPackageTagWithFiltering({
-      packageName,
-      currentVersion,
-      onlyStable: onlyStable ?? false,
-      logLevel,
-      cwd
+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 createGitlabRelease({
+  config,
+  release,
+  dryRun
+}) {
+  const token = config.tokens.gitlab || config.repo?.token;
+  if (!token && !dryRun) {
+    throw new Error(
+      "No GitLab token found. Set GITLAB_TOKEN or CI_JOB_TOKEN environment variable or configure tokens.gitlab"
+    );
+  }
+  const repoConfig = config.repo?.repo;
+  if (!repoConfig) {
+    throw new Error("No repository URL found in config");
   }
+  logger.debug(`Parsed repository URL: ${repoConfig}`);
+  const projectPath = encodeURIComponent(repoConfig);
+  const gitlabDomain = config.repo?.domain || "gitlab.com";
+  const apiUrl = `https://${gitlabDomain}/api/v4/projects/${projectPath}/releases`;
+  logger.info(`Creating GitLab release at: ${apiUrl}`);
+  const payload = {
+    tag_name: release.tag_name,
+    name: release.name || release.tag_name,
+    description: release.description || "",
+    ref: release.ref || "main"
+  };
   try {
-    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
-    let grepPattern;
-    if (onlyStable) {
-      grepPattern = `^${escapedPackageName}@[0-9]+\\.[0-9]+\\.[0-9]+$`;
-    } else {
-      grepPattern = `^${escapedPackageName}@`;
+    if (dryRun) {
+      logger.info("[dry-run] GitLab release:", formatJson(payload));
+      return {
+        tag_name: release.tag_name,
+        name: release.name || release.tag_name,
+        description: release.description || "",
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        released_at: (/* @__PURE__ */ new Date()).toISOString(),
+        _links: {
+          self: `${apiUrl}/${encodeURIComponent(release.tag_name)}`
+        }
+      };
     }
-    const { 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(`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;
   }
 }
-async function getLastPackageTagWithFiltering({
-  packageName,
-  currentVersion,
-  onlyStable,
-  logLevel,
-  cwd
+async function gitlabIndependentMode({
+  config,
+  dryRun,
+  bumpResult,
+  suffix,
+  force
 }) {
-  const recentTags = await getAllRecentPackageTags({
-    packageName,
-    limit: 50,
-    logLevel,
-    cwd
+  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  const packages = await getPackagesOrBumpedPackages({
+    config,
+    bumpResult,
+    suffix,
+    force
   });
-  if (recentTags.length === 0) {
-    logger.debug(`No tags found for package ${packageName}`);
-    return null;
-  }
-  const compatibleTags = filterCompatibleTags({
-    tags: recentTags,
-    currentVersion,
-    onlyStable,
-    packageName
+  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
   });
-  if (compatibleTags.length === 0) {
-    logger.debug(`No compatible tags found for package ${packageName}`);
-    return null;
+  const postedReleases = [];
+  for (const pkg of packages) {
+    const newVersion = isBumpedPackage(pkg) && pkg.newVersion || pkg.version;
+    const from = config.from || pkg.fromTag;
+    const to = getIndependentTag({ version: newVersion, name: pkg.name });
+    if (!from) {
+      logger.warn(`No from tag found for ${pkg.name}, skipping release`);
+      continue;
+    }
+    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${to}`);
+    const changelog = await generateChangelog({
+      pkg,
+      config,
+      dryRun,
+      newVersion
+    });
+    if (!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)
+      });
+    }
   }
-  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
-  });
-  if (!lastPackageTag) {
-    return getFirstCommit(cwd);
+  if (postedReleases.length === 0) {
+    logger.warn("No releases created");
+  } else {
+    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitLab!`);
   }
-  return lastPackageTag;
+  return postedReleases;
 }
-async function resolveFromTagUnified({
+async function gitlabUnified({
   config,
-  currentVersion,
-  graduating,
-  logLevel
+  dryRun,
+  rootPackage,
+  bumpResult
 }) {
-  const filterPrereleases = shouldFilterPrereleaseTags(currentVersion, graduating);
-  const onlyStable = graduating || filterPrereleases;
-  const from = await getLastRepoTag({
-    currentVersion,
-    onlyStable,
-    logLevel,
+  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  const newVersion = bumpResult?.newVersion || rootPackage.newVersion || rootPackage.version;
+  const to = config.templates.tagBody.replace("{{newVersion}}", newVersion);
+  const changelog = await generateChangelog({
+    pkg: rootPackage,
+    config,
+    dryRun,
+    newVersion
+  });
+  const releaseBody = changelog.split("\n").slice(2).join("\n");
+  logger.debug("Getting current branch...");
+  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
+    noSuccess: true,
+    noStdout: true,
+    logLevel: config.logLevel,
     cwd: config.cwd
-  }) || getFirstCommit(config.cwd);
-  return from;
-}
-async function resolveFromTag({
-  config,
-  versionMode,
-  step,
-  packageName,
-  currentVersion,
-  graduating,
-  logLevel
-}) {
-  let from;
-  if (versionMode === "independent") {
-    if (!packageName) {
-      throw new Error("Package name is required for independent version mode");
-    }
-    from = await resolveFromTagIndependent({
-      cwd: config.cwd,
-      packageName,
-      currentVersion,
-      graduating,
-      logLevel
-    });
+  });
+  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 {
-    from = await resolveFromTagUnified({
+    logger.debug("Publishing release to GitLab...");
+    await createGitlabRelease({
       config,
-      currentVersion,
-      graduating,
-      logLevel
+      release,
+      dryRun
     });
   }
-  logger.debug(`[${versionMode}](${step}) Using from tag: ${from}`);
-  return config.from || from;
+  logger.success(`Release ${to} published to GitLab!`);
+  return [{
+    name: to,
+    tag: to,
+    version: to,
+    prerelease: isPrerelease(newVersion)
+  }];
 }
-function resolveToTag({
-  config,
-  versionMode,
-  newVersion,
-  step,
-  packageName
-}) {
-  const isUntaggedStep = step === "bump" || step === "changelog";
-  let to;
-  if (isUntaggedStep) {
-    to = getCurrentGitRef(config.cwd);
-  } else if (versionMode === "independent") {
-    if (!packageName) {
-      throw new Error("Package name is required for independent version mode");
+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
+      });
     }
-    if (!newVersion) {
-      throw new Error("New version is required for independent version mode");
+    const rootPackageBase = readPackageJson(config.cwd);
+    if (!rootPackageBase) {
+      throw new Error("Failed to read root package.json");
     }
-    to = getIndependentTag({ version: newVersion, name: packageName });
-  } else {
-    to = newVersion ? config.templates.tagBody.replace("{{newVersion}}", newVersion) : getCurrentGitRef(config.cwd);
+    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;
   }
-  logger.debug(`[${versionMode}](${step}) Using to tag: ${to}`);
-  return config.to || to;
-}
-async function resolveTags({
-  config,
-  step,
-  pkg,
-  newVersion
-}) {
-  const versionMode = config.monorepo?.versionMode || "standalone";
-  const logLevel = config.logLevel;
-  logger.debug(`[${versionMode}](${step}) Resolving tags`);
-  const releaseType = config.bump.type;
-  const 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
-  });
-  const to = resolveToTag({
-    config,
-    versionMode,
-    newVersion,
-    step,
-    packageName: pkg.name
-  });
-  logger.debug(`[${versionMode}](${step}) Using tags: ${from} \u2192 ${to}`);
-  return { from, to };
 }
 
 let sessionOtp;
@@ -2712,7 +2744,7 @@ async function handleOtpError() {
     logger.debug("OTP received, retrying publish...");
     return otp;
   } catch (promptError) {
-    logger.error("Failed to get OTP");
+    logger.fail("Failed to get OTP");
     throw promptError;
   }
 }
@@ -2756,69 +2788,362 @@ function getAuthCommand({
   });
   return `${packageManager} ${args.join(" ")}`;
 }
-function getPublishCommand({
-  packageManager,
-  tag,
-  config,
-  otp,
-  dryRun
+function getPublishCommand({
+  packageManager,
+  tag,
+  config,
+  otp,
+  dryRun
+}) {
+  const args = getCommandArgs({
+    packageManager,
+    tag,
+    config,
+    otp,
+    dryRun,
+    type: "publish"
+  });
+  const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
+  return `${baseCommand} ${args.join(" ")}`;
+}
+async function publishPackage({
+  pkg,
+  config,
+  packageManager,
+  dryRun
+}) {
+  const tag = determinePublishTag(pkg.newVersion || pkg.version, config.publish.tag);
+  const packageNameAndVersion = getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version });
+  logger.debug(`Building publish command for ${pkg.name}`);
+  let dynamicOtp;
+  const maxAttempts = 2;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const command = getPublishCommand({
+        packageManager,
+        tag,
+        config,
+        otp: dynamicOtp,
+        dryRun
+      });
+      process.chdir(pkg.path);
+      await executePublishCommand({
+        command,
+        packageNameAndVersion,
+        packageManager,
+        pkg,
+        config,
+        dryRun,
+        tag
+      });
+      if (dynamicOtp && !sessionOtp) {
+        sessionOtp = dynamicOtp;
+        logger.debug("OTP stored for session");
+      }
+      return;
+    } catch (error) {
+      if (isOtpError(error) && attempt < maxAttempts - 1) {
+        dynamicOtp = await handleOtpError();
+      } else {
+        logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
+        throw error;
+      }
+    } finally {
+      process.chdir(config.cwd);
+    }
+  }
+}
+
+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
 }) {
-  const args = getCommandArgs({
-    packageManager,
-    tag,
-    config,
-    otp,
-    dryRun,
-    type: "publish"
+  logger.debug("Preparing Twitter post...");
+  const changelogSummary = extractChangelogSummary(changelog, 150);
+  const message = formatTweetMessage({
+    template,
+    projectName,
+    version,
+    changelog: changelogSummary,
+    releaseUrl,
+    changelogUrl
   });
-  const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
-  return `${baseCommand} ${args.join(" ")}`;
-}
-async function publishPackage({
-  pkg,
-  config,
-  packageManager,
-  dryRun
-}) {
-  const tag = determinePublishTag(pkg.newVersion || pkg.version, config.publish.tag);
-  const packageNameAndVersion = getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version });
-  logger.debug(`Building publish command for ${pkg.name}`);
-  let dynamicOtp;
-  const maxAttempts = 2;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      const command = getPublishCommand({
-        packageManager,
-        tag,
-        config,
-        otp: dynamicOtp,
-        dryRun
-      });
-      process.chdir(pkg.path);
-      await executePublishCommand({
-        command,
-        packageNameAndVersion,
-        packageManager,
-        pkg,
-        config,
-        dryRun,
-        tag
-      });
-      if (dynamicOtp && !sessionOtp) {
-        sessionOtp = dynamicOtp;
-        logger.debug("OTP stored for session");
-      }
-      return;
-    } catch (error) {
-      if (isOtpError(error) && attempt < maxAttempts - 1) {
-        dynamicOtp = await handleOtpError();
-      } else {
-        logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
-        throw error;
-      }
-    } finally {
-      process.chdir(config.cwd);
+  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;
   }
 }
 
@@ -2856,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
   });
@@ -2877,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({
@@ -2938,7 +3263,6 @@ async function bumpSelectiveMode({
   logger.debug("Determining packages to bump...");
   const packages = await getPackages({
     config,
-    patterns: config.monorepo?.packages,
     suffix,
     force
   });
@@ -2969,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({
@@ -3006,7 +3331,6 @@ async function bumpIndependentMode({
   logger.debug("Starting bump in independent mode");
   const packagesToBump = await getPackages({
     config,
-    patterns: config.monorepo?.packages,
     suffix,
     force
   });
@@ -3078,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,
@@ -3104,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;
@@ -3227,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
         });
@@ -3257,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) {
@@ -3309,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({
@@ -3343,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");
@@ -3358,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,
@@ -3385,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) {
@@ -3408,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,
@@ -3416,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 });
     }
   }
 }
@@ -3444,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}`);
   }
@@ -3519,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,
@@ -3556,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
     }
@@ -3569,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;
@@ -3583,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,
@@ -3598,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,
@@ -3616,7 +4246,7 @@ async function release(options = {}) {
     } else {
       logger.info("Skipping changelog generation (--no-changelog)");
     }
-    logger.box("Step 3/6: Publish packages to registry");
+    logger.box("Publish packages to registry");
     let publishResponse;
     if (config.release.publish) {
       try {
@@ -3630,17 +4260,18 @@ async function release(options = {}) {
           config,
           configName: options.configName,
           suffix: options.suffix,
-          force
+          force,
+          safetyCheck: false
         });
       } catch (error) {
-        logger.error("Publish failed, rolling back modified files...");
+        logger.fail("Publish failed, rolling back modified files...");
         await rollbackModifiedFiles({ config });
         throw error;
       }
     } else {
       logger.info("Skipping publish (--no-publish)");
     }
-    logger.box("Step 4/6: Commit changes and create tag");
+    logger.box("Commit changes and create tag");
     let createdTags = [];
     if (config.release.commit) {
       createdTags = await createCommitAndTags({
@@ -3654,7 +4285,7 @@ async function release(options = {}) {
     } else {
       logger.info("Skipping commit and tag (--no-commit)");
     }
-    logger.box("Step 5/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 {
@@ -3674,40 +4305,75 @@ async function release(options = {}) {
     }
     let provider = config.repo?.provider;
     let postedReleases = [];
-    logger.box("Step 6/6: Publish Git release");
+    let providerError;
+    logger.box("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);
-      }
+      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,
+        safetyCheck: false
+      });
+      provider = response.detectedProvider;
+      postedReleases = response.postedReleases;
+      providerError = response.error;
     } else {
       logger.info("Skipping release (--no-provider-release)");
     }
+    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 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) {
@@ -3717,4 +4383,4 @@ Git provider: ${provider}`);
   }
 }
 
-export { executeBuildCmd as $, getCurrentGitBranch as A, getCurrentGitRef as B, github as C, createGitlabRelease as D, gitlab as E, detectPackageManager as F, determinePublishTag as G, getPackagesToPublishInSelectiveMode as H, getPackagesToPublishInIndependentMode as I, getAuthCommand as J, publishPackage as K, readPackageJson as L, getRootPackage as M, readPackages as N, getPackages as O, getPackageCommits as P, hasLernaJson as Q, getIndependentTag as R, getLastStableTag as S, getLastTag as T, getLastRepoTag as U, getLastPackageTag as V, resolveTags as W, executeHook as X, isInCI as Y, getCIName as Z, executeFormatCmd as _, providerRelease as a, isBumpedPackage as a0, getPackagesOrBumpedPackages as a1, isGraduatingToStableBetweenVersion as a2, determineSemverChange as a3, determineReleaseType as a4, writeVersion as a5, getPackageNewVersion as a6, updateLernaVersion as a7, extractVersionFromPackageTag as a8, isPrerelease as a9, isStableReleaseType as aa, isPrereleaseReleaseType as ab, isGraduating as ac, getPreid as ad, isChangedPreid as ae, getBumpedPackageIndependently as af, confirmBump as ag, getBumpedIndependentPackages as ah, shouldFilterPrereleaseTags as ai, extractVersionFromTag as aj, isTagVersionCompatibleWithCurrent as ak, 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, getModifiedReleaseFilePatterns as u, createCommitAndTags as v, writeChangelogToFile as w, pushCommitAndTags as x, rollbackModifiedFiles as y, getFirstCommit 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 };