git-coco 0.32.0 → 0.33.0

package/dist/index.js

@@ -68,7 +68,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.32.0";
+const BUILD_VERSION = "0.33.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -523,6 +523,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);
@@ -537,7 +539,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
@@ -592,6 +596,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) {
@@ -1000,7 +1010,7 @@ const schema$1 = {
                     "$ref": "#/definitions/LLMProvider"
                 },
                 "model": {
-                    "$ref": "#/definitions/LLMModel"
+                    "$ref": "#/definitions/ConfiguredLLMModel"
                 },
                 "baseURL": {
                     "type": "string",
@@ -1692,6 +1702,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": [
@@ -1708,6 +1727,17 @@ const schema$1 = {
                 "anthropic"
             ]
         },
+        "ConfiguredLLMModel": {
+            "anyOf": [
+                {
+                    "$ref": "#/definitions/LLMModel"
+                },
+                {
+                    "type": "string",
+                    "const": "dynamic"
+                }
+            ]
+        },
         "LLMModel": {
             "anyOf": [
                 {
@@ -2005,6 +2035,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,
@@ -2013,7 +2078,7 @@ const schema$1 = {
                     "$ref": "#/definitions/LLMProvider"
                 },
                 "model": {
-                    "$ref": "#/definitions/LLMModel"
+                    "$ref": "#/definitions/ConfiguredLLMModel"
                 },
                 "endpoint": {
                     "type": "string"
@@ -2733,6 +2798,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": [
@@ -2755,7 +2829,7 @@ const schema$1 = {
                     "$ref": "#/definitions/LLMProvider"
                 },
                 "model": {
-                    "$ref": "#/definitions/LLMModel"
+                    "$ref": "#/definitions/ConfiguredLLMModel"
                 },
                 "fields": {
                     "type": "object",
@@ -2885,6 +2959,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": [
@@ -6951,11 +7034,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',
@@ -7002,8 +7085,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));
 };
 
 /**
@@ -7203,6 +7286,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.
  *
@@ -7392,7 +7681,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');
@@ -7410,8 +7699,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 });
         }
@@ -8240,13 +8542,26 @@ function getPathFromFilePath(filePath) {
     return filePath.split('/').slice(0, -1).join('/');
 }
 
-async function summarize(documents$1, { chain, textSplitter, options }) {
+async function summarize(documents$1, { chain, textSplitter, options, logger, tokenizer, metadata }) {
     const { returnIntermediateSteps = false } = options || {};
     const docs = await textSplitter.splitDocuments(documents$1.map((doc) => new documents.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$1.length,
+        inputChunks: docs.length,
+        ...metadata,
+    });
     if (res.error)
         throw new Error(res.error);
     return res.text && res.text.trim();
@@ -8255,7 +8570,7 @@ async function summarize(documents$1, { chain, textSplitter, options }) {
 /**
  * Summarize a single file diff that exceeds the token threshold.
  */
-async function summarizeFileDiff(fileDiff, { chain, textSplitter, tokenizer }) {
+async function summarizeFileDiff(fileDiff, { chain, textSplitter, tokenizer, logger, metadata, }) {
     try {
         const fileSummary = await summarize([
             {
@@ -8268,6 +8583,12 @@ async function summarizeFileDiff(fileDiff, { chain, textSplitter, tokenizer }) {
         ], {
             chain,
             textSplitter,
+            tokenizer,
+            logger,
+            metadata: {
+                ...metadata,
+                task: 'summarize-large-file',
+            },
             options: {
                 returnIntermediateSteps: false,
             },
@@ -8307,7 +8628,7 @@ async function processInWaves$1(items, processor, maxConcurrent) {
  * @returns Array of file diffs with large files summarized
  */
 async function summarizeLargeFiles(diffs, options) {
-    const { maxFileTokens, minTokensForSummary, maxConcurrent, tokenizer, logger, chain, textSplitter } = options;
+    const { maxFileTokens, minTokensForSummary, maxConcurrent, tokenizer, logger, chain, textSplitter, metadata } = options;
     // Identify files that need summarization
     const filesToSummarize = [];
     const results = [...diffs];
@@ -8321,7 +8642,7 @@ async function summarizeLargeFiles(diffs, options) {
     }
     logger.verbose(`Pre-summarizing ${filesToSummarize.length} large file(s)...`, { color: 'blue' });
     // Process large files in waves
-    const summarizedFiles = await processInWaves$1(filesToSummarize, async ({ diff }) => summarizeFileDiff(diff, { chain, textSplitter, tokenizer }), maxConcurrent);
+    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;
@@ -8384,7 +8705,7 @@ function createDirectoryDiffs(node) {
 /**
  * Summarize a directory diff asynchronously.
  */
-async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
+async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer, logger, metadata }) {
     try {
         const directorySummary = await summarize(directory.diffs.map((diff) => ({
             pageContent: diff.diff,
@@ -8395,6 +8716,12 @@ async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenize
         })), {
             chain,
             textSplitter,
+            tokenizer,
+            logger,
+            metadata: {
+                ...metadata,
+                task: 'summarize-directory-diff',
+            },
             options: {
                 returnIntermediateSteps: true,
             },
@@ -8438,7 +8765,7 @@ const defaultOutputCallback = (group) => {
  * 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
@@ -8470,7 +8797,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];
@@ -8507,7 +8834,7 @@ 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: Directory grouping & assessment
@@ -8535,6 +8862,7 @@ async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 204
         logger,
         chain,
         textSplitter,
+        metadata,
     });
     logger.stopSpinner('Files pre-processed').stopTimer();
     directoryDiffs = createDirectoryDiffs(preprocessedNode);
@@ -8558,6 +8886,7 @@ async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 204
         chain,
         textSplitter,
         tokenizer,
+        metadata,
     });
     logger.stopSpinner(`Diffs Consolidated`).stopTimer();
     return summarizedDiffs.map(handleOutput).join('');
@@ -10499,7 +10828,7 @@ function isObject(subject) {
 }
 
 
-function toArray(sequence) {
+function toArray$1(sequence) {
   if (Array.isArray(sequence)) return sequence;
   else if (isNothing(sequence)) return [];
 
@@ -10541,7 +10870,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;
@@ -11512,7 +11841,7 @@ for (var i = 0; i < 256; i++) {
   simpleEscapeMap[i] = simpleEscapeSequence(i);
 }
 
-async function fileChangeParser({ changes, commit, options: { tokenizer, git, llm: model, logger, maxTokens, minTokensForSummary, maxFileTokens, maxConcurrent, }, }) {
+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',
@@ -11540,6 +11869,7 @@ async function fileChangeParser({ changes, commit, options: { tokenizer, git, ll
         textSplitter,
         chain: summarizationChain,
         logger,
+        metadata,
     });
     logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
     return summary;
@@ -11612,11 +11942,14 @@ async function processInWaves(items, processor, maxConcurrent = 6) {
     }
     return results;
 }
-const handler$4 = async (argv, logger) => {
+const handler$5 = async (argv, logger) => {
     const config = loadConfig(argv);
     const git = getRepo();
     const key = getApiKeyForModel(config);
-    const { provider, model } = getModelAndProviderFromConfig(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,
@@ -11630,7 +11963,8 @@ const handler$4 = async (argv, logger) => {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
-    const llm = getLlm(provider, model, config);
+    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) {
@@ -11700,12 +12034,17 @@ const handler$4 = 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: 'changelog',
+                                    provider,
+                                    model: String(summaryService.model),
+                                },
                             },
                         })
                         : undefined,
@@ -11726,12 +12065,17 @@ const handler$4 = 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: 'changelog',
+                        provider,
+                        model: String(summaryService.model),
+                    },
                 },
             });
             return `## Diff for ${data.branch}\n\n${diffSummary}`;
@@ -11798,6 +12142,14 @@ const handler$4 = async (argv, logger) => {
                 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);
@@ -11821,14 +12173,15 @@ const handler$4 = async (argv, logger) => {
         },
         mode: MODE,
     });
+    logLlmTelemetrySummary(logger, 'changelog');
 };
 
 var changelog = {
-    command: command$4,
+    command: command$5,
     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,
+    builder: builder$5,
+    handler: commandExecutor(handler$5),
+    options: options$5,
 };
 
 const conventionalTypeRegex = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?!?:/;
@@ -11845,11 +12198,11 @@ const ConventionalCommitMessageResponseSchema = objectType({
     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';
+const command$4 = 'commit';
 /**
  * Command line options via yargs
  */
-const options$3 = {
+const options$4 = {
     i: {
         alias: 'interactive',
         description: 'Toggle interactive mode',
@@ -11905,9 +12258,24 @@ const options$3 = {
         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$3 = (yargs) => {
-    return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
+const builder$4 = (yargs) => {
+    return yargs.options(options$4).usage(getCommandUsageHeader(command$4));
 };
 
 /**
@@ -11921,15 +12289,24 @@ const builder$3 = (yargs) => {
  * @returns Parsed result matching the schema type
  */
 async function executeChainWithSchema(schema, llm, prompt, variables, options = {}) {
-    const { retryOptions = { maxAttempts: 3 }, fallbackParser, onFallback, ...parserOptions } = 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;
     };
@@ -11946,6 +12323,12 @@ async function executeChainWithSchema(schema, llm, prompt, variables, options =
                 prompt,
                 variables,
                 parser: new output_parsers.StringOutputParser(),
+                logger,
+                tokenizer,
+                metadata: {
+                    task: 'schema-chain-fallback',
+                    ...metadata,
+                },
             });
             const fallbackText = typeof fallbackResult === 'string' ? fallbackResult : String(fallbackResult);
             return fallbackParser(fallbackText);
@@ -12408,17 +12791,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 = prompts$1.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$1 = await git.diff(['--staged', '--', change.filePath]);
+        const [patch] = diff.parsePatch(diff$1);
+        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 diff.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 = child_process.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) {
@@ -12436,6 +13147,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) {
@@ -12473,12 +13200,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),
+                },
             },
         });
     }
@@ -12628,6 +13360,14 @@ IMPORTANT RULES:
                     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) => {
@@ -12836,29 +13576,30 @@ IMPORTANT RULES:
         },
         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));
 };
 
 /**
@@ -13209,7 +13950,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;
@@ -13380,8 +14121,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,
@@ -13459,13 +14479,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) {
@@ -13496,19 +14520,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];
@@ -13543,7 +14597,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:
@@ -13588,15 +14652,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';
             }
@@ -13633,6 +14716,7 @@ ${errorMessage}
         },
         mode: MODE,
     });
+    logLlmTelemetrySummary(logger, 'recap');
 };
 
 var recap = {
@@ -13988,13 +15072,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) {
@@ -14018,7 +15106,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];
         }
@@ -14040,19 +15138,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];
@@ -14092,14 +15220,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);
@@ -14118,6 +15265,7 @@ const handler = async (argv, logger) => {
         },
     });
     const reviewer = new TaskList(recap, { ...config, apiKey: key ?? undefined });
+    logLlmTelemetrySummary(logger, 'review');
     await reviewer.start();
 };
 
@@ -14138,6 +15286,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));
 
 /**
@@ -14592,5 +15741,6 @@ var commitValidationHandler = /*#__PURE__*/Object.freeze({
 exports.changelog = changelog;
 exports.commit = commit;
 exports.init = init;
+exports.log = log;
 exports.recap = recap;
 exports.types = types;