relizy 0.2.5-beta.9 → 0.2.6-beta.0

package/dist/shared/{relizy.DXsVzrS_.mjs → relizy.DAGRGqEb.mjs}

@@ -1,446 +1,901 @@
 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) {
+  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;
+  }
+}
+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 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
+}) {
+  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");
+  }
+}
+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.info("[dry-run] exec build command: ", config.publish.buildCmd);
+    }
+  } else {
+    logger.debug("No build command specified");
+  }
+}
+function isBumpedPackage(pkg) {
+  return "oldVersion" in pkg && !!pkg.oldVersion;
+}
+async function getPackagesOrBumpedPackages({
+  config,
+  bumpResult,
+  suffix,
+  force
+}) {
+  if (bumpResult?.bumpedPackages && bumpResult.bumpedPackages.length > 0) {
+    return bumpResult.bumpedPackages;
+  }
+  return await getPackages({
+    config,
+    patterns: config.monorepo?.packages,
+    suffix,
+    force
+  });
+}
+
+function getGitStatus(cwd) {
+  return execSync("git status --porcelain", {
+    cwd,
+    encoding: "utf8"
+  }).trim();
+}
+function checkGitStatusIfDirty() {
+  logger.debug("Checking git status");
+  const dirty = getGitStatus();
+  if (dirty) {
+    logger.debug("git status:", `
+${dirty.trim().split("\n").map((line) => line.trim()).join("\n")}`);
+    const error = `Git status is dirty!
+
+Please commit or stash your changes before bumping or use --no-clean flag. 
+
+Unstaged files:
+
+ ${dirty.trim()}`;
+    throw new Error(error);
+  }
+}
+async function fetchGitTags(cwd) {
+  logger.debug("Fetching git tags from remote");
+  try {
+    await execPromise("git fetch --tags", { cwd, noStderr: true, noStdout: true, noSuccess: true });
+    logger.debug("Git tags fetched successfully");
+  } catch (error) {
+    logger.fail("Failed to fetch some git tags from remote (tags might already exist locally)", error);
+    logger.info("Continuing with local tags");
+  }
+}
+function detectGitProvider(cwd = process.cwd()) {
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf8"
+    }).trim();
+    if (remoteUrl.includes("github.com")) {
+      return "github";
+    }
+    if (remoteUrl.includes("gitlab.com") || remoteUrl.includes("gitlab")) {
+      return "gitlab";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseGitRemoteUrl(remoteUrl) {
+  const sshRegex = /git@[\w.-]+:([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
+  const httpsRegex = /https?:\/\/[\w.-]+\/([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
+  const sshMatch = remoteUrl.match(sshRegex);
+  if (sshMatch) {
+    return {
+      owner: sshMatch[1],
+      repo: sshMatch[2]
+    };
+  }
+  const httpsMatch = remoteUrl.match(httpsRegex);
+  if (httpsMatch) {
+    return {
+      owner: httpsMatch[1],
+      repo: httpsMatch[2]
+    };
+  }
+  return null;
+}
+async function createCommitAndTags({
+  config,
+  noVerify,
+  bumpedPackages,
+  newVersion,
+  dryRun,
+  logLevel
+}) {
+  const internalConfig = config || await loadRelizyConfig();
+  try {
+    await executeHook("before:commit-and-tag", internalConfig, dryRun ?? false);
+    const filePatternsToAdd = [
+      "package.json",
+      "lerna.json",
+      "CHANGELOG.md",
+      "**/CHANGELOG.md",
+      "**/package.json"
+    ];
+    logger.start("Start commit and tag");
+    logger.debug("Adding files to git staging area...");
+    for (const pattern of filePatternsToAdd) {
+      if (pattern === "lerna.json" && !hasLernaJson(internalConfig.cwd)) {
+        logger.verbose(`Skipping lerna.json as it doesn't exist`);
+        continue;
+      }
+      if ((pattern === "lerna.json" || pattern === "CHANGELOG.md") && !existsSync(join(internalConfig.cwd, pattern))) {
+        logger.verbose(`Skipping ${pattern} as it doesn't exist`);
+        continue;
+      }
+      if (dryRun) {
+        logger.info(`[dry-run] git add ${pattern}`);
+        continue;
+      }
+      try {
+        logger.debug(`git add ${pattern}`);
+        execSync(`git add ${pattern}`);
+      } catch {
+      }
+    }
+    const rootPackage = readPackageJson(internalConfig.cwd);
+    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);
+      }
+      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"
+  });
+  return result.trim();
+}
+function getCurrentGitRef(cwd) {
+  const branch = getCurrentGitBranch(cwd);
+  return branch || "HEAD";
+}
+
+async function generateMarkDown({
+  commits,
+  config,
+  from,
+  to,
+  isFirstCommit
+}) {
+  const typeGroups = groupBy(commits, "type");
+  const markdown = [];
+  const breakingChanges = [];
+  const updatedConfig = {
+    ...config,
+    from,
+    to
+  };
+  const versionTitle = updatedConfig.to;
+  const changelogTitle = `${updatedConfig.from}...${updatedConfig.to}`;
+  markdown.push("", `## ${changelogTitle}`, "");
+  if (updatedConfig.repo && updatedConfig.from && versionTitle) {
+    const formattedCompareLink = formatCompareChanges(versionTitle, {
+      ...updatedConfig,
+      from: isFirstCommit ? getFirstCommit(updatedConfig.cwd) : updatedConfig.from
+    });
+    markdown.push(formattedCompareLink);
+  }
+  for (const type in updatedConfig.types) {
+    const group = typeGroups[type];
+    if (!group || group.length === 0) {
+      continue;
+    }
+    if (typeof updatedConfig.types[type] === "boolean") {
+      continue;
+    }
+    markdown.push("", `### ${updatedConfig.types[type]?.title}`, "");
+    for (const commit of group.reverse()) {
+      const line = formatCommit(commit, updatedConfig);
+      markdown.push(line);
+      if (commit.isBreaking) {
+        breakingChanges.push(line);
+      }
+    }
+  }
+  if (breakingChanges.length > 0) {
+    markdown.push("", "#### \u26A0\uFE0F Breaking Changes", "", ...breakingChanges);
+  }
+  const _authors = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    if (!commit.author) {
+      continue;
+    }
+    const name = formatName(commit.author.name);
+    if (!name || name.includes("[bot]")) {
+      continue;
+    }
+    if (updatedConfig.excludeAuthors && updatedConfig.excludeAuthors.some(
+      (v) => name.includes(v) || commit.author.email?.includes(v)
+    )) {
+      continue;
+    }
+    if (_authors.has(name)) {
+      const entry = _authors.get(name);
+      entry?.email.add(commit.author.email);
+    } else {
+      _authors.set(name, { email: /* @__PURE__ */ new Set([commit.author.email]), name });
+    }
+  }
+  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]) {
@@ -538,9 +993,8 @@ async function generateChangelog({
   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) {
+  if (!toTag) {
     toTag = config.monorepo?.versionMode === "independent" ? getIndependentTag({ version: newVersion, name: pkg.name }) : config.templates.tagBody.replace("{{newVersion}}", newVersion);
   }
   if (!toTag) {
@@ -658,7 +1112,8 @@ function getDefaultConfig() {
     },
     publish: {
       private: false,
-      args: []
+      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,
@@ -672,7 +1127,8 @@ function getDefaultConfig() {
       push: true,
       clean: true,
       providerRelease: true,
-      noVerify: false
+      noVerify: false,
+      gitTag: true
     },
     logLevel: "default",
     safetyCheck: true
@@ -716,137 +1172,19 @@ async function loadRelizyConfig(options) {
   });
   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);
+    if (options?.configName) {
+      logger.error(`No config file found with name "${configName}"`);
+      process$1.exit(1);
+    }
   }
-  return sorted;
+  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;
 }
 
 async function githubIndependentMode({
@@ -864,10 +1202,10 @@ async function githubIndependentMode({
   if (!config.tokens.github && !config.repo?.token) {
     throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
   }
-  const packages = bumpResult?.bumped && bumpResult?.bumpedPackages || await getPackages({
-    suffix,
-    patterns: config.monorepo?.packages,
+  const packages = await getPackagesOrBumpedPackages({
     config,
+    bumpResult,
+    suffix,
     force
   });
   logger.info(`Creating ${packages.length} GitHub release(s)`);
@@ -941,12 +1279,13 @@ async function githubUnified({
   if (!config.tokens.github && !config.repo?.token) {
     throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
   }
-  const to = config.to || config.templates.tagBody.replace("{{newVersion}}", bumpResult?.bumped && bumpResult.newVersion || rootPackage.version);
+  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: bumpResult?.newVersion || rootPackage.version
+    newVersion
   });
   const releaseBody = changelog.split("\n").slice(2).join("\n");
   const release = {
@@ -1006,10 +1345,14 @@ async function github(options) {
       });
     }
     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: options.bumpResult?.newVersion || rootPackageBase.version,
+      newVersion,
       pkg: rootPackageBase
     });
     const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
@@ -1101,9 +1444,9 @@ async function gitlabIndependentMode({
   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,
+  const packages = await getPackagesOrBumpedPackages({
     config,
+    bumpResult,
     suffix,
     force
   });
@@ -1174,12 +1517,13 @@ async function gitlabUnified({
   bumpResult
 }) {
   logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
-  const to = config.templates.tagBody.replace("{{newVersion}}", rootPackage.newVersion || rootPackage.version);
+  const newVersion = bumpResult?.newVersion || rootPackage.newVersion || rootPackage.version;
+  const to = config.templates.tagBody.replace("{{newVersion}}", newVersion);
   const changelog = await generateChangelog({
     pkg: rootPackage,
     config,
     dryRun,
-    newVersion: bumpResult?.newVersion || rootPackage.version
+    newVersion
   });
   const releaseBody = changelog.split("\n").slice(2).join("\n");
   logger.debug("Getting current branch...");
@@ -1216,7 +1560,7 @@ async function gitlabUnified({
     name: to,
     tag: to,
     version: to,
-    prerelease: isPrerelease(rootPackage.version)
+    prerelease: isPrerelease(newVersion)
   }];
 }
 async function gitlab(options = {}) {
@@ -1245,10 +1589,14 @@ async function gitlab(options = {}) {
       });
     }
     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: options.bumpResult?.newVersion || rootPackageBase.version,
+      newVersion,
       pkg: rootPackageBase
     });
     const rootPackage = options.bumpResult?.rootPackage || await getRootPackage({
@@ -1259,7 +1607,7 @@ async function gitlab(options = {}) {
       from,
       to
     });
-    logger.debug(`Root package: ${getIndependentTag({ name: rootPackage.name, version: rootPackage.newVersion || rootPackage.version })}`);
+    logger.debug(`Root package: ${getIndependentTag({ name: rootPackage.name, version: newVersion })}`);
     return await gitlabUnified({
       config,
       dryRun,
@@ -1272,6 +1620,12 @@ async function gitlab(options = {}) {
   }
 }
 
+function isGraduatingToStableBetweenVersion(version, newVersion) {
+  const isSameBase = semver.major(version) === semver.major(newVersion) && semver.minor(version) === semver.minor(newVersion) && semver.patch(version) === semver.patch(newVersion);
+  const fromPrerelease = semver.prerelease(version) !== null;
+  const toStable = semver.prerelease(newVersion) === null;
+  return isSameBase && fromPrerelease && toStable;
+}
 function determineSemverChange(commits, types) {
   let [hasMajor, hasMinor, hasPatch] = [false, false, false];
   for (const commit of commits) {
@@ -1402,26 +1756,27 @@ function determineReleaseType({
   }
   return handleExplicitReleaseType({ releaseType, currentVersion });
 }
-function writeVersion(pkgPath, version, dryRun = false) {
+function writeVersion(pkgPath, newVersion, dryRun = false) {
   const packageJsonPath = join(pkgPath, "package.json");
   try {
-    logger.debug(`Writing ${version} to ${pkgPath}`);
+    logger.debug(`Writing ${newVersion} to ${pkgPath}`);
     const content = readFileSync(packageJsonPath, "utf8");
     const packageJson = JSON.parse(content);
     const oldVersion = packageJson.version;
-    packageJson.version = version;
+    packageJson.version = newVersion;
     if (dryRun) {
-      logger.info(`[dry-run] Updated ${packageJson.name}: ${oldVersion} \u2192 ${version}`);
+      logger.info(`[dry-run] Updated ${packageJson.name}: ${oldVersion} \u2192 ${newVersion}`);
       return;
     }
     writeFileSync(packageJsonPath, `${formatJson(packageJson)}
 `, "utf8");
-    logger.info(`Updated ${packageJson.name}: ${oldVersion} \u2192 ${version}`);
+    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,
@@ -1429,7 +1784,7 @@ function getPackageNewVersion({
 }) {
   let newVersion = semver.inc(currentVersion, releaseType, preid);
   if (!newVersion) {
-    throw new Error(`Unable to bump version "${currentVersion}" with release type "${releaseType}"
+    throw new Error(`Unable to bump "${name}" version "${currentVersion}" with release type "${releaseType}"
 
 You should use an explicit release type (use flag: --major, --minor, --patch, --premajor, --preminor, --prepatch, --prerelease)`);
   }
@@ -1438,13 +1793,13 @@ You should use an explicit release type (use flag: --major, --minor, --patch, --
   }
   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`);
+    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 from prerelease ${currentVersion} to stable ${newVersion}`);
+    logger.info(`Graduating "${name}" from prerelease ${currentVersion} to stable ${newVersion}`);
   }
   if (isChangedPreid(currentVersion, preid)) {
-    logger.debug(`Graduating from ${getPreid(currentVersion)} to ${preid}`);
+    logger.debug(`Graduating "${name}" from ${getPreid(currentVersion)} to ${preid}`);
   }
   return newVersion;
 }
@@ -1668,14 +2023,12 @@ async function confirmBump({
   });
   if (versionMode === "unified") {
     if (!newVersion) {
-      logger.error("Cannot confirm bump in unified mode without a new version");
-      process.exit(1);
+      throw new Error("Cannot confirm bump in unified mode without a new version");
     }
     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);
+      throw new Error("Cannot confirm bump in selective mode without a new version");
     }
     displaySelectiveModePackages({ packages, newVersion, force });
   } else if (versionMode === "independent") {
@@ -1878,12 +2231,13 @@ async function resolveTags({
   const logLevel = config.logLevel;
   logger.debug(`[${versionMode}](${step}) Resolving tags`);
   const releaseType = config.bump.type;
+  const graduating = typeof newVersion === "string" ? isGraduatingToStableBetweenVersion(pkg.version, newVersion) : isGraduating(pkg.version, releaseType);
   const from = await resolveFromTag({
     config,
     versionMode,
     step,
     packageName: pkg.name,
-    graduating: isGraduating(pkg.version, releaseType),
+    graduating,
     logLevel
   });
   const to = resolveToTag({
@@ -1896,536 +2250,289 @@ async function resolveTags({
   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}`);
-      }
-    }
-    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("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.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
-}) {
-  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);
-  }
-  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);
-    });
-  });
-}
-async function handleOtpError() {
-  if (isInCI()) {
-    logger.error("OTP required but running in CI environment. Please provide OTP via config or `--otp` flag");
-    throw new Error("OTP required in CI environment");
-  }
-  logger.warn("Publish failed: OTP required");
-  try {
-    const otp = await promptOtpWithTimeout();
-    logger.debug("OTP received, retrying publish...");
-    return otp;
-  } catch (promptError) {
-    logger.error("Failed to get OTP:", promptError);
-    throw promptError;
-  }
-}
-async function executePublishCommand({
-  command,
-  packageNameAndVersion,
-  pkg,
-  config,
-  dryRun
-}) {
-  logger.debug(`Executing publish command (${command}) in ${pkg.path}`);
-  if (dryRun) {
-    logger.info(`[dry-run] ${packageNameAndVersion}: Run ${command}`);
-    return;
-  }
-  const { stdout } = await execPromise(command, {
-    noStderr: true,
-    noStdout: true,
-    logLevel: config.logLevel,
-    cwd: pkg.path
-  });
-  if (stdout) {
-    logger.debug(stdout);
-  }
-  logger.info(`Published ${packageNameAndVersion}`);
-}
-async function publishPackage({
-  pkg,
-  config,
-  packageManager,
-  dryRun
-}) {
-  const tag = determinePublishTag(pkg.version, config.publish.tag);
-  const packageNameAndVersion = getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version });
-  const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
-  logger.debug(`Building publish command for ${pkg.name}`);
-  let dynamicOtp;
-  const maxAttempts = 2;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      const args = getCommandArgs({
-        packageManager,
-        tag,
-        config,
-        otp: dynamicOtp
-      });
-      const command = `${baseCommand} ${args.join(" ")}`;
-      logger.debug(`Publishing ${packageNameAndVersion} with tag '${tag}' with command: ${command}`);
-      process.chdir(pkg.path);
-      await executePublishCommand({
-        command,
-        packageNameAndVersion,
-        pkg,
-        config,
-        dryRun
-      });
-      if (dynamicOtp && !sessionOtp) {
-        sessionOtp = dynamicOtp;
-        logger.debug("OTP stored for session");
-      }
-      return;
-    } catch (error) {
-      if (isOtpError(error) && attempt < maxAttempts - 1) {
-        dynamicOtp = await handleOtpError();
-      } else {
-        logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
-        throw error;
-      }
-    } finally {
-      process.chdir(config.cwd);
-    }
-  }
-}
-
-function readPackageJson(packagePath) {
-  const packageJsonPath = join(packagePath, "package.json");
-  if (!existsSync(packageJsonPath))
-    throw new Error(`package.json not found at ${packageJsonPath}`);
-  if (!statSync(packagePath).isDirectory())
-    throw new Error(`Not a directory: ${packagePath}`);
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  if (!packageJson.name || !packageJson.version) {
-    throw new Error(`Invalid package.json at ${packagePath}`);
-  }
-  return {
-    name: packageJson.name,
-    version: packageJson.version,
-    private: packageJson.private || false,
-    path: packagePath
-  };
-}
-async function getRootPackage({
-  config,
-  force,
-  from,
-  to,
-  suffix,
-  changelog
-}) {
+
+let sessionOtp;
+function detectPackageManager(cwd = process.cwd()) {
   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);
+    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}`);
       }
-      newVersion = getPackageNewVersion({
-        currentVersion: packageJson.version,
-        releaseType,
-        preid: config.bump.preid,
-        suffix
-      });
     }
-    return {
-      ...packageJson,
-      path: config.cwd,
-      fromTag: from,
-      commits,
-      newVersion
+    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("No package manager detected, defaulting to npm");
+    return "npm";
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(errorMessage);
+    logger.fail(`Error detecting package manager: ${error}, defaulting to npm`);
+    return "npm";
   }
 }
-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);
+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 packages;
+  return packagesToPublish;
 }
-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
+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}`);
+    }
   }
