git-coco 0.11.1 → 0.12.1

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 'use strict';
 
-var prompts = require('@langchain/core/prompts');
+var prompts$1 = require('@langchain/core/prompts');
 var example_selectors = require('@langchain/core/example_selectors');
 var yargs = require('yargs');
-var fs = require('fs');
-var prompts$1 = require('@inquirer/prompts');
 var chalk = require('chalk');
+var fs = require('fs');
+var prompts = require('@inquirer/prompts');
 var ini = require('ini');
 var os = require('os');
 var path = require('path');
@@ -14,9 +14,10 @@ var Ajv = require('ajv');
 var ora = require('ora');
 var now = require('performance-now');
 var prettyMilliseconds = require('pretty-ms');
-var output_parsers = require('@langchain/core/output_parsers');
 var ollama = require('@langchain/ollama');
 var openai = require('@langchain/openai');
+var output_parsers = require('@langchain/core/output_parsers');
+var simpleGit = require('simple-git');
 var pQueue = require('p-queue');
 var documents = require('@langchain/core/documents');
 var outputs = require('@langchain/core/outputs');
@@ -32,7 +33,6 @@ require('@langchain/core/utils/env');
 require('@langchain/core/utils/json_patch');
 var diff = require('diff');
 var minimatch = require('minimatch');
-var simpleGit = require('simple-git');
 var tiktoken = require('tiktoken');
 var child_process = require('child_process');
 
@@ -58,6 +58,27 @@ var ini__namespace = /*#__PURE__*/_interopNamespaceDefault(ini);
 var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
+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
  *
