git-coco 0.31.1 → 0.32.0

package/dist/index.js

@@ -18,6 +18,7 @@ var anthropic = require('@langchain/anthropic');
 var ollama = require('@langchain/ollama');
 var openai = require('@langchain/openai');
 var output_parsers = require('@langchain/core/output_parsers');
+var minimatch = require('minimatch');
 var simpleGit = require('simple-git');
 var documents = require('@langchain/core/documents');
 var diff = require('diff');
@@ -34,7 +35,6 @@ require('@langchain/core/utils/json_schema');
 require('@langchain/core/utils/json_patch');
 require('@langchain/core/utils/env');
 require('@langchain/core/utils/async_caller');
-var minimatch = require('minimatch');
 var tiktoken = require('tiktoken');
 var child_process = require('child_process');
 var readline = require('readline');
@@ -68,7 +68,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.31.1";
+const BUILD_VERSION = "0.32.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -468,7 +468,7 @@ function getDefaultServiceConfigFromAlias(provider, model) {
     }
 }
 
-const DEFAULT_IGNORED_FILES = [
+const DEFAULT_IGNORED_FILES$1 = [
     'package-lock.json',
     'yarn.lock',
     'pnpm-lock.yaml',
@@ -476,7 +476,7 @@ const DEFAULT_IGNORED_FILES = [
     'bun.lock',
     'node_modules',
 ];
-const DEFAULT_IGNORED_EXTENSIONS = ['.map', '.lock'];
+const DEFAULT_IGNORED_EXTENSIONS$1 = ['.map', '.lock'];
 const COCO_CONFIG_START_COMMENT = '# -- start coco config --';
 const COCO_CONFIG_END_COMMENT = '# -- end coco config --';
 /**
@@ -490,8 +490,8 @@ const DEFAULT_CONFIG = {
     defaultBranch: 'main',
     service: getDefaultServiceConfigFromAlias('openai'),
     summarizePrompt: SUMMARIZE_PROMPT.template,
-    ignoredFiles: DEFAULT_IGNORED_FILES,
-    ignoredExtensions: DEFAULT_IGNORED_EXTENSIONS,
+    ignoredFiles: DEFAULT_IGNORED_FILES$1,
+    ignoredExtensions: DEFAULT_IGNORED_EXTENSIONS$1,
 };
 /**
  * Create a named export of all config keys for use in other modules.
@@ -7291,6 +7291,75 @@ function createSchemaParser(schema, llm, options = {}
     }
 }
 
+async function renderPrompt(prompt, variables) {
+    if (typeof prompt.format === 'function') {
+        return await prompt.format(variables);
+    }
+    if (typeof prompt.template === 'string') {
+        return Object.entries(variables).reduce((result, [key, value]) => {
+            return result
+                .replaceAll(`{{${key}}}`, value)
+                .replaceAll(`{${key}}`, value);
+        }, prompt.template);
+    }
+    throw new Error('Prompt must provide either a format function or template string');
+}
+/**
+ * Ensure the fully rendered LLM prompt fits the configured request budget.
+ *
+ * Diff condensation budgets only cover the diff summary itself. This guard accounts
+ * for the rest of the rendered prompt, then trims the summary as a deterministic
+ * fallback when additional context pushes the request over budget.
+ */
+async function enforcePromptBudget({ prompt, variables, tokenizer, maxTokens, summaryKey = 'summary', responseTokenReserve = 512, }) {
+    const renderedPrompt = await renderPrompt(prompt, variables);
+    const promptTokenCount = tokenizer(renderedPrompt);
+    if (promptTokenCount <= maxTokens) {
+        return { variables, promptTokenCount, truncated: false };
+    }
+    const summary = variables[summaryKey] || '';
+    const variablesWithoutSummary = { ...variables, [summaryKey]: '' };
+    const overheadTokenCount = tokenizer(await renderPrompt(prompt, variablesWithoutSummary));
+    const summaryBudget = Math.max(0, maxTokens - overheadTokenCount - responseTokenReserve);
+    if (summaryBudget === 0) {
+        const emptySummaryVariables = { ...variables, [summaryKey]: '' };
+        const emptySummaryTokenCount = tokenizer(await renderPrompt(prompt, emptySummaryVariables));
+        if (emptySummaryTokenCount > maxTokens) {
+            throw new Error(`Rendered prompt exceeds token budget before adding ${summaryKey}: ` +
+                `${emptySummaryTokenCount} > ${maxTokens}`);
+        }
+        return {
+            variables: emptySummaryVariables,
+            promptTokenCount: emptySummaryTokenCount,
+            truncated: true,
+        };
+    }
+    let low = 0;
+    let high = summary.length;
+    let bestSummary = '';
+    let bestTokenCount = overheadTokenCount;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const candidateSummary = summary.slice(0, mid);
+        const candidateVariables = { ...variables, [summaryKey]: candidateSummary };
+        const candidateTokenCount = tokenizer(await renderPrompt(prompt, candidateVariables));
+        if (candidateTokenCount <= maxTokens - responseTokenReserve) {
+            bestSummary = candidateSummary;
+            bestTokenCount = candidateTokenCount;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    const trimmedVariables = { ...variables, [summaryKey]: bestSummary.trimEnd() };
+    return {
+        variables: trimmedVariables,
+        promptTokenCount: bestTokenCount,
+        truncated: true,
+    };
+}
+
 /**
  * Extracts provider and endpoint info from LLM instance if available
  */
@@ -7580,6 +7649,148 @@ async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main
     return [];
 }
 
+/**
+ * Determines the status of a file based on its changes in the Git repository.
+ *
+ * @param file - The file to check the status of.
+ * @param location - The location to check the status in ('index' or 'working_dir'). Defaults to 'index'.
+ * @returns The status of the file ('added', 'deleted', 'modified', 'renamed', 'untracked', or 'unknown').
+ * @throws Error if the file type is invalid.
+ */
+function getStatus(file, location = 'index') {
+    if ('index' in file && 'working_dir' in file) {
+        const statusCode = file[location];
+        switch (statusCode) {
+            case 'A':
+                return 'added';
+            case 'D':
+                return 'deleted';
+            case 'M':
+                return 'modified';
+            case 'R':
+                return 'renamed';
+            case '?':
+                return 'untracked';
+            default:
+                return 'unknown';
+        }
+    }
+    else if ('binary' in file && file.binary === true) {
+        // DiffResultBinaryFile: has before/after, no changes/insertions/deletions
+        if (file.file.includes('=>'))
+            return 'renamed';
+        if (file.before === 0 && file.after > 0)
+            return 'added';
+        if (file.after === 0 && file.before > 0)
+            return 'deleted';
+        if (file.before > 0 && file.after > 0)
+            return 'modified';
+        return 'untracked';
+    }
+    else if ('changes' in file && 'binary' in file) {
+        // DiffResultTextFile: has changes/insertions/deletions
+        if (file.changes === 0)
+            return 'untracked';
+        if (file.file.includes('=>'))
+            return 'renamed';
+        if (file.deletions === 0 && file.insertions > 0)
+            return 'added';
+        if (file.insertions === 0 && file.deletions > 0)
+            return 'deleted';
+        if ((file.insertions > 0 && file.deletions > 0) || file.changes > 0)
+            return 'modified';
+        return 'unknown';
+    }
+    else {
+        throw new Error('Invalid file type');
+    }
+}
+
+/**
+ * Returns the summary text for a file change.
+ *
+ * @param file - The file status or diff result.
+ * @param change - The partial file change object.
+ * @returns The summary text for the file change.
+ * @throws Error if the file type is invalid.
+ */
+function getSummaryText(file, change) {
+    const status = change.status || getStatus(file);
+    let filePath;
+    if ('path' in file) {
+        filePath = file.path;
+    }
+    else if ('file' in file) {
+        filePath = change?.filePath || file.file;
+    }
+    else {
+        throw new Error('Invalid file type');
+    }
+    if (change.oldFilePath) {
+        return `${status}: ${change.oldFilePath} -> ${filePath}`;
+    }
+    return `${status}: ${filePath}`;
+}
+
+/**
+ * Parses a file string and returns the parsed file paths.
+ * If the file string contains a separator, it splits the string into root path, file path, and old file path.
+ * If the file string doesn't contain the separator, it assumes the file string itself is the file path and old file path is undefined.
+ * @param file The file string to parse.
+ * @returns The parsed file paths.
+ */
+function parseFileString(file) {
+    const separator = ' => ';
+    if (file.includes(separator)) {
+        const [oldFilePathWithRoot, filePath] = file.split(separator);
+        const [rootPath, oldFilePath] = oldFilePathWithRoot.split('{');
+        return {
+            filePath: rootPath + filePath.trim().replace('{', '').replace('}', ''),
+            oldFilePath: rootPath + oldFilePath.trim().replace('{', '').replace('}', ''),
+        };
+    }
+    else {
+        return {
+            filePath: file.trim(),
+            oldFilePath: undefined,
+        };
+    }
+}
+
+const config = loadConfig();
+const DEFAULT_IGNORED_FILES = config?.ignoredFiles?.length ? config.ignoredFiles : [];
+const DEFAULT_IGNORED_EXTENSIONS = config?.ignoredExtensions?.length ? config.ignoredExtensions : [];
+/**
+ * Retrieves the changes made in a commit.
+ *
+ * @deprecated use `getChanges` instead
+ *
+ * @param commit - The commit hash.
+ * @param options - Optional parameters for customization.
+ * @returns A promise that resolves to an array of FileChange objects representing the changes made in the commit.
+ */
+async function getChangesByCommit({ commit, options: { git, ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS, }, }) {
+    const changes = [];
+    const diffSummary = await git.diffSummary([`${commit}^..${commit}`]);
+    diffSummary.files.forEach((file) => {
+        const { filePath, oldFilePath } = parseFileString(file.file);
+        const fileChange = {
+            filePath,
+            oldFilePath,
+            status: getStatus(file),
+        };
+        fileChange.summary = getSummaryText(file, fileChange);
+        changes.push(fileChange);
+    });
+    const ignoredExtensionsSet = new Set(ignoredExtensions.map((extension) => extension.toLowerCase()));
+    const filteredChanges = changes.filter((file) => {
+        const extension = path.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
+    });
+    return filteredChanges;
+}
+
 /**
  * Retrieves the SimpleGit instance for the repository.
  * @returns {SimpleGit} The SimpleGit instance.
@@ -7940,104 +8151,6 @@ async function handleResult({ result, mode, interactiveModeCallback }) {
     }
 }
 
-/**
- * Fetches the diff for the given commit ID.
- *
- * @param commitId The commit ID for which the diff is to be retrieved.
- * @returns A promise that resolves to the diff of the commit.
- */
-async function getDiffForCommit(commitId, { git, }) {
-    try {
-        return await git.diff(['-p', `${commitId}^..${commitId}`]);
-    }
-    catch (error) {
-        throw new Error(`Error fetching diff for commit ${commitId}: ${error.message}`);
-    }
-}
-
-/**
- * Determines the status of a file based on its changes in the Git repository.
- *
- * @param file - The file to check the status of.
- * @param location - The location to check the status in ('index' or 'working_dir'). Defaults to 'index'.
- * @returns The status of the file ('added', 'deleted', 'modified', 'renamed', 'untracked', or 'unknown').
- * @throws Error if the file type is invalid.
- */
-function getStatus(file, location = 'index') {
-    if ('index' in file && 'working_dir' in file) {
-        const statusCode = file[location];
-        switch (statusCode) {
-            case 'A':
-                return 'added';
-            case 'D':
-                return 'deleted';
-            case 'M':
-                return 'modified';
-            case 'R':
-                return 'renamed';
-            case '?':
-                return 'untracked';
-            default:
-                return 'unknown';
-        }
-    }
-    else if ('binary' in file && file.binary === true) {
-        // DiffResultBinaryFile: has before/after, no changes/insertions/deletions
-        if (file.file.includes('=>'))
-            return 'renamed';
-        if (file.before === 0 && file.after > 0)
-            return 'added';
-        if (file.after === 0 && file.before > 0)
-            return 'deleted';
-        if (file.before > 0 && file.after > 0)
-            return 'modified';
-        return 'untracked';
-    }
-    else if ('changes' in file && 'binary' in file) {
-        // DiffResultTextFile: has changes/insertions/deletions
-        if (file.changes === 0)
-            return 'untracked';
-        if (file.file.includes('=>'))
-            return 'renamed';
-        if (file.deletions === 0 && file.insertions > 0)
-            return 'added';
-        if (file.insertions === 0 && file.deletions > 0)
-            return 'deleted';
-        if ((file.insertions > 0 && file.deletions > 0) || file.changes > 0)
-            return 'modified';
-        return 'unknown';
-    }
-    else {
-        throw new Error('Invalid file type');
-    }
-}
-
-/**
- * Returns the summary text for a file change.
- *
- * @param file - The file status or diff result.
- * @param change - The partial file change object.
- * @returns The summary text for the file change.
- * @throws Error if the file type is invalid.
- */
-function getSummaryText(file, change) {
-    const status = change.status || getStatus(file);
-    let filePath;
-    if ('path' in file) {
-        filePath = file.path;
-    }
-    else if ('file' in file) {
-        filePath = change?.filePath || file.file;
-    }
-    else {
-        throw new Error('Invalid file type');
-    }
-    if (change.oldFilePath) {
-        return `${status}: ${change.oldFilePath} -> ${filePath}`;
-    }
-    return `${status}: ${filePath}`;
-}
-
 /**
  * Retrieves the diff between the current branch and a specified target branch.
  *
@@ -8118,1050 +8231,571 @@ async function getDiffForBranch({ git, logger, baseBranch, headBranch, options,
     }
 }
 
-const template$3 = `You are a highly skilled software engineer tasked with writing a git changelog. Your response should be informative, well-structured, and in the imperative.
+/**
+ * Extract the path from a file path string.
+ * @param {string} filePath - The full file path.
+ * @returns {string} The path portion of the file path.
+ */
+function getPathFromFilePath(filePath) {
+    return filePath.split('/').slice(0, -1).join('/');
+}
 
-## Input
-You will be provided with a summary of changes. This summary can be one of the following:
-1. A list of commits, each with its author, hash, message, and body.
-2. A list of commits, each with its details AND the full diff of the changes.
-3. A single, comprehensive diff for an entire branch.
+async function summarize(documents$1, { chain, textSplitter, options }) {
+    const { returnIntermediateSteps = false } = options || {};
+    const docs = await textSplitter.splitDocuments(documents$1.map((doc) => new documents.Document(doc)));
+    const res = await chain.invoke({
+        input_documents: docs,
+        returnIntermediateSteps,
+    });
+    if (res.error)
+        throw new Error(res.error);
+    return res.text && res.text.trim();
+}
 
-## Rules
-- Create a descriptive title for the changelog that gives a high-level overview of the changes.
-- **BREAKING CHANGES**: Identify any commits that introduce breaking changes. These must be listed first under a "### 💥 BREAKING CHANGES" heading.
-- **Grouping**: Logically group related changes under descriptive headings (e.g., ### Features, ### Fixes, ### Refactors).
-- **Dependencies**: Group all dependency updates (e.g., changes to package.json, go.mod) under a "### Dependencies" section.
-- **Summaries**: For each change, provide a concise summary.
-- **Attribution**: {{author_instructions}}
-- **Technical Details**: If provided with diffs, use them to understand the technical details and provide a more accurate and detailed description of the changes.
-- **Clarity**: Avoid generalizations like "various bug fixes," "improvements," or "enhancements." Be specific.
-- **Formatting**: Your entire response must be valid Markdown.
-
-## Formatting Instructions
-{{format_instructions}}
-
-{{additional_context}}
-
-"""{{summary}}"""`;
-const inputVariables$2 = [
-    'format_instructions',
-    'summary',
-    'additional_context',
-    'author_instructions',
-];
-const CHANGELOG_PROMPT = new prompts$1.PromptTemplate({
-    template: template$3,
-    inputVariables: inputVariables$2,
-});
-
-const handler$4 = async (argv, logger) => {
-    const config = loadConfig(argv);
-    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);
+/**
+ * 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,
+        };
     }
-    if (config.service.authentication.type !== 'None' && !key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        process.exit(1);
+    catch (error) {
+        // On error, return original diff unchanged
+        console.error(`Failed to summarize file ${fileDiff.file}:`, error);
+        return fileDiff;
     }
-    const llm = getLlm(provider, model, config);
-    const INTERACTIVE = isInteractive(config);
-    if (INTERACTIVE) {
-        if (!config.hideCocoBanner) {
-            logger.log(LOGO);
-        }
+}
+/**
+ * Process files in waves to respect concurrency limits.
+ */
+async function processInWaves$1(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);
     }
-    async function factory() {
-        const branchName = await getCurrentBranchName({ git });
-        if (argv.onlyDiff) {
-            logger.verbose(`Generating changelog based on branch diff`, { color: 'yellow' });
-            const diff = await getDiffForBranch({ git, logger, baseBranch: argv.branch || 'main', headBranch: branchName });
-            return {
-                branch: branchName,
-                diff: JSON.stringify(diff.staged, null, 2),
-            };
-        }
-        let commits = [];
-        if (config.sinceLastTag) {
-            logger.verbose(`Generating commit log since the last tag`, { color: 'yellow' });
-            // This function returns string[], needs to be adapted or replaced
-            // For now, this path will have limited details.
-            const commitMessages = await getChangesSinceLastTag({ git});
-            commits = commitMessages.map(msg => ({ message: msg }));
-        }
-        else if (config.range && config.range.includes(':')) {
-            const [from, to] = config.range.split(':');
-            if (!from || !to) {
-                logger.log(`Invalid range provided. Expected format is <from>:<to>`, { color: 'red' });
-                process.exit(1);
-            }
-            commits = await getCommitLogRangeDetails(from, to, { git, noMerges: true });
-        }
-        else if (argv.branch) {
-            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',
-            });
-            commits = await getCommitLogCurrentBranch({ git, logger });
-        }
-        let commitsWithDiffText = commits;
-        if (argv.withDiff) {
-            commitsWithDiffText = await Promise.all(commits.map(async (commit) => ({
-                ...commit,
-                diffText: await getDiffForCommit(commit.hash, { git }),
-            })));
+    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$1(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 {
-            branch: branchName,
-            commits: commitsWithDiffText,
-            withDiff: argv.withDiff,
+            path: node.path,
+            diffs: node.diffs.map((diff) => diffMap.get(diff.file) || diff),
+            children: node.children.map(rebuildNode),
         };
     }
-    async function parser(data) {
-        if (data.diff) {
-            return `## Diff for ${data.branch}\n\n${data.diff}`;
-        }
-        if (!data.commits || data.commits.length === 0) {
-            return `## ${data.branch}\n\nNo commits found.`;
-        }
-        let result = `## ${data.branch}\n\n`;
-        result += data.commits.map(commit => {
-            let commitStr = `Author: ${commit.author_name}\nCommit: ${commit.hash}\nMessage: ${commit.message}\n${commit.body}`;
-            if (data.withDiff && commit.diffText) {
-                commitStr += `\nDiff:\n${commit.diffText}`;
+    return rebuildNode(rootNode);
+}
+
+/**
+ * Create groups from a given node info.
+ * @param {DiffNode} node - The node info to start grouping.
+ * @returns {DirectoryDiff[]} The groups created.
+ */
+function createDirectoryDiffs(node) {
+    const groupByPath = {};
+    function traverse(node) {
+        node.diffs.forEach((diff) => {
+            const path = getPathFromFilePath(diff.file);
+            if (!groupByPath[path]) {
+                groupByPath[path] = { diffs: [], path, tokenCount: 0 };
             }
-            return commitStr.trim();
-        }).join('\n\n---\n\n');
-        return result;
+            groupByPath[path].diffs.push(diff);
+            groupByPath[path].tokenCount += diff.tokenCount;
+        });
+        node.children.forEach(traverse);
     }
-    const changelogMsg = await generateAndReviewLoop({
-        label: 'changelog',
-        options: {
-            ...config,
-            prompt: config.prompt || CHANGELOG_PROMPT.template,
-            logger,
-            interactive: INTERACTIVE,
-            review: {
-                enableFullRetry: false,
+    traverse(node);
+    return Object.values(groupByPath);
+}
+/**
+ * Summarize a directory diff asynchronously.
+ */
+async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
+    try {
+        const directorySummary = await summarize(directory.diffs.map((diff) => ({
+            pageContent: diff.diff,
+            metadata: {
+                file: diff.file,
+                summary: diff.summary,
+            },
+        })), {
+            chain,
+            textSplitter,
+            options: {
+                returnIntermediateSteps: true,
             },
-        },
-        factory,
-        parser,
-        agent: async (context, options) => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const parser = createSchemaParser(ChangelogResponseSchema, llm);
-            const prompt = getPrompt({
-                template: options.prompt,
-                variables: CHANGELOG_PROMPT.inputVariables,
-                fallback: CHANGELOG_PROMPT,
-            });
-            const formatInstructions = "Only respond with a valid JSON object, containing two fields: 'title' an escaped string, no more than 65 characters, and 'content' also an escaped string.";
-            let additional_context = '';
-            if (argv.additional) {
-                additional_context = `## Additional Context\n${argv.additional}`;
-            }
-            const author_instructions = argv.author
-                ? 'At the end of each item, attribute the author and include a reference to the commit hash, like this: `by @author_name (f6dbe61)`. Use the first 7 characters of the hash.'
-                : 'At the end of each item, include a reference to the commit hash, like this: `(f6dbe61)`. Use the first 7 characters of the hash.';
-            const changelog = await executeChain({
-                llm,
-                prompt,
-                variables: {
-                    summary: context,
-                    format_instructions: formatInstructions,
-                    additional_context: additional_context,
-                    author_instructions: author_instructions,
-                },
-                parser,
-            });
-            const branchName = await getCurrentBranchName({ git });
-            const ticketId = extractTicketIdFromBranchName(branchName);
-            const footer = ticketId ? `\n\nPart of **${ticketId}**` : '';
-            return `${changelog.title}\n\n${changelog.content}${footer}`;
-        },
-        noResult: async () => {
-            if (config.range) {
-                logger.log(`No commits found in the provided range.`, { color: 'red' });
-                process.exit(0);
-            }
-            logger.log(`No commits found in the current branch.`, { color: 'red' });
-            process.exit(0);
-        },
-    });
-    const MODE = (INTERACTIVE && 'interactive') || (config.commit && 'interactive') || config?.mode || 'stdout';
-    handleResult({
-        result: changelogMsg,
-        interactiveModeCallback: async () => {
-            logSuccess();
-        },
-        mode: MODE,
-    });
-};
-
-var changelog = {
-    command: command$4,
-    desc: 'Generate a changelog from current or target branch, provided commit range, or since the last tag.',
-    builder: builder$4,
-    handler: commandExecutor(handler$4),
-    options: options$4,
-};
-
-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().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')").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
- */
-const options$3 = {
-    i: {
-        alias: 'interactive',
-        description: 'Toggle interactive mode',
-        type: 'boolean',
-    },
-    ignoredFiles: {
-        description: 'Ignored files',
-        type: 'array',
-    },
-    ignoredExtensions: {
-        description: 'Ignored extensions',
-        type: 'array',
-    },
-    append: {
-        description: 'Add content to the end of the generated commit message',
-        type: 'string',
-    },
-    appendTicket: {
-        description: 'Append ticket ID from branch name to the commit message',
-        type: 'boolean',
-        alias: 't',
-    },
-    additional: {
-        description: 'Add extra contextual information to the prompt',
-        type: 'string',
-        alias: 'a',
-    },
-    withPreviousCommits: {
-        description: 'Include previous commits as context (specify number of commits, 0 for none)',
-        type: 'number',
-        default: 0,
-        alias: 'p',
-    },
-    conventional: {
-        description: 'Generate commit message in Conventional Commits format',
-        type: 'boolean',
-        default: false,
-        alias: 'c',
-    },
-    includeBranchName: {
-        description: 'Include the current branch name in the commit prompt for context',
-        type: 'boolean',
-        default: true,
-    },
-    noDiff: {
-        description: 'Only pass basic "git status" result instead of providing entire diff',
-        type: 'boolean',
-        default: false,
-    },
-};
-const builder$3 = (yargs) => {
-    return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
-};
-
-/**
- * High-level function that combines chain execution with schema-based parsing
- * Includes automatic retry logic and graceful degradation
- * @param schema - Zod schema for the expected output structure
- * @param llm - LLM instance
- * @param prompt - Prompt template
- * @param variables - Variables for the prompt
- * @param options - Configuration options
- * @returns Parsed result matching the schema type
- */
-async function executeChainWithSchema(schema, llm, prompt, variables, options = {}) {
-    const { retryOptions = { maxAttempts: 3 }, fallbackParser, onFallback, ...parserOptions } = options;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const parser = createSchemaParser(schema, llm, parserOptions);
-    const operation = async () => {
-        const result = await executeChain({
-            llm,
-            prompt,
-            variables,
-            parser,
         });
-        return result;
-    };
-    try {
-        return await withRetry(operation, retryOptions);
+        const newTokenTotal = tokenizer(directorySummary);
+        return {
+            diffs: directory.diffs,
+            path: directory.path,
+            summary: directorySummary,
+            tokenCount: newTokenTotal,
+        };
     }
     catch (error) {
-        if (fallbackParser) {
-            if (onFallback) {
-                onFallback();
-            }
-            const fallbackResult = await executeChain({
-                llm,
-                prompt,
-                variables,
-                parser: new output_parsers.StringOutputParser(),
-            });
-            const fallbackText = typeof fallbackResult === 'string' ? fallbackResult : String(fallbackResult);
-            return fallbackParser(fallbackText);
-        }
-        // No fallback available, re-throw the error
-        throw error;
+        console.error(error);
+        return directory;
     }
 }
-
 /**
- * Utility to repair common JSON formatting issues that LLMs make
- * Specifically handles cases where string values are not properly quoted
+ * 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
  */
-function repairJson(jsonString) {
-    // Remove any markdown code block wrapping
-    let cleaned = jsonString.replace(/```(?:json)?\s*([\s\S]*?)\s*```/g, '$1').trim();
-    // Remove inline code block wrapping
-    cleaned = cleaned.replace(/^`(.*)`$/, '$1').trim();
-    // If it doesn't look like JSON, return as-is
-    if (!cleaned.startsWith('{') || !cleaned.endsWith('}')) {
-        return jsonString;
+const defaultOutputCallback = (group) => {
+    let output = `
+-------\n* changes in "/${group.path}"\n\n`;
+    if (group.summary) {
+        output += `${group.diffs.map((diff) => ` • ${diff.summary}`).join('\n')}\n\nSummary:\n\n${group.summary}\n\n`;
     }
-    try {
-        // First try parsing as-is
-        JSON.parse(cleaned);
-        return cleaned;
+    else {
+        output += `${group.diffs.map((diff) => ` • ${diff.summary}\n\n${diff.diff}`).join('\n\n')}\n\n`;
     }
-    catch {
-        // Try to repair common issues
-        let repaired = cleaned;
-        // Fix unquoted string values in title and body fields
-        // Pattern: "title": unquoted_value, -> "title": "unquoted_value",
-        repaired = repaired.replace(/"(title|body)":\s*([^",\{\}\[\]]+?)(?=\s*[,\}])/g, (match, field, value) => {
-            // Clean up the value (remove leading/trailing whitespace)
-            const cleanValue = value.trim();
-            // If it's already quoted or looks like a number/boolean, leave it
-            if (cleanValue.startsWith('"') || /^(true|false|\d+)$/.test(cleanValue)) {
-                return match;
+    return output;
+};
+/**
+ * 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;
             }
-            // Quote the value
-            return `"${field}": "${cleanValue}"`;
-        });
-        // Fix missing quotes around field names (though this should be rare)
-        repaired = repaired.replace(/([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)\s*:/g, '$1"$2":');
-        // Remove trailing commas before closing braces
-        repaired = repaired.replace(/,(\s*[}\]])/g, '$1');
-        try {
-            // Test if the repair worked
-            JSON.parse(repaired);
-            return repaired;
+            // Skip directories that have already been summarized
+            if (results[index].summary) {
+                cursor = i + 1;
+                continue;
+            }
+            wave.push(index);
+            cursor = i + 1;
         }
-        catch {
-            // If repair failed, return original
-            return jsonString;
+        // No more eligible candidates
+        if (wave.length === 0) {
+            break;
         }
-    }
-}
-
-/**
- * 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);
-            }
+        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 null;
+    return { directories: results, totalTokenCount };
 }
 /**
- * Utility function to ensure commit messages are properly formatted as strings
- * rather than JSON objects, whether they come as parsed objects or stringified JSON
+ * 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
  */
-function formatCommitMessage(result, options = {}) {
-    const { append, ticketId, appendTicket } = options;
-    // Helper function to construct the final message with appends
-    const constructMessage = (title, body) => {
-        const appendedText = append ? `\n\n${append}` : '';
-        const ticketFooter = appendTicket && ticketId ? `\n\nPart of **${ticketId}**` : '';
-        return `${title}\n\n${body}${appendedText}${ticketFooter}`;
+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: Directory grouping & assessment
+    logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
+    let directoryDiffs = createDirectoryDiffs(rootDiffNode);
+    // 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);
+    logger.stopSpinner('Diffs Organized').stopTimer();
+    logger.verbose(`Total token count: ${totalTokenCount}, max allowed: ${maxTokens}`, {
+        color: totalTokenCount > maxTokens ? 'yellow' : 'green',
+    });
+    // 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 2: Pre-process large files only when the raw diff is over budget
+    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();
+    directoryDiffs = createDirectoryDiffs(preprocessedNode);
+    directoryDiffs.sort((a, b) => b.tokenCount - a.tokenCount);
+    totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
+    logger.verbose(`Total token count after file pre-processing: ${totalTokenCount}`, {
+        color: totalTokenCount > maxTokens ? 'yellow' : 'green',
+    });
+    if (totalTokenCount <= maxTokens) {
+        logger.verbose(`Under token budget after file pre-processing.`, { 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('');
+}
+
+function createLimit(maxConcurrent) {
+    const limit = Math.max(1, maxConcurrent);
+    let active = 0;
+    const queue = [];
+    const runNext = () => {
+        active--;
+        const next = queue.shift();
+        if (next)
+            next();
     };
-    // If it's a string, check if it contains a JSON object (including markdown code blocks)
-    if (typeof result === 'string') {
-        // Early return if string clearly doesn't contain JSON-like content
-        if (!result.includes('{') && !result.includes('"title"')) {
-            return result;
-        }
-        // 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 (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 extractionPatterns) {
-            const match = result.match(pattern);
-            if (match && match[1]) {
-                jsonString = match[1].trim();
-                foundMatch = true;
-                break;
-            }
+    return async (operation) => {
+        if (active >= limit) {
+            await new Promise((resolve) => queue.push(resolve));
         }
-        // Only attempt JSON parsing if we found potential JSON content
-        if (foundMatch || jsonString.startsWith('{')) {
-            try {
-                // Try to parse as JSON to see if it's a stringified object
-                const parsed = JSON.parse(jsonString);
-                if (parsed &&
-                    typeof parsed === 'object' &&
-                    typeof parsed.title === 'string' &&
-                    typeof parsed.body === 'string' &&
-                    parsed.title.length > 0 &&
-                    parsed.body.length > 0) {
-                    // It's a valid stringified JSON object, format it properly
-                    return constructMessage(parsed.title, parsed.body);
-                }
-            }
-            catch {
-                // Try to repair the JSON and parse again
-                try {
-                    const repairedJson = repairJson(jsonString);
-                    const parsed = JSON.parse(repairedJson);
-                    if (parsed &&
-                        typeof parsed === 'object' &&
-                        typeof parsed.title === 'string' &&
-                        typeof parsed.body === 'string' &&
-                        parsed.title.length > 0 &&
-                        parsed.body.length > 0) {
-                        // Successfully repaired and parsed JSON
-                        return constructMessage(parsed.title, parsed.body);
-                    }
-                }
-                catch {
-                    // 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
-                        }
-                    }
-                }
-            }
+        active++;
+        try {
+            return await operation();
         }
-        // If no JSON found and it's already formatted, return as-is
-        return result;
-    }
-    // If it's already an object with title and body, format it
-    if (typeof result === 'object' && result !== null &&
-        'title' in result && 'body' in result) {
-        const commitMsgObj = result;
-        if (typeof commitMsgObj.title === 'string' && typeof commitMsgObj.body === 'string') {
-            return constructMessage(commitMsgObj.title, commitMsgObj.body);
+        finally {
+            runNext();
         }
-    }
-    // Fallback - convert to string and return as-is
-    return String(result);
+    };
 }
-
 /**
- * Extract the path from a file path string.
- * @param {string} filePath - The full file path.
- * @returns {string} The path portion of the file path.
+ * Asynchronously collect diffs for a given node and its children.
  */
-function getPathFromFilePath(filePath) {
-    return filePath.split('/').slice(0, -1).join('/');
+async function collectDiffs(node, getFileDiff, tokenizer, logger, maxConcurrent = 6, limit = createLimit(maxConcurrent)) {
+    // Collect diffs for the files of the current node
+    const diffPromises = node.files.map((nodeFile) => limit(async () => {
+        const diff = await getFileDiff(nodeFile);
+        const tokenCount = tokenizer(diff);
+        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
+            color: 'magenta',
+        });
+        return {
+            file: nodeFile.filePath,
+            summary: nodeFile.summary,
+            diff,
+            tokenCount,
+        };
+    }));
+    // Collect diffs for the children of the current node
+    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger, maxConcurrent, limit));
+    const [diffs, children] = await Promise.all([
+        Promise.all(diffPromises),
+        Promise.all(childrenPromises),
+    ]);
+    return {
+        path: node.getPath(),
+        diffs,
+        children,
+    };
 }
 
-async function summarize(documents$1, { chain, textSplitter, options }) {
-    const { returnIntermediateSteps = false } = options || {};
-    const docs = await textSplitter.splitDocuments(documents$1.map((doc) => new documents.Document(doc)));
-    const res = await chain.invoke({
-        input_documents: docs,
-        returnIntermediateSteps,
-    });
-    if (res.error)
-        throw new Error(res.error);
-    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,
-        };
+class DiffTreeNode {
+    constructor(path) {
+        this.path = [];
+        this.files = [];
+        this.children = new Map();
+        if (path)
+            this.path = path;
     }
-    catch (error) {
-        // On error, return original diff unchanged
-        console.error(`Failed to summarize file ${fileDiff.file}:`, error);
-        return fileDiff;
+    addFile(file) {
+        this.files.push(file);
     }
-}
-/**
- * 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);
+    addChild(part, node) {
+        this.children.set(part, node);
     }
-    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;
+    getChild(part) {
+        return this.children.get(part);
     }
-    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);
+    getPath() {
+        return this.path.join('/');
     }
-    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),
-        };
+    print(indentation = 0) {
+        const indent = ' '.repeat(indentation);
+        let output = `${indent}- Path: ${this.getPath()}\n`;
+        if (this.files.length > 0) {
+            output += `${indent}  Files:\n`;
+            for (const file of this.files) {
+                output += `${indent}    - ${file.summary}\n`;
+            }
+        }
+        if (this.children.size > 0) {
+            output += `${indent}  Children:\n`;
+            for (const [, child] of this.children) {
+                output += child.print(indentation + 4);
+            }
+        }
+        return output;
     }
-    return rebuildNode(rootNode);
 }
-
-/**
- * Create groups from a given node info.
- * @param {DiffNode} node - The node info to start grouping.
- * @returns {DirectoryDiff[]} The groups created.
- */
-function createDirectoryDiffs(node) {
-    const groupByPath = {};
-    function traverse(node) {
-        node.diffs.forEach((diff) => {
-            const path = getPathFromFilePath(diff.file);
-            if (!groupByPath[path]) {
-                groupByPath[path] = { diffs: [], path, tokenCount: 0 };
+const createDiffTree = (changes) => {
+    const root = new DiffTreeNode();
+    for (const change of changes) {
+        let currentParent = root;
+        const parts = change.filePath.split('/');
+        parts.pop();
+        for (const part of parts) {
+            let childNode = currentParent.getChild(part);
+            if (!childNode) {
+                childNode = new DiffTreeNode([...currentParent.path, part]);
+                currentParent.addChild(part, childNode);
             }
-            groupByPath[path].diffs.push(diff);
-            groupByPath[path].tokenCount += diff.tokenCount;
+            currentParent = childNode;
+        }
+        // Create a NodeFile object and add it to the parent
+        currentParent.addFile({
+            filePath: change.filePath,
+            oldFilePath: change.oldFilePath,
+            summary: change.summary,
+            status: change.status,
         });
-        node.children.forEach(traverse);
     }
-    traverse(node);
-    return Object.values(groupByPath);
-}
+    return root;
+};
+
 /**
- * Summarize a directory diff asynchronously.
+ * Parses the default file diff for a given nodeFile.
+ *
+ * @param nodeFile - The file change object.
+ * @param commit - The commit to diff against. Defaults to '--staged'.
+ * @param git - The SimpleGit instance.
+ * @returns A Promise that resolves to the file diff as a string.
  */
-async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
+async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
+    if (commit === '--staged') {
+        return await git.diff(['--staged', nodeFile.filePath]);
+    }
+    else if (commit === '--unstaged') {
+        return await git.diff([nodeFile.filePath]);
+    }
+    else if (commit === '--untracked') {
+        // For untracked files, read the file content directly from the filesystem
+        try {
+            const fileContent = await fs.promises.readFile(nodeFile.filePath, 'utf-8');
+            return fileContent;
+        }
+        catch (error) {
+            throw new Error(`Error reading untracked file: ${error?.message || 'Unknown error'}`);
+        }
+    }
+    // For branch comparisons, handle files that may not exist in the base branch
     try {
-        const directorySummary = await summarize(directory.diffs.map((diff) => ({
-            pageContent: diff.diff,
-            metadata: {
-                file: diff.file,
-                summary: diff.summary,
-            },
-        })), {
-            chain,
-            textSplitter,
-            options: {
-                returnIntermediateSteps: true,
-            },
-        });
-        const newTokenTotal = tokenizer(directorySummary);
-        return {
-            diffs: directory.diffs,
-            path: directory.path,
-            summary: directorySummary,
-            tokenCount: newTokenTotal,
-        };
+        return await git.diff([commit, nodeFile.filePath]);
     }
     catch (error) {
-        console.error(error);
-        return directory;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // If the error indicates the file doesn't exist in the base branch, handle it gracefully
+        if (errorMessage.includes('unknown revision or path not in the working tree') ||
+            errorMessage.includes('ambiguous argument')) {
+            // This is likely a newly added file - show the entire file content as an addition
+            if (nodeFile.status === 'added') {
+                try {
+                    const fileContent = await fs.promises.readFile(nodeFile.filePath, 'utf-8');
+                    return `+++ ${nodeFile.filePath}\n${fileContent.split('\n').map(line => `+${line}`).join('\n')}`;
+                }
+                catch (fsError) {
+                    return `Error reading added file ${nodeFile.filePath}: ${fsError instanceof Error ? fsError.message : String(fsError)}`;
+                }
+            }
+            // For other cases, try to get the file content from the current HEAD
+            try {
+                const fileContent = await git.show([`HEAD:${nodeFile.filePath}`]);
+                return `File content from current version:\n${fileContent}`;
+            }
+            catch (showError) {
+                // If all else fails, provide a meaningful error message
+                return `Unable to retrieve diff for ${nodeFile.filePath}. File may be newly added or renamed.`;
+            }
+        }
+        // Re-throw other types of errors
+        throw error;
     }
 }
 /**
- * Default output formatter for directory diffs.
+ * Parses the diff for a renamed file.
  *
- * 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`;
-    if (group.summary) {
-        output += `${group.diffs.map((diff) => ` • ${diff.summary}`).join('\n')}\n\nSummary:\n\n${group.summary}\n\n`;
-    }
-    else {
-        output += `${group.diffs.map((diff) => ` • ${diff.summary}\n\n${diff.diff}`).join('\n\n')}\n\n`;
-    }
-    return output;
-};
-/**
- * Process directory summarization in waves to respect concurrency limits
- * while maintaining predictable behavior.
+ * @param nodeFile - The file change object.
+ * @param commit - The commit hash or '--staged'.
+ * @param git - The SimpleGit instance.
+ * @param logger - The logger instance.
+ * @returns A Promise that resolves to the diff string.
  */
-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;
+async function parseRenamedFileDiff(nodeFile, commit, git, logger) {
+    let result = '';
+    const oldFilePath = nodeFile?.oldFilePath || nodeFile.filePath;
+    let previousCommitHash = 'HEAD';
+    let newCommitHash = '';
+    if (commit !== '--staged') {
+        try {
+            previousCommitHash = await git.revparse([`${commit}~1`]);
         }
-        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',
+        catch (err) {
+            logger.verbose(`Error getting previous commit hash for ${nodeFile.filePath}`, {
+                color: 'red',
             });
-        });
-        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;
         }
+        newCommitHash = commit;
     }
-    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(preprocessedNode);
-    // Sort by token count descending for consistent output ordering
-    directoryDiffs.sort((a, b) => b.tokenCount - a.tokenCount);
-    const totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
-    logger.stopSpinner('Diffs Organized').stopTimer();
-    logger.verbose(`Total token count: ${totalTokenCount}, max allowed: ${maxTokens}`, {
-        color: totalTokenCount > maxTokens ? 'yellow' : 'green',
-    });
-    // 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('');
-}
-
-/**
- * Asynchronously collect diffs for a given node and its children.
- */
-async function collectDiffs(node, getFileDiff, tokenizer, logger) {
-    // Collect diffs for the files of the current node
-    const diffPromises = node.files.map(async (nodeFile) => {
-        const diff = await getFileDiff(nodeFile);
-        const tokenCount = tokenizer(diff);
-        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
-            color: 'magenta',
-        });
-        return {
-            file: nodeFile.filePath,
-            summary: nodeFile.summary,
-            diff,
-            tokenCount,
-        };
-    });
-    // Collect diffs for the children of the current node
-    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
-    const [diffs, children] = await Promise.all([
-        Promise.all(diffPromises),
-        Promise.all(childrenPromises),
-    ]);
-    return {
-        path: node.getPath(),
-        diffs,
-        children,
-    };
-}
-
-class DiffTreeNode {
-    constructor(path) {
-        this.path = [];
-        this.files = [];
-        this.children = new Map();
-        if (path)
-            this.path = path;
-    }
-    addFile(file) {
-        this.files.push(file);
-    }
-    addChild(part, node) {
-        this.children.set(part, node);
-    }
-    getChild(part) {
-        return this.children.get(part);
-    }
-    getPath() {
-        return this.path.join('/');
-    }
-    print(indentation = 0) {
-        const indent = ' '.repeat(indentation);
-        let output = `${indent}- Path: ${this.getPath()}\n`;
-        if (this.files.length > 0) {
-            output += `${indent}  Files:\n`;
-            for (const file of this.files) {
-                output += `${indent}    - ${file.summary}\n`;
-            }
+    try {
+        const [previousContent, newContent] = await Promise.all([
+            git.show([`${previousCommitHash}:${oldFilePath}`]),
+            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
+        ]);
+        if (previousContent !== newContent) {
+            result = diff.createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
+                context: 3,
+            });
+            // remove the first 4 lines of the patch (they contain the old and new file names)
+            result = result.split('\n').slice(4).join('\n');
         }
-        if (this.children.size > 0) {
-            output += `${indent}  Children:\n`;
-            for (const [, child] of this.children) {
-                output += child.print(indentation + 4);
-            }
+        else {
+            result = 'File contents are unchanged.';
         }
-        return output;
     }
-}
-const createDiffTree = (changes) => {
-    const root = new DiffTreeNode();
-    for (const change of changes) {
-        let currentParent = root;
-        const parts = change.filePath.split('/');
-        parts.pop();
-        for (const part of parts) {
-            let childNode = currentParent.getChild(part);
-            if (!childNode) {
-                childNode = new DiffTreeNode([...currentParent.path, part]);
-                currentParent.addChild(part, childNode);
-            }
-            currentParent = childNode;
-        }
-        // Create a NodeFile object and add it to the parent
-        currentParent.addFile({
-            filePath: change.filePath,
-            oldFilePath: change.oldFilePath,
-            summary: change.summary,
-            status: change.status,
-        });
+    catch (err) {
+        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
+        result = 'Error comparing file contents.';
     }
-    return root;
-};
-
+    return result;
+}
 /**
- * Parses the default file diff for a given nodeFile.
+ * Retrieves the diff for a given file change in a specific commit.
+ * If the file is deleted, it returns a message indicating that the file has been deleted.
+ * If the file is renamed, it parses the renamed file diff and returns it.
+ * Otherwise, it retrieves the default diff from the index and returns it.
  *
  * @param nodeFile - The file change object.
- * @param commit - The commit to diff against. Defaults to '--staged'.
+ * @param commit - The commit hash.
  * @param git - The SimpleGit instance.
- * @returns A Promise that resolves to the file diff as a string.
- */
-async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
-    if (commit === '--staged') {
-        return await git.diff(['--staged', nodeFile.filePath]);
-    }
-    else if (commit === '--unstaged') {
-        return await git.diff([nodeFile.filePath]);
-    }
-    else if (commit === '--untracked') {
-        // For untracked files, read the file content directly from the filesystem
-        try {
-            const fileContent = await fs.promises.readFile(nodeFile.filePath, 'utf-8');
-            return fileContent;
-        }
-        catch (error) {
-            throw new Error(`Error reading untracked file: ${error?.message || 'Unknown error'}`);
-        }
-    }
-    // For branch comparisons, handle files that may not exist in the base branch
-    try {
-        return await git.diff([commit, nodeFile.filePath]);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // If the error indicates the file doesn't exist in the base branch, handle it gracefully
-        if (errorMessage.includes('unknown revision or path not in the working tree') ||
-            errorMessage.includes('ambiguous argument')) {
-            // This is likely a newly added file - show the entire file content as an addition
-            if (nodeFile.status === 'added') {
-                try {
-                    const fileContent = await fs.promises.readFile(nodeFile.filePath, 'utf-8');
-                    return `+++ ${nodeFile.filePath}\n${fileContent.split('\n').map(line => `+${line}`).join('\n')}`;
-                }
-                catch (fsError) {
-                    return `Error reading added file ${nodeFile.filePath}: ${fsError instanceof Error ? fsError.message : String(fsError)}`;
-                }
-            }
-            // For other cases, try to get the file content from the current HEAD
-            try {
-                const fileContent = await git.show([`HEAD:${nodeFile.filePath}`]);
-                return `File content from current version:\n${fileContent}`;
-            }
-            catch (showError) {
-                // If all else fails, provide a meaningful error message
-                return `Unable to retrieve diff for ${nodeFile.filePath}. File may be newly added or renamed.`;
-            }
-        }
-        // Re-throw other types of errors
-        throw error;
-    }
-}
-/**
- * Parses the diff for a renamed file.
- *
- * @param nodeFile - The file change object.
- * @param commit - The commit hash or '--staged'.
- * @param git - The SimpleGit instance.
- * @param logger - The logger instance.
- * @returns A Promise that resolves to the diff string.
- */
-async function parseRenamedFileDiff(nodeFile, commit, git, logger) {
-    let result = '';
-    const oldFilePath = nodeFile?.oldFilePath || nodeFile.filePath;
-    let previousCommitHash = 'HEAD';
-    let newCommitHash = '';
-    if (commit !== '--staged') {
-        try {
-            previousCommitHash = await git.revparse([`${commit}~1`]);
-        }
-        catch (err) {
-            logger.verbose(`Error getting previous commit hash for ${nodeFile.filePath}`, {
-                color: 'red',
-            });
-        }
-        newCommitHash = commit;
-    }
-    try {
-        const [previousContent, newContent] = await Promise.all([
-            git.show([`${previousCommitHash}:${oldFilePath}`]),
-            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
-        ]);
-        if (previousContent !== newContent) {
-            result = diff.createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
-                context: 3,
-            });
-            // remove the first 4 lines of the patch (they contain the old and new file names)
-            result = result.split('\n').slice(4).join('\n');
-        }
-        else {
-            result = 'File contents are unchanged.';
-        }
-    }
-    catch (err) {
-        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
-        result = 'Error comparing file contents.';
-    }
-    return result;
-}
-/**
- * Retrieves the diff for a given file change in a specific commit.
- * If the file is deleted, it returns a message indicating that the file has been deleted.
- * If the file is renamed, it parses the renamed file diff and returns it.
- * Otherwise, it retrieves the default diff from the index and returns it.
- *
- * @param nodeFile - The file change object.
- * @param commit - The commit hash.
- * @param git - The SimpleGit instance.
- * @param logger - The logger instance.
- * @returns A promise that resolves to the diff as a string.
+ * @param logger - The logger instance.
+ * @returns A promise that resolves to the diff as a string.
  */
 async function getDiff(nodeFile, commit, { git, logger, }) {
     if (nodeFile.status === 'deleted') {
@@ -10767,7 +10401,7 @@ var RecursiveCharacterTextSplitter = class RecursiveCharacterTextSplitter extend
 };
 
 //#region src/chains/summarization/stuff_prompts.ts
-const template$2 = `Write a concise summary of the following:
+const template$3 = `Write a concise summary of the following:
 
 
 "{text}"
@@ -10775,7 +10409,7 @@ const template$2 = `Write a concise summary of the following:
 
 CONCISE SUMMARY:`;
 const DEFAULT_PROMPT = /* @__PURE__ */ new prompts$1.PromptTemplate({
-	template: template$2,
+	template: template$3,
 	inputVariables: ["text"]
 });
 
@@ -11871,46 +11505,658 @@ function simpleEscapeSequence(c) {
         (c === 0x50/* P */) ? '\u2029' : '';
 }
 
-var simpleEscapeCheck = new Array(256); // integer, for fast access
-var simpleEscapeMap = new Array(256);
-for (var i = 0; i < 256; i++) {
-  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
-  simpleEscapeMap[i] = simpleEscapeSequence(i);
+var simpleEscapeCheck = new Array(256); // integer, for fast access
+var simpleEscapeMap = new Array(256);
+for (var i = 0; i < 256; i++) {
+  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+  simpleEscapeMap[i] = simpleEscapeSequence(i);
+}
+
+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',
+        combineMapPrompt: SUMMARIZE_PROMPT,
+        combinePrompt: SUMMARIZE_PROMPT,
+    });
+    logger.startTimer();
+    const rootTreeNode = createDiffTree(changes);
+    logger.stopTimer('Created file hierarchy');
+    // Collect diffs
+    logger.startTimer().startSpinner(`Collecting Diffs...\n`, { color: 'blue' });
+    const diffs = await collectDiffs(rootTreeNode, (path) => getDiff(path, commit, { git, logger }), tokenizer, logger, maxConcurrent);
+    logger.stopSpinner('Diffs Collected').stopTimer();
+    // 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 || 2048,
+        minTokensForSummary,
+        maxFileTokens,
+        maxConcurrent,
+        textSplitter,
+        chain: summarizationChain,
+        logger,
+    });
+    logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
+    return summary;
+}
+
+/**
+ * Retrieves a TikToken for the specified model.
+ *
+ * @param {TiktokenModel} modelName - The name of the TiktokenModel.
+ * @returns A Promise that resolves to the TikToken.
+ */
+const getTikToken = async (modelName) => {
+    return await tiktoken.encoding_for_model(modelName);
+};
+/**
+ * Retrieves the token counter for a given model name.
+ *
+ * @param {TikTokenModel} modelName - The name of the Tiktoken model.
+ * @returns A promise that resolves to a function that calculates the number of tokens in a given text.
+ */
+const getTokenCounter = async (modelName) => {
+    return getTikToken(modelName).then((tokenizer) => (text) => {
+        const tokens = tokenizer.encode(text);
+        return tokens.length;
+    });
+};
+
+const template$2 = `You are a highly skilled software engineer tasked with writing a git changelog. Your response should be informative, well-structured, and in the imperative.
+
+## Input
+You will be provided with a summary of changes. This summary can be one of the following:
+1. A list of commits, each with its author, hash, message, and body.
+2. A list of commits, each with its details AND the full diff of the changes.
+3. A single, comprehensive diff for an entire branch.
+
+## Rules
+- Create a descriptive title for the changelog that gives a high-level overview of the changes.
+- **BREAKING CHANGES**: Identify any commits that introduce breaking changes. These must be listed first under a "### 💥 BREAKING CHANGES" heading.
+- **Grouping**: Logically group related changes under descriptive headings (e.g., ### Features, ### Fixes, ### Refactors).
+- **Dependencies**: Group all dependency updates (e.g., changes to package.json, go.mod) under a "### Dependencies" section.
+- **Summaries**: For each change, provide a concise summary.
+- **Attribution**: {{author_instructions}}
+- **Technical Details**: If provided with diffs, use them to understand the technical details and provide a more accurate and detailed description of the changes.
+- **Clarity**: Avoid generalizations like "various bug fixes," "improvements," or "enhancements." Be specific.
+- **Formatting**: Your entire response must be valid Markdown.
+
+## Formatting Instructions
+{{format_instructions}}
+
+{{additional_context}}
+
+"""{{summary}}"""`;
+const inputVariables$2 = [
+    'format_instructions',
+    'summary',
+    'additional_context',
+    'author_instructions',
+];
+const CHANGELOG_PROMPT = new prompts$1.PromptTemplate({
+    template: template$2,
+    inputVariables: inputVariables$2,
+});
+
+async function processInWaves(items, processor, maxConcurrent = 6) {
+    const results = [];
+    const limit = Math.max(1, maxConcurrent);
+    for (let i = 0; i < items.length; i += limit) {
+        const waveResults = await Promise.all(items.slice(i, i + limit).map(processor));
+        results.push(...waveResults);
+    }
+    return results;
+}
+const handler$4 = async (argv, logger) => {
+    const config = loadConfig(argv);
+    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);
+    }
+    const llm = getLlm(provider, model, config);
+    const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
+    const INTERACTIVE = isInteractive(config);
+    if (INTERACTIVE) {
+        if (!config.hideCocoBanner) {
+            logger.log(LOGO);
+        }
+    }
+    async function factory() {
+        const branchName = await getCurrentBranchName({ git });
+        if (argv.onlyDiff) {
+            const baseBranch = argv.branch || config.defaultBranch || 'main';
+            logger.verbose(`Generating changelog based on branch diff`, { color: 'yellow' });
+            const diff = await getDiffForBranch({ git, logger, baseBranch, headBranch: branchName });
+            return {
+                branch: branchName,
+                diffChanges: diff.staged,
+                diffCommit: `${baseBranch}..${branchName}`,
+            };
+        }
+        let commits = [];
+        if (config.sinceLastTag) {
+            logger.verbose(`Generating commit log since the last tag`, { color: 'yellow' });
+            // This function returns string[], needs to be adapted or replaced
+            // For now, this path will have limited details.
+            const commitMessages = await getChangesSinceLastTag({ git});
+            commits = commitMessages.map(msg => ({ message: msg }));
+        }
+        else if (config.range && config.range.includes(':')) {
+            const [from, to] = config.range.split(':');
+            if (!from || !to) {
+                logger.log(`Invalid range provided. Expected format is <from>:<to>`, { color: 'red' });
+                process.exit(1);
+            }
+            commits = await getCommitLogRangeDetails(from, to, { git, noMerges: true });
+        }
+        else if (argv.branch) {
+            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',
+            });
+            commits = await getCommitLogCurrentBranch({ git, logger });
+        }
+        let commitsWithDiffText = commits;
+        if (argv.withDiff) {
+            commitsWithDiffText = await processInWaves(commits, async (commit) => {
+                const changes = await getChangesByCommit({
+                    commit: commit.hash,
+                    options: {
+                        git,
+                        ignoredFiles: config.ignoredFiles || undefined,
+                        ignoredExtensions: config.ignoredExtensions || undefined,
+                    },
+                });
+                return {
+                    ...commit,
+                    diffText: changes.length > 0
+                        ? await fileChangeParser({
+                            changes,
+                            commit: `${commit.hash}^..${commit.hash}`,
+                            options: {
+                                tokenizer,
+                                git,
+                                llm,
+                                logger,
+                                maxTokens: config.service.tokenLimit,
+                                minTokensForSummary: config.service.minTokensForSummary,
+                                maxFileTokens: config.service.maxFileTokens,
+                                maxConcurrent: config.service.maxConcurrent,
+                            },
+                        })
+                        : undefined,
+                };
+            }, config.service.maxConcurrent);
+        }
+        return {
+            branch: branchName,
+            commits: commitsWithDiffText,
+            withDiff: argv.withDiff,
+        };
+    }
+    async function parser(data) {
+        if (data.diffChanges && data.diffCommit) {
+            const diffSummary = await fileChangeParser({
+                changes: data.diffChanges,
+                commit: data.diffCommit,
+                options: {
+                    tokenizer,
+                    git,
+                    llm,
+                    logger,
+                    maxTokens: config.service.tokenLimit,
+                    minTokensForSummary: config.service.minTokensForSummary,
+                    maxFileTokens: config.service.maxFileTokens,
+                    maxConcurrent: config.service.maxConcurrent,
+                },
+            });
+            return `## Diff for ${data.branch}\n\n${diffSummary}`;
+        }
+        if (!data.commits || data.commits.length === 0) {
+            return `## ${data.branch}\n\nNo commits found.`;
+        }
+        let result = `## ${data.branch}\n\n`;
+        result += data.commits.map(commit => {
+            let commitStr = `Author: ${commit.author_name}\nCommit: ${commit.hash}\nMessage: ${commit.message}\n${commit.body}`;
+            if (data.withDiff && commit.diffText) {
+                commitStr += `\nDiff:\n${commit.diffText}`;
+            }
+            return commitStr.trim();
+        }).join('\n\n---\n\n');
+        return result;
+    }
+    const changelogMsg = await generateAndReviewLoop({
+        label: 'changelog',
+        options: {
+            ...config,
+            prompt: config.prompt || CHANGELOG_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+            review: {
+                enableFullRetry: false,
+            },
+        },
+        factory,
+        parser,
+        agent: async (context, options) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const parser = createSchemaParser(ChangelogResponseSchema, llm);
+            const prompt = getPrompt({
+                template: options.prompt,
+                variables: CHANGELOG_PROMPT.inputVariables,
+                fallback: CHANGELOG_PROMPT,
+            });
+            const formatInstructions = "Only respond with a valid JSON object, containing two fields: 'title' an escaped string, no more than 65 characters, and 'content' also an escaped string.";
+            let additional_context = '';
+            if (argv.additional) {
+                additional_context = `## Additional Context\n${argv.additional}`;
+            }
+            const author_instructions = argv.author
+                ? 'At the end of each item, attribute the author and include a reference to the commit hash, like this: `by @author_name (f6dbe61)`. Use the first 7 characters of the hash.'
+                : 'At the end of each item, include a reference to the commit hash, like this: `(f6dbe61)`. Use the first 7 characters of the hash.';
+            const variables = {
+                summary: context,
+                format_instructions: formatInstructions,
+                additional_context: additional_context,
+                author_instructions: author_instructions,
+            };
+            const budgetedPrompt = await enforcePromptBudget({
+                prompt,
+                variables,
+                tokenizer,
+                maxTokens: config.service.tokenLimit || 2048,
+            });
+            if (budgetedPrompt.truncated) {
+                logger.verbose(`Rendered prompt exceeded token budget; trimmed summary to ${budgetedPrompt.promptTokenCount} tokens.`, { color: 'yellow' });
+            }
+            const changelog = await executeChain({
+                llm,
+                prompt,
+                variables: budgetedPrompt.variables,
+                parser,
+            });
+            const branchName = await getCurrentBranchName({ git });
+            const ticketId = extractTicketIdFromBranchName(branchName);
+            const footer = ticketId ? `\n\nPart of **${ticketId}**` : '';
+            return `${changelog.title}\n\n${changelog.content}${footer}`;
+        },
+        noResult: async () => {
+            if (config.range) {
+                logger.log(`No commits found in the provided range.`, { color: 'red' });
+                process.exit(0);
+            }
+            logger.log(`No commits found in the current branch.`, { color: 'red' });
+            process.exit(0);
+        },
+    });
+    const MODE = (INTERACTIVE && 'interactive') || (config.commit && 'interactive') || config?.mode || 'stdout';
+    handleResult({
+        result: changelogMsg,
+        interactiveModeCallback: async () => {
+            logSuccess();
+        },
+        mode: MODE,
+    });
+};
+
+var changelog = {
+    command: command$4,
+    desc: 'Generate a changelog from current or target branch, provided commit range, or since the last tag.',
+    builder: builder$4,
+    handler: commandExecutor(handler$4),
+    options: options$4,
+};
+
+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().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')").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
+ */
+const options$3 = {
+    i: {
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+        type: 'boolean',
+    },
+    ignoredFiles: {
+        description: 'Ignored files',
+        type: 'array',
+    },
+    ignoredExtensions: {
+        description: 'Ignored extensions',
+        type: 'array',
+    },
+    append: {
+        description: 'Add content to the end of the generated commit message',
+        type: 'string',
+    },
+    appendTicket: {
+        description: 'Append ticket ID from branch name to the commit message',
+        type: 'boolean',
+        alias: 't',
+    },
+    additional: {
+        description: 'Add extra contextual information to the prompt',
+        type: 'string',
+        alias: 'a',
+    },
+    withPreviousCommits: {
+        description: 'Include previous commits as context (specify number of commits, 0 for none)',
+        type: 'number',
+        default: 0,
+        alias: 'p',
+    },
+    conventional: {
+        description: 'Generate commit message in Conventional Commits format',
+        type: 'boolean',
+        default: false,
+        alias: 'c',
+    },
+    includeBranchName: {
+        description: 'Include the current branch name in the commit prompt for context',
+        type: 'boolean',
+        default: true,
+    },
+    noDiff: {
+        description: 'Only pass basic "git status" result instead of providing entire diff',
+        type: 'boolean',
+        default: false,
+    },
+    noVerify: {
+        description: 'Skip pre-commit and commit-msg hooks (passes --no-verify to git commit)',
+        type: 'boolean',
+        default: false,
+        alias: 'n',
+    },
+};
+const builder$3 = (yargs) => {
+    return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
+};
+
+/**
+ * High-level function that combines chain execution with schema-based parsing
+ * Includes automatic retry logic and graceful degradation
+ * @param schema - Zod schema for the expected output structure
+ * @param llm - LLM instance
+ * @param prompt - Prompt template
+ * @param variables - Variables for the prompt
+ * @param options - Configuration options
+ * @returns Parsed result matching the schema type
+ */
+async function executeChainWithSchema(schema, llm, prompt, variables, options = {}) {
+    const { retryOptions = { maxAttempts: 3 }, fallbackParser, onFallback, ...parserOptions } = options;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parser = createSchemaParser(schema, llm, parserOptions);
+    const operation = async () => {
+        const result = await executeChain({
+            llm,
+            prompt,
+            variables,
+            parser,
+        });
+        return result;
+    };
+    try {
+        return await withRetry(operation, retryOptions);
+    }
+    catch (error) {
+        if (fallbackParser) {
+            if (onFallback) {
+                onFallback();
+            }
+            const fallbackResult = await executeChain({
+                llm,
+                prompt,
+                variables,
+                parser: new output_parsers.StringOutputParser(),
+            });
+            const fallbackText = typeof fallbackResult === 'string' ? fallbackResult : String(fallbackResult);
+            return fallbackParser(fallbackText);
+        }
+        // No fallback available, re-throw the error
+        throw error;
+    }
+}
+
+/**
+ * Utility to repair common JSON formatting issues that LLMs make
+ * Specifically handles cases where string values are not properly quoted
+ */
+function repairJson(jsonString) {
+    // Remove any markdown code block wrapping
+    let cleaned = jsonString.replace(/```(?:json)?\s*([\s\S]*?)\s*```/g, '$1').trim();
+    // Remove inline code block wrapping
+    cleaned = cleaned.replace(/^`(.*)`$/, '$1').trim();
+    // If it doesn't look like JSON, return as-is
+    if (!cleaned.startsWith('{') || !cleaned.endsWith('}')) {
+        return jsonString;
+    }
+    try {
+        // First try parsing as-is
+        JSON.parse(cleaned);
+        return cleaned;
+    }
+    catch {
+        // Try to repair common issues
+        let repaired = cleaned;
+        // Fix unquoted string values in title and body fields
+        // Pattern: "title": unquoted_value, -> "title": "unquoted_value",
+        repaired = repaired.replace(/"(title|body)":\s*([^",\{\}\[\]]+?)(?=\s*[,\}])/g, (match, field, value) => {
+            // Clean up the value (remove leading/trailing whitespace)
+            const cleanValue = value.trim();
+            // If it's already quoted or looks like a number/boolean, leave it
+            if (cleanValue.startsWith('"') || /^(true|false|\d+)$/.test(cleanValue)) {
+                return match;
+            }
+            // Quote the value
+            return `"${field}": "${cleanValue}"`;
+        });
+        // Fix missing quotes around field names (though this should be rare)
+        repaired = repaired.replace(/([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)\s*:/g, '$1"$2":');
+        // Remove trailing commas before closing braces
+        repaired = repaired.replace(/,(\s*[}\]])/g, '$1');
+        try {
+            // Test if the repair worked
+            JSON.parse(repaired);
+            return repaired;
+        }
+        catch {
+            // If repair failed, return original
+            return 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;
 }
-
-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',
-        combineMapPrompt: SUMMARIZE_PROMPT,
-        combinePrompt: SUMMARIZE_PROMPT,
-    });
-    logger.startTimer();
-    const rootTreeNode = createDiffTree(changes);
-    logger.stopTimer('Created file hierarchy');
-    // Collect diffs
-    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 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 || 2048,
-        minTokensForSummary,
-        maxFileTokens,
-        maxConcurrent,
-        textSplitter,
-        chain: summarizationChain,
-        logger,
-    });
-    logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
-    return summary;
+/**
+ * Utility function to ensure commit messages are properly formatted as strings
+ * rather than JSON objects, whether they come as parsed objects or stringified JSON
+ */
+function formatCommitMessage(result, options = {}) {
+    const { append, ticketId, appendTicket } = options;
+    // Helper function to construct the final message with appends
+    const constructMessage = (title, body) => {
+        const appendedText = append ? `\n\n${append}` : '';
+        const ticketFooter = appendTicket && ticketId ? `\n\nPart of **${ticketId}**` : '';
+        return `${title}\n\n${body}${appendedText}${ticketFooter}`;
+    };
+    // If it's a string, check if it contains a JSON object (including markdown code blocks)
+    if (typeof result === 'string') {
+        // Early return if string clearly doesn't contain JSON-like content
+        if (!result.includes('{') && !result.includes('"title"')) {
+            return result;
+        }
+        // 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 (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 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 (foundMatch || jsonString.startsWith('{')) {
+            try {
+                // Try to parse as JSON to see if it's a stringified object
+                const parsed = JSON.parse(jsonString);
+                if (parsed &&
+                    typeof parsed === 'object' &&
+                    typeof parsed.title === 'string' &&
+                    typeof parsed.body === 'string' &&
+                    parsed.title.length > 0 &&
+                    parsed.body.length > 0) {
+                    // It's a valid stringified JSON object, format it properly
+                    return constructMessage(parsed.title, parsed.body);
+                }
+            }
+            catch {
+                // Try to repair the JSON and parse again
+                try {
+                    const repairedJson = repairJson(jsonString);
+                    const parsed = JSON.parse(repairedJson);
+                    if (parsed &&
+                        typeof parsed === 'object' &&
+                        typeof parsed.title === 'string' &&
+                        typeof parsed.body === 'string' &&
+                        parsed.title.length > 0 &&
+                        parsed.body.length > 0) {
+                        // Successfully repaired and parsed JSON
+                        return constructMessage(parsed.title, parsed.body);
+                    }
+                }
+                catch {
+                    // 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
+                        }
+                    }
+                }
+            }
+        }
+        // If no JSON found and it's already formatted, return as-is
+        return result;
+    }
+    // If it's already an object with title and body, format it
+    if (typeof result === 'object' && result !== null &&
+        'title' in result && 'body' in result) {
+        const commitMsgObj = result;
+        if (typeof commitMsgObj.title === 'string' && typeof commitMsgObj.body === 'string') {
+            return constructMessage(commitMsgObj.title, commitMsgObj.body);
+        }
+    }
+    // Fallback - convert to string and return as-is
+    return String(result);
 }
 
