git-coco 0.6.2 → 0.7.0

package/dist/index.esm.mjs

@@ -1,455 +1,383 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
+import { PromptTemplate } from 'langchain/prompts';
+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 os from 'os';
+import os__default from 'os';
+import * as path from 'path';
+import path__default from 'path';
+import * as ini from 'ini';
+import ora from 'ora';
+import now from 'performance-now';
+import prettyMilliseconds from 'pretty-ms';
 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 GPT3NodeTokenizer from 'gpt3-tokenizer';
-import chalk from 'chalk';
-import ora from 'ora';
-import now from 'performance-now';
-import prettyMilliseconds from 'pretty-ms';
-import * as path from 'path';
-import path__default from 'path';
 import { minimatch } from 'minimatch';
-import * as fs from 'fs';
-import fs__default from 'fs';
-import { confirm, editor, select, password, input } from '@inquirer/prompts';
-import * as os from 'os';
-import os__default from 'os';
-import * as ini from 'ini';
 import { simpleGit } from 'simple-git';
+import { encoding_for_model } from 'tiktoken';
+import { exec } from 'child_process';
 
 /**
- * Extract the path from a file path string.
- * @param {string} filePath - The full file path.
- * @returns {string} The path portion of the file path.
+ * Returns a new object with all undefined keys removed
+ *
+ * @param obj Object to remove undefined keys from
+ * @returns
  */
-function getPathFromFilePath(filePath) {
-    return filePath.split('/').slice(0, -1).join('/');
+function removeUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
 }
 
-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.call({
-        input_documents: docs,
-        returnIntermediateSteps,
-    });
-    if (res.error)
-        throw new Error(res.error);
-    return res.text && res.text.trim();
-}
+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,
+});
 
 /**
- * Create groups from a given node info.
- * @param {DiffNode} node - The node info to start grouping.
- * @returns {DirectoryDiff[]} The groups created.
+ * Default Config
+ *
+ * @type {Config}
  */
-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);
-}
+const DEFAULT_CONFIG = {
+    service: 'openai/gpt-4',
+    verbose: false,
+    tokenLimit: 1024,
+    summarizePrompt: SUMMARIZE_PROMPT.template,
+    temperature: 0.4,
+    mode: 'stdout',
+    ignoredFiles: ['package-lock.json'],
+    ignoredExtensions: ['.map', '.lock'],
+    defaultBranch: 'main',
+};
 /**
- * Summarize a directory diff asynchronously.
+ * Create a named export of all config keys for use in other modules.
+ *
+ * @see Currently used in `src/lib/config/services/env.ts` to validate all env vars.
+ *
+ * @type {string[]}
  */
-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.encode(directorySummary).text.length;
-        return {
-            diffs: directory.diffs,
-            path: directory.path,
-            summary: directorySummary,
-            tokenCount: newTokenTotal,
-        };
+const CONFIG_KEYS = Object.keys({
+    ...DEFAULT_CONFIG,
+    huggingFaceHubApiKey: '',
+    openAIApiKey: '',
+    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]);
+        }
     }
