git-coco 0.3.2 → 0.3.4

package/dist/index.js

@@ -2,26 +2,26 @@
 'use strict';
 
 var yargs = require('yargs');
-var prompts$1 = require('@inquirer/prompts');
-var simpleGit = require('simple-git');
-var fs = require('fs');
-var os = require('os');
-var path = require('path');
-var ini = require('ini');
-var prompts = require('langchain/prompts');
 var pQueue = require('p-queue');
 var document = require('langchain/document');
 var hf = require('langchain/llms/hf');
+var prompts = require('langchain/prompts');
 var chains = require('langchain/chains');
 var openai = require('langchain/llms/openai');
 var text_splitter = require('langchain/text_splitter');
 var diff = require('diff');
-var chalk = require('chalk');
 var GPT3NodeTokenizer = require('gpt3-tokenizer');
+var chalk = require('chalk');
 var ora = require('ora');
 var now = require('performance-now');
 var prettyMilliseconds = require('pretty-ms');
+var path = require('path');
 var minimatch = require('minimatch');
+var fs = require('fs');
+var os = require('os');
+var ini = require('ini');
+var simpleGit = require('simple-git');
+var prompts$1 = require('@inquirer/prompts');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -40,214 +40,11 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var ini__namespace = /*#__PURE__*/_interopNamespaceDefault(ini);
 
-/**
- * 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__namespace.join(os__namespace.homedir(), '.gitconfig');
-    if (fs__namespace.existsSync(gitConfigPath)) {
-        const gitConfigRaw = fs__namespace.readFileSync(gitConfigPath, 'utf-8');
-        const gitConfigParsed = ini__namespace.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__namespace.existsSync('.gitignore')) {
-        const gitignoreContent = fs__namespace.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__namespace.existsSync('.ignore')) {
-        const ignoreContent = fs__namespace.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__namespace.existsSync('.coco.config.json')) {
-        const projectConfig = JSON.parse(fs__namespace.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__namespace.join(os__namespace.homedir(), '.config');
-    const xdgConfigPath = path__namespace.join(xdgConfigHome, 'coco', 'config.json');
-    if (fs__namespace.existsSync(xdgConfigPath)) {
-        const xdgConfig = JSON.parse(fs__namespace.readFileSync(xdgConfigPath, 'utf-8'));
-        config = { ...config, ...xdgConfig };
-    }
-    return config;
-}
-
-const template$1 = `Write informative git commit message 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.
-- Write concisely using an informal tone
-- List significant changes
-- DO NOT use phrases like "this commit", "this change", etc.
-- 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 prompts.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 prompts.PromptTemplate({
-    template,
-    inputVariables,
-});
-
-/**
- * Default Config
- *
- * @type {Config}
- */
-const DEFAULT_CONFIG = {
-    model: 'openai/gpt-3.5-turbo',
-    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 };
-}
-
 /**
  * Extract the path from a file path string.
  * @param {string} filePath - The full file path.
@@ -389,12 +186,29 @@ 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();
     for (const change of changes) {
         let currentParent = root;
-        const parts = change.filepath.split('/');
+        const parts = change.filePath.split('/');
         parts.pop();
         for (const part of parts) {
             let childNode = currentParent.getChild(part);
@@ -406,8 +220,8 @@ const createDiffTree = (changes) => {
         }
         // Create a NodeFile object and add it to the parent
         currentParent.addFile({
-            filepath: change.filepath,
-            oldFilepath: change.oldFilepath,
+            filePath: change.filePath,
+            oldFilePath: change.oldFilePath,
             summary: change.summary,
             status: change.status,
         });
@@ -425,11 +239,11 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger) {
         // TODO: Swap out the GPT3Tokenizer for LangChain tokenizer
         const tokenizedDiff = tokenizer.encode(diff).text;
         const tokenCount = tokenizedDiff.length;
-        logger.verbose(`Collected diff for ${nodeFile.filepath} (${tokenCount} tokens)`, {
+        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
             color: 'magenta',
         });
         return {
-            file: nodeFile.filepath,
+            file: nodeFile.filePath,
             summary: nodeFile.summary,
             diff,
             tokenCount,
@@ -454,7 +268,7 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger) {
  * @param configuration
  * @returns LLM Model
  */
