git-coco 0.11.0 → 0.12.0

package/dist/index.esm.mjs

@@ -2,10 +2,10 @@
 import { PromptTemplate, BasePromptTemplate, ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate } from '@langchain/core/prompts';
 import { ConditionalPromptSelector, isChatModel } from '@langchain/core/example_selectors';
 import yargs from 'yargs';
+import chalk from 'chalk';
 import * as fs from 'fs';
 import fs__default from 'fs';
 import { confirm, editor, select, password, input } from '@inquirer/prompts';
-import chalk from 'chalk';
 import * as ini from 'ini';
 import * as os from 'os';
 import os__default from 'os';
@@ -15,28 +15,49 @@ import Ajv from 'ajv';
 import ora from 'ora';
 import now from 'performance-now';
 import prettyMilliseconds from 'pretty-ms';
+import { ChatOllama } from '@langchain/ollama';
+import { ChatOpenAI } from '@langchain/openai';
+import { JsonOutputParser, BaseOutputParser } from '@langchain/core/output_parsers';
+import { simpleGit } from 'simple-git';
 import pQueue from 'p-queue';
 import { Document, BaseDocumentTransformer } from '@langchain/core/documents';
 import { RUN_KEY } from '@langchain/core/outputs';
 import { CallbackManager, parseCallbackConfigArg } from '@langchain/core/callbacks/manager';
 import { ensureConfig, Runnable } from '@langchain/core/runnables';
 import { BaseLangChain, BaseLanguageModel } from '@langchain/core/language_models/base';
-import { BaseOutputParser, JsonOutputParser } from '@langchain/core/output_parsers';
 import '@langchain/core/messages';
 import '@langchain/core/memory';
 import '@langchain/core/chat_history';
 import '@langchain/core/utils/tiktoken';
-import { ChatOpenAI } from '@langchain/openai';
 import '@langchain/core/utils/async_caller';
 import '@langchain/core/utils/env';
 import '@langchain/core/utils/json_patch';
 import { createTwoFilesPatch } from 'diff';
-import { ChatOllama } from '@langchain/ollama';
 import { minimatch } from 'minimatch';
-import { simpleGit } from 'simple-git';
 import { encoding_for_model } from 'tiktoken';
 import { exec } from 'child_process';
 
+const isInteractive = (config) => {
+    return config?.mode === 'interactive' || !!config?.interactive;
+};
+const SEPERATOR = chalk.blue('─────────────');
+const LOGO = chalk.green(`┌──────┐
+│┏┏┓┏┏┓│
+│┗┗┛┗┗┛│
+└──────┘`);
+chalk.green(`┌────┐
+│coco│
+└────┘`);
+const USAGE_BANNER = chalk.green(`${LOGO}
+${chalk.bgGreen(`\xa0v${process.env.npm_package_version}\xa0`)}
+`);
+const getCommandUsageHeader = (command) => {
+    return chalk.green(`${USAGE_BANNER}\n${chalk.white('Command:')}\n\xa0\xa0\xa0\xa0\xa0 $0 ${chalk.greenBright(command)} [options]`);
+};
+const CONFIG_ALREADY_EXISTS = (path) => {
+    return `coco config found in '${path}', do you want to override it?`;
+};
+
 /**
  * Returns a new object with all undefined keys removed
  *
@@ -47,16 +68,64 @@ function removeUndefined(obj) {
     return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
 }
 
-const template$3 = `GOAL: Use functional abstractions to summarize the following text
+async function updateFileSection({ filePath, startComment, endComment, getNewContent, confirmUpdate = true, confirmMessage = (path) => `A section already exists in ${path}, do you want to override it?`, }) {
+    const lines = fs__default.existsSync(filePath) ? fs__default.readFileSync(filePath, 'utf-8').split(/\r?\n/) : [];
+    const newLines = [];
+    let foundSection = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === startComment) {
+            foundSection = true;
+            if (confirmUpdate) {
+                const confirmOverwrite = await confirm({
+                    message: typeof confirmMessage === 'function' ? confirmMessage(filePath) : confirmMessage,
+                    default: false,
+                });
+                if (!confirmOverwrite) {
+                    // keep all lines until the end comment
+                    while (i < lines.length && lines[i].trim() !== endComment) {
+                        newLines.push(lines[i]);
+                        i++;
+                    }
+                    newLines.push(endComment);
+                    continue;
+                }
+            }
+            newLines.push(startComment);
+            // Insert the new content
+            const newContent = await getNewContent();
+            newLines.push(newContent);
+            // Skip the existing content of the section
+            while (i < lines.length && lines[i].trim() !== endComment) {
+                i++;
+            }
+            newLines.push(endComment);
+            continue;
+        }
+        if (!foundSection || lines[i].trim() !== endComment) {
+            newLines.push(lines[i]);
+        }
+    }
+    // If section wasn't found, append it at the end
+    if (!foundSection) {
+        newLines.push('\n' + startComment);
+        const newContent = await getNewContent();
+        newLines.push(newContent);
+        newLines.push(endComment);
+    }
+    // Write the updated contents back to the file
+    fs__default.writeFileSync(filePath, newLines.join('\n'));
+}
+
+const template$4 = `GOAL: Use functional abstractions to summarize the following text
 
 RULES: Avoid phrases like  "this change", "this code", or "this function" etc. Instead refer to the function, variable, or class by name.
 
 TEXT:"""{text}"""
 `;
-const inputVariables$2 = ['text'];
+const inputVariables$3 = ['text'];
 const SUMMARIZE_PROMPT = new PromptTemplate({
-    inputVariables: inputVariables$2,
-    template: template$3,
+    inputVariables: inputVariables$3,
+    template: template$4,
 });
 
 /**
@@ -107,9 +176,9 @@ function getDefaultServiceApiKey(config) {
 }
 const DEFAULT_OPENAI_LLM_SERVICE = {
     provider: 'openai',
-    model: 'gpt-4-turbo',
+    model: 'gpt-4',
     tokenLimit: 2024,
-    temperature: 0.4,
+    temperature: 0.32,
     authentication: {
         type: 'APIKey',
         credentials: {
@@ -182,68 +251,6 @@ const CONFIG_KEYS = Object.keys({
     prompt: '',
 });
 
-async function updateFileSection({ filePath, startComment, endComment, getNewContent, confirmUpdate = true, confirmMessage = (path) => `A section already exists in ${path}, do you want to override it?`, }) {
-    const lines = fs__default.existsSync(filePath) ? fs__default.readFileSync(filePath, 'utf-8').split(/\r?\n/) : [];
-    const newLines = [];
-    let foundSection = false;
-    for (let i = 0; i < lines.length; i++) {
-        if (lines[i].trim() === startComment) {
-            foundSection = true;
-            if (confirmUpdate) {
-                const confirmOverwrite = await confirm({
-                    message: typeof confirmMessage === 'function' ? confirmMessage(filePath) : confirmMessage,
-                    default: false,
-                });
-                if (!confirmOverwrite) {
-                    // keep all lines until the end comment
-                    while (i < lines.length && lines[i].trim() !== endComment) {
-                        newLines.push(lines[i]);
-                        i++;
-                    }
-                    newLines.push(endComment);
-                    continue;
-                }
-            }
-            newLines.push(startComment);
-            // Insert the new content
-            const newContent = await getNewContent();
-            newLines.push(newContent);
-            // Skip the existing content of the section
-            while (i < lines.length && lines[i].trim() !== endComment) {
-                i++;
-            }
-            newLines.push(endComment);
-            continue;
-        }
-        if (!foundSection || lines[i].trim() !== endComment) {
-            newLines.push(lines[i]);
-        }
-    }
-    // If section wasn't found, append it at the end
-    if (!foundSection) {
-        newLines.push('\n' + startComment);
-        const newContent = await getNewContent();
-        newLines.push(newContent);
-        newLines.push(endComment);
-    }
-    // Write the updated contents back to the file
-    fs__default.writeFileSync(filePath, newLines.join('\n'));
-}
-
-const isInteractive = (argv) => {
-    return argv?.mode === 'interactive' || argv.interactive;
-};
-const SEPERATOR = chalk.blue('─────────────');
-const LOGO = chalk.green(`┌────────────┐
-│┌─┐┌─┐┌─┐┌─┐│
-││  │ ││  │ ││
-│└─┘└─┘└─┘└─┘│
-└────────────┘ 
-`);
-const CONFIG_ALREADY_EXISTS = (path) => {
-    return `coco config found in '${path}', do you want to override it?`;
-};
-
 /**
  * Load environment variables
  *
@@ -267,6 +274,9 @@ function loadEnvConfig(config) {
             handleServiceEnvVar(envConfig.service, key, envValue);
         }
         else {
+            if (key === 'service' || !envValue) {
+                return;
+            }
             envConfig[key] = envValue;
         }
     });
@@ -375,7 +385,6 @@ function loadGitConfig(config) {
         config = {
             ...config,
             service: service,
-            temperature: gitConfigParsed.coco?.temperature || config.temperature,
             prompt: gitConfigParsed.coco?.prompt || config.prompt,
             mode: gitConfigParsed.coco?.mode || config.mode,
             summarizePrompt: gitConfigParsed.coco?.summarizePrompt || config.summarizePrompt,
@@ -1916,88 +1925,651 @@ function commandExecutor(handler) {
 }
 
 /**
- * Extract the path from a file path string.
- * @param {string} filePath - The full file path.
- * @returns {string} The path portion of the file path.
+ * Get LLM Model Based on Configuration
+ *
+ * @param fields
+ * @param configuration
+ * @returns LLM Model
  */
