@storm-software/git-tools 2.115.16 → 2.116.1

package/bin/git.cjs

@@ -2,7 +2,7 @@
 'use strict';
 
 var chunkCIJVSMK2_cjs = require('./chunk-CIJVSMK2.cjs');
-var chunkXH6F7XTV_cjs = require('./chunk-XH6F7XTV.cjs');
+var chunkLD4V463J_cjs = require('./chunk-LD4V463J.cjs');
 var TOML = require('@ltd/j-toml');
 var commander = require('commander');
 var prompts = require('@inquirer/prompts');
@@ -11,6 +11,7 @@ var chalkTemplate = require('chalk-template');
 var fs = require('fs/promises');
 var fs$1 = require('fs');
 var childProcess = require('child_process');
+var jiti$1 = require('jiti');
 var defaultRules = require('@commitlint/rules');
 require('stream');
 var util = require('util');
@@ -28,7 +29,7 @@ var publish_js = require('nx/src/command-line/release/publish.js');
 var version_js = require('nx/src/command-line/release/version.js');
 var nxJson_js = require('nx/src/config/nx-json.js');
 var enquirer = require('enquirer');
-var config = require('nx/src/command-line/release/config/config');
+var config$1 = require('nx/src/command-line/release/config/config');
 var deepMergeJson = require('nx/src/command-line/release/config/deep-merge-json');
 var filterReleaseGroups = require('nx/src/command-line/release/config/filter-release-groups');
 var versionPlans = require('nx/src/command-line/release/config/version-plans');
@@ -56,6 +57,7 @@ var DefaultChangelogRenderer = require('nx/release/changelog-renderer');
 var conventionalCommits = require('nx/src/command-line/release/config/conventional-commits');
 var os = require('os');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var TOML__default = /*#__PURE__*/_interopDefault(TOML);
@@ -221,7 +223,7 @@ var COMMIT_TYPES = {
     }
   }
 };