-  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
-  });
+  return packagesToPublish;
 }
-async function getPackages({
-  patterns,
+function isYarnBerry() {
+  return existsSync(path.join(process.cwd(), ".yarnrc.yml"));
+}
+function getCommandArgs({
+  packageManager,
+  tag,
   config,
-  suffix,
-  force
-}) {
-  const readedPackages = readPackages({
-    cwd: config.cwd,
-    patterns,
-    ignorePackageNames: config.monorepo?.ignorePackageNames
-  });
-  const packages = /* @__PURE__ */ new Map();
-  const foundPaths = /* @__PURE__ */ new Set();
-  const patternsSet = new Set(patterns);
-  if (!patterns)
-    patternsSet.add(".");
-  logger.debug(`Getting packages from patterns: ${patternsSet.values()}`);
-  for (const pattern of patternsSet) {
-    const matches = fastGlob.sync(pattern, {
-      cwd: config.cwd,
-      onlyDirectories: true,
-      absolute: true,
-      ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
-    });
-    for (const matchPath of matches) {
-      if (foundPaths.has(matchPath))
-        continue;
-      const packageBase = readPackageJson(matchPath);
-      if (packageBase.private) {
-        logger.debug(`${packageBase.name} is private and will be ignored`);
-        continue;
-      }
-      if (config.monorepo?.ignorePackageNames?.includes(packageBase.name)) {
-        logger.debug(`${packageBase.name} ignored by config (monorepo.ignorePackageNames)`);
-        continue;
-      }
-      if (!packageBase.version) {
-        logger.warn(`${packageBase.name} has no version and will be ignored`);
-        continue;
-      }
-      const { from, to } = await resolveTags({
-        config,
-        step: "bump",
-        pkg: packageBase,
-        newVersion: void 0
-      });
-      const commits = await getPackageCommits({
-        pkg: packageBase,
-        from,
-        to,
-        config,
-        changelog: false
-      });
-      foundPaths.add(matchPath);
-      const dependencies = getPackageDependencies({
-        packagePath: matchPath,
-        allPackageNames: new Set(readedPackages.map((p) => p.name)),
-        dependencyTypes: config.bump?.dependencyTypes
-      });
-      packages.set(packageBase.name, {
-        ...packageBase,
-        path: matchPath,
-        fromTag: from,
-        dependencies,
-        commits,
-        reason: commits.length > 0 ? "commits" : void 0,
-        dependencyChain: void 0,
-        newVersion: void 0
-      });
+  otp,
+  type,
+  dryRun
+}) {
+  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");
+  }
+  if (dryRun) {
+    args.push("--dry-run");
+  }
+  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;
+  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;
   }
-  if (typeof type === "boolean") {
-    return type;
+}
+async function executePublishCommand({
+  command,
+  packageNameAndVersion,
+  pkg,
+  config,
+  tag,
+  dryRun,
+  packageManager
+}) {
+  logger.info(`${dryRun ? "[dry-run] " : ""}Publishing ${packageNameAndVersion} with tag "${tag}"`);
+  const dryRunPublish = dryRun && packageManager !== "npm" && packageManager !== "yarn";
+  if (dryRunPublish) {
+    logger.info(`${dryRun ? "[dry-run] " : ""}Skipping actual publish for ${packageNameAndVersion}`);
+    return;
   }
-  return false;
+  const { stdout, stderr } = await execPromise(command, {
+    noStderr: true,
+    noStdout: true,
+    noSuccess: true,
+    logLevel: config.logLevel,
+    cwd: pkg.path
+  });
+  logger.debug("Publish stdout:", stdout);
+  logger.debug("Publish stderr:", stderr);
 }
-async function getPackageCommits({
+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,
+  dryRun
+}) {
+  const args = getCommandArgs({
+    packageManager,
+    tag,
+    config,
+    otp,
+    dryRun,
+    type: "publish"
+  });
+  const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
+  return `${baseCommand} ${args.join(" ")}`;
+}
+async function publishPackage({
   pkg,
-  from,
-  to,
   config,
-  changelog
+  packageManager,
+  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;
+  const tag = determinePublishTag(pkg.newVersion || pkg.version, config.publish.tag);
+  const packageNameAndVersion = getIndependentTag({ name: pkg.name, version: pkg.newVersion || pkg.version });
+  logger.debug(`Building publish command for ${pkg.name}`);
+  let dynamicOtp;
+  const maxAttempts = 2;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const command = getPublishCommand({
+        packageManager,
+        tag,
+        config,
+        otp: dynamicOtp,
+        dryRun
+      });
+      process.chdir(pkg.path);
+      await executePublishCommand({
+        command,
+        packageNameAndVersion,
+        packageManager,
+        pkg,
+        config,
+        dryRun,
+        tag
+      });
+      if (dynamicOtp && !sessionOtp) {
+        sessionOtp = dynamicOtp;
+        logger.debug("OTP stored for session");
+      }
+      return;
+    } catch (error) {
+      if (isOtpError(error) && attempt < maxAttempts - 1) {
+        dynamicOtp = await handleOtpError();
+      } else {
+        logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
+        throw error;
+      }
+    } finally {
+      process.chdir(config.cwd);
     }
-    const packageRelativePath = relative(changelogConfig.cwd, pkg.path);
-    const scopeMatches = commit.scope === pkg.name;
-    const bodyContainsPath = commit.body.includes(packageRelativePath);
-    return scopeMatches || bodyContainsPath;
-  });
-  logger.debug(`Found ${commits.length} commit(s) for ${pkg.name} from ${from} to ${to}`);
-  if (commits.length > 0) {
-    logger.debug(`${pkg.name}: ${commits.length} commit(s) found`);
-  } else {
-    logger.debug(`${pkg.name}: No commits found`);
   }
-  return commits;
-}
-function hasLernaJson(rootDir) {
-  const lernaJsonPath = join(rootDir, "lerna.json");
-  return existsSync(lernaJsonPath);
 }
 
 async function bumpUnifiedMode({
@@ -2436,6 +2543,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",
@@ -2515,6 +2625,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",
@@ -2717,22 +2830,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,
@@ -2764,10 +2861,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
   });
@@ -2786,10 +2886,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;
@@ -2802,7 +2906,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,
@@ -2843,7 +2946,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,
@@ -2867,27 +2970,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({
@@ -2927,11 +3031,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);
   }
 }
@@ -2998,6 +3102,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,
@@ -3008,14 +3146,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) {
@@ -3026,11 +3166,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
     });
@@ -3114,7 +3258,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,
@@ -3130,7 +3275,7 @@ function getReleaseConfig(options = {}) {
     }
   });
 }
-function releaseSafetyCheck({
+async function releaseSafetyCheck({
   config,
   provider
 }) {
@@ -3138,6 +3283,7 @@ function releaseSafetyCheck({
     return;
   }
   providerReleaseSafetyCheck({ config, provider });
+  await publishSafetyCheck({ config });
 }
 async function release(options = {}) {
   const dryRun = options.dryRun ?? false;
@@ -3147,7 +3293,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");
@@ -3223,7 +3369,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,
@@ -3261,10 +3407,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"}
@@ -3278,4 +3424,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 };