-function getPathFromFilePath(filePath) {
-    return filePath.split('/').slice(0, -1).join('/');
+function getLlm(provider, model, config) {
+    if (!model) {
+        throw new Error(`Invalid LLM Service: ${provider}/${model}`);
+    }
+    switch (provider) {
+        case 'ollama':
+            return new ChatOllama({
+                baseUrl: DEFAULT_OLLAMA_LLM_SERVICE.endpoint,
+                maxConcurrency: config.service.maxConcurrent,
+                model,
+            });
+        case 'openai':
+        default:
+            const openAiModel = new ChatOpenAI({
+                openAIApiKey: getApiKeyForModel(config),
+                model,
+                temperature: config.service.temperature || 0.2,
+            });
+            return openAiModel;
+    }
 }
 
-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();
+function getPrompt({ template, variables, fallback }) {
+    if (!template && !fallback)
+        throw new Error('Must provide either a template or a fallback');
+    return (template
+        ? new PromptTemplate({
+            template,
+            inputVariables: variables,
+        })
+        : fallback);
 }
 
-/**
- * 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);
+const executeChain = async ({ llm, prompt, variables, parser }) => {
+    if (!llm || !prompt || !variables) {
+        throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
     }
-    traverse(node);
-    return Object.values(groupByPath);
+    const chain = prompt.pipe(llm).pipe(parser);
+    let res;
+    try {
+        res = await chain.invoke(variables);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`LLMChain call error: ${error.message}`);
+        }
+    }
+    if (!res) {
+        throw new Error('Empty response from LLMChain call');
+    }
+    return res;
+};
+
+function extractTicketIdFromBranchName(branchName) {
+    const regex = /((?<!([A-Z]+)-?)[A-Z]+-\d+)/;
+    const match = branchName.match(regex);
+    return match ? match[0] : null;
 }
+
 /**
- * Summarize a directory diff asynchronously.
+ * Retrieves the commit log range between two specified commits.
+ *
+ * @param from - The starting commit.
+ * @param to - The ending commit.
+ * @param options - Additional options for retrieving the commit log range.
+ * @returns A promise that resolves to an array of commit log messages.
+ * @throws If there is an error retrieving the commit log range.
  */
-async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
+async function getCommitLogRange(from, to, { noMerges, git }) {
     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,
-        };
+        const logOptions = { from: `${from}^1`, to, '--no-merges': noMerges };
+        const commitLog = await git.log(logOptions);
+        return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
     }
     catch (error) {
-        console.error(error);
-        return directory;
+        // If there's an error, handle it appropriately
+        throw error;
     }
 }
