git-coco 0.20.1 → 0.21.1

package/dist/index.js

@@ -18,6 +18,8 @@ var anthropic = require('@langchain/anthropic');
 var ollama = require('@langchain/ollama');
 var openai = require('@langchain/openai');
 var output_parsers = require('@langchain/core/output_parsers');
+require('@langchain/core/utils/json_schema');
+require('@langchain/core/utils/types');
 var base = require('@langchain/core/language_models/base');
 var runnables = require('@langchain/core/runnables');
 var outputs = require('@langchain/core/outputs');
@@ -39,6 +41,8 @@ var child_process = require('child_process');
 var readline = require('node:readline');
 var require$$0 = require('stream');
 var readline$1 = require('readline');
+var core$1 = require('@commitlint/core');
+var url = require('url');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -68,7 +72,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline$1);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.20.1";
+const BUILD_VERSION = "0.21.1";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -1200,6 +1204,8 @@ const schema$1 = {
                 "text-davinci-edit-001",
                 "code-davinci-edit-001",
                 "text-embedding-ada-002",
+                "text-embedding-3-small",
+                "text-embedding-3-large",
                 "text-similarity-davinci-001",
                 "text-similarity-curie-001",
                 "text-similarity-babbage-001",
@@ -1235,10 +1241,54 @@ const schema$1 = {
                 "gpt-4-vision-preview",
                 "gpt-4o",
                 "gpt-4o-2024-05-13",
+                "gpt-4o-2024-08-06",
+                "gpt-4o-2024-11-20",
+                "gpt-4o-mini-2024-07-18",
                 "gpt-4o-mini",
+                "gpt-4o-search-preview",
+                "gpt-4o-search-preview-2025-03-11",
+                "gpt-4o-mini-search-preview",
+                "gpt-4o-mini-search-preview-2025-03-11",
+                "gpt-4o-audio-preview",
+                "gpt-4o-audio-preview-2024-12-17",
+                "gpt-4o-audio-preview-2024-10-01",
+                "gpt-4o-mini-audio-preview",
+                "gpt-4o-mini-audio-preview-2024-12-17",
+                "o1",
+                "o1-2024-12-17",
+                "o1-mini",
+                "o1-mini-2024-09-12",
+                "o1-preview",
+                "o1-preview-2024-09-12",
+                "o1-pro",
+                "o1-pro-2025-03-19",
+                "o3",
+                "o3-2025-04-16",
+                "o3-mini",
+                "o3-mini-2025-01-31",
+                "o4-mini",
+                "o4-mini-2025-04-16",
+                "chatgpt-4o-latest",
+                "gpt-4o-realtime",
+                "gpt-4o-realtime-preview-2024-10-01",
+                "gpt-4o-realtime-preview-2024-12-17",
+                "gpt-4o-mini-realtime-preview",
+                "gpt-4o-mini-realtime-preview-2024-12-17",
                 "gpt-4.1",
+                "gpt-4.1-2025-04-14",
                 "gpt-4.1-mini",
-                "gpt-4.1-nano"
+                "gpt-4.1-mini-2025-04-14",
+                "gpt-4.1-nano",
+                "gpt-4.1-nano-2025-04-14",
+                "gpt-4.5-preview",
+                "gpt-4.5-preview-2025-02-27",
+                "gpt-5",
+                "gpt-5-2025-08-07",
+                "gpt-5-nano",
+                "gpt-5-nano-2025-08-07",
+                "gpt-5-mini",
+                "gpt-5-mini-2025-08-07",
+                "gpt-5-chat-latest"
             ]
         },
         "OllamaModel": {
@@ -1500,6 +1550,13 @@ const schema$1 = {
         "ChatModel": {
             "type": "string",
             "enum": [
+                "gpt-5",
+                "gpt-5-mini",
+                "gpt-5-nano",
+                "gpt-5-2025-08-07",
+                "gpt-5-mini-2025-08-07",
+                "gpt-5-nano-2025-08-07",
+                "gpt-5-chat-latest",
                 "gpt-4.1",
                 "gpt-4.1-mini",
                 "gpt-4.1-nano",
@@ -6223,8 +6280,6 @@ function getPrompt({ template, variables, fallback }) {
     throw new LangChainExecutionError('getPrompt: Unexpected execution path - neither template nor fallback available', { template, fallback, variables });
 }
 
-new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-
 /**
  * Base interface that all chains must implement.
  */
@@ -6327,7 +6382,7 @@ class BaseChain extends base.BaseLangChain {
     async run(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, config) {
-        const inputKeys = this.inputKeys.filter((k) => !this.memory?.memoryKeys.includes(k) ?? true);
+        const inputKeys = this.inputKeys.filter((k) => !this.memory?.memoryKeys.includes(k));
         const isKeylessInput = inputKeys.length <= 1;
         if (!isKeylessInput) {
             throw new Error(`Chain ${this._chainType()} expects multiple inputs, cannot use 'run' `);
@@ -6498,7 +6553,7 @@ function _getLanguageModel(llmLike) {
  * import { ChatOpenAI } from "@langchain/openai";
  *
  * const prompt = ChatPromptTemplate.fromTemplate("Tell me a {adjective} joke");
- * const llm = new ChatOpenAI();
+ * const llm = new ChatOpenAI({ model: "gpt-4o-mini" });
  * const chain = prompt.pipe(llm);
  *
  * const response = await chain.invoke({ adjective: "funny" });
@@ -7114,6 +7169,8 @@ Please follow the guidelines below when writing your commit message:
 
 {{branch_name_context}}
 
+{{commitlint_rules_context}}
+
 {{format_instructions}}
 
 {{commit_history}}
@@ -7121,7 +7178,7 @@ Please follow the guidelines below when writing your commit message:
 {{additional_context}}
 `;
 // Define the variables that will be passed to the prompt template
-const inputVariables$3 = ['summary', 'format_instructions', 'additional_context', 'commit_history', 'branch_name_context'];
+const inputVariables$3 = ['summary', 'format_instructions', 'additional_context', 'commit_history', 'branch_name_context', 'commitlint_rules_context'];
 const COMMIT_PROMPT = new prompts$1.PromptTemplate({
     template: template$4,
     inputVariables: inputVariables$3,
@@ -7163,23 +7220,20 @@ Based on the following diff summary, generate a conventional commit message that
 
 {{branch_name_context}}
 
+{{commitlint_rules_context}}
+
 {{format_instructions}}
 
 {{commit_history}}
 
-{{additional_context}}
-
-Remember:
-- Be concise and precise
-- Focus on WHAT and WHY, not HOW
-- Use imperative mood in both title and body
-- Ensure the title alone provides enough context to understand the change`;
+{{additional_context}}`;
 const conventionalInputVariables = [
     'summary',
     'additional_context',
     'commit_history',
     'format_instructions',
     'branch_name_context',
+    'commitlint_rules_context',
 ];
 const CONVENTIONAL_COMMIT_PROMPT = new prompts$1.PromptTemplate({
     template: CONVENTIONAL_TEMPLATE,
@@ -7388,7 +7442,9 @@ async function generateAndReviewLoop({ label, factory, parser, noResult, agent,
                 continue;
             }
             // Only edit the result in interactive mode if approved
-            result = await editResult(result, options);
+            // Use custom edit function if provided, otherwise use default editResult
+            const editFunction = options.review?.customEditFunction || editResult;
+            result = await editFunction(result, options);
         }
         else {
             // In non-interactive mode, we return the result as is to be output to stdout by the caller.
@@ -7572,17 +7628,17 @@ var changelog = {
 const conventionalTypeRegex = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?:/;
 // Regular commit message schema with basic validation
 const CommitMessageResponseSchema = objectType({
-    title: stringType(),
-    body: stringType(),
-});
+    title: stringType().describe("Title of the commit message"),
+    body: stringType().describe("Body of the commit message"),
+}).describe("Object with commit message 'title' and 'body'");
 // Conventional commit message schema with strict formatting rules
 const ConventionalCommitMessageResponseSchema = objectType({
     title: stringType()
         .max(50, "Title must be 50 characters or less")
-        .refine((title) => conventionalTypeRegex.test(title), "Title must follow Conventional Commits format (e.g., 'feat: add new feature' or 'fix(scope): fix bug')"),
-    body: stringType()
+        .refine((title) => conventionalTypeRegex.test(title), "Title must follow Conventional Commits format (e.g., 'feat: add new feature' or 'fix(scope): fix bug')").describe("Title of the commit message"),
+    body: stringType().describe("Body of the commit message")
     // .max(280, "Body must be 280 characters or less"),
-});
+}).describe("Object with Conventional Commit message 'title' and 'body' adhering to Conventional Commits specification");
 const command$3 = 'commit';
 /**
  * Command line options via yargs
@@ -8241,12 +8297,12 @@ function formatSet(input) {
  * const overallChain = new SequentialChain({
  *   chains: [
  *     new LLMChain({
- *       llm: new ChatOpenAI({ temperature: 0 }),
+ *       llm: new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0 }),
  *       prompt: promptTemplate,
  *       outputKey: "synopsis",
  *     }),
  *     new LLMChain({
- *       llm: new OpenAI({ temperature: 0 }),
+ *       llm: new OpenAI({ model: "gpt-4o-mini", temperature: 0 }),
  *       prompt: reviewPromptTemplate,
  *       outputKey: "review",
  *     }),
@@ -8483,7 +8539,8 @@ class SimpleSequentialChain extends BaseChain {
     /** @ignore */
     _validateChains() {
         for (const chain of this.chains) {
-            if (chain.inputKeys.filter((k) => !chain.memory?.memoryKeys.includes(k) ?? true).length !== 1) {
+            if (chain.inputKeys.filter((k) => !chain.memory?.memoryKeys.includes(k))
+                .length !== 1) {
                 throw new Error(`Chains used in SimpleSequentialChain should all have one input, got ${chain.inputKeys.length} for ${chain._chainType()}.`);
             }
             if (chain.outputKeys.length !== 1) {
@@ -11037,6 +11094,75 @@ const getTokenCounter = async (modelName) => {
     });
 };
 
+const COMMITLINT_CONFIG_FILES = [
+    '.commitlintrc',
+    '.commitlintrc.json',
+    '.commitlintrc.yaml',
+    '.commitlintrc.yml',
+    '.commitlintrc.js',
+    '.commitlintrc.cjs',
+    'commitlint.config.js',
+    'commitlint.config.cjs',
+];
+
+/**
+ * Finds the project root directory starting from the given current directory.
+ * It checks if the `.git` directory or `package.json` file exists in the current directory or any of its parent directories.
+ * If found, it returns the path to the project root directory.
+ * If not found, it throws an error.
+ *
+ * @param currentDir - The current directory to start searching from.
+ * @returns The path to the project root directory.
+ * @throws Error if the project root directory cannot be found.
+ */
+function findProjectRoot(currentDir) {
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        if (fs.existsSync(path.join(currentDir, '.git')) ||
+            fs.existsSync(path.join(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    throw new Error('Unable to find project root. Are you in the right directory?');
+}
+
+/**
+ * Check if a commitlint configuration exists in the project root.
+ */
+async function hasCommitlintConfig() {
+    const projectRoot = findProjectRoot(process.cwd());
+    if (!projectRoot) {
+        return false;
+    }
+    // Check for dedicated commitlint config files
+    for (const file of COMMITLINT_CONFIG_FILES) {
+        if (fs.existsSync(path.join(projectRoot, file))) {
+            return true;
+        }
+    }
+    // Check for commitlint config in package.json
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkgContent = fs.readFileSync(pkgPath, 'utf8');
+            const pkg = JSON.parse(pkgContent);
+            if (pkg.commitlint) {
+                return true;
+            }
+        }
+        catch (error) {
+            // Ignore errors reading or parsing package.json
+        }
+    }
+    return false;
+}
+
+var hasCommitlintConfig$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  hasCommitlintConfig: hasCommitlintConfig
+});
+
 async function noResult$2({ git, logger }) {
     const { staged, unstaged, untracked } = await getChanges({ git });
     const hasStaged = staged && staged.length > 0;
@@ -11091,12 +11217,18 @@ const handler$3 = async (argv, logger) => {
             color: 'yellow',
         });
     }
+    logger.verbose(`→ ${provider} (${model})`, {
+        color: 'green',
+    });
+    const USE_CONVENTIONAL_COMMITS = config.conventionalCommits || argv.conventional;
     async function factory() {
         if (config.noDiff) {
             const status = await git.status();
-            return status.files.map(file => ({
+            return status.files.map((file) => ({
                 filePath: file.path,
-                status: (file.index === 'A' || file.index === '?' ? 'added' : 'modified'),
+                status: (file.index === 'A' || file.index === '?'
+                    ? 'added'
+                    : 'modified'),
                 summary: file.path, // Simplified summary for noDiff
             }));
         }
@@ -11112,6 +11244,13 @@ const handler$3 = async (argv, logger) => {
         }
     }
     async function parser(changes) {
+        if (config.noDiff) {
+            // When noDiff is enabled, just return a simple summary without parsing file contents
+            const filesSummary = changes
+                .map((change) => `${change.status}: ${change.filePath}`)
+                .join('\n');
+            return `Staged files:\n${filesSummary}`;
+        }
         return await fileChangeParser({
             changes,
             commit: '--staged',
@@ -11123,7 +11262,7 @@ const handler$3 = async (argv, logger) => {
         options: {
             ...config,
             prompt: config.prompt ||
-                (config.conventionalCommits || argv.conventional
+                (USE_CONVENTIONAL_COMMITS
                     ? CONVENTIONAL_COMMIT_PROMPT.template
                     : COMMIT_PROMPT.template),
             logger,
@@ -11136,21 +11275,27 @@ const handler$3 = async (argv, logger) => {
                     retryMessageOnly: 'Restart the function execution from generating the commit message',
                     retryFull: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
                 },
+                customEditFunction: async (message, options) => {
+                    const { editCommitMessage } = await Promise.resolve().then(function () { return editCommitMessage$1; });
+                    return editCommitMessage(message, options);
+                },
             },
         },
         factory,
         parser,
         agent: async (context, options) => {
-            // Check if conventional commits are enabled via config or CLI flag
-            const useConventional = config.conventionalCommits || argv.conventional;
             // Select the appropriate schema based on whether conventional commits are enabled
-            const schema = useConventional
+            const schema = USE_CONVENTIONAL_COMMITS
                 ? ConventionalCommitMessageResponseSchema
                 : CommitMessageResponseSchema;
             const formatInstructions = `You must always return valid JSON fenced by a markdown code block. Do not return any additional text. The JSON object you return should match the following schema:
-{{ body: string, title: string }}`;
+${schema.description}
+{
+  "title": "The commit title",
+  "body": "The commit body"
+}`;
             // Use conventional commit prompt if enabled
-            const promptTemplate = useConventional ? CONVENTIONAL_COMMIT_PROMPT : COMMIT_PROMPT;
+            const promptTemplate = USE_CONVENTIONAL_COMMITS ? CONVENTIONAL_COMMIT_PROMPT : COMMIT_PROMPT;
             const prompt = getPrompt({
                 template: options.prompt,
                 variables: promptTemplate.inputVariables,
@@ -11180,6 +11325,13 @@ const handler$3 = async (argv, logger) => {
                 : config.includeBranchName !== false; // Default to true if not explicitly set to false
             // Create branch name context string based on the configuration
             const branchNameContext = includeBranchName ? `Current git branch name: ${branchName}` : '';
+            // Load commitlint rules context if available
+            const hasCommitLintConfig = await hasCommitlintConfig();
+            let commitlint_rules_context = '';
+            if (USE_CONVENTIONAL_COMMITS || hasCommitLintConfig) {
+                const { getCommitlintRulesContext } = await Promise.resolve().then(function () { return commitlintValidator; });
+                commitlint_rules_context = await getCommitlintRulesContext();
+            }
             // Get variables for the prompt
             const variables = {
                 summary: context,
@@ -11187,59 +11339,106 @@ const handler$3 = async (argv, logger) => {
                 additional_context: additional_context,
                 commit_history: commit_history,
                 branch_name_context: branchNameContext,
+                commitlint_rules_context: commitlint_rules_context,
             };
             const maxAttempts = config.service.provider === 'ollama' && 'maxParsingAttempts' in config.service
                 ? config.service.maxParsingAttempts || 3
                 : 3;
-            const commitMsg = await executeChainWithSchema(schema, llm, prompt, variables, {
-                retryOptions: {
-                    maxAttempts,
-                    onRetry: (attempt, error) => {
-                        logger.verbose(`Failed to parse commit message (attempt ${attempt}/${maxAttempts}): ${error.message}`, { color: 'yellow' });
+            // Custom retry logic for commitlint validation
+            let retryCount = 0;
+            let validationErrors = '';
+            const generateCommitMessage = async () => {
+                // Update variables with validation errors for retry attempts
+                const currentVariables = {
+                    ...variables,
+                    additional_context: validationErrors
+                        ? `${variables.additional_context}\n\n## Validation Errors from Previous Attempt\nPlease fix the following issues:\n${validationErrors}`
+                        : variables.additional_context,
+                };
+                const commitMsg = await executeChainWithSchema(schema, llm, prompt, currentVariables, {
+                    retryOptions: {
+                        maxAttempts,
+                        onRetry: (attempt, error) => {
+                            logger.verbose(`Failed to parse commit message (attempt ${attempt}/${maxAttempts}): ${error.message}`, { color: 'yellow' });
+                        },
                     },
-                },
-                fallbackParser: (text) => ({
-                    title: text.split('\n')[0] || 'Auto-generated commit',
-                    body: text.split('\n').slice(1).join('\n') || 'Generated commit message',
-                }),
-                onFallback: () => {
-                    logger.verbose('Max retry attempts reached. Falling back to simple text output.', {
-                        color: 'red',
+                    fallbackParser: (text) => ({
+                        title: text.split('\n')[0] || 'Auto-generated commit',
+                        body: text.split('\n').slice(1).join('\n') || 'Generated commit message',
+                    }),
+                    onFallback: () => {
+                        logger.verbose('Max retry attempts reached. Falling back to simple text output.', {
+                            color: 'red',
+                        });
+                    },
+                });
+                // Construct the full commit message
+                const appendedText = argv.append ? `\n\n${argv.append}` : '';
+                const ticketId = extractTicketIdFromBranchName(branchName);
+                const ticketFooter = argv.appendTicket && ticketId ? `\n\nPart of **${ticketId}**` : '';
+                const fullMessage = `${commitMsg.title}\n\n${commitMsg.body}${appendedText}${ticketFooter}`;
+                // If commitlint validation is needed, validate the message
+                if (USE_CONVENTIONAL_COMMITS || hasCommitLintConfig) {
+                    const { validateCommitMessage, CommitlintValidationError } = await Promise.resolve().then(function () { return commitlintValidator; });
+                    const validationResult = await validateCommitMessage(fullMessage);
+                    logger.verbose(`Validation result: ${JSON.stringify(validationResult)}`, {
+                        color: 'yellow',
                     });
+                    if (!validationResult.valid) {
+                        retryCount++;
+                        // Format validation errors for next attempt
+                        validationErrors = validationResult.errors.map((error) => `- ${error}`).join('\n');
+                        // Auto-retry up to 2 times
+                        if (retryCount <= 2) {
+                            logger.verbose(`Commit message validation failed (attempt ${retryCount}/2). Retrying with error feedback...`, { color: 'yellow' });
+                            throw new CommitlintValidationError(`Validation failed: ${validationResult.errors.join('; ')}`, validationResult, fullMessage);
+                        }
+                        // After 2 failed attempts, let the user decide
+                        const { handleValidationErrors } = await Promise.resolve().then(function () { return commitValidationHandler; });
+                        const validationHandlerResult = await handleValidationErrors(fullMessage, validationResult, {
+                            logger,
+                            interactive: INTERACTIVE,
+                            openInEditor: config.openInEditor,
+                        });
+                        logger.verbose(`Validation handler result: ${JSON.stringify(validationHandlerResult)}`, {
+                            color: 'blue',
+                        });
+                        switch (validationHandlerResult.action) {
+                            case 'proceed':
+                                return validationHandlerResult.message;
+                            case 'edit':
+                                return validationHandlerResult.message;
+                            case 'regenerate':
+                                // Reset retry count and validation errors for fresh attempts
+                                retryCount = 0;
+                                validationErrors = '';
+                                throw new CommitlintValidationError('User requested regeneration', validationResult, fullMessage);
+                            case 'abort':
+                                logger.log('\nAborting commit due to validation errors.', { color: 'red' });
+                                process.exit(1);
+                        }
+                    }
+                }
+                return fullMessage;
+            };
+            // Custom shouldRetry function for commitlint errors
+            const shouldRetryCommitlint = (error) => {
+                return error.name === 'CommitlintValidationError';
+            };
+            // Use retry wrapper for commitlint validation with up to 4 total attempts
+            // (2 automatic retries + 2 more if user chooses "Try again")
+            return await withRetry(generateCommitMessage, {
+                maxAttempts: 6, // Allow for multiple user retry requests
+                shouldRetry: shouldRetryCommitlint,
+                backoffMs: 0, // No delay needed for commitlint retries
+                onRetry: (attempt, error) => {
+                    if (error.name === 'CommitlintValidationError' && attempt <= 2) {
+                        // Don't log for auto-retries, we already log in the function
+                        return;
+                    }
+                    logger.verbose(`Retrying commit message generation (attempt ${attempt}): ${error.message}`, { color: 'yellow' });
                 },
             });
-            // Construct the full commit message
-            const appendedText = argv.append ? `\n\n${argv.append}` : '';
-            const ticketId = extractTicketIdFromBranchName(branchName);
-            const ticketFooter = argv.appendTicket && ticketId ? `\n\nPart of **${ticketId}**` : '';
-            const fullMessage = `${commitMsg.title}\n\n${commitMsg.body}${appendedText}${ticketFooter}`;
-            // If conventional commits are enabled, validate with commitlint
-            if (useConventional) {
-                const { validateCommitMessage } = await Promise.resolve().then(function () { return commitlintValidator; });
-                const { handleValidationErrors } = await Promise.resolve().then(function () { return commitValidationHandler; });
-                const validationResult = await validateCommitMessage(fullMessage);
-                const validationHandlerResult = await handleValidationErrors(fullMessage, validationResult, {
-                    logger,
-                    interactive: INTERACTIVE,
-                    openInEditor: config.openInEditor,
-                });
-                switch (validationHandlerResult.action) {
-                    case 'proceed':
-                        // Validation passed, use the message as is
-                        return validationHandlerResult.message;
-                    case 'edit':
-                        // User edited the message, use the edited version
-                        return validationHandlerResult.message;
-                    case 'regenerate':
-                        // User wants to regenerate, throw special error to trigger regeneration
-                        throw new Error('REGENERATE_COMMIT_MESSAGE');
-                    case 'abort':
-                        // User wants to abort or validation failed in non-interactive mode
-                        logger.log('\nAborting commit due to validation errors.', { color: 'red' });
-                        process.exit(1);
-                }
-            }
-            return fullMessage;
         },
         noResult: async () => {
             await noResult$2({ git, logger });
@@ -11280,28 +11479,6 @@ const builder$2 = (yargs) => {
     return yargs.options(options$2).usage(getCommandUsageHeader(command$2));
 };
 
-/**
- * Finds the project root directory starting from the given current directory.
- * It checks if the `.git` directory or `package.json` file exists in the current directory or any of its parent directories.
- * If found, it returns the path to the project root directory.
- * If not found, it throws an error.
- *
- * @param currentDir - The current directory to start searching from.
- * @returns The path to the project root directory.
- * @throws Error if the project root directory cannot be found.
- */
-function findProjectRoot(currentDir) {
-    const root = path.parse(currentDir).root;
-    while (currentDir !== root) {
-        if (fs.existsSync(path.join(currentDir, '.git')) ||
-            fs.existsSync(path.join(currentDir, 'package.json'))) {
-            return currentDir;
-        }
-        currentDir = path.dirname(currentDir);
-    }
-    throw new Error('Unable to find project root. Are you in the right directory?');
-}
-
 /**
  * Executes a command as a Promise and returns the result.
  *
@@ -13221,11 +13398,13 @@ function isObservable(obj) {
     return !!obj && (obj instanceof Observable || (isFunction(obj.lift) && isFunction(obj.subscribe)));
 }
 
-var EmptyError = createErrorClass(function (_super) { return function EmptyErrorImpl() {
-    _super(this);
-    this.name = 'EmptyError';
-    this.message = 'no elements in sequence';
-}; });
+var EmptyError = createErrorClass(function (_super) {
+    return function EmptyErrorImpl() {
+        _super(this);
+        this.name = 'EmptyError';
+        this.message = 'no elements in sequence';
+    };
+});
 
 function lastValueFrom(source, config) {
     var hasConfig = typeof config === 'object';
@@ -14512,23 +14691,183 @@ y.command(review.command, review.desc, review.builder, review.handler);
 y.command(init.command, init.desc, init.builder, init.handler);
 y.help().parse(process.argv.slice(2));
 
+/**
+ * Edit a commit message with commitlint validation if config exists
+ */
+async function editCommitMessage(message, options) {
+    // First, let the user edit the message
+    const editedMessage = await editResult(message, options);
+    // Then validate it against commitlint if config exists
+    const { hasCommitlintConfig } = await Promise.resolve().then(function () { return hasCommitlintConfig$1; });
+    const hasConfig = await hasCommitlintConfig();
+    if (hasConfig) {
+        const { validateCommitMessage } = await Promise.resolve().then(function () { return commitlintValidator; });
+        const { handleValidationErrors } = await Promise.resolve().then(function () { return commitValidationHandler; });
+        const validationResult = await validateCommitMessage(editedMessage);
+        if (!validationResult.valid) {
+            // Show validation errors and get user action
+            const validationHandlerResult = await handleValidationErrors(editedMessage, validationResult, {
+                logger: options.logger,
+                interactive: options.interactive,
+                openInEditor: options.openInEditor,
+            });
+            // Return the result from the validation handler
+            return validationHandlerResult.message;
+        }
+    }
+    return editedMessage;
+}
+
+var editCommitMessage$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  editCommitMessage: editCommitMessage
+});
+
+/**
+ * Custom error for commitlint validation failures
+ * This allows the retry system to identify these errors specifically
+ */
+class CommitlintValidationError extends Error {
+    constructor(message, validationResult, commitMessage) {
+        super(message);
+        this.name = 'CommitlintValidationError';
+        this.validationResult = validationResult;
+        this.commitMessage = commitMessage;
+    }
+}
 /**
  * Load commitlint configuration
  */
 async function loadCommitlintConfig() {
-    // Dynamically import commitlint core
-    const commitlint = await import('@commitlint/core');
-    const { load } = commitlint;
+    const projectRoot = findProjectRoot(process.cwd());
+    const cwd = projectRoot || process.cwd();
+    // @commitlint/load has issues with ESM configs (e.g. commitlint.config.js with `export default`).
+    // Let's try to load them manually first.
+    const esmConfigCandidates = COMMITLINT_CONFIG_FILES.filter((file) => file.endsWith('.js'));
+    for (const configFile of esmConfigCandidates) {
+        const configPath = path.join(cwd, configFile);
+        if (fs.existsSync(configPath)) {
+            try {
+                const module = await import(url.pathToFileURL(configPath).href);
+                if (module.default &&
+                    (Object.keys(module.default.rules || {}).length > 0 ||
+                        (module.default.extends && module.default.extends.length > 0))) {
+                    // We found a config, now let commitlint process it (for extends etc)
+                    return await core$1.load(module.default, { cwd });
+                }
+            }
+            catch (error) {
+                // Failed to import, maybe not an ESM file after all or syntax error.
+                // We will let the standard load take a chance.
+            }
+        }
+    }
     try {
-        // Try to load project config
-        const config = await load();
-        return config;
+        // Let @commitlint/load try to find the config. This works for CJS, JSON, and YAML.
+        const config = await core$1.load({}, { cwd });
+        // Check if a real config was loaded.
+        if (config.extends.length > 0 || Object.keys(config.rules).length > 0) {
+            return config;
+        }
     }
-    catch {
-        // If no config found or error loading, use conventional config
-        return load({
-            extends: ['@commitlint/config-conventional'],
-        });
+    catch (error) {
+        // Could be an error parsing, or just not found. Fall through to default.
+    }
+    // If nothing worked, fallback to conventional config
+    return core$1.load({
+        extends: ['@commitlint/config-conventional'],
+    });
+}
+/**
+ * Format commitlint rules into a human-readable string for AI prompts
+ */
+function formatCommitlintRulesForPrompt(config) {
+    if (!config.rules || Object.keys(config.rules).length === 0) {
+        return '';
+    }
+    const ruleDescriptions = [];
+    // Add information about extends if present
+    if (config.extends && config.extends.length > 0) {
+        ruleDescriptions.push(`Following ${config.extends.join(', ')} configuration`);
+    }
+    // Process key rules that affect commit message format
+    const rules = config.rules;
+    // Header length rules
+    if (rules['header-max-length']) {
+        const [level, , maxLength] = rules['header-max-length'];
+        if (level > 0) {
+            ruleDescriptions.push(`Header (title) must be ${maxLength} characters or less (including spaces)`);
+        }
+    }
+    if (rules['header-min-length']) {
+        const [level, , minLength] = rules['header-min-length'];
+        if (level > 0) {
+            ruleDescriptions.push(`Header (title) must be at least ${minLength} characters (including spaces)`);
+        }
+    }
+    // Body length rules
+    if (rules['body-max-line-length']) {
+        const [level, , maxLength] = rules['body-max-line-length'];
+        if (level > 0) {
+            ruleDescriptions.push(`Body lines must be ${maxLength} characters or less (including spaces)`);
+        }
+    }
+    // Type rules
+    if (rules['type-enum']) {
+        const [level, , allowedTypes] = rules['type-enum'];
+        if (level > 0 && Array.isArray(allowedTypes)) {
+            ruleDescriptions.push(`Allowed types: ${allowedTypes.join(', ')}`);
+        }
+    }
+    // Case rules
+    if (rules['type-case']) {
+        const [level, , caseType] = rules['type-case'];
+        if (level > 0) {
+            ruleDescriptions.push(`Type must be ${caseType} case`);
+        }
+    }
+    if (rules['subject-case']) {
+        const [level, , caseType] = rules['subject-case'];
+        if (level > 0) {
+            ruleDescriptions.push(`Subject must be ${caseType} case`);
+        }
+    }
+    // Scope rules
+    if (rules['scope-enum']) {
+        const [level, , allowedScopes] = rules['scope-enum'];
+        if (level > 0 && Array.isArray(allowedScopes)) {
+            ruleDescriptions.push(`Allowed scopes: ${allowedScopes.join(', ')}`);
+        }
+    }
+    // Subject rules
+    if (rules['subject-full-stop']) {
+        const [level, condition] = rules['subject-full-stop'];
+        if (level > 0) {
+            const verb = condition === 'always' ? 'must' : 'must not';
+            ruleDescriptions.push(`Subject ${verb} end with a period`);
+        }
+    }
+    if (rules['subject-empty']) {
+        const [level, condition] = rules['subject-empty'];
+        if (level > 0) {
+            const requirement = condition === 'never' ? 'must not be empty' : 'must be empty';
+            ruleDescriptions.push(`Subject ${requirement}`);
+        }
+    }
+    return ruleDescriptions.length > 0
+        ? `## Commitlint Rules\nYour commit message must follow these project-specific rules:\n${ruleDescriptions.map(rule => `- ${rule}`).join('\n')}\n`
+        : '';
+}
+/**
+ * Get commitlint rules context for prompt if config exists
+ */
+async function getCommitlintRulesContext() {
+    try {
+        const config = await loadCommitlintConfig();
+        return formatCommitlintRulesForPrompt(config);
+    }
+    catch (error) {
+        return '';
     }
 }
 /**
@@ -14537,10 +14876,7 @@ async function loadCommitlintConfig() {
 async function validateCommitMessage(message, options = {}) {
     try {
         const config = await loadCommitlintConfig();
-        // Dynamically import commitlint lint function
-        const commitlint = await import('@commitlint/core');
-        const { lint } = commitlint;
-        const result = await lint(message, config.rules, options);
+        const result = await core$1.lint(message, config.rules, options);
         return {
             valid: result.valid,
             errors: result.errors.map((error) => error.message),
@@ -14558,6 +14894,9 @@ async function validateCommitMessage(message, options = {}) {
 
 var commitlintValidator = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  CommitlintValidationError: CommitlintValidationError,
+  formatCommitlintRulesForPrompt: formatCommitlintRulesForPrompt,
+  getCommitlintRulesContext: getCommitlintRulesContext,
   loadCommitlintConfig: loadCommitlintConfig,
   validateCommitMessage: validateCommitMessage
 });
@@ -14594,29 +14933,45 @@ async function handleValidationErrors(message, validationResult, options) {
         message: 'How would you like to proceed?:',
         choices: [
             {
-                name: 'Edit',
-                value: 'edit',
-                description: 'Edit the commit message manually',
+                name: 'Try 2 more attempts',
+                value: 'retry',
+                description: 'Let the AI try generating 2 more commit messages with error feedback',
             },
             {
-                name: 'Retry',
-                value: 'retry',
-                description: 'Regenerate a new commit message',
+                name: 'Edit manually',
+                value: 'edit',
+                description: 'Edit the commit message manually to fix the issues',
             },
             {
                 name: 'Abort',
                 value: 'abort',
-                description: 'Abort the commit',
+                description: 'Abort the commit process',
             },
         ],
     });
     switch (choice) {
-        case '1': {
+        case 'edit': {
             // Edit message manually
             const editedMessage = await editResult(message, options);
+            // Validate the manually edited message if commitlint config exists
+            const { hasCommitlintConfig } = await Promise.resolve().then(function () { return hasCommitlintConfig$1; });
+            const hasConfig = await hasCommitlintConfig();
+            if (hasConfig) {
+                const { validateCommitMessage } = await Promise.resolve().then(function () { return commitlintValidator; });
+                const editedValidationResult = await validateCommitMessage(editedMessage);
+                if (!editedValidationResult.valid) {
+                    // Show validation errors for the edited message
+                    options.logger.log('\nEdited commit message also has validation issues:', { color: 'yellow' });
+                    editedValidationResult.errors.forEach((error) => {
+                        options.logger.log(`  • ${error}`, { color: 'red' });
+                    });
+                    // Recursively handle validation errors for the edited message
+                    return await handleValidationErrors(editedMessage, editedValidationResult, options);
+                }
+            }
             return { message: editedMessage, action: 'edit' };
         }
-        case '2':
+        case 'retry':
             // Regenerate message
             return { message, action: 'regenerate' };
         default: