@storm-software/git-tools 2.115.16 → 2.116.1

package/bin/git.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { run } from './chunk-54Q5U5WW.js';
-import { getConfig, handleProcess, writeSuccess, exitWithSuccess, exitWithError, writeInfo, findWorkspaceRootSafe, writeFatal, joinPaths, writeDebug, defu, isVerbose, writeWarning, getWorkspaceConfig, writeTrace, __require, STORM_DEFAULT_RELEASE_BANNER } from './chunk-7TA5K5AW.js';
+import { getConfig, handleProcess, writeSuccess, exitWithSuccess, exitWithError, writeInfo, findWorkspaceRootSafe, writeFatal, getWorkspaceConfig, joinPaths, writeDebug, defu, isVerbose, writeWarning, writeTrace, __require, STORM_DEFAULT_RELEASE_BANNER } from './chunk-VATYGW5F.js';
 import TOML from '@ltd/j-toml';
 import { Command, Option } from 'commander';
 import { select, confirm, input } from '@inquirer/prompts';
@@ -10,11 +10,12 @@ import fs, { readFile as readFile$1, writeFile } from 'node:fs/promises';
 import { existsSync } from 'fs';
 import { readFile } from 'fs/promises';
 import childProcess, { execSync } from 'node:child_process';
+import { createJiti } from 'jiti';
+import { existsSync as existsSync$1, rmSync, readdirSync, readFileSync, writeFileSync, statSync, promises } from 'node:fs';
 import defaultRules from '@commitlint/rules';
 import 'stream';
 import util from 'util';
 import { readCachedProjectGraph, createProjectGraphAsync as createProjectGraphAsync$1, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph$1 } from 'nx/src/project-graph/project-graph';
-import { existsSync as existsSync$1, rmSync, readdirSync, readFileSync, writeFileSync, statSync, promises } from 'node:fs';
 import wrap from 'word-wrap';
 import Path, { join as join$1, extname } from 'node:path';
 import { createProjectGraphAsync, readProjectsConfigurationFromProjectGraph } from 'nx/src/project-graph/project-graph.js';
@@ -204,7 +205,7 @@ var COMMIT_TYPES = {
     }
   }
 };
-var DEFAULT_COMMIT_QUESTIONS = {
+var DEFAULT_MINIMAL_COMMIT_QUESTIONS = {
   type: {
     type: "select",
     title: "Commit Type",
@@ -219,15 +220,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",
@@ -270,6 +262,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",
@@ -279,17 +289,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"],
@@ -313,12 +353,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*)(?:\((.*)\))?!: (.*)$/,
+    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*)(?:\((.*)\))!: (.*)$/,
     headerCorrespondence: ["type", "scope", "subject"],
     noteKeywords: ["BREAKING CHANGE", "BREAKING-CHANGE"],
     revertPattern: /^(?:Revert|revert:)\s"?([\s\S]+?)"?\s*This reverts commit (\w*)\./i,
@@ -326,6 +384,38 @@ var DEFAULT_COMMITLINT_CONFIG = {
     issuePrefixes: ["#"]
   }
 };