-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;
+
+/**
+ * Retrieves the name of the current branch.
+ *
+ * @param {GetCurrentBranchName} options - The options for retrieving the branch name.
+ * @returns {Promise<string>} - A promise that resolves to the name of the current branch.
+ */
+async function getCurrentBranchName({ git }) {
+    return await git.revparse(['--abbrev-ref', 'HEAD']);
+}
+
+/**
+ * Retrieves the commit log between the current branch and a specified target branch.
+ *
+ * @param {Object} options - The options for retrieving the commit log.
+ * @param {SimpleGit} options.git - The SimpleGit instance.
+ * @param {Logger} options.logger - The logger for logging messages.
+ * @param {string} options.targetBranch - The target branch to compare against.
+ * @returns {Promise<string[]>} The array of commit messages in the commit log.
+ */
+async function getCommitLogAgainstBranch({ git, logger, targetBranch, }) {
+    try {
+        // Get the current branch name
+        const currentBranch = await getCurrentBranchName({ git });
+        // Get the list of commits that are unique to the current branch compared to the target branch
+        const uniqueCommits = (await git.raw(['rev-list', `${targetBranch}..${currentBranch}`]))
+            .split('\n')
+            .filter(Boolean)
+            .reverse();
+        logger?.verbose(`Found ${uniqueCommits.length} unique commits between "${currentBranch}" and "${targetBranch}"`, { color: 'blue' });
+        const firstCommit = uniqueCommits[0];
+        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
+        if (!firstCommit || !lastCommit) {
+            logger?.log('Unable to determine first and last commit between branches', { color: 'yellow' });
+            return [];
+        }
+        // Retrieve commit log with messages
+        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
+    }
+    catch (error) {
+        logger?.log('Encountered an error getting commit log between branches', { color: 'red' });
+    }
+    return [];
+}
+
+/**
+ * Retrieves the commit log for the current branch.
+ *
+ * @param {Object} options - The options for retrieving the commit log.
+ * @param {SimpleGit} options.git - The SimpleGit instance.
+ * @param {Logger} options.logger - The logger for logging messages.
+ * @param {string} [options.comparisonBranch='main'] - The branch to compare against.
+ * @param {string} [options.comparisonRemote='origin'] - The remote to compare against.
+ * @returns {Promise<string[]>} The array of commit messages in the commit log.
+ */
+async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main', comparisonRemote = 'origin', }) {
+    try {
+        // Get the current branch name
+        const branch = await getCurrentBranchName({ git });
+        // Check if the current branch has any commits
+        const hasCommits = (await git.raw(['rev-list', '--count', branch])) !== '0';
+        if (!hasCommits) {
+            logger?.log('No commits on the current branch.');
+            return [];
+        }
+        // Get the list of commits that are unique to the current branch
+        let uniqueCommits;
+        if (comparisonBranch === branch) {
+            // If the comparison branch is the same as the current branch, we compare against the remote.
+            uniqueCommits = (await git.raw(['rev-list', `${comparisonRemote}/${comparisonBranch}..${branch}`]))
+                .split('\n')
+                .filter(Boolean)
+                .reverse();
+        }
+        else {
+            // Your existing code for different branches
+            uniqueCommits = (await git.raw(['rev-list', `${comparisonBranch}..${branch}`]))
+                .split('\n')
+                .filter(Boolean)
+                .reverse();
+        }
+        logger?.verbose(`Found ${uniqueCommits.length} unique commits on "${branch}"`, { color: 'blue' });
+        const firstCommit = uniqueCommits[0];
+        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
+        if (!firstCommit || !lastCommit) {
+            logger?.log('Unable to determine first and last commit on the current branch', { color: 'yellow' });
+            return [];
+        }
+        // Retrieve commit log with messages
+        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
+    }
+    catch (error) {
+        logger?.log('Encountered an error getting commit log from current branch', { color: 'red' });
+    }
+    return [];
+}
+
+/**
+ * Retrieves the SimpleGit instance for the repository.
+ * @returns {SimpleGit} The SimpleGit instance.
+ */
+const getRepo = () => {
+    let git;
+    try {
+        git = simpleGit();
+    }
+    catch (e) {
+        console.log('Error initializing git repo', e);
+        process.exit(1);
+    }
+    return git;
+};
+
+const template$3 = `Write informative git commit message, in the imperative, based on the diffs & file changes provided in the "Diff Summary" section.  
+Commit Messages must have a short description that is less than 50 characters and a longer detailed summary around 300 characters, the shorter and more concise the better. 
+
+Please follow the guidelines below when writing your commit message:
+
+- Write concisely using an informal tone
+- Avoid phrases like "this commit", "this change", "this function", etc. Instead refer to the function, variable, or class by name
+- Avoid referencing specific files names or long paths in the commit message
+- DO NOT include any diffs or file changes in the commit message
+- Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
+
+{format_instructions}
+
+""""""
+{summary}
+""""""
+
+{additional}
+`;
+const inputVariables$2 = ['summary', 'format_instructions', 'additional'];
+const COMMIT_PROMPT = new PromptTemplate({
+    template: template$3,
+    inputVariables: inputVariables$2,
+});
+
+/**
+ * Verify template string contains all required input variables
+ *
+ * @param text template string
+ * @param inputVariables template variables
+ * @returns boolean or error message
+ */
+function validatePromptTemplate(text, inputVariables) {
+    if (!text) {
+        return 'Prompt template cannot be empty';
+    }
+    if (!inputVariables.some((entry) => text.includes(entry))) {
+        return ('Prompt template must include at least one of the following input variables: ' +
+            inputVariables.map((value) => `{${value}}`).join(', '));
+    }
+    return true;
+}
+
+async function editPrompt(options) {
+    return await editor({
+        message: 'Edit the prompt',
+        default: options.prompt?.length ? options.prompt : COMMIT_PROMPT.template,
+        waitForUseInput: false,
+        postfix: 'Press ENTER to continue',
+        validate: (text) => validatePromptTemplate(text, COMMIT_PROMPT.inputVariables),
+    });
+}
+
+async function editResult(result, options) {
+    if (options.openInEditor) {
+        return await editor({
+            message: 'Edit the commit message',
+            default: result,
+            waitForUseInput: false,
+            validate: (text) => (text ? true : 'Commit message cannot be empty'),
+        });
+    }
+    return result;
+}
+
+async function getUserReviewDecision({ label, descriptions, enableRetry = true, enableFullRetry = true, enableModifyPrompt = true, }) {
+    const choices = [
+        {
+            name: '✨ Looks good!',
+            value: 'approve',
+            description: descriptions?.approve || `Continue with the generated ${label}`,
+        },
+        {
+            name: '📝 Edit',
+            value: 'edit',
+            description: descriptions?.edit || `Edit the generated ${label} before proceeding`,
+        },
+    ];
+    if (enableModifyPrompt) {
+        choices.push({
+            name: '🪶  Modify Prompt',
+            value: 'modifyPrompt',
+            description: descriptions?.modifyPrompt || `Modify the prompt template and regenerate the ${label}`,
+        });
+    }
+    if (enableRetry) {
+        choices.push({
+            name: '🔄 Retry',
+            value: 'retryMessageOnly',
+            description: descriptions?.retryMessageOnly ||
+                `Restart the function execution from generating the ${label}`,
+        });
+    }
+    if (enableFullRetry) {
+        choices.push({
+            name: '🔄 Retry Full',
+            value: 'retryFull',
+            description: descriptions?.retryFull ||
+                `Restart the function execution from the beginning, regenerating both the summary and ${label}`,
+        });
+    }
+    choices.push({
+        name: '💣 Cancel',
+        value: 'cancel',
+        description: descriptions?.cancel || `Cancel the ${label}`,
+    });
+    return (await select({
+        message: `Would you like to make any changes to the ${label}?`,
+        choices,
+    }));
+}
+
+function logResult(label, result) {
+    console.log(`\n${chalk.bgBlue(chalk.bold(`Proposed ${label}:`))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
+}
+
+async function generateAndReviewLoop({ label, factory, parser, noResult, agent, options, }) {
+    const { logger } = options;
+    let continueLoop = true;
+    let modifyPrompt = false;
+    let context = '';
+    let result = '';
+    const changes = await factory();
+    // if we don't have any changes, bail.
+    if (!changes || !Object.keys(changes).length) {
+        await noResult(options);
+    }
+    while (continueLoop) {
+        if (!context.length) {
+            context = await parser(changes, result, options);
+        }
+        // if we still don't have a context, bail.
+        if (!context.length) {
+            await noResult(options);
+        }
+        if (modifyPrompt) {
+            options.prompt = await editPrompt(options);
+        }
+        logger.startTimer().startSpinner(`Generating ${label}\n`, {
+            color: 'blue',
+        });
+        result = await agent(context, options);
+        if (!result) {
+            logger.stopSpinner('💀 Agent failed to return content.', {
+                mode: 'fail',
+                color: 'red',
+            });
+            process.exit(0);
+        }
+        logger
+            .stopSpinner(`Generated ${label}`, {
+            color: 'green',
+            mode: 'succeed',
+        })
+            .stopTimer();
+        if (options?.interactive) {
+            logResult(label, result);
+            const reviewAnswer = await getUserReviewDecision({
+                label,
+                ...(options?.review || {}),
+            });
+            if (reviewAnswer === 'cancel') {
+                process.exit(0);
+            }
+            if (reviewAnswer === 'edit') {
+                options.openInEditor = true;
+            }
+            if (reviewAnswer === 'retryFull') {
+                context = '';
+                result = '';
+                options.prompt = '';
+                continue;
+            }
+            if (reviewAnswer === 'retryMessageOnly') {
+                modifyPrompt = false;
+                result = '';
+                continue;
+            }
+            if (reviewAnswer === 'modifyPrompt') {
+                modifyPrompt = true;
+                result = '';
+                continue;
+            }
+        }
+        // if we're here, we're done.
+        result = await editResult(result, options);
+        continueLoop = false;
+    }
+    return result;
+}
+
+const logSuccess = () => {
+    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
+};
+
+async function handleResult({ result, mode, interactiveHandler }) {
+    switch (mode) {
+        case 'interactive':
+            if (interactiveHandler) {
+                await interactiveHandler(result);
+            }
+            else {
+                console.warn('No result handler provided for interactive mode.');
+                logSuccess();
+            }
+            break;
+        case 'stdout':
+        default:
+            process.stdout.write(result, 'utf8');
+            break;
+    }
+    process.exit(0);
+}
+
+const template$2 = `Write informative git changelog, in the imperative, based on a series of individual messages.
+
+- Include the git commit hash as reference for each change, including just the first 7 characters
+- Logically group changes, and if necessary, summarize dependency updates
+
+{format_instructions}
+
+"""{summary}"""`;
+const inputVariables$1 = ['format_instructions', 'summary'];
+const CHANGELOG_PROMPT = new PromptTemplate({
+    template: template$2,
+    inputVariables: inputVariables$1,
+});
+
+const handler$3 = async (argv, logger) => {
+    const config = loadConfig(argv);
+    const git = getRepo();
+    const key = getApiKeyForModel(config);
+    const { provider, model } = getModelAndProviderFromConfig(config);
+    if (config.service.authentication.type !== 'None' && !key) {
+        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
+        process.exit(1);
+    }
+    const llm = getLlm(provider, model, config);
+    const INTERACTIVE = isInteractive(config);
+    if (INTERACTIVE) {
+        logger.log(LOGO);
+    }
+    async function factory() {
+        const branchName = await getCurrentBranchName({ git });
+        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);
+            }
+            return {
+                branch: branchName,
+                commits: await getCommitLogRange(from, to, { git, noMerges: true }),
+            };
+        }
+        if (argv.branch) {
+            logger.verbose(`Generating commit log against branch: ${argv.branch}`, { color: 'yellow' });
+            return {
+                branch: branchName,
+                commits: await getCommitLogAgainstBranch({ git, logger, targetBranch: argv.branch }),
+            };
+        }
+        logger.verbose(`No range or branch provided. Defaulting to current branch`, { color: 'yellow' });
+        return {
+            branch: branchName,
+            commits: await getCommitLogCurrentBranch({ git, logger }),
+        };
+    }
+    async function parser({ branch, commits }) {
+        let result;
+        if (!commits || commits.length === 0) {
+            result = `## ${branch}\n\nNo commits found.`;
+        }
+        else {
+            result = `## ${branch}\n\n${commits.map((commit) => commit.trim()).join('\n\n')}`;
+        }
+        return result;
+    }
+    const changelogMsg = await generateAndReviewLoop({
+        label: 'changelog',
+        factory,
+        parser,
+        agent: async (context, options) => {
+            const parser = new JsonOutputParser();
+            const prompt = getPrompt({
+                template: options.prompt,
+                variables: CHANGELOG_PROMPT.inputVariables,
+                fallback: CHANGELOG_PROMPT,
+            });
+            const formatInstructions = "Respond with a valid JSON object, containing two fields: 'header' and 'content', both strings.";
+            const changelog = await executeChain({
+                llm,
+                prompt,
+                variables: {
+                    summary: context,
+                    format_instructions: formatInstructions,
+                },
+                parser,
+            });
+            const branchName = await getCurrentBranchName({ git });
+            const ticketId = extractTicketIdFromBranchName(branchName);
+            const footer = ticketId ? `\n\nPart of **${ticketId}**` : '';
+            return `${changelog.header}\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);
+        },
+        options: {
+            ...config,
+            prompt: config.prompt || CHANGELOG_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+            review: {
+                enableFullRetry: false,
+            },
+        },
+    });
+    const MODE = (INTERACTIVE && 'interactive') || (config.commit && 'interactive') || config?.mode || 'stdout';
+    handleResult({
+        result: changelogMsg,
+        interactiveHandler: async () => {
+            logSuccess();
+        },
+        mode: MODE,
+    });
+};
+
+/**
+ * Command line options via yargs
+ */
+const options$3 = {
+    range: {
+        type: 'string',
+        alias: 'r',
+        description: 'Commit range e.g `HEAD~2:HEAD`',
+    },
+    branch: {
+        type: 'string',
+        alias: 'b',
+        description: 'Target branch to compare against',
+    },
+    i: {
+        type: 'boolean',
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+    },
+};
+const builder$3 = (yargsInstance) => {
+    return yargsInstance.options(options$3).usage(getCommandUsageHeader(changelog.command));
+};
+
+var changelog = {
+    command: 'changelog',
+    desc: 'Generate a changelog from current or target branch or provided commit range.',
+    builder: builder$3,
+    handler: commandExecutor(handler$3),
+    options: options$3,
+};
+
+/**
+ * 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();
+}
+
+/**
+ * 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;
+    }
+}
+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;
 };
 async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
     const queue = new pQueue({ concurrency: 8 });
@@ -4252,7 +4824,7 @@ var vector_db_qa = /*#__PURE__*/Object.freeze({
 });
 
 /* eslint-disable spaced-comment */
-const template$2 = `Write a concise summary of the following:
+const template$1 = `Write a concise summary of the following:
 
 
 "{text}"
@@ -4260,7 +4832,7 @@ const template$2 = `Write a concise summary of the following:
 
 CONCISE SUMMARY:`;
 const DEFAULT_PROMPT = /*#__PURE__*/ new PromptTemplate({
-    template: template$2,
+    template: template$1,
     inputVariables: ["text"],
 });
 
@@ -5187,757 +5759,456 @@ function representYamlBinary(object /*, style*/) {
   return result;
 }
 
-function isBinary(obj) {
-  return Object.prototype.toString.call(obj) ===  '[object Uint8Array]';
-}
-
-var binary = new type('tag:yaml.org,2002:binary', {
-  kind: 'scalar',
-  resolve: resolveYamlBinary,
-  construct: constructYamlBinary,
-  predicate: isBinary,
-  represent: representYamlBinary
-});
-
-var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
-var _toString$2       = Object.prototype.toString;
-
-function resolveYamlOmap(data) {
-  if (data === null) return true;
-
-  var objectKeys = [], index, length, pair, pairKey, pairHasKey,
-      object = data;
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
-    pairHasKey = false;
-
-    if (_toString$2.call(pair) !== '[object Object]') return false;
-
-    for (pairKey in pair) {
-      if (_hasOwnProperty$3.call(pair, pairKey)) {
-        if (!pairHasKey) pairHasKey = true;
-        else return false;
-      }
-    }
-
-    if (!pairHasKey) return false;
-
-    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
-    else return false;
-  }
-
-  return true;
-}
-
-function constructYamlOmap(data) {
-  return data !== null ? data : [];
-}
-
-var omap = new type('tag:yaml.org,2002:omap', {
-  kind: 'sequence',
-  resolve: resolveYamlOmap,
-  construct: constructYamlOmap
-});
-
-var _toString$1 = Object.prototype.toString;
-
-function resolveYamlPairs(data) {
-  if (data === null) return true;
-
-  var index, length, pair, keys, result,
-      object = data;
-
-  result = new Array(object.length);
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
-
-    if (_toString$1.call(pair) !== '[object Object]') return false;
-
-    keys = Object.keys(pair);
-
-    if (keys.length !== 1) return false;
-
-    result[index] = [ keys[0], pair[keys[0]] ];
-  }
-
-  return true;
-}
-
-function constructYamlPairs(data) {
-  if (data === null) return [];
-
-  var index, length, pair, keys, result,
-      object = data;
-
-  result = new Array(object.length);
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
-
-    keys = Object.keys(pair);
-
-    result[index] = [ keys[0], pair[keys[0]] ];
-  }
-
-  return result;
-}
-
-var pairs = new type('tag:yaml.org,2002:pairs', {
-  kind: 'sequence',
-  resolve: resolveYamlPairs,
-  construct: constructYamlPairs
-});
-
-var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
-
-function resolveYamlSet(data) {
-  if (data === null) return true;
-
-  var key, object = data;
-
-  for (key in object) {
-    if (_hasOwnProperty$2.call(object, key)) {
-      if (object[key] !== null) return false;
-    }
-  }
-
-  return true;
-}
-
-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 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);
-}
-
-/**
- * Get Summarization Chain
- * @param model
- * @param options
- * @returns
- */
-function getSummarizationChain(model, options = { type: 'map_reduce' }) {
-    return loadSummarizationChain(model, options);
-}
-
-/**
- * Get Recursive Character Text Splitter
- *
- * @param options
- * @returns
- */
-function getTextSplitter(options = {}) {
-    return new RecursiveCharacterTextSplitter(options);
-}
-
-/**
- * Parses the default file diff for a given nodeFile.
- *
- * @param nodeFile - The file change object.
- * @param commit - The commit to diff against. Defaults to '--staged'.
- * @param git - The SimpleGit instance.
- * @returns A Promise that resolves to the file diff as a string.
- */
-async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
-    if (commit !== '--staged') {
-        return await git.diff([`${commit}~1..${commit}`, '--', nodeFile.filePath]);
-    }
-    return await git.diff([commit, nodeFile.filePath]);
-}
-/**
- * Parses the diff for a renamed file.
- *
- * @param nodeFile - The file change object.
- * @param commit - The commit hash or '--staged'.
- * @param git - The SimpleGit instance.
- * @param logger - The logger instance.
- * @returns A Promise that resolves to the diff string.
- */
-async function parseRenamedFileDiff(nodeFile, commit, git, logger) {
-    let result = '';
-    const oldFilePath = nodeFile?.oldFilePath || nodeFile.filePath;
-    let previousCommitHash = 'HEAD';
-    let newCommitHash = '';
-    if (commit !== '--staged') {
-        try {
-            previousCommitHash = await git.revparse([`${commit}~1`]);
-        }
-        catch (err) {
-            logger.verbose(`Error getting previous commit hash for ${nodeFile.filePath}`, {
-                color: 'red',
-            });
-        }
-        newCommitHash = commit;
-    }
-    try {
-        const [previousContent, newContent] = await Promise.all([
-            git.show([`${previousCommitHash}:${oldFilePath}`]),
-            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
-        ]);
-        if (previousContent !== newContent) {
-            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
-                context: 3,
-            });
-            // remove the first 4 lines of the patch (they contain the old and new file names)
-            result = result.split('\n').slice(4).join('\n');
-        }
-        else {
-            result = 'File contents are unchanged.';
-        }
-    }
-    catch (err) {
-        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
-        result = 'Error comparing file contents.';
-    }
-    return result;
+function isBinary(obj) {
+  return Object.prototype.toString.call(obj) ===  '[object Uint8Array]';
 }
-/**
- * Retrieves the diff for a given file change in a specific commit.
- * If the file is deleted, it returns a message indicating that the file has been deleted.
- * If the file is renamed, it parses the renamed file diff and returns it.
- * Otherwise, it retrieves the default diff from the index and returns it.
- *
- * @param nodeFile - The file change object.
- * @param commit - The commit hash.
- * @param git - The SimpleGit instance.
- * @param logger - The logger instance.
- * @returns A promise that resolves to the diff as a string.
- */
-async function getDiff(nodeFile, commit, { git, logger, }) {
-    if (nodeFile.status === 'deleted') {
-        return 'This file has been deleted.';
-    }
-    if (nodeFile.status === 'renamed' && nodeFile.oldFilePath) {
-        const renamedDiff = await parseRenamedFileDiff(nodeFile, commit, git, logger);
-        return renamedDiff;
+
+var binary = new type('tag:yaml.org,2002:binary', {
+  kind: 'scalar',
+  resolve: resolveYamlBinary,
+  construct: constructYamlBinary,
+  predicate: isBinary,
+  represent: representYamlBinary
+});
+
+var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
+var _toString$2       = Object.prototype.toString;
+
+function resolveYamlOmap(data) {
+  if (data === null) return true;
+
+  var objectKeys = [], index, length, pair, pairKey, pairHasKey,
+      object = data;
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+    pairHasKey = false;
+
+    if (_toString$2.call(pair) !== '[object Object]') return false;
+
+    for (pairKey in pair) {
+      if (_hasOwnProperty$3.call(pair, pairKey)) {
+        if (!pairHasKey) pairHasKey = true;
+        else return false;
+      }
     }
-    // If not deleted or renamed, get the diff from the index
-    const defaultDiff = await parseDefaultFileDiff(nodeFile, commit, git);
-    return defaultDiff;
+
+    if (!pairHasKey) return false;
+
+    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
+    else return false;
+  }
+
+  return true;
 }
 
-// Max tokens for GPT-3 is 4096
-// const MAX_TOKENS_PER_SUMMARY = 4096
-const MAX_TOKENS_PER_SUMMARY = 12288;
-async function fileChangeParser({ changes, commit, options: { tokenizer, git, llm: model, logger }, }) {
-    const textSplitter = getTextSplitter({ chunkSize: 10000, chunkOverlap: 250 });
-    // const textSplitter = new TokenTextSplitter({
-    //   chunkSize: 10000,
-    //   chunkOverlap: 250,
-    // });
-    const summarizationChain = getSummarizationChain(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
-    logger.startTimer();
-    const summary = await summarizeDiffs(diffs, {
-        tokenizer,
-        maxTokens: MAX_TOKENS_PER_SUMMARY,
-        textSplitter,
-        chain: summarizationChain,
-        logger,
-    });
-    logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
-    return summary;
+function constructYamlOmap(data) {
+  return data !== null ? data : [];
 }
 
-const template$1 = `Write informative git commit message, in the imperative, based on the diffs & file changes provided in the "Diff Summary" section.  
-Commit Messages must have a short description that is less than 50 characters and a longer detailed summary no more than 300 characters, the shorter and more concise the better.  Please follow the guidelines below when writing your commit message:
+var omap = new type('tag:yaml.org,2002:omap', {
+  kind: 'sequence',
+  resolve: resolveYamlOmap,
+  construct: constructYamlOmap
+});
+
+var _toString$1 = Object.prototype.toString;
 
-- Write concisely using an informal tone
-- DO NOT use phrases like "this commit", "this change", "this function", etc. Instead refer to the function, variable, or class by name
-- DO NOT use specific names or files from the code
-- DO NOT include any diffs or file changes in the commit message
-- Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
+function resolveYamlPairs(data) {
+  if (data === null) return true;
 
-{format_instructions}
+  var index, length, pair, keys, result,
+      object = data;
 
-"""{summary}"""`;
-const inputVariables$1 = ['summary', 'format_instructions'];
-const COMMIT_PROMPT = new PromptTemplate({
-    template: template$1,
-    inputVariables: inputVariables$1,
+  result = new Array(object.length);
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+
+    if (_toString$1.call(pair) !== '[object Object]') return false;
+
+    keys = Object.keys(pair);
+
+    if (keys.length !== 1) return false;
+
+    result[index] = [ keys[0], pair[keys[0]] ];
+  }
+
+  return true;
+}
+
+function constructYamlPairs(data) {
+  if (data === null) return [];
+
+  var index, length, pair, keys, result,
+      object = data;
+
+  result = new Array(object.length);
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+
+    keys = Object.keys(pair);
+
+    result[index] = [ keys[0], pair[keys[0]] ];
+  }
+
+  return result;
+}
+
+var pairs = new type('tag:yaml.org,2002:pairs', {
+  kind: 'sequence',
+  resolve: resolveYamlPairs,
+  construct: constructYamlPairs
 });
 
-/**
- * Get LLM Model Based on Configuration
- *
- * @param fields
- * @param configuration
- * @returns LLM Model
- */
-function getLlm(provider, model, config) {
-    if (!model) {
-        throw new Error(`Invalid LLM Service: ${provider}/${model}`);
-    }
-    switch (provider) {
-        case 'ollama':
-            return new ChatOllama({
-                baseUrl: DEFAULT_OLLAMA_LLM_SERVICE.endpoint,
-                maxConcurrency: config.service.maxConcurrent,
-                model,
-            });
-        case 'openai':
-        default:
-            const openAiModel = new ChatOpenAI({
-                openAIApiKey: getApiKeyForModel(config),
-                model,
-                temperature: config.service.temperature || 0.2,
-            });
-            return openAiModel;
+var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+
+function resolveYamlSet(data) {
+  if (data === null) return true;
+
+  var key, object = data;
+
+  for (key in object) {
+    if (_hasOwnProperty$2.call(object, key)) {
+      if (object[key] !== null) return false;
     }
+  }
+
+  return true;
 }
 
-function getPrompt({ template, variables, fallback }) {
-    if (!template && !fallback)
-        throw new Error('Must provide either a template or a fallback');
-    return (template
-        ? new PromptTemplate({
-            template,
-            inputVariables: variables,
-        })
-        : fallback);
+function constructYamlSet(data) {
+  return data !== null ? data : {};
 }
 
-/**
- * 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 ('changes' in file && 'binary' in file) {
-        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');
-    }
+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);
 }
 
 /**
- * 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.
+ * Get Summarization Chain
+ * @param model
+ * @param options
+ * @returns
  */
-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}`;
+function getSummarizationChain(model, options = { type: 'map_reduce' }) {
+    return loadSummarizationChain(model, options);
 }
 
 /**
- * Retrieves the changes in the Git repository.
+ * Get Recursive Character Text Splitter
  *
- * @param {GetChangesInput} options - The options for retrieving the changes.
- * @returns {Promise<GetChangesResult>} A promise that resolves to the changes in the Git repository.
+ * @param options
+ * @returns
  */
-async function getChanges({ git, options }) {
-    const { ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS } = options || {};
-    const staged = [];
-    const unstaged = [];
-    const untracked = [];
-    const status = await git.status();
-    status.files.forEach((file) => {
-        const fileChange = {
-            filePath: file.path,
-            oldFilePath: status.renamed.filter((renamed) => renamed.to === file.path)[0]?.from,
-        };
-        // Unstaged files
-        if (file.working_dir !== '?' && file.working_dir !== ' ') {
-            fileChange.status = getStatus(file, 'working_dir');
-            fileChange.summary = getSummaryText(file, fileChange);
-            unstaged.push(fileChange);
-        }
-        // Staged files
-        if (file.index !== ' ' && file.index !== '?') {
-            fileChange.status = getStatus(file);
-            fileChange.summary = getSummaryText(file, fileChange);
-            staged.push(fileChange);
-        }
-        // Untracked files
-        if (file.working_dir === '?' && file.index === '?') {
-            fileChange.status = 'added';
-            fileChange.summary = getSummaryText(file, fileChange);
-            untracked.push(fileChange);
-        }
-    });
-    const ignoredExtensionsSet = new Set(ignoredExtensions.map((extension) => extension.toLowerCase()));
-    const filteredStaged = staged.filter((file) => {
-        const extension = path__default.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
-    });
-    const filteredUnstaged = unstaged.filter((file) => {
-        const extension = path__default.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
-    });
-    const filteredUntracked = untracked.filter((file) => {
-        const extension = path__default.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
-    });
-    return {
-        staged: filteredStaged,
-        unstaged: filteredUnstaged,
-        untracked: filteredUntracked,
-    };
-}
-
-async function noResult({ git, logger }) {
-    const { staged, unstaged, untracked } = await getChanges({ git });
-    const hasStaged = staged && staged.length > 0;
-    const hasUnstaged = unstaged && unstaged.length > 0;
-    const hasUntracked = untracked && untracked.length > 0;
-    if (hasStaged) {
-        logger.log(`Staged files detected, but no summary generated...`, { color: 'red' });
-        logger.log(`Files are likely either:\n  • changed files are ignored\n  • file diff is too large.`, { color: 'yellow' });
-    }
-    else if (hasUnstaged || hasUntracked) {
-        logger.log('Forget something? No staged changes found... 👻', { color: 'red' });
-        if (hasUnstaged) {
-            logger.log('\nChanges not staged for commit:', { color: 'yellow' });
-            logger.verbose(`\t${unstaged.map(({ summary }) => summary).join('\n\t')}`, {
-                color: 'red',
-            });
-        }
-        if (hasUntracked) {
-            logger.log('\nUntracked changes:', { color: 'yellow' });
-            logger.verbose(`\t${untracked.map(({ summary }) => summary).join('\n\t')}`, {
-                color: 'red',
-            });
-        }
-    }
-    else {
-        logger.log('No repo changes detected. 👀', { color: 'blue' });
-    }
+function getTextSplitter(options = {}) {
+    return new RecursiveCharacterTextSplitter(options);
 }
 
 /**
- * Verify template string contains all required input variables
+ * Parses the default file diff for a given nodeFile.
  *
- * @param text template string
- * @param inputVariables template variables
- * @returns boolean or error message
+ * @param nodeFile - The file change object.
+ * @param commit - The commit to diff against. Defaults to '--staged'.
+ * @param git - The SimpleGit instance.
+ * @returns A Promise that resolves to the file diff as a string.
  */
-function validatePromptTemplate(text, inputVariables) {
-    if (!text) {
-        return 'Prompt template cannot be empty';
-    }
-    if (!inputVariables.some((entry) => text.includes(entry))) {
-        return ('Prompt template must include at least one of the following input variables: ' +
-            inputVariables.map((value) => `{${value}}`).join(', '));
-    }
-    return true;
-}
-
-async function editPrompt(options) {
-    return await editor({
-        message: 'Edit the prompt',
-        default: options.prompt?.length ? options.prompt : COMMIT_PROMPT.template,
-        waitForUseInput: false,
-        postfix: 'Press ENTER to continue',
-        validate: (text) => validatePromptTemplate(text, COMMIT_PROMPT.inputVariables),
-    });
-}
-
-async function editResult(result, options) {
-    if (options.openInEditor) {
-        return await editor({
-            message: 'Edit the commit message',
-            default: result,
-            waitForUseInput: false,
-            validate: (text) => (text ? true : 'Commit message cannot be empty'),
-        });
-    }
-    return result;
-}
-
-async function getUserReviewDecision({ label, descriptions, enableRetry = true, enableFullRetry = true, enableModifyPrompt = true, }) {
-    const choices = [
-        {
-            name: '✨ Looks good!',
-            value: 'approve',
-            description: descriptions?.approve || `Continue with the generated ${label}`,
-        },
-        {
-            name: '📝 Edit',
-            value: 'edit',
-            description: descriptions?.edit || `Edit the generated ${label} before proceeding`,
-        },
-    ];
-    if (enableModifyPrompt) {
-        choices.push({
-            name: '🪶  Modify Prompt',
-            value: 'modifyPrompt',
-            description: descriptions?.modifyPrompt || `Modify the prompt template and regenerate the ${label}`,
-        });
-    }
-    if (enableRetry) {
-        choices.push({
-            name: '🔄 Retry',
-            value: 'retryMessageOnly',
-            description: descriptions?.retryMessageOnly ||
-                `Restart the function execution from generating the ${label}`,
-        });
-    }
-    if (enableFullRetry) {
-        choices.push({
-            name: '🔄 Retry Full',
-            value: 'retryFull',
-            description: descriptions?.retryFull ||
-                `Restart the function execution from the beginning, regenerating both the summary and ${label}`,
-        });
+async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
+    if (commit !== '--staged') {
+        return await git.diff([`${commit}~1..${commit}`, '--', nodeFile.filePath]);
     }
-    choices.push({
-        name: '💣 Cancel',
-        value: 'cancel',
-        description: descriptions?.cancel || `Cancel the ${label}`,
-    });
-    return (await select({
-        message: `Would you like to make any changes to the ${label}?`,
-        choices,
-    }));
-}
-
-function logResult(label, result) {
-    console.log(`\n${chalk.bgBlue(chalk.bold(`Proposed ${label}:`))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
+    return await git.diff([commit, nodeFile.filePath]);
 }
-
-async function generateAndReviewLoop({ label, factory, parser, noResult, agent, options, }) {
-    const { logger } = options;
-    let continueLoop = true;
-    let modifyPrompt = false;
-    let context = '';
+/**
+ * Parses the diff for a renamed file.
+ *
+ * @param nodeFile - The file change object.
+ * @param commit - The commit hash or '--staged'.
+ * @param git - The SimpleGit instance.
+ * @param logger - The logger instance.
+ * @returns A Promise that resolves to the diff string.
+ */
+async function parseRenamedFileDiff(nodeFile, commit, git, logger) {
     let result = '';
-    const changes = await factory();
-    // if we don't have any changes, bail.
-    if (!changes || !Object.keys(changes).length) {
-        await noResult(options);
-    }
-    while (continueLoop) {
-        if (!context.length) {
-            context = await parser(changes, result, options);
-        }
-        // if we still don't have a context, bail.
-        if (!context.length) {
-            await noResult(options);
-        }
-        if (modifyPrompt) {
-            options.prompt = await editPrompt(options);
+    const oldFilePath = nodeFile?.oldFilePath || nodeFile.filePath;
+    let previousCommitHash = 'HEAD';
+    let newCommitHash = '';
+    if (commit !== '--staged') {
+        try {
+            previousCommitHash = await git.revparse([`${commit}~1`]);
         }
-        logger.startTimer().startSpinner(`Generating ${label}\n`, {
-            color: 'blue',
-        });
-        result = await agent(context, options);
-        if (!result) {
-            logger.stopSpinner('💀 Agent failed to return content.', {
-                mode: 'fail',
+        catch (err) {
+            logger.verbose(`Error getting previous commit hash for ${nodeFile.filePath}`, {
                 color: 'red',
             });
-            process.exit(0);
         }
-        logger
-            .stopSpinner(`Generated ${label}`, {
-            color: 'green',
-            mode: 'succeed',
-        })
-            .stopTimer();
-        if (options?.interactive) {
-            logResult(label, result);
-            const reviewAnswer = await getUserReviewDecision({
-                label,
-                ...(options?.review || {}),
+        newCommitHash = commit;
+    }
+    try {
+        const [previousContent, newContent] = await Promise.all([
+            git.show([`${previousCommitHash}:${oldFilePath}`]),
+            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
+        ]);
+        if (previousContent !== newContent) {
+            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
+                context: 3,
             });
-            if (reviewAnswer === 'cancel') {
-                process.exit(0);
-            }
-            if (reviewAnswer === 'edit') {
-                options.openInEditor = true;
-            }
-            if (reviewAnswer === 'retryFull') {
-                context = '';
-                result = '';
-                options.prompt = '';
-                continue;
-            }
-            if (reviewAnswer === 'retryMessageOnly') {
-                modifyPrompt = false;
-                result = '';
-                continue;
-            }
-            if (reviewAnswer === 'modifyPrompt') {
-                modifyPrompt = true;
-                result = '';
-                continue;
-            }
+            // remove the first 4 lines of the patch (they contain the old and new file names)
+            result = result.split('\n').slice(4).join('\n');
         }
-        // if we're here, we're done.
-        result = await editResult(result, options);
-        continueLoop = false;
+        else {
+            result = 'File contents are unchanged.';
+        }
+    }
+    catch (err) {
+        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
+        result = 'Error comparing file contents.';
     }
     return result;
 }
-
-const executeChain = async ({ llm, prompt, variables, parser, }) => {
-    if (!llm || !prompt || !variables) {
-        throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
+/**
+ * Retrieves the diff for a given file change in a specific commit.
+ * If the file is deleted, it returns a message indicating that the file has been deleted.
+ * If the file is renamed, it parses the renamed file diff and returns it.
+ * Otherwise, it retrieves the default diff from the index and returns it.
+ *
+ * @param nodeFile - The file change object.
+ * @param commit - The commit hash.
+ * @param git - The SimpleGit instance.
+ * @param logger - The logger instance.
+ * @returns A promise that resolves to the diff as a string.
+ */
+async function getDiff(nodeFile, commit, { git, logger, }) {
+    if (nodeFile.status === 'deleted') {
+        return 'This file has been deleted.';
     }
-    const chain = prompt.pipe(llm).pipe(parser);
-    let res;
-    try {
-        res = await chain.invoke(variables);
+    if (nodeFile.status === 'renamed' && nodeFile.oldFilePath) {
+        const renamedDiff = await parseRenamedFileDiff(nodeFile, commit, git, logger);
+        return renamedDiff;
     }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`LLMChain call error: ${error.message}`);
+    // If not deleted or renamed, get the diff from the index
+    const defaultDiff = await parseDefaultFileDiff(nodeFile, commit, git);
+    return defaultDiff;
+}
+
+// Max tokens for GPT-3 is 4096
+// const MAX_TOKENS_PER_SUMMARY = 4096
+const MAX_TOKENS_PER_SUMMARY = 12288;
+async function fileChangeParser({ changes, commit, options: { tokenizer, git, llm: model, logger }, }) {
+    const textSplitter = getTextSplitter({ chunkSize: 10000, chunkOverlap: 250 });
+    // const textSplitter = new TokenTextSplitter({
+    //   chunkSize: 10000,
+    //   chunkOverlap: 250,
+    // });
+    const summarizationChain = getSummarizationChain(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
+    logger.startTimer();
+    const summary = await summarizeDiffs(diffs, {
+        tokenizer,
+        maxTokens: MAX_TOKENS_PER_SUMMARY,
+        textSplitter,
+        chain: summarizationChain,
+        logger,
+    });
+    logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
+    return summary;
+}
+
+/**
+ * Creates a commit with the specified commit message.
+ *
+ * @param message The commit message.
+ * @param git The SimpleGit instance.
+ * @returns A Promise that resolves to the CommitResult.
+ */
+async function createCommit(message, git) {
+    return await git.commit(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';
         }
     }
-    if (!res) {
-        throw new Error('Empty response from LLMChain call');
+    else if ('changes' in file && 'binary' in file) {
+        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';
     }
-    return res;
-};
-
-const logSuccess = () => {
-    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
-};
+    else {
+        throw new Error('Invalid file type');
+    }
+}
 
-async function handleResult({ result, mode, interactiveHandler }) {
-    switch (mode) {
-        case 'interactive':
-            if (interactiveHandler) {
-                await interactiveHandler(result);
-            }
-            else {
-                console.warn('No result handler provided for interactive mode.');
-                logSuccess();
-            }
-            break;
-        case 'stdout':
-        default:
-            process.stdout.write(result, 'utf8');
-            break;
+/**
+ * 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;
     }
-    process.exit(0);
+    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 SimpleGit instance for the repository.
- * @returns {SimpleGit} The SimpleGit instance.
+ * Retrieves the changes in the Git repository.
+ *
+ * @param {GetChangesInput} options - The options for retrieving the changes.
+ * @returns {Promise<GetChangesResult>} A promise that resolves to the changes in the Git repository.
  */
-const getRepo = () => {
-    let git;
-    try {
-        git = simpleGit();
-    }
-    catch (e) {
-        console.log('Error initializing git repo', e);
-        process.exit(1);
-    }
-    return git;
-};
+async function getChanges({ git, options }) {
+    const { ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS } = options || {};
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    const status = await git.status();
+    status.files.forEach((file) => {
+        const fileChange = {
+            filePath: file.path,
+            oldFilePath: status.renamed.filter((renamed) => renamed.to === file.path)[0]?.from,
+        };
+        // Unstaged files
+        if (file.working_dir !== '?' && file.working_dir !== ' ') {
+            fileChange.status = getStatus(file, 'working_dir');
+            fileChange.summary = getSummaryText(file, fileChange);
+            unstaged.push(fileChange);
+        }
+        // Staged files
+        if (file.index !== ' ' && file.index !== '?') {
+            fileChange.status = getStatus(file);
+            fileChange.summary = getSummaryText(file, fileChange);
+            staged.push(fileChange);
+        }
+        // Untracked files
+        if (file.working_dir === '?' && file.index === '?') {
+            fileChange.status = 'added';
+            fileChange.summary = getSummaryText(file, fileChange);
+            untracked.push(fileChange);
+        }
+    });
+    const ignoredExtensionsSet = new Set(ignoredExtensions.map((extension) => extension.toLowerCase()));
+    const filteredStaged = staged.filter((file) => {
+        const extension = path__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
+    });
+    const filteredUnstaged = unstaged.filter((file) => {
+        const extension = path__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
+    });
+    const filteredUntracked = untracked.filter((file) => {
+        const extension = path__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
+    });
+    return {
+        staged: filteredStaged,
+        unstaged: filteredUnstaged,
+        untracked: filteredUntracked,
+    };
+}
 
 /**
  * Retrieves a TikToken for the specified model.
@@ -5961,331 +6232,112 @@ const getTokenCounter = async (modelName) => {
     });
 };
 
-/**
- * Creates a commit with the specified commit message.
- *
- * @param message The commit message.
- * @param git The SimpleGit instance.
- * @returns A Promise that resolves to the CommitResult.
- */
-async function createCommit(message, git) {
-    return await git.commit(message);
-}
-
-const handler$2 = async (argv, logger) => {
-    const git = getRepo();
-    const options = loadConfig(argv);
-    const key = getApiKeyForModel(options);
-    const { provider, model } = getModelAndProviderFromConfig(options);
-    if (options.service.authentication.type !== 'None' && !key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        process.exit(1);
-    }
-    const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4');
-    const llm = getLlm(provider, model, options);
-    const INTERACTIVE = isInteractive(options);
-    if (INTERACTIVE) {
-        logger.log(LOGO);
-    }
-    async function factory() {
-        const changes = await getChanges({ git });
-        return changes.staged;
-    }
-    async function parser(changes) {
-        return await fileChangeParser({
-            changes,
-            commit: '--staged',
-            options: { tokenizer, git, llm, logger },
-        });
-    }
-    const commitMsg = await generateAndReviewLoop({
-        label: 'commit message',
-        options: {
-            ...options,
-            prompt: options.prompt || COMMIT_PROMPT.template,
-            logger,
-            interactive: INTERACTIVE,
-            review: {
-                descriptions: {
-                    approve: `Commit staged changes with generated commit message`,
-                    edit: 'Edit the commit message before proceeding',
-                    modifyPrompt: 'Modify the prompt template and regenerate the commit message',
-                    retryMessageOnly: 'Restart the function execution from generating the commit message',
-                    retryFull: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
-                },
-            },
-        },
-        factory,
-        parser,
-        agent: async (context, options) => {
-            const parser = new JsonOutputParser();
-            const prompt = getPrompt({
-                template: options.prompt,
-                variables: COMMIT_PROMPT.inputVariables,
-                fallback: COMMIT_PROMPT,
-            });
-            const formatInstructions = "Respond with a valid JSON object, containing two fields: 'title' and 'body'.";
-            const commitMsg = await executeChain({
-                llm,
-                prompt,
-                variables: { summary: context, format_instructions: formatInstructions },
-                parser,
-            });
-            return `${commitMsg.title}\n\n${commitMsg.body}`;
-        },
-        noResult: async () => {
-            await noResult({ git, logger });
-            process.exit(0);
-        },
-    });
-    const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
-    handleResult({
-        result: commitMsg,
-        interactiveHandler: async (result) => {
-            await createCommit(result, git);
-            logSuccess();
-        },
-        mode: MODE,
-    });
-};
-
-/**
- * Command line options via yargs
- */
-const options$2 = {
-    service: { type: 'string', description: 'LLM/Model-Name', choices: ['openai', 'ollama'] },
-    openAIApiKey: {
-        type: 'string',
-        description: 'OpenAI API Key',
-    },
-    tokenLimit: { type: 'number', description: 'Token limit' },
-    prompt: {
-        type: 'string',
-        alias: 'p',
-        description: 'Commit message prompt',
-    },
-    i: {
-        type: 'boolean',
-        alias: 'interactive',
-        description: 'Toggle interactive mode',
-    },
-    s: {
-        type: 'boolean',
-        description: 'Automatically commit staged changes with generated commit message',
-        default: false,
-    },
-    e: {
-        type: 'boolean',
-        alias: 'edit',
-        description: 'Open commit message in editor before proceeding',
-    },
-    summarizePrompt: {
-        type: 'string',
-        description: 'Large file summary prompt',
-    },
-    ignoredFiles: {
-        type: 'array',
-        description: 'Ignored files',
-    },
-    ignoredExtensions: {
-        type: 'array',
-        description: 'Ignored extensions',
-    },
-};
-const builder$2 = (yargs) => {
-    return yargs.options(options$2);
-};
-
-var commit = {
-    command: 'commit',
-    desc: 'Write a commit message summarizing the staged changes.',
-    builder: builder$2,
-    handler: commandExecutor(handler$2),
-    options: options$2,
-};
-
-/**
- * Retrieves the commit log range between two specified commits.
- *
- * @param from - The starting commit.
- * @param to - The ending commit.
- * @param options - Additional options for retrieving the commit log range.
- * @returns A promise that resolves to an array of commit log messages.
- * @throws If there is an error retrieving the commit log range.
- */
-async function getCommitLogRange(from, to, { noMerges, git }) {
-    try {
-        const logOptions = { from: `${from}^1`, to, '--no-merges': noMerges };
-        const commitLog = await git.log(logOptions);
-        return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n - ${author_name}<${author_email}> (${hash})`);
-    }
-    catch (error) {
-        // If there's an error, handle it appropriately
-        console.error('Error getting commit messages:', error);
-        throw error;
-    }
-}
-
-/**
- * Retrieves the name of the current branch.
- *
- * @param {GetCurrentBranchName} options - The options for retrieving the branch name.
- * @returns {Promise<string>} - A promise that resolves to the name of the current branch.
- */
-async function getCurrentBranchName({ git }) {
-    return await git.revparse(['--abbrev-ref', 'HEAD']);
-}
-
-/**
- * Retrieves the commit log for the current branch.
- *
- * @param {Object} options - The options for retrieving the commit log.
- * @param {SimpleGit} options.git - The SimpleGit instance.
- * @param {Logger} options.logger - The logger for logging messages.
- * @param {string} [options.comparisonBranch='main'] - The branch to compare against.
- * @param {string} [options.comparisonRemote='origin'] - The remote to compare against.
- * @returns {Promise<string[]>} The array of commit messages in the commit log.
- */
-async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main', comparisonRemote = 'origin', }) {
-    try {
-        // Get the current branch name
-        const branch = await getCurrentBranchName({ git });
-        // Check if the current branch has any commits
-        const hasCommits = (await git.raw(['rev-list', '--count', branch])) !== '0';
-        if (!hasCommits) {
-            logger?.log('No commits on the current branch.');
-            return [];
-        }
-        // Get the list of commits that are unique to the current branch
-        let uniqueCommits;
-        if (comparisonBranch === branch) {
-            // If the comparison branch is the same as the current branch, we compare against the remote.
-            uniqueCommits = (await git.raw(['rev-list', `${comparisonRemote}/${comparisonBranch}..${branch}`]))
-                .split('\n')
-                .filter(Boolean)
-                .reverse();
-        }
-        else {
-            // Your existing code for different branches
-            uniqueCommits = (await git.raw(['rev-list', `${comparisonBranch}..${branch}`]))
-                .split('\n')
-                .filter(Boolean)
-                .reverse();
+async function noResult$1({ git, logger }) {
+    const { staged, unstaged, untracked } = await getChanges({ git });
+    const hasStaged = staged && staged.length > 0;
+    const hasUnstaged = unstaged && unstaged.length > 0;
+    const hasUntracked = untracked && untracked.length > 0;
+    if (hasStaged) {
+        logger.log(`Staged files detected, but no summary generated...`, { color: 'red' });
+        logger.log(`Files are likely either:\n  • changed files are ignored\n  • file diff is too large.`, { color: 'yellow' });
+    }
+    else if (hasUnstaged || hasUntracked) {
+        logger.log('Forget something? No staged changes found... 👻', { color: 'red' });
+        if (hasUnstaged) {
+            logger.log('\nChanges not staged for commit:', { color: 'yellow' });
+            logger.verbose(`\t${unstaged.map(({ summary }) => summary).join('\n\t')}`, {
+                color: 'red',
+            });
         }
-        logger?.verbose(`Found ${uniqueCommits.length} unique commits on "${branch}"`, { color: 'blue' });
-        const firstCommit = uniqueCommits[0];
-        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
-        if (!firstCommit || !lastCommit) {
-            logger?.log('Unable to determine first and last commit on the current branch', { color: 'yellow' });
-            return [];
+        if (hasUntracked) {
+            logger.log('\nUntracked changes:', { color: 'yellow' });
+            logger.verbose(`\t${untracked.map(({ summary }) => summary).join('\n\t')}`, {
+                color: 'red',
+            });
         }
-        // Retrieve commit log with messages
-        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
     }
-    catch (error) {
-        logger?.log('Encountered an error getting commit log from current branch', { color: 'red' });
+    else {
+        logger.log('No repo changes detected. 👀', { color: 'blue' });
     }
-    return [];
 }
 
-const template = `Write informative git changelog, in the imperative, based on a series of individual messages.
-
-- Typically a hyphen or asterisk is used for the bullet
-- Summarize dependency updates
-
-{format_instructions}
-
-"""{summary}"""`;
-const inputVariables = ['format_instructions', 'summary'];
-const CHANGELOG_PROMPT = new PromptTemplate({
-    template,
-    inputVariables,
-});
-
-const handler$1 = async (argv, logger) => {
-    const config = loadConfig(argv);
+const handler$2 = async (argv, logger) => {
     const git = getRepo();
+    const config = loadConfig(argv);
     const key = getApiKeyForModel(config);
     const { provider, model } = getModelAndProviderFromConfig(config);
     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-4');
     const llm = getLlm(provider, model, config);
     const INTERACTIVE = isInteractive(config);
     if (INTERACTIVE) {
         logger.log(LOGO);
     }
     async function factory() {
-        const branchName = await getCurrentBranchName({ git });
-        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);
-            }
-            return {
-                branch: branchName,
-                commits: await getCommitLogRange(from, to, { git, noMerges: true }),
-            };
-        }
-        logger.verbose(`No range provided. Defaulting to current branch`, { color: 'yellow' });
-        return {
-            branch: branchName,
-            commits: await getCommitLogCurrentBranch({ git, logger }),
-        };
+        const changes = await getChanges({ git });
+        return changes.staged;
     }
-    async function parser({ branch, commits }) {
-        console.log({ branch, commits });
-        const result = `## ${branch}\n\n${commits.map((commit) => `- ${commit}`).join('\n')}`;
-        return result;
+    async function parser(changes) {
+        return await fileChangeParser({
+            changes,
+            commit: '--staged',
+            options: { tokenizer, git, llm, logger },
+        });
     }
-    const changelogMsg = await generateAndReviewLoop({
-        label: 'changelog',
+    const commitMsg = await generateAndReviewLoop({
+        label: 'commit message',
+        options: {
+            ...config,
+            prompt: config.prompt || COMMIT_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+            review: {
+                descriptions: {
+                    approve: `Commit staged changes with generated commit message`,
+                    edit: 'Edit the commit message before proceeding',
+                    modifyPrompt: 'Modify the prompt template and regenerate the commit message',
+                    retryMessageOnly: 'Restart the function execution from generating the commit message',
+                    retryFull: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
+                },
+            },
+        },
         factory,
         parser,
         agent: async (context, options) => {
             const parser = new JsonOutputParser();
             const prompt = getPrompt({
                 template: options.prompt,
-                variables: CHANGELOG_PROMPT.inputVariables,
-                fallback: CHANGELOG_PROMPT,
+                variables: COMMIT_PROMPT.inputVariables,
+                fallback: COMMIT_PROMPT,
             });
-            const formatInstructions = "Respond with a valid JSON object, containing two fields: 'header' and 'content'.";
-            const changelog = await executeChain({
+            const formatInstructions = "Respond with a valid JSON object, containing two fields: 'title' and 'body', both strings.";
+            const additionalContext = argv.additional ? `${argv.additional}` : '';
+            const commitMsg = await executeChain({
                 llm,
                 prompt,
                 variables: {
                     summary: context,
                     format_instructions: formatInstructions,
+                    additional: additionalContext,
                 },
                 parser,
             });
-            console.log({ changelog });
-            return `${changelog.header}\n\n${changelog.content}`;
+            const appendedText = argv.append ? `\n\n${argv.append}` : '';
+            return `${commitMsg.title}\n\n${commitMsg.body}${appendedText}`;
         },
         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' });
+            await noResult$1({ git, logger });
             process.exit(0);
         },
-        options: {
-            ...config,
-            prompt: config.prompt || CHANGELOG_PROMPT.template,
-            logger,
-            interactive: INTERACTIVE,
-            review: {
-                enableFullRetry: false,
-            },
-        },
     });
     const MODE = (INTERACTIVE && 'interactive') || (config.commit && 'interactive') || config?.mode || 'stdout';
     handleResult({
-        result: changelogMsg,
-        interactiveHandler: async () => {
+        result: commitMsg,
+        interactiveHandler: async (result) => {
+            await createCommit(result, git);
             logSuccess();
         },
         mode: MODE,
@@ -6295,43 +6347,39 @@ const handler$1 = async (argv, logger) => {
 /**
  * Command line options via yargs
  */
-const options$1 = {
-    range: {
-        type: 'string',
-        alias: 'r',
-        description: 'Commit range e.g `HEAD~2:HEAD`',
-    },
-    tokenLimit: { type: 'number', description: 'Token limit' },
-    prompt: {
-        type: 'string',
-        alias: 'p',
-        description: 'Prompt for llm',
-    },
+const options$2 = {
     i: {
-        type: 'boolean',
         alias: 'interactive',
         description: 'Toggle interactive mode',
-    },
-    e: {
         type: 'boolean',
-        alias: 'edit',
-        description: 'Open generated changelog message in editor before proceeding',
     },
-    summarizePrompt: {
+    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',
+    },
+    additional: {
+        description: 'Add extra contextual information to the prompt',
         type: 'string',
-        description: 'Prompt for summarizing large files',
     },
 };
-const builder$1 = (yargs) => {
-    return yargs.options(options$1);
+const builder$2 = (yargsInstance) => {
+    return yargsInstance.options(options$2).usage(getCommandUsageHeader(commit.command));
 };
 
-var changelog = {
-    command: 'changelog',
-    desc: 'Generate a changelog from a commit range',
-    builder: builder$1,
-    handler: commandExecutor(handler$1),
-    options: options$1,
+var commit = {
+    command: 'commit',
+    desc: 'Summarize the staged changes in a commit message.',
+    builder: builder$2,
+    handler: commandExecutor(handler$2),
+    options: options$2,
 };
 
 /**
@@ -6637,7 +6685,7 @@ const questions = {
     }),
 };
 
-const handler = async (argv, logger) => {
+const handler$1 = async (argv, logger) => {
     const options = loadConfig(argv);
     logger.log(LOGO);
     let scope = options?.scope;
@@ -6675,8 +6723,11 @@ const handler = async (argv, logger) => {
         if (advOptions) {
             config.mode = await questions.selectMode();
             config.defaultBranch = await questions.selectDefaultGitBranch();
-            config.temperature = await questions.inputModelTemperature();
-            config.tokenLimit = await questions.inputTokenLimit();
+            config.service = {
+                ...config.service,
+                temperature: await questions.inputModelTemperature(),
+                tokenLimit: await questions.inputTokenLimit(),
+            };
             config.verbose = await questions.enableVerboseMode();
             const promptForIgnores = await confirm({
                 message: 'would you like to configure ignored files and extensions?',
@@ -6740,20 +6791,217 @@ const handler = async (argv, logger) => {
 /**
  * Command line options via yargs
  */
-const options = {
+const options$1 = {
     scope: {
         type: 'string',
         description: 'configure coco for the current user or project?',
         choices: ['global', 'project'],
     },
 };
-const builder = (yargs) => {
-    return yargs.options(options);
+const builder$1 = (yargs) => {
+    return yargs.options(options$1).usage(getCommandUsageHeader(init.command));
 };
 
 var init = {
     command: 'init',
     desc: 'install & configure coco globally or for the current project',
+    builder: builder$1,
+    handler: commandExecutor(handler$1),
+    options: options$1,
+};
+
+/**
+ * Formats a commit log into a readable string format.
+ *
+ * @param commitLog - The commit log result containing an array of commit details.
+ * @returns An array of formatted commit log strings.
+ *
+ * Each formatted string includes:
+ * - The date of the commit in square brackets.
+ * - The commit message.
+ * - The commit body.
+ * - The commit hash in parentheses.
+ * - The author's name and email in angle brackets.
+ */
+const formatCommitLog = (commitLog) => {
+    return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
+};
+
+const getChangesByTimestamp = async ({ since, git }) => {
+    const commitLog = await git.log({ '--since': since });
+    return formatCommitLog(commitLog);
+};
+
+const getChangesSinceLastTag = async ({ git }) => {
+    const tags = await git.tags();
+    if (tags.all.length > 0) {
+        const lastTag = tags.latest;
+        const commitLog = await git.log({ from: lastTag });
+        return formatCommitLog(commitLog);
+    }
+    else {
+        return ['No tags found in the repository.'];
+    }
+};
+
+async function noResult({ logger }) {
+    logger.log('No repo changes detected. 👀', { color: 'blue' });
+}
+
+const template = `Following the formatting instructions, summarize the following changes in the underlying git repository/branch.  
+The summarization should descibe in a general sense what has changed in the repository over the specified timeframe.  Specific files can be mentioned, but the summary should be general enough to be useful to someone who has not seen the changes.
+
+Breaking down the changes into categories (e.g. bug fixes, new features, etc.) with markdown headings is encouraged.
+
+{timeframe}
+
+{format_instructions}
+
+"""{changes}"""`;
+const inputVariables = ['format_instructions', 'changes', 'timeframe'];
+const RECAP_PROMPT = new PromptTemplate({
+    template,
+    inputVariables,
+});
+
+const handler = async (argv, logger) => {
+    const git = getRepo();
+    const config = loadConfig(argv);
+    const key = getApiKeyForModel(config);
+    const { provider, model } = getModelAndProviderFromConfig(config);
+    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-4');
+    const llm = getLlm(provider, model, config);
+    const INTERACTIVE = isInteractive(config);
+    if (INTERACTIVE) {
+        logger.log(LOGO);
+    }
+    const { 'last-month': lastMonth, 'last-tag': lastTag, yesterday, 'last-week': lastWeek } = argv;
+    const timeframe = lastMonth ? 'last-month' : lastTag ? 'last-tag' : yesterday ? 'yesterday' : lastWeek ? 'last-week' : 'current';
+    logger.log(`Generating recap for timeframe: ${timeframe}`);
+    async function factory() {
+        switch (timeframe) {
+            case 'current':
+                const { staged, unstaged, untracked } = await getChanges({ git });
+                logger.log(`Staged: ${staged.length}, Unstaged: ${unstaged?.length || 0}, Untracked: ${untracked?.length || 0}`);
+                const result = await fileChangeParser({
+                    changes: [...staged, ...(unstaged ? unstaged : []), ...(untracked ? untracked : [])],
+                    commit: 'HEAD',
+                    options: { tokenizer, git, llm, logger },
+                });
+                logger.log(`Parsed Result: ${result}`);
+                return [result];
+            case 'yesterday':
+                const yesterday = new Date();
+                yesterday.setDate(yesterday.getDate() - 1);
+                return await getChangesByTimestamp({ git, since: yesterday.toISOString().split('T')[0] });
+            case 'last-week':
+                const lastWeek = new Date();
+                lastWeek.setDate(lastWeek.getDate() - 7);
+                return await getChangesByTimestamp({ git, since: lastWeek.toISOString().split('T')[0] });
+            case 'last-month':
+                const lastMonth = new Date();
+                lastMonth.setMonth(lastMonth.getMonth() - 1);
+                return await getChangesByTimestamp({ git, since: lastMonth.toISOString().split('T')[0] });
+            case 'last-tag':
+                const tags = await getChangesSinceLastTag({ git });
+                return tags;
+            default:
+                logger.log(`Invalid timeframe: ${timeframe}`, { color: 'red' });
+                return [];
+        }
+    }
+    async function parser(changes) {
+        console.log({ changes });
+        return changes.join('\n');
+    }
+    const recap = await generateAndReviewLoop({
+        label: 'recap',
+        options: {
+            ...config,
+            prompt: config.prompt || RECAP_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+            review: {
+                descriptions: {
+                    approve: `Commit staged changes with generated commit message`,
+                    edit: 'Edit the commit message before proceeding',
+                    modifyPrompt: 'Modify the prompt template and regenerate the commit message',
+                    retryMessageOnly: 'Restart the function execution from generating the commit message',
+                    retryFull: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
+                },
+            },
+        },
+        factory,
+        parser,
+        agent: async (context, options) => {
+            const parser = new JsonOutputParser();
+            const formatInstructions = "Respond with a valid JSON object, containing one field: 'summary', a string.";
+            const prompt = getPrompt({
+                template: options.prompt,
+                variables: RECAP_PROMPT.inputVariables,
+                fallback: RECAP_PROMPT,
+            });
+            const response = await executeChain({
+                llm,
+                prompt,
+                variables: {
+                    changes: context,
+                    format_instructions: formatInstructions,
+                    timeframe,
+                },
+                parser,
+            });
+            logger.log(response.summary || 'no response');
+            return `${response.summary}`;
+        },
+        noResult: async () => {
+            await noResult({ git, logger });
+            process.exit(0);
+        },
+    });
+    logger.log(`Recap generated: ${recap}`, { color: 'green' });
+};
+
+/**
+ * Command line options via yargs
+ */
+const options = {
+    yesterday: {
+        type: 'boolean',
+        description: 'Recap for yesterday',
+    },
+    "last-week": {
+        alias: 'week',
+        type: 'boolean',
+        description: 'Recap for last week',
+    },
+    "last-month": {
+        alias: 'month',
+        type: 'boolean',
+        description: 'Recap for last month',
+    },
+    "last-tag": {
+        alias: 'tag',
+        type: 'boolean',
+        description: 'Recap for last tag',
+    },
+    i: {
+        type: 'boolean',
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+    },
+};
+const builder = (yargsInstance) => {
+    return yargsInstance.options(options).usage(getCommandUsageHeader(recap.command));
+};
+
+var recap = {
+    command: 'recap',
+    desc: 'Summarize the changes in the repository over a specified timeframe.',
     builder,
     handler: commandExecutor(handler),
     options,
@@ -6764,22 +7012,11 @@ var types = /*#__PURE__*/Object.freeze({
 });
 
 const y = yargs();
-y.scriptName('coco').usage('$0 <cmd> [args]');
-y.command([commit.command, '$0'], commit.desc, 
-// TODO: fix type on builder
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-commit.builder, commit.handler).options(commit.options);
-y.command(changelog.command, changelog.desc, 
-// TODO: fix type on builder
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-changelog.builder, changelog.handler).options(changelog.options);
-y.command(init.command, init.desc, 
-// TODO: fix type on builder
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-init.builder, init.handler).options(init.options);
-y.parse(process.argv.slice(2));
-
-export { changelog, commit, init, types };
+y.scriptName('coco');
+y.command([commit.command, '$0'], commit.desc, commit.builder, commit.handler);
+y.command(changelog.command, changelog.desc, changelog.builder, changelog.handler);
+y.command(recap.command, recap.desc, recap.builder, recap.handler);
+y.command(init.command, init.desc, init.builder, init.handler);
+y.help().parse(process.argv.slice(2));
+
+export { changelog, commit, init, recap, types };