git-coco 0.23.1 → 0.25.0

package/dist/index.js

@@ -26,7 +26,6 @@ var outputs = require('@langchain/core/outputs');
 var manager = require('@langchain/core/callbacks/manager');
 require('@langchain/core/utils/json_patch');
 var simpleGit = require('simple-git');
-var pQueue = require('p-queue');
 var documents = require('@langchain/core/documents');
 var diff = require('diff');
 require('@langchain/core/messages');
@@ -69,7 +68,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.23.1";
+const BUILD_VERSION = "0.25.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -184,6 +183,17 @@ async function updateFileSection({ filePath, startComment, endComment, getNewCon
     fs.writeFileSync(filePath, newLines.join('\n'));
 }
 
+/**
+ * Prompt template for summarizing code diffs.
+ *
+ * TODO: Future improvements to consider:
+ * - Separate prompts for file-level vs directory-level summarization
+ * - Include file type context (e.g., "This is a React component", "This is a test file")
+ * - Add guidance for preserving semantic meaning of changes
+ * - Consider change type (added/modified/deleted) in prompt for better context
+ * - Include hints about the programming language for more idiomatic summaries
+ * - Add support for custom user-provided summarization prompts via config
+ */
 const template$5 = `GOAL: Use functional abstractions to summarize the following text
 
 RULES: Avoid phrases like  "this change", "this code", or "this function" etc. Instead refer to the function, variable, or class by name.
@@ -1061,6 +1071,16 @@ const schema$1 = {
                     "description": "The maximum number of requests to make concurrently.",
                     "default": 6
                 },
+                "minTokensForSummary": {
+                    "type": "number",
+                    "description": "Minimum token count for a directory/file group to be eligible for summarization. Groups below this threshold preserve raw diffs to maintain detail.",
+                    "default": 400
+                },
+                "maxFileTokens": {
+                    "type": "number",
+                    "description": "Maximum tokens allowed for a single file diff before it gets pre-summarized. Prevents large files from biasing the overall summary. If not set, defaults to 25% of tokenLimit.",
+                    "default": "undefined (uses 0.25 * tokenLimit)"
+                },
                 "authentication": {
                     "anyOf": [
                         {
@@ -1821,6 +1841,16 @@ const schema$1 = {
                     "description": "The maximum number of requests to make concurrently.",
                     "default": 6
                 },
+                "minTokensForSummary": {
+                    "type": "number",
+                    "description": "Minimum token count for a directory/file group to be eligible for summarization. Groups below this threshold preserve raw diffs to maintain detail.",
+                    "default": 400
+                },
+                "maxFileTokens": {
+                    "type": "number",
+                    "description": "Maximum tokens allowed for a single file diff before it gets pre-summarized. Prevents large files from biasing the overall summary. If not set, defaults to 25% of tokenLimit.",
+                    "default": "undefined (uses 0.25 * tokenLimit)"
+                },
                 "authentication": {
                     "anyOf": [
                         {
@@ -1972,6 +2002,16 @@ const schema$1 = {
                     "description": "The maximum number of requests to make concurrently.",
                     "default": 6
                 },
+                "minTokensForSummary": {
+                    "type": "number",
+                    "description": "Minimum token count for a directory/file group to be eligible for summarization. Groups below this threshold preserve raw diffs to maintain detail.",
+                    "default": 400
+                },
+                "maxFileTokens": {
+                    "type": "number",
+                    "description": "Maximum tokens allowed for a single file diff before it gets pre-summarized. Prevents large files from biasing the overall summary. If not set, defaults to 25% of tokenLimit.",
+                    "default": "undefined (uses 0.25 * tokenLimit)"
+                },
                 "authentication": {
                     "anyOf": [
                         {
@@ -6080,9 +6120,13 @@ const options$4 = {
         alias: 'b',
         description: 'Target branch to compare against',
     },
+    tag: {
+        type: 'string',
+        alias: 't',
+        description: 'Target tag to compare against',
+    },
     sinceLastTag: {
         type: 'boolean',
-        alias: 't',
         description: 'Generate changelog for all commits since the last tag',
         default: false,
     },
@@ -7096,6 +7140,37 @@ async function getCommitLogAgainstBranch({ git, logger, targetBranch, }) {
     return [];
 }
 
+/**
+ * Retrieves the commit log between the current branch and a specified tag.
+ *
+ * @param {Object} options - The options for retrieving the commit log.
+ * @param {SimpleGit} options.git - The SimpleGit instance.
+ * @param {Logger} options.logger - The logger for logging messages.
+ * @param {string} options.targetTag - The tag to compare against.
+ * @returns {Promise<CommitDetails[]>} The array of commit messages in the commit log.
+ */
+async function getCommitLogAgainstTag({ git, logger, targetTag, }) {
+    try {
+        const currentBranch = await getCurrentBranchName({ git });
+        const uniqueCommits = (await git.raw(['rev-list', `${targetTag}..${currentBranch}`]))
+            .split('\n')
+            .filter(Boolean)
+            .reverse();
+        logger?.verbose(`Found ${uniqueCommits.length} unique commits between "${currentBranch}" and tag "${targetTag}"`, { color: 'blue' });
+        const firstCommit = uniqueCommits[0];
+        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
+        if (!firstCommit || !lastCommit) {
+            logger?.log('Unable to determine first and last commit between branch and tag', { color: 'yellow' });
+            return [];
+        }
+        return await getCommitLogRangeDetails(firstCommit, lastCommit, { git, noMerges: true });
+    }
+    catch (error) {
+        logger?.log('Encountered an error getting commit log between branch and tag', { color: 'red' });
+    }
+    return [];
+}
+
 /**
  * Retrieves the commit log for the current branch.
  *
@@ -7714,6 +7789,15 @@ const handler$4 = async (argv, logger) => {
     const git = getRepo();
     const key = getApiKeyForModel(config);
     const { provider, model } = getModelAndProviderFromConfig(config);
+    const exclusiveOptions = [
+        argv.branch ? '--branch' : null,
+        argv.tag ? '--tag' : null,
+        config.sinceLastTag ? '--since-last-tag' : null,
+    ].filter(Boolean);
+    if (exclusiveOptions.length > 1) {
+        logger.log(`Options ${exclusiveOptions.join(', ')} cannot be used together.`, { color: 'red' });
+        process.exit(1);
+    }
     if (config.service.authentication.type !== 'None' && !key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
@@ -7755,6 +7839,10 @@ const handler$4 = async (argv, logger) => {
             logger.verbose(`Generating commit log against branch: ${argv.branch}`, { color: 'yellow' });
             commits = await getCommitLogAgainstBranch({ git, logger, targetBranch: argv.branch });
         }
+        else if (argv.tag) {
+            logger.verbose(`Generating commit log against tag: ${argv.tag}`, { color: 'yellow' });
+            commits = await getCommitLogAgainstTag({ git, logger, targetTag: argv.tag });
+        }
         else {
             logger.verbose(`No range, branch, or tag option provided. Defaulting to current branch`, {
                 color: 'yellow',
@@ -8028,6 +8116,45 @@ function repairJson(jsonString) {
     }
 }
 
+/**
+ * Extract the first complete JSON object from a string by tracking balanced braces
+ */
+function extractFirstJsonObject(text) {
+    const startIndex = text.indexOf('{');
+    if (startIndex === -1)
+        return null;
+    let braceCount = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (let i = startIndex; i < text.length; i++) {
+        const char = text[i];
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (char === '\\') {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === '{') {
+            braceCount++;
+        }
+        else if (char === '}') {
+            braceCount--;
+            if (braceCount === 0) {
+                // Found the end of the first complete JSON object
+                return text.substring(startIndex, i + 1);
+            }
+        }
+    }
+    return null;
+}
 /**
  * Utility function to ensure commit messages are properly formatted as strings
  * rather than JSON objects, whether they come as parsed objects or stringified JSON
@@ -8046,23 +8173,26 @@ function formatCommitMessage(result, options = {}) {
         if (!result.includes('{') && !result.includes('"title"')) {
             return result;
         }
-        // Handle multiple markdown code block formats
-        const codeBlockPatterns = [
+        // Handle multiple markdown code block formats and embedded JSON
+        const extractionPatterns = [
             /```(?:json)?\s*(\{[\s\S]*?\})\s*```/, // Standard markdown blocks
             /`(\{[\s\S]*?\})`/, // Inline code blocks
-            /^\s*(\{[\s\S]*\})\s*$/ // Raw JSON without blocks
+            /^\s*(\{[\s\S]*\})\s*$/, // Raw JSON without blocks (entire string)
+            /(\{[\s\S]*?\})/ // JSON anywhere in text (fallback)
         ];
         let jsonString = result;
+        let foundMatch = false;
         // Try each pattern to extract JSON
-        for (const pattern of codeBlockPatterns) {
+        for (const pattern of extractionPatterns) {
             const match = result.match(pattern);
             if (match && match[1]) {
                 jsonString = match[1].trim();
+                foundMatch = true;
                 break;
             }
         }
         // Only attempt JSON parsing if we found potential JSON content
-        if (jsonString !== result || jsonString.startsWith('{')) {
+        if (foundMatch || jsonString.startsWith('{')) {
             try {
                 // Try to parse as JSON to see if it's a stringified object
                 const parsed = JSON.parse(jsonString);
@@ -8092,7 +8222,24 @@ function formatCommitMessage(result, options = {}) {
                     }
                 }
                 catch {
-                    // Repair failed, continue to fallback
+                    // Repair failed, try extracting just the first complete JSON object
+                    const firstObject = extractFirstJsonObject(jsonString);
+                    if (firstObject) {
+                        try {
+                            const parsed = JSON.parse(firstObject);
+                            if (parsed &&
+                                typeof parsed === 'object' &&
+                                typeof parsed.title === 'string' &&
+                                typeof parsed.body === 'string' &&
+                                parsed.title.length > 0 &&
+                                parsed.body.length > 0) {
+                                return constructMessage(parsed.title, parsed.body);
+                            }
+                        }
+                        catch {
+                            // Even first object extraction failed, continue to fallback
+                        }
+                    }
                 }
             }
         }
@@ -8132,6 +8279,114 @@ async function summarize(documents$1, { chain, textSplitter, options }) {
     return res.text && res.text.trim();
 }
 
+/**
+ * Summarize a single file diff that exceeds the token threshold.
+ */
+async function summarizeFileDiff(fileDiff, { chain, textSplitter, tokenizer }) {
+    try {
+        const fileSummary = await summarize([
+            {
+                pageContent: fileDiff.diff,
+                metadata: {
+                    file: fileDiff.file,
+                    summary: fileDiff.summary,
+                },
+            },
+        ], {
+            chain,
+            textSplitter,
+            options: {
+                returnIntermediateSteps: false,
+            },
+        });
+        const newTokenCount = tokenizer(fileSummary);
+        return {
+            ...fileDiff,
+            diff: fileSummary,
+            tokenCount: newTokenCount,
+        };
+    }
+    catch (error) {
+        // On error, return original diff unchanged
+        console.error(`Failed to summarize file ${fileDiff.file}:`, error);
+        return fileDiff;
+    }
+}
+/**
+ * Process files in waves to respect concurrency limits.
+ */
+async function processInWaves(items, processor, maxConcurrent) {
+    const results = [];
+    for (let i = 0; i < items.length; i += maxConcurrent) {
+        const wave = items.slice(i, i + maxConcurrent);
+        const waveResults = await Promise.all(wave.map(processor));
+        results.push(...waveResults);
+    }
+    return results;
+}
+/**
+ * Pre-summarize individual files that exceed the maxFileTokens threshold.
+ * This prevents large files from dominating the token budget and biasing
+ * the final commit message toward a single file's changes.
+ *
+ * @param diffs - Array of file diffs to process
+ * @param options - Configuration options for summarization
+ * @returns Array of file diffs with large files summarized
+ */
+async function summarizeLargeFiles(diffs, options) {
+    const { maxFileTokens, minTokensForSummary, maxConcurrent, tokenizer, logger, chain, textSplitter } = options;
+    // Identify files that need summarization
+    const filesToSummarize = [];
+    const results = [...diffs];
+    diffs.forEach((diff, index) => {
+        if (diff.tokenCount > maxFileTokens && diff.tokenCount >= minTokensForSummary) {
+            filesToSummarize.push({ index, diff });
+        }
+    });
+    if (filesToSummarize.length === 0) {
+        return results;
+    }
+    logger.verbose(`Pre-summarizing ${filesToSummarize.length} large file(s)...`, { color: 'blue' });
+    // Process large files in waves
+    const summarizedFiles = await processInWaves(filesToSummarize, async ({ diff }) => summarizeFileDiff(diff, { chain, textSplitter, tokenizer }), maxConcurrent);
+    // Update results with summarized files
+    summarizedFiles.forEach((summarizedDiff, i) => {
+        const originalIndex = filesToSummarize[i].index;
+        const originalTokens = results[originalIndex].tokenCount;
+        const newTokens = summarizedDiff.tokenCount;
+        logger.verbose(` - ${summarizedDiff.file}: ${originalTokens} -> ${newTokens} tokens`, { color: 'magenta' });
+        results[originalIndex] = summarizedDiff;
+    });
+    return results;
+}
+/**
+ * Pre-process a DiffNode tree, summarizing large files at the leaf level.
+ * Returns a new DiffNode with updated token counts.
+ */
+async function preprocessLargeFiles(rootNode, options) {
+    // Collect all diffs from the tree
+    const allDiffs = [];
+    function collectDiffs(node) {
+        allDiffs.push(...node.diffs);
+        node.children.forEach(collectDiffs);
+    }
+    collectDiffs(rootNode);
+    // Summarize large files
+    const processedDiffs = await summarizeLargeFiles(allDiffs, options);
+    // Create a map for quick lookup
+    const diffMap = new Map();
+    processedDiffs.forEach((diff) => diffMap.set(diff.file, diff));
+    // Rebuild tree with processed diffs
+    function rebuildNode(node) {
+        return {
+            path: node.path,
+            diffs: node.diffs.map((diff) => diffMap.get(diff.file) || diff),
+            children: node.children.map(rebuildNode),
+        };
+    }
+    return rebuildNode(rootNode);
+}
+
 /**
  * Create groups from a given node info.
  * @param {DiffNode} node - The node info to start grouping.
@@ -8184,6 +8439,16 @@ async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenize
         return directory;
     }
 }
+/**
+ * Default output formatter for directory diffs.
+ *
+ * TODO: Future improvements to consider:
+ * - Hierarchical output showing file -> directory -> overall summary
+ * - Configurable verbosity levels (compact, standard, detailed)
+ * - Machine-readable format option (JSON) for programmatic use
+ * - Semantic grouping by change type (added/modified/deleted) or feature area
+ * - Visual diff indicators showing magnitude of changes
+ */
 const defaultOutputCallback = (group) => {
     let output = `
 -------\n* changes in "/${group.path}"\n\n`;
@@ -8195,41 +8460,124 @@ const defaultOutputCallback = (group) => {
     }
     return output;
 };
-async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
-    const queue = new pQueue({ concurrency: 8 });
+/**
+ * Process directory summarization in waves to respect concurrency limits
+ * while maintaining predictable behavior.
+ */
+async function summarizeInWaves(directories, options) {
+    const { totalTokenCount: initialTotal, maxTokens, minTokensForSummary, maxConcurrent, logger, chain, textSplitter, tokenizer, } = options;
+    let totalTokenCount = initialTotal;
+    const results = [...directories];
+    // Create sorted indices by token count (descending) for prioritized processing
+    const sortedIndices = directories
+        .map((d, i) => ({ index: i, tokens: d.tokenCount }))
+        .sort((a, b) => b.tokens - a.tokens);
+    let cursor = 0;
+    while (totalTokenCount > maxTokens && cursor < sortedIndices.length) {
+        // Select wave candidates: directories that exceed minTokensForSummary
+        const wave = [];
+        for (let i = cursor; i < sortedIndices.length && wave.length < maxConcurrent; i++) {
+            const { index, tokens } = sortedIndices[i];
+            // Skip directories below the minimum threshold
+            if (tokens < minTokensForSummary) {
+                cursor = i + 1;
+                continue;
+            }
+            // Skip directories that have already been summarized
+            if (results[index].summary) {
+                cursor = i + 1;
+                continue;
+            }
+            wave.push(index);
+            cursor = i + 1;
+        }
+        // No more eligible candidates
+        if (wave.length === 0) {
+            break;
+        }
+        logger.verbose(`\nProcessing wave of ${wave.length} directories...`, { color: 'blue' });
+        // Process wave in parallel
+        const waveResults = await Promise.all(wave.map((idx) => summarizeDirectoryDiff(results[idx], { chain, textSplitter, tokenizer })));
+        // Update results and recalculate total
+        waveResults.forEach((result, i) => {
+            const idx = wave[i];
+            const originalTokens = results[idx].tokenCount;
+            const newTokens = result.tokenCount;
+            const reduction = originalTokens - newTokens;
+            totalTokenCount -= reduction;
+            results[idx] = result;
+            logger.verbose(` • Summarized "/${result.path}": ${originalTokens} -> ${newTokens} tokens`, {
+                color: 'magenta',
+            });
+        });
+        logger.verbose(`Total token count: ${totalTokenCount}`, {
+            color: totalTokenCount > maxTokens ? 'yellow' : 'green',
+        });
+        // Check if we're now under budget
+        if (totalTokenCount <= maxTokens) {
+            logger.verbose(`Under token budget, stopping summarization.`, { color: 'green' });
+            break;
+        }
+    }
+    return { directories: results, totalTokenCount };
+}
+/**
+ * Summarize diffs using a three-phase approach:
+ *
+ * Phase 1: Pre-process large files to prevent any single file from dominating
+ * Phase 2: Group diffs by directory and assess total token count
+ * Phase 3: Wave-based parallel summarization until under budget
+ *
+ * This approach ensures:
+ * - Large files don't bias the summary
+ * - Small changes preserve their detail (minTokensForSummary threshold)
+ * - Efficient parallel processing with predictable behavior
+ * - Early exit when under token budget
+ */
+async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, minTokensForSummary = 400, maxFileTokens, maxConcurrent = 6, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
+    // Calculate maxFileTokens as 25% of maxTokens if not specified
+    const effectiveMaxFileTokens = maxFileTokens ?? Math.floor(maxTokens * 0.25);
+    // PHASE 1: Pre-process large files
+    logger.startTimer().startSpinner(`Pre-processing large files...`, { color: 'blue' });
+    const preprocessedNode = await preprocessLargeFiles(rootDiffNode, {
+        maxFileTokens: effectiveMaxFileTokens,
+        minTokensForSummary,
+        maxConcurrent,
+        tokenizer,
+        logger,
+        chain,
+        textSplitter,
+    });
+    logger.stopSpinner('Files pre-processed').stopTimer();
+    // PHASE 2: Directory grouping & assessment
     logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
-    const directoryDiffs = createDirectoryDiffs(rootDiffNode);
-    // Sort by token count descending
+    const directoryDiffs = createDirectoryDiffs(preprocessedNode);
+    // Sort by token count descending for consistent output ordering
     directoryDiffs.sort((a, b) => b.tokenCount - a.tokenCount);
-    let totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
+    const totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
     logger.stopSpinner('Diffs Organized').stopTimer();
-    logger.startSpinner(`Consolidating Diffs`, { color: 'blue' });
-    const processingTasks = directoryDiffs.map((group, i) => {
-        return queue.add(async () => {
-            // If the diff token count is already less than the average req, we can skip summarizing.
-            const isLessThanAvgTokenReq = group.tokenCount <= maxTokens / directoryDiffs.length;
-            if (totalTokenCount <= maxTokens || isLessThanAvgTokenReq) {
-                return group;
-            }
-            group = await summarizeDirectoryDiff(group, {
-                chain,
-                textSplitter,
-                tokenizer,
-            });
-            // We need to subtract the old token count and add the new one
-            totalTokenCount = totalTokenCount - directoryDiffs[i].tokenCount + group.tokenCount;
-            directoryDiffs[i] = group;
-            logger
-                .verbose(`\n • Summarized diffs in "/${group.path}" `, { color: 'blue' })
-                .verbose(`\nTotal token count: ${totalTokenCount}`, {
-                color: totalTokenCount > maxTokens ? 'yellow' : 'green',
-            });
-            return group;
-        }, { priority: group.tokenCount });
+    logger.verbose(`Total token count: ${totalTokenCount}, max allowed: ${maxTokens}`, {
+        color: totalTokenCount > maxTokens ? 'yellow' : 'green',
     });
-    await Promise.all(processingTasks);
-    logger.stopSpinner(`Summarized Diffs`);
-    return directoryDiffs.map(handleOutput).join('');
+    // Early exit if already under budget
+    if (totalTokenCount <= maxTokens) {
+        logger.verbose(`Already under token budget, skipping summarization.`, { color: 'green' });
+        return directoryDiffs.map(handleOutput).join('');
+    }
+    // PHASE 3: Wave-based summarization
+    logger.startTimer().startSpinner(`Consolidating Diffs...`, { color: 'blue' });
+    const { directories: summarizedDiffs } = await summarizeInWaves(directoryDiffs, {
+        totalTokenCount,
+        maxTokens,
+        minTokensForSummary,
+        maxConcurrent,
+        logger,
+        chain,
+        textSplitter,
+        tokenizer,
+    });
+    logger.stopSpinner(`Diffs Consolidated`).stopTimer();
+    return summarizedDiffs.map(handleOutput).join('');
 }
 
 /**
@@ -11229,7 +11577,7 @@ for (var i = 0; i < 256; i++) {
   simpleEscapeMap[i] = simpleEscapeSequence(i);
 }
 
-async function fileChangeParser({ changes, commit, options: { tokenizer, git, llm: model, logger, maxTokens }, }) {
+async function fileChangeParser({ changes, commit, options: { tokenizer, git, llm: model, logger, maxTokens, minTokensForSummary, maxFileTokens, maxConcurrent, }, }) {
     const textSplitter = new RecursiveCharacterTextSplitter({ chunkSize: 10000, chunkOverlap: 250 });
     const summarizationChain = loadSummarizationChain(model, {
         type: 'map_reduce',
@@ -11243,11 +11591,17 @@ async function fileChangeParser({ changes, commit, options: { tokenizer, git, ll
     logger.startTimer().startSpinner(`Collecting Diffs...\n`, { color: 'blue' });
     const diffs = await collectDiffs(rootTreeNode, (path) => getDiff(path, commit, { git, logger }), tokenizer, logger);
     logger.stopSpinner('Diffs Collected').stopTimer();
-    // Summarize diffs
+    // Summarize diffs using three-phase approach:
+    // 1. Pre-process large files to prevent bias
+    // 2. Group by directory and assess token count
+    // 3. Wave-based parallel summarization until under budget
     logger.startTimer();
     const summary = await summarizeDiffs(diffs, {
         tokenizer,
-        maxTokens: maxTokens || 4096,
+        maxTokens: maxTokens || 2048,
+        minTokensForSummary,
+        maxFileTokens,
+        maxConcurrent,
         textSplitter,
         chain: summarizationChain,
         logger,
@@ -11550,7 +11904,16 @@ const handler$3 = async (argv, logger) => {
         return await fileChangeParser({
             changes,
             commit: '--staged',
-            options: { tokenizer, git, llm, logger, maxTokens: config.service.tokenLimit },
+            options: {
+                tokenizer,
+                git,
+                llm,
+                logger,
+                maxTokens: config.service.tokenLimit,
+                minTokensForSummary: config.service.minTokensForSummary,
+                maxFileTokens: config.service.maxFileTokens,
+                maxConcurrent: config.service.maxConcurrent,
+            },
         });
     }
     const commitMsg = await generateAndReviewLoop({
@@ -11593,18 +11956,16 @@ const handler$3 = async (argv, logger) => {
 REQUIRED JSON FORMAT:
 ${schema.description}
 
-EXAMPLE (follow this exact structure):
-{
-  "title": "feat(auth): add user authentication system",
-  "body": "Implement JWT-based authentication with login and logout functionality. Includes password hashing and session management."
-}
+EXAMPLE (follow this EXACT format - compact JSON on a single line or minimal whitespace):
+{"title": "feat(auth): add user authentication system", "body": "Implement JWT-based authentication with login and logout functionality. Includes password hashing and session management."}
 
 IMPORTANT RULES:
+- Return ONLY the JSON object - NO markdown code blocks, NO backticks, NO extra text
 - ALL string values MUST be enclosed in double quotes
+- Use compact JSON format (minimal whitespace) for best compatibility
 - NO trailing commas
 - NO comments or additional text outside the JSON
-- The "title" and "body" values must be properly quoted strings
-- Return ONLY the JSON object, nothing else`;
+- The "title" and "body" values must be properly quoted strings`;
             // Use conventional commit prompt if enabled
             const promptTemplate = USE_CONVENTIONAL_COMMITS ? CONVENTIONAL_COMMIT_PROMPT : COMMIT_PROMPT;
             const prompt = getPrompt({
@@ -11698,10 +12059,33 @@ IMPORTANT RULES:
                             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',
-                    }),
+                    fallbackParser: (text) => {
+                        // First try to parse as JSON in case it's valid JSON with unusual formatting
+                        try {
+                            // Remove markdown code blocks if present
+                            let cleanText = text.trim();
+                            const codeBlockMatch = cleanText.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+                            if (codeBlockMatch && codeBlockMatch[1]) {
+                                cleanText = codeBlockMatch[1].trim();
+                            }
+                            const parsed = JSON.parse(cleanText);
+                            if (parsed &&
+                                typeof parsed === 'object' &&
+                                typeof parsed.title === 'string' &&
+                                typeof parsed.body === 'string' &&
+                                parsed.title.length > 0) {
+                                return parsed;
+                            }
+                        }
+                        catch {
+                            // JSON parsing failed, fall through to text splitting
+                        }
+                        // Fallback to simple text splitting
+                        return {
+                            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',