git-coco 0.3.3 → 0.4.0

package/dist/index.esm.mjs

@@ -1,231 +1,26 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
-import { simpleGit } from 'simple-git';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import path__default from 'path';
-import * as ini from 'ini';
-import { PromptTemplate } from 'langchain/prompts';
-import chalk from 'chalk';
-import { select, editor } from '@inquirer/prompts';
 import pQueue from 'p-queue';
 import { Document } from 'langchain/document';
 import { HuggingFaceInference } from 'langchain/llms/hf';
+import { PromptTemplate } from 'langchain/prompts';
 import { loadSummarizationChain, LLMChain } from 'langchain/chains';
 import { OpenAI } from 'langchain/llms/openai';
 import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
 import { createTwoFilesPatch } from 'diff';
-import { minimatch } from 'minimatch';
 import GPT3NodeTokenizer from 'gpt3-tokenizer';
+import chalk from 'chalk';
 import ora from 'ora';
 import now from 'performance-now';
 import prettyMilliseconds from 'pretty-ms';
-
-/**
- * Returns a new object with all undefined keys removed
- *
- * @param obj Object to remove undefined keys from
- * @returns
- */
-function removeUndefined(obj) {
-    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
-}
-
-/**
- * Load environment variables
- *
- * @param {Config} config
- * @returns {Config} Updated config
- **/
-function loadEnvConfig(config) {
-    const envConfig = {
-        model: process.env.COCO_MODEL || undefined,
-        openAIApiKey: process.env.OPENAI_API_KEY || undefined,
-        huggingFaceHubApiKey: process.env.HUGGINGFACE_HUB_API_KEY || undefined,
-        tokenLimit: process.env.COCO_TOKEN_LIMIT
-            ? parseInt(process.env.COCO_TOKEN_LIMIT)
-            : undefined,
-        prompt: process.env.COCO_PROMPT,
-        mode: process.env.COCO_MODE,
-        summarizePrompt: process.env.COCO_SUMMARIZE_PROMPT,
-        ignoredFiles: process.env.COCO_IGNORED_FILES
-            ? process.env.COCO_IGNORED_FILES.split(',')
-            : undefined,
-        ignoredExtensions: process.env.COCO_IGNORED_EXTENSIONS
-            ? process.env.COCO_IGNORED_EXTENSIONS.split(',')
-            : undefined,
-    };
-    config = { ...config, ...removeUndefined(envConfig) };
-    return config;
-}
-
-/**
- * Load git profile config (from ~/.gitconfig)
- *
- * @param {Config} config
- * @returns {Config} Updated config
- **/
-function loadGitConfig(config) {
-    const gitConfigPath = path.join(os.homedir(), '.gitconfig');
-    if (fs.existsSync(gitConfigPath)) {
-        const gitConfigRaw = fs.readFileSync(gitConfigPath, 'utf-8');
-        const gitConfigParsed = ini.parse(gitConfigRaw);
-        config = {
-            ...config,
-            model: gitConfigParsed.coco?.model || config.model,
-            openAIApiKey: gitConfigParsed.coco?.openAIApiKey || config.openAIApiKey,
-            huggingFaceHubApiKey: gitConfigParsed.coco?.huggingFaceHubApiKey || config.huggingFaceHubApiKey,
-            tokenLimit: parseInt(gitConfigParsed.coco?.tokenLimit) || config.tokenLimit,
-            prompt: gitConfigParsed.coco?.prompt || config.prompt,
-            mode: gitConfigParsed.coco?.mode || config.mode,
-            temperature: gitConfigParsed.coco?.temperature || config.temperature,
-            summarizePrompt: gitConfigParsed.coco?.summarizePrompt || config.summarizePrompt,
-            ignoredFiles: gitConfigParsed.coco?.ignoredFiles || config.ignoredFiles,
-            ignoredExtensions: gitConfigParsed.coco?.ignoredExtensions || config.ignoredExtensions,
-        };
-    }
-    return config;
-}
-
-/**
- * Load .gitignore in project root
- *
- * @param {Config} config
- * @returns
- */
-function loadGitignore(config) {
-    if (fs.existsSync('.gitignore')) {
-        const gitignoreContent = fs.readFileSync('.gitignore', 'utf-8');
-        config.ignoredFiles = [
-            ...(config?.ignoredFiles || []),
-            ...gitignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
-        ];
-    }
-    return config;
-}
-/**
- * Load .ignore in project root
- *
- * @param {Config} config
- * @returns
- */
-function loadIgnore(config) {
-    if (fs.existsSync('.ignore')) {
-        const ignoreContent = fs.readFileSync('.ignore', 'utf-8');
-        config.ignoredFiles = [
-            ...(config?.ignoredFiles || []),
-            ...ignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
-        ];
-    }
-    return config;
-}
-
-/**
- * Load project config
- *
- * @param {Config} config
- * @returns {Config} Updated config
- **/
-function loadProjectConfig(config) {
-    if (fs.existsSync('.coco.config.json')) {
-        const projectConfig = JSON.parse(fs.readFileSync('.coco.config.json', 'utf-8'));
-        config = { ...config, ...projectConfig };
-    }
-    return config;
-}
-
-/**
- * Load XDG config
- *
- * @param {Config} config
- * @returns {Config} Updated config
- */
-function loadXDGConfig(config) {
-    const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
-    const xdgConfigPath = path.join(xdgConfigHome, 'coco', 'config.json');
-    if (fs.existsSync(xdgConfigPath)) {
-        const xdgConfig = JSON.parse(fs.readFileSync(xdgConfigPath, 'utf-8'));
-        config = { ...config, ...xdgConfig };
-    }
-    return config;
-}
-
-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 followed by a newline character and then a more verbose detailed description.
-
-- Typically a hyphen or asterisk is used for the bullet
-- 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 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
-- Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
-
-"""{summary}"""
-
-Commit:`;
-const inputVariables$1 = ['summary'];
-const COMMIT_PROMPT = new PromptTemplate({
-    template: template$1,
-    inputVariables: inputVariables$1,
-});
-
-const template = `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 = ['text'];
-const SUMMARIZE_PROMPT = new PromptTemplate({
-    template,
-    inputVariables,
-});
-
-/**
- * Default Config
- *
- * @type {Config}
- */
-const DEFAULT_CONFIG = {
-    model: 'openai/gpt-4',
-    verbose: false,
-    tokenLimit: 1024,
-    prompt: COMMIT_PROMPT.template,
-    summarizePrompt: SUMMARIZE_PROMPT.template,
-    temperature: 0.4,
-    mode: 'stdout',
-    ignoredFiles: ['package-lock.json'],
-    ignoredExtensions: ['.map', '.lock'],
-};
-/**
- * Load application config
- *
- * Merge config from multiple sources.
- *
- * \* Order of precedence:
- * \* 1. Command line flags
- * \* 2. Environment variables
- * \* 3. Project config
- * \* 4. Git config
- * \* 5. XDG config
- * \* 6. .gitignore
- * \* 7. .ignore
- * \* 8. Default config
- *
- * @returns {Config} application config
- **/
-function loadConfig(argv = {}) {
-    // Default config
-    let config = DEFAULT_CONFIG;
-    config = loadGitignore(config);
-    config = loadIgnore(config);
-    config = loadXDGConfig(config);
-    config = loadGitConfig(config);
-    config = loadProjectConfig(config);
-    config = loadEnvConfig(config);
-    return { ...config, ...argv };
-}
+import * as path from 'path';
+import path__default from 'path';
+import { minimatch } from 'minimatch';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as ini from 'ini';
+import { simpleGit } from 'simple-git';
+import { editor, select } from '@inquirer/prompts';
 
 /**
  * Extract the path from a file path string.
@@ -368,6 +163,23 @@ class DiffTreeNode {
     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();
@@ -461,7 +273,7 @@ function getModel(name, key, fields) {
  * @param options
  * @returns
  */