+var monorepo_default = config2;
+
+// src/commitlint/helpers.ts
+var jiti = createJiti(import.meta.url, { importMeta: import.meta });
+async function resolveCommitlintConfig(workspaceConfig, configPath) {
+  if (configPath && configPath !== "@storm-software/git-tools/commitlint/minimal" && configPath !== "@storm-software/git-tools/commitlint/monorepo") {
+    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";
+    writeInfo(
+      `Using standard commitlint config file: ${configPath}`,
+      workspaceConfig
+    );
+  }
+  let config5 = {};
+  if ((configPath.endsWith(".json") || configPath.endsWith(".jsonc")) && !existsSync$1(jiti.esmResolve(configPath, workspaceConfig.workspaceRoot))) {
+    const configContent = await readFile$1(
+      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 = /(?!.*)/;
@@ -742,11 +832,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 {
@@ -757,7 +844,7 @@ async function lint(message, rawRulesConfig, rawOpts) {
     };
   }
   const allRules = new Map(Object.entries(defaultRules));
-  const missing = Object.keys(rulesConfig).filter(
+  const missing = Object.keys(commitlintConfig.rules).filter(
     (name) => typeof allRules.get(name) !== "function"
   );
   if (missing.length > 0) {
@@ -769,19 +856,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.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.inspect(
@@ -789,11 +876,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.inspect(
-          config
-        )} of length ${config.length}`
+          config5
+        )} of length ${config5.length}`
       );
     }
     if (level < 0 || level > 2) {
@@ -822,9 +909,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}`);
@@ -897,18 +986,18 @@ function getRuleFromScopeEnum(scopeEnum) {
 
 // src/commitlint/run.ts
 var COMMIT_EDITMSG_PATH = ".git/COMMIT_EDITMSG";
-var runCommitLint = async (config, params) => {
+async function runCommitLint(workspaceConfig, options) {
   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 = joinPaths(
-      config.workspaceRoot,
-      params.file || params.message || COMMIT_EDITMSG_PATH
+      workspaceConfig.workspaceRoot,
+      options.file || options.message || COMMIT_EDITMSG_PATH
     );
     if (existsSync(commitFile)) {
       commitMessage = (await readFile(commitFile, "utf8"))?.trim();
@@ -918,14 +1007,14 @@ var runCommitLint = async (config, params) => {
     let gitLogCmd = "git log -1 --no-merges";
     const gitRemotes = childProcess.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) {
         writeWarning(
-          `No upstream remote found for ${config.name}.git. Skipping comparison.`,
-          config
+          `No upstream remote found for ${workspaceConfig.name}.git. Skipping comparison.`,
+          workspaceConfig
         );
         return;
       }
@@ -934,8 +1023,8 @@ var runCommitLint = async (config, params) => {
       gitLogCmd = gitLogCmd + ` ${currentBranch} ^${upstreamRemoteIdentifier}/main`;
     } else {
       writeWarning(
-        `No upstream remote found for ${config.name}.git. Skipping comparison against upstream main.`,
-        config
+        `No upstream remote found for ${workspaceConfig.name}.git. Skipping comparison against upstream main.`,
+        workspaceConfig
       );
       return;
     }
@@ -943,36 +1032,50 @@ var runCommitLint = async (config, params) => {
     if (!commitMessage) {
       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 = 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) {
-    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) {
+    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 += `
 
@@ -986,15 +1089,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 = createJiti(import.meta.url, { importMeta: import.meta });
+async function resolveCommitConfig(workspaceConfig, configPath) {
+  if (configPath && configPath !== "@storm-software/git-tools/commit/minimal" && configPath !== "@storm-software/git-tools/commit/monorepo") {
+    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";
+    writeInfo(
+      `Using standard commit config file: ${configPath}`,
+      workspaceConfig
+    );
+  }
+  let config5 = {};
+  if ((configPath.endsWith(".json") || configPath.endsWith(".jsonc")) && !existsSync$1(jiti2.esmResolve(configPath, workspaceConfig.workspaceRoot))) {
+    const configContent = await readFile$1(
+      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() {
@@ -1007,49 +1176,19 @@ function getGitRootDir() {
   const dir = 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 {
-    writeInfo(`Using custom commit config file: ${commitizenFile}`, config);
-    let commitizenConfig = await import(commitizenFile);
-    if (commitizenConfig?.default) {
-      commitizenConfig = commitizenConfig?.default;
-    }
-    state = {
-      config: await resolveCommitOptions(
-        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) => {
@@ -1065,9 +1204,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") {
@@ -1126,7 +1267,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,
@@ -1145,13 +1286,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(answers.body || "", wrapOptions) : "";
   const breaking = answers.breakingBody && typeof answers.breakingBody === "string" ? wrap(answers.breakingBody || "", wrapOptions) : "";
   const issues = answers.issuesBody && typeof answers.issuesBody === "string" ? wrap(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) {
@@ -1160,26 +1301,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 getConfig();
-  const state = await createState(config, commitizenFile);
+async function runCommit(commitizenFile, dryRun = false) {
+  const workspaceConfig = await getWorkspaceConfig();
+  const state = await createState(workspaceConfig, commitizenFile);
   if (dryRun) {
-    writeInfo("Running in dry mode.", config);
+    writeInfo("Running in dry mode.", workspaceConfig);
   }
   console.log(chalkTemplate`
 {bold.#999999 ----------------------------------------}
@@ -1197,22 +1338,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(commandItems);
   if (dryRun) {
     writeDebug(
       `Skipping execution [dry-run]: ${command.replace(commitMsgFile, ".git/COMMIT_EDITMSG")}`,
-      config
+      workspaceConfig
     );
-    writeDebug(`Message [dry-run]: ${message}`, config);
+    writeDebug(`Message [dry-run]: ${message}`, workspaceConfig);
   } else {
     await fs.writeFile(commitMsgFile, message);
-    run(config, command);
+    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))) {
@@ -1224,8 +1365,8 @@ var askQuestions = async (state) => {
     }
   }
   return state.answers;
-};
-var askQuestion = (index, question) => {
+}
+async function askQuestion(index, question) {
   const message = chalkTemplate`{bold ${index + 1}. ${question.title}} - ${question.description}
 `;
   if (question.type === "select" && question.enum && Object.keys(question.enum).length > 1) {
@@ -1263,7 +1404,7 @@ var askQuestion = (index, question) => {
       validate
     });
   }
-};
+}
 function findFileName(filePath) {
   return filePath?.split(
     filePath?.includes(Path.sep) ? Path.sep : filePath?.includes("/") ? "/" : "\\"
@@ -2469,11 +2610,11 @@ var StormChangelogRenderer = class extends DefaultChangelogRenderer {
    *
    * @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() {
@@ -2926,37 +3067,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(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";
   }
@@ -2979,7 +3120,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) {
@@ -3000,7 +3141,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) {
@@ -3286,8 +3427,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 ? (
@@ -3722,14 +3863,14 @@ async function generateChangelogForWorkspace({
       `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`
     );
@@ -3757,7 +3898,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 = interpolate(interpolatedTreePath, {
       projectName: "",
@@ -3784,8 +3925,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
   });
@@ -3836,8 +3977,8 @@ async function generateChangelogForProjects({
       `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";
@@ -3845,7 +3986,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 = interpolate(interpolatedTreePath, {
         projectName: project.name,
@@ -3872,12 +4013,12 @@ async function generateChangelogForProjects({
         changes,
         changelogEntryVersion: releaseVersion.rawVersion,
         project: project.name,
-        entryWhenNoChanges: typeof config.entryWhenNoChanges === "string" ? interpolate(config.entryWhenNoChanges, {
+        entryWhenNoChanges: typeof config5.entryWhenNoChanges === "string" ? 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),
@@ -4066,7 +4207,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 = {
@@ -4130,21 +4271,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)) {
+  if (!await isUserAnOrganizationMember(process.env.GITHUB_ACTOR, config5)) {
     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;
@@ -4152,9 +4293,9 @@ 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";
-  writeDebug("Creating workspace Project Graph data...", config);
+  writeDebug("Creating workspace Project Graph data...", config5);
   const nxJson = readNxJson();
-  writeDebug("Reading in the workspaces release configuration", config);
+  writeDebug("Reading in the workspaces release configuration", config5);
   const to = options.head || process.env.NX_HEAD;
   const from = options.base || process.env.NX_BASE;
   writeDebug(
@@ -4162,7 +4303,7 @@ var runRelease = async (config, options) => {
  - From: ${from}
  - To: ${to}
 `,
-    config
+    config5
   );
   if (nxJson.release?.groups) {
     nxJson.release.groups = Object.keys(nxJson.release.groups).reduce(
@@ -4180,17 +4321,17 @@ var runRelease = async (config, options) => {
   );
   writeInfo(
     "Using the following `nx.json` release configuration values",
-    config
+    config5
   );
-  writeInfo(nxReleaseConfig, config);
+  writeInfo(nxReleaseConfig, config5);
   const releaseVersion = createAPI$1(nxReleaseConfig);
   const releaseChangelog = createAPI(nxReleaseConfig);
   const releasePublish = createAPI$2(nxReleaseConfig);
-  writeDebug("Determining the current release versions...", config);
+  writeDebug("Determining the current release versions...", config5);
   const { workspaceVersion, projectsVersionData } = await releaseVersion({
     dryRun: false,
-    verbose: isVerbose(config.logLevel),
-    preid: config.preid,
+    verbose: isVerbose(config5.logLevel),
+    preid: config5.preid,
     deleteVersionPlans: false,
     stageChanges: true,
     gitCommit: false
@@ -4200,17 +4341,17 @@ var runRelease = async (config, options) => {
     version: nxReleaseConfig?.projectsRelationship !== "fixed" ? void 0 : workspaceVersion,
     versionData: projectsVersionData,
     dryRun: false,
-    verbose: isVerbose(config.logLevel),
+    verbose: isVerbose(config5.logLevel),
     to,
     from,
     gitCommit: true,
     gitCommitMessage: "release(monorepo): Publish workspace release updates"
   });
-  writeDebug("Tagging commit with git", config);
+  writeDebug("Tagging commit with git", config5);
   if (options.skipPublish) {
     writeWarning(
       "Skipping publishing packages since `skipPublish` was provided as `true` in the release options.",
-      config
+      config5
     );
   } else {
     const changedProjects = Object.keys(projectsVersionData).filter(
@@ -4221,13 +4362,13 @@ var runRelease = async (config, options) => {
         `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: isVerbose(config.logLevel)
+        verbose: isVerbose(config5.logLevel)
       });
       const failedProjects = Object.keys(result).filter(
         (key) => result[key]?.code && result[key]?.code > 0
@@ -4242,12 +4383,12 @@ ${failedProjects.map((failedProject) => `  - ${failedProject} (Error Code: ${res
         );
       }
     } else {
-      writeWarning("Skipped publishing packages.", config);
+      writeWarning("Skipped publishing packages.", config5);
     }
   }
-  writeSuccess("Completed the Storm workspace release process!", config);
+  writeSuccess("Completed the Storm workspace release process!", config5);
 };
-async function updatePackageManifests(projectsVersionData, config) {
+async function updatePackageManifests(projectsVersionData, config5) {
   let projectGraph;
   try {
     projectGraph = readCachedProjectGraph$1();
@@ -4262,7 +4403,7 @@ async function updatePackageManifests(projectsVersionData, config) {
         if (!projectNode?.data.root) {
           writeWarning(
             `Project node ${node} not found in the project graph. Skipping manifest update.`,
-            config
+            config5
           );
           return;
         }
@@ -4271,10 +4412,10 @@ async function updatePackageManifests(projectsVersionData, config) {
           writeTrace(
             `Writing version ${versionData.newVersion} update to manifest file for ${node}
         `,
-            config
+            config5
           );
           const projectRoot = joinPaths(
-            config.workspaceRoot,
+            config5.workspaceRoot,
             projectNode.data.root
           );
           const packageJsonPath = joinPaths(projectRoot, "package.json");
@@ -4296,15 +4437,15 @@ async function updatePackageManifests(projectsVersionData, config) {
       })
     );
   } else {
-    writeWarning("No project nodes found. Skipping manifest updates.", config);
+    writeWarning("No project nodes found. Skipping manifest updates.", config5);
   }
 }
 
 // src/cli/index.ts
 var _config = {};
-function createProgram(config) {
-  _config = config;
-  writeInfo("\u26A1 Running Storm Git Tools", config);
+function createProgram(config5) {
+  _config = config5;
+  writeInfo("\u26A1 Running Storm Git Tools", config5);
   const root = findWorkspaceRootSafe(process.cwd());
   process.env.STORM_WORKSPACE_ROOT ??= root;
   process.env.NX_WORKSPACE_ROOT_PATH ??= root;
@@ -4316,7 +4457,7 @@ function createProgram(config) {
   const commitConfig = new Option(
     "--config <file>",
     "The Commitizen config file path"
-  ).default("@storm-software/git-tools/commit/config");
+  ).makeOptionMandatory(false);
   const commitDryRun = new Option(
     "--dry-run",
     "Should the commit be run in dry-run mode (no updates are made)"
@@ -4362,11 +4503,15 @@ 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 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 {
@@ -4374,7 +4519,7 @@ async function commitAction({
       `\u26A1 Preparing to commit your changes. Please provide the requested details below...`,
       _config
     );
-    await runCommit(config, dryRun);
+    await runCommit(config5, dryRun);
     writeSuccess(
       `\u{1F389} Storm Commit processing completed successfully!
 
@@ -4440,21 +4585,13 @@ Stacktrace: ${error.stack}` : ""}`,
     throw new Error(error.message, { cause: error });
   }
 }
-async function commitLintAction({
-  config,
-  message,
-  file
-}) {
+async function commitLintAction(options) {
   try {
     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
-    });
+    await runCommitLint(_config, options);
     writeSuccess(
       "Linting the commit messages completed successfully!\n",
       _config
@@ -4472,18 +4609,18 @@ ${error.message}`,
 
 // bin/git.ts
 void (async () => {
-  const config = await getConfig();
+  const config5 = await getConfig();
   try {
-    handleProcess(config);
-    const program = createProgram(config);
+    handleProcess(config5);
+    const program = createProgram(config5);
     await program.parseAsync(process.argv);
     writeSuccess(
       `\u{1F389}  Git ${process.argv && process.argv.length >= 3 && process.argv[2] ? process.argv[2] : "tool"} processing completed successfully!`,
-      config
+      config5
     );
-    exitWithSuccess(config);
+    exitWithSuccess(config5);
   } catch (error) {
-    exitWithError(config);
+    exitWithError(config5);
     process.exit(1);
   }
 })();