git-coco 0.31.1 → 0.33.0

package/dist/index.esm.mjs

@@ -18,10 +18,11 @@ import prettyMilliseconds from 'pretty-ms';
 import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatOllama } from '@langchain/ollama';
 import { ChatOpenAI } from '@langchain/openai';
-import { StructuredOutputParser, StringOutputParser, BaseOutputParser } from '@langchain/core/output_parsers';
-import { simpleGit } from 'simple-git';
+import { StructuredOutputParser, BaseOutputParser, StringOutputParser } from '@langchain/core/output_parsers';
+import { minimatch } from 'minimatch';
+import { simpleGit, GitError } from 'simple-git';
 import { Document, BaseDocumentTransformer } from '@langchain/core/documents';
-import { createTwoFilesPatch } from 'diff';
+import { createTwoFilesPatch, parsePatch, formatPatch } from 'diff';
 import { ensureConfig, Runnable } from '@langchain/core/runnables';
 import { BaseLangChain, BaseLanguageModel } from '@langchain/core/language_models/base';
 import { RUN_KEY } from '@langchain/core/outputs';
@@ -35,9 +36,8 @@ import '@langchain/core/utils/json_schema';
 import '@langchain/core/utils/json_patch';
 import '@langchain/core/utils/env';
 import '@langchain/core/utils/async_caller';
-import { minimatch } from 'minimatch';
 import { encoding_for_model } from 'tiktoken';
-import { exec, spawn } from 'child_process';
+import { spawn, exec } from 'child_process';
 import * as readline from 'readline';
 import { pathToFileURL } from 'url';
 
@@ -46,7 +46,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.31.1";
+const BUILD_VERSION = "0.33.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -446,7 +446,7 @@ function getDefaultServiceConfigFromAlias(provider, model) {
     }
 }
 
