relizy 0.1.0

package/dist/shared/relizy.Blp-ymeX.mjs

@@ -0,0 +1,2954 @@
+import { logger, execPromise } from '@maz-ui/node';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, statSync } from 'node:fs';
+import path, { join } from 'node:path';
+import { formatCompareChanges, formatReference, resolveRepoConfig, getRepoConfig, createGithubRelease, getGitDiff, parseCommits, determineSemverChange } from 'changelogen';
+import fastGlob from 'fast-glob';
+import { confirm } from '@inquirer/prompts';
+import { upperFirst, formatJson } from '@maz-ui/utils';
+import * as semver from 'semver';
+import process$1 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 generateMarkDown(commits, config) {
+  const typeGroups = groupBy(commits, "type");
+  const markdown = [];
+  const breakingChanges = [];
+  const v = config.newVersion && config.templates.tagBody.replaceAll("{{newVersion}}", config.newVersion);
+  markdown.push("", `## ${v || `${config.from || ""}...${config.to}`}`, "");
+  if (config.repo && config.from && v) {
+    markdown.push(formatCompareChanges(v, config));
+  }
+  for (const type in config.types) {
+    const group = typeGroups[type];
+    if (!group || group.length === 0) {
+      continue;
+    }
+    if (typeof config.types[type] === "boolean") {
+      continue;
+    }
+    markdown.push("", `### ${config.types[type]?.title}`, "");
+    for (const commit of group.reverse()) {
+      const line = formatCommit(commit, config);
+      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 (config.excludeAuthors && config.excludeAuthors.some(
+      (v2) => name.includes(v2) || commit.author.email?.includes(v2)
+    )) {
+      continue;
+    }
+    if (_authors.has(name)) {
+      const entry = _authors.get(name);
+      entry?.email.add(commit.author.email);
+    } else {
+      _authors.set(name, { email: /* @__PURE__ */ new Set([commit.author.email]), name });
+    }
+  }
+  await Promise.all(
+    [..._authors.keys()].map(async (authorName) => {
+      const meta = _authors.get(authorName);
+      if (!meta) {
+        return;
+      }
+      for (const data of [...meta.email, meta.name]) {
+        const { user } = await fetch$1(`https://ungh.cc/users/find/${data}`).then((r) => r.json()).catch(() => ({ user: null }));
+        if (user) {
+          meta.github = user.username;
+          break;
+        }
+      }
+    })
+  );
+  const authors = [..._authors.entries()].map((e) => ({
+    name: e[0],
+    ...e[1]
+  }));
+  if (authors.length > 0 && !config.noAuthors) {
+    markdown.push(
+      "",
+      "### \u2764\uFE0F Contributors",
+      "",
+      ...authors.map((i) => {
+        const _email = [...i.email].find(
+          (e) => !e.includes("noreply.github.com")
+        );
+        const email = config.hideAuthorEmail !== true && _email ? ` <${_email}>` : "";
+        const github = i.github ? ` ([@${i.github}](https://github.com/${i.github}))` : "";
+        return `- ${i.name}${github || email || ""}`;
+      })
+    );
+  }
+  return convert(markdown.join("\n").trim(), true);
+}
+function getCommitBody(commit) {
+  if (!commit.body) {
+    return "";
+  }
+  const lines = commit.body.split("\n");
+  const contentLines = lines.filter((line) => {
+    const trimmedLine = line.trim();
+    if (!trimmedLine) {
+      return false;
+    }
+    const isFileLine = /^[AMDRC]\s+/.test(trimmedLine);
+    return !isFileLine;
+  });
+  if (contentLines.length === 0) {
+    return "";
+  }
+  const indentedBody = contentLines.map((line) => `  ${line}`).join("\n");
+  return `
+
+${indentedBody}
+`;
+}
+function formatCommit(commit, config) {
+  const body = config.changelog.includeCommitBody ? getCommitBody(commit) : "";
+  return `- ${commit.scope ? `**${commit.scope.trim()}:** ` : ""}${commit.isBreaking ? "\u26A0\uFE0F  " : ""}${upperFirst(commit.description)}${formatReferences(commit.references, config)}${body}`;
+}
+function formatReferences(references, config) {
+  const pr = references.filter((ref) => ref.type === "pull-request");
+  const issue = references.filter((ref) => ref.type === "issue");
+  if (pr.length > 0 || issue.length > 0) {
+    return ` (${[...pr, ...issue].map((ref) => formatReference(ref, config.repo)).join(", ")})`;
+  }
+  if (references.length > 0) {
+    return ` (${formatReference(references[0], config.repo)})`;
+  }
+  return "";
+}
+function formatName(name = "") {
+  return name.split(" ").map((p) => upperFirst(p.trim())).join(" ");
+}
+function groupBy(items, key) {
+  const groups = {};
+  for (const item of items) {
+    groups[item[key]] = groups[item[key]] || [];
+    groups[item[key]]?.push(item);
+  }
+  return groups;
+}
+
+function fromTagIsFirstCommit(fromTag, cwd) {
+  return fromTag === getFirstCommit(cwd);
+}
+async function generateChangelog({
+  pkg,
+  commits,
+  config,
+  from,
+  dryRun
+}) {
+  let fromTag = config.from || config.templates.tagBody.replace("{{newVersion}}", pkg.currentVersion) || from;
+  const isFirstCommit = fromTagIsFirstCommit(fromTag, config.cwd);
+  if (isFirstCommit) {
+    fromTag = config.monorepo?.versionMode === "independent" ? `${pkg.name}@0.0.0` : config.templates.tagBody.replace("{{newVersion}}", "0.0.0");
+  }
+  const toTag = config.to || (config.monorepo?.versionMode === "independent" ? `${pkg.name}@${pkg.version}` : config.templates.tagBody.replace("{{newVersion}}", pkg.version));
+  try {
+    logger.debug(`Generating changelog for ${pkg.name} - from ${fromTag} to ${toTag}`);
+    config = {
+      ...config,
+      from: fromTag,
+      to: toTag
+    };
+    let changelog = await generateMarkDown(commits, config);
+    logger.verbose(`Output changelog for ${pkg.name}:
+${changelog}`);
+    if (commits.length === 0) {
+      changelog = `${changelog}
+
+${config.templates.emptyChangelogContent}`;
+    }
+    logger.debug(`Changelog generated for ${pkg.name} (${commits.length} commits)`);
+    logger.verbose(`Final changelog for ${pkg.name}:
+
+${changelog}
+
+`);
+    if (dryRun) {
+      logger.info(`[dry-run] ${pkg.name} - Generate changelog ${fromTag}...${toTag}`);
+    }
+    return changelog;
+  } catch (error) {
+    throw new Error(`Error generating changelog for ${pkg.name} (${fromTag}...${toTag}): ${error}`);
+  }
+}
+function writeChangelogToFile({
+  pkg,
+  changelog,
+  dryRun = false
+}) {
+  const changelogPath = join(pkg.path, "CHANGELOG.md");
+  let existingChangelog = "";
+  if (existsSync(changelogPath)) {
+    existingChangelog = readFileSync(changelogPath, "utf8");
+  }
+  const lines = existingChangelog.split("\n");
+  const titleIndex = lines.findIndex((line) => line.startsWith("# "));
+  let updatedChangelog;
+  if (titleIndex !== -1) {
+    const beforeTitle = lines.slice(0, titleIndex + 1);
+    const afterTitle = lines.slice(titleIndex + 1);
+    updatedChangelog = [...beforeTitle, "", changelog, "", ...afterTitle].join("\n");
+  } else {
+    const title = "# Changelog\n";
+    updatedChangelog = `${title}
+${changelog}
+${existingChangelog}`;
+  }
+  if (dryRun) {
+    logger.info(`[dry-run] ${pkg.name} - Write changelog to ${changelogPath}`);
+  } else {
+    logger.debug(`Writing changelog to ${changelogPath}`);
+    writeFileSync(changelogPath, updatedChangelog, "utf8");
+    logger.info(`Changelog updated for ${pkg.name}`);
+  }
+}
+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) {
+      logger.error("Format command failed:", error);
+      process.exit(1);
+    }
+  } 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.log("[dry-run] exec build command: ", config.publish.buildCmd);
+    }
+  } else {
+    logger.debug("No build command specified");
+  }
+}
+
+function getDefaultConfig() {
+  return {
+    cwd: process$1.cwd(),
+    types: {
+      feat: { title: "\u{1F680} Enhancements", semver: "minor" },
+      perf: { title: "\u{1F525} Performance", semver: "patch" },
+      fix: { title: "\u{1FA79} Fixes", semver: "patch" },
+      refactor: { title: "\u{1F485} Refactors", semver: "patch" },
+      docs: { title: "\u{1F4D6} Documentation", semver: "patch" },
+      build: { title: "\u{1F4E6} Build", semver: "patch" },
+      types: { title: "\u{1F30A} Types", semver: "patch" },
+      chore: { title: "\u{1F3E1} Chore" },
+      examples: { title: "\u{1F3C0} Examples" },
+      test: { title: "\u2705 Tests" },
+      style: { title: "\u{1F3A8} Styles" },
+      ci: { title: "\u{1F916} CI" }
+    },
+    templates: {
+      commitMessage: "chore(release): bump version to {{newVersion}}",
+      tagMessage: "Bump version to v{{newVersion}}",
+      tagBody: "v{{newVersion}}",
+      emptyChangelogContent: "No relevant changes for this release"
+    },
+    excludeAuthors: [],
+    noAuthors: false,
+    bump: {
+      type: "release",
+      clean: true,
+      dependencyTypes: ["dependencies"],
+      yes: false
+    },
+    changelog: {
+      rootChangelog: true,
+      includeCommitBody: true
+    },
+    publish: {
+      private: false,
+      args: []
+    },
+    tokens: {
+      gitlab: process$1.env.RELIZY_TOKENS_GITLAB || process$1.env.GITLAB_TOKEN || process$1.env.GITLAB_API_TOKEN || process$1.env.CI_JOB_TOKEN,
+      github: process$1.env.RELIZY_TOKENS_GITHUB || process$1.env.GITHUB_TOKEN || process$1.env.GH_TOKEN
+    },
+    scopeMap: {},
+    release: {
+      commit: true,
+      publish: true,
+      changelog: true,
+      push: true,
+      clean: true,
+      release: true,
+      noVerify: false
+    },
+    logLevel: "default"
+  };
+}
+function setupLogger(logLevel) {
+  if (logLevel) {
+    logger.setLevel(logLevel);
+    logger.debug(`Log level set to: ${logLevel}`);
+  }
+}
+async function resolveConfig(config, cwd) {
+  if (!config.repo) {
+    const resolvedRepoConfig = await resolveRepoConfig(cwd);
+    config.repo = {
+      ...resolvedRepoConfig,
+      provider: resolvedRepoConfig.provider
+    };
+  }
+  if (typeof config.repo === "string") {
+    const resolvedRepoConfig = getRepoConfig(config.repo);
+    config.repo = {
+      ...resolvedRepoConfig,
+      provider: resolvedRepoConfig.provider
+    };
+  }
+  return config;
+}
+async function loadMonorepoConfig({ baseConfig, overrides, configName = "relizy" }) {
+  const cwd = overrides?.cwd ?? process$1.cwd();
+  configName ??= "relizy";
+  await setupDotenv({ cwd });
+  const defaultConfig = getDefaultConfig();
+  const overridesConfig = defu(overrides, baseConfig);
+  const results = await loadConfig({
+    cwd,
+    name: configName,
+    packageJson: true,
+    defaults: defaultConfig,
+    overrides: overridesConfig
+  });
+  if (!results._configFile) {
+    logger.error(`No config file found with name "${configName}"`);
+    process$1.exit(1);
+  }
+  setupLogger(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 getPackagesWithDependencies(packages, dependencyTypes) {
+  const allPackageNames = new Set(packages.map((p) => p.name));
+  return packages.map((pkg) => ({
+    ...pkg,
+    dependencies: getPackageDependencies(pkg.path, allPackageNames, dependencyTypes)
+  }));
+}
+function getDependentsOf(packageName, allPackages) {
+  return allPackages.filter(
+    (pkg) => pkg.dependencies.includes(packageName)
+  );
+}
+function expandPackagesToBumpWithDependents({
+  packagesWithCommits,
+  allPackages,
+  dependencyTypes
+}) {
+  const packagesWithDeps = getPackagesWithDependencies(allPackages, dependencyTypes);
+  const result = /* @__PURE__ */ new Map();
+  logger.debug(`Expanding packages to bump: ${packagesWithCommits.length} packages with commits, ${allPackages.length} total packages`);
+  for (const pkg of packagesWithCommits) {
+    result.set(pkg.name, {
+      ...pkg,
+      reason: "commits",
+      commits: pkg.commits
+    });
+  }
+  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(currentPkgName, packagesWithDeps);
+    for (const dependent of dependents) {
+      if (!result.has(dependent.name)) {
+        const currentChain = result.get(currentPkgName)?.dependencyChain || [];
+        const chain = [...currentChain, currentPkgName];
+        const packageInfo = allPackages.find((p) => p.name === dependent.name);
+        if (packageInfo) {
+          result.set(dependent.name, {
+            ...packageInfo,
+            reason: "dependency",
+            dependencyChain: chain,
+            commits: []
+          });
+          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) {
+    if (visited.has(pkgName))
+      return;
+    if (visiting.has(pkgName)) {
+      logger.warn(`Circular dependency detected involving ${pkgName}`);
+      return;
+    }
+    visiting.add(pkgName);
+    const pkg = packageMap.get(pkgName);
+    if (!pkg)
+      return;
+    for (const depName of pkg.dependencies) {
+      visit(depName);
+    }
+    visiting.delete(pkgName);
+    visited.add(pkgName);
+    sorted.push(pkg);
+  }
+  for (const pkg of packages) {
+    visit(pkg.name);
+  }
+  return sorted;
+}
+
+function getGitStatus(cwd) {
+  return execSync("git status --porcelain", {
+    cwd,
+    encoding: "utf8"
+  }).trim();
+}
+function checkGitStatusIfDirty() {
+  logger.debug("Checking git status");
+  const dirty = getGitStatus();
+  if (dirty) {
+    logger.debug("git status:", `
+${dirty.trim().split("\n").map((line) => line.trim()).join("\n")}`);
+    throw new Error("Working directory is not clean");
+  }
+}
+async function fetchGitTags(cwd) {
+  logger.debug("Fetching git tags from remote");
+  try {
+    await execPromise("git fetch --tags", { cwd, noStderr: true, noStdout: true, noSuccess: true });
+    logger.debug("Git tags fetched successfully");
+  } catch (error) {
+    logger.warn("Failed to fetch some git tags from remote (tags might already exist locally)", error);
+    logger.info("Continuing with local tags");
+  }
+}
+function detectGitProvider(cwd = process.cwd()) {
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf8"
+    }).trim();
+    if (remoteUrl.includes("github.com")) {
+      return "github";
+    }
+    if (remoteUrl.includes("gitlab.com") || remoteUrl.includes("gitlab")) {
+      return "gitlab";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseGitRemoteUrl(remoteUrl) {
+  const sshRegex = /git@[\w.-]+:([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
+  const httpsRegex = /https?:\/\/[\w.-]+\/([\w.-]+)\/([\w.-]+?)(?:\.git)?$/;
+  const sshMatch = remoteUrl.match(sshRegex);
+  if (sshMatch) {
+    return {
+      owner: sshMatch[1],
+      repo: sshMatch[2]
+    };
+  }
+  const httpsMatch = remoteUrl.match(httpsRegex);
+  if (httpsMatch) {
+    return {
+      owner: httpsMatch[1],
+      repo: httpsMatch[2]
+    };
+  }
+  return null;
+}
+async function createCommitAndTags({
+  config,
+  noVerify,
+  bumpedPackages,
+  newVersion,
+  dryRun,
+  logLevel
+}) {
+  const 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(config.cwd)) {
+      logger.verbose(`Skipping lerna.json as it doesn't exist`);
+      continue;
+    }
+    if ((pattern === "lerna.json" || pattern === "CHANGELOG.md") && !existsSync(join(config.cwd, pattern))) {
+      logger.verbose(`Skipping ${pattern} as it doesn't exist`);
+      continue;
+    }
+    if (dryRun) {
+      logger.info(`[dry-run] git add ${pattern}`);
+      continue;
+    }
+    try {
+      logger.debug(`git add ${pattern}`);
+      execSync(`git add ${pattern}`);
+    } catch {
+    }
+  }
+  const rootPackage = getRootPackage(config.cwd);
+  newVersion = newVersion || rootPackage.version;
+  const versionForMessage = config.monorepo?.versionMode === "independent" ? bumpedPackages?.map((pkg) => `${pkg.name}@${pkg.version}`).join(", ") || "unknown" : newVersion || "unknown";
+  const commitMessage = config.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: config.cwd
+    });
+    logger.success(`Committed: ${commitMessage}${noVerify ? " (--no-verify)" : ""}`);
+  }
+  const signTags = config.signTags ? "-s" : "";
+  logger.debug(`Sign tags: ${config.signTags}`);
+  const createdTags = [];
+  if (config.monorepo?.versionMode === "independent" && bumpedPackages && bumpedPackages.length > 0) {
+    logger.debug(`Creating ${bumpedPackages.length} independent package tags`);
+    for (const pkg of bumpedPackages) {
+      const tagName = `${pkg.name}@${pkg.version}`;
+      const tagMessage = config.templates?.tagMessage?.replaceAll("{{newVersion}}", pkg.version || "") || tagName;
+      if (dryRun) {
+        logger.info(`[dry-run] git tag ${signTags} -a ${tagName} -m "${tagMessage}"`);
+      } else {
+        const cmd = `git tag ${signTags} -a ${tagName} -m "${tagMessage}"`;
+        logger.debug(`Executing: ${cmd}`);
+        try {
+          await execPromise(cmd, {
+            logLevel,
+            noStderr: true,
+            noStdout: true,
+            cwd: config.cwd
+          });
+          logger.debug(`Tag created: ${tagName}`);
+        } catch (error) {
+          logger.error(`Failed to create tag ${tagName}:`, error);
+          throw error;
+        }
+      }
+      createdTags.push(tagName);
+    }
+    logger.success(`Created ${createdTags.length} tags for independent packages, ${createdTags.join(", ")}`);
+  } else {
+    const tagName = config.templates.tagBody?.replaceAll("{{newVersion}}", newVersion);
+    const tagMessage = config.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: config.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!");
+  return createdTags;
+}
+async function pushCommitAndTags({ dryRun, logLevel, cwd }) {
+  logger.start("Start push changes and tags");
+  if (dryRun) {
+    logger.info("[dry-run] git push --follow-tags");
+  } else {
+    logger.debug("Executing: git push --follow-tags");
+    await execPromise("git push --follow-tags", { noStderr: true, noStdout: true, logLevel, cwd });
+  }
+  logger.success("End push changes and tags");
+}
+function getFirstCommit(cwd) {
+  const result = execSync(
+    "git rev-list --max-parents=0 HEAD",
+    {
+      cwd,
+      encoding: "utf8"
+    }
+  );
+  return result.trim();
+}
+function getCurrentGitBranch(cwd) {
+  const result = execSync("git rev-parse --abbrev-ref HEAD", {
+    cwd,
+    encoding: "utf8"
+  });
+  return result.trim();
+}
+function getCurrentGitRef(cwd) {
+  const branch = getCurrentGitBranch(cwd);
+  return branch || "HEAD";
+}
+
+async function githubIndependentMode({
+  config,
+  dryRun,
+  bumpedPackages
+}) {
+  const repoConfig = config.repo;
+  if (!repoConfig) {
+    throw new Error("No repository configuration found. Please check your changelog config.");
+  }
+  logger.debug(`GitHub token: ${config.tokens.github ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github) {
+    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+  }
+  const packages = bumpedPackages || getPackages({
+    cwd: config.cwd,
+    patterns: config.monorepo?.packages,
+    ignorePackageNames: config.monorepo?.ignorePackageNames
+  });
+  logger.info(`Creating ${packages.length} GitHub release(s)`);
+  const postedReleases = [];
+  for (const pkg of packages) {
+    const to = `${pkg.name}@${pkg.version}`;
+    const from = pkg.fromTag;
+    if (!from) {
+      logger.warn(`No fromTag found for ${pkg.name}, skipping release`);
+      continue;
+    }
+    const toTag = dryRun ? "HEAD" : to;
+    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${toTag}`);
+    const commits = await getPackageCommits({
+      pkg,
+      to: toTag,
+      from,
+      config,
+      changelog: true
+    });
+    const changelog = await generateChangelog({
+      pkg,
+      commits,
+      config,
+      from,
+      dryRun
+    });
+    const releaseBody = changelog.split("\n").slice(2).join("\n");
+    const release = {
+      tag_name: to,
+      name: to,
+      body: releaseBody,
+      prerelease: isPrerelease(pkg.version)
+    };
+    logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
+    if (dryRun) {
+      logger.info(`[dry-run] Publish GitHub release for ${to}`);
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: pkg.version,
+        prerelease: release.prerelease
+      });
+    } else {
+      logger.debug(`Publishing release ${to} to GitHub...`);
+      await createGithubRelease({
+        ...config,
+        from,
+        to,
+        repo: repoConfig
+      }, release);
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: pkg.version,
+        prerelease: release.prerelease
+      });
+    }
+  }
+  if (postedReleases.length === 0) {
+    logger.warn("No releases created");
+  } else {
+    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitHub!`);
+  }
+  return postedReleases;
+}
+async function githubUnified({
+  config,
+  dryRun,
+  rootPackage,
+  fromTag,
+  oldVersion
+}) {
+  const repoConfig = config.repo;
+  if (!repoConfig) {
+    throw new Error("No repository configuration found. Please check your changelog config.");
+  }
+  logger.debug(`GitHub token: ${config.tokens.github ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github) {
+    throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
+  }
+  const to = config.templates.tagBody.replace("{{newVersion}}", rootPackage.version);
+  const toTag = dryRun ? "HEAD" : to;
+  const commits = await getPackageCommits({
+    pkg: rootPackage,
+    config,
+    from: fromTag || getFirstCommit(config.cwd),
+    to: toTag,
+    changelog: true
+  });
+  logger.debug(`Found ${commits.length} commit(s)`);
+  const changelog = await generateChangelog({
+    pkg: rootPackage,
+    commits,
+    config,
+    from: fromTag || oldVersion || "v0.0.0",
+    dryRun
+  });
+  const releaseBody = changelog.split("\n").slice(2).join("\n");
+  const release = {
+    tag_name: to,
+    name: to,
+    body: releaseBody,
+    prerelease: isPrerelease(to)
+  };
+  logger.debug(`Creating release for ${to}${release.prerelease ? " (prerelease)" : ""}`);
+  logger.debug("Release details:", formatJson({
+    tag_name: release.tag_name,
+    name: release.name,
+    prerelease: release.prerelease
+  }));
+  if (dryRun) {
+    logger.info("[dry-run] Publish GitHub release for", release.tag_name);
+  } else {
+    logger.debug("Publishing release to GitHub...");
+    await createGithubRelease({
+      ...config,
+      from: fromTag || oldVersion || "v0.0.0",
+      to,
+      repo: repoConfig
+    }, release);
+  }
+  logger.success(`Release ${to} published to GitHub!`);
+  return [{
+    name: to,
+    tag: to,
+    version: to,
+    prerelease: release.prerelease
+  }];
+}
+async function github(options = {}) {
+  try {
+    logger.start("Start publishing GitHub release");
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const config = await loadMonorepoConfig({
+      configName: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        from: options.from,
+        to: options.to,
+        logLevel: options.logLevel,
+        tokens: {
+          github: options.token || process.env.CHANGELOGEN_TOKENS_GITHUB || process.env.GITHUB_TOKEN || process.env.GH_TOKEN
+        }
+      }
+    });
+    if (!options.bumpResult?.bumped) {
+      logger.warn("No bump result found, skipping release");
+      return [];
+    }
+    if (config.monorepo?.versionMode === "independent") {
+      return await githubIndependentMode({ config, dryRun, bumpedPackages: options.bumpResult.bumpedPackages });
+    }
+    const rootPackage = getRootPackage(config.cwd);
+    return await githubUnified({
+      config,
+      dryRun,
+      rootPackage,
+      fromTag: options.bumpResult.fromTag,
+      oldVersion: options.bumpResult.oldVersion
+    });
+  } catch (error) {
+    logger.error("Error publishing GitHub release:", error);
+    throw error;
+  }
+}
+
+async function createGitlabRelease({
+  config,
+  release,
+  dryRun
+}) {
+  const token = config.tokens.gitlab || process.env.GITLAB_TOKEN || process.env.CI_JOB_TOKEN;
+  if (!token && !dryRun) {
+    throw new Error(
+      "No GitLab token found. Set GITLAB_TOKEN or CI_JOB_TOKEN environment variable or configure tokens.gitlab"
+    );
+  }
+  const repoConfig = config.repo?.repo;
+  if (!repoConfig) {
+    throw new Error("No repository URL found in config");
+  }
+  logger.debug(`Parsed repository URL: ${repoConfig}`);
+  const projectPath = encodeURIComponent(repoConfig);
+  const gitlabDomain = config.repo?.domain || "gitlab.com";
+  const apiUrl = `https://${gitlabDomain}/api/v4/projects/${projectPath}/releases`;
+  logger.info(`Creating GitLab release at: ${apiUrl}`);
+  const payload = {
+    tag_name: release.tag_name,
+    name: release.name || release.tag_name,
+    description: release.description || "",
+    ref: release.ref || "main"
+  };
+  try {
+    if (dryRun) {
+      logger.info("[dry-run] GitLab release:", formatJson(payload));
+      return {
+        tag_name: release.tag_name,
+        name: release.name || release.tag_name,
+        description: release.description || "",
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        released_at: (/* @__PURE__ */ new Date()).toISOString(),
+        _links: {
+          self: `${apiUrl}/${encodeURIComponent(release.tag_name)}`
+        }
+      };
+    }
+    logger.debug(`POST GitLab release to ${apiUrl} with payload: ${formatJson(payload)}`);
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PRIVATE-TOKEN": token || ""
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`GitLab API error (${response.status}): ${errorText}`);
+    }
+    const result = await response.json();
+    logger.debug(`Created GitLab release: ${result._links.self}`);
+    return result;
+  } catch (error) {
+    logger.error("Failed to create GitLab release:", error);
+    throw error;
+  }
+}
+async function gitlabIndependentMode({
+  config,
+  dryRun,
+  bumpedPackages
+}) {
+  logger.debug(`GitLab token: ${config.tokens.gitlab ? "\u2713 provided" : "\u2717 missing"}`);
+  const packages = bumpedPackages || getPackages({
+    cwd: config.cwd,
+    patterns: config.monorepo?.packages,
+    ignorePackageNames: config.monorepo?.ignorePackageNames
+  });
+  logger.info(`Creating ${packages.length} GitLab release(s) for independent packages`);
+  logger.debug("Getting current branch...");
+  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
+    noSuccess: true,
+    noStdout: true,
+    logLevel: config.logLevel,
+    cwd: config.cwd
+  });
+  const postedReleases = [];
+  for (const pkg of packages) {
+    const to = `${pkg.name}@${pkg.version}`;
+    const from = pkg.fromTag;
+    if (!from) {
+      logger.warn(`No fromTag found for ${pkg.name}, skipping release`);
+      continue;
+    }
+    logger.debug(`Processing ${pkg.name}: ${from} \u2192 ${to}`);
+    const commits = await getPackageCommits({
+      pkg,
+      config,
+      from,
+      to,
+      changelog: true
+    });
+    const changelog = await generateChangelog({
+      pkg,
+      commits,
+      config,
+      from,
+      dryRun
+    });
+    if (!changelog) {
+      logger.warn(`No changelog found for ${pkg.name}`);
+      continue;
+    }
+    const releaseBody = changelog.split("\n").slice(2).join("\n");
+    const release = {
+      tag_name: to,
+      name: to,
+      description: releaseBody,
+      ref: currentBranch.trim()
+    };
+    logger.debug(`Creating release for ${to} (ref: ${release.ref})`);
+    if (dryRun) {
+      logger.info(`[dry-run] Publish GitLab release for ${to}`);
+    } else {
+      logger.debug(`Publishing release ${to} to GitLab...`);
+      await createGitlabRelease({
+        config,
+        release,
+        dryRun
+      });
+      postedReleases.push({
+        name: pkg.name,
+        tag: release.tag_name,
+        version: pkg.version,
+        prerelease: isPrerelease(pkg.version)
+      });
+    }
+  }
+  if (postedReleases.length === 0) {
+    logger.warn("No releases created");
+  } else {
+    logger.success(`Releases ${postedReleases.map((r) => r.tag).join(", ")} published to GitLab!`);
+  }
+  return postedReleases;
+}
+async function gitlabUnified({
+  config,
+  dryRun,
+  rootPackage,
+  fromTag,
+  oldVersion
+}) {
+  logger.debug(`GitLab token: ${config.tokens.gitlab ? "\u2713 provided" : "\u2717 missing"}`);
+  const to = config.templates.tagBody.replace("{{newVersion}}", rootPackage.version);
+  const commits = await getPackageCommits({
+    pkg: rootPackage,
+    config,
+    from: fromTag || getFirstCommit(config.cwd),
+    to,
+    changelog: true
+  });
+  logger.debug(`Found ${commits.length} commit(s)`);
+  const changelog = await generateChangelog({
+    pkg: rootPackage,
+    commits,
+    config,
+    from: fromTag || oldVersion || "v0.0.0",
+    dryRun
+  });
+  const releaseBody = changelog.split("\n").slice(2).join("\n");
+  logger.debug("Getting current branch...");
+  const { stdout: currentBranch } = await execPromise("git rev-parse --abbrev-ref HEAD", {
+    noSuccess: true,
+    noStdout: true,
+    logLevel: config.logLevel,
+    cwd: config.cwd
+  });
+  const release = {
+    tag_name: to,
+    name: to,
+    description: releaseBody,
+    ref: currentBranch.trim()
+  };
+  logger.info(`Creating release for ${to} (ref: ${release.ref})`);
+  logger.debug("Release details:", formatJson({
+    tag_name: release.tag_name,
+    name: release.name,
+    ref: release.ref
+  }));
+  if (dryRun) {
+    logger.info("[dry-run] Publish GitLab release for", release.tag_name);
+  } else {
+    logger.debug("Publishing release to GitLab...");
+    await createGitlabRelease({
+      config,
+      release,
+      dryRun
+    });
+  }
+  logger.success(`Release ${to} published to GitLab!`);
+  return [{
+    name: to,
+    tag: to,
+    version: to,
+    prerelease: isPrerelease(rootPackage.version)
+  }];
+}
+async function gitlab(options = {}) {
+  try {
+    logger.start("Start publishing GitLab release");
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const config = await loadMonorepoConfig({
+      configName: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        from: options.from,
+        to: options.to,
+        logLevel: options.logLevel,
+        tokens: {
+          gitlab: options.token || process.env.CHANGELOGEN_TOKENS_GITLAB || process.env.GITLAB_TOKEN || process.env.GITLAB_API_TOKEN || process.env.CI_JOB_TOKEN
+        }
+      }
+    });
+    if (!options.bumpResult?.bumped) {
+      logger.warn("No bump result found, skipping release");
+      return [];
+    }
+    if (config.monorepo?.versionMode === "independent") {
+      return await gitlabIndependentMode({
+        config,
+        dryRun,
+        bumpedPackages: options.bumpResult.bumpedPackages
+      });
+    }
+    const rootPackage = getRootPackage(process.cwd());
+    logger.debug(`Root package: ${rootPackage.name}@${rootPackage.version}`);
+    return await gitlabUnified({
+      config,
+      dryRun,
+      rootPackage,
+      fromTag: options.bumpResult.fromTag,
+      oldVersion: options.bumpResult.oldVersion
+    });
+  } catch (error) {
+    logger.error("Error publishing GitLab release:", error);
+    throw error;
+  }
+}
+
+function getPackageInfo(packagePath, ignorePackageNames) {
+  const packageJsonPath = join(packagePath, "package.json");
+  if (!existsSync(packageJsonPath))
+    return null;
+  if (!statSync(packagePath).isDirectory())
+    return null;
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (packageJson.private) {
+      logger.debug(`${packageJson.name} is private and will be ignored`);
+      return null;
+    }
+    if (ignorePackageNames?.includes(packageJson.name)) {
+      logger.debug(`${packageJson.name} ignored by config monorepo.ignorePackageNames`);
+      return null;
+    }
+    if (!packageJson.version) {
+      logger.warn(`${packageJson.name} has no version and will be ignored`);
+      return null;
+    }
+    return {
+      name: packageJson.name,
+      currentVersion: packageJson.version,
+      path: packagePath,
+      version: packageJson.version
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.warn(`Unable to read ${packageJsonPath}:`, errorMessage);
+    return null;
+  }
+}
+function getPackages({
+  cwd,
+  patterns,
+  ignorePackageNames
+}) {
+  const packages = [];
+  const foundPaths = /* @__PURE__ */ new Set();
+  if (!patterns)
+    patterns = ["."];
+  logger.debug(`Getting packages from patterns: ${patterns.join(", ")}`);
+  for (const pattern of patterns) {
+    try {
+      const matches = fastGlob.sync(pattern, {
+        cwd,
+        onlyDirectories: true,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+      });
+      for (const matchPath of matches) {
+        if (foundPaths.has(matchPath))
+          continue;
+        const packageInfo = getPackageInfo(matchPath, ignorePackageNames);
+        if (packageInfo) {
+          foundPaths.add(matchPath);
+          packages.push(packageInfo);
+        }
+      }
+    } catch (error) {
+      logger.error(`Unable to match pattern "${pattern}":`, error);
+    }
+  }
+  return packages;
+}
+function isAllowedCommit({
+  commit,
+  type,
+  changelog
+}) {
+  if (commit.type === "chore" && ["deps", "release"].includes(commit.scope) && !commit.isBreaking) {
+    return false;
+  }
+  if (typeof type === "object") {
+    return !!type.semver || changelog && !!type.title;
+  }
+  if (typeof type === "boolean") {
+    return type;
+  }
+  return false;
+}
+async function getPackageCommits({
+  pkg,
+  from,
+  to,
+  config,
+  changelog
+}) {
+  logger.debug(`Analyzing commits for ${pkg.name} since ${from} to ${to}`);
+  const changelogConfig = {
+    ...config,
+    from,
+    to
+  };
+  const rawCommits = await getGitDiff(from, to, changelogConfig.cwd);
+  const allCommits = parseCommits(rawCommits, changelogConfig);
+  const hasBreakingChanges = allCommits.some((commit) => commit.isBreaking);
+  logger.debug(`Has breaking changes: ${hasBreakingChanges}`);
+  const rootPackage = getRootPackage(changelogConfig.cwd);
+  const commits = allCommits.filter((commit) => {
+    const type = changelogConfig?.types[commit.type];
+    if (!isAllowedCommit({ commit, type, changelog })) {
+      return false;
+    }
+    if (pkg.path === changelogConfig.cwd || pkg.name === rootPackage.name) {
+      return true;
+    }
+    const packageRelativePath = pkg.path.replace(`${changelogConfig.cwd}/`, "");
+    const scopeMatches = commit.scope === pkg.name;
+    const bodyContainsPath = commit.body.includes(packageRelativePath);
+    return scopeMatches || bodyContainsPath;
+  });
+  logger.debug(`Found ${commits.length} commit(s) for ${pkg.name} from ${from} to ${to}`);
+  if (commits.length > 0) {
+    logger.debug(`${pkg.name}: ${commits.length} commit(s) found`);
+  } else {
+    logger.debug(`${pkg.name}: No commits found`);
+  }
+  return commits;
+}
+function getRootPackage(rootDir) {
+  const packageJsonPath = join(rootDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    throw new Error(`package.json not found at ${packageJsonPath}`);
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return {
+      name: packageJson.name,
+      currentVersion: packageJson.version || "0.0.0",
+      path: rootDir,
+      version: packageJson.version || "0.0.0"
+    };
+  } catch (error) {
+    throw new Error(`Unable to read ${packageJsonPath}: ${error}`);
+  }
+}
+function hasLernaJson(rootDir) {
+  const lernaJsonPath = join(rootDir, "lerna.json");
+  return existsSync(lernaJsonPath);
+}
+async function getPackageToBump({
+  packages,
+  config,
+  from,
+  to
+}) {
+  const packagesWithCommits = [];
+  for (const pkg of packages) {
+    const commits = await getPackageCommits({
+      pkg,
+      from,
+      to,
+      config,
+      changelog: false
+    });
+    const graduating = isGraduating(pkg.version, config.bump.type) || isChangedPreid(pkg.version, config.bump.preid);
+    if (commits.length > 0 || graduating) {
+      packagesWithCommits.push({ ...pkg, commits });
+    }
+  }
+  const allPackagesToBump = expandPackagesToBumpWithDependents({
+    allPackages: packages,
+    packagesWithCommits,
+    dependencyTypes: config.bump?.dependencyTypes
+  });
+  return allPackagesToBump;
+}
+
+function detectReleaseTypeFromCommits(commits, config) {
+  return determineSemverChange(commits, config);
+}
+function validatePrereleaseDowngrade(currentVersion, targetPreid, configuredType) {
+  if (configuredType !== "prerelease" || !targetPreid || !isPrerelease(currentVersion)) {
+    return;
+  }
+  const testVersion = semver.inc(currentVersion, "prerelease", targetPreid);
+  if (testVersion && !semver.gt(testVersion, currentVersion)) {
+    throw new Error(`Unable to graduate from ${currentVersion} to ${testVersion}, it's not a valid prerelease`);
+  }
+}
+function handleStableVersionWithReleaseType(commits, config, force) {
+  if (!commits?.length && !force) {
+    logger.debug('No commits found for stable version with "release" type, skipping bump');
+    return null;
+  }
+  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, config) : null;
+  if (!detectedType && !force) {
+    logger.debug("No significant commits found, skipping bump");
+    return null;
+  }
+  logger.debug(`Auto-detected release type from commits: ${detectedType}`);
+  return detectedType;
+}
+function handleStableVersionWithPrereleaseType(commits, config, force) {
+  if (!commits?.length && !force) {
+    logger.debug('No commits found for stable version with "prerelease" type, skipping bump');
+    return null;
+  }
+  const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, config) : null;
+  if (!detectedType) {
+    logger.debug("No significant commits found, using prepatch as default");
+    return "prepatch";
+  }
+  const prereleaseType = `pre${detectedType}`;
+  logger.debug(`Auto-detected prerelease type from commits: ${prereleaseType}`);
+  return prereleaseType;
+}
+function handlePrereleaseVersionToStable(currentVersion) {
+  logger.debug(`Graduating from prerelease ${currentVersion} to stable release`);
+  return "release";
+}
+function handlePrereleaseVersionWithPrereleaseType(currentVersion, targetPreid, commits, config, force) {
+  const currentPreid = getPreid(currentVersion);
+  const hasChangedPreid = targetPreid && currentPreid && currentPreid !== targetPreid;
+  if (hasChangedPreid) {
+    const testVersion = semver.inc(currentVersion, "prerelease", targetPreid);
+    if (!testVersion) {
+      throw new Error(`Unable to change preid from ${currentPreid} to ${targetPreid} for version ${currentVersion}`);
+    }
+    const isUpgrade = semver.gt(testVersion, currentVersion);
+    if (!isUpgrade) {
+      throw new Error(`Unable to change preid from ${currentVersion} to ${testVersion}, it's not a valid upgrade (cannot downgrade from ${currentPreid} to ${targetPreid})`);
+    }
+    const detectedType = commits?.length ? detectReleaseTypeFromCommits(commits, config) : null;
+    const prereleaseType = detectedType ? `pre${detectedType}` : "prepatch";
+    logger.debug(`Changing preid from ${currentPreid} to ${targetPreid} with release type: ${prereleaseType}`);
+    return prereleaseType;
+  }
+  if (!commits?.length && !force) {
+    logger.debug("No commits found for prerelease version, skipping bump");
+    return null;
+  }
+  logger.debug(`Incrementing prerelease version: ${currentVersion}`);
+  return "prerelease";
+}
+function handleExplicitReleaseType(configuredType, currentVersion) {
+  const isCurrentPrerelease = isPrerelease(currentVersion);
+  const isGraduatingToStable = isCurrentPrerelease && isStableReleaseType(configuredType);
+  if (isGraduatingToStable) {
+    logger.debug(`Graduating from prerelease ${currentVersion} to stable with type: ${configuredType}`);
+  } else {
+    logger.debug(`Using explicit release type: ${configuredType}`);
+  }
+  return configuredType;
+}
+function determineReleaseType({
+  currentVersion,
+  from,
+  to,
+  commits,
+  config,
+  force
+}) {
+  const configWithRange = {
+    ...config,
+    from,
+    to
+  };
+  const configuredType = configWithRange.bump.type;
+  const targetPreid = configWithRange.bump.preid;
+  if (configuredType === "release" && targetPreid) {
+    throw new Error('You cannot use a "release" type with a "preid", to use a preid you must use a "prerelease" type');
+  }
+  validatePrereleaseDowngrade(currentVersion, targetPreid, configuredType);
+  if (force) {
+    logger.debug(`Force flag enabled, using configured type: ${configuredType}`);
+    return configuredType;
+  }
+  const isCurrentPrerelease = isPrerelease(currentVersion);
+  if (!isCurrentPrerelease) {
+    if (configuredType === "release") {
+      return handleStableVersionWithReleaseType(commits, configWithRange, force);
+    }
+    if (configuredType === "prerelease") {
+      return handleStableVersionWithPrereleaseType(commits, configWithRange, force);
+    }
+    return handleExplicitReleaseType(configuredType, currentVersion);
+  }
+  if (configuredType === "release") {
+    return handlePrereleaseVersionToStable(currentVersion);
+  }
+  if (configuredType === "prerelease") {
+    return handlePrereleaseVersionWithPrereleaseType(
+      currentVersion,
+      targetPreid,
+      commits,
+      configWithRange,
+      force
+    );
+  }
+  return handleExplicitReleaseType(configuredType, currentVersion);
+}
+function writeVersion(pkgPath, version, dryRun = false) {
+  const packageJsonPath = join(pkgPath, "package.json");
+  try {
+    logger.debug(`Writing ${version} to ${pkgPath}`);
+    const content = readFileSync(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(content);
+    const oldVersion = packageJson.version;
+    packageJson.version = version;
+    if (dryRun) {
+      logger.info(`[dry-run] Updated ${packageJson.name}: ${oldVersion} \u2192 ${version}`);
+      return;
+    }
+    writeFileSync(packageJsonPath, `${formatJson(packageJson)}
+`, "utf8");
+    logger.info(`Updated ${packageJson.name}: ${oldVersion} \u2192 ${version}`);
+  } catch (error) {
+    throw new Error(`Unable to write version to ${packageJsonPath}: ${error}`);
+  }
+}
+function bumpPackageVersion({
+  currentVersion,
+  releaseType,
+  preid,
+  suffix
+}) {
+  let newVersion = semver.inc(currentVersion, releaseType, preid);
+  if (!newVersion) {
+    throw new Error(`Unable to bump version "${currentVersion}" with release type "${releaseType}"`);
+  }
+  if (isPrereleaseReleaseType(releaseType) && suffix) {
+    newVersion = newVersion.replace(/\.(\d+)$/, `.${suffix}`);
+  }
+  const isValidVersion = semver.gt(newVersion, currentVersion);
+  if (!isValidVersion) {
+    throw new Error(`Unable to bump version "${currentVersion}" to "${newVersion}", new version is not greater than current version`);
+  }
+  if (isGraduating(currentVersion, releaseType)) {
+    logger.info(`Graduating from prerelease ${currentVersion} to stable ${newVersion}`);
+  }
+  return newVersion;
+}
+function updateLernaVersion({
+  rootDir,
+  versionMode,
+  version,
+  dryRun = false
+}) {
+  const lernaJsonExists = hasLernaJson(rootDir);
+  if (!lernaJsonExists) {
+    return;
+  }
+  const lernaJsonPath = join(rootDir, "lerna.json");
+  if (!existsSync(lernaJsonPath)) {
+    return;
+  }
+  try {
+    logger.debug("Updating lerna.json version");
+    const content = readFileSync(lernaJsonPath, "utf8");
+    const lernaJson = JSON.parse(content);
+    const oldVersion = lernaJson.version;
+    if (lernaJson.version === "independent" || versionMode === "independent") {
+      logger.debug("Lerna version is independent or version mode is independent, skipping update");
+      return;
+    }
+    lernaJson.version = version;
+    if (dryRun) {
+      logger.info(`[dry-run] update lerna.json: ${oldVersion} \u2192 ${version}`);
+      return;
+    }
+    writeFileSync(lernaJsonPath, `${formatJson(lernaJson)}
+`, "utf8");
+    logger.success(`Updated lerna.json: ${oldVersion} \u2192 ${version}`);
+  } catch (error) {
+    logger.warn(`Unable to update lerna.json: ${error}`);
+  }
+}
+function extractVersionFromPackageTag(tag) {
+  const atIndex = tag.lastIndexOf("@");
+  if (atIndex === -1) {
+    return null;
+  }
+  return tag.slice(atIndex + 1);
+}
+function isPrerelease(version) {
+  if (!version)
+    return false;
+  const prerelease = semver.prerelease(version);
+  return prerelease ? prerelease.length > 0 : false;
+}
+function isStableReleaseType(releaseType) {
+  const stableTypes = ["release", "major", "minor", "patch"];
+  return stableTypes.includes(releaseType);
+}
+function isPrereleaseReleaseType(releaseType) {
+  const prereleaseTypes = ["prerelease", "premajor", "preminor", "prepatch"];
+  return prereleaseTypes.includes(releaseType);
+}
+function isGraduating(currentVersion, releaseType) {
+  return isPrerelease(currentVersion) && isStableReleaseType(releaseType);
+}
+function getPreid(version) {
+  if (!version)
+    return null;
+  const prerelease = semver.prerelease(version);
+  if (!prerelease || prerelease.length === 0) {
+    return null;
+  }
+  return prerelease[0];
+}
+function isChangedPreid(currentVersion, targetPreid) {
+  if (!targetPreid || !isPrerelease(currentVersion)) {
+    return false;
+  }
+  const currentPreid = getPreid(currentVersion);
+  if (!currentPreid) {
+    return false;
+  }
+  return currentPreid !== targetPreid;
+}
+function bumpPackageIndependently({
+  pkg,
+  dryRun
+}) {
+  logger.debug(`Analyzing ${pkg.name}`);
+  const currentVersion = pkg.version || "0.0.0";
+  const newVersion = pkg.version;
+  logger.debug(`Bumping ${pkg.name} from ${currentVersion} to ${newVersion}`);
+  writeVersion(pkg.path, newVersion, dryRun);
+  return { bumped: true, newVersion, oldVersion: currentVersion };
+}
+function displayRootAndLernaUpdates({
+  versionMode,
+  currentVersion,
+  newVersion,
+  dryRun,
+  lernaJsonExists
+}) {
+  if (versionMode !== "independent" && currentVersion && newVersion) {
+    logger.log(`${dryRun ? "[dry-run] " : ""}Root package.json: ${currentVersion} \u2192 ${newVersion}`);
+    logger.log("");
+    if (lernaJsonExists) {
+      logger.log(`${dryRun ? "[dry-run] " : ""}lerna.json: ${currentVersion} \u2192 ${newVersion}`);
+      logger.log("");
+    }
+  }
+}
+function displayUnifiedModePackages({
+  packages,
+  newVersion,
+  force
+}) {
+  logger.log(`${packages.length} package(s)${force ? " (force)" : ""}:`);
+  packages.forEach((pkg) => {
+    logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion}`);
+  });
+  logger.log("");
+}
+function displaySelectiveModePackages({
+  packages,
+  newVersion,
+  force
+}) {
+  if (force) {
+    logger.log(`${packages.length} package(s) (force):`);
+    packages.forEach((pkg) => {
+      logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion}`);
+    });
+    logger.log("");
+  } else {
+    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
+    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
+    if (packagesWithCommits.length > 0) {
+      logger.log(`${packagesWithCommits.length} package(s) with commits:`);
+      packagesWithCommits.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsDependents.length > 0) {
+      logger.log(`${packagesAsDependents.length} dependent package(s):`);
+      packagesAsDependents.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.version} \u2192 ${newVersion}`);
+      });
+      logger.log("");
+    }
+  }
+}
+function displayIndependentModePackages({
+  packages,
+  force,
+  dryRun
+}) {
+  if (force) {
+    logger.log(`${dryRun ? "[dry-run] " : ""}${packages.length} package(s) (force):`);
+    packages.forEach((pkg) => {
+      logger.log(`  \u2022 ${pkg.name}: ${pkg.currentVersion} \u2192 ${pkg.version}`);
+    });
+    logger.log("");
+  } else {
+    const packagesWithCommits = packages.filter((p) => "reason" in p && p.reason === "commits");
+    const packagesAsDependents = packages.filter((p) => "reason" in p && p.reason === "dependency");
+    if (packagesWithCommits.length > 0) {
+      logger.log(`${dryRun ? "[dry-run] " : ""}${packagesWithCommits.length} package(s) with commits:`);
+      packagesWithCommits.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.currentVersion} \u2192 ${pkg.version}`);
+      });
+      logger.log("");
+    }
+    if (packagesAsDependents.length > 0) {
+      logger.log(`${dryRun ? "[dry-run] " : ""}${packagesAsDependents.length} dependent package(s):`);
+      packagesAsDependents.forEach((pkg) => {
+        logger.log(`  \u2022 ${pkg.name}: ${pkg.currentVersion} \u2192 ${pkg.version}`);
+      });
+      logger.log("");
+    }
+  }
+}
+async function confirmBump({
+  versionMode,
+  config,
+  packages,
+  force,
+  currentVersion,
+  newVersion,
+  dryRun
+}) {
+  const lernaJsonExists = hasLernaJson(config.cwd);
+  logger.log("");
+  logger.info(`${dryRun ? "[dry-run] " : ""}The following packages will be updated:
+`);
+  displayRootAndLernaUpdates({
+    versionMode,
+    currentVersion,
+    newVersion,
+    lernaJsonExists,
+    dryRun
+  });
+  if (versionMode === "unified" && newVersion) {
+    displayUnifiedModePackages({ packages, newVersion, force });
+  } else if (versionMode === "selective" && newVersion) {
+    displaySelectiveModePackages({ packages, newVersion, force });
+  } else if (versionMode === "independent") {
+    displayIndependentModePackages({ packages, force, dryRun });
+  }
+  try {
+    const confirmed = await confirm({
+      message: `${dryRun ? "[dry-run] " : ""}Do you want to proceed with these version updates?`,
+      default: true
+    });
+    if (!confirmed) {
+      logger.warn("Bump cancelled by user");
+      process.exit(0);
+    }
+  } catch {
+    logger.error("Error while confirming bump");
+    process.exit(1);
+  }
+  logger.log("");
+}
+async function findPackagesWithCommits({
+  packages,
+  config,
+  force
+}) {
+  const packagesWithCommits = [];
+  logger.debug(`Checking for commits in ${packages.length} package(s)`);
+  for (const pkg of packages) {
+    const { from, to } = await resolveTags({
+      config,
+      versionMode: "independent",
+      step: "bump",
+      currentVersion: pkg.version,
+      newVersion: void 0,
+      pkg,
+      logLevel: config.logLevel
+    });
+    const commits = await getPackageCommits({
+      pkg,
+      from,
+      to,
+      config,
+      changelog: false
+    });
+    if (commits.length <= 0 && !force) {
+      logger.debug(`${pkg.name}: No commits found, skipping`);
+      continue;
+    }
+    packagesWithCommits.push({ ...pkg, commits });
+    logger.debug(`${pkg.name}: ${commits.length} commit(s)`);
+  }
+  return packagesWithCommits;
+}
+async function calculatePackageNewVersion({
+  pkg,
+  config,
+  force,
+  suffix
+}) {
+  const releaseType = config.bump.type;
+  const { from, to } = await resolveTags({
+    config,
+    versionMode: "independent",
+    step: "bump",
+    currentVersion: pkg.version,
+    newVersion: void 0,
+    pkg,
+    logLevel: config.logLevel
+  });
+  const forcedBump = pkg.reason === "dependency";
+  let forcedBumpType;
+  if (forcedBump) {
+    if (isStableReleaseType(releaseType)) {
+      forcedBumpType = "patch";
+    } else {
+      forcedBumpType = isPrerelease(pkg.version) ? "prerelease" : "prepatch";
+    }
+  }
+  const commits = pkg.commits?.length > 0 ? pkg.commits : await getPackageCommits({
+    pkg,
+    from,
+    to,
+    config,
+    changelog: false
+  });
+  let calculatedReleaseType = null;
+  if (forcedBumpType) {
+    calculatedReleaseType = forcedBumpType;
+  } else if (commits.length === 0 && !force) {
+    return null;
+  } else {
+    calculatedReleaseType = determineReleaseType({ from, to, commits, config, force, currentVersion: pkg.version });
+    if (!calculatedReleaseType) {
+      return null;
+    }
+  }
+  const currentVersion = pkg.version || "0.0.0";
+  const newVersion = bumpPackageVersion({
+    currentVersion,
+    releaseType: calculatedReleaseType,
+    preid: config.bump.preid,
+    suffix
+  });
+  return {
+    name: pkg.name,
+    path: pkg.path,
+    currentVersion,
+    version: newVersion,
+    fromTag: from,
+    reason: pkg.reason,
+    commits,
+    dependencyChain: pkg.dependencyChain
+  };
+}
+async function calculateNewVersionsForPackages({
+  allPackagesToBump,
+  config,
+  force,
+  suffix
+}) {
+  const packagesWithNewVersions = [];
+  for (const pkgToBump of allPackagesToBump) {
+    const packageWithNewVersion = await calculatePackageNewVersion({
+      pkg: pkgToBump,
+      config,
+      force,
+      suffix
+    });
+    if (packageWithNewVersion) {
+      packagesWithNewVersions.push(packageWithNewVersion);
+    }
+  }
+  return packagesWithNewVersions;
+}
+async function findPackagesWithCommitsAndCalculateVersions({
+  packages,
+  config,
+  force,
+  suffix
+}) {
+  const packagesWithCommits = await findPackagesWithCommits({
+    packages,
+    config,
+    force
+  });
+  if (packagesWithCommits.length === 0) {
+    return [];
+  }
+  const allPackagesToBump = expandPackagesToBumpWithDependents({
+    allPackages: packages,
+    packagesWithCommits,
+    dependencyTypes: config.bump.dependencyTypes
+  });
+  logger.debug(`Total packages to bump (including dependents): ${allPackagesToBump.length}`);
+  const packagesWithNewVersions = await calculateNewVersionsForPackages({
+    allPackagesToBump,
+    config,
+    force,
+    suffix
+  });
+  logger.debug(`Found ${packagesWithNewVersions.length} package(s) to bump`);
+  return packagesWithNewVersions;
+}
+function bumpIndependentPackages({
+  packages,
+  dryRun
+}) {
+  const bumpedPackages = [];
+  for (const pkgToBump of packages) {
+    logger.debug(`Bumping ${pkgToBump.name} from ${pkgToBump.currentVersion} to ${pkgToBump.version} (reason: ${pkgToBump.reason})`);
+    const result = bumpPackageIndependently({
+      pkg: pkgToBump,
+      dryRun
+    });
+    if (result.bumped) {
+      bumpedPackages.push({
+        ...pkgToBump,
+        version: result.newVersion
+      });
+    }
+  }
+  return bumpedPackages;
+}
+
+async function getLastRepoTag(options) {
+  let lastTag = null;
+  if (options?.onlyStable) {
+    const { stdout: stdout2 } = await execPromise(
+      `git tag --sort=-creatordate | grep -E '^[^0-9]*[0-9]+\\.[0-9]+\\.[0-9]+$' | head -n 1`,
+      {
+        logLevel: options?.logLevel,
+        noStderr: true,
+        noStdout: true,
+        noSuccess: true,
+        cwd: options?.cwd
+      }
+    );
+    lastTag = stdout2.trim();
+    logger.debug("Last stable tag:", lastTag || "No stable tags found");
+    return lastTag;
+  }
+  const { stdout } = await execPromise(`git tag --sort=-creatordate | head -n 1`, {
+    logLevel: options?.logLevel,
+    noStderr: true,
+    noStdout: true,
+    noSuccess: true,
+    cwd: options?.cwd
+  });
+  lastTag = stdout.trim();
+  logger.debug("Last tag:", lastTag || "No tags found");
+  return lastTag;
+}
+async function getLastPackageTag({
+  packageName,
+  onlyStable,
+  logLevel,
+  cwd
+}) {
+  try {
+    const escapedPackageName = packageName.replace(/[@/]/g, "\\$&");
+    let grepPattern;
+    if (onlyStable) {
+      grepPattern = `^${escapedPackageName}@[0-9]+\\.[0-9]+\\.[0-9]+$`;
+    } else {
+      grepPattern = `^${escapedPackageName}@`;
+    }
+    const { stdout } = await execPromise(
+      `git tag --sort=-creatordate | grep -E '${grepPattern}' | sed -n '1p'`,
+      {
+        logLevel,
+        noStderr: true,
+        noStdout: true,
+        noSuccess: true,
+        cwd
+      }
+    );
+    const tag = stdout.trim();
+    return tag || null;
+  } catch {
+    return null;
+  }
+}
+async function resolveTagsIndependent({
+  cwd,
+  pkg,
+  graduating,
+  newVersion,
+  step,
+  logLevel
+}) {
+  let to;
+  if (step === "bump") {
+    to = getCurrentGitRef(cwd);
+  } else {
+    to = newVersion ? `${pkg.name}@${newVersion}` : getCurrentGitRef(cwd);
+  }
+  const lastPackageTag = await getLastPackageTag({
+    packageName: pkg.name,
+    onlyStable: graduating,
+    logLevel
+  });
+  if (!lastPackageTag) {
+    const from = await getLastRepoTag({ logLevel }) || getFirstCommit(cwd);
+    return { from, to };
+  }
+  return { from: lastPackageTag, to };
+}
+async function resolveTagsUnified({
+  config,
+  newVersion,
+  graduating,
+  step,
+  logLevel
+}) {
+  let to;
+  if (step === "bump") {
+    to = getCurrentGitRef(config.cwd);
+  } else {
+    to = newVersion ? config.templates.tagBody.replace("{{newVersion}}", newVersion) : getCurrentGitRef(config.cwd);
+  }
+  const from = await getLastRepoTag({ onlyStable: graduating, logLevel }) || getFirstCommit(config.cwd);
+  return { from, to };
+}
+async function resolveTags({
+  config,
+  versionMode,
+  step,
+  pkg,
+  currentVersion,
+  newVersion,
+  logLevel
+}) {
+  logger.debug(`[${versionMode}](${step}) Resolving tags`);
+  const graduating = currentVersion && isGraduating(currentVersion, config.bump.type) || false;
+  const newTags = newVersion && config.templates.tagBody.replace("{{newVersion}}", newVersion) || null;
+  if (config.from) {
+    const tags2 = {
+      from: config.from,
+      to: config.to || newTags || getCurrentGitRef(config.cwd)
+    };
+    logger.debug(`[${versionMode}](${step}) Using specified tags: ${tags2.from} \u2192 ${tags2.to}`);
+    return tags2;
+  }
+  if (versionMode === "independent") {
+    const tags2 = await resolveTagsIndependent({
+      cwd: config.cwd,
+      pkg,
+      graduating,
+      newVersion,
+      step,
+      logLevel
+    });
+    logger.debug(`[${versionMode}](${step}) Using tags: ${tags2.from} \u2192 ${tags2.to}`);
+    return tags2;
+  }
+  const tags = await resolveTagsUnified({
+    config,
+    newVersion,
+    graduating,
+    step,
+    logLevel
+  });
+  logger.debug(`[${versionMode}](${step}) Using tags: ${tags.from} \u2192 ${tags.to}`);
+  return tags;
+}
+
+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) {
+        logger.warn(`Failed to parse package.json: ${e.message}`);
+      }
+    }
+    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.warn(`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,
+      versionMode: "independent",
+      step: "publish",
+      pkg,
+      newVersion: pkg.version,
+      currentVersion: void 0,
+      logLevel: config.logLevel
+    });
+    const commits = await getPackageCommits({
+      pkg,
+      from,
+      to,
+      config,
+      changelog: false
+    });
+    if (commits.length > 0) {
+      packagesToPublish.push(pkg);
+      logger.debug(`${pkg.name}: ${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
+}) {
+  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 otp = config.publish.otp;
+  if (otp) {
+    args.push("--otp", otp);
+  }
+  return args;
+}
+async function publishPackage({
+  pkg,
+  config,
+  packageManager,
+  dryRun
+}) {
+  const tag = determinePublishTag(pkg.version, config.publish.tag);
+  logger.debug(`Building publish command for ${pkg.name}`);
+  const args = getCommandArgs({
+    packageManager,
+    tag,
+    config
+  });
+  const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
+  const command = `${baseCommand} ${args.join(" ")}`;
+  const packageNameAndVersion = `${pkg.name}@${pkg.version}`;
+  logger.debug(`Publishing ${packageNameAndVersion} with tag '${tag}' with command: ${command}`);
+  try {
+    process.chdir(pkg.path);
+    logger.debug(`Executing publish command (${command}) in ${pkg.path}`);
+    if (dryRun) {
+      logger.info(`[dry-run] ${packageNameAndVersion}: Run ${command}`);
+    } else {
+      const { stdout } = await execPromise(command, {
+        noStderr: true,
+        noStdout: true,
+        logLevel: config.logLevel,
+        cwd: pkg.path
+      });
+      if (stdout) {
+        logger.debug(stdout);
+      }
+    }
+    if (!dryRun) {
+      logger.info(`Published ${packageNameAndVersion}`);
+    }
+  } catch (error) {
+    logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
+    throw error;
+  } finally {
+    process.chdir(config.cwd);
+  }
+}
+
+async function bumpUnifiedMode({
+  config,
+  packages,
+  dryRun,
+  force,
+  suffix
+}) {
+  logger.debug("Starting bump in unified mode");
+  const rootPackage = getRootPackage(config.cwd);
+  const currentVersion = rootPackage.version;
+  const { from, to } = await resolveTags({
+    config,
+    versionMode: "unified",
+    step: "bump",
+    newVersion: void 0,
+    pkg: void 0,
+    currentVersion,
+    logLevel: config.logLevel
+  });
+  logger.debug(`Bump from ${from} to ${to}`);
+  const commits = await getPackageCommits({
+    pkg: rootPackage,
+    from,
+    to,
+    config,
+    changelog: false
+  });
+  logger.debug(`Found ${commits.length} commits since ${from}`);
+  const releaseType = determineReleaseType({
+    from,
+    to,
+    currentVersion,
+    commits,
+    config,
+    force
+  });
+  if (!releaseType) {
+    logger.debug("No commits require a version bump");
+    return { bumped: false };
+  }
+  if (config.bump.type && force) {
+    logger.debug(`Using specified release type: ${releaseType}`);
+  } else {
+    logger.debug(`Detected release type from commits: ${releaseType}`);
+  }
+  const newVersion = bumpPackageVersion({
+    currentVersion,
+    releaseType,
+    preid: config.bump.preid,
+    suffix
+  });
+  logger.debug(`${currentVersion} \u2192 ${newVersion} (unified mode)`);
+  const allPackages = [rootPackage, ...packages];
+  if (!config.bump.yes) {
+    await confirmBump({
+      versionMode: "unified",
+      config,
+      packages,
+      force,
+      currentVersion,
+      newVersion,
+      dryRun
+    });
+  } else {
+    logger.info(`${allPackages.length === 1 ? allPackages[0].name : allPackages.length} package(s) bumped from ${currentVersion} to ${newVersion} (unified mode)`);
+  }
+  for (const pkg of allPackages) {
+    writeVersion(pkg.path, newVersion, dryRun);
+  }
+  if (newVersion) {
+    updateLernaVersion({
+      rootDir: config.cwd,
+      versionMode: config.monorepo?.versionMode,
+      version: newVersion,
+      dryRun
+    });
+  }
+  if (!dryRun) {
+    logger.info(`All ${allPackages.length} package(s) bumped to ${newVersion}`);
+  }
+  return {
+    bumped: true,
+    oldVersion: currentVersion,
+    newVersion,
+    bumpedPackages: packages.map((pkg) => ({
+      ...pkg,
+      currentVersion: pkg.version,
+      version: newVersion,
+      fromTag: from
+    }))
+  };
+}
+async function bumpIndependentMode({
+  config,
+  packages,
+  dryRun,
+  force,
+  suffix
+}) {
+  logger.debug("Starting bump in independent mode");
+  const packagesWithNewVersions = await findPackagesWithCommitsAndCalculateVersions({
+    packages,
+    config,
+    force,
+    suffix
+  });
+  if (packagesWithNewVersions.length === 0) {
+    logger.debug("No packages have commits");
+    return { bumped: false };
+  }
+  if (!config.bump.yes) {
+    await confirmBump({
+      versionMode: "independent",
+      config,
+      packages: packagesWithNewVersions,
+      force,
+      dryRun
+    });
+  } else {
+    const bumpedByCommits2 = packagesWithNewVersions.filter((p) => p.reason === "commits").length;
+    const bumpedByDependency2 = packagesWithNewVersions.length - bumpedByCommits2;
+    logger.info(
+      `${bumpedByCommits2 + bumpedByDependency2} package(s) will be bumped independently (${bumpedByCommits2} from commits, ${bumpedByDependency2} from dependencies)`
+    );
+  }
+  const bumpedPackages = bumpIndependentPackages({
+    packages: packagesWithNewVersions,
+    dryRun
+  });
+  const bumpedByCommits = bumpedPackages.filter(
+    (p) => packagesWithNewVersions.find((pkg) => pkg.name === p.name)?.reason === "commits"
+  ).length;
+  const bumpedByDependency = bumpedPackages.length - bumpedByCommits;
+  if (bumpedPackages.length === 0) {
+    logger.debug("No packages were bumped");
+  } else {
+    logger.info(
+      `${dryRun ? "[dry-run] " : ""}${bumpedPackages.length} package(s) bumped independently (${bumpedByCommits} from commits, ${bumpedByDependency} from dependencies)`
+    );
+  }
+  return {
+    bumped: bumpedPackages.length > 0,
+    bumpedPackages
+  };
+}
+async function bumpSelectiveMode({
+  config,
+  packages,
+  dryRun,
+  force,
+  suffix
+}) {
+  logger.debug("Starting bump in selective mode");
+  const rootPackage = getRootPackage(config.cwd);
+  const currentVersion = rootPackage.version;
+  const { from, to } = await resolveTags({
+    config,
+    versionMode: "selective",
+    step: "bump",
+    currentVersion,
+    newVersion: void 0,
+    pkg: void 0,
+    logLevel: config.logLevel
+  });
+  logger.debug(`Bump from ${from} to ${to}`);
+  const commits = await getPackageCommits({
+    pkg: rootPackage,
+    from,
+    to,
+    config,
+    changelog: false
+  });
+  const releaseType = determineReleaseType({ from, to, commits, config, force, currentVersion });
+  if (!releaseType) {
+    logger.debug("No commits require a version bump");
+    return { bumped: false };
+  }
+  const newVersion = bumpPackageVersion({
+    currentVersion,
+    releaseType,
+    preid: config.bump.preid,
+    suffix
+  });
+  logger.debug("Determining packages to bump...");
+  const packagesToBump = force ? packages : await getPackageToBump({
+    packages,
+    from,
+    to,
+    config
+  });
+  if (packagesToBump.length === 0) {
+    logger.debug("No packages have commits, skipping bump");
+    return { bumped: false };
+  }
+  if (!config.bump.yes) {
+    await confirmBump({
+      versionMode: "selective",
+      config,
+      packages: packagesToBump,
+      force,
+      currentVersion,
+      newVersion,
+      dryRun
+    });
+  } else {
+    if (force) {
+      logger.info(`${packagesToBump.length} package(s) bumped to ${newVersion} (force)`);
+    } else {
+      const bumpedByCommits = packagesToBump.filter((p) => "reason" in p && p.reason === "commits").length;
+      const bumpedByDependency = packagesToBump.filter((p) => "reason" in p && p.reason === "dependency").length;
+      logger.info(
+        `${currentVersion} \u2192 ${newVersion} (selective mode: ${bumpedByCommits} with commits, ${bumpedByDependency} as dependents)`
+      );
+    }
+  }
+  logger.debug(`Writing version to ${packagesToBump.length} package(s)`);
+  writeVersion(rootPackage.path, newVersion, dryRun);
+  for (const pkg of packagesToBump) {
+    writeVersion(pkg.path, newVersion, dryRun);
+  }
+  updateLernaVersion({
+    rootDir: config.cwd,
+    versionMode: config.monorepo?.versionMode,
+    version: newVersion,
+    dryRun
+  });
+  if (!dryRun) {
+    logger.info(
+      `${packagesToBump.length} package(s) bumped to ${newVersion} (${packages.length - packagesToBump.length} skipped)`
+    );
+  }
+  return {
+    bumped: true,
+    oldVersion: currentVersion,
+    fromTag: from,
+    newVersion,
+    bumpedPackages: packagesToBump.map((pkg) => ({
+      ...pkg,
+      currentVersion: pkg.version,
+      version: newVersion,
+      fromTag: from
+    }))
+  };
+}
+async function bump(options = {}) {
+  try {
+    logger.start("Start bumping versions");
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const force = options.force ?? false;
+    logger.debug(`Bump forced: ${force}`);
+    const config = await loadMonorepoConfig({
+      configName: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        bump: {
+          yes: options.yes,
+          type: options.type,
+          clean: options.clean,
+          preid: options.preid
+        },
+        logLevel: options.logLevel
+      }
+    });
+    if (config.bump.clean && config.release.clean) {
+      try {
+        checkGitStatusIfDirty();
+      } catch {
+        logger.error("Git status is dirty, please commit or stash your changes before bumping or use --no-clean flag");
+        process.exit(1);
+      }
+    }
+    await fetchGitTags(config.cwd);
+    logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+    const packages = getPackages({
+      cwd: config.cwd,
+      patterns: config.monorepo?.packages,
+      ignorePackageNames: config.monorepo?.ignorePackageNames
+    });
+    logger.debug(`Found ${packages.length} package(s)`);
+    let result;
+    const payload = {
+      config,
+      packages,
+      dryRun,
+      force,
+      suffix: options.suffix
+    };
+    if (config.monorepo?.versionMode === "unified" || !config.monorepo) {
+      result = await bumpUnifiedMode(payload);
+    } else if (config.monorepo?.versionMode === "selective") {
+      result = await bumpSelectiveMode(payload);
+    } else {
+      result = await bumpIndependentMode(payload);
+    }
+    if (result.bumped) {
+      const resultLog = result.bumpedPackages.length === 1 ? result.bumpedPackages[0].name : result.bumpedPackages.length;
+      logger.success(`${dryRun ? "[dry-run] " : ""}Version bump completed (${resultLog} package${resultLog === 1 || typeof resultLog === "string" ? "" : "s"} bumped)`);
+    } else {
+      logger.fail("No packages to bump, no commits found");
+    }
+    return result;
+  } catch (error) {
+    logger.error("Error bumping versions:", error);
+    throw error;
+  }
+}
+
+function getPackagesToGenerateChangelogFor({
+  config,
+  bumpedPackages
+}) {
+  if (bumpedPackages && bumpedPackages.length > 0) {
+    return bumpedPackages;
+  }
+  return getPackages({
+    cwd: config.cwd,
+    ignorePackageNames: config.monorepo?.ignorePackageNames,
+    patterns: config.monorepo?.packages
+  });
+}
+async function generateIndependentRootChangelog({
+  packages,
+  config,
+  dryRun
+}) {
+  if (!config.changelog?.rootChangelog) {
+    logger.debug("Skipping root changelog generation");
+    return;
+  }
+  logger.debug("Generating aggregated root changelog for independent mode");
+  const rootPackage = getRootPackage(config.cwd);
+  const packageChangelogs = [];
+  for (const pkg of packages) {
+    const { from, to } = await resolveTags({
+      config,
+      versionMode: "independent",
+      step: "changelog",
+      currentVersion: pkg.version,
+      newVersion: void 0,
+      pkg,
+      logLevel: config.logLevel
+    });
+    const lastTag = from;
+    logger.debug(`Generating changelog for ${pkg.name} (${lastTag}...${to})`);
+    const commits = await getPackageCommits({
+      pkg,
+      from: lastTag,
+      to,
+      config,
+      changelog: true
+    });
+    const changelog2 = await generateChangelog({
+      config,
+      pkg,
+      commits,
+      from: lastTag,
+      dryRun
+    });
+    if (changelog2) {
+      const cleanedChangelog = changelog2.split("\n").slice(2).join("\n");
+      packageChangelogs.push(`## ${pkg.name}@${pkg.version}
+
+${cleanedChangelog}`);
+    }
+  }
+  if (packageChangelogs.length === 0) {
+    logger.debug("No changelogs to aggregate");
+    return;
+  }
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const aggregatedChangelog = `**Multiple Packages Updated** - ${date}
+
+${packageChangelogs.join("\n\n")}`;
+  logger.verbose(`Aggregated root changelog: ${aggregatedChangelog}`);
+  writeChangelogToFile({
+    pkg: rootPackage,
+    changelog: aggregatedChangelog,
+    dryRun
+  });
+  logger.debug("Aggregated root changelog written");
+}
+async function generateSimpleRootChangelog({
+  config,
+  dryRun
+}) {
+  if (!config.changelog?.rootChangelog) {
+    logger.debug("Skipping root changelog generation");
+    return;
+  }
+  logger.debug("Generating simple root changelog");
+  const rootPackage = getRootPackage(config.cwd);
+  const { from, to } = await resolveTags({
+    config,
+    versionMode: config.monorepo?.versionMode || "unified",
+    step: "changelog",
+    currentVersion: rootPackage.version,
+    newVersion: void 0,
+    pkg: void 0,
+    logLevel: config.logLevel
+  });
+  logger.debug(`Generating root changelog (${from}...${to})`);
+  logger.debug(`Root package: ${rootPackage.name} at ${rootPackage.path}`);
+  const rootCommits = await getPackageCommits({
+    pkg: rootPackage,
+    from,
+    to,
+    config,
+    changelog: true
+  });
+  const rootChangelog = await generateChangelog({
+    pkg: rootPackage,
+    commits: rootCommits,
+    config,
+    from,
+    dryRun
+  });
+  if (rootChangelog) {
+    writeChangelogToFile({
+      changelog: rootChangelog,
+      pkg: rootPackage,
+      dryRun
+    });
+    logger.debug("Root changelog written");
+  } else {
+    logger.debug("No changelog to generate for root package");
+  }
+}
+async function changelog(options = {}) {
+  try {
+    logger.start("Start generating changelogs");
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const config = await loadMonorepoConfig({
+      configName: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        from: options.from,
+        to: options.to,
+        logLevel: options.logLevel,
+        changelog: {
+          rootChangelog: options.rootChangelog,
+          formatCmd: options.formatCmd
+        }
+      }
+    });
+    logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+    const packages = getPackagesToGenerateChangelogFor({
+      config,
+      bumpedPackages: options.bumpedPackages
+    });
+    if (config.changelog?.rootChangelog && config.monorepo) {
+      if (config.monorepo.versionMode === "independent") {
+        await generateIndependentRootChangelog({
+          packages,
+          config,
+          dryRun
+        });
+      } else {
+        await generateSimpleRootChangelog({
+          config,
+          dryRun
+        });
+      }
+    } else {
+      logger.debug("Skipping root changelog generation");
+    }
+    logger.debug("Generating package changelogs...");
+    logger.debug(`Processing ${packages.length} package(s)`);
+    let generatedCount = 0;
+    for await (const pkg of packages) {
+      const { from, to } = await resolveTags({
+        config,
+        versionMode: config.monorepo?.versionMode || "unified",
+        step: "changelog",
+        currentVersion: pkg.version,
+        newVersion: void 0,
+        pkg,
+        logLevel: config.logLevel
+      });
+      logger.debug(`Processing ${pkg.name} (${from}...${to})`);
+      const commits = await getPackageCommits({
+        pkg,
+        from,
+        to,
+        config,
+        changelog: true
+      });
+      logger.debug(`${pkg.name}: ${commits.length} commit(s)`);
+      const changelog2 = await generateChangelog({
+        pkg,
+        commits,
+        config,
+        from,
+        dryRun
+      });
+      if (changelog2) {
+        writeChangelogToFile({
+          pkg,
+          changelog: changelog2,
+          dryRun
+        });
+        generatedCount++;
+        logger.debug(`${pkg.name}: changelog written`);
+      }
+    }
+    logger.debug(`Generated ${generatedCount} package changelog(s)`);
+    await executeFormatCmd({
+      config,
+      dryRun
+    });
+    logger.success(`${dryRun ? "[dry run] " : ""}Changelog generation completed!`);
+  } catch (error) {
+    logger.error("Error generating changelogs:", error);
+    throw error;
+  }
+}
+
+async function providerRelease(options = {}) {
+  const dryRun = options.dryRun ?? false;
+  logger.debug(`Dry run: ${dryRun}`);
+  const config = await loadMonorepoConfig({
+    configName: options.configName,
+    baseConfig: options.config,
+    overrides: {
+      from: options.from,
+      to: options.to,
+      tokens: {
+        github: options.token,
+        gitlab: options.token
+      },
+      logLevel: options.logLevel
+    }
+  });
+  logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+  const detectedProvider = options.provider || detectGitProvider();
+  if (!detectedProvider) {
+    logger.warn("Unable to detect Git provider. Skipping release publication.");
+    throw new Error("Unable to detect Git provider");
+  } else {
+    logger.info(
+      options.provider ? `Using Git provider: ${options.provider}` : `Detected Git provider: ${detectedProvider}`
+    );
+  }
+  let postedReleases = [];
+  const payload = {
+    from: config.from,
+    dryRun,
+    config,
+    logLevel: config.logLevel,
+    bumpResult: options.bumpResult
+  };
+  if (detectedProvider === "github") {
+    postedReleases = await github(payload);
+  } else if (detectedProvider === "gitlab") {
+    postedReleases = await gitlab(payload);
+  } else {
+    logger.warn(`Unsupported Git provider: ${detectedProvider}`);
+  }
+  return {
+    detectedProvider,
+    postedReleases
+  };
+}
+
+async function publish(options = {}) {
+  try {
+    logger.start("Start publishing packages");
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const packageManager = detectPackageManager(process.cwd());
+    logger.debug(`Package manager: ${packageManager}`);
+    const config = await loadMonorepoConfig({
+      configName: options.configName,
+      baseConfig: options.config,
+      overrides: {
+        publish: {
+          access: options.access,
+          otp: options.otp,
+          registry: options.registry,
+          tag: options.tag,
+          buildCmd: options.buildCmd
+        },
+        logLevel: options.logLevel
+      }
+    });
+    logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+    if (config.publish.registry) {
+      logger.debug(`Registry: ${config.publish.registry}`);
+    }
+    if (config.publish.tag) {
+      logger.debug(`Tag: ${config.publish.tag}`);
+    }
+    const packages = options.bumpedPackages || getPackages({
+      cwd: config.cwd,
+      patterns: config.publish.packages ?? config.monorepo?.packages,
+      ignorePackageNames: config.monorepo?.ignorePackageNames
+    });
+    const rootPackage = getRootPackage(config.cwd);
+    logger.debug(`Found ${packages.length} package(s)`);
+    logger.debug("Building dependency graph and sorting...");
+    const packagesWithDeps = getPackagesWithDependencies(packages, config.bump.dependencyTypes);
+    const sortedPackages = topologicalSort(packagesWithDeps);
+    let publishedPackages = packages || [];
+    if (publishedPackages.length === 0 && config.monorepo?.versionMode === "independent") {
+      logger.debug("Determining packages to publish in independent mode...");
+      publishedPackages = await getPackagesToPublishInIndependentMode(sortedPackages, config);
+      logger.info(`Publishing ${publishedPackages.length} package(s) (independent mode)`);
+      logger.debug(`Packages: ${publishedPackages.join(", ")}`);
+    } else if (publishedPackages.length === 0 && config.monorepo?.versionMode === "selective") {
+      logger.debug("Determining packages to publish in selective mode...");
+      publishedPackages = getPackagesToPublishInSelectiveMode(sortedPackages, rootPackage.version);
+      logger.info(`Publishing ${publishedPackages.length} package(s) matching root version (selective mode)`);
+      logger.debug(`Packages: ${publishedPackages.join(", ")}`);
+    } else if (publishedPackages.length === 0) {
+      publishedPackages = sortedPackages;
+      logger.info(`Publishing ${publishedPackages.length} package(s) (unified mode)`);
+    }
+    if (publishedPackages.length === 0) {
+      logger.warn("No packages need to be published");
+      return;
+    }
+    await executeBuildCmd({
+      config,
+      dryRun
+    });
+    for (const pkg of sortedPackages) {
+      if (publishedPackages.some((p) => p.name === pkg.name)) {
+        logger.debug(`Publishing ${pkg.name}@${pkg.version}...`);
+        await publishPackage({
+          pkg,
+          config,
+          packageManager,
+          dryRun
+        });
+      }
+    }
+    if (!dryRun) {
+      logger.info("Package(s) have been published to npm registry");
+    }
+    logger.success("Publishing completed!");
+    return {
+      publishedPackages
+    };
+  } catch (error) {
+    logger.error("Error publishing packages:", error);
+    throw error;
+  }
+}
+
+function getReleaseConfig(options = {}) {
+  return loadMonorepoConfig({
+    configName: options.configName,
+    overrides: {
+      logLevel: options.logLevel,
+      from: options.from,
+      to: options.to,
+      tokens: {
+        github: options.token,
+        gitlab: options.token
+      },
+      bump: {
+        type: options.type,
+        preid: options.preid,
+        clean: options.clean,
+        yes: options.yes
+      },
+      changelog: {
+        formatCmd: options.formatCmd,
+        rootChangelog: options.rootChangelog
+      },
+      publish: {
+        access: options.access,
+        otp: options.otp,
+        registry: options.registry,
+        tag: options.tag,
+        buildCmd: options.buildCmd
+      },
+      release: {
+        commit: options.commit,
+        changelog: options.changelog,
+        push: options.push,
+        publish: options.publish,
+        noVerify: options.noVerify,
+        release: options.release,
+        clean: options.clean
+      }
+    }
+  });
+}
+async function release(options = {}) {
+  try {
+    const dryRun = options.dryRun ?? false;
+    logger.debug(`Dry run: ${dryRun}`);
+    const force = options.force ?? false;
+    logger.debug(`Force bump: ${force}`);
+    const config = await getReleaseConfig(options);
+    logger.debug(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
+    logger.debug(`Push: ${config.release.push}, Publish: ${config.release.publish}, Release: ${config.release.release}`);
+    logger.box("Step 1/6: Bump versions");
+    const bumpResult = await bump({
+      type: config.bump.type,
+      preid: config.bump.preid,
+      dryRun,
+      config,
+      force,
+      clean: config.release.clean,
+      configName: options.configName
+    });
+    if (!bumpResult.bumped) {
+      logger.debug("No packages bumped");
+      return;
+    }
+    logger.box("Step 2/6: Generate changelogs");
+    if (config.release.changelog) {
+      await changelog({
+        from: config.from,
+        to: config.to,
+        dryRun,
+        formatCmd: config.changelog.formatCmd,
+        rootChangelog: config.changelog.rootChangelog,
+        bumpedPackages: bumpResult.bumpedPackages,
+        config,
+        logLevel: config.logLevel,
+        configName: options.configName
+      });
+    } else {
+      logger.info("Skipping changelog generation (--no-changelog)");
+    }
+    logger.box("Step 3/6: Commit changes and create tag");
+    let createdTags = [];
+    if (config.release.commit) {
+      createdTags = await createCommitAndTags({
+        config,
+        noVerify: config.release.noVerify,
+        bumpedPackages: bumpResult.bumpedPackages,
+        newVersion: bumpResult.newVersion,
+        dryRun,
+        logLevel: config.logLevel
+      });
+    } else {
+      logger.info("Skipping commit and tag (--no-commit)");
+    }
+    logger.box("Step 4/6: Push changes and tags");
+    if (config.release.push && config.release.commit) {
+      await pushCommitAndTags({ dryRun, logLevel: config.logLevel, cwd: config.cwd });
+    } else {
+      logger.info("Skipping push (--no-push or --no-commit)");
+    }
+    logger.box("Step 5/6: Publish packages to registry");
+    let publishResponse;
+    if (config.release.publish) {
+      publishResponse = await publish({
+        registry: config.publish.registry,
+        tag: config.publish.tag,
+        access: config.publish.access,
+        otp: config.publish.otp,
+        bumpedPackages: bumpResult.bumpedPackages,
+        dryRun,
+        config,
+        configName: options.configName
+      });
+    } else {
+      logger.info("Skipping publish (--no-publish)");
+    }
+    let provider = config.repo?.provider;
+    let postedReleases = [];
+    logger.box("Step 6/6: Publish Git release");
+    if (config.release.release) {
+      logger.debug(`Provider from config: ${provider}`);
+      try {
+        const response = await providerRelease({
+          provider,
+          dryRun,
+          config,
+          logLevel: config.logLevel,
+          bumpResult,
+          configName: options.configName
+        });
+        provider = response.detectedProvider;
+        postedReleases = response.postedReleases;
+      } catch (error) {
+        logger.error("Error during release publication:", error);
+      }
+    } else {
+      logger.info("Skipping release (--no-release)");
+    }
+    const publishedPackageCount = publishResponse?.publishedPackages.length ?? 0;
+    const versionDisplay = config.monorepo?.versionMode === "independent" ? `${bumpResult.bumpedPackages.length} packages bumped independently` : bumpResult.newVersion || getRootPackage(config.cwd).version;
+    logger.box(`Release workflow completed!
+
+Version: ${versionDisplay}
+Tag(s): ${createdTags.length ? createdTags.join(", ") : "No"}
+Pushed: ${config.release.push ? "Yes" : "Disabled"}
+Published packages: ${config.release.publish ? publishedPackageCount : "Disabled"}
+Published release: ${config.release.release ? postedReleases.length : "Disabled"}
+Git provider: ${provider}`);
+  } catch (error) {
+    logger.error("Error during release workflow:", error);
+    throw error;
+  }
+}
+
+export { isChangedPreid as $, getCurrentGitRef as A, github as B, createGitlabRelease as C, gitlab as D, getPackages as E, getPackageCommits as F, getRootPackage as G, hasLernaJson as H, getPackageToBump as I, detectPackageManager as J, determinePublishTag as K, getPackagesToPublishInSelectiveMode as L, getPackagesToPublishInIndependentMode as M, publishPackage as N, getLastRepoTag as O, getLastPackageTag as P, resolveTags as Q, determineReleaseType as R, writeVersion as S, bumpPackageVersion as T, updateLernaVersion as U, extractVersionFromPackageTag as V, isPrerelease as W, isStableReleaseType as X, isPrereleaseReleaseType as Y, isGraduating as Z, getPreid as _, publish as a, bumpPackageIndependently as a0, confirmBump as a1, findPackagesWithCommitsAndCalculateVersions as a2, bumpIndependentPackages as a3, bump as b, changelog as c, executeBuildCmd as d, executeFormatCmd as e, getDefaultConfig as f, generateChangelog as g, defineConfig as h, getPackageDependencies as i, getPackagesWithDependencies as j, getDependentsOf as k, loadMonorepoConfig as l, expandPackagesToBumpWithDependents as m, getGitStatus as n, checkGitStatusIfDirty as o, providerRelease as p, fetchGitTags as q, release as r, detectGitProvider as s, topologicalSort as t, parseGitRemoteUrl as u, createCommitAndTags as v, writeChangelogToFile as w, pushCommitAndTags as x, getFirstCommit as y, getCurrentGitBranch as z };