git-coco 0.11.1 → 0.12.0

package/dist/index.esm.mjs

@@ -2,10 +2,10 @@
 import { PromptTemplate, BasePromptTemplate, ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate } from '@langchain/core/prompts';
 import { ConditionalPromptSelector, isChatModel } from '@langchain/core/example_selectors';
 import yargs from 'yargs';
+import chalk from 'chalk';
 import * as fs from 'fs';
 import fs__default from 'fs';
 import { confirm, editor, select, password, input } from '@inquirer/prompts';
-import chalk from 'chalk';
 import * as ini from 'ini';
 import * as os from 'os';
 import os__default from 'os';
@@ -15,9 +15,10 @@ import Ajv from 'ajv';
 import ora from 'ora';
 import now from 'performance-now';
 import prettyMilliseconds from 'pretty-ms';
-import { BaseOutputParser, JsonOutputParser } from '@langchain/core/output_parsers';
 import { ChatOllama } from '@langchain/ollama';
 import { ChatOpenAI } from '@langchain/openai';
+import { JsonOutputParser, BaseOutputParser } from '@langchain/core/output_parsers';
+import { simpleGit } from 'simple-git';
 import pQueue from 'p-queue';
 import { Document, BaseDocumentTransformer } from '@langchain/core/documents';
 import { RUN_KEY } from '@langchain/core/outputs';
@@ -33,10 +34,30 @@ import '@langchain/core/utils/env';
 import '@langchain/core/utils/json_patch';
 import { createTwoFilesPatch } from 'diff';
 import { minimatch } from 'minimatch';
-import { simpleGit } from 'simple-git';
 import { encoding_for_model } from 'tiktoken';
 import { exec } from 'child_process';
 
