relizy 0.2.5-beta.8 → 0.2.5

package/dist/shared/{relizy.cH6JI7VO.mjs → relizy.CU6Hj4K0.mjs}

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