-function getModelAPIKey(name, options) {
+function getApiKeyForModel(name, options) {
     const [llm, model] = name.split(/\/(.*)/s);
     if (!model) {
         throw new Error(`Invalid model: ${name}`);
@@ -518,19 +330,47 @@ function validatePromptTemplate(text, inputVariables) {
     return true;
 }
 
-const parseDefaultFileDiff = async (nodeFile, git) => {
-    return await git.diff(['--staged', nodeFile.filePath]);
-};
-const parseRenamedFileDiff = async (nodeFile, git, logger) => {
+const template$2 = `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 PromptTemplate({
+    template: template$2,
+    inputVariables: inputVariables$2,
+});
+
+async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
+    if (commit !== '--staged') {
+        return await git.diff([`${commit}~1..${commit}`, '--', nodeFile.filePath]);
+    }
+    return await git.diff([commit, nodeFile.filePath]);
+}
+async function parseRenamedFileDiff(nodeFile, commit, git, logger) {
     let result = '';
     const oldFilePath = nodeFile?.oldFilePath || nodeFile.filePath;
+    let previousCommitHash = 'HEAD';
+    let newCommitHash = '';
+    if (commit !== '--staged') {
+        try {
+            previousCommitHash = await git.revparse([`${commit}~1`]);
+        }
+        catch (err) {
+            logger.verbose(`Error getting previous commit hash for ${nodeFile.filePath}`, {
+                color: 'red',
+            });
+        }
+        newCommitHash = commit;
+    }
     try {
-        const [headContent, indexContent] = await Promise.all([
-            git.show([`HEAD:${oldFilePath}`]),
-            git.show([`:${nodeFile.filePath}`]),
+        const [previousContent, newContent] = await Promise.all([
+            git.show([`${previousCommitHash}:${oldFilePath}`]),
+            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
         ]);
-        if (headContent !== indexContent) {
-            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, headContent, indexContent, '', '', {
+        if (previousContent !== newContent) {
+            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
                 context: 3,
             });
             // remove the first 4 lines of the patch (they contain the old and new file names)
@@ -545,23 +385,23 @@ const parseRenamedFileDiff = async (nodeFile, git, logger) => {
         result = 'Error comparing file contents.';
     }
     return result;
-};
-const getDiff = async (nodeFile, { git, logger, }) => {
+}
+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, git, logger);
+        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, git);
+    const defaultDiff = await parseDefaultFileDiff(nodeFile, commit, git);
     return defaultDiff;
-};
+}
 
 const MAX_TOKENS_PER_SUMMARY = 2048;
-const fileChangeParser = async (changes, { tokenizer, git, model, logger }) => {
-    const textSplitter = getTextSplitter({ chunkSize: 2000, chunkOverlap: 125, });
+async function fileChangeParser({ changes, commit, options: { tokenizer, git, model, logger }, }) {
+    const textSplitter = getTextSplitter({ chunkSize: 2000, chunkOverlap: 125 });
     const summarizationChain = getChain(model, {
         type: 'map_reduce',
         combineMapPrompt: SUMMARIZE_PROMPT,
@@ -572,7 +412,7 @@ const fileChangeParser = async (changes, { tokenizer, git, model, logger }) => {
     logger.stopTimer('Created file hierarchy');
     // Collect diffs
     logger.startTimer().startSpinner(`Collecting Diffs...\n`, { color: 'blue' });
-    const diffs = await collectDiffs(rootTreeNode, (path) => getDiff(path, { git, logger }), tokenizer, logger);
+    const diffs = await collectDiffs(rootTreeNode, (path) => getDiff(path, commit, { git, logger }), tokenizer, logger);
     logger.stopSpinner('Diffs Collected').stopTimer();
     // Summarize diffs
     logger.startTimer();
@@ -581,36 +421,105 @@ const fileChangeParser = async (changes, { tokenizer, git, model, logger }) => {
         maxTokens: MAX_TOKENS_PER_SUMMARY,
         textSplitter,
         chain: summarizationChain,
-        logger
+        logger,
     });
     logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
     return summary;
-};
+}
 
-const llm = async ({ llm, prompt, variables }) => {
-    if (!llm || !prompt || !variables) {
-        throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
-    }
-    const chain = new LLMChain({ llm, prompt });
-    let res;
-    try {
-        res = await chain.call(variables);
+/**
+ * Wrapper around GPT3NodeTokenizer to handle default export.
+ *
+ * @see https://github.com/botisan-ai/gpt3-tokenizer/issues/18
+ *
+ * @returns {GPT3NodeTokenizer} The GPT3NodeTokenizer instance.
+ */
+const getTokenizer = () => {
+    let tokenizer;
+    // eslint-disable-next-line
+    // @ts-ignore
+    if (GPT3NodeTokenizer.default) {
+        // eslint-disable-next-line
+        // @ts-ignore
+        tokenizer = new GPT3NodeTokenizer.default({ type: 'gpt3' });
     }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`LLMChain call error: ${error.message}`);
+    else {
+        tokenizer = new GPT3NodeTokenizer({ type: 'gpt3' });
+    }
+    return tokenizer;
+};
+
+class Logger {
+    constructor(config) {
+        this.config = config;
+        this.spinner = null;
+    }
+    log(message, options = { color: 'blue' }) {
+        let outputMessage = message;
+        if (options.color) {
+            outputMessage = chalk[options.color](outputMessage);
         }
+        console.log(outputMessage);
+        return this;
     }
-    if (!res) {
-        throw new Error('Empty response from LLMChain call');
+    verbose(message, options = {}) {
+        if (!this.config?.verbose) {
+            return this;
+        }
+        this.log(message, options);
+        return this;
     }
-    if (res.error) {
-        throw new Error(`LLMChain response error: ${res.error}`);
+    startTimer() {
+        this.timerStart = now();
+        return this;
     }
-    return res.text.trim();
-};
+    stopTimer(message, options = { color: 'yellow' }) {
+        if (!this.config?.verbose || !this.timerStart) {
+            return this;
+        }
+        const elapsedTime = prettyMilliseconds(now() - this.timerStart);
+        let outputMessage = message
+            ? `${message} (⏲ ${elapsedTime})`
+            : `⏲ ${elapsedTime}`;
+        if (options.color) {
+            outputMessage = chalk[options.color](outputMessage);
+        }
+        console.log(outputMessage);
+        return this;
+    }
+    startSpinner(message, options = { color: 'green' }) {
+        const spinnerMessage = options.color ? chalk[options.color](message) : message;
+        this.spinner = ora(spinnerMessage).start();
+        return this;
+    }
+    stopSpinner(message = '', options = { mode: 'succeed', color: 'green' }) {
+        const spinnerMessage = options?.color ? chalk[options.color](message) : message;
+        this.spinner?.[options.mode || 'succeed'](spinnerMessage);
+        this.spinner = null;
+        return this;
+    }
+}
+
+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 followed by a newline character and then a more verbose detailed description.
+
+- Typically a hyphen or asterisk is used for the bullet
+- 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 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
+- Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
+
+"""{summary}"""
 
-const getStatus = (file, location = 'index') => {
+Commit:`;
+const inputVariables$1 = ['summary'];
+const COMMIT_PROMPT = new PromptTemplate({
+    template: template$1,
+    inputVariables: inputVariables$1,
+});
+
+function getStatus(file, location = 'index') {
     if ('index' in file && 'working_dir' in file) {
         const statusCode = file[location];
         switch (statusCode) {
@@ -642,11 +551,11 @@ const getStatus = (file, location = 'index') => {
         return 'unknown';
     }
     else {
-        throw new Error("Invalid file type");
+        throw new Error('Invalid file type');
     }
-};
+}
 
-const getSummaryText = (file, change) => {
+function getSummaryText(file, change) {
     const status = change.status || getStatus(file);
     let filePath;
     if ('path' in file) {
@@ -656,13 +565,186 @@ const getSummaryText = (file, change) => {
         filePath = change?.filePath || file.file;
     }
     else {
-        throw new Error("Invalid file type");
+        throw new Error('Invalid file type');
     }
     if (change.oldFilePath) {
         return `${status}: ${change.oldFilePath} -> ${filePath}`;
     }
     return `${status}: ${filePath}`;
+}
+
+/**
+ * Returns a new object with all undefined keys removed
+ *
+ * @param obj Object to remove undefined keys from
+ * @returns
+ */
+function removeUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}
+
+/**
+ * Load environment variables
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadEnvConfig(config) {
+    const envConfig = {
+        model: process.env.COCO_MODEL || undefined,
+        openAIApiKey: process.env.OPENAI_API_KEY || undefined,
+        huggingFaceHubApiKey: process.env.HUGGINGFACE_HUB_API_KEY || undefined,
+        tokenLimit: process.env.COCO_TOKEN_LIMIT
+            ? parseInt(process.env.COCO_TOKEN_LIMIT)
+            : undefined,
+        prompt: process.env.COCO_PROMPT,
+        mode: process.env.COCO_MODE,
+        summarizePrompt: process.env.COCO_SUMMARIZE_PROMPT,
+        ignoredFiles: process.env.COCO_IGNORED_FILES
+            ? process.env.COCO_IGNORED_FILES.split(',')
+            : undefined,
+        ignoredExtensions: process.env.COCO_IGNORED_EXTENSIONS
+            ? process.env.COCO_IGNORED_EXTENSIONS.split(',')
+            : undefined,
+    };
+    config = { ...config, ...removeUndefined(envConfig) };
+    return config;
+}
+
+/**
+ * Load git profile config (from ~/.gitconfig)
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadGitConfig(config) {
+    const gitConfigPath = path.join(os.homedir(), '.gitconfig');
+    if (fs.existsSync(gitConfigPath)) {
+        const gitConfigRaw = fs.readFileSync(gitConfigPath, 'utf-8');
+        const gitConfigParsed = ini.parse(gitConfigRaw);
+        config = {
+            ...config,
+            model: gitConfigParsed.coco?.model || config.model,
+            openAIApiKey: gitConfigParsed.coco?.openAIApiKey || config.openAIApiKey,
+            huggingFaceHubApiKey: gitConfigParsed.coco?.huggingFaceHubApiKey || config.huggingFaceHubApiKey,
+            tokenLimit: parseInt(gitConfigParsed.coco?.tokenLimit) || config.tokenLimit,
+            prompt: gitConfigParsed.coco?.prompt || config.prompt,
+            mode: gitConfigParsed.coco?.mode || config.mode,
+            temperature: gitConfigParsed.coco?.temperature || config.temperature,
+            summarizePrompt: gitConfigParsed.coco?.summarizePrompt || config.summarizePrompt,
+            ignoredFiles: gitConfigParsed.coco?.ignoredFiles || config.ignoredFiles,
+            ignoredExtensions: gitConfigParsed.coco?.ignoredExtensions || config.ignoredExtensions,
+        };
+    }
+    return config;
+}
+
+/**
+ * Load .gitignore in project root
+ *
+ * @param {Config} config
+ * @returns
+ */
+function loadGitignore(config) {
+    if (fs.existsSync('.gitignore')) {
+        const gitignoreContent = fs.readFileSync('.gitignore', 'utf-8');
+        config.ignoredFiles = [
+            ...(config?.ignoredFiles || []),
+            ...gitignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
+        ];
+    }
+    return config;
+}
+/**
+ * Load .ignore in project root
+ *
+ * @param {Config} config
+ * @returns
+ */
+function loadIgnore(config) {
+    if (fs.existsSync('.ignore')) {
+        const ignoreContent = fs.readFileSync('.ignore', 'utf-8');
+        config.ignoredFiles = [
+            ...(config?.ignoredFiles || []),
+            ...ignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
+        ];
+    }
+    return config;
+}
+
+/**
+ * Load project config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadProjectConfig(config) {
+    if (fs.existsSync('.coco.config.json')) {
+        const projectConfig = JSON.parse(fs.readFileSync('.coco.config.json', 'utf-8'));
+        config = { ...config, ...projectConfig };
+    }
+    return config;
+}
+
+/**
+ * Load XDG config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ */
+function loadXDGConfig(config) {
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    const xdgConfigPath = path.join(xdgConfigHome, 'coco', 'config.json');
+    if (fs.existsSync(xdgConfigPath)) {
+        const xdgConfig = JSON.parse(fs.readFileSync(xdgConfigPath, 'utf-8'));
+        config = { ...config, ...xdgConfig };
+    }
+    return config;
+}
+
+/**
+ * Default Config
+ *
+ * @type {Config}
+ */
+const DEFAULT_CONFIG = {
+    model: 'openai/gpt-4',
+    verbose: false,
+    tokenLimit: 1024,
+    summarizePrompt: SUMMARIZE_PROMPT.template,
+    temperature: 0.4,
+    mode: 'stdout',
+    ignoredFiles: ['package-lock.json'],
+    ignoredExtensions: ['.map', '.lock'],
 };
+/**
+ * Load application config
+ *
+ * Merge config from multiple sources.
+ *
+ * \* Order of precedence:
+ * \* 1. Command line flags
+ * \* 2. Environment variables
+ * \* 3. Project config
+ * \* 4. Git config
+ * \* 5. XDG config
+ * \* 6. .gitignore
+ * \* 7. .ignore
+ * \* 8. Default config
+ *
+ * @returns {Config} application config
+ **/
+function loadConfig(argv = {}) {
+    // Default config
+    let config = DEFAULT_CONFIG;
+    config = loadGitignore(config);
+    config = loadIgnore(config);
+    config = loadXDGConfig(config);
+    config = loadGitConfig(config);
+    config = loadProjectConfig(config);
+    config = loadEnvConfig(config);
+    return { ...config, ...argv };
+}
 
 const config = loadConfig();
 const DEFAULT_IGNORED_FILES = config?.ignoredFiles?.length ? config.ignoredFiles : [];
@@ -720,7 +802,7 @@ async function getChanges({ git, options }) {
     };
 }
 
-const noResult = async ({ git, logger }) => {
+async function noResult({ git, logger }) {
     const { staged, unstaged, untracked } = await getChanges({ git });
     const hasStaged = staged && staged.length > 0;
     const hasUnstaged = unstaged && unstaged.length > 0;
@@ -747,112 +829,117 @@ const noResult = async ({ git, logger }) => {
     else {
         logger.log('No repo changes detected. 👀', { color: 'blue' });
     }
-};
-
-async function createCommit(commitMsg, git) {
-    return await git.commit(commitMsg);
 }
 
-const SEPERATOR = chalk.blue('----------------');
 const isInteractive = (argv) => {
     return argv?.mode === 'interactive' || argv.interactive;
 };
-const logCommit = (commit) => {
-    console.log(`\n${chalk.bgBlue(chalk.bold('Proposed Commit:'))}\n${SEPERATOR}\n${commit}\n${SEPERATOR}\n`);
-};
-const logSuccess = () => {
-    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
-};
-const generateCommitMessageAndReviewLoop = async (changes, options) => {
-    const { logger, model, git, tokenizer } = options;
-    let summary = '';
-    let commitMsg = '';
-    let promptTemplate = options?.prompt || '';
-    let modifyPrompt = false;
-    // determine if we continue generating commit messages
+const SEPERATOR = chalk.blue('----------------');
+
+function logResult(result) {
+    console.log(`\n${chalk.bgBlue(chalk.bold('Proposed Commit:'))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
+}
+
+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() {
+    return await select({
+        message: 'Would you like to make any changes to the commit message?',
+        choices: [
+            {
+                name: '✨ Looks good!',
+                value: 'approve',
+                description: 'Commit staged changes with generated commit message',
+            },
+            {
+                name: '📝 Edit',
+                value: 'edit',
+                description: 'Edit the commit message before proceeding',
+            },
+            {
+                name: '🪶  Modify Prompt',
+                value: 'modifyPrompt',
+                description: 'Modify the prompt template and regenerate the commit message',
+            },
+            {
+                name: '🔄 Retry - Message Only',
+                value: 'retryMessageOnly',
+                description: 'Restart the function execution from generating the commit message',
+            },
+            {
+                name: '🔄 Retry - Full',
+                value: 'retryFull',
+                description: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
+            },
+            {
+                name: '💣 Cancel',
+                value: 'cancel',
+            },
+        ],
+    });
+}
+
+async function editPrompt(options) {
+    return await editor({
+        message: 'Edit the prompt',
+        default: options.prompt?.length ? options.prompt : COMMIT_PROMPT.template,
+        waitForUseInput: false,
+        validate: (text) => validatePromptTemplate(text, COMMIT_PROMPT.inputVariables),
+    });
+}
+
+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 || !changes.length) {
+        await noResult(options);
+    }
     while (continueLoop) {
-        if (changes.length !== 0 && !summary.length) {
-            logger.verbose(`\nChanged Files: \n ${changes.map(({ summary }) => summary).join('\n ')}`, {
-                color: 'blue',
-            });
-            summary = await fileChangeParser(changes, { tokenizer, git, model, logger });
+        if (!context.length) {
+            context = await parser(changes, result, options);
         }
-        // Handle empty summary
-        if (!summary.length) {
-            await noResult({ git, logger });
-            process.exit(0);
+        // if we still don't have a context, bail.
+        if (!context.length) {
+            await noResult(options);
         }
-        // Prompt user for commit template prompt, if necessary
         if (modifyPrompt) {
-            promptTemplate = await editor({
-                message: 'Edit the prompt',
-                default: promptTemplate.length ? promptTemplate : COMMIT_PROMPT.template,
-                waitForUseInput: false,
-                validate: (text) => validatePromptTemplate(text, COMMIT_PROMPT.inputVariables),
-            });
+            options.prompt = await editPrompt(options);
         }
-        logger.startTimer().startSpinner(`Generating Commit Message\n`, {
+        logger.startTimer().startSpinner(`Generating ${label}\n`, {
             color: 'blue',
         });
-        commitMsg = await llm({
-            llm: model,
-            prompt: getPrompt({
-                template: promptTemplate,
-                variables: COMMIT_PROMPT.inputVariables,
-                fallback: COMMIT_PROMPT,
-            }),
-            variables: { summary },
-        });
-        if (!commitMsg) {
-            logger.stopSpinner('💀 Failed to generate commit message.', {
+        result = await agent(context, options);
+        if (!result) {
+            logger.stopSpinner('💀 Agent failed to return content.', {
                 mode: 'fail',
                 color: 'red',
             });
             process.exit(0);
         }
         logger
-            .stopSpinner('Generated Commit Message', {
+            .stopSpinner(`Generated ${label}`, {
             color: 'green',
             mode: 'succeed',
         })
             .stopTimer();
         if (options?.interactive) {
-            logCommit(commitMsg);
-            const reviewAnswer = await select({
-                message: 'Would you like to make any changes to the commit message?',
-                choices: [
-                    {
-                        name: '✨ Looks good!',
-                        value: 'approve',
-                        description: 'Commit staged changes with generated commit message',
-                    },
-                    {
-                        name: '📝 Edit',
-                        value: 'edit',
-                        description: 'Edit the commit message before proceeding',
-                    },
-                    {
-                        name: '🪶  Modify Prompt',
-                        value: 'modifyPrompt',
-                        description: 'Modify the prompt template and regenerate the commit message',
-                    },
-                    {
-                        name: '🔄 Retry - Message Only',
-                        value: 'retryMessageOnly',
-                        description: 'Restart the function execution from generating the commit message',
-                    },
-                    {
-                        name: '🔄 Retry - Full',
-                        value: 'retryFull',
-                        description: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
-                    },
-                    {
-                        name: '💣 Cancel',
-                        value: 'cancel',
-                    },
-                ],
-            });
+            logResult(result);
+            const reviewAnswer = await getUserReviewDecision();
             if (reviewAnswer === 'cancel') {
                 process.exit(0);
             }
@@ -860,133 +947,138 @@ const generateCommitMessageAndReviewLoop = async (changes, options) => {
                 options.openInEditor = true;
             }
             if (reviewAnswer === 'retryFull') {
-                summary = '';
-                commitMsg = '';
-                promptTemplate = '';
+                context = '';
+                result = '';
+                options.prompt = '';
                 continue;
             }
             if (reviewAnswer === 'retryMessageOnly') {
                 modifyPrompt = false;
-                commitMsg = '';
+                result = '';
                 continue;
             }
             if (reviewAnswer === 'modifyPrompt') {
                 modifyPrompt = true;
-                commitMsg = '';
+                result = '';
                 continue;
             }
         }
-        if (options.openInEditor) {
-            commitMsg = await editor({
-                message: 'Edit the commit message',
-                default: commitMsg,
-                waitForUseInput: false,
-                validate: (text) => {
-                    if (!text) {
-                        return 'Commit message cannot be empty';
-                    }
-                    return true;
-                },
-            });
-        }
+        // if we're here, we're done.
+        result = await editResult(result, options);
         continueLoop = false;
     }
-    return commitMsg;
+    return result;
+}
+
+const executeChain = async ({ llm, prompt, variables }) => {
+    if (!llm || !prompt || !variables) {
+        throw new Error('The input parameters "llm", "prompt", and "variables" are all required.');
+    }
+    const chain = new LLMChain({ llm, prompt });
+    let res;
+    try {
+        res = await chain.call(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');
+    }
+    if (res.error) {
+        throw new Error(`LLMChain response error: ${res.error}`);
+    }
+    return res.text.trim();
+};
+
+async function createCommit(commitMsg, git) {
+    return await git.commit(commitMsg);
+}
+
+const logSuccess = () => {
+    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
 };
-const handleResult = async (commit, { mode, git }) => {
+
+const handleResult = async (result, { mode, git }) => {
     // Handle resulting commit message
     switch (mode) {
         case 'interactive':
-            await createCommit(commit, git);
+            await createCommit(result, git);
             logSuccess();
             break;
         case 'stdout':
         default:
-            process.stdout.write(commit, 'utf8');
+            process.stdout.write(result, 'utf8');
             break;
     }
     process.exit(0);
 };
 
-/**
- * Wrapper around GPT3NodeTokenizer to handle default export.
- *
- * @see https://github.com/botisan-ai/gpt3-tokenizer/issues/18
- *
- * @returns {GPT3NodeTokenizer} The GPT3NodeTokenizer instance.
- */
-const getTokenizer = () => {
-    let tokenizer;
-    // eslint-disable-next-line
-    // @ts-ignore
-    if (GPT3NodeTokenizer.default) {
-        // eslint-disable-next-line
-        // @ts-ignore
-        tokenizer = new GPT3NodeTokenizer.default({ type: 'gpt3' });
-    }
-    else {
-        tokenizer = new GPT3NodeTokenizer({ type: 'gpt3' });
-    }
-    return tokenizer;
-};
-
-class Logger {
-    constructor(config) {
-        this.config = config;
-        this.spinner = null;
-    }
-    log(message, options = { color: 'blue' }) {
-        let outputMessage = message;
-        if (options.color) {
-            outputMessage = chalk[options.color](outputMessage);
-        }
-        console.log(outputMessage);
-        return this;
-    }
-    verbose(message, options = {}) {
-        if (!this.config?.verbose) {
-            return this;
-        }
-        this.log(message, options);
-        return this;
-    }
-    startTimer() {
-        this.timerStart = now();
-        return this;
-    }
-    stopTimer(message, options = { color: 'yellow' }) {
-        if (!this.config?.verbose || !this.timerStart) {
-            return this;
-        }
-        const elapsedTime = prettyMilliseconds(now() - this.timerStart);
-        let outputMessage = message
-            ? `${message} (⏲ ${elapsedTime})`
-            : `⏲ ${elapsedTime}`;
-        if (options.color) {
-            outputMessage = chalk[options.color](outputMessage);
-        }
-        console.log(outputMessage);
-        return this;
+const tokenizer = getTokenizer();
+const git$1 = simpleGit();
+async function handler$1(argv) {
+    const options = loadConfig(argv);
+    const logger = new Logger(options);
+    const key = getApiKeyForModel(options.model, options);
+    if (!key) {
+        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
+        process.exit(1);
     }
-    startSpinner(message, options = { color: 'green' }) {
-        const spinnerMessage = options.color ? chalk[options.color](message) : message;
-        this.spinner = ora(spinnerMessage).start();
-        return this;
+    const model = getModel(options.model, key, {
+        temperature: 0.4,
+        maxConcurrency: 10,
+    });
+    const INTERACTIVE = isInteractive(options);
+    async function factory() {
+        const changes = await getChanges({ git: git$1 });
+        return changes.staged;
     }
-    stopSpinner(message = '', options = { mode: 'succeed', color: 'green' }) {
-        const spinnerMessage = options?.color ? chalk[options.color](message) : message;
-        this.spinner?.[options.mode || 'succeed'](spinnerMessage);
-        this.spinner = null;
-        return this;
+    async function parser(changes) {
+        return await fileChangeParser({
+            changes,
+            commit: '--staged',
+            options: { tokenizer, git: git$1, model, logger },
+        });
     }
+    const commitMsg = await generateAndReviewLoop({
+        label: 'Commit Message',
+        factory,
+        parser,
+        agent: async (context, options) => {
+            return await executeChain({
+                llm: model,
+                prompt: getPrompt({
+                    template: options.prompt,
+                    variables: COMMIT_PROMPT.inputVariables,
+                    fallback: COMMIT_PROMPT,
+                }),
+                variables: { summary: context },
+            });
+        },
+        noResult: async () => {
+            await noResult({ git: git$1, logger });
+            process.exit(0);
+        },
+        options: {
+            ...options,
+            prompt: options.prompt || COMMIT_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+        },
+    });
+    const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
+    handleResult(commitMsg, {
+        mode: MODE,
+        git: git$1,
+    });
 }
 
-// const argv = loadArgv()
-const tokenizer = getTokenizer();
-const git = simpleGit();
-const command = ['commit', '$0'];
-const description = 'Generate a commit message based on the diff summary';
-const builder = {
+/**
+ * Command line options via yargs
+ */
+const options$1 = {
     model: { type: 'string', description: 'LLM/Model-Name' },
     openAIApiKey: {
         type: 'string',
@@ -1032,10 +1124,56 @@ const builder = {
         description: 'Ignored extensions',
     },
 };
+const builder$1 = (yargs) => {
+    return yargs.options(options$1);
+};
+
+var commit = {
+    command: 'commit',
+    desc: 'Generate commit message',
+    builder: builder$1,
+    handler: handler$1,
+    options: options$1,
+};
+
+const template = `Write informative git changelog, in the imperative, based on a series of individual messages.
+
+- Typically a hyphen or asterisk is used for the bullet
+- Summarize dependency updates
+
+"""{summary}"""
+
+Changelog:`;
+const inputVariables = ['summary'];
+const CHANGELOG_PROMPT = new PromptTemplate({
+    template,
+    inputVariables,
+});
+
+async function getCommitLogRange(from, to, { noMerges, git }) {
+    try {
+        const output = await git.raw([
+            'log',
+            `${from}..${to}`,
+            '--pretty=format:%s',
+            // Include '--no-merges' here if you want to exclude merge commits.
+            noMerges ? '--no-merges' : null,
+        ].filter(Boolean)); // filter(Boolean) removes any null values from the array
+        const messages = output.split('\n').filter(Boolean);
+        return messages;
+    }
+    catch (error) {
+        // If there's an error, handle it appropriately
+        console.error('Error getting commit messages:', error);
+        throw error;
+    }
+}
+
+const git = simpleGit();
 async function handler(argv) {
     const options = loadConfig(argv);
     const logger = new Logger(options);
-    const key = getModelAPIKey(options.model, options);
+    const key = getApiKeyForModel(options.model, options);
     if (!key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
@@ -1045,47 +1183,128 @@ async function handler(argv) {
         maxConcurrency: 10,
     });
     const INTERACTIVE = isInteractive(options);
-    const { staged: changes } = await getChanges({ git });
-    const commitMsg = await generateCommitMessageAndReviewLoop(changes, {
-        logger,
-        model,
-        git,
-        tokenizer,
-        prompt: options.prompt,
-        interactive: INTERACTIVE,
-        openInEditor: options.openInEditor,
+    const [from, to] = options.range?.split(':');
+    if (!from || !to) {
+        logger.log(`Invalid range provided. Expected format is <from>:<to>`, { color: 'red' });
+        process.exit(1);
+    }
+    async function factory() {
+        const messages = await getCommitLogRange(from, to, { git, noMerges: true });
+        return messages;
+    }
+    async function parser(messages) {
+        const result = messages.join('\n');
+        return result;
+    }
+    const changelogMsg = await generateAndReviewLoop({
+        label: 'Changelog',
+        factory,
+        parser,
+        agent: async (context, options) => {
+            const prompt = getPrompt({
+                template: options.prompt,
+                variables: CHANGELOG_PROMPT.inputVariables,
+                fallback: CHANGELOG_PROMPT,
+            });
+            return await executeChain({
+                llm: model,
+                prompt,
+                variables: { summary: context },
+            });
+        },
+        noResult: async () => {
+            await noResult({ git, logger });
+            process.exit(0);
+        },
+        options: {
+            ...options,
+            prompt: options.prompt || CHANGELOG_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+        },
     });
-    const MODE = (options.interactive && 'interactive') ||
-        (options.commit && 'interactive') ||
-        options?.mode ||
-        'stdout';
-    handleResult(commitMsg, {
+    const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
+    handleResult(changelogMsg, {
         mode: MODE,
         git,
     });
 }
 
-var commit = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  builder: builder,
-  command: command,
-  description: description,
-  handler: handler
-});
+/**
+ * Command line options via yargs
+ */
+const options = {
+    range: {
+        type: 'string',
+        alias: 'r',
+        description: 'Commit range e.g `HEAD~2:HEAD`',
+        demandOption: true,
+    },
+    model: { type: 'string', description: 'LLM/Model-Name' },
+    openAIApiKey: {
+        type: 'string',
+        description: 'OpenAI API Key',
+        conflicts: 'huggingFaceHubApiKey',
+    },
+    huggingFaceHubApiKey: {
+        type: 'string',
+        description: 'HuggingFace Hub API Key',
+        conflicts: 'openAIApiKey',
+    },
+    tokenLimit: { type: 'number', description: 'Token limit' },
+    prompt: {
+        type: 'string',
+        alias: 'p',
+        description: 'Prompt for llm',
+    },
+    i: {
+        type: 'boolean',
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+    },
+    e: {
+        type: 'boolean',
+        alias: 'edit',
+        description: 'Open generated changelog message in editor before proceeding',
+    },
+    summarizePrompt: {
+        type: 'string',
+        description: 'Prompt for summarizing large files',
+    },
+    ignoredFiles: {
+        type: 'array',
+        description: 'Ignored files',
+    },
+    ignoredExtensions: {
+        type: 'array',
+        description: 'Ignored extensions',
+    },
+};
+const builder = (yargs) => {
+    return yargs.options(options);
+};
+
+var changelog = {
+    command: 'changelog',
+    desc: 'Generate a changelog from a commit range',
+    builder,
+    handler,
+    options,
+};
 
 yargs
     .scriptName('coco')
-    .commandDir('./commands', {
-    extensions: ['ts'],
-})
+    .usage('$0 <cmd> [args]')
+    .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)
+    .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)
     .demandCommand()
-    .strict()
-    .option('h', { alias: 'help' })
-    .option('v', {
-    alias: 'verbose',
-    type: 'boolean',
-    description: 'Run with verbose logging',
-}).argv;
-
-export { commit, loadConfig };
+    .help().argv;
 //# sourceMappingURL=index.esm.mjs.map