+const isInteractive = (config) => {
+    return config?.mode === 'interactive' || !!config?.interactive;
+};
+const SEPERATOR = chalk.blue('─────────────');
+const LOGO = chalk.green(`┌──────┐
+│┏┏┓┏┏┓│
+│┗┗┛┗┗┛│
+└──────┘`);
+chalk.green(`┌────┐
+│coco│
+└────┘`);
+const USAGE_BANNER = chalk.green(`${LOGO}
+${chalk.bgGreen(`\xa0v${process.env.npm_package_version}\xa0`)}
+`);
+const getCommandUsageHeader = (command) => {
+    return chalk.green(`${USAGE_BANNER}\n${chalk.white('Command:')}\n\xa0\xa0\xa0\xa0\xa0 $0 ${chalk.greenBright(command)} [options]`);
+};
+const CONFIG_ALREADY_EXISTS = (path) => {
+    return `coco config found in '${path}', do you want to override it?`;
+};
+
 /**
  * Returns a new object with all undefined keys removed
  *
@@ -47,16 +68,64 @@ function removeUndefined(obj) {
     return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
 }
 
-const template$3 = `GOAL: Use functional abstractions to summarize the following text
+async function updateFileSection({ filePath, startComment, endComment, getNewContent, confirmUpdate = true, confirmMessage = (path) => `A section already exists in ${path}, do you want to override it?`, }) {
+    const lines = fs__default.existsSync(filePath) ? fs__default.readFileSync(filePath, 'utf-8').split(/\r?\n/) : [];
+    const newLines = [];
+    let foundSection = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === startComment) {
+            foundSection = true;
+            if (confirmUpdate) {
+                const confirmOverwrite = await confirm({
+                    message: typeof confirmMessage === 'function' ? confirmMessage(filePath) : confirmMessage,
+                    default: false,
+                });
+                if (!confirmOverwrite) {
+                    // keep all lines until the end comment
+                    while (i < lines.length && lines[i].trim() !== endComment) {
+                        newLines.push(lines[i]);
+                        i++;
+                    }
+                    newLines.push(endComment);
+                    continue;
+                }
+            }
+            newLines.push(startComment);
+            // Insert the new content
+            const newContent = await getNewContent();
+            newLines.push(newContent);
+            // Skip the existing content of the section
+            while (i < lines.length && lines[i].trim() !== endComment) {
+                i++;
+            }
+            newLines.push(endComment);
+            continue;
+        }
+        if (!foundSection || lines[i].trim() !== endComment) {
+            newLines.push(lines[i]);
+        }
+    }
+    // If section wasn't found, append it at the end
+    if (!foundSection) {
+        newLines.push('\n' + startComment);
+        const newContent = await getNewContent();
+        newLines.push(newContent);
+        newLines.push(endComment);
+    }
+    // Write the updated contents back to the file
+    fs__default.writeFileSync(filePath, newLines.join('\n'));
+}
+
+const template$4 = `GOAL: Use functional abstractions to summarize the following text
 
 RULES: Avoid phrases like  "this change", "this code", or "this function" etc. Instead refer to the function, variable, or class by name.
 
 TEXT:"""{text}"""
 `;
-const inputVariables$2 = ['text'];
+const inputVariables$3 = ['text'];
 const SUMMARIZE_PROMPT = new PromptTemplate({
-    inputVariables: inputVariables$2,
-    template: template$3,
+    inputVariables: inputVariables$3,
+    template: template$4,
 });
 
 /**
@@ -182,68 +251,6 @@ const CONFIG_KEYS = Object.keys({
     prompt: '',
 });
 
-async function updateFileSection({ filePath, startComment, endComment, getNewContent, confirmUpdate = true, confirmMessage = (path) => `A section already exists in ${path}, do you want to override it?`, }) {
-    const lines = fs__default.existsSync(filePath) ? fs__default.readFileSync(filePath, 'utf-8').split(/\r?\n/) : [];
-    const newLines = [];
-    let foundSection = false;
-    for (let i = 0; i < lines.length; i++) {
-        if (lines[i].trim() === startComment) {
-            foundSection = true;
-            if (confirmUpdate) {
-                const confirmOverwrite = await confirm({
-                    message: typeof confirmMessage === 'function' ? confirmMessage(filePath) : confirmMessage,
-                    default: false,
-                });
-                if (!confirmOverwrite) {
-                    // keep all lines until the end comment
-                    while (i < lines.length && lines[i].trim() !== endComment) {
-                        newLines.push(lines[i]);
-                        i++;
-                    }
-                    newLines.push(endComment);
-                    continue;
-                }
-            }
-            newLines.push(startComment);
-            // Insert the new content
-            const newContent = await getNewContent();
-            newLines.push(newContent);
-            // Skip the existing content of the section
-            while (i < lines.length && lines[i].trim() !== endComment) {
-                i++;
-            }
-            newLines.push(endComment);
-            continue;
-        }
-        if (!foundSection || lines[i].trim() !== endComment) {
-            newLines.push(lines[i]);
-        }
-    }
-    // If section wasn't found, append it at the end
-    if (!foundSection) {
-        newLines.push('\n' + startComment);
-        const newContent = await getNewContent();
-        newLines.push(newContent);
-        newLines.push(endComment);
-    }
-    // Write the updated contents back to the file
-    fs__default.writeFileSync(filePath, newLines.join('\n'));
-}
-
-const isInteractive = (argv) => {
-    return argv?.mode === 'interactive' || argv.interactive;
-};
-const SEPERATOR = chalk.blue('─────────────');
-const LOGO = chalk.green(`┌────────────┐
-│┌─┐┌─┐┌─┐┌─┐│
-││  │ ││  │ ││
-│└─┘└─┘└─┘└─┘│
-└────────────┘ 
-`);
-const CONFIG_ALREADY_EXISTS = (path) => {
-    return `coco config found in '${path}', do you want to override it?`;
-};
-
 /**
  * Load environment variables
  *
@@ -267,6 +274,9 @@ function loadEnvConfig(config) {
             handleServiceEnvVar(envConfig.service, key, envValue);
         }
         else {
+            if (key === 'service' || !envValue) {
+                return;
+            }
             envConfig[key] = envValue;
         }
     });
@@ -375,7 +385,6 @@ function loadGitConfig(config) {
         config = {
             ...config,
             service: service,
-            temperature: gitConfigParsed.coco?.temperature || config.temperature,
             prompt: gitConfigParsed.coco?.prompt || config.prompt,
             mode: gitConfigParsed.coco?.mode || config.mode,
             summarizePrompt: gitConfigParsed.coco?.summarizePrompt || config.summarizePrompt,
@@ -1915,26 +1924,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
  *
@@ -1975,80 +1964,603 @@ function getPrompt({ template, variables, fallback }) {
         : 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, { chain, textSplitter, options }) {
-    const { returnIntermediateSteps = false } = options || {};
-    const docs = await textSplitter.splitDocuments(documents.map((doc) => new Document(doc)));
-    const res = await chain.invoke({
-        input_documents: docs,
-        returnIntermediateSteps,
-    });
-    if (res.error)
-        throw new Error(res.error);
-    return res.text && res.text.trim();
+function 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();
+    }
+    catch (e) {
+        console.log('Error initializing git repo', e);
+        process.exit(1);
+    }
+    return git;
+};
+
+const template$3 = `Write informative git commit message, in the imperative, based on the diffs & file changes provided in the "Diff Summary" section.  
+Commit Messages must have a short description that is less than 50 characters and a longer detailed summary around 300 characters, the shorter and more concise the better. 
+
+Please follow the guidelines below when writing your commit message:
+
+- Write concisely using an informal tone
+- Avoid phrases like "this commit", "this change", "this function", etc. Instead refer to the function, variable, or class by name
+- Avoid referencing specific files names or long paths in the commit message
+- DO NOT include any diffs or file changes in the commit message
+- Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
+
+{format_instructions}
+
+""""""
+{summary}
+""""""
+
+{additional}
+`;
+const inputVariables$2 = ['summary', 'format_instructions', 'additional'];
+const COMMIT_PROMPT = new PromptTemplate({
+    template: template$3,
+    inputVariables: inputVariables$2,
+});
+
+/**
+ * Verify template string contains all required input variables
+ *
+ * @param text template string
+ * @param inputVariables template variables
+ * @returns boolean or error message
+ */
+function validatePromptTemplate(text, inputVariables) {
+    if (!text) {
+        return 'Prompt template cannot be empty';
+    }
+    if (!inputVariables.some((entry) => text.includes(entry))) {
+        return ('Prompt template must include at least one of the following input variables: ' +
+            inputVariables.map((value) => `{${value}}`).join(', '));
+    }
+    return true;
+}
+
+async function editPrompt(options) {
+    return await editor({
+        message: 'Edit the prompt',
+        default: options.prompt?.length ? options.prompt : COMMIT_PROMPT.template,
+        waitForUseInput: false,
+        postfix: 'Press ENTER to continue',
+        validate: (text) => validatePromptTemplate(text, COMMIT_PROMPT.inputVariables),
+    });
+}
+
+async function editResult(result, options) {
+    if (options.openInEditor) {
+        return await editor({
+            message: 'Edit the commit message',
+            default: result,
+            waitForUseInput: false,
+            validate: (text) => (text ? true : 'Commit message cannot be empty'),
+        });
+    }
+    return result;
+}
+
+async function getUserReviewDecision({ label, descriptions, enableRetry = true, enableFullRetry = true, enableModifyPrompt = true, }) {
+    const choices = [
+        {
+            name: '✨ Looks good!',
+            value: 'approve',
+            description: descriptions?.approve || `Continue with the generated ${label}`,
+        },
+        {
+            name: '📝 Edit',
+            value: 'edit',
+            description: descriptions?.edit || `Edit the generated ${label} before proceeding`,
+        },
+    ];
+    if (enableModifyPrompt) {
+        choices.push({
+            name: '🪶  Modify Prompt',
+            value: 'modifyPrompt',
+            description: descriptions?.modifyPrompt || `Modify the prompt template and regenerate the ${label}`,
+        });
+    }
+    if (enableRetry) {
+        choices.push({
+            name: '🔄 Retry',
+            value: 'retryMessageOnly',
+            description: descriptions?.retryMessageOnly ||
+                `Restart the function execution from generating the ${label}`,
+        });
+    }
+    if (enableFullRetry) {
+        choices.push({
+            name: '🔄 Retry Full',
+            value: 'retryFull',
+            description: descriptions?.retryFull ||
+                `Restart the function execution from the beginning, regenerating both the summary and ${label}`,
+        });
+    }
+    choices.push({
+        name: '💣 Cancel',
+        value: 'cancel',
+        description: descriptions?.cancel || `Cancel the ${label}`,
+    });
+    return (await select({
+        message: `Would you like to make any changes to the ${label}?`,
+        choices,
+    }));
+}
+
+function logResult(label, result) {
+    console.log(`\n${chalk.bgBlue(chalk.bold(`Proposed ${label}:`))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
+}
+
+async function generateAndReviewLoop({ label, factory, parser, noResult, agent, options, }) {
+    const { logger } = options;
+    let continueLoop = true;
+    let modifyPrompt = false;
+    let context = '';
+    let result = '';
+    const changes = await factory();
+    // if we don't have any changes, bail.
+    if (!changes || !Object.keys(changes).length) {
+        await noResult(options);
+    }
+    while (continueLoop) {
+        if (!context.length) {
+            context = await parser(changes, result, options);
+        }
+        // if we still don't have a context, bail.
+        if (!context.length) {
+            await noResult(options);
+        }
+        if (modifyPrompt) {
+            options.prompt = await editPrompt(options);
+        }
+        logger.startTimer().startSpinner(`Generating ${label}\n`, {
+            color: 'blue',
+        });
+        result = await agent(context, options);
+        if (!result) {
+            logger.stopSpinner('💀 Agent failed to return content.', {
+                mode: 'fail',
+                color: 'red',
+            });
+            process.exit(0);
+        }
+        logger
+            .stopSpinner(`Generated ${label}`, {
+            color: 'green',
+            mode: 'succeed',
+        })
+            .stopTimer();
+        if (options?.interactive) {
+            logResult(label, result);
+            const reviewAnswer = await getUserReviewDecision({
+                label,
+                ...(options?.review || {}),
+            });
+            if (reviewAnswer === 'cancel') {
+                process.exit(0);
+            }
+            if (reviewAnswer === 'edit') {
+                options.openInEditor = true;
+            }
+            if (reviewAnswer === 'retryFull') {
+                context = '';
+                result = '';
+                options.prompt = '';
+                continue;
+            }
+            if (reviewAnswer === 'retryMessageOnly') {
+                modifyPrompt = false;
+                result = '';
+                continue;
+            }
+            if (reviewAnswer === 'modifyPrompt') {
+                modifyPrompt = true;
+                result = '';
+                continue;
+            }
+        }
+        // if we're here, we're done.
+        result = await editResult(result, options);
+        continueLoop = false;
+    }
+    return result;
+}
+
+const logSuccess = () => {
+    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
+};
+
+async function handleResult({ result, mode, interactiveHandler }) {
+    switch (mode) {
+        case 'interactive':
+            if (interactiveHandler) {
+                await interactiveHandler(result);
+            }
+            else {
+                console.warn('No result handler provided for interactive mode.');
+                logSuccess();
+            }
+            break;
+        case 'stdout':
+        default:
+            process.stdout.write(result, 'utf8');
+            break;
+    }
+    process.exit(0);
+}
+
+const template$2 = `Write informative git changelog, in the imperative, based on a series of individual messages.
+
+- Include the git commit hash as reference for each change, including just the first 7 characters
+- Logically group changes, and if necessary, summarize dependency updates
+
+{format_instructions}
+
+"""{summary}"""`;
+const inputVariables$1 = ['format_instructions', 'summary'];
+const CHANGELOG_PROMPT = new PromptTemplate({
+    template: template$2,
+    inputVariables: inputVariables$1,
+});
+
+const handler$3 = async (argv, logger) => {
+    const config = loadConfig(argv);
+    const git = getRepo();
+    const key = getApiKeyForModel(config);
+    const { provider, model } = getModelAndProviderFromConfig(config);
+    if (config.service.authentication.type !== 'None' && !key) {
+        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
+        process.exit(1);
+    }
+    const llm = getLlm(provider, model, config);
+    const INTERACTIVE = isInteractive(config);
+    if (INTERACTIVE) {
+        logger.log(LOGO);
+    }
+    async function factory() {
+        const branchName = await getCurrentBranchName({ git });
+        if (config.range && config.range.includes(':')) {
+            const [from, to] = config.range.split(':');
+            if (!from || !to) {
+                logger.log(`Invalid range provided. Expected format is <from>:<to>`, { color: 'red' });
+                process.exit(1);
+            }
+            return {
+                branch: branchName,
+                commits: await getCommitLogRange(from, to, { git, noMerges: true }),
+            };
+        }
+        if (argv.branch) {
+            logger.verbose(`Generating commit log against branch: ${argv.branch}`, { color: 'yellow' });
+            return {
+                branch: branchName,
+                commits: await getCommitLogAgainstBranch({ git, logger, targetBranch: argv.branch }),
+            };
+        }
+        logger.verbose(`No range or branch provided. Defaulting to current branch`, { color: 'yellow' });
+        return {
+            branch: branchName,
+            commits: await getCommitLogCurrentBranch({ git, logger }),
+        };
+    }
+    async function parser({ branch, commits }) {
+        let result;
+        if (!commits || commits.length === 0) {
+            result = `## ${branch}\n\nNo commits found.`;
+        }
+        else {
+            result = `## ${branch}\n\n${commits.map((commit) => commit.trim()).join('\n\n')}`;
+        }
+        return result;
+    }
+    const changelogMsg = await generateAndReviewLoop({
+        label: 'changelog',
+        factory,
+        parser,
+        agent: async (context, options) => {
+            const parser = new JsonOutputParser();
+            const prompt = getPrompt({
+                template: options.prompt,
+                variables: CHANGELOG_PROMPT.inputVariables,
+                fallback: CHANGELOG_PROMPT,
+            });
+            const formatInstructions = "Respond with a valid JSON object, containing two fields: 'header' and 'content', both strings.";
+            const changelog = await executeChain({
+                llm,
+                prompt,
+                variables: {
+                    summary: context,
+                    format_instructions: formatInstructions,
+                },
+                parser,
+            });
+            const branchName = await getCurrentBranchName({ git });
+            const ticketId = extractTicketIdFromBranchName(branchName);
+            const footer = ticketId ? `\n\nPart of **${ticketId}**` : '';
+            return `${changelog.header}\n\n${changelog.content}${footer}`;
+        },
+        noResult: async () => {
+            if (config.range) {
+                logger.log(`No commits found in the provided range.`, { color: 'red' });
+                process.exit(0);
+            }
+            logger.log(`No commits found in the current branch.`, { color: 'red' });
+            process.exit(0);
+        },
+        options: {
+            ...config,
+            prompt: config.prompt || CHANGELOG_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+            review: {
+                enableFullRetry: false,
+            },
+        },
+    });
+    const MODE = (INTERACTIVE && 'interactive') || (config.commit && 'interactive') || config?.mode || 'stdout';
+    handleResult({
+        result: changelogMsg,
+        interactiveHandler: async () => {
+            logSuccess();
+        },
+        mode: MODE,
+    });
+};
+
+/**
+ * Command line options via yargs
+ */
+const options$3 = {
+    range: {
+        type: 'string',
+        alias: 'r',
+        description: 'Commit range e.g `HEAD~2:HEAD`',
+    },
+    branch: {
+        type: 'string',
+        alias: 'b',
+        description: 'Target branch to compare against',
+    },
+    i: {
+        type: 'boolean',
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+    },
+};
+const builder$3 = (yargsInstance) => {
+    return yargsInstance.options(options$3).usage(getCommandUsageHeader(changelog.command));
+};
+
+var changelog = {
+    command: 'changelog',
+    desc: 'Generate a changelog from current or target branch or provided commit range.',
+    builder: builder$3,
+    handler: commandExecutor(handler$3),
+    options: options$3,
+};
+
+/**
+ * Extract the path from a file path string.
+ * @param {string} filePath - The full file path.
+ * @returns {string} The path portion of the file path.
+ */
+function getPathFromFilePath(filePath) {
+    return filePath.split('/').slice(0, -1).join('/');
+}
+
+async function summarize(documents, { chain, textSplitter, options }) {
+    const { returnIntermediateSteps = false } = options || {};
+    const docs = await textSplitter.splitDocuments(documents.map((doc) => new Document(doc)));
+    const res = await chain.invoke({
+        input_documents: docs,
+        returnIntermediateSteps,
+    });
+    if (res.error)
+        throw new Error(res.error);
+    return res.text && res.text.trim();
+}
+
+/**
+ * Create groups from a given node info.
+ * @param {DiffNode} node - The node info to start grouping.
+ * @returns {DirectoryDiff[]} The groups created.
+ */
+function createDirectoryDiffs(node) {
+    const groupByPath = {};
+    function traverse(node) {
+        node.diffs.forEach((diff) => {
+            const path = getPathFromFilePath(diff.file);
+            if (!groupByPath[path]) {
+                groupByPath[path] = { diffs: [], path, tokenCount: 0 };
+            }
+            groupByPath[path].diffs.push(diff);
+            groupByPath[path].tokenCount += diff.tokenCount;
+        });
+        node.children.forEach(traverse);
+    }
+    traverse(node);
+    return Object.values(groupByPath);
+}
+/**
+ * Summarize a directory diff asynchronously.
+ */
+async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
+    try {
+        const directorySummary = await summarize(directory.diffs.map((diff) => ({
+            pageContent: diff.diff,
+            metadata: {
+                file: diff.file,
+                summary: diff.summary,
+            },
+        })), {
+            chain,
+            textSplitter,
+            options: {
+                returnIntermediateSteps: true,
+            },
+        });
+        const newTokenTotal = tokenizer(directorySummary);
+        return {
+            diffs: directory.diffs,
+            path: directory.path,
+            summary: directorySummary,
+            tokenCount: newTokenTotal,
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return directory;
+    }
+}
+const defaultOutputCallback = (group) => {
     let output = `
 -------\n* changes in "/${group.path}"\n\n`;
     if (group.summary) {
@@ -4312,7 +4824,7 @@ var vector_db_qa = /*#__PURE__*/Object.freeze({
 });
 
 /* eslint-disable spaced-comment */
-const template$2 = `Write a concise summary of the following:
+const template$1 = `Write a concise summary of the following:
 
 
 "{text}"
@@ -4320,7 +4832,7 @@ const template$2 = `Write a concise summary of the following:
 
 CONCISE SUMMARY:`;
 const DEFAULT_PROMPT = /*#__PURE__*/ new PromptTemplate({
-    template: template$2,
+    template: template$1,
     inputVariables: ["text"],
 });
 
@@ -5515,410 +6027,187 @@ 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__default.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
-    });
-    const filteredUnstaged = unstaged.filter((file) => {
-        const extension = path__default.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
-    });
-    const filteredUntracked = untracked.filter((file) => {
-        const extension = path__default.extname(file.filePath).toLowerCase();
-        return (!ignoredExtensionsSet.has(extension) &&
-            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
-    });
-    return {
-        staged: filteredStaged,
-        unstaged: filteredUnstaged,
-        untracked: filteredUntracked,
-    };
-}
-
-/**
- * Retrieves the SimpleGit instance for the repository.
- * @returns {SimpleGit} The SimpleGit instance.
- */
-const getRepo = () => {
-    let git;
-    try {
-        git = simpleGit();
-    }
-    catch (e) {
-        console.log('Error initializing git repo', e);
-        process.exit(1);
-    }
-    return git;
-};
-
-const template$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 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';
-    }
-    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 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 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;
 }
 