+/**
+ * Error thrown when a pre-commit hook blocks a commit (e.g. a linter exits non-zero).
+ * Contains the raw hook output so callers can present it cleanly to the user.
+ */
+class PreCommitHookError extends Error {
+    constructor(hookOutput) {
+        super('Pre-commit hook failed');
+        this.name = 'PreCommitHookError';
+        this.hookOutput = hookOutput;
+    }
+}
 /**
  * Detects whether a GitError was caused by a pre-commit hook that modified files.
  * These hooks (e.g. black, prettier) reformat files and exit non-zero on the first run,
@@ -11930,15 +12176,19 @@ function isPreCommitHookModifiedFilesError(error) {
  * Creates a commit with the specified commit message.
  * Handles the case where pre-commit hooks modify files (e.g. black, prettier):
  * when detected, stages the hook-modified files and retries the commit once.
+ * Any other GitError (e.g. hook lint failure) is wrapped in a PreCommitHookError
+ * so callers can present it cleanly instead of showing a raw stack trace.
  *
  * @param message The commit message.
  * @param git The SimpleGit instance.
  * @param onHookModifiedFiles Optional callback invoked before the auto-retry so callers can notify the user.
+ * @param options Optional commit options (e.g. noVerify).
  * @returns A Promise that resolves to the CommitResult.
  */