-    catch (error) {
-        console.error(error);
-        return directory;
+    // 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 defaultOutputCallback = (group) => {
-    let output = `
--------\n* changes in "/${group.path}"\n\n`;
-    if (group.summary) {
-        output += `${group.diffs.map((diff) => ` • ${diff.summary}`).join('\n')}\n\nSummary:\n\n${group.summary}\n\n`;
-    }
-    else {
-        output += `${group.diffs.map((diff) => ` • ${diff.summary}\n\n${diff.diff}`).join('\n\n')}\n\n`;
-    }
-    return output;
+
+const isInteractive = (argv) => {
+    return argv?.mode === 'interactive' || argv.interactive;
 };
-async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
-    const queue = new pQueue({ concurrency: 8 });
-    logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
-    const directoryDiffs = createDirectoryDiffs(rootDiffNode);
-    // Sort by token count descending
-    directoryDiffs.sort((a, b) => b.tokenCount - a.tokenCount);
-    let totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
-    logger.stopSpinner('Diffs Organized').stopTimer();
-    logger.startSpinner(`Consolidating Diffs`, { color: 'blue' });
-    const processingTasks = directoryDiffs.map((group, i) => {
-        return queue.add(async () => {
-            // If the diff token count is already less than the average req, we can skip summarizing.
-            const isLessThanAvgTokenReq = group.tokenCount <= maxTokens / directoryDiffs.length;
-            if (totalTokenCount <= maxTokens || isLessThanAvgTokenReq) {
-                return group;
-            }
-            group = await summarizeDirectoryDiff(group, {
-                chain,
-                textSplitter,
-                tokenizer,
-            });
-            // We need to subtract the old token count and add the new one
-            totalTokenCount = totalTokenCount - directoryDiffs[i].tokenCount + group.tokenCount;
-            directoryDiffs[i] = group;
-            logger
-                .verbose(`\n • Summarized diffs in "/${group.path}" `, { color: 'blue' })
-                .verbose(`\nTotal token count: ${totalTokenCount}`, {
-                color: totalTokenCount > maxTokens ? 'yellow' : 'green',
-            });
-            return group;
-        }, { priority: group.tokenCount });
+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
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadEnvConfig(config) {
+    const envConfig = {};
+    CONFIG_KEYS.forEach((key) => {
+        const envVarName = toEnvVarName(key);
+        const envValue = parseEnvValue(key, process.env[envVarName]);
+        if (envValue === undefined)
+            return;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        envConfig[key] = envValue;
     });
-    await Promise.all(processingTasks);
-    logger.stopSpinner(`Summarized Diffs`);
-    return directoryDiffs.map(handleOutput).join('');
+    return { ...config, ...removeUndefined(envConfig) };
 }
-
-class DiffTreeNode {
-    constructor(path) {
-        this.path = [];
-        this.files = [];
-        this.children = new Map();
-        if (path)
-            this.path = path;
+function parseEnvValue(key, value) {
+    if (value === undefined) {
+        return undefined;
     }
-    addFile(file) {
-        this.files.push(file);
+    else if (key === 'tokenLimit' && typeof value === 'string') {
+        return parseInt(value);
     }
-    addChild(part, node) {
-        this.children.set(part, node);
+    else if ((key === 'ignoredFiles' || key === 'ignoredExtensions') &&
+        typeof value === 'string' &&
+        value.includes(',')) {
+        return value.split(',');
     }
-    getChild(part) {
-        return this.children.get(part);
+    return value;
+}
+function toEnvVarName(key) {
+    switch (key) {
+        case 'openAIApiKey':
+            return 'OPENAI_API_KEY';
+        case 'huggingFaceHubApiKey':
+            return 'HUGGINGFACE_HUB_API_KEY';
+        default:
+            return 'COCO_' + key.replace(/([A-Z])/g, '_$1').toUpperCase();
     }
-    getPath() {
-        return this.path.join('/');
+}
+function formatEnvValue(value) {
+    if (typeof value === 'number') {
+        return `${value}`;
     }
-    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;
+    else if (Array.isArray(value)) {
+        return `${value.join(',')}`;
     }
-}
-const createDiffTree = (changes) => {
-    const root = new DiffTreeNode();
-    for (const change of changes) {
-        let currentParent = root;
-        const parts = change.filePath.split('/');
-        parts.pop();
-        for (const part of parts) {
-            let childNode = currentParent.getChild(part);
-            if (!childNode) {
-                childNode = new DiffTreeNode([...currentParent.path, part]);
-                currentParent.addChild(part, childNode);
-            }
-            currentParent = childNode;
-        }
-        // Create a NodeFile object and add it to the parent
-        currentParent.addFile({
-            filePath: change.filePath,
-            oldFilePath: change.oldFilePath,
-            summary: change.summary,
-            status: change.status,
-        });
+    else if (typeof value === 'string') {
+        // Escape newlines and tabs in strings
+        return `${value.replace(/\n/g, '\\n').replace(/\t/g, '\\t')}`;
     }
-    return root;
+    return `${value}`;
+}
+const appendToEnvFile = async (filePath, config) => {
+    const startComment = '# -- Start coco config --';
+    const endComment = '# -- End coco config --';
+    const getNewContent = async () => {
+        return Object.entries(config)
+            .map(([key, value]) => `${toEnvVarName(key)}=${formatEnvValue(value)}`)
+            .join('\n');
+    };
+    await updateFileSection({
+        filePath,
+        startComment,
+        endComment,
+        getNewContent,
+        confirmMessage: CONFIG_ALREADY_EXISTS,
+    });
 };
 
 /**
- * Asynchronously collect diffs for a given node and its children.
- */
-async function collectDiffs(node, getFileDiff, tokenizer, logger) {
-    // Collect diffs for the files of the current node
-    const diffPromises = node.files.map(async (nodeFile) => {
-        const diff = await getFileDiff(nodeFile);
-        // 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)`, {
-            color: 'magenta',
-        });
-        return {
-            file: nodeFile.filePath,
-            summary: nodeFile.summary,
-            diff,
-            tokenCount,
+ * 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,
+            service: gitConfigParsed.coco?.model || config.service,
+            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,
+            defaultBranch: gitConfigParsed.coco?.defaultBranch || config.defaultBranch,
         };
-    });
-    // Collect diffs for the children of the current node
-    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
-    const [diffs, children] = await Promise.all([
-        Promise.all(diffPromises),
-        Promise.all(childrenPromises),
-    ]);
-    return {
-        path: node.getPath(),
-        diffs,
-        children,
-    };
+    }
+    return config;
 }
-
 /**
- * Get LLM Model Based on Configuration
- * @param fields
- * @param configuration
- * @returns LLM Model
+ * Appends the provided configuration to a git config file.
+ *
+ * @param filePath - The path to the .gitconfig
+ * @param config - The configuration object to append.
  */
-function getModel(name, key, fields) {
-    const [llm, model] = name.split(/\/(.*)/s);
-    if (!model) {
-        throw new Error(`Invalid model: ${name}`);
-    }
-    switch (llm) {
-        case 'huggingface':
-            return new HuggingFaceInference({
-                model: model,
-                apiKey: key,
-                maxConcurrency: 4,
-                ...fields,
-            });
-        case 'openai':
-        default:
-            return new OpenAI({
-                openAIApiKey: key,
-                modelName: model,
-                ...fields,
-            });
+const appendToGitConfig = async (filePath, config) => {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File ${filePath} does not exist.`);
     }
-}
+    const startComment = '# -- Start coco config --';
+    const endComment = '# -- End coco config --';
+    const header = '[coco]';
+    // Function to generate new content for the coco section
+    const getNewContent = async () => {
+        const contentLines = [header];
+        for (const key in config) {
+            // check if string has new lines, if so, wrap in quotes
+            if (typeof config[key] === 'string') {
+                const value = config[key];
+                if (value.includes('\n')) {
+                    contentLines.push(`\t${key} = ${JSON.stringify(value)}`);
+                    continue;
+                }
+            }
+            contentLines.push(`\t${key} = ${config[key]}`);
+        }
+        return contentLines.join('\n');
+    };
+    await updateFileSection({
+        filePath,
+        startComment,
+        endComment,
+        getNewContent,
+        confirmUpdate: true,
+        confirmMessage: CONFIG_ALREADY_EXISTS,
+    });
+};
+
 /**
- * Retrieve appropriate API key based on selected model
- * @param name
- * @param options
+ * Load .gitignore in project root
+ *
+ * @param {Config} config
  * @returns
  */
-function getApiKeyForModel(name, options) {
-    const [llm, model] = name.split(/\/(.*)/s);
-    if (!model) {
-        throw new Error(`Invalid model: ${name}`);
-    }
-    switch (llm) {
-        case 'huggingface':
-            return options.huggingFaceHubApiKey;
-        case 'openai':
-        default:
-            return options.openAIApiKey;
+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;
 }
 /**
- * Get Recursive Character Text Splitter
- * @param options
+ * Load .ignore in project root
+ *
+ * @param {Config} config
  * @returns
  */
-function getTextSplitter(options = {}) {
-    return new RecursiveCharacterTextSplitter(options);
+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;
 }
+
 /**
- * Get Summarization Chain
- * @param model
- * @param options
- * @returns
- */
-function getChain(model, options = { type: 'map_reduce' }) {
-    return loadSummarizationChain(model, options);
-}
-function getPrompt({ template, variables, fallback }) {
-    if (!template && !fallback)
-        throw new Error('Must provide either a template or a fallback');
-    return (template
-        ? new PromptTemplate({
-            template,
-            inputVariables: variables,
-        })
-        : fallback);
+ * Load project config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadProjectConfig(config) {
+    // TODO: Add validation based of JSON schema?
+    // @see https://github.com/acornejo/jjv
+    if (fs.existsSync('.coco.config.json')) {
+        const projectConfig = JSON.parse(fs.readFileSync('.coco.config.json', 'utf-8'));
+        config = { ...config, ...projectConfig };
+    }
+    return config;
 }
+const appendToProjectConfig = (filePath, config) => {
+    fs.writeFileSync(filePath, JSON.stringify({
+        $schema: 'https://git-co.co/schema.json',
+        ...config,
+    }, null, 2));
+};
+
 /**
- * Verify  template string contains all required input variables
- * @param text template string
- * @param inputVariables template variables
- * @returns boolean or error message
+ * Load XDG config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
  */
-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;
-}
-
-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 [previousContent, newContent] = await Promise.all([
-            git.show([`${previousCommitHash}:${oldFilePath}`]),
-            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
-        ]);
-        if (previousContent !== newContent) {
-            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
-                context: 3,
-            });
-            // remove the first 4 lines of the patch (they contain the old and new file names)
-            result = result.split('\n').slice(4).join('\n');
-        }
-        else {
-            result = 'File contents are unchanged.';
-        }
-    }
-    catch (err) {
-        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
-        result = 'Error comparing file contents.';
-    }
-    return result;
-}
-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;
+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 };
     }
-    // If not deleted or renamed, get the diff from the index
-    const defaultDiff = await parseDefaultFileDiff(nodeFile, commit, git);
-    return defaultDiff;
-}
-
-const MAX_TOKENS_PER_SUMMARY = 2048;
-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,
-        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;
+    return config;
 }
 
 /**
- * Wrapper around GPT3NodeTokenizer to handle default export.
+ * Load application config
  *
- * @see https://github.com/botisan-ai/gpt3-tokenizer/issues/18
+ * Merge config from multiple sources.
  *
- * @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;
-};
+ * \* 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 };
+}
 
 class Logger {
     constructor(config) {
@@ -502,391 +430,492 @@ class Logger {
     }
 }
 
-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,
-});
-
-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';
+function commandExecutor(handler) {
+    return async (argv) => {
+        const options = loadConfig(argv);
+        const logger = new Logger(options);
+        try {
+            await handler(argv, logger);
         }
-    }
-    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');
-    }
-}
-
-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}`;
+        catch (error) {
+            logger.log('\nFailed to execute command', { color: 'yellow' });
+            logger.verbose(`\nError: "${error.message}"`, { color: 'red' });
+            logger.log('\nThanks for using coco, make it a great day! 👋🤖', { color: 'blue' });
+            process.exit(0);
+        }
+    };
 }
 
 /**
- * Returns a new object with all undefined keys removed
- *
- * @param obj Object to remove undefined keys from
- * @returns
+ * 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 removeUndefined(obj) {
-    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+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.call({
+        input_documents: docs,
+        returnIntermediateSteps,
+    });
+    if (res.error)
+        throw new Error(res.error);
+    return res.text && res.text.trim();
 }
 
 /**
- * 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'],
-    defaultBranch: 'main',
-};
-/**
- * Config keys
- *
- * @type {string[]}
+ * Create groups from a given node info.
+ * @param {DiffNode} node - The node info to start grouping.
+ * @returns {DirectoryDiff[]} The groups created.
  */
-const CONFIG_KEYS = Object.keys({
-    ...DEFAULT_CONFIG,
-    huggingFaceHubApiKey: '',
-    openAIApiKey: '',
-    prompt: '',
-});
-
-async function updateFileSection(filePath, startComment, endComment, getNewContent, confirmUpdate = true) {
-    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: `A section already exists in ${filePath}, do you want to override it?`,
-                    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++;
+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 };
             }
-            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);
+            groupByPath[path].diffs.push(diff);
+            groupByPath[path].tokenCount += diff.tokenCount;
+        });
+        node.children.forEach(traverse);
     }
-    // Write the updated contents back to the file
-    fs__default.writeFileSync(filePath, newLines.join('\n'));
+    traverse(node);
+    return Object.values(groupByPath);
 }
-
 /**
- * Load environment variables
- *
- * @param {Config} config
- * @returns {Config} Updated config
- **/
-function loadEnvConfig(config) {
-    const envConfig = {};
-    CONFIG_KEYS.forEach((key) => {
-        const envVarName = toEnvVarName(key);
-        const envValue = parseEnvValue(key, process.env[envVarName]);
-        if (envValue === undefined)
-            return;
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        envConfig[key] = envValue;
-    });
-    return { ...config, ...removeUndefined(envConfig) };
-}
-function parseEnvValue(key, value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    else if (key === 'tokenLimit' && typeof value === 'string') {
-        return parseInt(value);
+ * 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,
+        };
     }
-    else if ((key === 'ignoredFiles' || key === 'ignoredExtensions') &&
-        typeof value === 'string' &&
-        value.includes(',')) {
-        return value.split(',');
+    catch (error) {
+        console.error(error);
+        return directory;
     }
-    return value;
 }
-function toEnvVarName(key) {
-    switch (key) {
-        case 'openAIApiKey':
-            return 'OPENAI_API_KEY';
-        case 'huggingFaceHubApiKey':
-            return 'HUGGINGFACE_HUB_API_KEY';
-        default:
-            return 'COCO_' + key.replace(/([A-Z])/g, '_$1').toUpperCase();
+const defaultOutputCallback = (group) => {
+    let output = `
+-------\n* changes in "/${group.path}"\n\n`;
+    if (group.summary) {
+        output += `${group.diffs.map((diff) => ` • ${diff.summary}`).join('\n')}\n\nSummary:\n\n${group.summary}\n\n`;
+    }
+    else {
+        output += `${group.diffs.map((diff) => ` • ${diff.summary}\n\n${diff.diff}`).join('\n\n')}\n\n`;
     }
+    return output;
+};
+async function summarizeDiffs(rootDiffNode, { tokenizer, logger, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
+    const queue = new pQueue({ concurrency: 8 });
+    logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
+    const directoryDiffs = createDirectoryDiffs(rootDiffNode);
+    // Sort by token count descending
+    directoryDiffs.sort((a, b) => b.tokenCount - a.tokenCount);
+    let totalTokenCount = directoryDiffs.reduce((sum, group) => sum + group.tokenCount, 0);
+    logger.stopSpinner('Diffs Organized').stopTimer();
+    logger.startSpinner(`Consolidating Diffs`, { color: 'blue' });
+    const processingTasks = directoryDiffs.map((group, i) => {
+        return queue.add(async () => {
+            // If the diff token count is already less than the average req, we can skip summarizing.
+            const isLessThanAvgTokenReq = group.tokenCount <= maxTokens / directoryDiffs.length;
+            if (totalTokenCount <= maxTokens || isLessThanAvgTokenReq) {
+                return group;
+            }
+            group = await summarizeDirectoryDiff(group, {
+                chain,
+                textSplitter,
+                tokenizer,
+            });
+            // We need to subtract the old token count and add the new one
+            totalTokenCount = totalTokenCount - directoryDiffs[i].tokenCount + group.tokenCount;
+            directoryDiffs[i] = group;
+            logger
+                .verbose(`\n • Summarized diffs in "/${group.path}" `, { color: 'blue' })
+                .verbose(`\nTotal token count: ${totalTokenCount}`, {
+                color: totalTokenCount > maxTokens ? 'yellow' : 'green',
+            });
+            return group;
+        }, { priority: group.tokenCount });
+    });
+    await Promise.all(processingTasks);
+    logger.stopSpinner(`Summarized Diffs`);
+    return directoryDiffs.map(handleOutput).join('');
 }
-function formatEnvValue(value) {
-    if (typeof value === 'number') {
-        return `${value}`;
+
+class DiffTreeNode {
+    constructor(path) {
+        this.path = [];
+        this.files = [];
+        this.children = new Map();
+        if (path)
+            this.path = path;
     }
-    else if (Array.isArray(value)) {
-        return `${value.join(',')}`;
+    addFile(file) {
+        this.files.push(file);
     }
-    else if (typeof value === 'string') {
-        // Escape newlines and tabs in strings
-        return `${value.replace(/\n/g, '\\n').replace(/\t/g, '\\t')}`;
+    addChild(part, node) {
+        this.children.set(part, node);
+    }
+    getChild(part) {
+        return this.children.get(part);
+    }
+    getPath() {
+        return this.path.join('/');
+    }
+    print(indentation = 0) {
+        const indent = ' '.repeat(indentation);
+        let output = `${indent}- Path: ${this.getPath()}\n`;
+        if (this.files.length > 0) {
+            output += `${indent}  Files:\n`;
+            for (const file of this.files) {
+                output += `${indent}    - ${file.summary}\n`;
+            }
+        }
+        if (this.children.size > 0) {
+            output += `${indent}  Children:\n`;
+            for (const [, child] of this.children) {
+                output += child.print(indentation + 4);
+            }
+        }
+        return output;
     }
-    return `${value}`;
 }
-const appendToEnvFile = async (filePath, config) => {
-    const startComment = '# -- Start coco config --';
-    const endComment = '# -- End coco config --';
-    const getNewContent = async () => {
-        return Object.entries(config)
-            .map(([key, value]) => `${toEnvVarName(key)}=${formatEnvValue(value)}`)
-            .join('\n');
-    };
-    await updateFileSection(filePath, startComment, endComment, getNewContent);
+const createDiffTree = (changes) => {
+    const root = new DiffTreeNode();
+    for (const change of changes) {
+        let currentParent = root;
+        const parts = change.filePath.split('/');
+        parts.pop();
+        for (const part of parts) {
+            let childNode = currentParent.getChild(part);
+            if (!childNode) {
+                childNode = new DiffTreeNode([...currentParent.path, part]);
+                currentParent.addChild(part, childNode);
+            }
+            currentParent = childNode;
+        }
+        // Create a NodeFile object and add it to the parent
+        currentParent.addFile({
+            filePath: change.filePath,
+            oldFilePath: change.oldFilePath,
+            summary: change.summary,
+            status: change.status,
+        });
+    }
+    return root;
 };
 
 /**
- * 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,
-            defaultBranch: gitConfigParsed.coco?.defaultBranch || config.defaultBranch,
+ * Asynchronously collect diffs for a given node and its children.
+ */
+async function collectDiffs(node, getFileDiff, tokenizer, logger) {
+    // Collect diffs for the files of the current node
+    const diffPromises = node.files.map(async (nodeFile) => {
+        const diff = await getFileDiff(nodeFile);
+        const tokenCount = tokenizer(diff);
+        logger.verbose(`Collected diff for ${nodeFile.filePath} (${tokenCount} tokens)`, {
+            color: 'magenta',
+        });
+        return {
+            file: nodeFile.filePath,
+            summary: nodeFile.summary,
+            diff,
+            tokenCount,
         };
+    });
+    // Collect diffs for the children of the current node
+    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer, logger));
+    const [diffs, children] = await Promise.all([
+        Promise.all(diffPromises),
+        Promise.all(childrenPromises),
+    ]);
+    return {
+        path: node.getPath(),
+        diffs,
+        children,
+    };
+}
+
+function getModelAndProviderFromService(service) {
+    const [provider, model] = service.split(/\/(.*)/s);
+    if (!model || !provider) {
+        throw new Error(`Invalid service: ${service}`);
     }
-    return config;
+    return { provider, model };
+}
+function getModelFromService(service) {
+    const { model } = getModelAndProviderFromService(service);
+    return model;
 }
 /**
- * Appends the provided configuration to a git config file.
- *
- * @param filePath - The path to the .gitconfig
- * @param config - The configuration object to append.
+ * Get LLM Model Based on Configuration
+ * @param fields
+ * @param configuration
+ * @returns LLM Model
  */
-const appendToGitConfig = async (filePath, config) => {
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`File ${filePath} does not exist.`);
+function getLlm(service, key, fields) {
+    const { provider, model } = getModelAndProviderFromService(service);
+    if (!model) {
+        throw new Error(`Invalid LLM Service: ${service}`);
     }
-    const startComment = '# -- Start coco config --';
-    const endComment = '# -- End coco config --';
-    const header = '[coco]';
-    // Function to generate new content for the coco section
-    const getNewContent = async () => {
-        const contentLines = [header];
-        for (const key in config) {
-            // check if string has new lines, if so, wrap in quotes
-            if (typeof config[key] === 'string') {
-                const value = config[key];
-                if (value.includes('\n')) {
-                    contentLines.push(`\t${key} = ${JSON.stringify(value)}`);
-                    continue;
-                }
-            }
-            contentLines.push(`\t${key} = ${config[key]}`);
-        }
-        return contentLines.join('\n');
-    };
-    // Use the updateFileSection utility
-    await updateFileSection(filePath, startComment, endComment, getNewContent);
-};
-
+    switch (provider) {
+        case 'huggingface':
+            return new HuggingFaceInference({
+                model: model,
+                apiKey: key,
+                maxConcurrency: 4,
+                ...fields,
+            });
+        case 'openai':
+        default:
+            return new OpenAI({
+                openAIApiKey: key,
+                modelName: model,
+                ...fields,
+            });
+    }
+}
 /**
- * Load .gitignore in project root
- *
- * @param {Config} config
+ * Retrieve appropriate API key based on selected model
+ * @param service
+ * @param options
  * @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('#')),
-        ];
+function getApiKeyForModel(service, options) {
+    const { provider } = getModelAndProviderFromService(service);
+    switch (provider) {
+        case 'huggingface':
+            return options.huggingFaceHubApiKey;
+        case 'openai':
+        default:
+            return options.openAIApiKey;
     }
-    return config;
 }
 /**
- * Load .ignore in project root
- *
- * @param {Config} config
+ * Get Recursive Character Text Splitter
+ * @param options
  * @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('#')),
-        ];
+function getTextSplitter(options = {}) {
+    return new RecursiveCharacterTextSplitter(options);
+}
+/**
+ * Get Summarization Chain
+ * @param model
+ * @param options
+ * @returns
+ */
+function getSummarizationChain(model, options = { type: 'map_reduce' }) {
+    return loadSummarizationChain(model, options);
+}
+function getPrompt({ template, variables, fallback }) {
+    if (!template && !fallback)
+        throw new Error('Must provide either a template or a fallback');
+    return (template
+        ? new PromptTemplate({
+            template,
+            inputVariables: variables,
+        })
+        : fallback);
+}
+/**
+ * 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 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 [previousContent, newContent] = await Promise.all([
+            git.show([`${previousCommitHash}:${oldFilePath}`]),
+            git.show([`${newCommitHash}:${nodeFile.filePath}`]),
+        ]);
+        if (previousContent !== newContent) {
+            result = createTwoFilesPatch(oldFilePath, nodeFile.filePath, previousContent, newContent, '', '', {
+                context: 3,
+            });
+            // remove the first 4 lines of the patch (they contain the old and new file names)
+            result = result.split('\n').slice(4).join('\n');
+        }
+        else {
+            result = 'File contents are unchanged.';
+        }
+    }
+    catch (err) {
+        logger.verbose(`Error comparing file contents for ${nodeFile.filePath}`, { color: 'red' });
+        result = 'Error comparing file contents.';
+    }
+    return result;
+}
+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;
+}
+
+const MAX_TOKENS_PER_SUMMARY = 2048;
+async function fileChangeParser({ changes, commit, options: { tokenizer, git, llm: model, logger }, }) {
+    const textSplitter = getTextSplitter({ chunkSize: 2000, chunkOverlap: 125 });
+    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;
+}
+
+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,
+});
+
+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';
     }
-    return config;
-}
-
-/**
- * Load project config
- *
- * @param {Config} config
- * @returns {Config} Updated config
- **/
-function loadProjectConfig(config) {
-    // TODO: Add validation based of JSON schema?
-    // @see https://github.com/acornejo/jjv
-    if (fs.existsSync('.coco.config.json')) {
-        const projectConfig = JSON.parse(fs.readFileSync('.coco.config.json', 'utf-8'));
-        config = { ...config, ...projectConfig };
+    else {
+        throw new Error('Invalid file type');
     }
-    return config;
 }
-const appendToProjectConfig = (filePath, config) => {
-    fs.writeFileSync(filePath, JSON.stringify({
-        $schema: 'https://git-co.co/schema.json',
-        ...config,
-    }, null, 2));
-};
 
-/**
- * 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 };
+function getSummaryText(file, change) {
+    const status = change.status || getStatus(file);
+    let filePath;
+    if ('path' in file) {
+        filePath = file.path;
     }
-    return config;
-}
-
-/**
- * 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 };
+    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}`;
 }
 
 const config = loadConfig();
@@ -974,11 +1003,6 @@ async function noResult({ git, logger }) {
     }
 }
 
-const isInteractive = (argv) => {
-    return argv?.mode === 'interactive' || argv.interactive;
-};
-const SEPERATOR = chalk.blue('----------------');
-
 function logResult(label, result) {
     console.log(`\n${chalk.bgBlue(chalk.bold(`Proposed ${label}:`))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
 }
@@ -995,41 +1019,51 @@ async function editResult(result, options) {
     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 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,
+    }));
 }
 
 async function editPrompt(options) {
@@ -1082,7 +1116,10 @@ async function generateAndReviewLoop({ label, factory, parser, noResult, agent,
             .stopTimer();
         if (options?.interactive) {
             logResult(label, result);
-            const reviewAnswer = await getUserReviewDecision();
+            const reviewAnswer = await getUserReviewDecision({
+                label,
+                ...options?.review || {},
+            });
             if (reviewAnswer === 'cancel') {
                 process.exit(0);
             }
@@ -1136,20 +1173,20 @@ const executeChain = async ({ llm, prompt, variables }) => {
     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 (result, { mode, git }) => {
-    // Handle resulting commit message
+async function handleResult({ result, mode, interactiveHandler }) {
     switch (mode) {
         case 'interactive':
-            await createCommit(result, git);
-            logSuccess();
+            if (interactiveHandler) {
+                await interactiveHandler(result);
+            }
+            else {
+                console.warn('No result handler provided for interactive mode.');
+                logSuccess();
+            }
             break;
         case 'stdout':
         default:
@@ -1157,7 +1194,7 @@ const handleResult = async (result, { mode, git }) => {
             break;
     }
     process.exit(0);
-};
+}
 
 const getRepo = () => {
     let git;
@@ -1171,21 +1208,38 @@ const getRepo = () => {
     return git;
 };
 
-async function handler$2(argv) {
-    const tokenizer = getTokenizer();
+const getTikToken = async (modelName) => {
+    return await encoding_for_model(modelName);
+};
+const getTokenCounter = async (modelName) => getTikToken(modelName).then((tokenizer) => (text) => {
+    // console.log('Running GetTokenCount', { tokenizer, length: text.length })
+    const tokens = tokenizer.encode(text);
+    // console.log('Tokens', { tokenCount: tokens.length })
+    return tokens.length;
+});
+
+async function createCommit(commitMsg, git) {
+    return await git.commit(commitMsg);
+}
+
+const handler$2 = async (argv, logger) => {
     const git = getRepo();
     const options = loadConfig(argv);
-    const logger = new Logger(options);
-    const key = getApiKeyForModel(options.model, options);
+    const { service } = options;
+    const key = getApiKeyForModel(service, options);
+    const tokenizer = await getTokenCounter(getModelFromService(service));
     if (!key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
-    const model = getModel(options.model, key, {
+    const llm = getLlm(service, key, {
         temperature: 0.4,
         maxConcurrency: 10,
     });
     const INTERACTIVE = isInteractive(options);
+    if (INTERACTIVE) {
+        logger.log(LOGO);
+    }
     async function factory() {
         const changes = await getChanges({ git });
         return changes.staged;
@@ -1194,16 +1248,16 @@ async function handler$2(argv) {
         return await fileChangeParser({
             changes,
             commit: '--staged',
-            options: { tokenizer, git, model, logger },
+            options: { tokenizer, git, llm, logger },
         });
     }
     const commitMsg = await generateAndReviewLoop({
-        label: 'Commit Message',
+        label: 'commit message',
         factory,
         parser,
         agent: async (context, options) => {
             return await executeChain({
-                llm: model,
+                llm,
                 prompt: getPrompt({
                     template: options.prompt,
                     variables: COMMIT_PROMPT.inputVariables,
@@ -1221,14 +1275,27 @@ async function handler$2(argv) {
             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',
+                },
+            },
         },
     });
     const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
-    handleResult(commitMsg, {
+    handleResult({
+        result: commitMsg,
+        interactiveHandler: async (result) => {
+            await createCommit(result, git);
+            logSuccess();
+        },
         mode: MODE,
-        git,
     });
-}
+};
 
 /**
  * Command line options via yargs
@@ -1287,7 +1354,7 @@ var commit = {
     command: 'commit',
     desc: 'Generate commit message',
     builder: builder$2,
-    handler: handler$2,
+    handler: commandExecutor(handler$2),
     options: options$2,
 };
 
@@ -1364,20 +1431,22 @@ async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main
     return [];
 }
 
-async function handler$1(argv) {
+const handler$1 = async (argv, logger) => {
     const options = loadConfig(argv);
-    const logger = new Logger(options);
     const git = getRepo();
-    const key = getApiKeyForModel(options.model, options);
+    const key = getApiKeyForModel(options.service, options);
     if (!key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
         process.exit(1);
     }
-    const model = getModel(options.model, key, {
+    const model = getLlm(options.service, key, {
         temperature: 0.4,
         maxConcurrency: 10,
     });
     const INTERACTIVE = isInteractive(options);
+    if (INTERACTIVE) {
+        logger.log(LOGO);
+    }
     async function factory() {
         if (options.range) {
             const [from, to] = options.range?.split(':');
@@ -1395,7 +1464,7 @@ async function handler$1(argv) {
         return result;
     }
     const changelogMsg = await generateAndReviewLoop({
-        label: 'Changelog',
+        label: 'changelog',
         factory,
         parser,
         agent: async (context, options) => {
@@ -1423,14 +1492,20 @@ async function handler$1(argv) {
             prompt: options.prompt || CHANGELOG_PROMPT.template,
             logger,
             interactive: INTERACTIVE,
+            review: {
+                enableFullRetry: false,
+            },
         },
     });
     const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
-    handleResult(changelogMsg, {
+    handleResult({
+        result: changelogMsg,
+        interactiveHandler: async () => {
+            logSuccess();
+        },
         mode: MODE,
-        git,
     });
-}
+};
 
 /**
  * Command line options via yargs
@@ -1489,39 +1564,138 @@ var changelog = {
     command: 'changelog',
     desc: 'Generate a changelog from a commit range',
     builder: builder$1,
-    handler: handler$1,
+    handler: commandExecutor(handler$1),
     options: options$1,
 };
 
-const handleProjectLevelConfig = async () => {
-    const projectConfiguration = await select({
-        message: 'select type project level configuration:',
-        choices: [
-            {
-                name: '.coco.config.json',
-                value: '.coco.config.json',
-            },
-            {
-                name: '.env',
-                value: '.env',
-            },
-        ],
+/**
+ * Finds the project root directory starting from the given current directory.
+ * It checks if the `.git` directory or `package.json` file exists in the current directory or any of its parent directories.
+ * If found, it returns the path to the project root directory.
+ * If not found, it throws an error.
+ *
+ * @param currentDir - The current directory to start searching from.
+ * @returns The path to the project root directory.
+ * @throws Error if the project root directory cannot be found.
+ */
+function findProjectRoot(currentDir) {
+    const root = path__default.parse(currentDir).root;
+    while (currentDir !== root) {
+        if (fs__default.existsSync(path__default.join(currentDir, '.git')) ||
+            fs__default.existsSync(path__default.join(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        currentDir = path__default.dirname(currentDir);
+    }
+    throw new Error('Unable to find project root. Are you in the right directory?');
+}
+
+// Function to execute a command and return a promise
+function execPromise(command, options = {}) {
+    return new Promise((resolve, reject) => {
+        exec(command, options, (error, stdout, stderr) => {
+            if (error) {
+                reject(`Execution error: ${error}`);
+            }
+            else {
+                resolve({ stdout, stderr });
+            }
+        });
     });
-    let configFile = '.coco.config.json';
-    if (projectConfiguration === '.env') {
-        configFile = '.env';
-        if (!fs__default.existsSync('.env')) {
-            fs__default.writeFileSync('.env', '');
+}
+
+/**
+ * Installs a package using npm.
+ *
+ * @param {InstallPackageInput} options - The options for installing the package.
+ * @returns {Promise<boolean>} - A promise that resolves to true if the package is installed successfully, false otherwise.
+ */
+async function installNpmPackage({ name, flags = [], cwd = process.cwd(), }) {
+    const { stdout, stderr } = await execPromise(`npm i ${name} ${flags.join(' ')} --yes`, { cwd });
+    if (stderr) {
+        console.error(`Execution error: ${stderr}`);
+        return false;
+    }
+    console.log(stdout);
+    console.error(stderr);
+    return true;
+}
+
+/**
+ * Checks if a package is installed in a project.
+ *
+ * @param packageName - The name of the package to check.
+ * @param projectPath - The path to the project.
+ * @returns True if the package is installed, false otherwise.
+ */
+function isPackageInstalled(packageName, projectPath) {
+    try {
+        // Construct the path to the package.json file
+        const packageJsonPath = path__default.join(projectPath, 'package.json');
+        // Read the package.json file
+        const packageJson = JSON.parse(fs__default.readFileSync(packageJsonPath, 'utf8'));
+        // Check both dependencies and devDependencies
+        const dependencies = packageJson.dependencies || {};
+        const devDependencies = packageJson.devDependencies || {};
+        // Return true if the package is found in either
+        return dependencies.hasOwnProperty(packageName) || devDependencies.hasOwnProperty(packageName);
+    }
+    catch (error) {
+        console.error(`Error checking package installation: ${error.message}`);
+        return false;
+    }
+}
+
+// TODO: QoL improvement to import this from `package.json`
+const packageName = 'git-coco';
+async function checkAndHandlePackageInstallation({ global = false, logger, }) {
+    try {
+        // Global installation
+        if (global) {
+            logger.startSpinner(`Installing '${packageName}' globally...`, { color: 'blue' });
+            await installNpmPackage({ name: packageName, flags: ['-g'] });
+            logger.stopSpinner(`Installed '${packageName}' globally`);
+            return;
+        }
+        // Project level installation
+        const projectRoot = findProjectRoot(process.cwd());
+        let shouldInstall = false;
+        if (isPackageInstalled(packageName, projectRoot)) {
+            shouldInstall = await confirm({
+                message: `'${packageName}' is already installed in '${projectRoot}/package.json', would you like to update?`,
+                default: shouldInstall,
+            });
+        }
+        else {
+            shouldInstall = true;
+        }
+        if (!shouldInstall) {
+            return;
         }
+        logger.startSpinner(`Installing '${packageName}' in project...`, { color: 'blue' });
+        await installNpmPackage({ name: packageName, cwd: projectRoot });
+        logger.stopSpinner(`Installed '${packageName}' in project`);
     }
-    return configFile;
-};
-const handleSystemLevelConfig = () => {
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+    }
+}
+
+function getPathToUsersGitConfig() {
     return path__default.join(os__default.homedir(), '.gitconfig');
-};
-async function handler(argv) {
-    const options = loadConfig(argv);
-    const logger = new Logger(options);
+}
+
+async function createProjectFileAndReturnPath(fileName, contents) {
+    const projectRoot = findProjectRoot(process.cwd());
+    const configFile = `${projectRoot}/${fileName}`;
+    if (!fs__default.existsSync(configFile)) {
+        fs__default.writeFileSync(configFile, contents || '');
+    }
+    return configFile;
+}
+
+const handler = async (argv, logger) => {
+    logger.log(LOGO);
     const level = await select({
         message: 'configure coco at the system or project level:',
         choices: [
@@ -1539,11 +1713,25 @@ async function handler(argv) {
     });
     let configFilePath = '';
     switch (level) {
-        case 'system':
-            configFilePath = await handleSystemLevelConfig();
-            break;
         case 'project':
-            configFilePath = await handleProjectLevelConfig();
+            const projectConfiguration = await select({
+                message: 'select type project level configuration:',
+                choices: [
+                    {
+                        name: '.coco.config.json',
+                        value: '.coco.config.json',
+                    },
+                    {
+                        name: '.env',
+                        value: '.env',
+                    },
+                ],
+            });
+            configFilePath = await createProjectFileAndReturnPath(projectConfiguration);
+            break;
+        case 'system':
+        default:
+            configFilePath = getPathToUsersGitConfig();
             break;
     }
     // interactive v.s stdout mode
@@ -1640,7 +1828,7 @@ async function handler(argv) {
     // add to config after logging, so that the API key is not logged
     config.openAIApiKey = apiKey;
     const isApproved = await confirm({
-        message: 'look good? (hiding API key for security)',
+        message: 'looking good? (API key hidden for security)',
     });
     if (isApproved) {
         if (configFilePath.endsWith('.gitconfig')) {
@@ -1652,62 +1840,19 @@ async function handler(argv) {
         else if (configFilePath === '.coco.config.json') {
             await appendToProjectConfig(configFilePath, config);
         }
-        logger.log(`init successful! 🦾🤖🎉`, { color: 'green' });
+        // After config is written, check for package installation
+        await checkAndHandlePackageInstallation({ global: level === 'system', logger });
+        logger.log(`\ninit successful! 🦾🤖🎉`, { color: 'green' });
     }
     else {
-        logger.log('init cancelled.', { color: 'yellow' });
+        logger.log('\ninit cancelled.', { color: 'yellow' });
     }
-}
+};
 
 /**
  * Command line options via yargs
  */
-const options = {
-    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: '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 options = {};
 const builder = (yargs) => {
     return yargs.options(options);
 };
@@ -1716,7 +1861,7 @@ var init = {
     command: 'init',
     desc: 'Setup coco for a new project or system',
     builder,
-    handler,
+    handler: commandExecutor(handler),
     options,
 };
 
@@ -1724,25 +1869,23 @@ var types = /*#__PURE__*/Object.freeze({
   __proto__: null
 });
 
-yargs
-    .scriptName('coco')
-    .usage('$0 <cmd> [args]')
-    .command([commit.command, '$0'], commit.desc, 
+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)
-    .command(changelog.command, changelog.desc, 
+commit.builder, commit.handler);
+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)
-    .command(init.command, init.desc, 
+changelog.builder, changelog.handler);
+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)
-    .demandCommand()
-    .help().argv;
+init.builder, init.handler);
+y.parse(process.argv.slice(2));
 
 export { changelog, commit, init, types };