-function getModel(name, key, fields, configuration) {
+function getModel(name, key, fields) {
     const [llm, model] = name.split(/\/(.*)/s);
     if (!model) {
         throw new Error(`Invalid model: ${name}`);
@@ -473,7 +287,7 @@ function getModel(name, key, fields, configuration) {
                 openAIApiKey: key,
                 modelName: model,
                 ...fields,
-            }, configuration);
+            });
     }
 }
 /**
@@ -482,7 +296,7 @@ function getModel(name, key, fields, configuration) {
  * @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}`);
@@ -539,19 +353,47 @@ function validatePromptTemplate(text, inputVariables) {
     return true;
 }
 
-const parseDefaultFileDiff = async (nodeFile, git) => {
-    return await git.diff(['--staged', nodeFile.filepath]);
+const template$1 = `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$1 = ['text'];
+const SUMMARIZE_PROMPT = new prompts.PromptTemplate({
+    template: template$1,
+    inputVariables: inputVariables$1,
+});
+
+const parseDefaultFileDiff = async (nodeFile, commit = '--staged', git) => {
+    if (commit !== '--staged') {
+        return await git.diff([`${commit}~1..${commit}`, '--', nodeFile.filePath]);
+    }
+    return await git.diff([commit, nodeFile.filePath]);
 };
-const parseRenamedFileDiff = async (nodeFile, git, logger) => {
+const parseRenamedFileDiff = async (nodeFile, commit, git, logger) => {
     let result = '';
-    const oldFilepath = nodeFile?.oldFilepath || nodeFile.filepath;
+    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 = diff.createTwoFilesPatch(oldFilepath, nodeFile.filepath, headContent, indexContent, '', '', {
+        if (previousContent !== newContent) {
+            result = diff.createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
                 context: 3,
             });
             // remove the first 4 lines of the patch (they contain the old and new file names)
@@ -562,27 +404,27 @@ const parseRenamedFileDiff = async (nodeFile, git, logger) => {
         }
     }
     catch (err) {
-        logger.verbose(`Error comparing file contents for ${nodeFile.filepath}`, { color: 'red' });
+        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
         result = 'Error comparing file contents.';
     }
     return result;
 };
-const getDiff = async (nodeFile, { git, logger, }) => {
+const getDiff = async (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);
+    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, 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,
@@ -593,7 +435,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();
@@ -602,19 +444,11 @@ 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 SEPERATOR = chalk.blue('----------------');
-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! 🦾🤖')));
-};
+}
 
 /**
  * Wrapper around GPT3NodeTokenizer to handle default export.
@@ -689,76 +523,266 @@ class Logger {
     }
 }
 
-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 chains.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}`);
+const template = `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 = ['summary'];
+const COMMIT_PROMPT = new prompts.PromptTemplate({
+    template,
+    inputVariables,
+});
+
+const getStatus = (file, location = 'index') => {
+    if ('index' in file && 'working_dir' in file) {
+        const statusCode = file[location];
+        switch (statusCode) {
+            case 'A':
+                return 'added';
+            case 'D':
+                return 'deleted';
+            case 'M':
+                return 'modified';
+            case 'R':
+                return 'renamed';
+            case '?':
+                return 'untracked';
+            default:
+                return 'unknown';
         }
     }
-    if (!res) {
-        throw new Error('Empty response from LLMChain call');
+    else if ('changes' in file && 'binary' in file) {
+        if (file.changes === 0)
+            return 'untracked';
+        if (file.file.includes('=>'))
+            return 'renamed';
+        if (file.deletions === 0 && file.insertions > 0)
+            return 'added';
+        if (file.insertions === 0 && file.deletions > 0)
+            return 'deleted';
+        if ((file.insertions > 0 && file.deletions > 0) || file.changes > 0)
+            return 'modified';
+        return 'unknown';
     }
-    if (res.error) {
-        throw new Error(`LLMChain response error: ${res.error}`);
+    else {
+        throw new Error("Invalid file type");
     }
-    return res.text.trim();
 };
 
-const getStatus = (file, location = 'index') => {
-    const statusCode = file[location] ? file[location] : file.index;
-    let status;
-    switch (statusCode) {
-        case 'A':
-            status = 'added';
-            break;
-        case 'D':
-            status = 'deleted';
-            break;
-        case 'M':
-            status = 'modified';
-            break;
-        case 'R':
-            status = 'renamed';
-            break;
-        case '?':
-            status = 'untracked';
-            break;
-        default:
-            status = 'unknown';
-            break;
+const 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;
+    return `${status}: ${filePath}`;
 };
 
-const getSummaryText = (file, change) => {
-    const status = change.status || getStatus(file);
-    if (change.oldFilepath) {
-        return `${status}: ${change.oldFilepath} -> ${file.path}`;
+/**
+ * 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__namespace.join(os__namespace.homedir(), '.gitconfig');
+    if (fs__namespace.existsSync(gitConfigPath)) {
+        const gitConfigRaw = fs__namespace.readFileSync(gitConfigPath, 'utf-8');
+        const gitConfigParsed = ini__namespace.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__namespace.existsSync('.gitignore')) {
+        const gitignoreContent = fs__namespace.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__namespace.existsSync('.ignore')) {
+        const ignoreContent = fs__namespace.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__namespace.existsSync('.coco.config.json')) {
+        const projectConfig = JSON.parse(fs__namespace.readFileSync('.coco.config.json', 'utf-8'));
+        config = { ...config, ...projectConfig };
     }
-    return `${status}: ${file.path}`;
+    return config;
+}
+
+/**
+ * Load XDG config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ */
+function loadXDGConfig(config) {
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME || path__namespace.join(os__namespace.homedir(), '.config');
+    const xdgConfigPath = path__namespace.join(xdgConfigHome, 'coco', 'config.json');
+    if (fs__namespace.existsSync(xdgConfigPath)) {
+        const xdgConfig = JSON.parse(fs__namespace.readFileSync(xdgConfigPath, 'utf-8'));
+        config = { ...config, ...xdgConfig };
+    }
+    return config;
+}
+
+/**
+ * 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 };
+}
 
 const config = loadConfig();
 const DEFAULT_IGNORED_FILES = config?.ignoredFiles?.length ? config.ignoredFiles : [];
 const DEFAULT_IGNORED_EXTENSIONS = config?.ignoredExtensions?.length ? config.ignoredExtensions : [];
-async function getChanges(git, options = {}) {
-    const { ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS } = options;
+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,
+            filePath: file.path,
+            oldFilePath: status.renamed.filter((renamed) => renamed.to === file.path)[0]?.from,
         };
         // Unstaged files
         if (file.working_dir !== '?' && file.working_dir !== ' ') {
@@ -781,16 +805,19 @@ async function getChanges(git, options = {}) {
     });
     const ignoredExtensionsSet = new Set(ignoredExtensions.map((extension) => extension.toLowerCase()));
     const filteredStaged = staged.filter((file) => {
-        const extension = path.extname(file.filepath).toLowerCase();
-        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch.minimatch(file.filepath, ignoredPattern));
+        const extension = path.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
     });
     const filteredUnstaged = unstaged.filter((file) => {
-        const extension = path.extname(file.filepath).toLowerCase();
-        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch.minimatch(file.filepath, ignoredPattern));
+        const extension = path.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
     });
     const filteredUntracked = untracked.filter((file) => {
-        const extension = path.extname(file.filepath).toLowerCase();
-        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch.minimatch(file.filepath, ignoredPattern));
+        const extension = path.extname(file.filePath).toLowerCase();
+        return (!ignoredExtensionsSet.has(extension) &&
+            !ignoredFiles.some((ignoredPattern) => minimatch.minimatch(file.filePath, ignoredPattern)));
     });
     return {
         staged: filteredStaged,
@@ -799,8 +826,8 @@ async function getChanges(git, options = {}) {
     };
 }
 
-const noResult = async ({ git, logger }) => {
-    const { staged, unstaged, untracked } = await getChanges(git);
+async function noResult({ git, logger }) {
+    const { staged, unstaged, untracked } = await getChanges({ git });
     const hasStaged = staged && staged.length > 0;
     const hasUnstaged = unstaged && unstaged.length > 0;
     const hasUntracked = untracked && untracked.length > 0;
@@ -826,18 +853,254 @@ const noResult = async ({ git, logger }) => {
     else {
         logger.log('No repo changes detected. 👀', { color: 'blue' });
     }
+}
+
+const isInteractive = (argv) => {
+    return argv?.mode === 'interactive' || argv.interactive;
+};
+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 prompts$1.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 prompts$1.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 prompts$1.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({ 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 (!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 Message\n`, {
+            color: 'blue',
+        });
+        result = await agent(context, options);
+        if (!result) {
+            logger.stopSpinner('💀 Agent failed to generate message.', {
+                mode: 'fail',
+                color: 'red',
+            });
+            process.exit(0);
+        }
+        logger
+            .stopSpinner('Generated Commit Message', {
+            color: 'green',
+            mode: 'succeed',
+        })
+            .stopTimer();
+        if (options?.interactive) {
+            logResult(result);
+            const reviewAnswer = await getUserReviewDecision();
+            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 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 chains.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 argv = loadArgv()
+const logSuccess = () => {
+    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
+};
+
+const handleResult = async (result, { mode, git }) => {
+    // Handle resulting commit message
+    switch (mode) {
+        case 'interactive':
+            await createCommit(result, git);
+            logSuccess();
+            break;
+        case 'stdout':
+        default:
+            process.stdout.write(result, 'utf8');
+            break;
+    }
+    process.exit(0);
+};
+
 const tokenizer = getTokenizer();
 const git = simpleGit.simpleGit();
-const command = ['commit', '$0'];
-const description = 'Generate a commit message based on the diff summary';
-const builder = {
+async function handler(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);
+    }
+    const model = getModel(options.model, key, {
+        temperature: 0.4,
+        maxConcurrency: 10,
+    });
+    const INTERACTIVE = isInteractive(options);
+    async function factory() {
+        const changes = await getChanges({ git });
+        return changes.staged;
+    }
+    async function parser(changes) {
+        return await fileChangeParser({
+            changes,
+            commit: '--staged',
+            options: { tokenizer, git, model, logger },
+        });
+    }
+    const commitMsg = await generateAndReviewLoop({
+        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, logger });
+            process.exit(0);
+        },
+        options: {
+            ...options,
+            logger,
+            interactive: INTERACTIVE,
+        },
+    });
+    const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
+    handleResult(commitMsg, {
+        mode: MODE,
+        git,
+    });
+}
+
+/**
+ * Command line options via yargs
+ */
+const options = {
     model: { type: 'string', description: 'LLM/Model-Name' },
     openAIApiKey: {
         type: 'string',
@@ -883,182 +1146,20 @@ const builder = {
         description: 'Ignored extensions',
     },
 };
-async function handler(argv) {
-    const options = loadConfig(argv);
-    const logger = new Logger(options);
-    const key = getModelAPIKey(options.model, options);
-    if (!key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        process.exit(1);
-    }
-    const model = getModel(options.model, key, {
-        temperature: 0.4,
-        maxConcurrency: 10,
-    });
-    const INTERACTIVE = options?.mode === 'interactive' || options.interactive;
-    const { staged: changes } = await getChanges(git);
-    let summary = '';
-    let commitMsg = '';
-    let promptTemplate = options?.prompt || '';
-    let modifyPrompt = false;
-    while (true) {
-        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 });
-        }
-        // Handle empty summary
-        if (!summary.length) {
-            await noResult({ git, logger });
-            process.exit(0);
-        }
-        // Prompt user for commit template prompt, if necessary
-        if (modifyPrompt) {
-            promptTemplate = await prompts$1.editor({
-                message: 'Edit the prompt',
-                default: promptTemplate.length ? promptTemplate : COMMIT_PROMPT.template,
-                waitForUseInput: false,
-                validate: (text) => validatePromptTemplate(text, COMMIT_PROMPT.inputVariables),
-            });
-        }
-        logger.startTimer().startSpinner(`Generating Commit Message\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.', {
-                mode: 'fail',
-                color: 'red',
-            });
-            process.exit(0);
-        }
-        logger
-            .stopSpinner('Generated Commit Message', {
-            color: 'green',
-            mode: 'succeed',
-        })
-            .stopTimer();
-        if (INTERACTIVE) {
-            logCommit(commitMsg);
-            const reviewAnswer = await prompts$1.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',
-                    },
-                ],
-            });
-            if (reviewAnswer === 'cancel') {
-                process.exit(0);
-            }
-            if (reviewAnswer === 'edit') {
-                options.openInEditor = true;
-            }
-            if (reviewAnswer === 'retryFull') {
-                summary = '';
-                commitMsg = '';
-                promptTemplate = '';
-                continue;
-            }
-            if (reviewAnswer === 'retryMessageOnly') {
-                modifyPrompt = false;
-                commitMsg = '';
-                continue;
-            }
-            if (reviewAnswer === 'modifyPrompt') {
-                modifyPrompt = true;
-                commitMsg = '';
-                continue;
-            }
-        }
-        if (options.openInEditor) {
-            commitMsg = await prompts$1.editor({
-                message: 'Edit the commit message',
-                default: commitMsg,
-                waitForUseInput: false,
-                validate: (text) => {
-                    if (!text) {
-                        return 'Commit message cannot be empty';
-                    }
-                    return true;
-                },
-            });
-        }
-        const MODE = (options.interactive && 'interactive') ||
-            (options.commit && 'interactive') ||
-            options?.mode ||
-            'stdout';
-        // Handle resulting commit message
-        switch (MODE) {
-            case 'interactive':
-                await createCommit(commitMsg, git);
-                logSuccess();
-                break;
-            case 'stdout':
-            default:
-                process.stdout.write(commitMsg, 'utf8');
-                break;
-        }
-        process.exit(0);
-    }
-}
-
-var commit = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  builder: builder,
-  command: command,
-  description: description,
-  handler: handler
-});
+const builder = (yargs) => {
+    return yargs.options(options);
+};
 
-yargs
-    .scriptName('coco')
-    .commandDir('./commands', {
-    extensions: ['ts'],
-})
-    .demandCommand()
-    .strict()
-    .option('h', { alias: 'help' })
-    .option('v', {
-    alias: 'verbose',
-    type: 'boolean',
-    description: 'Run with verbose logging',
-}).argv;
+var commit = {
+    command: 'commit',
+    desc: 'Generate commit message',
+    builder,
+    handler,
+    options,
+};
 
-exports.commit = commit;
-exports.loadConfig = loadConfig;
+yargs.scriptName('coco').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).argv;