-async function createCommit(message, git, onHookModifiedFiles) {
+async function createCommit(message, git, onHookModifiedFiles, options) {
+    const flags = options?.noVerify ? ['--no-verify'] : [];
     try {
-        return await git.commit(message);
+        return await git.commit(message, flags);
     }
     catch (error) {
         if (isPreCommitHookModifiedFilesError(error)) {
@@ -11948,7 +12198,12 @@ async function createCommit(message, git, onHookModifiedFiles) {
             }
             // Stage all hook-modified files and retry the commit once
             await git.add('.');
-            return await git.commit(message);
+            return await git.commit(message, flags);
+        }
+        // Wrap any other GitError so callers can present it cleanly rather than
+        // showing a raw Node.js stack trace originating from simple-git internals.
+        if (error instanceof simpleGit.GitError) {
+            throw new PreCommitHookError(error.message);
         }
         throw error;
     }
@@ -11961,7 +12216,7 @@ async function createCommit(message, git, onHookModifiedFiles) {
  * @returns {Promise<GetChangesResult>} A promise that resolves to the changes in the Git repository.
  */
 async function getChanges({ git, options }) {
-    const { ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS } = options || {};
+    const { ignoredFiles = DEFAULT_IGNORED_FILES$1, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS$1 } = options || {};
     const staged = [];
     const unstaged = [];
     const untracked = [];
@@ -12055,28 +12310,6 @@ async function getPreviousCommits(options) {
     }
 }
 
-/**
- * Retrieves a TikToken for the specified model.
- *
- * @param {TiktokenModel} modelName - The name of the TiktokenModel.
- * @returns A Promise that resolves to the TikToken.
- */
-const getTikToken = async (modelName) => {
-    return await tiktoken.encoding_for_model(modelName);
-};
-/**
- * Retrieves the token counter for a given model name.
- *
- * @param {TikTokenModel} modelName - The name of the Tiktoken model.
- * @returns A promise that resolves to a function that calculates the number of tokens in a given text.
- */
-const getTokenCounter = async (modelName) => {
-    return getTikToken(modelName).then((tokenizer) => (text) => {
-        const tokens = tokenizer.encode(text);
-        return tokens.length;
-    });
-};
-
 const COMMITLINT_CONFIG_FILES = [
     '.commitlintrc',
     '.commitlintrc.json',
@@ -12385,7 +12618,16 @@ IMPORTANT RULES:
                         ? `${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, {
+                const budgetedPrompt = await enforcePromptBudget({
+                    prompt,
+                    variables: currentVariables,
+                    tokenizer,
+                    maxTokens: config.service.tokenLimit || 2048,
+                });
+                if (budgetedPrompt.truncated) {
+                    logger.verbose(`Rendered prompt exceeded token budget; trimmed summary to ${budgetedPrompt.promptTokenCount} tokens.`, { color: 'yellow' });
+                }
+                const commitMsg = await executeChainWithSchema(schema, llm, prompt, budgetedPrompt.variables, {
                     retryOptions: {
                         maxAttempts,
                         onRetry: (attempt, error) => {
@@ -12530,10 +12772,67 @@ IMPORTANT RULES:
     handleResult({
         result: commitMsg,
         interactiveModeCallback: async (result) => {
-            await createCommit(result, git, () => {
-                logger.log('⚠️  Pre-commit hook modified files. Staging changes and retrying commit...', { color: 'yellow' });
-            });
-            logSuccess();
+            const noVerify = argv.noVerify || config.noVerify || false;
+            const attemptCommit = async (skipHooks) => {
+                try {
+                    await createCommit(result, git, () => {
+                        logger.log('⚠️  Pre-commit hook modified files. Staging changes and retrying commit...', { color: 'yellow' });
+                    }, { noVerify: skipHooks });
+                    logSuccess();
+                }
+                catch (error) {
+                    if (error instanceof PreCommitHookError) {
+                        // Display friendly hook failure output
+                        logger.log('\n✖ Commit blocked by pre-commit hook', { color: 'red' });
+                        logger.log('\nHook output:', { color: 'yellow' });
+                        logger.log(SEPERATOR);
+                        logger.log(error.hookOutput);
+                        logger.log(SEPERATOR);
+                        if (INTERACTIVE) {
+                            const { select } = await import('@inquirer/prompts');
+                            const choice = await select({
+                                message: 'How would you like to proceed?',
+                                choices: [
+                                    {
+                                        name: '🔄 Retry',
+                                        value: 'retry',
+                                        description: 'Fix the issues above and retry the commit',
+                                    },
+                                    {
+                                        name: '⚠️  Skip hooks',
+                                        value: 'skip',
+                                        description: 'Retry with --no-verify to bypass pre-commit hooks (use with care)',
+                                    },
+                                    {
+                                        name: '💣 Abort',
+                                        value: 'abort',
+                                        description: 'Abort the commit',
+                                    },
+                                ],
+                            });
+                            if (choice === 'retry') {
+                                await attemptCommit(false);
+                            }
+                            else if (choice === 'skip') {
+                                logger.log('⚠️  Skipping hooks with --no-verify...', { color: 'yellow' });
+                                await attemptCommit(true);
+                            }
+                            else {
+                                logger.log('\nCommit aborted.', { color: 'red' });
+                                process.exit(1);
+                            }
+                        }
+                        else {
+                            logger.log('\nFix the issues above and try again, or use --no-verify to skip hooks.', { color: 'yellow' });
+                            process.exit(1);
+                        }
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            };
+            await attemptCommit(noVerify);
         },
         mode: MODE,
     });