-const DEFAULT_IGNORED_FILES = [
+const DEFAULT_IGNORED_FILES$1 = [
     'package-lock.json',
     'yarn.lock',
     'pnpm-lock.yaml',
@@ -454,7 +454,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 --';
 /**
@@ -468,8 +468,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.
@@ -501,6 +501,8 @@ function loadEnvConfig(config) {
         'COCO_SERVICE_REQUEST_OPTIONS_TIMEOUT',
         'COCO_SERVICE_REQUEST_OPTIONS_MAX_RETRIES',
         'COCO_SERVICE_FIELDS',
+        'COCO_SERVICE_DYNAMIC_MODELS',
+        'COCO_SERVICE_DYNAMIC_MODEL_PREFERENCE',
     ];
     envKeys.forEach((key) => {
         const envVarName = toEnvVarName(key);
@@ -515,7 +517,9 @@ function loadEnvConfig(config) {
             key === 'COCO_SERVICE_ENDPOINT' ||
             key === 'COCO_SERVICE_REQUEST_OPTIONS_TIMEOUT' ||
             key === 'COCO_SERVICE_REQUEST_OPTIONS_MAX_RETRIES' ||
-            key === 'COCO_SERVICE_FIELDS') {
+            key === 'COCO_SERVICE_FIELDS' ||
+            key === 'COCO_SERVICE_DYNAMIC_MODELS' ||
+            key === 'COCO_SERVICE_DYNAMIC_MODEL_PREFERENCE') {
             // NOTE: We want to ensure that the service object is always defined
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
@@ -570,6 +574,12 @@ function handleServiceEnvVar(service, key, value) {
         case 'COCO_SERVICE_FIELDS':
             service.fields = value;
             break;
+        case 'COCO_SERVICE_DYNAMIC_MODELS':
+            service.dynamicModels = value;
+            break;
+        case 'COCO_SERVICE_DYNAMIC_MODEL_PREFERENCE':
+            service.dynamicModelPreference = value;
+            break;
     }
 }
 function parseEnvValue(key, value) {
@@ -978,7 +988,7 @@ const schema$1 = {
                     "$ref": "#/definitions/LLMProvider"
                 },
                 "model": {
-                    "$ref": "#/definitions/LLMModel"
+                    "$ref": "#/definitions/ConfiguredLLMModel"
                 },
                 "baseURL": {
                     "type": "string",
@@ -1670,6 +1680,15 @@ const schema$1 = {
                     "type": "number",
                     "description": "The maximum number of attempts for schema parsing with retry logic.",
                     "default": 3
+                },
+                "dynamicModels": {
+                    "$ref": "#/definitions/DynamicModelProfile",
+                    "description": "Optional task-to-model overrides used when model is set to \"dynamic\"."
+                },
+                "dynamicModelPreference": {
+                    "$ref": "#/definitions/DynamicModelPreference",
+                    "description": "Default dynamic routing preference when model is set to \"dynamic\".",
+                    "default": "balanced"
                 }
             },
             "required": [
@@ -1686,6 +1705,17 @@ const schema$1 = {
                 "anthropic"
             ]
         },
+        "ConfiguredLLMModel": {
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/LLMModel"
+                },
+                {
+                    "type": "string",
+                    "const": "dynamic"
+                }
+            ]
+        },
         "LLMModel": {
             "anyOf": [
                 {
@@ -1983,6 +2013,41 @@ const schema$1 = {
                 null
             ]
         },
+        "DynamicModelProfile": {
+            "type": "object",
+            "properties": {
+                "summarize": {
+                    "$ref": "#/definitions/LLMModel"
+                },
+                "commit": {
+                    "$ref": "#/definitions/LLMModel"
+                },
+                "changelog": {
+                    "$ref": "#/definitions/LLMModel"
+                },
+                "review": {
+                    "$ref": "#/definitions/LLMModel"
+                },
+                "recap": {
+                    "$ref": "#/definitions/LLMModel"
+                },
+                "repair": {
+                    "$ref": "#/definitions/LLMModel"
+                },
+                "largeDiff": {
+                    "$ref": "#/definitions/LLMModel"
+                }
+            },
+            "additionalProperties": false
+        },
+        "DynamicModelPreference": {
+            "type": "string",
+            "enum": [
+                "cost",
+                "balanced",
+                "quality"
+            ]
+        },
         "OllamaLLMService": {
             "type": "object",
             "additionalProperties": false,
@@ -1991,7 +2056,7 @@ const schema$1 = {
                     "$ref": "#/definitions/LLMProvider"
                 },
                 "model": {
-                    "$ref": "#/definitions/LLMModel"
+                    "$ref": "#/definitions/ConfiguredLLMModel"
                 },
                 "endpoint": {
                     "type": "string"
@@ -2711,6 +2776,15 @@ const schema$1 = {
                     "type": "number",
                     "description": "The maximum number of attempts for schema parsing with retry logic.",
                     "default": 3
+                },
+                "dynamicModels": {
+                    "$ref": "#/definitions/DynamicModelProfile",
+                    "description": "Optional task-to-model overrides used when model is set to \"dynamic\"."
+                },
+                "dynamicModelPreference": {
+                    "$ref": "#/definitions/DynamicModelPreference",
+                    "description": "Default dynamic routing preference when model is set to \"dynamic\".",
+                    "default": "balanced"
                 }
             },
             "required": [
@@ -2733,7 +2807,7 @@ const schema$1 = {
                     "$ref": "#/definitions/LLMProvider"
                 },
                 "model": {
-                    "$ref": "#/definitions/LLMModel"
+                    "$ref": "#/definitions/ConfiguredLLMModel"
                 },
                 "fields": {
                     "type": "object",
@@ -2863,6 +2937,15 @@ const schema$1 = {
                     "type": "number",
                     "description": "The maximum number of attempts for schema parsing with retry logic.",
                     "default": 3
+                },
+                "dynamicModels": {
+                    "$ref": "#/definitions/DynamicModelProfile",
+                    "description": "Optional task-to-model overrides used when model is set to \"dynamic\"."
+                },
+                "dynamicModelPreference": {
+                    "$ref": "#/definitions/DynamicModelPreference",
+                    "description": "Default dynamic routing preference when model is set to \"dynamic\".",
+                    "default": "balanced"
                 }
             },
             "required": [
@@ -6929,11 +7012,11 @@ const ChangelogResponseSchema = objectType({
     title: stringType(),
     content: stringType(),
 });
-const command$4 = 'changelog';
+const command$5 = 'changelog';
 /**
  * Command line options via yargs
  */
-const options$4 = {
+const options$5 = {
     range: {
         type: 'string',
         alias: 'r',
@@ -6980,8 +7063,8 @@ const options$4 = {
         description: 'Toggle interactive mode',
     },
 };
-const builder$4 = (yargs) => {
-    return yargs.options(options$4).usage(getCommandUsageHeader(command$4));
+const builder$5 = (yargs) => {
+    return yargs.options(options$5).usage(getCommandUsageHeader(command$5));
 };
 
 /**
@@ -7181,6 +7264,212 @@ function getLlm(provider, model, config) {
     }
 }
 
+const OPENAI_DYNAMIC_DEFAULTS = {
+    cost: {
+        summarize: 'gpt-4.1-nano',
+        commit: 'gpt-4.1-mini',
+        changelog: 'gpt-4.1-mini',
+        review: 'gpt-4.1-mini',
+        recap: 'gpt-4.1-nano',
+        repair: 'gpt-4.1-mini',
+        largeDiff: 'gpt-4.1',
+    },
+    balanced: {
+        summarize: 'gpt-4.1-mini',
+        commit: 'gpt-4.1-mini',
+        changelog: 'gpt-4.1',
+        review: 'gpt-4.1',
+        recap: 'gpt-4.1-mini',
+        repair: 'gpt-4.1',
+        largeDiff: 'gpt-4.1',
+    },
+    quality: {
+        summarize: 'gpt-4.1-mini',
+        commit: 'gpt-4.1',
+        changelog: 'gpt-4.1',
+        review: 'gpt-4.1',
+        recap: 'gpt-4.1',
+        repair: 'gpt-4.1',
+        largeDiff: 'gpt-4.1',
+    },
+};
+const ANTHROPIC_DYNAMIC_DEFAULTS = {
+    cost: {
+        summarize: 'claude-3-5-haiku-latest',
+        commit: 'claude-3-5-haiku-latest',
+        changelog: 'claude-3-5-sonnet-latest',
+        review: 'claude-3-5-sonnet-latest',
+        recap: 'claude-3-5-haiku-latest',
+        repair: 'claude-3-5-sonnet-latest',
+        largeDiff: 'claude-3-5-sonnet-latest',
+    },
+    balanced: {
+        summarize: 'claude-3-5-haiku-latest',
+        commit: 'claude-3-5-sonnet-latest',
+        changelog: 'claude-3-5-sonnet-latest',
+        review: 'claude-3-7-sonnet-latest',
+        recap: 'claude-3-5-sonnet-latest',
+        repair: 'claude-3-7-sonnet-latest',
+        largeDiff: 'claude-3-7-sonnet-latest',
+    },
+    quality: {
+        summarize: 'claude-3-5-sonnet-latest',
+        commit: 'claude-3-7-sonnet-latest',
+        changelog: 'claude-3-7-sonnet-latest',
+        review: 'claude-sonnet-4-0',
+        recap: 'claude-3-7-sonnet-latest',
+        repair: 'claude-sonnet-4-0',
+        largeDiff: 'claude-sonnet-4-0',
+    },
+};
+const OLLAMA_DYNAMIC_DEFAULTS = {
+    cost: {
+        summarize: 'llama3.2:3b',
+        commit: 'llama3.1:8b',
+        changelog: 'llama3.1:8b',
+        review: 'qwen2.5-coder:7b',
+        recap: 'llama3.2:3b',
+        repair: 'qwen2.5-coder:7b',
+        largeDiff: 'qwen2.5-coder:14b',
+    },
+    balanced: {
+        summarize: 'llama3.1:8b',
+        commit: 'qwen2.5-coder:14b',
+        changelog: 'qwen2.5-coder:14b',
+        review: 'qwen2.5-coder:32b',
+        recap: 'llama3.1:8b',
+        repair: 'qwen2.5-coder:32b',
+        largeDiff: 'qwen2.5-coder:32b',
+    },
+    quality: {
+        summarize: 'qwen2.5-coder:14b',
+        commit: 'qwen2.5-coder:32b',
+        changelog: 'qwen2.5-coder:32b',
+        review: 'qwen2.5-coder:32b',
+        recap: 'qwen2.5-coder:14b',
+        repair: 'qwen2.5-coder:32b',
+        largeDiff: 'qwen2.5-coder:32b',
+    },
+};
+const DYNAMIC_DEFAULTS = {
+    openai: OPENAI_DYNAMIC_DEFAULTS,
+    anthropic: ANTHROPIC_DYNAMIC_DEFAULTS,
+    ollama: OLLAMA_DYNAMIC_DEFAULTS,
+};
+const DYNAMIC_MODEL_TASKS = [
+    'summarize',
+    'commit',
+    'changelog',
+    'review',
+    'recap',
+    'repair',
+    'largeDiff',
+];
+function validateDynamicModelProfile(service) {
+    const dynamicModels = service.dynamicModels;
+    if (!dynamicModels)
+        return;
+    const unknownTasks = Object.keys(dynamicModels).filter((task) => !DYNAMIC_MODEL_TASKS.includes(task));
+    if (unknownTasks.length > 0) {
+        throw new LangChainConfigurationError(`Unknown dynamic model task(s): ${unknownTasks.join(', ')}. Supported tasks: ${DYNAMIC_MODEL_TASKS.join(', ')}`, { unknownTasks, supportedTasks: DYNAMIC_MODEL_TASKS });
+    }
+    Object.entries(dynamicModels).forEach(([task, model]) => {
+        if (typeof model !== 'string' || model.trim() === '' || model === 'dynamic') {
+            throw new LangChainConfigurationError(`Dynamic model override for '${task}' must be a concrete model name`, { task, model });
+        }
+    });
+}
+function resolveDynamicModel(config, task) {
+    const service = config.service;
+    validateDynamicModelProfile(service);
+    if (service.model !== 'dynamic') {
+        return service.model;
+    }
+    const preference = service.dynamicModelPreference || 'balanced';
+    const providerDefaults = DYNAMIC_DEFAULTS[service.provider];
+    const defaultModel = providerDefaults[preference]?.[task];
+    return service.dynamicModels?.[task] || defaultModel;
+}
+function resolveDynamicService(config, task) {
+    const model = resolveDynamicModel(config, task);
+    return {
+        ...config.service,
+        model,
+    };
+}
+
+const telemetryByCommand = new Map();
+function estimatePromptTokens(tokenizer, renderedPrompt) {
+    if (!tokenizer)
+        return undefined;
+    try {
+        return tokenizer(renderedPrompt);
+    }
+    catch {
+        return undefined;
+    }
+}
+function logLlmCall(logger, metadata) {
+    if (!logger)
+        return;
+    recordLlmTelemetry(metadata);
+    const fields = [
+        `task=${metadata.task}`,
+        metadata.command ? `command=${metadata.command}` : undefined,
+        metadata.provider ? `provider=${metadata.provider}` : undefined,
+        metadata.model ? `model=${metadata.model}` : undefined,
+        metadata.retryAttempt ? `retryAttempt=${metadata.retryAttempt}` : undefined,
+        metadata.promptTokens !== undefined ? `promptTokens=${metadata.promptTokens}` : undefined,
+        metadata.elapsedMs !== undefined ? `elapsedMs=${metadata.elapsedMs}` : undefined,
+        metadata.inputDocuments !== undefined ? `inputDocuments=${metadata.inputDocuments}` : undefined,
+        metadata.inputChunks !== undefined ? `inputChunks=${metadata.inputChunks}` : undefined,
+        metadata.parserType ? `parser=${metadata.parserType}` : undefined,
+        metadata.variableKeys?.length ? `variableKeys=${metadata.variableKeys.join(',')}` : undefined,
+    ].filter(Boolean);
+    logger.verbose(`[llm] ${fields.join(' ')}`, { color: 'cyan' });
+}
+function recordLlmTelemetry(metadata) {
+    const command = metadata.command || 'unknown';
+    const current = telemetryByCommand.get(command) || {
+        calls: 0,
+        promptTokens: 0,
+        elapsedMs: 0,
+        inputDocuments: 0,
+        inputChunks: 0,
+        tasks: new Set(),
+        models: new Set(),
+    };
+    current.calls += 1;
+    current.promptTokens += metadata.promptTokens || 0;
+    current.elapsedMs += metadata.elapsedMs || 0;
+    current.inputDocuments += metadata.inputDocuments || 0;
+    current.inputChunks += metadata.inputChunks || 0;
+    current.tasks.add(metadata.task);
+    if (metadata.model) {
+        current.models.add(metadata.model);
+    }
+    telemetryByCommand.set(command, current);
+}
+function logLlmTelemetrySummary(logger, command) {
+    if (!logger)
+        return;
+    const summary = telemetryByCommand.get(command);
+    if (!summary || summary.calls === 0)
+        return;
+    const fields = [
+        `command=${command}`,
+        `calls=${summary.calls}`,
+        summary.promptTokens > 0 ? `promptTokens=${summary.promptTokens}` : undefined,
+        summary.elapsedMs > 0 ? `elapsedMs=${summary.elapsedMs}` : undefined,
+        summary.inputDocuments > 0 ? `inputDocuments=${summary.inputDocuments}` : undefined,
+        summary.inputChunks > 0 ? `inputChunks=${summary.inputChunks}` : undefined,
+        summary.tasks.size > 0 ? `tasks=${[...summary.tasks].join(',')}` : undefined,
+        summary.models.size > 0 ? `models=${[...summary.models].join(',')}` : undefined,
+    ].filter(Boolean);
+    logger.verbose(`[llm:summary] ${fields.join(' ')}`, { color: 'cyan' });
+    telemetryByCommand.delete(command);
+}
+
 /**
  * Creates a PromptTemplate from a template string or returns a fallback template.
  *
@@ -7269,6 +7558,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
  */
@@ -7301,7 +7659,7 @@ function extractLlmInfo(llm) {
  * @throws LangChainExecutionError if the chain execution fails or returns empty results
  * @throws LangChainNetworkError if a network/connection error occurs
  */
-const executeChain = async ({ llm, prompt, variables, parser, provider, endpoint, }) => {
+const executeChain = async ({ llm, prompt, variables, parser, provider, endpoint, logger, tokenizer, metadata, }) => {
     validateRequired(llm, 'llm', 'executeChain');
     validateRequired(prompt, 'prompt', 'executeChain');
     validateRequired(variables, 'variables', 'executeChain');
@@ -7319,8 +7677,21 @@ const executeChain = async ({ llm, prompt, variables, parser, provider, endpoint
     const effectiveProvider = provider || llmInfo.provider;
     const effectiveEndpoint = endpoint || llmInfo.endpoint;
     try {
+        const renderedPrompt = await prompt.format(variables);
+        const promptTokens = estimatePromptTokens(tokenizer, renderedPrompt);
         const chain = prompt.pipe(llm).pipe(parser);
+        const startedAt = Date.now();
         const result = (await chain.invoke(variables));
+        const elapsedMs = Date.now() - startedAt;
+        logLlmCall(logger, {
+            task: metadata?.task || 'chain',
+            provider: effectiveProvider,
+            parserType: parser.constructor.name,
+            variableKeys: Object.keys(variables),
+            promptTokens,
+            elapsedMs,
+            ...metadata,
+        });
         if (result === null || result === undefined) {
             throw new LangChainExecutionError('executeChain: Chain execution returned null or undefined result', { variables, promptInputVariables: prompt.inputVariables });
         }
@@ -7558,6 +7929,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__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
+    });
+    return filteredChanges;
+}
+
 /**
  * Retrieves the SimpleGit instance for the repository.
  * @returns {SimpleGit} The SimpleGit instance.
@@ -7919,116 +8432,18 @@ async function handleResult({ result, mode, interactiveModeCallback }) {
 }
 
 /**
- * Fetches the diff for the given commit ID.
+ * Retrieves the diff between the current branch and a specified target branch.
  *
- * @param commitId The commit ID for which the diff is to be retrieved.
- * @returns A promise that resolves to the diff of the commit.
+ * @param {Object} options - The options for retrieving the diff.
+ * @param {SimpleGit} options.git - The SimpleGit instance.
+ * @param {Logger} options.logger - The logger for logging messages.
+ * @param {string} options.baseBranch - The base branch to compare against.
+ * @param {string} options.headBranch - The head branch to compare.
+ * @param {string[]} options.ignoredFiles - Array of specific files to ignore.
+ * @param {string[]} options.ignoredExtensions - Array of file extensions to ignore.
+ * @returns {Promise<GetChangesResult>} The diff between the current branch and the target branch.
  */
-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.
- *
- * @param {Object} options - The options for retrieving the diff.
- * @param {SimpleGit} options.git - The SimpleGit instance.
- * @param {Logger} options.logger - The logger for logging messages.
- * @param {string} options.baseBranch - The base branch to compare against.
- * @param {string} options.headBranch - The head branch to compare.
- * @param {string[]} options.ignoredFiles - Array of specific files to ignore.
- * @param {string[]} options.ignoredExtensions - Array of file extensions to ignore.
- * @returns {Promise<GetChangesResult>} The diff between the current branch and the target branch.
- */
-async function getDiffForBranch({ git, logger, baseBranch, headBranch, options, }) {
+async function getDiffForBranch({ git, logger, baseBranch, headBranch, options, }) {
     try {
         logger?.verbose(`Getting diff for branches: baseBranch="${baseBranch}", headBranch="${headBranch}"`, {
             color: 'blue',
@@ -8096,726 +8511,239 @@ 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.
-
-## 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}}
+/**
+ * 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('/');
+}
 
-"""{{summary}}"""`;
-const inputVariables$2 = [
-    'format_instructions',
-    'summary',
-    'additional_context',
-    'author_instructions',
-];
-const CHANGELOG_PROMPT = new PromptTemplate({
-    template: template$3,
-    inputVariables: inputVariables$2,
-});
+async function summarize(documents, { chain, textSplitter, options, logger, tokenizer, metadata }) {
+    const { returnIntermediateSteps = false } = options || {};
+    const docs = await textSplitter.splitDocuments(documents.map((doc) => new Document(doc)));
+    const promptTokens = tokenizer
+        ? docs.reduce((sum, doc) => sum + tokenizer(doc.pageContent), 0)
+        : undefined;
+    const startedAt = Date.now();
+    const res = await chain.invoke({
+        input_documents: docs,
+        returnIntermediateSteps,
+    });
+    const elapsedMs = Date.now() - startedAt;
+    logLlmCall(logger, {
+        task: 'summarize',
+        promptTokens,
+        elapsedMs,
+        inputDocuments: documents.length,
+        inputChunks: docs.length,
+        ...metadata,
+    });
+    if (res.error)
+        throw new Error(res.error);
+    return res.text && res.text.trim();
+}
 
-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, logger, metadata, }) {
+    try {
+        const fileSummary = await summarize([
+            {
+                pageContent: fileDiff.diff,
+                metadata: {
+                    file: fileDiff.file,
+                    summary: fileDiff.summary,
+                },
+            },
+        ], {
+            chain,
+            textSplitter,
+            tokenizer,
+            logger,
+            metadata: {
+                ...metadata,
+                task: 'summarize-large-file',
+            },
+            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, metadata } = 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 });
         }
-        return {
-            branch: branchName,
-            commits: commitsWithDiffText,
-            withDiff: argv.withDiff,
-        };
+    });
+    if (filesToSummarize.length === 0) {
+        return results;
     }
-    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 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 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,
+    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, logger, metadata }), 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;
     });
-};
-
-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';
+    return results;
+}
 /**
- * Command line options via yargs
+ * Pre-process a DiffNode tree, summarizing large files at the leaf level.
+ * Returns a new DiffNode with updated token counts.
  */
-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));
-};
+async function preprocessLargeFiles(rootNode, options) {
+    // Collect all diffs from the tree
+    const allDiffs = [];
+    function collectDiffs(node) {
+        allDiffs.push(...node.diffs);
+        node.children.forEach(collectDiffs);
+    }
+    collectDiffs(rootNode);
+    // Summarize large files
+    const processedDiffs = await summarizeLargeFiles(allDiffs, options);
+    // Create a map for quick lookup
+    const diffMap = new Map();
+    processedDiffs.forEach((diff) => diffMap.set(diff.file, diff));
+    // Rebuild tree with processed diffs
+    function rebuildNode(node) {
+        return {
+            path: node.path,
+            diffs: node.diffs.map((diff) => diffMap.get(diff.file) || diff),
+            children: node.children.map(rebuildNode),
+        };
+    }
+    return rebuildNode(rootNode);
+}
 
 /**
- * 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
+ * Create groups from a given node info.
+ * @param {DiffNode} node - The node info to start grouping.
+ * @returns {DirectoryDiff[]} The groups created.
  */
-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();
+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 fallbackResult = await executeChain({
-                llm,
-                prompt,
-                variables,
-                parser: new StringOutputParser(),
-            });
-            const fallbackText = typeof fallbackResult === 'string' ? fallbackResult : String(fallbackResult);
-            return fallbackParser(fallbackText);
-        }
-        // No fallback available, re-throw the error
-        throw error;
+            groupByPath[path].diffs.push(diff);
+            groupByPath[path].tokenCount += diff.tokenCount;
+        });
+        node.children.forEach(traverse);
     }
+    traverse(node);
+    return Object.values(groupByPath);
 }
-
 /**
- * Utility to repair common JSON formatting issues that LLMs make
- * Specifically handles cases where string values are not properly quoted
+ * Summarize a directory diff asynchronously.
  */
-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;
-    }
+async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer, logger, metadata }) {
     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;
-}
-/**
- * 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);
-}
-
-/**
- * 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('/');
-}
-
-async function summarize(documents, { chain, textSplitter, options }) {
-    const { returnIntermediateSteps = false } = options || {};
-    const docs = await textSplitter.splitDocuments(documents.map((doc) => new 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,
-                },
+        const directorySummary = await summarize(directory.diffs.map((diff) => ({
+            pageContent: diff.diff,
+            metadata: {
+                file: diff.file,
+                summary: diff.summary,
             },
-        ], {
+        })), {
             chain,
             textSplitter,
+            tokenizer,
+            logger,
+            metadata: {
+                ...metadata,
+                task: 'summarize-directory-diff',
+            },
             options: {
-                returnIntermediateSteps: false,
+                returnIntermediateSteps: true,
             },
         });
-        const newTokenCount = tokenizer(fileSummary);
+        const newTokenTotal = tokenizer(directorySummary);
         return {
-            ...fileDiff,
-            diff: fileSummary,
-            tokenCount: newTokenCount,
+            diffs: directory.diffs,
+            path: directory.path,
+            summary: directorySummary,
+            tokenCount: newTokenTotal,
         };
     }
     catch (error) {
-        // On error, return original diff unchanged
-        console.error(`Failed to summarize file ${fileDiff.file}:`, error);
-        return fileDiff;
+        console.error(error);
+        return directory;
     }
 }
 /**
- * Process files in waves to respect concurrency limits.
+ * 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
  */
-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);
+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`;
     }
-    return results;
-}
-/**
- * Pre-summarize individual files that exceed the maxFileTokens threshold.
- * This prevents large files from dominating the token budget and biasing
- * the final commit message toward a single file's changes.
- *
- * @param diffs - Array of file diffs to process
- * @param options - Configuration options for summarization
- * @returns Array of file diffs with large files summarized
- */
-async function summarizeLargeFiles(diffs, options) {
-    const { maxFileTokens, minTokensForSummary, maxConcurrent, tokenizer, logger, chain, textSplitter } = options;
-    // Identify files that need summarization
-    const filesToSummarize = [];
-    const results = [...diffs];
-    diffs.forEach((diff, index) => {
-        if (diff.tokenCount > maxFileTokens && diff.tokenCount >= minTokensForSummary) {
-            filesToSummarize.push({ index, diff });
-        }
-    });
-    if (filesToSummarize.length === 0) {
-        return results;
-    }
-    logger.verbose(`Pre-summarizing ${filesToSummarize.length} large file(s)...`, { color: 'blue' });
-    // Process large files in waves
-    const summarizedFiles = await processInWaves(filesToSummarize, async ({ diff }) => summarizeFileDiff(diff, { chain, textSplitter, tokenizer }), maxConcurrent);
-    // Update results with summarized files
-    summarizedFiles.forEach((summarizedDiff, i) => {
-        const originalIndex = filesToSummarize[i].index;
-        const originalTokens = results[originalIndex].tokenCount;
-        const newTokens = summarizedDiff.tokenCount;
-        logger.verbose(` - ${summarizedDiff.file}: ${originalTokens} -> ${newTokens} tokens`, { color: 'magenta' });
-        results[originalIndex] = summarizedDiff;
-    });
-    return results;
-}
-/**
- * Pre-process a DiffNode tree, summarizing large files at the leaf level.
- * Returns a new DiffNode with updated token counts.
- */
-async function preprocessLargeFiles(rootNode, options) {
-    // Collect all diffs from the tree
-    const allDiffs = [];
-    function collectDiffs(node) {
-        allDiffs.push(...node.diffs);
-        node.children.forEach(collectDiffs);
-    }
-    collectDiffs(rootNode);
-    // Summarize large files
-    const processedDiffs = await summarizeLargeFiles(allDiffs, options);
-    // Create a map for quick lookup
-    const diffMap = new Map();
-    processedDiffs.forEach((diff) => diffMap.set(diff.file, diff));
-    // Rebuild tree with processed diffs
-    function rebuildNode(node) {
-        return {
-            path: node.path,
-            diffs: node.diffs.map((diff) => diffMap.get(diff.file) || diff),
-            children: node.children.map(rebuildNode),
-        };
-    }
-    return rebuildNode(rootNode);
-}
-
-/**
- * Create groups from a given node info.
- * @param {DiffNode} node - The node info to start grouping.
- * @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 };
-            }
-            groupByPath[path].diffs.push(diff);
-            groupByPath[path].tokenCount += diff.tokenCount;
-        });
-        node.children.forEach(traverse);
-    }
-    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,
-            },
-        });
-        const newTokenTotal = tokenizer(directorySummary);
-        return {
-            diffs: directory.diffs,
-            path: directory.path,
-            summary: directorySummary,
-            tokenCount: newTokenTotal,
-        };
-    }
-    catch (error) {
-        console.error(error);
-        return directory;
-    }
-}
-/**
- * Default output formatter for directory diffs.
- *
- * TODO: Future improvements to consider:
- * - Hierarchical output showing file -> directory -> overall summary
- * - Configurable verbosity levels (compact, standard, detailed)
- * - Machine-readable format option (JSON) for programmatic use
- * - Semantic grouping by change type (added/modified/deleted) or feature area
- * - Visual diff indicators showing magnitude of changes
- */
-const defaultOutputCallback = (group) => {
-    let output = `
--------\n* changes in "/${group.path}"\n\n`;
-    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;
-};
+    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.
  */
 async function summarizeInWaves(directories, options) {
-    const { totalTokenCount: initialTotal, maxTokens, minTokensForSummary, maxConcurrent, logger, chain, textSplitter, tokenizer, } = options;
+    const { totalTokenCount: initialTotal, maxTokens, minTokensForSummary, maxConcurrent, logger, chain, textSplitter, tokenizer, metadata, } = options;
     let totalTokenCount = initialTotal;
     const results = [...directories];
     // Create sorted indices by token count (descending) for prioritized processing
@@ -8847,7 +8775,7 @@ async function summarizeInWaves(directories, options) {
         }
         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 })));
+        const waveResults = await Promise.all(wave.map((idx) => summarizeDirectoryDiff(results[idx], { chain, textSplitter, tokenizer, logger, metadata })));
         // Update results and recalculate total
         waveResults.forEach((result, i) => {
             const idx = wave[i];
@@ -8884,10 +8812,25 @@ async function summarizeInWaves(directories, options) {
  * - 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, }) {
+async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, minTokensForSummary = 400, maxFileTokens, maxConcurrent = 6, textSplitter, chain, metadata, 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
+    // 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,
@@ -8897,21 +8840,17 @@ async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 204
         logger,
         chain,
         textSplitter,
+        metadata,
     });
     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 = createDirectoryDiffs(preprocessedNode);
     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}`, {
+    totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
+    logger.verbose(`Total token count after file pre-processing: ${totalTokenCount}`, {
         color: totalTokenCount > maxTokens ? 'yellow' : 'green',
     });
-    // Early exit if already under budget
     if (totalTokenCount <= maxTokens) {
-        logger.verbose(`Already under token budget, skipping summarization.`, { color: 'green' });
+        logger.verbose(`Under token budget after file pre-processing.`, { color: 'green' });
         return directoryDiffs.map(handleOutput).join('');
     }
     // PHASE 3: Wave-based summarization
@@ -8925,17 +8864,41 @@ async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 204
         chain,
         textSplitter,
         tokenizer,
+        metadata,
     });
     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();
