relizy 0.1.0 → 0.2.0

package/dist/shared/{relizy.Blp-ymeX.mjs → relizy.CBq0DAtR.mjs}

@@ -2,14 +2,14 @@ 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 { upperFirst, formatJson } from '@maz-ui/utils';
 import { setupDotenv, loadConfig } from 'c12';
+import { formatCompareChanges, formatReference, resolveRepoConfig, getRepoConfig, createGithubRelease, getGitDiff, parseCommits, determineSemverChange } from 'changelogen';
 import { defu } from 'defu';
+import fastGlob from 'fast-glob';
+import { confirm, input } from '@inquirer/prompts';
+import * as semver from 'semver';
 import { convert } from 'convert-gitmoji';
 import { fetch as fetch$1 } from 'node-fetch-native';
 
@@ -110,7 +110,8 @@ function getCommitBody(commit) {
       return false;
     }
     const isFileLine = /^[AMDRC]\s+/.test(trimmedLine);
-    return !isFileLine;
+    const R100 = /R100\s+/.test(trimmedLine);
+    return !isFileLine && !R100;
   });
   if (contentLines.length === 0) {
     return "";
@@ -148,6 +149,138 @@ function groupBy(items, key) {
   return groups;
 }
 
+async function executeHook(hook, config, dryRun, params) {
+  const hookInput = config.hooks?.[hook];
+  if (!hookInput) {
+    logger.debug(`Hook ${hook} not found`);
+    return;
+  }
+  if (typeof hookInput === "function") {
+    logger.info(`Executing hook ${hook}`);
+    const result = await hookInput(config, dryRun, params);
+    if (result)
+      logger.debug(`Hook ${hook} returned: ${result}`);
+    logger.info(`Hook ${hook} executed`);
+    return result;
+  }
+  if (typeof hookInput === "string") {
+    logger.info(`Executing hook ${hook}`);
+    const result = await execPromise(hookInput, {
+      logLevel: config.logLevel,
+      cwd: config.cwd,
+      noStderr: true,
+      noStdout: true
+    });
+    if (result)
+      logger.debug(`Hook ${hook} returned: ${result}`);
+    logger.info(`Hook ${hook} executed`);
+    return result;
+  }
+}
+function isInCI() {
+  return Boolean(
+    process.env.CI === "true" || process.env.CONTINUOUS_INTEGRATION === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.GITHUB_WORKFLOW || process.env.GITLAB_CI === "true" || process.env.CIRCLECI === "true" || process.env.TRAVIS === "true" || process.env.JENKINS_HOME || process.env.JENKINS_URL || process.env.BUILD_ID || process.env.TF_BUILD === "True" || process.env.AZURE_PIPELINES === "true" || process.env.TEAMCITY_VERSION || process.env.BITBUCKET_BUILD_NUMBER || process.env.DRONE === "true" || process.env.APPVEYOR === "True" || process.env.APPVEYOR === "true" || process.env.BUILDKITE === "true" || process.env.CODEBUILD_BUILD_ID || process.env.NETLIFY === "true" || process.env.VERCEL === "1" || process.env.HEROKU_TEST_RUN_ID || process.env.BUDDY === "true" || process.env.SEMAPHORE === "true" || process.env.CF_BUILD_ID || process.env.bamboo_buildKey || process.env.BUILD_ID && process.env.PROJECT_ID || process.env.SCREWDRIVER === "true" || process.env.STRIDER === "true"
+  );
+}
+function getCIName() {
+  if (process.env.GITHUB_ACTIONS === "true")
+    return "GitHub Actions";
+  if (process.env.GITLAB_CI === "true")
+    return "GitLab CI";
+  if (process.env.CIRCLECI === "true")
+    return "CircleCI";
+  if (process.env.TRAVIS === "true")
+    return "Travis CI";
+  if (process.env.JENKINS_HOME || process.env.JENKINS_URL)
+    return "Jenkins";
+  if (process.env.TF_BUILD === "True")
+    return "Azure Pipelines";
+  if (process.env.TEAMCITY_VERSION)
+    return "TeamCity";
+  if (process.env.BITBUCKET_BUILD_NUMBER)
+    return "Bitbucket Pipelines";
+  if (process.env.DRONE === "true")
+    return "Drone";
+  if (process.env.APPVEYOR)
+    return "AppVeyor";
+  if (process.env.BUILDKITE === "true")
+    return "Buildkite";
+  if (process.env.CODEBUILD_BUILD_ID)
+    return "AWS CodeBuild";
+  if (process.env.NETLIFY === "true")
+    return "Netlify";
+  if (process.env.VERCEL === "1")
+    return "Vercel";
+  if (process.env.HEROKU_TEST_RUN_ID)
+    return "Heroku CI";
+  if (process.env.BUDDY === "true")
+    return "Buddy";
+  if (process.env.SEMAPHORE === "true")
+    return "Semaphore";
+  if (process.env.CF_BUILD_ID)
+    return "Codefresh";
+  if (process.env.bamboo_buildKey)
+    return "Bamboo";
+  if (process.env.BUILD_ID && process.env.PROJECT_ID)
+    return "Google Cloud Build";
+  if (process.env.SCREWDRIVER === "true")
+    return "Screwdriver";
+  if (process.env.STRIDER === "true")
+    return "Strider";
+  if (process.env.CI === "true")
+    return "Unknown CI";
+  return null;
+}
+async function executeFormatCmd({
+  config,
+  dryRun
+}) {
+  if (config.changelog?.formatCmd) {
+    logger.info("Running format command");
+    logger.debug(`Running format command: ${config.changelog.formatCmd}`);
+    try {
+      if (!dryRun) {
+        await execPromise(config.changelog.formatCmd, {
+          noStderr: true,
+          noStdout: true,
+          logLevel: config.logLevel,
+          cwd: config.cwd
+        });
+        logger.info("Format completed");
+      } else {
+        logger.log("[dry-run] exec format command: ", config.changelog.formatCmd);
+      }
+    } catch (error) {
+      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 fromTagIsFirstCommit(fromTag, cwd) {
   return fromTag === getFirstCommit(cwd);
 }
@@ -164,21 +297,27 @@ async function generateChangelog({
     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));
+  logger.debug(`Generating changelog for ${pkg.name} - from ${fromTag} to ${toTag}`);
   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}`);
+    const generatedChangelog = await generateMarkDown(commits, config);
+    let changelog = generatedChangelog;
     if (commits.length === 0) {
       changelog = `${changelog}
 
 ${config.templates.emptyChangelogContent}`;
     }
+    const changelogResult = await executeHook("generate:changelog", config, dryRun, {
+      commits,
+      changelog
+    });
+    changelog = changelogResult || changelog;
+    logger.verbose(`Output changelog for ${pkg.name}:
+${changelog}`);
     logger.debug(`Changelog generated for ${pkg.name} (${commits.length} commits)`);
     logger.verbose(`Final changelog for ${pkg.name}:
 
@@ -224,55 +363,6 @@ ${existingChangelog}`;
     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 {
@@ -314,8 +404,8 @@ function getDefaultConfig() {
       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
+      gitlab: process$1.env.RELIZY_GITLAB_TOKEN || process$1.env.GITLAB_TOKEN || process$1.env.GITLAB_API_TOKEN || process$1.env.CI_JOB_TOKEN,
+      github: process$1.env.RELIZY_GITHUB_TOKEN || process$1.env.GITHUB_TOKEN || process$1.env.GH_TOKEN
     },
     scopeMap: {},
     release: {
@@ -324,10 +414,11 @@ function getDefaultConfig() {
       changelog: true,
       push: true,
       clean: true,
-      release: true,
+      providerRelease: true,
       noVerify: false
     },
-    logLevel: "default"
+    logLevel: "default",
+    safetyCheck: true
   };
 }
 function setupLogger(logLevel) {
@@ -353,12 +444,12 @@ async function resolveConfig(config, cwd) {
   }
   return config;
 }
-async function loadMonorepoConfig({ baseConfig, overrides, configName = "relizy" }) {
-  const cwd = overrides?.cwd ?? process$1.cwd();
-  configName ??= "relizy";
+async function loadRelizyConfig(options) {
+  const cwd = options?.overrides?.cwd ?? process$1.cwd();
+  const configName = options?.configName ?? "relizy";
   await setupDotenv({ cwd });
   const defaultConfig = getDefaultConfig();
-  const overridesConfig = defu(overrides, baseConfig);
+  const overridesConfig = defu(options?.overrides, options?.baseConfig);
   const results = await loadConfig({
     cwd,
     name: configName,
@@ -367,10 +458,13 @@ async function loadMonorepoConfig({ baseConfig, overrides, configName = "relizy"
     overrides: overridesConfig
   });
   if (!results._configFile) {
-    logger.error(`No config file found with name "${configName}"`);
-    process$1.exit(1);
+    logger.debug(`No config file found with name "${configName}" - using standalone mode`);
+    if (options?.configName) {
+      logger.error(`No config file found with name "${configName}"`);
+      process$1.exit(1);
+    }
   }
-  setupLogger(overrides?.logLevel || results.config.logLevel);
+  setupLogger(options?.overrides?.logLevel || results.config.logLevel);
   logger.verbose("User config:", formatJson(results.config.changelog));
   const resolvedConfig = await resolveConfig(results.config, cwd);
   logger.debug("Resolved config:", formatJson(resolvedConfig));
@@ -499,7 +593,7 @@ function checkGitStatusIfDirty() {
   if (dirty) {
     logger.debug("git status:", `
 ${dirty.trim().split("\n").map((line) => line.trim()).join("\n")}`);
-    throw new Error("Working directory is not clean");
+    throw new Error(dirty);
   }
 }
 async function fetchGitTags(cwd) {
@@ -555,61 +649,88 @@ async function createCommitAndTags({
   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;
+} = {}) {
+  const internalConfig = config || await loadRelizyConfig();
+  try {
+    await executeHook("before:commit-and-tag", internalConfig, dryRun ?? false);
+    const filePatternsToAdd = [
+      "package.json",
+      "lerna.json",
+      "CHANGELOG.md",
+      "**/CHANGELOG.md",
+      "**/package.json"
+    ];
+    logger.start("Start commit and tag");
+    logger.debug("Adding files to git staging area...");
+    for (const pattern of filePatternsToAdd) {
+      if (pattern === "lerna.json" && !hasLernaJson(internalConfig.cwd)) {
+        logger.verbose(`Skipping lerna.json as it doesn't exist`);
+        continue;
+      }
+      if ((pattern === "lerna.json" || pattern === "CHANGELOG.md") && !existsSync(join(internalConfig.cwd, pattern))) {
+        logger.verbose(`Skipping ${pattern} as it doesn't exist`);
+        continue;
+      }
+      if (dryRun) {
+        logger.info(`[dry-run] git add ${pattern}`);
+        continue;
+      }
+      try {
+        logger.debug(`git add ${pattern}`);
+        execSync(`git add ${pattern}`);
+      } catch {
+      }
     }
+    const rootPackage = getRootPackage(internalConfig.cwd);
+    newVersion = newVersion || rootPackage.version;
+    const versionForMessage = internalConfig.monorepo?.versionMode === "independent" ? bumpedPackages?.map((pkg) => `${pkg.name}@${pkg.version}`).join(", ") || "unknown" : newVersion || "unknown";
+    const commitMessage = internalConfig.templates.commitMessage?.replaceAll("{{newVersion}}", versionForMessage) || `chore(release): bump version to ${versionForMessage}`;
+    const noVerifyFlag = noVerify ? "--no-verify " : "";
+    logger.debug(`No verify: ${noVerify}`);
     if (dryRun) {
-      logger.info(`[dry-run] git 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;
+      logger.info(`[dry-run] git commit ${noVerifyFlag}-m "${commitMessage}"`);
+    } else {
+      logger.debug(`Executing: git commit ${noVerifyFlag}-m "${commitMessage}"`);
+      await execPromise(`git commit ${noVerifyFlag}-m "${commitMessage}"`, {
+        logLevel,
+        noStderr: true,
+        noStdout: true,
+        cwd: internalConfig.cwd
+      });
+      logger.success(`Committed: ${commitMessage}${noVerify ? " (--no-verify)" : ""}`);
+    }
+    const signTags = internalConfig.signTags ? "-s" : "";
+    logger.debug(`Sign tags: ${internalConfig.signTags}`);
+    const createdTags = [];
+    if (internalConfig.monorepo?.versionMode === "independent" && bumpedPackages && bumpedPackages.length > 0) {
+      logger.debug(`Creating ${bumpedPackages.length} independent package tags`);
+      for (const pkg of bumpedPackages) {
+        const tagName = `${pkg.name}@${pkg.version}`;
+        const tagMessage = internalConfig.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: internalConfig.cwd
+            });
+            logger.debug(`Tag created: ${tagName}`);
+          } catch (error) {
+            logger.error(`Failed to create tag ${tagName}:`, error);
+            throw error;
+          }
+        }
+        createdTags.push(tagName);
+      }
+      logger.success(`Created ${createdTags.length} tags for independent packages, ${createdTags.join(", ")}`);
+    } else {
+      const tagName = internalConfig.templates.tagBody?.replaceAll("{{newVersion}}", newVersion);
+      const tagMessage = internalConfig.templates?.tagMessage?.replaceAll("{{newVersion}}", newVersion) || tagName;
       if (dryRun) {
         logger.info(`[dry-run] git tag ${signTags} -a ${tagName} -m "${tagMessage}"`);
       } else {
@@ -620,7 +741,7 @@ async function createCommitAndTags({
             logLevel,
             noStderr: true,
             noStdout: true,
-            cwd: config.cwd
+            cwd: internalConfig.cwd
           });
           logger.debug(`Tag created: ${tagName}`);
         } catch (error) {
@@ -630,33 +751,15 @@ async function createCommitAndTags({
       }
       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!");
+    await executeHook("after:commit-and-tag", internalConfig, dryRun ?? false);
+    return createdTags;
+  } catch (error) {
+    logger.error("Error committing and tagging:", error);
+    await executeHook("error:commit-and-tag", internalConfig, dryRun ?? false);
+    throw error;
   }
-  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");
@@ -666,7 +769,7 @@ async function pushCommitAndTags({ dryRun, logLevel, cwd }) {
     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");
+  logger.success("Pushing changes and tags completed!");
 }
 function getFirstCommit(cwd) {
   const result = execSync(
@@ -699,8 +802,8 @@ async function githubIndependentMode({
   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) {
+  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github && !config.repo?.token) {
     throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
   }
   const packages = bumpedPackages || getPackages({
@@ -783,8 +886,8 @@ async function githubUnified({
   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) {
+  logger.debug(`GitHub token: ${config.tokens.github || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
+  if (!config.tokens.github && !config.repo?.token) {
     throw new Error("No GitHub token specified. Set GITHUB_TOKEN or GH_TOKEN environment variable.");
   }
   const to = config.templates.tagBody.replace("{{newVersion}}", rootPackage.version);
@@ -838,10 +941,9 @@ async function githubUnified({
 }
 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({
+    const config = await loadRelizyConfig({
       configName: options.configName,
       baseConfig: options.config,
       overrides: {
@@ -849,7 +951,7 @@ async function github(options = {}) {
         to: options.to,
         logLevel: options.logLevel,
         tokens: {
-          github: options.token || process.env.CHANGELOGEN_TOKENS_GITHUB || process.env.GITHUB_TOKEN || process.env.GH_TOKEN
+          github: options.token
         }
       }
     });
@@ -879,7 +981,7 @@ async function createGitlabRelease({
   release,
   dryRun
 }) {
-  const token = config.tokens.gitlab || process.env.GITLAB_TOKEN || process.env.CI_JOB_TOKEN;
+  const token = config.tokens.gitlab || config.repo?.token;
   if (!token && !dryRun) {
     throw new Error(
       "No GitLab token found. Set GITLAB_TOKEN or CI_JOB_TOKEN environment variable or configure tokens.gitlab"
@@ -940,7 +1042,7 @@ async function gitlabIndependentMode({
   dryRun,
   bumpedPackages
 }) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab ? "\u2713 provided" : "\u2717 missing"}`);
+  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
   const packages = bumpedPackages || getPackages({
     cwd: config.cwd,
     patterns: config.monorepo?.packages,
@@ -1020,7 +1122,7 @@ async function gitlabUnified({
   fromTag,
   oldVersion
 }) {
-  logger.debug(`GitLab token: ${config.tokens.gitlab ? "\u2713 provided" : "\u2717 missing"}`);
+  logger.debug(`GitLab token: ${config.tokens.gitlab || config.repo?.token ? "\u2713 provided" : "\u2717 missing"}`);
   const to = config.templates.tagBody.replace("{{newVersion}}", rootPackage.version);
   const commits = await getPackageCommits({
     pkg: rootPackage,
@@ -1077,10 +1179,9 @@ async function gitlabUnified({
 }
 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({
+    const config = await loadRelizyConfig({
       configName: options.configName,
       baseConfig: options.config,
       overrides: {
@@ -1088,7 +1189,7 @@ async function gitlab(options = {}) {
         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
+          gitlab: options.token
         }
       }
     });
@@ -1976,6 +2077,7 @@ async function resolveTags({
   return tags;
 }
 
+let sessionOtp;
 function detectPackageManager(cwd = process.cwd()) {
   try {
     const packageJsonPath = join(cwd, "package.json");
@@ -2078,7 +2180,8 @@ function isYarnBerry() {
 function getCommandArgs({
   packageManager,
   tag,
-  config
+  config,
+  otp
 }) {
   const args = ["publish", "--tag", tag];
   if (packageManager === "pnpm") {
@@ -2098,12 +2201,72 @@ function getCommandArgs({
   if (access) {
     args.push("--access", access);
   }
-  const otp = config.publish.otp;
-  if (otp) {
-    args.push("--otp", otp);
+  const finalOtp = otp ?? sessionOtp ?? config.publish.otp;
+  if (finalOtp) {
+    args.push("--otp", finalOtp);
   }
   return args;
 }
+function isOtpError(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const errorMessage = "message" in error && typeof error.message === "string" ? error.message.toLowerCase() : "";
+  return errorMessage.includes("otp") || errorMessage.includes("one-time password") || errorMessage.includes("eotp");
+}
+function promptOtpWithTimeout(timeout = 9e4) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("OTP input timeout"));
+    }, timeout);
+    input({
+      message: "This operation requires a one-time password (OTP). Please enter your OTP:"
+    }).then((otp) => {
+      clearTimeout(timer);
+      resolve(otp);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+async function handleOtpError() {
+  if (process.env.CI) {
+    logger.error("OTP required but running in CI environment. Please provide OTP via config.");
+    throw new Error("OTP required in CI environment");
+  }
+  logger.warn("Publish failed: OTP required");
+  try {
+    const otp = await promptOtpWithTimeout();
+    logger.debug("OTP received, retrying publish...");
+    return otp;
+  } catch (promptError) {
+    logger.error("Failed to get OTP:", promptError);
+    throw promptError;
+  }
+}
+async function executePublishCommand({
+  command,
+  packageNameAndVersion,
+  pkg,
+  config,
+  dryRun
+}) {
+  logger.debug(`Executing publish command (${command}) in ${pkg.path}`);
+  if (dryRun) {
+    logger.info(`[dry-run] ${packageNameAndVersion}: Run ${command}`);
+    return;
+  }
+  const { stdout } = await execPromise(command, {
+    noStderr: true,
+    noStdout: true,
+    logLevel: config.logLevel,
+    cwd: pkg.path
+  });
+  if (stdout) {
+    logger.debug(stdout);
+  }
+  logger.info(`Published ${packageNameAndVersion}`);
+}
 async function publishPackage({
   pkg,
   config,
@@ -2111,40 +2274,44 @@ async function publishPackage({
   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
+  const baseCommand = packageManager === "yarn" && isYarnBerry() ? "yarn npm" : packageManager;
+  logger.debug(`Building publish command for ${pkg.name}`);
+  let dynamicOtp;
+  const maxAttempts = 2;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const args = getCommandArgs({
+        packageManager,
+        tag,
+        config,
+        otp: dynamicOtp
+      });
+      const command = `${baseCommand} ${args.join(" ")}`;
+      logger.debug(`Publishing ${packageNameAndVersion} with tag '${tag}' with command: ${command}`);
+      process.chdir(pkg.path);
+      await executePublishCommand({
+        command,
+        packageNameAndVersion,
+        pkg,
+        config,
+        dryRun
       });
-      if (stdout) {
-        logger.debug(stdout);
+      if (dynamicOtp && !sessionOtp) {
+        sessionOtp = dynamicOtp;
+        logger.debug("OTP stored for session");
       }
+      return;
+    } catch (error) {
+      if (isOtpError(error) && attempt < maxAttempts - 1) {
+        dynamicOtp = await handleOtpError();
+      } else {
+        logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
+        throw error;
+      }
+    } finally {
+      process.chdir(config.cwd);
     }
-    if (!dryRun) {
-      logger.info(`Published ${packageNameAndVersion}`);
-    }
-  } catch (error) {
-    logger.error(`Failed to publish ${packageNameAndVersion}:`, error);
-    throw error;
-  } finally {
-    process.chdir(config.cwd);
   }
 }
 
@@ -2393,30 +2560,31 @@ async function bumpSelectiveMode({
   };
 }
 async function bump(options = {}) {
+  const config = await loadRelizyConfig({
+    configName: options.configName,
+    baseConfig: options.config,
+    overrides: {
+      bump: {
+        yes: options.yes,
+        type: options.type,
+        clean: options.clean,
+        preid: options.preid
+      },
+      logLevel: options.logLevel
+    }
+  });
+  const dryRun = options.dryRun ?? false;
+  logger.debug(`Dry run: ${dryRun}`);
+  const force = options.force ?? false;
+  logger.debug(`Bump forced: ${force}`);
   try {
+    await executeHook("before:bump", config, dryRun);
     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");
+      } catch (error) {
+        logger.error("Git status is dirty, please commit or stash your changes before bumping or use --no-clean flag", error);
         process.exit(1);
       }
     }
@@ -2449,9 +2617,11 @@ async function bump(options = {}) {
     } else {
       logger.fail("No packages to bump, no commits found");
     }
+    await executeHook("after:bump", config, dryRun);
     return result;
   } catch (error) {
     logger.error("Error bumping versions:", error);
+    await executeHook("error:bump", config, dryRun);
     throw error;
   }
 }
@@ -2577,24 +2747,25 @@ async function generateSimpleRootChangelog({
   }
 }
 async function changelog(options = {}) {
+  const config = await loadRelizyConfig({
+    configName: options.configName,
+    baseConfig: options.config,
+    overrides: {
+      from: options.from,
+      to: options.to,
+      logLevel: options.logLevel,
+      changelog: {
+        rootChangelog: options.rootChangelog,
+        formatCmd: options.formatCmd
+      }
+    }
+  });
+  const dryRun = options.dryRun ?? false;
+  logger.debug(`Dry run: ${dryRun}`);
+  logger.info(`Version mode: ${config.monorepo?.versionMode || "standalone"}`);
   try {
+    await executeHook("before:changelog", config, dryRun);
     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
@@ -2660,16 +2831,35 @@ async function changelog(options = {}) {
       dryRun
     });
     logger.success(`${dryRun ? "[dry run] " : ""}Changelog generation completed!`);
+    await executeHook("after:changelog", config, dryRun);
   } catch (error) {
     logger.error("Error generating changelogs:", error);
+    await executeHook("error:changelog", config, dryRun);
     throw error;
   }
 }
 
+function providerReleaseSafetyCheck({ config, provider }) {
+  if (!config.safetyCheck || !config.release.providerRelease) {
+    return;
+  }
+  const internalProvider = provider || config.repo?.provider || detectGitProvider();
+  let token;
+  if (internalProvider === "github") {
+    token = config.tokens?.github || config.repo?.token;
+  } else if (internalProvider === "gitlab") {
+    token = config.tokens?.gitlab || config.repo?.token;
+  } else {
+    logger.error(`Unsupported Git provider: ${internalProvider || "unknown"}`);
+    process.exit(1);
+  }
+  if (!token) {
+    logger.error(`No token provided for ${internalProvider || "unknown"} - The release will not be published - Please refer to the documentation: https://louismazel.github.io/relizy/guide/installation#environment-setup`);
+    process.exit(1);
+  }
+}
 async function providerRelease(options = {}) {
-  const dryRun = options.dryRun ?? false;
-  logger.debug(`Dry run: ${dryRun}`);
-  const config = await loadMonorepoConfig({
+  const config = await loadRelizyConfig({
     configName: options.configName,
     baseConfig: options.config,
     overrides: {
@@ -2679,68 +2869,82 @@ async function providerRelease(options = {}) {
         github: options.token,
         gitlab: options.token
       },
-      logLevel: options.logLevel
+      logLevel: options.logLevel,
+      safetyCheck: options.safetyCheck
     }
   });
+  const dryRun = options.dryRun ?? false;
+  logger.debug(`Dry run: ${dryRun}`);
   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}`);
+  try {
+    await executeHook("before:provider-release", config, dryRun);
+    const detectedProvider = options.provider || detectGitProvider();
+    providerReleaseSafetyCheck({ config, provider: detectedProvider });
+    logger.start("Start provider release");
+    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}`);
+    }
+    await executeHook("after:provider-release", config, dryRun);
+    return {
+      detectedProvider,
+      postedReleases
+    };
+  } catch (error) {
+    logger.error("Error publishing releases:", error);
+    await executeHook("error:provider-release", config, dryRun);
+    throw error;
   }
-  return {
-    detectedProvider,
-    postedReleases
-  };
 }
 
 async function publish(options = {}) {
+  const config = await loadRelizyConfig({
+    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
+    }
+  });
+  const dryRun = options.dryRun ?? false;
+  logger.debug(`Dry run: ${dryRun}`);
+  const packageManager = detectPackageManager(process.cwd());
+  logger.debug(`Package manager: ${packageManager}`);
+  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}`);
+  }
   try {
+    await executeHook("before:publish", config, dryRun);
     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,
@@ -2788,18 +2992,20 @@ async function publish(options = {}) {
     if (!dryRun) {
       logger.info("Package(s) have been published to npm registry");
     }
-    logger.success("Publishing completed!");
+    logger.success("Publishing packages completed!");
+    await executeHook("after:publish", config, dryRun);
     return {
       publishedPackages
     };
   } catch (error) {
     logger.error("Error publishing packages:", error);
+    await executeHook("error:publish", config, dryRun);
     throw error;
   }
 }
 
 function getReleaseConfig(options = {}) {
-  return loadMonorepoConfig({
+  return loadRelizyConfig({
     configName: options.configName,
     overrides: {
       logLevel: options.logLevel,
@@ -2832,21 +3038,33 @@ function getReleaseConfig(options = {}) {
         push: options.push,
         publish: options.publish,
         noVerify: options.noVerify,
-        release: options.release,
+        providerRelease: options.providerRelease,
         clean: options.clean
-      }
+      },
+      safetyCheck: options.safetyCheck
     }
   });
 }
+function releaseSafetyCheck({
+  config,
+  provider
+}) {
+  if (!config.safetyCheck) {
+    return;
+  }
+  providerReleaseSafetyCheck({ config, provider });
+}
 async function release(options = {}) {
+  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}, Provider Release: ${config.release.providerRelease}`);
+  releaseSafetyCheck({ config, provider: options.provider });
   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}`);
+    await executeHook("before:release", config, dryRun);
     logger.box("Step 1/6: Bump versions");
     const bumpResult = await bump({
       type: config.bump.type,
@@ -2893,7 +3111,14 @@ async function release(options = {}) {
     }
     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 });
+      await executeHook("before:push", config, dryRun);
+      try {
+        await pushCommitAndTags({ dryRun, logLevel: config.logLevel, cwd: config.cwd });
+        await executeHook("after:push", config, dryRun);
+      } catch (error) {
+        await executeHook("error:push", config, dryRun);
+        throw error;
+      }
     } else {
       logger.info("Skipping push (--no-push or --no-commit)");
     }
@@ -2916,7 +3141,7 @@ async function release(options = {}) {
     let provider = config.repo?.provider;
     let postedReleases = [];
     logger.box("Step 6/6: Publish Git release");
-    if (config.release.release) {
+    if (config.release.providerRelease) {
       logger.debug(`Provider from config: ${provider}`);
       try {
         const response = await providerRelease({
@@ -2933,7 +3158,7 @@ async function release(options = {}) {
         logger.error("Error during release publication:", error);
       }
     } else {
-      logger.info("Skipping release (--no-release)");
+      logger.info("Skipping release (--no-provider-release)");
     }
     const publishedPackageCount = publishResponse?.publishedPackages.length ?? 0;
     const versionDisplay = config.monorepo?.versionMode === "independent" ? `${bumpResult.bumpedPackages.length} packages bumped independently` : bumpResult.newVersion || getRootPackage(config.cwd).version;
@@ -2943,12 +3168,14 @@ 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"}
+Published release: ${config.release.providerRelease ? postedReleases.length : "Disabled"}
 Git provider: ${provider}`);
+    await executeHook("after:release", config, dryRun);
   } catch (error) {
+    await executeHook("error:release", config, dryRun);
     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 };
+export { isStableReleaseType as $, github as A, createGitlabRelease as B, gitlab as C, getPackages as D, getPackageCommits as E, getRootPackage as F, hasLernaJson as G, getPackageToBump as H, detectPackageManager as I, determinePublishTag as J, getPackagesToPublishInSelectiveMode as K, getPackagesToPublishInIndependentMode as L, publishPackage as M, getLastRepoTag as N, getLastPackageTag as O, resolveTags as P, executeHook as Q, isInCI as R, getCIName as S, executeFormatCmd as T, executeBuildCmd as U, determineReleaseType as V, writeVersion as W, bumpPackageVersion as X, updateLernaVersion as Y, extractVersionFromPackageTag as Z, isPrerelease as _, providerRelease as a, isPrereleaseReleaseType as a0, isGraduating as a1, getPreid as a2, isChangedPreid as a3, bumpPackageIndependently as a4, confirmBump as a5, findPackagesWithCommitsAndCalculateVersions as a6, bumpIndependentPackages as a7, bump as b, changelog as c, publish as d, getDefaultConfig as e, defineConfig as f, generateChangelog as g, getPackageDependencies as h, getPackagesWithDependencies as i, getDependentsOf as j, expandPackagesToBumpWithDependents as k, loadRelizyConfig as l, getGitStatus as m, checkGitStatusIfDirty as n, fetchGitTags as o, providerReleaseSafetyCheck as p, detectGitProvider as q, release as r, parseGitRemoteUrl as s, topologicalSort as t, createCommitAndTags as u, pushCommitAndTags as v, writeChangelogToFile as w, getFirstCommit as x, getCurrentGitBranch as y, getCurrentGitRef as z };