@@ -68,16 +89,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.existsSync(filePath) ? fs.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 prompts.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.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 SUMMARIZE_PROMPT = new prompts.PromptTemplate({
-    inputVariables: inputVariables$2,
-    template: template$3,
+const inputVariables$3 = ['text'];
+const SUMMARIZE_PROMPT = new prompts$1.PromptTemplate({
+    inputVariables: inputVariables$3,
+    template: template$4,
 });
 
 /**
@@ -203,68 +272,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.existsSync(filePath) ? fs.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 prompts$1.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.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
  *
@@ -288,6 +295,9 @@ function loadEnvConfig(config) {
             handleServiceEnvVar(envConfig.service, key, envValue);
         }
         else {
+            if (key === 'service' || !envValue) {
+                return;
+            }
             envConfig[key] = envValue;
         }
     });
@@ -396,7 +406,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,
@@ -1936,26 +1945,6 @@ function commandExecutor(handler) {
     };
 }
 
-const executeChain = async ({ llm, prompt, variables, parser, }) => {
-    if (!llm || !prompt || !variables) {
-        throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
-    }
-    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;
-};
-
 /**
  * Get LLM Model Based on Configuration
  *
@@ -1989,87 +1978,610 @@ function getPrompt({ template, variables, fallback }) {
     if (!template && !fallback)
         throw new Error('Must provide either a template or a fallback');
     return (template
-        ? new prompts.PromptTemplate({
+        ? new prompts$1.PromptTemplate({
             template,
             inputVariables: variables,
         })
         : fallback);
 }
 
-/**
- * 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('/');
-}
+const executeChain = async ({ llm, prompt, variables, parser }) => {
+    if (!llm || !prompt || !variables) {
+        throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
+    }
+    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;
+};
 
-async function summarize(documents$1, { chain, textSplitter, options }) {
-    const { returnIntermediateSteps = false } = options || {};
-    const docs = await textSplitter.splitDocuments(documents$1.map((doc) => new documents.Document(doc)));
-    const res = await chain.invoke({
-        input_documents: docs,
-        returnIntermediateSteps,
-    });
-    if (res.error)
-        throw new Error(res.error);
-    return res.text && res.text.trim();
+function extractTicketIdFromBranchName(branchName) {
+    const regex = /((?<!([A-Z]+)-?)[A-Z]+-\d+)/;
+    const match = branchName.match(regex);
+    return match ? match[0] : null;
 }
 
 /**
- * Create groups from a given node info.
- * @param {DiffNode} node - The node info to start grouping.
- * @returns {DirectoryDiff[]} The groups created.
+ * 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.
  */
-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);
+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(${hash}) - ${author_name}<${author_email}>`);
+    }
+    catch (error) {
+        // If there's an error, handle it appropriately
+        throw error;
     }
-    traverse(node);
-    return Object.values(groupByPath);
 }
+
 /**
- * Summarize a directory diff asynchronously.
+ * 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 summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
+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 {
-        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,
-        };
+        // 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) {
-        console.error(error);
-        return directory;
+        logger?.log('Encountered an error getting commit log between branches', { color: 'red' });
     }
+    return [];
 }
-const defaultOutputCallback = (group) => {
+
+/**
+ * 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.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 prompts$1.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 prompts.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 prompts.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 prompts.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 prompts$1.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 output_parsers.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$1, { chain, textSplitter, options }) {
+    const { returnIntermediateSteps = false } = options || {};
+    const docs = await textSplitter.splitDocuments(documents$1.map((doc) => new documents.Document(doc)));
+    const res = await chain.invoke({
+        input_documents: docs,
+        returnIntermediateSteps,
+    });
+    if (res.error)
+        throw new Error(res.error);
+    return res.text && res.text.trim();
+}
+
+/**
+ * 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) {
@@ -2117,100 +2629,6 @@ async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 204
     return directoryDiffs.map(handleOutput).join('');
 }
 
-class DiffTreeNode {
-    constructor(path) {
-        this.path = [];
-        this.files = [];
-        this.children = new Map();
-        if (path)
-            this.path = path;
-    }
-    addFile(file) {
-        this.files.push(file);
-    }
-    addChild(part, node) {
-        this.children.set(part, node);
-    }
-    getChild(part) {
-        return this.children.get(part);
-    }
-    getPath() {
-        return this.path.join('/');
-    }
-    print(indentation = 0) {
-        const indent = ' '.repeat(indentation);
-        let output = `${indent}- Path: ${this.getPath()}\n`;
-        if (this.files.length > 0) {
-            output += `${indent}  Files:\n`;
-            for (const file of this.files) {
-                output += `${indent}    - ${file.summary}\n`;
-            }
-        }
-        if (this.children.size > 0) {
-            output += `${indent}  Children:\n`;
-            for (const [, child] of this.children) {
-                output += child.print(indentation + 4);
-            }
-        }
-        return output;
-    }
-}
-const createDiffTree = (changes) => {
-    const root = new DiffTreeNode();
-    for (const change of changes) {
-        let currentParent = root;
-        const parts = change.filePath.split('/');
-        parts.pop();
-        for (const part of parts) {
-            let childNode = currentParent.getChild(part);
-            if (!childNode) {
-                childNode = new DiffTreeNode([...currentParent.path, part]);
-                currentParent.addChild(part, childNode);
-            }
-            currentParent = childNode;
-        }
-        // Create a NodeFile object and add it to the parent
-        currentParent.addFile({
-            filePath: change.filePath,
-            oldFilePath: change.oldFilePath,
-            summary: change.summary,
-            status: change.status,
-        });
-    }
-    return root;
-};
-
-/**
- * Asynchronously collect diffs for a given node and its children.
- */
-async function collectDiffs(node, getFileDiff, tokenizer, logger) {
-    // Collect diffs for the files of the current node
-    const diffPromises = node.files.map(async (nodeFile) => {
-        const diff = await getFileDiff(nodeFile);
-        const tokenCount = tokenizer(diff);
-        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
-            color: 'magenta',
-        });
-        return {
-            file: nodeFile.filePath,
-            summary: nodeFile.summary,
-            diff,
-            tokenCount,
-        };
-    });
-    // Collect diffs for the children of the current node
-    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
-    const [diffs, children] = await Promise.all([
-        Promise.all(diffPromises),
-        Promise.all(childrenPromises),
-    ]);
-    return {
-        path: node.getPath(),
-        diffs,
-        children,
-    };
-}
-
 /**
  * Base interface that all chains must implement.
  */
@@ -2645,7 +3063,7 @@ class LLMChain extends BaseChain {
         }
         return new LLMChain({
             llm: await base.BaseLanguageModel.deserialize(llm),
-            prompt: await prompts.BasePromptTemplate.deserialize(prompt),
+            prompt: await prompts$1.BasePromptTemplate.deserialize(prompt),
         });
     }
     /** @deprecated */
@@ -2675,7 +3093,7 @@ You should build the API url in order to get a response that is as short as poss
 
 Question:{question}
 API url:`;
-const API_URL_PROMPT_TEMPLATE = /* #__PURE__ */ new prompts.PromptTemplate({
+const API_URL_PROMPT_TEMPLATE = /* #__PURE__ */ new prompts$1.PromptTemplate({
     inputVariables: ["api_docs", "question"],
     template: API_URL_RAW_PROMPT_TEMPLATE,
 });
@@ -2688,7 +3106,7 @@ Here is the response from the API:
 Summarize this response to answer the original question.
 
 Summary:`;
-const API_RESPONSE_PROMPT_TEMPLATE = /* #__PURE__ */ new prompts.PromptTemplate({
+const API_RESPONSE_PROMPT_TEMPLATE = /* #__PURE__ */ new prompts$1.PromptTemplate({
     inputVariables: ["api_docs", "question", "api_url", "api_response"],
     template: API_RESPONSE_RAW_PROMPT_TEMPLATE,
 });
@@ -3413,7 +3831,7 @@ class RefineDocumentsChain extends BaseChain {
         return "RefineDocumentsChain";
     }
     get defaultDocumentPrompt() {
-        return new prompts.PromptTemplate({
+        return new prompts$1.PromptTemplate({
             inputVariables: ["page_content"],
             template: "{page_content}",
         });
@@ -3570,7 +3988,7 @@ var combine_docs_chain = /*#__PURE__*/Object.freeze({
 });
 
 /* eslint-disable spaced-comment */
-const DEFAULT_QA_PROMPT = /*#__PURE__*/ new prompts.PromptTemplate({
+const DEFAULT_QA_PROMPT = /*#__PURE__*/ new prompts$1.PromptTemplate({
     template: "Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.\n\n{context}\n\nQuestion: {question}\nHelpful Answer:",
     inputVariables: ["context", "question"],
 });
@@ -3579,10 +3997,10 @@ If you don't know the answer, just say that you don't know, don't try to make up
 ----------------
 {context}`;
 const messages = [
-    /*#__PURE__*/ prompts.SystemMessagePromptTemplate.fromTemplate(system_template),
-    /*#__PURE__*/ prompts.HumanMessagePromptTemplate.fromTemplate("{question}"),
+    /*#__PURE__*/ prompts$1.SystemMessagePromptTemplate.fromTemplate(system_template),
+    /*#__PURE__*/ prompts$1.HumanMessagePromptTemplate.fromTemplate("{question}"),
 ];
-const CHAT_PROMPT = /*#__PURE__*/ prompts.ChatPromptTemplate.fromMessages(messages);
+const CHAT_PROMPT = /*#__PURE__*/ prompts$1.ChatPromptTemplate.fromMessages(messages);
 const QA_PROMPT_SELECTOR = /*#__PURE__*/ new example_selectors.ConditionalPromptSelector(DEFAULT_QA_PROMPT, [[example_selectors.isChatModel, CHAT_PROMPT]]);
 
 /**
@@ -4333,15 +4751,15 @@ 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}"
 
 
 CONCISE SUMMARY:`;
-const DEFAULT_PROMPT = /*#__PURE__*/ new prompts.PromptTemplate({
-    template: template$2,
+const DEFAULT_PROMPT = /*#__PURE__*/ new prompts$1.PromptTemplate({
+    template: template$1,
     inputVariables: ["text"],
 });
 
@@ -4357,7 +4775,7 @@ Given the new context, refine the original summary
 If the context isn't useful, return the original summary.
 
 REFINED SUMMARY:`;
-const REFINE_PROMPT = /* #__PURE__ */ new prompts.PromptTemplate({
+const REFINE_PROMPT = /* #__PURE__ */ new prompts$1.PromptTemplate({
     template: refinePromptTemplate,
     inputVariables: ["existing_answer", "text"],
 });
@@ -5459,6 +5877,100 @@ function getTextSplitter(options = {}) {
     return new RecursiveCharacterTextSplitter(options);
 }
 
+/**
+ * Asynchronously collect diffs for a given node and its children.
+ */
+async function collectDiffs(node, getFileDiff, tokenizer, logger) {
+    // Collect diffs for the files of the current node
+    const diffPromises = node.files.map(async (nodeFile) => {
+        const diff = await getFileDiff(nodeFile);
+        const tokenCount = tokenizer(diff);
+        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
+            color: 'magenta',
+        });
+        return {
+            file: nodeFile.filePath,
+            summary: nodeFile.summary,
+            diff,
+            tokenCount,
+        };
+    });
+    // Collect diffs for the children of the current node
+    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
+    const [diffs, children] = await Promise.all([
+        Promise.all(diffPromises),
+        Promise.all(childrenPromises),
+    ]);
+    return {
+        path: node.getPath(),
+        diffs,
+        children,
+    };
+}
+
+class DiffTreeNode {
+    constructor(path) {
+        this.path = [];
+        this.files = [];
+        this.children = new Map();
+        if (path)
+            this.path = path;
+    }
+    addFile(file) {
+        this.files.push(file);
+    }
+    addChild(part, node) {
+        this.children.set(part, node);
+    }
+    getChild(part) {
+        return this.children.get(part);
+    }
+    getPath() {
+        return this.path.join('/');
+    }
+    print(indentation = 0) {
+        const indent = ' '.repeat(indentation);
+        let output = `${indent}- Path: ${this.getPath()}\n`;
+        if (this.files.length > 0) {
+            output += `${indent}  Files:\n`;
+            for (const file of this.files) {
+                output += `${indent}    - ${file.summary}\n`;
+            }
+        }
+        if (this.children.size > 0) {
+            output += `${indent}  Children:\n`;
+            for (const [, child] of this.children) {
+                output += child.print(indentation + 4);
+            }
+        }
+        return output;
+    }
+}
+const createDiffTree = (changes) => {
+    const root = new DiffTreeNode();
+    for (const change of changes) {
+        let currentParent = root;
+        const parts = change.filePath.split('/');
+        parts.pop();
+        for (const part of parts) {
+            let childNode = currentParent.getChild(part);
+            if (!childNode) {
+                childNode = new DiffTreeNode([...currentParent.path, part]);
+                currentParent.addChild(part, childNode);
+            }
+            currentParent = childNode;
+        }
+        // Create a NodeFile object and add it to the parent
+        currentParent.addFile({
+            filePath: change.filePath,
+            oldFilePath: change.oldFilePath,
+            summary: change.summary,
+            status: change.status,
+        });
+    }
+    return root;
+};
+
 /**
  * Parses the default file diff for a given nodeFile.
  *
@@ -5468,8 +5980,15 @@ function getTextSplitter(options = {}) {
  * @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]);
+    if (commit === '--staged') {
+        return await git.diff(['--staged', nodeFile.filePath]);
+    }
+    else if (commit === '--unstaged') {
+        return await git.diff([nodeFile.filePath]);
+    }
+    else if (commit === '--untracked') {
+        // For untracked files, return the entire file content
+        return await git.show([`:${nodeFile.filePath}`]);
     }
     return await git.diff([commit, nodeFile.filePath]);
 }
@@ -5532,414 +6051,187 @@ async function parseRenamedFileDiff(nodeFile, commit, git, logger) {
  * @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;
-    }
-    // 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';
-        }
-    }
-    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');
-    }
-}
-
-/**
- * Returns the summary text for a file change.
- *
- * @param file - The file status or diff result.
- * @param change - The partial file change object.
- * @returns The summary text for the file change.
- * @throws Error if the file type is invalid.
- */
-function getSummaryText(file, change) {
-    const status = change.status || getStatus(file);
-    let filePath;
-    if ('path' in file) {
-        filePath = file.path;
-    }
-    else if ('file' in file) {
-        filePath = change?.filePath || file.file;
-    }
-    else {
-        throw new Error('Invalid file type');
-    }
-    if (change.oldFilePath) {
-        return `${status}: ${change.oldFilePath} -> ${filePath}`;
-    }
-    return `${status}: ${filePath}`;
-}
-
-/**
- * Retrieves the 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.
- */
-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.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
-    });
-    const filteredUnstaged = unstaged.filter((file) => {
-        const extension = path.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
-    });
-    const filteredUntracked = untracked.filter((file) => {
-        const extension = path.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
-    });
-    return {
-        staged: filteredStaged,
-        unstaged: filteredUnstaged,
-        untracked: filteredUntracked,
-    };
-}
-
-/**
- * Retrieves the SimpleGit instance for the repository.
- * @returns {SimpleGit} The SimpleGit instance.
- */
-const getRepo = () => {
-    let git;
-    try {
-        git = simpleGit.simpleGit();
-    }
-    catch (e) {
-        console.log('Error initializing git repo', e);
-        process.exit(1);
-    }
-    return git;
-};
-
-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:
-
-- 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\`
-
-{format_instructions}
-
-"""{summary}"""`;
-const inputVariables$1 = ['summary', 'format_instructions'];
-const COMMIT_PROMPT = new prompts.PromptTemplate({
-    template: template$1,
-    inputVariables: inputVariables$1,
-});
-
-/**
- * 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';
+async function getDiff(nodeFile, commit, { git, logger, }) {
+    if (nodeFile.status === 'deleted') {
+        return 'This file has been deleted.';
     }
-    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(', '));
+    if (nodeFile.status === 'renamed' && nodeFile.oldFilePath) {
+        const renamedDiff = await parseRenamedFileDiff(nodeFile, commit, git, logger);
+        return renamedDiff;
     }
-    return true;
+    // If not deleted or renamed, get the diff from the index
+    const defaultDiff = await parseDefaultFileDiff(nodeFile, commit, git);
+    return defaultDiff;
 }
 
-async function editPrompt(options) {
-    return await prompts$1.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),
+// 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 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;
 }
 
-async function editResult(result, options) {
-    if (options.openInEditor) {
-        return await prompts$1.editor({
-            message: 'Edit the commit message',
-            default: result,
-            waitForUseInput: false,
-            validate: (text) => (text ? true : 'Commit message cannot be empty'),
-        });
-    }
-    return result;
+/**
+ * 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);
 }
 
-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}`,
-        });
+/**
+ * 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 (enableRetry) {
-        choices.push({
-            name: '🔄 Retry',
-            value: 'retryMessageOnly',
-            description: descriptions?.retryMessageOnly ||
-                `Restart the function execution from generating the ${label}`,
-        });
+    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';
     }
-    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}`,
-        });
+    else {
+        throw new Error('Invalid file type');
     }
-    choices.push({
-        name: '💣 Cancel',
-        value: 'cancel',
-        description: descriptions?.cancel || `Cancel the ${label}`,
-    });
-    return (await prompts$1.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;
+/**
+ * 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;
     }
-    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;
+    else if ('file' in file) {
+        filePath = change?.filePath || file.file;
     }
-    process.exit(0);
+    else {
+        throw new Error('Invalid file type');
+    }
+    if (change.oldFilePath) {
+        return `${status}: ${change.oldFilePath} -> ${filePath}`;
+    }
+    return `${status}: ${filePath}`;
+}
+
+/**
+ * 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.
+ */
+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.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
+    });
+    const filteredUnstaged = unstaged.filter((file) => {
+        const extension = path.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
+    });
+    const filteredUntracked = untracked.filter((file) => {
+        const extension = path.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
+    });
+    return {
+        staged: filteredStaged,
+        unstaged: filteredUnstaged,
+        untracked: filteredUntracked,
+    };
 }
 
 /**
@@ -5964,7 +6256,7 @@ const getTokenCounter = async (modelName) => {
     });
 };
 
-async function noResult({ git, logger }) {
+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;
@@ -5975,337 +6267,101 @@ async function noResult({ git, logger }) {
     }
     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' });
-    }
-}
-
-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 output_parsers.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(${hash}) - ${author_name}<${author_email}>`);
-    }
-    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();
+        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.
-
-- 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 = ['format_instructions', 'summary'];
-const CHANGELOG_PROMPT = new prompts.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 }) {
-        const result = `## ${branch}\n\n${commits.map((commit) => `${commit}`).join('\n\n\n')}`;
-        console.log({ result });
-        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 output_parsers.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', both strings.";
-            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,
             });
-            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,
@@ -6315,43 +6371,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,
 };
 
 /**
@@ -6451,13 +6503,13 @@ async function checkAndHandlePackageInstallation({ global = false, logger, }) {
         const projectRoot = findProjectRoot(process.cwd());
         let shouldInstall = false;
         if (isPackageInstalled(packageName, projectRoot)) {
-            shouldInstall = await prompts$1.confirm({
+            shouldInstall = await prompts.confirm({
                 message: `'${packageName}' is already installed in '${projectRoot}/package.json', would you like to update?`,
                 default: shouldInstall,
             });
         }
         else {
-            shouldInstall = await prompts$1.confirm({
+            shouldInstall = await prompts.confirm({
                 message: `'${packageName}' is not installed in '${projectRoot}/package.json', would you like to install?`,
                 default: shouldInstall,
             });
@@ -6495,7 +6547,7 @@ const questions = {
     /**
      * @description configure coco globally for the current user or project?
      */
-    whatScope: async () => await prompts$1.select({
+    whatScope: async () => await prompts.select({
         message: 'configure coco globally for the current user or for the current directory?',
         choices: [
             {
@@ -6510,7 +6562,7 @@ const questions = {
             },
         ],
     }),
-    selectLLMProvider: async () => await prompts$1.select({
+    selectLLMProvider: async () => await prompts.select({
         message: 'select language model provider:',
         choices: [
             {
@@ -6552,7 +6604,7 @@ const questions = {
                 })),
             ];
         }
-        return await prompts$1.select({
+        return await prompts.select({
             message: 'select language model:',
             choices: availableModels,
         });
@@ -6563,7 +6615,7 @@ const questions = {
      * print results to stdout
      * @returns 'interactive' | 'stdout'
      */
-    selectMode: async () => await prompts$1.select({
+    selectMode: async () => await prompts.select({
         message: 'select mode:',
         choices: [
             {
@@ -6581,19 +6633,19 @@ const questions = {
     inputOpenAIApiKey: async () => {
         // check for existing env var
         if (process.env.OPENAI_API_KEY) {
-            return (await prompts$1.confirm({
+            return (await prompts.confirm({
                 message: `use existing OPENAI_API_KEY env var?`,
                 default: true,
             }))
                 ? process.env.OPENAI_API_KEY
-                : await prompts$1.password({
+                : await prompts.password({
                     message: `enter your OpenAI API key:`,
                     validate(input) {
                         return input.length > 0 ? true : 'API key cannot be empty';
                     },
                 });
         }
-        return await prompts$1.password({
+        return await prompts.password({
             message: `enter your OpenAI API key:`,
             validate(input) {
                 return input.length > 0 ? true : 'API key cannot be empty';
@@ -6601,48 +6653,48 @@ const questions = {
         });
     },
     inputTokenLimit: async () => {
-        const tokenLimit = await prompts$1.input({
+        const tokenLimit = await prompts.input({
             message: 'maximum number of tokens for generating commit messages:',
             default: '300',
         });
         return parseInt(tokenLimit);
     },
     inputModelTemperature: async () => {
-        const temperature = await prompts$1.input({
+        const temperature = await prompts.input({
             message: 'model temperature for generating commit messages:',
             default: '0.36',
         });
         return parseFloat(temperature);
     },
-    selectDefaultGitBranch: async () => (await prompts$1.input({
+    selectDefaultGitBranch: async () => (await prompts.input({
         message: 'default branch for the repository:',
         default: 'main',
     })) || 'main',
-    configureAdvancedOptions: async () => await prompts$1.confirm({
+    configureAdvancedOptions: async () => await prompts.confirm({
         message: 'would you like to configure advanced options?',
         default: false,
     }),
-    enableVerboseMode: async () => await prompts$1.confirm({
+    enableVerboseMode: async () => await prompts.confirm({
         message: 'enable verbose logging:',
         default: false,
     }),
-    whatFilesToIgnore: async () => (await prompts$1.input({
+    whatFilesToIgnore: async () => (await prompts.input({
         message: 'paths of files to be excluded when generating commit messages (comma-separated):',
         default: 'package-lock.json',
     }))
         ?.split(',')
         ?.map((file) => file.trim()) || [],
-    whatExtensionsToIgnore: async () => (await prompts$1.input({
+    whatExtensionsToIgnore: async () => (await prompts.input({
         message: 'file extensions to be excluded when generating commit messages (comma-separated):',
         default: '.map, .lock',
     }))
         ?.split(',')
         ?.map((ext) => ext.trim()) || [],
-    modifyCommitPrompt: async () => await prompts$1.editor({
+    modifyCommitPrompt: async () => await prompts.editor({
         message: 'modify default commit message prompt:',
         default: COMMIT_PROMPT.template,
     }),
-    selectProjectConfigFileType: async () => await prompts$1.select({
+    selectProjectConfigFileType: async () => await prompts.select({
         message: 'where would you like to store the project config?',
         choices: [
             {
@@ -6657,7 +6709,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;
@@ -6695,10 +6747,13 @@ 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 prompts$1.confirm({
+            const promptForIgnores = await prompts.confirm({
                 message: 'would you like to configure ignored files and extensions?',
                 default: false,
             });
@@ -6706,7 +6761,7 @@ const handler = async (argv, logger) => {
                 config.ignoredFiles = await questions.whatFilesToIgnore();
                 config.ignoredExtensions = await questions.whatExtensionsToIgnore();
             }
-            const promptForCommitPrompt = await prompts$1.confirm({
+            const promptForCommitPrompt = await prompts.confirm({
                 message: 'would you like to configure the commit message prompt?',
                 default: false,
             });
@@ -6723,7 +6778,7 @@ const handler = async (argv, logger) => {
                 approvalMessage = 'looking good? (API key hidden for security)';
             }
         }
-        const isApproved = await prompts$1.confirm({
+        const isApproved = await prompts.confirm({
             message: approvalMessage,
         });
         let configFilePath = '';
@@ -6760,20 +6815,228 @@ 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 prompts$1.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 unstagedChanges = await fileChangeParser({
+                    changes: unstaged || [],
+                    commit: '--unstaged',
+                    options: { tokenizer, git, llm, logger },
+                });
+                const unstagedResponse = `Unstaged changes:\n${unstagedChanges}`;
+                const untrackedChanges = await fileChangeParser({
+                    changes: untracked || [],
+                    commit: '--untracked',
+                    options: { tokenizer, git, llm, logger },
+                });
+                const untrackedResponse = `Untracked changes:\n${untrackedChanges}`;
+                const stagedChanges = await fileChangeParser({
+                    changes: staged,
+                    commit: '--staged',
+                    options: { tokenizer, git, llm, logger },
+                });
+                const stagedResponse = `Staged changes:\n${stagedChanges}`;
+                return [unstagedResponse, untrackedResponse, stagedResponse];
+            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) {
+        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 output_parsers.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,
@@ -6784,25 +7047,15 @@ 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));
+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));
 
 exports.changelog = changelog;
 exports.commit = commit;
 exports.init = init;
+exports.recap = recap;
 exports.types = types;