+    };
+    return async (operation) => {
+        if (active >= limit) {
+            await new Promise((resolve) => queue.push(resolve));
+        }
+        active++;
+        try {
+            return await operation();
+        }
+        finally {
+            runNext();
+        }
+    };
+}
 /**
  * Asynchronously collect diffs for a given node and its children.
  */
-async function collectDiffs(node, getFileDiff, tokenizer, logger) {
+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(async (nodeFile) => {
+    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)`, {
@@ -8947,9 +8910,9 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger) {
             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 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),
@@ -10745,7 +10708,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}"
@@ -10753,7 +10716,7 @@ const template$2 = `Write a concise summary of the following:
 
 CONCISE SUMMARY:`;
 const DEFAULT_PROMPT = /* @__PURE__ */ new PromptTemplate({
-	template: template$2,
+	template: template$3,
 	inputVariables: ["text"]
 });
 
@@ -10843,7 +10806,7 @@ function isObject(subject) {
 }
 
 
-function toArray(sequence) {
+function toArray$1(sequence) {
   if (Array.isArray(sequence)) return sequence;
   else if (isNothing(sequence)) return [];
 
@@ -10885,7 +10848,7 @@ function isNegativeZero(number) {
 
 var isNothing_1      = isNothing;
 var isObject_1       = isObject;
-var toArray_1        = toArray;
+var toArray_1        = toArray$1;
 var repeat_1         = repeat;
 var isNegativeZero_1 = isNegativeZero;
 var extend_1         = extend;
@@ -11808,87 +11771,753 @@ function constructYamlSet(data) {
   return data !== null ? data : {};
 }
 
-var set = new type('tag:yaml.org,2002:set', {
-  kind: 'mapping',
-  resolve: resolveYamlSet,
-  construct: constructYamlSet
-});
-
-core.extend({
-  implicit: [
-    timestamp,
-    merge
-  ],
-  explicit: [
-    binary,
-    omap,
-    pairs,
-    set
-  ]
-});
-
-function simpleEscapeSequence(c) {
-  /* eslint-disable indent */
-  return (c === 0x30/* 0 */) ? '\x00' :
-        (c === 0x61/* a */) ? '\x07' :
-        (c === 0x62/* b */) ? '\x08' :
-        (c === 0x74/* t */) ? '\x09' :
-        (c === 0x09/* Tab */) ? '\x09' :
-        (c === 0x6E/* n */) ? '\x0A' :
-        (c === 0x76/* v */) ? '\x0B' :
-        (c === 0x66/* f */) ? '\x0C' :
-        (c === 0x72/* r */) ? '\x0D' :
-        (c === 0x65/* e */) ? '\x1B' :
-        (c === 0x20/* Space */) ? ' ' :
-        (c === 0x22/* " */) ? '\x22' :
-        (c === 0x2F/* / */) ? '/' :
-        (c === 0x5C/* \ */) ? '\x5C' :
-        (c === 0x4E/* N */) ? '\x85' :
-        (c === 0x5F/* _ */) ? '\xA0' :
-        (c === 0x4C/* L */) ? '\u2028' :
-        (c === 0x50/* P */) ? '\u2029' : '';
+var set = new type('tag:yaml.org,2002:set', {
+  kind: 'mapping',
+  resolve: resolveYamlSet,
+  construct: constructYamlSet
+});
+
+core.extend({
+  implicit: [
+    timestamp,
+    merge
+  ],
+  explicit: [
+    binary,
+    omap,
+    pairs,
+    set
+  ]
+});
+
+function simpleEscapeSequence(c) {
+  /* eslint-disable indent */
+  return (c === 0x30/* 0 */) ? '\x00' :
+        (c === 0x61/* a */) ? '\x07' :
+        (c === 0x62/* b */) ? '\x08' :
+        (c === 0x74/* t */) ? '\x09' :
+        (c === 0x09/* Tab */) ? '\x09' :
+        (c === 0x6E/* n */) ? '\x0A' :
+        (c === 0x76/* v */) ? '\x0B' :
+        (c === 0x66/* f */) ? '\x0C' :
+        (c === 0x72/* r */) ? '\x0D' :
+        (c === 0x65/* e */) ? '\x1B' :
+        (c === 0x20/* Space */) ? ' ' :
+        (c === 0x22/* " */) ? '\x22' :
+        (c === 0x2F/* / */) ? '/' :
+        (c === 0x5C/* \ */) ? '\x5C' :
+        (c === 0x4E/* N */) ? '\x85' :
+        (c === 0x5F/* _ */) ? '\xA0' :
+        (c === 0x4C/* L */) ? '\u2028' :
+        (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);
+}
+
+async function fileChangeParser({ changes, commit, options: { tokenizer, git, llm: model, logger, maxTokens, minTokensForSummary, maxFileTokens, maxConcurrent, metadata, }, }) {
+    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,
+        metadata,
+    });
+    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 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 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$5 = async (argv, logger) => {
+    const config = loadConfig(argv);
+    const git = getRepo();
+    const key = getApiKeyForModel(config);
+    const { provider } = getModelAndProviderFromConfig(config);
+    const changelogService = resolveDynamicService(config, 'changelog');
+    const summaryService = resolveDynamicService(config, argv.withDiff || argv.onlyDiff ? 'largeDiff' : 'summarize');
+    const model = changelogService.model;
+    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, service: changelogService });
+    const summaryLlm = getLlm(provider, summaryService.model, { ...config, service: summaryService });
+    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: summaryLlm,
+                                logger,
+                                maxTokens: config.service.tokenLimit,
+                                minTokensForSummary: config.service.minTokensForSummary,
+                                maxFileTokens: config.service.maxFileTokens,
+                                maxConcurrent: config.service.maxConcurrent,
+                                metadata: {
+                                    command: 'changelog',
+                                    provider,
+                                    model: String(summaryService.model),
+                                },
+                            },
+                        })
+                        : 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: summaryLlm,
+                    logger,
+                    maxTokens: config.service.tokenLimit,
+                    minTokensForSummary: config.service.minTokensForSummary,
+                    maxFileTokens: config.service.maxFileTokens,
+                    maxConcurrent: config.service.maxConcurrent,
+                    metadata: {
+                        command: 'changelog',
+                        provider,
+                        model: String(summaryService.model),
+                    },
+                },
+            });
+            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,
+                logger,
+                tokenizer,
+                metadata: {
+                    task: argv.withDiff ? 'changelog-with-diff' : argv.onlyDiff ? 'changelog-only-diff' : 'changelog',
+                    command: 'changelog',
+                    provider,
+                    model: String(model),
+                },
+            });
+            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,
+    });
+    logLlmTelemetrySummary(logger, 'changelog');
+};
+
+var changelog = {
+    command: command$5,
+    desc: 'Generate a changelog from current or target branch, provided commit range, or since the last tag.',
+    builder: builder$5,
+    handler: commandExecutor(handler$5),
+    options: options$5,
+};
+
+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$4 = 'commit';
+/**
+ * Command line options via yargs
+ */
+const options$4 = {
+    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',
+    },
+    split: {
+        description: 'Group staged changes into multiple related commit proposals',
+        type: 'boolean',
+        default: false,
+    },
+    plan: {
+        description: 'Only print a commit split plan without changing git state',
+        type: 'boolean',
+        default: false,
+    },
+    apply: {
+        description: 'Apply a generated file-level or hunk-level commit split plan and create commits',
+        type: 'boolean',
+        default: false,
+    },
+};
+const builder$4 = (yargs) => {
+    return yargs.options(options$4).usage(getCommandUsageHeader(command$4));
+};
+
+/**
+ * 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, logger, tokenizer, metadata, ...parserOptions } = options;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parser = createSchemaParser(schema, llm, parserOptions);
+    let attempt = 0;
+    const operation = async () => {
+        attempt++;
+        const result = await executeChain({
+            llm,
+            prompt,
+            variables,
+            parser,
+            logger,
+            tokenizer,
+            metadata: {
+                task: 'schema-chain',
+                ...metadata,
+                retryAttempt: attempt,
+            },
+        });
+        return result;
+    };
+    try {
+        return await withRetry(operation, retryOptions);
+    }
+    catch (error) {
+        if (fallbackParser) {
+            if (onFallback) {
+                onFallback();
+            }
+            const fallbackResult = await executeChain({
+                llm,
+                prompt,
+                variables,
+                parser: new StringOutputParser(),
+                logger,
+                tokenizer,
+                metadata: {
+                    task: 'schema-chain-fallback',
+                    ...metadata,
+                },
+            });
+            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;
 }
-
-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);
+/**
+ * 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);
 }
 
-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;
+/**
+ * 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,
@@ -11908,15 +12537,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)) {
@@ -11926,7 +12559,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 GitError) {
+            throw new PreCommitHookError(error.message);
         }
         throw error;
     }
@@ -11939,7 +12577,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 = [];
@@ -12019,41 +12657,19 @@ async function getPreviousCommits(options) {
     try {
         const logs = await git.log({ maxCount: count });
         if (!logs || logs.total === 0) {
-            return '';
-        }
-        // Format the commit logs
-        const formattedLogs = logs.all.map((commit) => {
-            return formatSingleCommit(commit);
-        }).join('\n\n');
-        return formattedLogs;
-    }
-    catch (error) {
-        console.error(`Error getting previous commits: ${error.message}`);
-        return '';
-    }
-}
-
-/**
- * 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 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;
-    });
-};
+            return '';
+        }
+        // Format the commit logs
+        const formattedLogs = logs.all.map((commit) => {
+            return formatSingleCommit(commit);
+        }).join('\n\n');
+        return formattedLogs;
+    }
+    catch (error) {
+        console.error(`Error getting previous commits: ${error.message}`);
+        return '';
+    }
+}
 
 const COMMITLINT_CONFIG_FILES = [
     '.commitlintrc',
@@ -12153,17 +12769,345 @@ async function noResult$2({ git, logger }) {
     }
 }
 
-const handler$3 = async (argv, logger) => {
+const CommitSplitPlanSchema = objectType({
+    groups: arrayType(objectType({
+        title: stringType().min(1),
+        body: stringType().optional(),
+        rationale: stringType().optional(),
+        files: arrayType(stringType()),
+        hunks: arrayType(stringType()),
+    })
+        .refine((group) => group.files.length > 0 || group.hunks.length > 0, {
+        message: 'Each group must include at least one file or hunk',
+    }))
+        .min(1),
+});
+const COMMIT_SPLIT_PROMPT = PromptTemplate.fromTemplate(`You are helping split staged git changes into a small sequence of coherent commits.
+
+Return ONLY valid JSON matching this schema:
+{{
+  "groups": [
+    {{
+      "title": "conventional commit style title",
+      "body": "commit body",
+      "rationale": "why these files belong together",
+      "files": ["relative/path.ts"],
+      "hunks": ["relative/path.ts::hunk-1"]
+    }}
+  ]
+}}
+
+Rules:
+- Use each staged file exactly once.
+- If a file has hunk IDs and contains unrelated changes, assign every hunk ID exactly once instead of assigning the whole file.
+- Do not list the same file in "files" when assigning that file through "hunks".
+- Only use file paths listed in the staged file inventory.
+- Only use hunk IDs listed in the staged hunk inventory.
+- Prefer 2-5 commits unless the changes are truly all one topic.
+- Keep commit titles concise and understandable.
+- Do not invent files.
+
+Staged file inventory:
+{file_inventory}
+
+Staged hunk inventory:
+{hunk_inventory}
+
+Condensed staged diff:
+{summary}
+
+Additional context:
+{additional_context}`);
+function isCommitSplitCommand(argv) {
+    return Boolean(argv.split || argv.plan || argv.apply || argv._.includes('split'));
+}
+function formatCommitSplitPlan(plan) {
+    return plan.groups
+        .map((group, index) => {
+        const body = group.body ? `\n\n${group.body}` : '';
+        const rationale = group.rationale ? `\n\nRationale: ${group.rationale}` : '';
+        const files = (group.files || []).map((file) => `- ${file}`).join('\n');
+        const hunks = (group.hunks || []).map((hunk) => `- ${hunk}`).join('\n');
+        const sections = [
+            files ? `Files:\n${files}` : undefined,
+            hunks ? `Hunks:\n${hunks}` : undefined,
+        ].filter(Boolean);
+        return `## ${index + 1}. ${group.title}${body}${rationale}\n\n${sections.join('\n\n')}`;
+    })
+        .join('\n\n---\n\n');
+}
+function getStagedFileSet(changes) {
+    return new Set(changes.map((change) => change.filePath));
+}
+function getGroupFiles(group) {
+    return group.files || [];
+}
+function getGroupHunks(group) {
+    return group.hunks || [];
+}
+function hunkHeader(hunk) {
+    return `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
+}
+function hunkPreview(hunk) {
+    return hunk.lines
+        .filter((line) => line.startsWith('+') || line.startsWith('-'))
+        .slice(0, 6)
+        .join('\n');
+}
+async function collectHunkInventory(staged, git) {
+    const hunks = [];
+    const byId = new Map();
+    const byFile = new Map();
+    for (const change of staged) {
+        if (change.status !== 'modified') {
+            continue;
+        }
+        const diff = await git.diff(['--staged', '--', change.filePath]);
+        const [patch] = parsePatch(diff);
+        if (!patch || patch.hunks.length === 0) {
+            continue;
+        }
+        patch.hunks.forEach((hunk, index) => {
+            const stagedHunk = {
+                id: `${change.filePath}::hunk-${index + 1}`,
+                filePath: change.filePath,
+                patch,
+                hunk,
+                header: hunkHeader(hunk),
+                preview: hunkPreview(hunk),
+            };
+            hunks.push(stagedHunk);
+            byId.set(stagedHunk.id, stagedHunk);
+            byFile.set(change.filePath, [...(byFile.get(change.filePath) || []), stagedHunk]);
+        });
+    }
+    return { hunks, byId, byFile };
+}
+function formatHunkInventory(inventory) {
+    if (inventory.hunks.length === 0) {
+        return 'No hunk-level inventory available. Use file-level groups.';
+    }
+    return inventory.hunks
+        .map((hunk) => {
+        const preview = hunk.preview ? `\n${hunk.preview}` : '';
+        return `- ${hunk.id}: ${hunk.header}${preview}`;
+    })
+        .join('\n');
+}
+function validatePlanForStagedFiles(plan, staged, hunkInventory) {
+    const stagedFiles = getStagedFileSet(staged);
+    const seen = new Set();
+    const seenHunks = new Set();
+    const unknown = [];
+    const duplicate = [];
+    const unknownHunks = [];
+    const duplicateHunks = [];
+    plan.groups.forEach((group) => {
+        getGroupFiles(group).forEach((file) => {
+            if (!stagedFiles.has(file)) {
+                unknown.push(file);
+                return;
+            }
+            if (seen.has(file)) {
+                duplicate.push(file);
+                return;
+            }
+            seen.add(file);
+        });
+        getGroupHunks(group).forEach((hunkId) => {
+            const hunk = hunkInventory?.byId.get(hunkId);
+            if (!hunk) {
+                unknownHunks.push(hunkId);
+                return;
+            }
+            if (seenHunks.has(hunkId)) {
+                duplicateHunks.push(hunkId);
+                return;
+            }
+            seenHunks.add(hunkId);
+        });
+    });
+    const hunkCoveredFiles = new Set([...seenHunks].map((hunkId) => hunkInventory?.byId.get(hunkId)?.filePath));
+    const mixedFiles = [...seen].filter((file) => hunkCoveredFiles.has(file));
+    const partiallyCoveredFiles = [...hunkCoveredFiles]
+        .filter((file) => Boolean(file))
+        .filter((file) => {
+        const fileHunks = hunkInventory?.byFile.get(file) || [];
+        return fileHunks.some((hunk) => !seenHunks.has(hunk.id));
+    });
+    const missing = [...stagedFiles].filter((file) => !seen.has(file) && !hunkCoveredFiles.has(file));
+    if (unknown.length ||
+        duplicate.length ||
+        unknownHunks.length ||
+        duplicateHunks.length ||
+        mixedFiles.length ||
+        partiallyCoveredFiles.length ||
+        missing.length) {
+        throw new Error([
+            unknown.length ? `unknown files: ${unknown.join(', ')}` : undefined,
+            duplicate.length ? `duplicate files: ${duplicate.join(', ')}` : undefined,
+            unknownHunks.length ? `unknown hunks: ${unknownHunks.join(', ')}` : undefined,
+            duplicateHunks.length ? `duplicate hunks: ${duplicateHunks.join(', ')}` : undefined,
+            mixedFiles.length ? `files assigned both as whole files and hunks: ${mixedFiles.join(', ')}` : undefined,
+            partiallyCoveredFiles.length
+                ? `files with only some hunks assigned: ${partiallyCoveredFiles.join(', ')}`
+                : undefined,
+            missing.length ? `missing files: ${missing.join(', ')}` : undefined,
+        ]
+            .filter(Boolean)
+            .join('; '));
+    }
+}
+function assertNoUnstagedOverlap(plan, changes, hunkInventory) {
+    const hunkFiles = new Set(plan.groups.flatMap((group) => getGroupHunks(group)
+        .map((hunkId) => hunkInventory?.byId.get(hunkId)?.filePath)
+        .filter((file) => Boolean(file))));
+    const plannedFiles = new Set(plan.groups
+        .flatMap((group) => getGroupFiles(group))
+        .filter((file) => !hunkFiles.has(file)));
+    const overlapping = [...(changes.unstaged || []), ...(changes.untracked || [])]
+        .map((change) => change.filePath)
+        .filter((file) => plannedFiles.has(file));
+    if (overlapping.length > 0) {
+        throw new Error(`Cannot apply split plan because these files also have unstaged or untracked changes: ${overlapping.join(', ')}`);
+    }
+}
+function buildPatchForHunks(hunks) {
+    const byFile = new Map();
+    hunks.forEach((hunk) => {
+        byFile.set(hunk.filePath, [...(byFile.get(hunk.filePath) || []), hunk]);
+    });
+    return [...byFile.values()]
+        .map((fileHunks) => {
+        const [firstHunk] = fileHunks;
+        return formatPatch({
+            ...firstHunk.patch,
+            hunks: fileHunks.map((hunk) => hunk.hunk),
+        });
+    })
+        .join('\n');
+}
+async function applyPatchToIndex(patch, git) {
+    const cwd = await git.revparse(['--show-toplevel']);
+    await new Promise((resolve, reject) => {
+        const child = spawn('git', ['apply', '--cached', '-'], {
+            cwd,
+            stdio: ['pipe', 'ignore', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`Failed to apply hunk patch to index: ${stderr.trim()}`));
+        });
+        child.stdin.write(patch);
+        child.stdin.end();
+    });
+}
+async function applyCommitSplitPlan({ plan, changes, hunkInventory, git, logger, noVerify, }) {
+    validatePlanForStagedFiles(plan, changes.staged, hunkInventory);
+    assertNoUnstagedOverlap(plan, changes, hunkInventory);
+    await git.raw(['reset']);
+    for (const group of plan.groups) {
+        const groupFiles = getGroupFiles(group);
+        const groupHunks = getGroupHunks(group).map((hunkId) => hunkInventory.byId.get(hunkId));
+        if (groupFiles.length > 0) {
+            await git.add(groupFiles);
+        }
+        if (groupHunks.length > 0) {
+            const patch = buildPatchForHunks(groupHunks.filter((hunk) => Boolean(hunk)));
+            await applyPatchToIndex(patch, git);
+        }
+        await createCommit(`${group.title}\n\n${group.body}`.trim(), git, undefined, { noVerify });
+        logger.verbose(`Created split commit: ${group.title}`, { color: 'green' });
+    }
+    return `Created ${plan.groups.length} split commit(s).`;
+}
+async function handleCommitSplit({ argv, config, git, logger, tokenizer, llm, }) {
+    const changes = await getChanges({
+        git,
+        options: {
+            ignoredFiles: config.ignoredFiles || undefined,
+            ignoredExtensions: config.ignoredExtensions || undefined,
+        },
+    });
+    if (changes.staged.length === 0) {
+        return 'No staged changes found.';
+    }
+    const hunkInventory = await collectHunkInventory(changes.staged, git);
+    const summary = await fileChangeParser({
+        changes: changes.staged,
+        commit: '--staged',
+        options: {
+            tokenizer,
+            git,
+            llm,
+            logger,
+            maxTokens: config.service.tokenLimit,
+            minTokensForSummary: config.service.minTokensForSummary,
+            maxFileTokens: config.service.maxFileTokens,
+            maxConcurrent: config.service.maxConcurrent,
+            metadata: {
+                command: 'commit',
+                provider: config.service.provider,
+                model: String(config.service.model),
+            },
+        },
+    });
+    const fileInventory = changes.staged
+        .map((change) => `- ${change.filePath}: ${change.status} - ${change.summary}`)
+        .join('\n');
+    const hunkInventoryText = formatHunkInventory(hunkInventory);
+    const plan = await executeChainWithSchema(CommitSplitPlanSchema, llm, COMMIT_SPLIT_PROMPT, {
+        file_inventory: fileInventory,
+        hunk_inventory: hunkInventoryText,
+        summary,
+        additional_context: argv.additional || '',
+    }, {
+        logger,
+        tokenizer,
+        metadata: {
+            task: 'commit-split-plan',
+            command: 'commit',
+            provider: config.service.provider,
+            model: String(config.service.model),
+        },
+    });
+    validatePlanForStagedFiles(plan, changes.staged, hunkInventory);
+    if (argv.apply) {
+        return await applyCommitSplitPlan({
+            plan,
+            changes,
+            hunkInventory,
+            git,
+            logger,
+            noVerify: argv.noVerify || config.noVerify || false,
+        });
+    }
+    return formatCommitSplitPlan(plan);
+}
+
+const handler$4 = async (argv, logger) => {
     const git = getRepo();
     const config = loadConfig(argv);
     const key = getApiKeyForModel(config);
-    const { provider, model } = getModelAndProviderFromConfig(config);
+    const { provider } = getModelAndProviderFromConfig(config);
+    const commitService = resolveDynamicService(config, 'commit');
+    const summaryService = resolveDynamicService(config, 'summarize');
+    const model = commitService.model;
     if (config.service.authentication.type !== 'None' && !key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
     const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
-    const llm = getLlm(provider, model, config);
+    const llm = getLlm(provider, model, { ...config, service: commitService });
+    const summaryLlm = getLlm(provider, summaryService.model, { ...config, service: summaryService });
     const INTERACTIVE = argv.interactive || isInteractive(config);
     if (INTERACTIVE) {
         if (!config.hideCocoBanner) {
@@ -12181,6 +13125,22 @@ const handler$3 = async (argv, logger) => {
     logger.verbose(`→ ${provider} (${model})`, {
         color: 'green',
     });
+    if (isCommitSplitCommand(argv)) {
+        const splitResult = await handleCommitSplit({
+            argv,
+            config,
+            git,
+            logger,
+            tokenizer,
+            llm,
+        });
+        await handleResult({
+            result: splitResult,
+            mode: config.mode || 'stdout',
+        });
+        logLlmTelemetrySummary(logger, 'commit');
+        return;
+    }
     const USE_CONVENTIONAL_COMMITS = config.conventionalCommits || argv.conventional;
     async function factory() {
         if (config.noDiff) {
@@ -12218,12 +13178,17 @@ const handler$3 = async (argv, logger) => {
             options: {
                 tokenizer,
                 git,
-                llm,
+                llm: summaryLlm,
                 logger,
                 maxTokens: config.service.tokenLimit,
                 minTokensForSummary: config.service.minTokensForSummary,
                 maxFileTokens: config.service.maxFileTokens,
                 maxConcurrent: config.service.maxConcurrent,
+                metadata: {
+                    command: 'commit',
+                    provider,
+                    model: String(summaryService.model),
+                },
             },
         });
     }
@@ -12363,7 +13328,24 @@ 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, {
+                    logger,
+                    tokenizer,
+                    metadata: {
+                        task: USE_CONVENTIONAL_COMMITS ? 'commit-message-conventional' : 'commit-message',
+                        command: 'commit',
+                        provider,
+                        model: String(model),
+                    },
                     retryOptions: {
                         maxAttempts,
                         onRetry: (attempt, error) => {
@@ -12508,36 +13490,94 @@ 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,
     });
+    logLlmTelemetrySummary(logger, 'commit');
 };
 
 var commit = {
-    command: command$3,
+    command: command$4,
     desc: 'Summarize the staged changes in a commit message.',
-    builder: builder$3,
-    handler: commandExecutor(handler$3),
-    options: options$3,
+    builder: builder$4,
+    handler: commandExecutor(handler$4),
+    options: options$4,
 };
 
-const command$2 = 'init';
+const command$3 = 'init';
 /**
  * Command line options via yargs
  */
-const options$2 = {
+const options$3 = {
     scope: {
         type: 'string',
         description: 'configure coco for the current user or project?',
         choices: ['global', 'project'],
     },
 };
-const builder$2 = (yargs) => {
-    return yargs.options(options$2).usage(getCommandUsageHeader(command$2));
+const builder$3 = (yargs) => {
+    return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
 };
 
 /**
@@ -12888,7 +13928,7 @@ const questions = {
     }),
 };
 
-const handler$2 = async (argv, logger) => {
+const handler$3 = async (argv, logger) => {
     const options = loadConfig(argv);
     logger.log(LOGO);
     let scope = options?.scope;
@@ -13059,8 +14099,287 @@ async function installCommitlintPackages(scope, logger) {
 }
 
 var init = {
-    command: command$2,
+    command: command$3,
     desc: 'install & configure coco globally or for the current project',
+    builder: builder$3,
+    handler: commandExecutor(handler$3),
+    options: options$3,
+};
+
+const command$2 = 'log';
+const options$2 = {
+    all: {
+        description: 'Show commits from all local and remote refs',
+        type: 'boolean',
+        default: false,
+    },
+    author: {
+        description: 'Filter commits by author',
+        type: 'string',
+    },
+    branch: {
+        description: 'Show commits reachable from a branch or ref',
+        type: 'string',
+        alias: 'b',
+    },
+    commit: {
+        description: 'Show details and changed files for a single commit',
+        type: 'string',
+        alias: 'c',
+    },
+    format: {
+        description: 'Output format',
+        choices: ['table', 'json'],
+        default: 'table',
+    },
+    limit: {
+        description: 'Maximum number of commits to show',
+        type: 'number',
+        default: 30,
+        alias: 'n',
+    },
+    noMerges: {
+        description: 'Exclude merge commits',
+        type: 'boolean',
+        default: false,
+    },
+    path: {
+        description: 'Filter commits by changed path',
+        type: 'array',
+    },
+    since: {
+        description: 'Show commits more recent than a date',
+        type: 'string',
+    },
+    until: {
+        description: 'Show commits older than a date',
+        type: 'string',
+    },
+};
+const builder$2 = (yargs) => {
+    return yargs.options(options$2).usage(getCommandUsageHeader(command$2));
+};
+
+const FIELD_SEPARATOR = '\x1f';
+const LOG_FORMAT = `%x1f%h%x1f%H%x1f%ad%x1f%an%x1f%d%x1f%s`;
+const DETAIL_FORMAT = `%H%x1f%h%x1f%ad%x1f%an%x1f%d%x1f%s%x1f%b`;
+function toArray(value) {
+    if (!value) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function normalizeLimit(limit) {
+    if (!limit || Number.isNaN(limit) || limit < 1) {
+        return 30;
+    }
+    return Math.floor(limit);
+}
+function cleanRefs(refs) {
+    const trimmed = refs.trim();
+    if (!trimmed) {
+        return [];
+    }
+    return trimmed
+        .replace(/^\(/, '')
+        .replace(/\)$/, '')
+        .split(',')
+        .map((ref) => ref.trim())
+        .filter(Boolean);
+}
+function parseLogOutput(output) {
+    return output
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .filter((line) => line.includes(FIELD_SEPARATOR))
+        .map((line) => {
+        const [graph, shortHash, hash, date, author, refs, message] = line.split(FIELD_SEPARATOR);
+        return {
+            graph: graph.trimEnd(),
+            shortHash,
+            hash,
+            date,
+            author,
+            refs: cleanRefs(refs),
+            message,
+        };
+    });
+}
+function parseNameStatus(output) {
+    return output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const [status, firstPath, secondPath] = line.split('\t');
+        if (status.startsWith('R') || status.startsWith('C')) {
+            return {
+                status,
+                oldPath: firstPath,
+                path: secondPath,
+            };
+        }
+        return {
+            status,
+            path: firstPath,
+        };
+    });
+}
+function parseCommitDetail(metadata, files) {
+    const [hash, shortHash, date, author, refs, message, body = ''] = metadata
+        .trimEnd()
+        .split(FIELD_SEPARATOR);
+    return {
+        shortHash,
+        hash,
+        date,
+        author,
+        refs: cleanRefs(refs),
+        message,
+        body: body.trim(),
+        files: parseNameStatus(files),
+    };
+}
+function truncate(value, width) {
+    if (value.length <= width) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, width - 1))}.`;
+}
+function pad(value, width) {
+    return truncate(value, width).padEnd(width, ' ');
+}
+function formatLogTable(entries) {
+    if (entries.length === 0) {
+        return 'No commits found.';
+    }
+    const rows = entries.map((entry) => {
+        const refs = entry.refs.join(', ');
+        return [
+            pad(entry.graph || '*', 8),
+            pad(entry.shortHash, 9),
+            pad(entry.date, 10),
+            pad(entry.author, 18),
+            pad(refs, 26),
+            entry.message,
+        ].join('  ');
+    });
+    return [
+        [
+            pad('Graph', 8),
+            pad('Commit', 9),
+            pad('Date', 10),
+            pad('Author', 18),
+            pad('Refs', 26),
+            'Message',
+        ].join('  '),
+        ...rows,
+    ].join('\n');
+}
+function formatCommitDetail(detail, format) {
+    if (format === 'json') {
+        return JSON.stringify(detail, null, 2);
+    }
+    const refs = detail.refs.length ? ` (${detail.refs.join(', ')})` : '';
+    const body = detail.body ? `\n\n${detail.body}` : '';
+    const files = detail.files.length
+        ? detail.files
+            .map((file) => {
+            if (file.oldPath) {
+                return `  ${file.status}  ${file.oldPath} -> ${file.path}`;
+            }
+            return `  ${file.status}  ${file.path}`;
+        })
+            .join('\n')
+        : '  No changed files found.';
+    return [
+        `commit ${detail.hash}${refs}`,
+        `Author: ${detail.author}`,
+        `Date:   ${detail.date}`,
+        '',
+        `    ${detail.message}${body}`,
+        '',
+        'Changed files:',
+        files,
+    ].join('\n');
+}
+function buildLogArgs(argv) {
+    const args = [
+        'log',
+        '--graph',
+        '--decorate=short',
+        '--date=short',
+        '--color=never',
+        `--max-count=${normalizeLimit(argv.limit)}`,
+        `--pretty=format:${LOG_FORMAT}`,
+    ];
+    if (argv.noMerges) {
+        args.push('--no-merges');
+    }
+    if (argv.author) {
+        args.push(`--author=${argv.author}`);
+    }
+    if (argv.since) {
+        args.push(`--since=${argv.since}`);
+    }
+    if (argv.until) {
+        args.push(`--until=${argv.until}`);
+    }
+    if (argv.all) {
+        args.push('--all');
+    }
+    else if (argv.branch) {
+        args.push(argv.branch);
+    }
+    const paths = toArray(argv.path);
+    if (paths.length > 0) {
+        args.push('--', ...paths);
+    }
+    return args;
+}
+async function getCommitDetail(git, commit) {
+    const metadata = await git.raw([
+        'show',
+        '--no-patch',
+        '--date=short',
+        '--color=never',
+        `--pretty=format:${DETAIL_FORMAT}`,
+        commit,
+    ]);
+    const files = await git.raw([
+        'show',
+        '--name-status',
+        '--format=',
+        '--find-renames',
+        '--color=never',
+        commit,
+    ]);
+    return parseCommitDetail(metadata, files);
+}
+const handler$2 = async (argv) => {
+    const git = getRepo();
+    const mode = argv.interactive ? 'interactive' : 'stdout';
+    const format = argv.format === 'json' ? 'json' : 'table';
+    if (argv.commit) {
+        const detail = await getCommitDetail(git, argv.commit);
+        await handleResult({
+            result: formatCommitDetail(detail, format),
+            mode,
+        });
+        return;
+    }
+    const output = await git.raw(buildLogArgs(argv));
+    const entries = parseLogOutput(output);
+    const result = format === 'json' ? JSON.stringify(entries, null, 2) : formatLogTable(entries);
+    await handleResult({
+        result,
+        mode,
+    });
+};
+
+var log = {
+    command: command$2,
+    desc: 'Explore commit history with a branch graph, filters, and commit details.',
     builder: builder$2,
     handler: commandExecutor(handler$2),
     options: options$2,
@@ -13138,13 +14457,17 @@ const handler$1 = async (argv, logger) => {
     const git = getRepo();
     const config = loadConfig(argv);
     const key = getApiKeyForModel(config);
-    const { provider, model } = getModelAndProviderFromConfig(config);
+    const { provider } = getModelAndProviderFromConfig(config);
+    const recapService = resolveDynamicService(config, 'recap');
+    const summaryService = resolveDynamicService(config, 'summarize');
+    const model = recapService.model;
     if (config.service.authentication.type !== 'None' && !key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
     const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
-    const llm = getLlm(provider, model, config);
+    const llm = getLlm(provider, model, { ...config, service: recapService });
+    const summaryLlm = getLlm(provider, summaryService.model, { ...config, service: summaryService });
     const INTERACTIVE = argv.interactive || isInteractive(config);
     if (INTERACTIVE) {
         if (!config.hideCocoBanner) {
@@ -13175,19 +14498,49 @@ const handler$1 = async (argv, logger) => {
                 const unstagedChanges = await fileChangeParser({
                     changes: unstaged || [],
                     commit: '--unstaged',
-                    options: { tokenizer, git, llm, logger },
+                    options: {
+                        tokenizer,
+                        git,
+                        llm: summaryLlm,
+                        logger,
+                        metadata: {
+                            command: 'recap',
+                            provider,
+                            model: String(summaryService.model),
+                        },
+                    },
                 });
                 const unstagedResponse = `Unstaged changes:\n${unstagedChanges}`;
                 const untrackedChanges = await fileChangeParser({
                     changes: untracked || [],
                     commit: '--untracked',
-                    options: { tokenizer, git, llm, logger },
+                    options: {
+                        tokenizer,
+                        git,
+                        llm: summaryLlm,
+                        logger,
+                        metadata: {
+                            command: 'recap',
+                            provider,
+                            model: String(summaryService.model),
+                        },
+                    },
                 });
                 const untrackedResponse = `Untracked changes:\n${untrackedChanges}`;
                 const stagedChanges = await fileChangeParser({
                     changes: staged,
                     commit: '--staged',
-                    options: { tokenizer, git, llm, logger },
+                    options: {
+                        tokenizer,
+                        git,
+                        llm: summaryLlm,
+                        logger,
+                        metadata: {
+                            command: 'recap',
+                            provider,
+                            model: String(summaryService.model),
+                        },
+                    },
                 });
                 const stagedResponse = `Staged changes:\n${stagedChanges}`;
                 return [unstagedResponse, untrackedResponse, stagedResponse];
@@ -13222,7 +14575,17 @@ const handler$1 = async (argv, logger) => {
                 const branchChanges = await fileChangeParser({
                     changes: changes.staged,
                     commit: baseBranch,
-                    options: { tokenizer, git, llm, logger },
+                    options: {
+                        tokenizer,
+                        git,
+                        llm: summaryLlm,
+                        logger,
+                        metadata: {
+                            command: 'recap',
+                            provider,
+                            model: String(summaryService.model),
+                        },
+                    },
                 });
                 return [branchChanges];
             default:
@@ -13267,15 +14630,34 @@ const handler$1 = async (argv, logger) => {
             try {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 const parser = createSchemaParser(RecapLlmResponseSchema, llm);
+                const variables = {
+                    changes: context,
+                    format_instructions: formatInstructions,
+                    timeframe,
+                };
+                const budgetedPrompt = await enforcePromptBudget({
+                    prompt,
+                    variables,
+                    tokenizer,
+                    maxTokens: config.service.tokenLimit || 2048,
+                    summaryKey: 'changes',
+                });
+                if (budgetedPrompt.truncated) {
+                    logger.verbose(`Rendered prompt exceeded token budget; trimmed changes to ${budgetedPrompt.promptTokenCount} tokens.`, { color: 'yellow' });
+                }
                 const response = await executeChain({
                     llm,
                     prompt,
-                    variables: {
-                        changes: context,
-                        format_instructions: formatInstructions,
-                        timeframe,
-                    },
+                    variables: budgetedPrompt.variables,
                     parser,
+                    logger,
+                    tokenizer,
+                    metadata: {
+                        task: 'recap',
+                        command: 'recap',
+                        provider,
+                        model: String(model),
+                    },
                 });
                 return response ? `${response.title}\n\n${response.summary}` : 'no response';
             }
@@ -13312,6 +14694,7 @@ ${errorMessage}
         },
         mode: MODE,
     });
+    logLlmTelemetrySummary(logger, 'recap');
 };
 
 var recap = {
@@ -13667,13 +15050,17 @@ const handler = async (argv, logger) => {
     const git = getRepo();
     const config = loadConfig(argv);
     const key = getApiKeyForModel(config);
-    const { provider, model } = getModelAndProviderFromConfig(config);
+    const { provider } = getModelAndProviderFromConfig(config);
+    const reviewService = resolveDynamicService(config, 'review');
+    const summaryService = resolveDynamicService(config, argv.branch ? 'largeDiff' : 'summarize');
+    const model = reviewService.model;
     if (config.service.authentication.type !== 'None' && !key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
     const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
-    const llm = getLlm(provider, model, config);
+    const llm = getLlm(provider, model, { ...config, service: reviewService });
+    const summaryLlm = getLlm(provider, summaryService.model, { ...config, service: summaryService });
     const INTERACTIVE = isInteractive(config);
     if (INTERACTIVE) {
         if (!config.hideCocoBanner) {
@@ -13697,7 +15084,17 @@ const handler = async (argv, logger) => {
             const branchChanges = await fileChangeParser({
                 changes: diff.staged,
                 commit: `--branch-diff-${argv.branch}`,
-                options: { tokenizer, git, llm, logger },
+                options: {
+                    tokenizer,
+                    git,
+                    llm: summaryLlm,
+                    logger,
+                    metadata: {
+                        command: 'review',
+                        provider,
+                        model: String(summaryService.model),
+                    },
+                },
             });
             return [branchChanges];
         }
@@ -13719,19 +15116,49 @@ const handler = async (argv, logger) => {
             const unstagedChanges = await fileChangeParser({
                 changes: unstaged || [],
                 commit: '--unstaged',
-                options: { tokenizer, git, llm, logger },
+                options: {
+                    tokenizer,
+                    git,
+                    llm: summaryLlm,
+                    logger,
+                    metadata: {
+                        command: 'review',
+                        provider,
+                        model: String(summaryService.model),
+                    },
+                },
             });
             const unstagedResponse = `Unstaged changes:\n${unstagedChanges}`;
             const untrackedChanges = await fileChangeParser({
                 changes: untracked || [],
                 commit: '--untracked',
-                options: { tokenizer, git, llm, logger },
+                options: {
+                    tokenizer,
+                    git,
+                    llm: summaryLlm,
+                    logger,
+                    metadata: {
+                        command: 'review',
+                        provider,
+                        model: String(summaryService.model),
+                    },
+                },
             });
             const untrackedResponse = `Untracked changes:\n${untrackedChanges}`;
             const stagedChanges = await fileChangeParser({
                 changes: staged,
                 commit: '--staged',
-                options: { tokenizer, git, llm, logger },
+                options: {
+                    tokenizer,
+                    git,
+                    llm: summaryLlm,
+                    logger,
+                    metadata: {
+                        command: 'review',
+                        provider,
+                        model: String(summaryService.model),
+                    },
+                },
             });
             const stagedResponse = `Staged changes:\n${stagedChanges}`;
             return [unstagedResponse, untrackedResponse, stagedResponse];
@@ -13771,14 +15198,33 @@ const handler = async (argv, logger) => {
                 variables: REVIEW_PROMPT.inputVariables,
                 fallback: REVIEW_PROMPT,
             });
+            const variables = {
+                changes: context,
+                format_instructions: formatInstructions,
+            };
+            const budgetedPrompt = await enforcePromptBudget({
+                prompt,
+                variables,
+                tokenizer,
+                maxTokens: config.service.tokenLimit || 2048,
+                summaryKey: 'changes',
+            });
+            if (budgetedPrompt.truncated) {
+                logger.verbose(`Rendered prompt exceeded token budget; trimmed changes to ${budgetedPrompt.promptTokenCount} tokens.`, { color: 'yellow' });
+            }
             const response = await executeChain({
                 llm,
                 prompt,
-                variables: {
-                    changes: context,
-                    format_instructions: formatInstructions,
-                },
+                variables: budgetedPrompt.variables,
                 parser,
+                logger,
+                tokenizer,
+                metadata: {
+                    task: argv.branch ? 'review-branch' : 'review',
+                    command: 'review',
+                    provider,
+                    model: String(model),
+                },
             });
             // sort by severity
             return response.sort((a, b) => b.severity - a.severity);
@@ -13797,6 +15243,7 @@ const handler = async (argv, logger) => {
         },
     });
     const reviewer = new TaskList(recap, { ...config, apiKey: key ?? undefined });
+    logLlmTelemetrySummary(logger, 'review');
     await reviewer.start();
 };
 
@@ -13817,6 +15264,7 @@ y.command(changelog.command, changelog.desc, changelog.builder, changelog.handle
 y.command(recap.command, recap.desc, recap.builder, recap.handler);
 y.command(review.command, review.desc, review.builder, review.handler);
 y.command(init.command, init.desc, init.builder, init.handler);
+y.command(log.command, log.desc, log.builder, log.handler);
 y.help().parse(process.argv.slice(2));
 
 /**
@@ -14268,4 +15716,4 @@ var commitValidationHandler = /*#__PURE__*/Object.freeze({
   handleValidationErrors: handleValidationErrors
 });
 
-export { changelog, commit, init, recap, types };
+export { changelog, commit, init, log, recap, types };