-var DEFAULT_COMMIT_QUESTIONS = {
+var DEFAULT_MINIMAL_COMMIT_QUESTIONS = {
   type: {
     type: "select",
     title: "Commit Type",
@@ -236,15 +238,6 @@ var DEFAULT_COMMIT_QUESTIONS = {
     maxLength: 20,
     minLength: 3
   },
-  scope: {
-    type: "select",
-    title: "Commit Scope",
-    description: "Select the monorepo project that is primarily impacted by this change",
-    enum: {},
-    defaultValue: "monorepo",
-    maxLength: 50,
-    minLength: 1
-  },
   subject: {
     type: "input",
     title: "Commit Subject",
@@ -287,6 +280,24 @@ var DEFAULT_COMMIT_QUESTIONS = {
     minLength: 3
   }
 };
+var DEFAULT_MONOREPO_COMMIT_QUESTIONS = {
+  type: DEFAULT_MINIMAL_COMMIT_QUESTIONS.type,
+  scope: {
+    type: "select",
+    title: "Commit Scope",
+    description: "Select the project that's the most impacted by this change",
+    enum: {},
+    defaultValue: "monorepo",
+    maxLength: 50,
+    minLength: 1
+  },
+  subject: DEFAULT_MINIMAL_COMMIT_QUESTIONS.subject,
+  body: DEFAULT_MINIMAL_COMMIT_QUESTIONS.body,
+  isBreaking: DEFAULT_MINIMAL_COMMIT_QUESTIONS.isBreaking,
+  breakingBody: DEFAULT_MINIMAL_COMMIT_QUESTIONS.breakingBody,
+  isIssueAffected: DEFAULT_MINIMAL_COMMIT_QUESTIONS.isIssueAffected,
+  issuesBody: DEFAULT_MINIMAL_COMMIT_QUESTIONS.issuesBody
+};
 var DEFAULT_COMMIT_PROMPT_MESSAGES = {
   skip: "press enter to skip",
   max: "must be %d chars at most",
@@ -296,17 +307,47 @@ var DEFAULT_COMMIT_PROMPT_MESSAGES = {
   lowerLimitWarning: "%s is %d characters less than the lower limit",
   closedIssueMessage: "Closes: "
 };
-var DEFAULT_COMMIT_MESSAGE_FORMAT = "{type}({scope}): {emoji}{subject}";
-var DEFAULT_COMMIT_SETTINGS = {
+var DEFAULT_MINIMAL_COMMIT_MESSAGE_FORMAT = "{type}: {emoji}{subject}";
+var DEFAULT_MINIMAL_COMMIT_SETTINGS = {
   enableMultipleScopes: false,
   disableEmoji: true,
   breakingChangePrefix: "\u{1F4A3} ",
   closedIssuePrefix: "\u2705 ",
-  format: DEFAULT_COMMIT_MESSAGE_FORMAT
+  format: DEFAULT_MINIMAL_COMMIT_MESSAGE_FORMAT
 };
-
-// src/commitlint/config.ts
-var DEFAULT_COMMIT_RULES = {
+var DEFAULT_MONOREPO_COMMIT_MESSAGE_FORMAT = "{type}({scope}): {emoji}{subject}";
+var DEFAULT_MONOREPO_COMMIT_SETTINGS = {
+  enableMultipleScopes: false,
+  disableEmoji: true,
+  breakingChangePrefix: "\u{1F4A3} ",
+  closedIssuePrefix: "\u2705 ",
+  format: DEFAULT_MONOREPO_COMMIT_MESSAGE_FORMAT
+};
+var DEFAULT_MINIMAL_COMMIT_RULES = {
+  "body-leading-blank": [1 /* Warning */, "always"],
+  "body-max-length": [2 /* Error */, "always", 600],
+  "footer-leading-blank": [1 /* Warning */, "always"],
+  "footer-max-line-length": [2 /* Error */, "always", 150],
+  "header-max-length": [2 /* Error */, "always", 150],
+  "header-trim": [2 /* Error */, "always"],
+  "subject-case": [2 /* Error */, "always", ["sentence-case"]],
+  "subject-empty": [2 /* Error */, "never"],
+  "subject-full-stop": [2 /* Error */, "never", "."],
+  "subject-max-length": [2 /* Error */, "always", 150],
+  "subject-min-length": [2 /* Error */, "always", 3],
+  "type-case": [2 /* Error */, "always", "kebab-case"],
+  "type-empty": [2 /* Error */, "never"],
+  "type-enum": [
+    2 /* Error */,
+    "always",
+    Object.keys(COMMIT_TYPES)
+  ],
+  "type-max-length": [2 /* Error */, "always", 20],
+  "type-min-length": [2 /* Error */, "always", 3],
+  "scope-case": 0 /* Disabled */,
+  "scope-empty": 0 /* Disabled */
+};
+var DEFAULT_MONOREPO_COMMIT_RULES = {
   "body-leading-blank": [1 /* Warning */, "always"],
   "body-max-length": [2 /* Error */, "always", 600],
   "footer-leading-blank": [1 /* Warning */, "always"],
@@ -330,12 +371,30 @@ var DEFAULT_COMMIT_RULES = {
   "scope-case": [2 /* Error */, "always", ["kebab-case"]],
   "scope-empty": [2 /* Error */, "never"]
 };
-var DEFAULT_COMMITLINT_CONFIG = {
-  rules: DEFAULT_COMMIT_RULES,
-  helpUrl: "https://developer.stormsoftware.com/commitlint",
+
+// src/commitlint/config/minimal.ts
+var config = {
+  rules: DEFAULT_MINIMAL_COMMIT_RULES,
+  helpUrl: "https://developer.stormsoftware.com/commitlint/minimal",
+  parserOpts: {
+    headerPattern: /^(\w*): (.*)$/,
+    breakingHeaderPattern: /^(\w*): (.*)$/,
+    headerCorrespondence: ["type", "subject"],
+    noteKeywords: ["BREAKING CHANGE", "BREAKING-CHANGE"],
+    revertPattern: /^(?:Revert|revert:)\s"?([\s\S]+?)"?\s*This reverts commit (\w*)\./i,
+    revertCorrespondence: ["header", "hash"],
+    issuePrefixes: ["#"]
+  }
+};
+var minimal_default = config;
+
+// src/commitlint/config/monorepo.ts
+var config2 = {
+  rules: DEFAULT_MONOREPO_COMMIT_RULES,
+  helpUrl: "https://developer.stormsoftware.com/commitlint/monorepo",
   parserOpts: {
-    headerPattern: /^(\w*)(?:\((.*)\))?!?: (.*)$/,
-    breakingHeaderPattern: /^(\w*)(?:\((.*)\))?!: (.*)$/,
+    headerPattern: /^(\w*)(?:\((.*)\))!?: (.*)$/,
+    breakingHeaderPattern: /^(\w*)(?:\((.*)\))!: (.*)$/,
     headerCorrespondence: ["type", "scope", "subject"],
     noteKeywords: ["BREAKING CHANGE", "BREAKING-CHANGE"],
     revertPattern: /^(?:Revert|revert:)\s"?([\s\S]+?)"?\s*This reverts commit (\w*)\./i,
@@ -343,6 +402,38 @@ var DEFAULT_COMMITLINT_CONFIG = {
     issuePrefixes: ["#"]
   }
 };
+var monorepo_default = config2;
+
+// src/commitlint/helpers.ts
+var jiti = jiti$1.createJiti(chunkLD4V463J_cjs.importMetaUrl, { importMeta: ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('git.cjs', document.baseURI).href)) }) });
+async function resolveCommitlintConfig(workspaceConfig, configPath) {
+  if (configPath && configPath !== "@storm-software/git-tools/commitlint/minimal" && configPath !== "@storm-software/git-tools/commitlint/monorepo") {
+    chunkLD4V463J_cjs.writeInfo(
+      `Using custom commitlint config file: ${configPath}`,
+      workspaceConfig
+    );
+  } else {
+    configPath = workspaceConfig?.variant === "minimal" ? "@storm-software/git-tools/commitlint/minimal" : "@storm-software/git-tools/commitlint/monorepo";
+    chunkLD4V463J_cjs.writeInfo(
+      `Using standard commitlint config file: ${configPath}`,
+      workspaceConfig
+    );
+  }
+  let config5 = {};
+  if ((configPath.endsWith(".json") || configPath.endsWith(".jsonc")) && !fs$1.existsSync(jiti.esmResolve(configPath, workspaceConfig.workspaceRoot))) {
+    const configContent = await fs.readFile(
+      jiti.esmResolve(configPath, workspaceConfig.workspaceRoot),
+      "utf8"
+    );
+    config5 = JSON.parse(configContent);
+  } else {
+    config5 = await jiti.import(jiti.esmResolve(configPath), { default: true });
+  }
+  return {
+    ...workspaceConfig.variant === "minimal" ? minimal_default : monorepo_default,
+    ...config5 ?? {}
+  };
+}
 
 // ../../node_modules/.pnpm/conventional-commits-parser@6.2.0/node_modules/conventional-commits-parser/dist/regex.js
 var nomatchRegex = /(?!.*)/;
@@ -759,11 +850,8 @@ ${body}` : message;
 ${footer}` : message;
   return message || "";
 };
-async function lint(message, rawRulesConfig, rawOpts) {
-  const rulesConfig = rawRulesConfig || {};
-  const parser = new CommitParser(
-    rawOpts?.parserOpts ?? DEFAULT_COMMITLINT_CONFIG.parserOpts
-  );
+async function lint(message, commitlintConfig) {
+  const parser = new CommitParser(commitlintConfig.parserOpts);
   const parsed = parser.parse(message);
   if (parsed.header === null && parsed.body === null && parsed.footer === null) {
     return {
@@ -774,7 +862,7 @@ async function lint(message, rawRulesConfig, rawOpts) {
     };
   }
   const allRules = new Map(Object.entries(defaultRules__default.default));
-  const missing = Object.keys(rulesConfig).filter(
+  const missing = Object.keys(commitlintConfig.rules).filter(
     (name) => typeof allRules.get(name) !== "function"
   );
   if (missing.length > 0) {
@@ -786,19 +874,19 @@ async function lint(message, rawRulesConfig, rawOpts) {
       ].join("\n")
     );
   }
-  const invalid = Object.entries(rulesConfig).map(([name, config]) => {
-    if (!Array.isArray(config)) {
+  const invalid = Object.entries(commitlintConfig.rules).map(([name, config5]) => {
+    if (!Array.isArray(config5)) {
       return new Error(
         `config for rule ${name} must be array, received ${util__default.default.inspect(
-          config
-        )} of type ${typeof config}`
+          config5
+        )} of type ${typeof config5}`
       );
     }
-    const [level] = config;
-    if (level === 0 /* Disabled */ && config.length === 1) {
+    const [level] = config5;
+    if (level === 0 /* Disabled */ && config5.length === 1) {
       return null;
     }
-    const [, when] = config;
+    const [, when] = config5;
     if (typeof level !== "number" || isNaN(level)) {
       return new Error(
         `level for rule ${name} must be number, received ${util__default.default.inspect(
@@ -806,11 +894,11 @@ async function lint(message, rawRulesConfig, rawOpts) {
         )} of type ${typeof level}`
       );
     }
-    if (config.length < 2 || config.length > 3) {
+    if (config5.length < 2 || config5.length > 3) {
       return new Error(
         `config for rule ${name} must be 2 or 3 items long, received ${util__default.default.inspect(
-          config
-        )} of length ${config.length}`
+          config5
+        )} of length ${config5.length}`
       );
     }
     if (level < 0 || level > 2) {
@@ -839,9 +927,11 @@ async function lint(message, rawRulesConfig, rawOpts) {
   if (invalid.length > 0) {
     throw new Error(invalid.map((i) => i.message).join("\n"));
   }
-  const pendingResults = Object.entries(rulesConfig).filter(([, config]) => !!config && config.length && config[0] > 0).map(async (entry) => {
-    const [name, config] = entry;
-    const [level, when, value] = config;
+  const pendingResults = Object.entries(
+    commitlintConfig.rules
+  ).filter(([, config5]) => !!config5 && config5.length && config5[0] > 0).map(async (entry) => {
+    const [name, config5] = entry;
+    const [level, when, value] = config5;
     const rule = allRules.get(name);
     if (!rule) {
       throw new Error(`Could not find rule implementation for ${name}`);
@@ -914,18 +1004,18 @@ function getRuleFromScopeEnum(scopeEnum) {
 
 // src/commitlint/run.ts
 var COMMIT_EDITMSG_PATH = ".git/COMMIT_EDITMSG";
-var runCommitLint = async (config, params) => {
-  chunkXH6F7XTV_cjs.writeInfo(
+async function runCommitLint(workspaceConfig, options) {
+  chunkLD4V463J_cjs.writeInfo(
     "\u{1F4DD} Validating git commit message aligns with the Storm Software specification",
-    config
+    workspaceConfig
   );
   let commitMessage;
-  if (params.message && params.message !== COMMIT_EDITMSG_PATH) {
-    commitMessage = params.message;
+  if (options.message && options.message !== COMMIT_EDITMSG_PATH) {
+    commitMessage = options.message;
   } else {
-    const commitFile = chunkXH6F7XTV_cjs.joinPaths(
-      config.workspaceRoot,
-      params.file || params.message || COMMIT_EDITMSG_PATH
+    const commitFile = chunkLD4V463J_cjs.joinPaths(
+      workspaceConfig.workspaceRoot,
+      options.file || options.message || COMMIT_EDITMSG_PATH
     );
     if (fs$1.existsSync(commitFile)) {
       commitMessage = (await fs.readFile(commitFile, "utf8"))?.trim();
@@ -935,61 +1025,75 @@ var runCommitLint = async (config, params) => {
     let gitLogCmd = "git log -1 --no-merges";
     const gitRemotes = childProcess__default.default.execSync("git remote -v").toString().trim().split("\n");
     const upstreamRemote = gitRemotes.find(
-      (remote) => remote.includes(`${config.name}.git`)
+      (remote) => remote.includes(`${workspaceConfig.name}.git`)
     );
     if (upstreamRemote) {
       const upstreamRemoteIdentifier = upstreamRemote.split("	")[0]?.trim();
       if (!upstreamRemoteIdentifier) {
-        chunkXH6F7XTV_cjs.writeWarning(
-          `No upstream remote found for ${config.name}.git. Skipping comparison.`,
-          config
+        chunkLD4V463J_cjs.writeWarning(
+          `No upstream remote found for ${workspaceConfig.name}.git. Skipping comparison.`,
+          workspaceConfig
         );
         return;
       }
-      chunkXH6F7XTV_cjs.writeDebug(`Comparing against remote ${upstreamRemoteIdentifier}`);
+      chunkLD4V463J_cjs.writeDebug(`Comparing against remote ${upstreamRemoteIdentifier}`);
       const currentBranch = childProcess__default.default.execSync("git branch --show-current").toString().trim();
       gitLogCmd = gitLogCmd + ` ${currentBranch} ^${upstreamRemoteIdentifier}/main`;
     } else {
-      chunkXH6F7XTV_cjs.writeWarning(
-        `No upstream remote found for ${config.name}.git. Skipping comparison against upstream main.`,
-        config
+      chunkLD4V463J_cjs.writeWarning(
+        `No upstream remote found for ${workspaceConfig.name}.git. Skipping comparison against upstream main.`,
+        workspaceConfig
       );
       return;
     }
     commitMessage = childProcess__default.default.execSync(gitLogCmd).toString().trim();
     if (!commitMessage) {
-      chunkXH6F7XTV_cjs.writeWarning(
+      chunkLD4V463J_cjs.writeWarning(
         "No commits found. Skipping commit message validation.",
-        config
+        workspaceConfig
       );
       return;
     }
   }
-  const allowedTypes = Object.keys(COMMIT_TYPES).join("|");
-  const allowedScopes = await getNxScopes({
-    config
-  });
-  const commitMsgRegex = `(${allowedTypes})\\((${allowedScopes})\\)!?:\\s(([a-z0-9:-s])+)`;
-  const matchCommit = new RegExp(commitMsgRegex, "g").test(commitMessage);
-  const commitlintConfig = chunkXH6F7XTV_cjs.defu(
-    params.config ?? {},
-    { rules: { "scope-enum": getRuleFromScopeEnum(allowedScopes) } },
-    DEFAULT_COMMITLINT_CONFIG
+  const commitlintConfig = await resolveCommitlintConfig(
+    workspaceConfig,
+    options.config
   );
-  const report = await lint(commitMessage, commitlintConfig.rules, {
-    parserOpts: commitlintConfig.parserOpts,
-    helpUrl: commitlintConfig.helpUrl
-  });
-  if (!matchCommit || report.errors.length || report.warnings.length) {
-    chunkXH6F7XTV_cjs.writeSuccess(`Commit was processing completed successfully!`, config);
+  let commitlintRegex;
+  const allowedTypes = commitlintConfig.rules["type-enum"] ?? COMMIT_TYPES;
+  let allowedScopes = [];
+  if (commitlintConfig.rules["scope-empty"] && commitlintConfig.rules["scope-empty"][0] !== 0 /* Disabled */) {
+    allowedScopes = await getNxScopes({
+      config: workspaceConfig
+    });
+    commitlintConfig.rules["scope-enum"] = getRuleFromScopeEnum(allowedScopes);
+    commitlintRegex = new RegExp(
+      `(${Object.keys(allowedTypes).join("|")})\\((${allowedScopes})\\)!?:\\s([a-z0-9:\\-\\/\\s])+`
+    );
+  } else {
+    commitlintRegex = new RegExp(
+      `(${Object.keys(allowedTypes).join("|")})!?:\\s([a-z0-9:\\-\\/\\s])+`
+    );
+  }
+  const report = await lint(commitMessage, commitlintConfig);
+  if (!commitlintRegex.test(commitMessage) || report.errors.length || report.warnings.length) {
+    chunkLD4V463J_cjs.writeSuccess(
+      `Commit was processing completed successfully!`,
+      workspaceConfig
+    );
   } else {
-    let errorMessage = " Oh no! Your commit message: \n-------------------------------------------------------------------\n" + commitMessage + "\n-------------------------------------------------------------------\n\n Does not follow the commit message convention specified by Storm Software.";
-    errorMessage += "\ntype(scope): subject \n BLANK LINE \n body";
+    let errorMessage = " Oh no! Your commit message: \n-------------------------------------------------------------------\n" + commitMessage + `
+-------------------------------------------------------------------
+
+ Does not follow the ${workspaceConfig.variant} commit message convention specified by the ${(typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization?.name) || "Storm Software"} team.`;
+    errorMessage += allowedScopes.length ? "\ntype(scope): subject \n BLANK LINE \n body" : "\ntype: subject \n BLANK LINE \n body";
     errorMessage += "\n";
     errorMessage += `
 Possible types: ${allowedTypes}`;
-    errorMessage += `
+    if (allowedScopes.length) {
+      errorMessage += `
 Possible scopes: ${allowedScopes} (if unsure use "monorepo")`;
+    }
     errorMessage += "\n\nEXAMPLE: \nfeat(my-lib): add an option to generate lazy-loadable modules\nfix(monorepo)!: breaking change should have exclamation mark\n";
     errorMessage += `
 
@@ -1003,15 +1107,81 @@ More details about the Storm Software commit message specification can be found
     throw new Error(errorMessage);
   }
   return report.input;
+}
+
+// src/commit/config/minimal.ts
+var config3 = {
+  settings: DEFAULT_MINIMAL_COMMIT_SETTINGS,
+  messages: DEFAULT_COMMIT_PROMPT_MESSAGES,
+  questions: DEFAULT_MINIMAL_COMMIT_QUESTIONS,
+  types: COMMIT_TYPES
 };
+var minimal_default2 = config3;
 
-// src/commit/config.ts
-var DEFAULT_COMMIT_CONFIG = {
-  settings: DEFAULT_COMMIT_SETTINGS,
+// src/commit/config/monorepo.ts
+var config4 = {
+  settings: DEFAULT_MONOREPO_COMMIT_SETTINGS,
   messages: DEFAULT_COMMIT_PROMPT_MESSAGES,
-  questions: DEFAULT_COMMIT_QUESTIONS,
+  questions: DEFAULT_MONOREPO_COMMIT_QUESTIONS,
   types: COMMIT_TYPES
 };
+var monorepo_default2 = config4;
+
+// src/commit/helpers.ts
+function resolveMinimalCommitOptions(config5 = minimal_default2) {
+  return {
+    parserPreset: "conventional-changelog-conventionalcommits",
+    prompt: {
+      settings: config5.settings,
+      messages: config5.messages,
+      questions: config5.questions
+    }
+  };
+}
+function resolveMonorepoCommitOptions(workspaceConfig, config5 = monorepo_default2) {
+  return {
+    utils: { getScopeEnum: getScopeEnumUtil({ config: workspaceConfig }) },
+    parserPreset: "conventional-changelog-conventionalcommits",
+    prompt: {
+      settings: config5.settings,
+      messages: config5.messages,
+      questions: config5.questions
+    }
+  };
+}
+var jiti2 = jiti$1.createJiti(chunkLD4V463J_cjs.importMetaUrl, { importMeta: ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('git.cjs', document.baseURI).href)) }) });
+async function resolveCommitConfig(workspaceConfig, configPath) {
+  if (configPath && configPath !== "@storm-software/git-tools/commit/minimal" && configPath !== "@storm-software/git-tools/commit/monorepo") {
+    chunkLD4V463J_cjs.writeInfo(
+      `Using custom commit config file: ${configPath}`,
+      workspaceConfig
+    );
+  } else {
+    configPath = workspaceConfig?.variant === "minimal" ? "@storm-software/git-tools/commit/minimal" : "@storm-software/git-tools/commit/monorepo";
+    chunkLD4V463J_cjs.writeInfo(
+      `Using standard commit config file: ${configPath}`,
+      workspaceConfig
+    );
+  }
+  let config5 = {};
+  if ((configPath.endsWith(".json") || configPath.endsWith(".jsonc")) && !fs$1.existsSync(jiti2.esmResolve(configPath, workspaceConfig.workspaceRoot))) {
+    const configContent = await fs.readFile(
+      jiti2.esmResolve(configPath, workspaceConfig.workspaceRoot),
+      "utf8"
+    );
+    config5 = JSON.parse(configContent);
+  } else {
+    config5 = await jiti2.import(jiti2.esmResolve(configPath), { default: true });
+  }
+  const mergedConfig = {
+    ...config5 ?? {},
+    ...workspaceConfig.variant === "minimal" ? minimal_default2 : monorepo_default2
+  };
+  return workspaceConfig.variant === "minimal" ? resolveMinimalCommitOptions(mergedConfig) : resolveMonorepoCommitOptions(
+    workspaceConfig,
+    mergedConfig
+  );
+}
 
 // src/commit/commit-state.ts
 function getGitDir() {
@@ -1024,49 +1194,19 @@ function getGitRootDir() {
   const dir = childProcess.execSync(`git rev-parse --show-toplevel 2>${devNull}`).toString().trim();
   return dir;
 }
-async function resolveCommitOptions(config, workspaceConfig) {
-  return {
-    utils: { getScopeEnum: getScopeEnumUtil({ config: workspaceConfig }) },
-    parserPreset: "conventional-changelog-conventionalcommits",
-    prompt: {
-      settings: config.settings,
-      messages: config.messages,
-      questions: config.questions
-    }
-  };
-}
-async function resolveDefaultCommitOptions(config) {
-  return resolveCommitOptions(DEFAULT_COMMIT_CONFIG, config);
-}
-async function createState(config, commitizenFile = "@storm-software/git-tools/commit/config") {
+async function createState(workspaceConfig, configPath) {
   let root;
   try {
     root = getGitRootDir();
   } catch (_2) {
     throw new Error("Could not find Git root folder.");
   }
-  let state;
-  if (commitizenFile === "@storm-software/git-tools/commit/config") {
-    state = {
-      config: await resolveDefaultCommitOptions(config),
-      root,
-      answers: {}
-    };
-  } else {
-    chunkXH6F7XTV_cjs.writeInfo(`Using custom commit config file: ${commitizenFile}`, config);
-    let commitizenConfig = await import(commitizenFile);
-    if (commitizenConfig?.default) {
-      commitizenConfig = commitizenConfig?.default;
-    }
-    state = {
-      config: await resolveCommitOptions(
-        chunkXH6F7XTV_cjs.defu(commitizenConfig ?? {}, DEFAULT_COMMIT_CONFIG),
-        config
-      ),
-      root,
-      answers: {}
-    };
-  }
+  const state = {
+    variant: workspaceConfig.variant,
+    config: await resolveCommitConfig(workspaceConfig, configPath),
+    root,
+    answers: {}
+  };
   if (state.config.prompt.questions.type && state.config.prompt.questions.type.enum) {
     state.config.prompt.questions.type.enum = Object.keys(state.config.prompt.questions.type.enum).reduce(
       (ret, key) => {
@@ -1082,9 +1222,11 @@ async function createState(config, commitizenFile = "@storm-software/git-tools/c
       {}
     );
   }
-  if (!state.config.prompt.questions.scope || !state.config.prompt.questions.scope.enum || Object.keys(state.config.prompt.questions.scope.enum).length === 0) {
+  if (workspaceConfig.variant === "monorepo" && (!state.config.prompt.questions?.scope || !state.config.prompt.questions?.scope.enum || Object.keys(
+    state.config.prompt.questions?.scope.enum
+  ).length === 0)) {
     const scopes = await getScopeEnum({
-      config
+      config: workspaceConfig
     });
     for (const scope of scopes) {
       if (scope === "monorepo") {
@@ -1116,7 +1258,7 @@ async function createState(config, commitizenFile = "@storm-software/git-tools/c
         const project = projectConfigurations.projects[scope];
         if (project) {
           let description = `${project.name} - ${project.root}`;
-          const packageJsonPath = chunkXH6F7XTV_cjs.joinPaths(project.root, "package.json");
+          const packageJsonPath = chunkLD4V463J_cjs.joinPaths(project.root, "package.json");
           if (fs$1.existsSync(packageJsonPath)) {
             const packageJsonFile = await fs.readFile(packageJsonPath, "utf8");
             const packageJson = JSON.parse(packageJsonFile);
@@ -1143,7 +1285,7 @@ async function createState(config, commitizenFile = "@storm-software/git-tools/c
 }
 var MAX_LINE_WIDTH = 72;
 var formatCommitMessage = (state) => {
-  const { config, answers } = state;
+  const { config: config5, answers } = state;
   const wrapOptions = {
     indent: "",
     trim: true,
@@ -1162,13 +1304,13 @@ var formatCommitMessage = (state) => {
   const scope = answers.scope ? answers.scope.trim() : "";
   const subject = answers.subject?.trim();
   const type = answers.type;
-  const format2 = config.prompt.settings.format || "{type}({scope}): {emoji}{subject}";
+  const format2 = config5.prompt.settings.format || "{type}({scope}): {emoji}{subject}";
   const body = answers.body && typeof answers.body === "string" ? wrap__default.default(answers.body || "", wrapOptions) : "";
   const breaking = answers.breakingBody && typeof answers.breakingBody === "string" ? wrap__default.default(answers.breakingBody || "", wrapOptions) : "";
   const issues = answers.issuesBody && typeof answers.issuesBody === "string" ? wrap__default.default(answers.issuesBody || "", wrapOptions) : "";
   const head = format2.replace(
     /\{emoji\}/g,
-    config.prompt.settings.disableEmoji ? "" : `${emoji} `
+    config5.prompt.settings.disableEmoji ? "" : `${emoji} `
   ).replace(/\{scope\}/g, scope).replace(/\{subject\}/g, subject || "").replace(/\{type\}/g, type || "");
   let msg = head;
   if (body) {
@@ -1177,26 +1319,26 @@ var formatCommitMessage = (state) => {
 ${body}`;
   }
   if (breaking) {
-    const breakingEmoji = config.prompt.settings.disableEmoji ? "" : config.prompt.settings.breakingChangePrefix;
+    const breakingEmoji = config5.prompt.settings.disableEmoji ? "" : config5.prompt.settings.breakingChangePrefix;
     msg += `
 
 BREAKING CHANGE: ${breakingEmoji}${breaking}`;
   }
   if (issues) {
-    const closedIssueEmoji = config.prompt.settings.disableEmoji ? "" : config.prompt.settings.closedIssuePrefix;
+    const closedIssueEmoji = config5.prompt.settings.disableEmoji ? "" : config5.prompt.settings.closedIssuePrefix;
     msg += `
 
-${closedIssueEmoji}${config.prompt.settings.closedIssueMessage}${issues}`;
+${closedIssueEmoji}${config5.prompt.settings.closedIssueMessage}${issues}`;
   }
   return msg;
 };
 
 // src/commit/run.ts
-var runCommit = async (commitizenFile = "@storm-software/git-tools/commit/config", dryRun = false) => {
-  const config = await chunkXH6F7XTV_cjs.getConfig();
-  const state = await createState(config, commitizenFile);
+async function runCommit(commitizenFile, dryRun = false) {
+  const workspaceConfig = await chunkLD4V463J_cjs.getWorkspaceConfig();
+  const state = await createState(workspaceConfig, commitizenFile);
   if (dryRun) {
-    chunkXH6F7XTV_cjs.writeInfo("Running in dry mode.", config);
+    chunkLD4V463J_cjs.writeInfo("Running in dry mode.", workspaceConfig);
   }
   console.log(chalkTemplate__default.default`
 {bold.#999999 ----------------------------------------}
@@ -1206,7 +1348,7 @@ var runCommit = async (commitizenFile = "@storm-software/git-tools/commit/config
 `);
   state.answers = await askQuestions(state);
   const message = formatCommitMessage(state);
-  const commitMsgFile = chunkXH6F7XTV_cjs.joinPaths(getGitDir(), "COMMIT_EDITMSG");
+  const commitMsgFile = chunkLD4V463J_cjs.joinPaths(getGitDir(), "COMMIT_EDITMSG");
   console.log(chalkTemplate__default.default`
 {bold.#999999 ----------------------------------------}
 
@@ -1214,22 +1356,22 @@ var runCommit = async (commitizenFile = "@storm-software/git-tools/commit/config
 {bold.#FFFFFF Git-Commit File} - {#DDDDDD ${commitMsgFile}}
 
     `);
-  await runCommitLint(config, { message });
+  await runCommitLint(workspaceConfig, { message });
   const commandItems = ["git", "commit", "-S"];
   commandItems.push(...["--file", commitMsgFile]);
   const command = shellescape__default.default(commandItems);
   if (dryRun) {
-    chunkXH6F7XTV_cjs.writeDebug(
+    chunkLD4V463J_cjs.writeDebug(
       `Skipping execution [dry-run]: ${command.replace(commitMsgFile, ".git/COMMIT_EDITMSG")}`,
-      config
+      workspaceConfig
     );
-    chunkXH6F7XTV_cjs.writeDebug(`Message [dry-run]: ${message}`, config);
+    chunkLD4V463J_cjs.writeDebug(`Message [dry-run]: ${message}`, workspaceConfig);
   } else {
     await fs__default.default.writeFile(commitMsgFile, message);
-    chunkCIJVSMK2_cjs.run(config, command);
+    chunkCIJVSMK2_cjs.run(workspaceConfig, command);
   }
-};
-var askQuestions = async (state) => {
+}
+async function askQuestions(state) {
   let index = 0;
   for (const key of Object.keys(state.config.prompt.questions)) {
     if (state.config.prompt.questions[key] && !state.config.prompt.questions[key].hidden && (!state.config.prompt.questions[key].when || state.config.prompt.questions[key].when(state.answers))) {
@@ -1241,8 +1383,8 @@ var askQuestions = async (state) => {
     }
   }
   return state.answers;
-};
-var askQuestion = (index, question) => {
+}
+async function askQuestion(index, question) {
   const message = chalkTemplate__default.default`{bold ${index + 1}. ${question.title}} - ${question.description}
 `;
   if (question.type === "select" && question.enum && Object.keys(question.enum).length > 1) {
@@ -1280,7 +1422,7 @@ var askQuestion = (index, question) => {
       validate
     });
   }
-};
+}
 function findFileName(filePath) {
   return filePath?.split(
     filePath?.includes(Path__default.default.sep) ? Path__default.default.sep : filePath?.includes("/") ? "/" : "\\"
@@ -2255,7 +2397,7 @@ async function generateChangelogContent(releaseVersion, filepath, newContent, cu
   const header = await prettier.format(
     `![${(typeof workspaceConfig?.release.banner === "string" ? workspaceConfig.organization ? titleCase(
       typeof workspaceConfig.organization === "string" ? workspaceConfig.organization : workspaceConfig.organization.name
-    ) : void 0 : workspaceConfig?.release.banner.alt) || "Branded release banner image"}](${bannerUrl || chunkXH6F7XTV_cjs.STORM_DEFAULT_RELEASE_BANNER})
+    ) : void 0 : workspaceConfig?.release.banner.alt) || "Branded release banner image"}](${bannerUrl || chunkLD4V463J_cjs.STORM_DEFAULT_RELEASE_BANNER})
 
 # Changelog ${project || workspaceConfig?.name ? "for" : ""}${workspaceConfig?.name ? ` ${titleCase(workspaceConfig.name)}` : ""}${project ? `${workspaceConfig?.name ? " -" : ""} ${titleCase(project)}` : ""}
 
@@ -2486,15 +2628,15 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer__default.def
    *
    * @param config - The configuration object for the ChangelogRenderer
    */
-  constructor(config) {
-    super(config);
+  constructor(config5) {
+    super(config5);
     this.config = {
-      ...config,
-      repoData: config.remoteReleaseClient.getRemoteRepoData()
+      ...config5,
+      repoData: config5.remoteReleaseClient.getRemoteRepoData()
     };
   }
   async render() {
-    this.workspaceConfig = await chunkXH6F7XTV_cjs.getWorkspaceConfig();
+    this.workspaceConfig = await chunkLD4V463J_cjs.getWorkspaceConfig();
     return await super.render();
   }
   preprocessChanges() {
@@ -2805,7 +2947,7 @@ async function createOrUpdateGithubReleaseInternal(githubRequestConfig, release,
     if (!shouldContinueInGitHub) {
       return;
     }
-    const open = chunkXH6F7XTV_cjs.__require("open");
+    const open = chunkLD4V463J_cjs.__require("open");
     await open(result.url).then(() => {
       console.info(
         `
@@ -2918,7 +3060,7 @@ async function resolveTokenData(hostname) {
   );
   if (fs$1.existsSync(ghCLIPath)) {
     const yamlContents = await fs$1.promises.readFile(ghCLIPath, "utf8");
-    const { load } = chunkXH6F7XTV_cjs.__require("@zkochan/js-yaml");
+    const { load } = chunkLD4V463J_cjs.__require("@zkochan/js-yaml");
     const ghCLIConfig = load(yamlContents);
     if (ghCLIConfig[hostname]) {
       if (ghCLIConfig[hostname].oauth_token) {
@@ -2943,37 +3085,37 @@ async function resolveTokenData(hostname) {
     `Unable to resolve a GitHub token for hostname ${hostname}. Please set the GITHUB_TOKEN or GH_TOKEN environment variable, or ensure you have an active session via the official gh CLI tool (https://cli.github.com).`
   );
 }
-async function getGithubReleaseByTag(config, tag) {
+async function getGithubReleaseByTag(config5, tag) {
   return (await makeGithubRequest(
-    config,
-    `/repos/${config.repo}/releases/tags/${tag}`,
+    config5,
+    `/repos/${config5.repo}/releases/tags/${tag}`,
     {}
   )).data;
 }
-async function makeGithubRequest(config, url, opts = {}) {
+async function makeGithubRequest(config5, url, opts = {}) {
   return await axios__default.default(url, {
     ...opts,
-    baseURL: config.apiBaseUrl,
+    baseURL: config5.apiBaseUrl,
     headers: {
       ...opts.headers,
-      Authorization: config.token ? `Bearer ${config.token}` : void 0
+      Authorization: config5.token ? `Bearer ${config5.token}` : void 0
     }
   });
 }
-async function createGithubRelease(config, body) {
-  return (await makeGithubRequest(config, `/repos/${config.repo}/releases`, {
+async function createGithubRelease(config5, body) {
+  return (await makeGithubRequest(config5, `/repos/${config5.repo}/releases`, {
     method: "POST",
     data: body
   })).data;
 }
-async function updateGithubRelease(config, id, body) {
-  return (await makeGithubRequest(config, `/repos/${config.repo}/releases/${id}`, {
+async function updateGithubRelease(config5, id, body) {
+  return (await makeGithubRequest(config5, `/repos/${config5.repo}/releases/${id}`, {
     method: "PATCH",
     data: body
   })).data;
 }
-function githubNewReleaseURL(config, release) {
-  let url = `https://${config.hostname}/${config.repo}/releases/new?tag=${release.version}&title=${release.version}&body=${encodeURIComponent(release.body)}&target=${release.commit}`;
+function githubNewReleaseURL(config5, release) {
+  let url = `https://${config5.hostname}/${config5.repo}/releases/new?tag=${release.version}&title=${release.version}&body=${encodeURIComponent(release.body)}&target=${release.commit}`;
   if (release.prerelease) {
     url += "&prerelease=true";
   }
@@ -2996,7 +3138,7 @@ async function createGithubRemoteReleaseClient(remoteName = "origin") {
     await resolveTokenData(repoData.hostname)
   );
 }
-async function isUserAnOrganizationMember(userId, config, remoteName = "origin") {
+async function isUserAnOrganizationMember(userId, config5, remoteName = "origin") {
   try {
     const repoData = getGitHubRepoData(remoteName, "github");
     if (!repoData) {
@@ -3017,7 +3159,7 @@ async function isUserAnOrganizationMember(userId, config, remoteName = "origin")
         apiBaseUrl: repoData.apiBaseUrl,
         token: tokenData?.token || null
       },
-      `/orgs/${typeof config.organization === "string" ? config.organization : config.organization?.name}/members/${userId}`,
+      `/orgs/${typeof config5.organization === "string" ? config5.organization : config5.organization?.name}/members/${userId}`,
       {}
     );
     if (result.status !== 204) {
@@ -3032,20 +3174,20 @@ async function isUserAnOrganizationMember(userId, config, remoteName = "origin")
 // src/release/changelog.ts
 function createAPI(overrideReleaseConfig) {
   return async function releaseChangelog(args) {
-    const workspaceConfig = await chunkXH6F7XTV_cjs.getWorkspaceConfig();
+    const workspaceConfig = await chunkLD4V463J_cjs.getWorkspaceConfig();
     const projectGraph$1 = await projectGraph.createProjectGraphAsync({ exitOnError: true });
     const nxJson$1 = nxJson.readNxJson();
     const userProvidedReleaseConfig = deepMergeJson.deepMergeJson(
       nxJson$1.release ?? {},
       overrideReleaseConfig ?? {}
     );
-    const { error: configError, nxReleaseConfig } = await config.createNxReleaseConfig(
+    const { error: configError, nxReleaseConfig } = await config$1.createNxReleaseConfig(
       projectGraph$1,
       await fileMapUtils.createProjectFileMapUsingProjectGraph(projectGraph$1),
       userProvidedReleaseConfig
     );
     if (configError) {
-      return await config.handleNxReleaseConfigError(configError, false);
+      return await config$1.handleNxReleaseConfigError(configError, false);
     }
     if (args.printConfig) {
       return printConfig.printConfigAndExit({
@@ -3303,8 +3445,8 @@ ${contents}`);
     }
     const allProjectChangelogs = {};
     for (const releaseGroup of releaseGroups) {
-      const config = releaseGroup.changelog;
-      if (config === false) {
+      const config5 = releaseGroup.changelog;
+      if (config5 === false) {
         continue;
       }
       const projects = args.projects?.length ? (
@@ -3693,7 +3835,7 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
     });
     latestCommit = await git.getCommitHash("HEAD");
   } else if ((args.stageChanges ?? nxReleaseConfig.changelog?.git.stageChanges) && changes.length) {
-    chunkXH6F7XTV_cjs.writeDebug(`Staging changed files with git`);
+    chunkLD4V463J_cjs.writeDebug(`Staging changed files with git`);
     await git.gitAdd({
       changedFiles,
       deletedFiles,
@@ -3702,7 +3844,7 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
     });
   }
   if (args.gitTag ?? nxReleaseConfig.changelog?.git.tag) {
-    chunkXH6F7XTV_cjs.writeDebug(`Tagging commit with git`);
+    chunkLD4V463J_cjs.writeDebug(`Tagging commit with git`);
     for (const tag of gitTagValues) {
       await gitTag({
         tag,
@@ -3714,7 +3856,7 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
     }
   }
   if (args.gitPush ?? nxReleaseConfig.changelog?.git.push) {
-    chunkXH6F7XTV_cjs.writeDebug(`Pushing to git remote "${args.gitRemote}"`);
+    chunkLD4V463J_cjs.writeDebug(`Pushing to git remote "${args.gitRemote}"`);
     await git.gitPush({
       gitRemote: args.gitRemote,
       dryRun: args.dryRun,
@@ -3733,20 +3875,20 @@ async function generateChangelogForWorkspace({
   workspaceChangelogVersion,
   changes
 }) {
-  const workspaceConfig = await chunkXH6F7XTV_cjs.getWorkspaceConfig();
+  const workspaceConfig = await chunkLD4V463J_cjs.getWorkspaceConfig();
   if (!workspaceConfig) {
     throw new Error(
       `Unable to determine the Storm workspace config. Please ensure that your storm-workspace.json file is present and valid.`
     );
   }
-  const config = nxReleaseConfig.changelog?.workspaceChangelog;
-  if (config === false) {
+  const config5 = nxReleaseConfig.changelog?.workspaceChangelog;
+  if (config5 === false) {
     return;
   }
   if (workspaceChangelogVersion === null) {
     return;
   }
-  if (!config) {
+  if (!config5) {
     throw new Error(
       `Workspace changelog is enabled but no configuration was provided. Please provide a workspaceChangelog object in your nx.json`
     );
@@ -3774,7 +3916,7 @@ async function generateChangelogForWorkspace({
   const interactive = args.interactive === "all" || args.interactive === "workspace";
   const dryRun = !!args.dryRun;
   const gitRemote = args.gitRemote;
-  let interpolatedTreePath = config.file || "";
+  let interpolatedTreePath = config5.file || "";
   if (interpolatedTreePath) {
     interpolatedTreePath = utils.interpolate(interpolatedTreePath, {
       projectName: "",
@@ -3801,8 +3943,8 @@ async function generateChangelogForWorkspace({
     changelogEntryVersion: releaseVersion.rawVersion,
     project: null,
     isVersionPlans: false,
-    entryWhenNoChanges: config.entryWhenNoChanges,
-    changelogRenderOptions: config.renderOptions,
+    entryWhenNoChanges: config5.entryWhenNoChanges,
+    changelogRenderOptions: config5.renderOptions,
     conventionalCommitsConfig: nxReleaseConfig.conventionalCommits,
     remoteReleaseClient
   });
@@ -3847,14 +3989,14 @@ async function generateChangelogForProjects({
   nxReleaseConfig,
   projectToAdditionalDependencyBumps
 }) {
-  const workspaceConfig = await chunkXH6F7XTV_cjs.getWorkspaceConfig();
+  const workspaceConfig = await chunkLD4V463J_cjs.getWorkspaceConfig();
   if (!workspaceConfig) {
     throw new Error(
       `Unable to determine the Storm workspace config. Please ensure that your storm-workspace.json file is present and valid.`
     );
   }
-  const config = releaseGroup.changelog;
-  if (config === false) {
+  const config5 = releaseGroup.changelog;
+  if (config5 === false) {
     return;
   }
   const interactive = args.interactive === "all" || args.interactive === "projects";
@@ -3862,7 +4004,7 @@ async function generateChangelogForProjects({
   const gitRemote = args.gitRemote;
   const projectChangelogs = {};
   for (const project of projects) {
-    let interpolatedTreePath = config.file || "";
+    let interpolatedTreePath = config5.file || "";
     if (interpolatedTreePath) {
       interpolatedTreePath = utils.interpolate(interpolatedTreePath, {
         projectName: project.name,
@@ -3889,12 +4031,12 @@ async function generateChangelogForProjects({
         changes,
         changelogEntryVersion: releaseVersion.rawVersion,
         project: project.name,
-        entryWhenNoChanges: typeof config.entryWhenNoChanges === "string" ? utils.interpolate(config.entryWhenNoChanges, {
+        entryWhenNoChanges: typeof config5.entryWhenNoChanges === "string" ? utils.interpolate(config5.entryWhenNoChanges, {
           projectName: project.name,
           projectRoot: project.data.root,
           workspaceRoot: ""
         }) : false,
-        changelogRenderOptions: config.renderOptions,
+        changelogRenderOptions: config5.renderOptions,
         isVersionPlans: !!releaseGroup.versionPlans,
         conventionalCommitsConfig: releaseGroup.versionPlans ? null : nxReleaseConfig.conventionalCommits,
         dependencyBumps: projectToAdditionalDependencyBumps.get(project.name),
@@ -4083,7 +4225,7 @@ ${workspaceConfig.release.footer}
 
 // src/release/config.ts
 var DEFAULT_CONVENTIONAL_COMMITS_CONFIG2 = {
-  questions: DEFAULT_COMMIT_QUESTIONS,
+  questions: DEFAULT_MONOREPO_COMMIT_QUESTIONS,
   types: COMMIT_TYPES
 };
 var DEFAULT_RELEASE_GROUP_CONFIG = {
@@ -4147,21 +4289,21 @@ var DEFAULT_RELEASE_CONFIG = {
 };
 
 // src/release/run.ts
-var runRelease = async (config, options) => {
+var runRelease = async (config5, options) => {
   if (!process.env.GITHUB_ACTOR) {
     throw new Error("The `GITHUB_ACTOR` environment variable is not set.");
   }
-  if (!await isUserAnOrganizationMember(process.env.GITHUB_ACTOR, config)) {
-    chunkXH6F7XTV_cjs.writeFatal(
+  if (!await isUserAnOrganizationMember(process.env.GITHUB_ACTOR, config5)) {
+    chunkLD4V463J_cjs.writeFatal(
       "You must be a member of the Storm Software organization to run the release process.",
-      config
+      config5
     );
     throw new Error(
-      `The GitHub actor "${process.env.GITHUB_ACTOR}" is not a member of the organization "${typeof config.organization === "string" ? config.organization : config.organization?.name}". Only members of the organization can initiate releases.`
+      `The GitHub actor "${process.env.GITHUB_ACTOR}" is not a member of the organization "${typeof config5.organization === "string" ? config5.organization : config5.organization?.name}". Only members of the organization can initiate releases.`
     );
   }
-  const name = config.bot.name;
-  const email = config.bot.email ? config.bot.email : config.bot.name ? `${config.bot.name}@users.noreply.github.com` : "bot@stormsoftware.com";
+  const name = config5.bot.name;
+  const email = config5.bot.email ? config5.bot.email : config5.bot.name ? `${config5.bot.name}@users.noreply.github.com` : "bot@stormsoftware.com";
   process.env.GIT_AUTHOR_NAME = name;
   process.env.GIT_AUTHOR_EMAIL = email;
   process.env.GIT_COMMITTER_NAME = name;
@@ -4169,45 +4311,45 @@ var runRelease = async (config, options) => {
   process.env.NODE_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_AUTH_TOKEN = process.env.NPM_TOKEN;
   process.env.NPM_CONFIG_PROVENANCE = "true";
-  chunkXH6F7XTV_cjs.writeDebug("Creating workspace Project Graph data...", config);
+  chunkLD4V463J_cjs.writeDebug("Creating workspace Project Graph data...", config5);
   const nxJson = nxJson_js.readNxJson();
-  chunkXH6F7XTV_cjs.writeDebug("Reading in the workspaces release configuration", config);
+  chunkLD4V463J_cjs.writeDebug("Reading in the workspaces release configuration", config5);
   const to = options.head || process.env.NX_HEAD;
   const from = options.base || process.env.NX_BASE;
-  chunkXH6F7XTV_cjs.writeDebug(
+  chunkLD4V463J_cjs.writeDebug(
     `Using the following Git SHAs to determine the release content:
  - From: ${from}
  - To: ${to}
 `,
-    config
+    config5
   );
   if (nxJson.release?.groups) {
     nxJson.release.groups = Object.keys(nxJson.release.groups).reduce(
       (ret, groupName) => {
         const groupConfig = nxJson.release?.groups?.[groupName];
-        ret[groupName] = chunkXH6F7XTV_cjs.defu(groupConfig, DEFAULT_RELEASE_GROUP_CONFIG);
+        ret[groupName] = chunkLD4V463J_cjs.defu(groupConfig, DEFAULT_RELEASE_GROUP_CONFIG);
         return ret;
       },
       {}
     );
   }
-  const nxReleaseConfig = chunkXH6F7XTV_cjs.defu(
+  const nxReleaseConfig = chunkLD4V463J_cjs.defu(
     nxJson.release,
     DEFAULT_RELEASE_CONFIG
   );
-  chunkXH6F7XTV_cjs.writeInfo(
+  chunkLD4V463J_cjs.writeInfo(
     "Using the following `nx.json` release configuration values",
-    config
+    config5
   );
-  chunkXH6F7XTV_cjs.writeInfo(nxReleaseConfig, config);
+  chunkLD4V463J_cjs.writeInfo(nxReleaseConfig, config5);
   const releaseVersion = version_js.createAPI(nxReleaseConfig);
   const releaseChangelog = createAPI(nxReleaseConfig);
   const releasePublish = publish_js.createAPI(nxReleaseConfig);
-  chunkXH6F7XTV_cjs.writeDebug("Determining the current release versions...", config);
+  chunkLD4V463J_cjs.writeDebug("Determining the current release versions...", config5);
   const { workspaceVersion, projectsVersionData } = await releaseVersion({
     dryRun: false,
-    verbose: chunkXH6F7XTV_cjs.isVerbose(config.logLevel),
-    preid: config.preid,
+    verbose: chunkLD4V463J_cjs.isVerbose(config5.logLevel),
+    preid: config5.preid,
     deleteVersionPlans: false,
     stageChanges: true,
     gitCommit: false
@@ -4217,34 +4359,34 @@ var runRelease = async (config, options) => {
     version: nxReleaseConfig?.projectsRelationship !== "fixed" ? void 0 : workspaceVersion,
     versionData: projectsVersionData,
     dryRun: false,
-    verbose: chunkXH6F7XTV_cjs.isVerbose(config.logLevel),
+    verbose: chunkLD4V463J_cjs.isVerbose(config5.logLevel),
     to,
     from,
     gitCommit: true,
     gitCommitMessage: "release(monorepo): Publish workspace release updates"
   });
-  chunkXH6F7XTV_cjs.writeDebug("Tagging commit with git", config);
+  chunkLD4V463J_cjs.writeDebug("Tagging commit with git", config5);
   if (options.skipPublish) {
-    chunkXH6F7XTV_cjs.writeWarning(
+    chunkLD4V463J_cjs.writeWarning(
       "Skipping publishing packages since `skipPublish` was provided as `true` in the release options.",
-      config
+      config5
     );
   } else {
     const changedProjects = Object.keys(projectsVersionData).filter(
       (key) => projectsVersionData[key]?.newVersion
     );
     if (changedProjects.length > 0) {
-      chunkXH6F7XTV_cjs.writeInfo(
+      chunkLD4V463J_cjs.writeInfo(
         `Publishing release for ${changedProjects.length} ${changedProjects.length === 1 ? "project" : "projects"}:
 ${changedProjects.map((changedProject) => `  - ${changedProject}`).join("\n")}
 `,
-        config
+        config5
       );
-      await updatePackageManifests(projectsVersionData, config);
+      await updatePackageManifests(projectsVersionData, config5);
       const result = await releasePublish({
         ...options,
         dryRun: !!options.dryRun,
-        verbose: chunkXH6F7XTV_cjs.isVerbose(config.logLevel)
+        verbose: chunkLD4V463J_cjs.isVerbose(config5.logLevel)
       });
       const failedProjects = Object.keys(result).filter(
         (key) => result[key]?.code && result[key]?.code > 0
@@ -4259,12 +4401,12 @@ ${failedProjects.map((failedProject) => `  - ${failedProject} (Error Code: ${res
         );
       }
     } else {
-      chunkXH6F7XTV_cjs.writeWarning("Skipped publishing packages.", config);
+      chunkLD4V463J_cjs.writeWarning("Skipped publishing packages.", config5);
     }
   }
-  chunkXH6F7XTV_cjs.writeSuccess("Completed the Storm workspace release process!", config);
+  chunkLD4V463J_cjs.writeSuccess("Completed the Storm workspace release process!", config5);
 };
-async function updatePackageManifests(projectsVersionData, config) {
+async function updatePackageManifests(projectsVersionData, config5) {
   let projectGraph;
   try {
     projectGraph = devkit.readCachedProjectGraph();
@@ -4277,25 +4419,25 @@ async function updatePackageManifests(projectsVersionData, config) {
       Object.keys(projectsVersionData).map(async (node) => {
         const projectNode = projectGraph.nodes[node];
         if (!projectNode?.data.root) {
-          chunkXH6F7XTV_cjs.writeWarning(
+          chunkLD4V463J_cjs.writeWarning(
             `Project node ${node} not found in the project graph. Skipping manifest update.`,
-            config
+            config5
           );
           return;
         }
         const versionData = projectsVersionData[node];
         if (projectNode?.data.root && versionData && versionData.newVersion !== null) {
-          chunkXH6F7XTV_cjs.writeTrace(
+          chunkLD4V463J_cjs.writeTrace(
             `Writing version ${versionData.newVersion} update to manifest file for ${node}
         `,
-            config
+            config5
           );
-          const projectRoot = chunkXH6F7XTV_cjs.joinPaths(
-            config.workspaceRoot,
+          const projectRoot = chunkLD4V463J_cjs.joinPaths(
+            config5.workspaceRoot,
             projectNode.data.root
           );
-          const packageJsonPath = chunkXH6F7XTV_cjs.joinPaths(projectRoot, "package.json");
-          const cargoTomlPath = chunkXH6F7XTV_cjs.joinPaths(projectRoot, "Cargo.toml");
+          const packageJsonPath = chunkLD4V463J_cjs.joinPaths(projectRoot, "package.json");
+          const cargoTomlPath = chunkLD4V463J_cjs.joinPaths(projectRoot, "Cargo.toml");
           if (fs$1.existsSync(packageJsonPath)) {
             const packageJsonContent = await fs.readFile(packageJsonPath, "utf8");
             const packageJson = JSON.parse(packageJsonContent);
@@ -4313,16 +4455,16 @@ async function updatePackageManifests(projectsVersionData, config) {
       })
     );
   } else {
-    chunkXH6F7XTV_cjs.writeWarning("No project nodes found. Skipping manifest updates.", config);
+    chunkLD4V463J_cjs.writeWarning("No project nodes found. Skipping manifest updates.", config5);
   }
 }
 
 // src/cli/index.ts
 var _config = {};
-function createProgram(config) {
-  _config = config;
-  chunkXH6F7XTV_cjs.writeInfo("\u26A1 Running Storm Git Tools", config);
-  const root = chunkXH6F7XTV_cjs.findWorkspaceRootSafe(process.cwd());
+function createProgram(config5) {
+  _config = config5;
+  chunkLD4V463J_cjs.writeInfo("\u26A1 Running Storm Git Tools", config5);
+  const root = chunkLD4V463J_cjs.findWorkspaceRootSafe(process.cwd());
   process.env.STORM_WORKSPACE_ROOT ??= root;
   process.env.NX_WORKSPACE_ROOT_PATH ??= root;
   if (root) {
@@ -4333,7 +4475,7 @@ function createProgram(config) {
   const commitConfig = new commander.Option(
     "--config <file>",
     "The Commitizen config file path"
-  ).default("@storm-software/git-tools/commit/config");
+  ).makeOptionMandatory(false);
   const commitDryRun = new commander.Option(
     "--dry-run",
     "Should the commit be run in dry-run mode (no updates are made)"
@@ -4379,20 +4521,24 @@ function createProgram(config) {
     "--file <commit-file>",
     "The commit message to lint"
   ).makeOptionMandatory(false);
-  program.command("commitlint").description("Run commitlint for the workspace's commit message.").addOption(commitConfig).addOption(commitMessage).addOption(commitFile).action(commitLintAction);
+  const commitlintConfig = new commander.Option(
+    "--config <file>",
+    "The CommitLint config file path"
+  ).makeOptionMandatory(false);
+  program.command("commitlint").description("Run commitlint for the workspace's commit message.").addOption(commitlintConfig).addOption(commitMessage).addOption(commitFile).action(commitLintAction);
   return program;
 }
 async function commitAction({
-  config = "@storm-software/git-tools/commit/config.js",
+  config: config5,
   dryRun = false
 }) {
   try {
-    chunkXH6F7XTV_cjs.writeInfo(
+    chunkLD4V463J_cjs.writeInfo(
       `\u26A1 Preparing to commit your changes. Please provide the requested details below...`,
       _config
     );
-    await runCommit(config, dryRun);
-    chunkXH6F7XTV_cjs.writeSuccess(
+    await runCommit(config5, dryRun);
+    chunkLD4V463J_cjs.writeSuccess(
       `\u{1F389} Storm Commit processing completed successfully!
 
 Note: Please run "pnpm push" to upload these changes to the remote ${_config.name ? _config.name : _config.namespace ? _config.namespace : _config.organization ? _config.organization : "Storm-Software"} Git repository at ${_config.repository}
@@ -4400,7 +4546,7 @@ Note: Please run "pnpm push" to upload these changes to the remote ${_config.nam
       _config
     );
   } catch (error) {
-    chunkXH6F7XTV_cjs.writeFatal(
+    chunkLD4V463J_cjs.writeFatal(
       `A fatal error occurred while running commit action: 
 
 ${error.message}`,
@@ -4411,14 +4557,14 @@ ${error.message}`,
 }
 async function readmeAction(options) {
   try {
-    chunkXH6F7XTV_cjs.writeInfo("\u26A1 Formatting the workspace's README.md files", _config);
+    chunkLD4V463J_cjs.writeInfo("\u26A1 Formatting the workspace's README.md files", _config);
     await runReadme(options);
-    chunkXH6F7XTV_cjs.writeSuccess(
+    chunkLD4V463J_cjs.writeSuccess(
       "Formatting of the workspace's README.md files is complete\n",
       _config
     );
   } catch (error) {
-    chunkXH6F7XTV_cjs.writeFatal(
+    chunkLD4V463J_cjs.writeFatal(
       `A fatal error occurred while running README format action: 
 
 ${error.message}`
@@ -4433,7 +4579,7 @@ async function releaseAction({
   dryRun
 }) {
   try {
-    chunkXH6F7XTV_cjs.writeInfo(
+    chunkLD4V463J_cjs.writeInfo(
       "\u26A1 Running the Storm Release and Publish process on the workspace",
       _config
     );
@@ -4443,9 +4589,9 @@ async function releaseAction({
       base,
       head
     });
-    chunkXH6F7XTV_cjs.writeSuccess("Release completed successfully!\n", _config);
+    chunkLD4V463J_cjs.writeSuccess("Release completed successfully!\n", _config);
   } catch (error) {
-    chunkXH6F7XTV_cjs.writeFatal(
+    chunkLD4V463J_cjs.writeFatal(
       `A fatal error occurred while running release action: 
 
 ${error.message} ${error.stack ? `
@@ -4457,27 +4603,19 @@ Stacktrace: ${error.stack}` : ""}`,
     throw new Error(error.message, { cause: error });
   }
 }
-async function commitLintAction({
-  config,
-  message,
-  file
-}) {
+async function commitLintAction(options) {
   try {
-    chunkXH6F7XTV_cjs.writeInfo(
+    chunkLD4V463J_cjs.writeInfo(
       `\u26A1 Linting the ${_config.repository ? _config.repository : _config.namespace ? _config.namespace : _config.name ? _config.name : typeof _config.organization === "string" ? _config.organization : _config.organization?.name ? _config.organization?.name : "Storm-Software"} repository's commit messages.`,
       _config
     );
-    await runCommitLint(_config, {
-      config,
-      message,
-      file
-    });
-    chunkXH6F7XTV_cjs.writeSuccess(
+    await runCommitLint(_config, options);
+    chunkLD4V463J_cjs.writeSuccess(
       "Linting the commit messages completed successfully!\n",
       _config
     );
   } catch (error) {
-    chunkXH6F7XTV_cjs.writeFatal(
+    chunkLD4V463J_cjs.writeFatal(
       `A fatal error occurred while linting the commit messages: 
 
 ${error.message}`,
@@ -4489,18 +4627,18 @@ ${error.message}`,
 
 // bin/git.ts
 void (async () => {
-  const config = await chunkXH6F7XTV_cjs.getConfig();
+  const config5 = await chunkLD4V463J_cjs.getConfig();
   try {
-    chunkXH6F7XTV_cjs.handleProcess(config);
-    const program = createProgram(config);
+    chunkLD4V463J_cjs.handleProcess(config5);
+    const program = createProgram(config5);
     await program.parseAsync(process.argv);
-    chunkXH6F7XTV_cjs.writeSuccess(
+    chunkLD4V463J_cjs.writeSuccess(
       `\u{1F389}  Git ${process.argv && process.argv.length >= 3 && process.argv[2] ? process.argv[2] : "tool"} processing completed successfully!`,
-      config
+      config5
     );
-    chunkXH6F7XTV_cjs.exitWithSuccess(config);
+    chunkLD4V463J_cjs.exitWithSuccess(config5);
   } catch (error) {
-    chunkXH6F7XTV_cjs.exitWithError(config);
+    chunkLD4V463J_cjs.exitWithError(config5);
     process.exit(1);
   }
 })();