-async function editResult(result, options) {
-    if (options.openInEditor) {
-        return await editor({
-            message: 'Edit the commit message',
-            default: result,
-            waitForUseInput: false,
-            validate: (text) => (text ? true : 'Commit message cannot be empty'),
-        });
-    }
-    return result;
+/**
+ * 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 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);
+/**
+ * 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;
     }
-    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;
+    else if ('file' in file) {
+        filePath = change?.filePath || file.file;
     }
-    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 {
+        throw new Error('Invalid file type');
     }
-    process.exit(0);
+    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__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
+    });
+    const filteredUnstaged = unstaged.filter((file) => {
+        const extension = path__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
+    });
+    const filteredUntracked = untracked.filter((file) => {
+        const extension = path__default.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch(file.filePath, ignoredPattern)));
+    });
+    return {
+        staged: filteredStaged,
+        unstaged: filteredUnstaged,
+        untracked: filteredUntracked,
+    };
 }
 
 /**
@@ -5943,7 +6232,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;
@@ -5953,338 +6242,102 @@ async function noResult({ git, logger }) {
         logger.log(`Files are likely either:\n  • changed files are ignored\n  • file diff is too large.`, { color: 'yellow' });
     }
     else if (hasUnstaged || hasUntracked) {
-        logger.log('Forget something? No staged changes found... 👻', { color: 'red' });
-        if (hasUnstaged) {
-            logger.log('\nChanges not staged for commit:', { color: 'yellow' });
-            logger.verbose(`\t${unstaged.map(({ summary }) => summary).join('\n\t')}`, {
-                color: 'red',
-            });
-        }
-        if (hasUntracked) {
-            logger.log('\nUntracked changes:', { color: 'yellow' });
-            logger.verbose(`\t${untracked.map(({ summary }) => summary).join('\n\t')}`, {
-                color: 'red',
-            });
-        }
-    }
-    else {
-        logger.log('No repo changes detected. 👀', { color: 'blue' });
-    }
-}
-
-const handler$2 = async (argv, logger) => {
-    const git = getRepo();
-    const options = loadConfig(argv);
-    const key = getApiKeyForModel(options);
-    const { provider, model } = getModelAndProviderFromConfig(options);
-    if (options.service.authentication.type !== 'None' && !key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        process.exit(1);
-    }
-    const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4');
-    const llm = getLlm(provider, model, options);
-    const INTERACTIVE = isInteractive(options);
-    if (INTERACTIVE) {
-        logger.log(LOGO);
-    }
-    async function factory() {
-        const changes = await getChanges({ git });
-        return changes.staged;
-    }
-    async function parser(changes) {
-        return await fileChangeParser({
-            changes,
-            commit: '--staged',
-            options: { tokenizer, git, llm, logger },
-        });
-    }
-    const commitMsg = await generateAndReviewLoop({
-        label: 'commit message',
-        options: {
-            ...options,
-            prompt: options.prompt || COMMIT_PROMPT.template,
-            logger,
-            interactive: INTERACTIVE,
-            review: {
-                descriptions: {
-                    approve: `Commit staged changes with generated commit message`,
-                    edit: 'Edit the commit message before proceeding',
-                    modifyPrompt: 'Modify the prompt template and regenerate the commit message',
-                    retryMessageOnly: 'Restart the function execution from generating the commit message',
-                    retryFull: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
-                },
-            },
-        },
-        factory,
-        parser,
-        agent: async (context, options) => {
-            const parser = new JsonOutputParser();
-            const prompt = getPrompt({
-                template: options.prompt,
-                variables: COMMIT_PROMPT.inputVariables,
-                fallback: COMMIT_PROMPT,
-            });
-            const formatInstructions = "Respond with a valid JSON object, containing two fields: 'title' and 'body'.";
-            const commitMsg = await executeChain({
-                llm,
-                prompt,
-                variables: { summary: context, format_instructions: formatInstructions },
-                parser,
-            });
-            return `${commitMsg.title}\n\n${commitMsg.body}`;
-        },
-        noResult: async () => {
-            await noResult({ git, logger });
-            process.exit(0);
-        },
-    });
-    const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
-    handleResult({
-        result: commitMsg,
-        interactiveHandler: async (result) => {
-            await createCommit(result, git);
-            logSuccess();
-        },
-        mode: MODE,
-    });
-};
-
-/**
- * Command line options via yargs
- */
-const options$2 = {
-    service: { type: 'string', description: 'LLM/Model-Name', choices: ['openai', 'ollama'] },
-    openAIApiKey: {
-        type: 'string',
-        description: 'OpenAI API Key',
-    },
-    tokenLimit: { type: 'number', description: 'Token limit' },
-    prompt: {
-        type: 'string',
-        alias: 'p',
-        description: 'Commit message prompt',
-    },
-    i: {
-        type: 'boolean',
-        alias: 'interactive',
-        description: 'Toggle interactive mode',
-    },
-    s: {
-        type: 'boolean',
-        description: 'Automatically commit staged changes with generated commit message',
-        default: false,
-    },
-    e: {
-        type: 'boolean',
-        alias: 'edit',
-        description: 'Open commit message in editor before proceeding',
-    },
-    summarizePrompt: {
-        type: 'string',
-        description: 'Large file summary prompt',
-    },
-    ignoredFiles: {
-        type: 'array',
-        description: 'Ignored files',
-    },
-    ignoredExtensions: {
-        type: 'array',
-        description: 'Ignored extensions',
-    },
-};
-const builder$2 = (yargs) => {
-    return yargs.options(options$2);
-};
-
-var commit = {
-    command: 'commit',
-    desc: 'Write a commit message summarizing the staged changes.',
-    builder: builder$2,
-    handler: commandExecutor(handler$2),
-    options: options$2,
-};
-
-/**
- * Retrieves the commit log range between two specified commits.
- *
- * @param from - The starting commit.
- * @param to - The ending commit.
- * @param options - Additional options for retrieving the commit log range.
- * @returns A promise that resolves to an array of commit log messages.
- * @throws If there is an error retrieving the commit log range.
- */
-async function getCommitLogRange(from, to, { noMerges, git }) {
-    try {
-        const logOptions = { from: `${from}^1`, to, '--no-merges': noMerges };
-        const commitLog = await git.log(logOptions);
-        return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${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();
+        logger.log('Forget something? No staged changes found... 👻', { color: 'red' });
+        if (hasUnstaged) {
+            logger.log('\nChanges not staged for commit:', { color: 'yellow' });
+            logger.verbose(`\t${unstaged.map(({ summary }) => summary).join('\n\t')}`, {
+                color: 'red',
+            });
         }
-        logger?.verbose(`Found ${uniqueCommits.length} unique commits on "${branch}"`, { color: 'blue' });
-        const firstCommit = uniqueCommits[0];
-        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
-        if (!firstCommit || !lastCommit) {
-            logger?.log('Unable to determine first and last commit on the current branch', { color: 'yellow' });
-            return [];
+        if (hasUntracked) {
+            logger.log('\nUntracked changes:', { color: 'yellow' });
+            logger.verbose(`\t${untracked.map(({ summary }) => summary).join('\n\t')}`, {
+                color: 'red',
+            });
         }
-        // Retrieve commit log with messages
-        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
     }
-    catch (error) {
-        logger?.log('Encountered an error getting commit log from current branch', { color: 'red' });
+    else {
+        logger.log('No repo changes detected. 👀', { color: 'blue' });
     }
-    return [];
 }
 
-const template = `Write informative git changelog, in the imperative, based on a series of individual messages.
-
-- 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 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 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,
@@ -6294,43 +6347,39 @@ const handler$1 = async (argv, logger) => {
 /**
  * Command line options via yargs
  */
-const options$1 = {
-    range: {
-        type: 'string',
-        alias: 'r',
-        description: 'Commit range e.g `HEAD~2:HEAD`',
-    },
-    tokenLimit: { type: 'number', description: 'Token limit' },
-    prompt: {
-        type: 'string',
-        alias: 'p',
-        description: 'Prompt for llm',
-    },
+const options$2 = {
     i: {
-        type: 'boolean',
         alias: 'interactive',
         description: 'Toggle interactive mode',
-    },
-    e: {
         type: 'boolean',
-        alias: 'edit',
-        description: 'Open generated changelog message in editor before proceeding',
     },
-    summarizePrompt: {
+    ignoredFiles: {
+        description: 'Ignored files',
+        type: 'array',
+    },
+    ignoredExtensions: {
+        description: 'Ignored extensions',
+        type: 'array',
+    },
+    append: {
+        description: 'Add content to the end of the generated commit message',
+        type: 'string',
+    },
+    additional: {
+        description: 'Add extra contextual information to the prompt',
         type: 'string',
-        description: 'Prompt for summarizing large files',
     },
 };
-const builder$1 = (yargs) => {
-    return yargs.options(options$1);
+const builder$2 = (yargsInstance) => {
+    return yargsInstance.options(options$2).usage(getCommandUsageHeader(commit.command));
 };
 
-var changelog = {
-    command: 'changelog',
-    desc: 'Generate a changelog from a commit range',
-    builder: builder$1,
-    handler: commandExecutor(handler$1),
-    options: options$1,
+var commit = {
+    command: 'commit',
+    desc: 'Summarize the staged changes in a commit message.',
+    builder: builder$2,
+    handler: commandExecutor(handler$2),
+    options: options$2,
 };
 
 /**
@@ -6636,7 +6685,7 @@ const questions = {
     }),
 };
 
-const handler = async (argv, logger) => {
+const handler$1 = async (argv, logger) => {
     const options = loadConfig(argv);
     logger.log(LOGO);
     let scope = options?.scope;
@@ -6674,8 +6723,11 @@ const handler = async (argv, logger) => {
         if (advOptions) {
             config.mode = await questions.selectMode();
             config.defaultBranch = await questions.selectDefaultGitBranch();
-            config.temperature = await questions.inputModelTemperature();
-            config.tokenLimit = await questions.inputTokenLimit();
+            config.service = {
+                ...config.service,
+                temperature: await questions.inputModelTemperature(),
+                tokenLimit: await questions.inputTokenLimit(),
+            };
             config.verbose = await questions.enableVerboseMode();
             const promptForIgnores = await confirm({
                 message: 'would you like to configure ignored files and extensions?',
@@ -6739,20 +6791,217 @@ const handler = async (argv, logger) => {
 /**
  * Command line options via yargs
  */
-const options = {
+const options$1 = {
     scope: {
         type: 'string',
         description: 'configure coco for the current user or project?',
         choices: ['global', 'project'],
     },
 };
-const builder = (yargs) => {
-    return yargs.options(options);
+const builder$1 = (yargs) => {
+    return yargs.options(options$1).usage(getCommandUsageHeader(init.command));
 };
 
 var init = {
     command: 'init',
     desc: 'install & configure coco globally or for the current project',
+    builder: builder$1,
+    handler: commandExecutor(handler$1),
+    options: options$1,
+};
+
+/**
+ * Formats a commit log into a readable string format.
+ *
+ * @param commitLog - The commit log result containing an array of commit details.
+ * @returns An array of formatted commit log strings.
+ *
+ * Each formatted string includes:
+ * - The date of the commit in square brackets.
+ * - The commit message.
+ * - The commit body.
+ * - The commit hash in parentheses.
+ * - The author's name and email in angle brackets.
+ */
+const formatCommitLog = (commitLog) => {
+    return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
+};
+
+const getChangesByTimestamp = async ({ since, git }) => {
+    const commitLog = await git.log({ '--since': since });
+    return formatCommitLog(commitLog);
+};
+
+const getChangesSinceLastTag = async ({ git }) => {
+    const tags = await git.tags();
+    if (tags.all.length > 0) {
+        const lastTag = tags.latest;
+        const commitLog = await git.log({ from: lastTag });
+        return formatCommitLog(commitLog);
+    }
+    else {
+        return ['No tags found in the repository.'];
+    }
+};
+
+async function noResult({ logger }) {
+    logger.log('No repo changes detected. 👀', { color: 'blue' });
+}
+
+const template = `Following the formatting instructions, summarize the following changes in the underlying git repository/branch.  
+The summarization should descibe in a general sense what has changed in the repository over the specified timeframe.  Specific files can be mentioned, but the summary should be general enough to be useful to someone who has not seen the changes.
+
+Breaking down the changes into categories (e.g. bug fixes, new features, etc.) with markdown headings is encouraged.
+
+{timeframe}
+
+{format_instructions}
+
+"""{changes}"""`;
+const inputVariables = ['format_instructions', 'changes', 'timeframe'];
+const RECAP_PROMPT = new PromptTemplate({
+    template,
+    inputVariables,
+});
+
+const handler = async (argv, logger) => {
+    const git = getRepo();
+    const config = loadConfig(argv);
+    const key = getApiKeyForModel(config);
+    const { provider, model } = getModelAndProviderFromConfig(config);
+    if (config.service.authentication.type !== 'None' && !key) {
+        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
+        process.exit(1);
+    }
+    const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4');
+    const llm = getLlm(provider, model, config);
+    const INTERACTIVE = isInteractive(config);
+    if (INTERACTIVE) {
+        logger.log(LOGO);
+    }
+    const { 'last-month': lastMonth, 'last-tag': lastTag, yesterday, 'last-week': lastWeek } = argv;
+    const timeframe = lastMonth ? 'last-month' : lastTag ? 'last-tag' : yesterday ? 'yesterday' : lastWeek ? 'last-week' : 'current';
+    logger.log(`Generating recap for timeframe: ${timeframe}`);
+    async function factory() {
+        switch (timeframe) {
+            case 'current':
+                const { staged, unstaged, untracked } = await getChanges({ git });
+                logger.log(`Staged: ${staged.length}, Unstaged: ${unstaged?.length || 0}, Untracked: ${untracked?.length || 0}`);
+                const result = await fileChangeParser({
+                    changes: [...staged, ...(unstaged ? unstaged : []), ...(untracked ? untracked : [])],
+                    commit: 'HEAD',
+                    options: { tokenizer, git, llm, logger },
+                });
+                logger.log(`Parsed Result: ${result}`);
+                return [result];
+            case 'yesterday':
+                const yesterday = new Date();
+                yesterday.setDate(yesterday.getDate() - 1);
+                return await getChangesByTimestamp({ git, since: yesterday.toISOString().split('T')[0] });
+            case 'last-week':
+                const lastWeek = new Date();
+                lastWeek.setDate(lastWeek.getDate() - 7);
+                return await getChangesByTimestamp({ git, since: lastWeek.toISOString().split('T')[0] });
+            case 'last-month':
+                const lastMonth = new Date();
+                lastMonth.setMonth(lastMonth.getMonth() - 1);
+                return await getChangesByTimestamp({ git, since: lastMonth.toISOString().split('T')[0] });
+            case 'last-tag':
+                const tags = await getChangesSinceLastTag({ git });
+                return tags;
+            default:
+                logger.log(`Invalid timeframe: ${timeframe}`, { color: 'red' });
+                return [];
+        }
+    }
+    async function parser(changes) {
+        console.log({ changes });
+        return changes.join('\n');
+    }
+    const recap = await generateAndReviewLoop({
+        label: 'recap',
+        options: {
+            ...config,
+            prompt: config.prompt || RECAP_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+            review: {
+                descriptions: {
+                    approve: `Commit staged changes with generated commit message`,
+                    edit: 'Edit the commit message before proceeding',
+                    modifyPrompt: 'Modify the prompt template and regenerate the commit message',
+                    retryMessageOnly: 'Restart the function execution from generating the commit message',
+                    retryFull: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
+                },
+            },
+        },
+        factory,
+        parser,
+        agent: async (context, options) => {
+            const parser = new JsonOutputParser();
+            const formatInstructions = "Respond with a valid JSON object, containing one field: 'summary', a string.";
+            const prompt = getPrompt({
+                template: options.prompt,
+                variables: RECAP_PROMPT.inputVariables,
+                fallback: RECAP_PROMPT,
+            });
+            const response = await executeChain({
+                llm,
+                prompt,
+                variables: {
+                    changes: context,
+                    format_instructions: formatInstructions,
+                    timeframe,
+                },
+                parser,
+            });
+            logger.log(response.summary || 'no response');
+            return `${response.summary}`;
+        },
+        noResult: async () => {
+            await noResult({ git, logger });
+            process.exit(0);
+        },
+    });
+    logger.log(`Recap generated: ${recap}`, { color: 'green' });
+};
+
+/**
+ * Command line options via yargs
+ */
+const options = {
+    yesterday: {
+        type: 'boolean',
+        description: 'Recap for yesterday',
+    },
+    "last-week": {
+        alias: 'week',
+        type: 'boolean',
+        description: 'Recap for last week',
+    },
+    "last-month": {
+        alias: 'month',
+        type: 'boolean',
+        description: 'Recap for last month',
+    },
+    "last-tag": {
+        alias: 'tag',
+        type: 'boolean',
+        description: 'Recap for last tag',
+    },
+    i: {
+        type: 'boolean',
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+    },
+};
+const builder = (yargsInstance) => {
+    return yargsInstance.options(options).usage(getCommandUsageHeader(recap.command));
+};
+
+var recap = {
+    command: 'recap',
+    desc: 'Summarize the changes in the repository over a specified timeframe.',
     builder,
     handler: commandExecutor(handler),
     options,
@@ -6763,22 +7012,11 @@ var types = /*#__PURE__*/Object.freeze({
 });
 
 const y = yargs();
-y.scriptName('coco').usage('$0 <cmd> [args]');
-y.command([commit.command, '$0'], commit.desc, 
-// TODO: fix type on builder
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-commit.builder, commit.handler).options(commit.options);
-y.command(changelog.command, changelog.desc, 
-// TODO: fix type on builder
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-changelog.builder, changelog.handler).options(changelog.options);
-y.command(init.command, init.desc, 
-// TODO: fix type on builder
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-init.builder, init.handler).options(init.options);
-y.parse(process.argv.slice(2));
-
-export { changelog, commit, init, types };
+y.scriptName('coco');
+y.command([commit.command, '$0'], commit.desc, commit.builder, commit.handler);
+y.command(changelog.command, changelog.desc, changelog.builder, changelog.handler);
+y.command(recap.command, recap.desc, recap.builder, recap.handler);
+y.command(init.command, init.desc, init.builder, init.handler);
+y.help().parse(process.argv.slice(2));
+
+export { changelog, commit, init, recap, types };