git-coco 0.6.3 → 0.7.0

package/dist/index.esm.mjs

@@ -1,163 +1,585 @@
 #!/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 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(directorySummary);
-        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;
-    }
-    addFile(file) {
-        this.files.push(file);
+function parseEnvValue(key, value) {
+    if (value === undefined) {
+        return undefined;
     }
-    addChild(part, node) {
-        this.children.set(part, node);
+    else if (key === 'tokenLimit' && typeof value === 'string') {
+        return parseInt(value);
+    }
+    else if ((key === 'ignoredFiles' || key === 'ignoredExtensions') &&
+        typeof value === 'string' &&
+        value.includes(',')) {
+        return value.split(',');
+    }
+    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();
+    }
+}
+function formatEnvValue(value) {
+    if (typeof value === 'number') {
+        return `${value}`;
+    }
+    else if (Array.isArray(value)) {
+        return `${value.join(',')}`;
+    }
+    else if (typeof value === 'string') {
+        // Escape newlines and tabs in strings
+        return `${value.replace(/\n/g, '\\n').replace(/\t/g, '\\t')}`;
+    }
+    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,
+    });
+};
+
+/**
+ * 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,
+        };
+    }
+    return config;
+}
+/**
+ * Appends the provided configuration to a git config file.
+ *
+ * @param filePath - The path to the .gitconfig
+ * @param config - The configuration object to append.
+ */
+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,
+    });
+};
+
+/**
+ * Load .gitignore in project root
+ *
+ * @param {Config} config
+ * @returns
+ */
+function loadGitignore(config) {
+    if (fs.existsSync('.gitignore')) {
+        const gitignoreContent = fs.readFileSync('.gitignore', 'utf-8');
+        config.ignoredFiles = [
+            ...(config?.ignoredFiles || []),
+            ...gitignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
+        ];
+    }
+    return config;
+}
+/**
+ * Load .ignore in project root
+ *
+ * @param {Config} config
+ * @returns
+ */
+function loadIgnore(config) {
+    if (fs.existsSync('.ignore')) {
+        const ignoreContent = fs.readFileSync('.ignore', 'utf-8');
+        config.ignoredFiles = [
+            ...(config?.ignoredFiles || []),
+            ...ignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
+        ];
+    }
+    return config;
+}
+
+/**
+ * Load project config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadProjectConfig(config) {
+    // 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));
+};
+
+/**
+ * Load XDG config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ */
+function loadXDGConfig(config) {
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    const xdgConfigPath = path.join(xdgConfigHome, 'coco', 'config.json');
+    if (fs.existsSync(xdgConfigPath)) {
+        const xdgConfig = JSON.parse(fs.readFileSync(xdgConfigPath, 'utf-8'));
+        config = { ...config, ...xdgConfig };
+    }
+    return config;
+}
+
+/**
+ * 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 };
+}
+
+class Logger {
+    constructor(config) {
+        this.config = config;
+        this.spinner = null;
+    }
+    log(message, options = { color: 'blue' }) {
+        let outputMessage = message;
+        if (options.color) {
+            outputMessage = chalk[options.color](outputMessage);
+        }
+        console.log(outputMessage);
+        return this;
+    }
+    verbose(message, options = {}) {
+        if (!this.config?.verbose) {
+            return this;
+        }
+        this.log(message, options);
+        return this;
+    }
+    startTimer() {
+        this.timerStart = now();
+        return this;
+    }
+    stopTimer(message, options = { color: 'yellow' }) {
+        if (!this.config?.verbose || !this.timerStart) {
+            return this;
+        }
+        const elapsedTime = prettyMilliseconds(now() - this.timerStart);
+        let outputMessage = message
+            ? `${message} (⏲ ${elapsedTime})`
+            : `⏲ ${elapsedTime}`;
+        if (options.color) {
+            outputMessage = chalk[options.color](outputMessage);
+        }
+        console.log(outputMessage);
+        return this;
+    }
+    startSpinner(message, options = { color: 'green' }) {
+        const spinnerMessage = options.color ? chalk[options.color](message) : message;
+        this.spinner = ora(spinnerMessage).start();
+        return this;
+    }
+    stopSpinner(message = '', options = { mode: 'succeed', color: 'green' }) {
+        const spinnerMessage = options?.color ? chalk[options.color](message) : message;
+        this.spinner?.[options.mode || 'succeed'](spinnerMessage);
+        this.spinner = null;
+        return this;
+    }
+}
+
+function commandExecutor(handler) {
+    return async (argv) => {
+        const options = loadConfig(argv);
+        const logger = new Logger(options);
+        try {
+            await handler(argv, logger);
+        }
+        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);
+        }
+    };
+}
+
+/**
+ * Extract the path from a file path string.
+ * @param {string} filePath - The full file path.
+ * @returns {string} The path portion of the file path.
+ */
+function getPathFromFilePath(filePath) {
+    return filePath.split('/').slice(0, -1).join('/');
+}
+
+async function summarize(documents, { chain, textSplitter, options }) {
+    const { returnIntermediateSteps = false } = options || {};
+    const docs = await textSplitter.splitDocuments(documents.map((doc) => new Document(doc)));
+    const res = await chain.call({
+        input_documents: docs,
+        returnIntermediateSteps,
+    });
+    if (res.error)
+        throw new Error(res.error);
+    return res.text && res.text.trim();
+}
+
+/**
+ * Create groups from a given node info.
+ * @param {DiffNode} node - The node info to start grouping.
+ * @returns {DirectoryDiff[]} The groups created.
+ */
+function createDirectoryDiffs(node) {
+    const groupByPath = {};
+    function traverse(node) {
+        node.diffs.forEach((diff) => {
+            const path = getPathFromFilePath(diff.file);
+            if (!groupByPath[path]) {
+                groupByPath[path] = { diffs: [], path, tokenCount: 0 };
+            }
+            groupByPath[path].diffs.push(diff);
+            groupByPath[path].tokenCount += diff.tokenCount;
+        });
+        node.children.forEach(traverse);
+    }
+    traverse(node);
+    return Object.values(groupByPath);
+}
+/**
+ * Summarize a directory diff asynchronously.
+ */
+async function summarizeDirectoryDiff(directory, { chain, textSplitter, tokenizer }) {
+    try {
+        const directorySummary = await summarize(directory.diffs.map((diff) => ({
+            pageContent: diff.diff,
+            metadata: {
+                file: diff.file,
+                summary: diff.summary,
+            },
+        })), {
+            chain,
+            textSplitter,
+            options: {
+                returnIntermediateSteps: true,
+            },
+        });
+        const newTokenTotal = tokenizer(directorySummary);
+        return {
+            diffs: directory.diffs,
+            path: directory.path,
+            summary: directorySummary,
+            tokenCount: newTokenTotal,
+        };
+    }
+    catch (error) {
+        console.error(error);
+        return directory;
+    }
+}
+const defaultOutputCallback = (group) => {
+    let output = `
+-------\n* changes in "/${group.path}"\n\n`;
+    if (group.summary) {
+        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('');
+}
+
+class DiffTreeNode {
+    constructor(path) {
+        this.path = [];
+        this.files = [];
+        this.children = new Map();
+        if (path)
+            this.path = path;
+    }
+    addFile(file) {
+        this.files.push(file);
+    }
+    addChild(part, node) {
+        this.children.set(part, node);
     }
     getChild(part) {
         return this.children.get(part);
@@ -338,18 +760,6 @@ function validatePromptTemplate(text, inputVariables) {
     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]);
@@ -431,59 +841,8 @@ async function fileChangeParser({ changes, commit, options: { tokenizer, git, ll
         chain: summarizationChain,
         logger,
     });
-    logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
-    return summary;
-}
-
-class Logger {
-    constructor(config) {
-        this.config = config;
-        this.spinner = null;
-    }
-    log(message, options = { color: 'blue' }) {
-        let outputMessage = message;
-        if (options.color) {
-            outputMessage = chalk[options.color](outputMessage);
-        }
-        console.log(outputMessage);
-        return this;
-    }
-    verbose(message, options = {}) {
-        if (!this.config?.verbose) {
-            return this;
-        }
-        this.log(message, options);
-        return this;
-    }
-    startTimer() {
-        this.timerStart = now();
-        return this;
-    }
-    stopTimer(message, options = { color: 'yellow' }) {
-        if (!this.config?.verbose || !this.timerStart) {
-            return this;
-        }
-        const elapsedTime = prettyMilliseconds(now() - this.timerStart);
-        let outputMessage = message
-            ? `${message} (⏲ ${elapsedTime})`
-            : `⏲ ${elapsedTime}`;
-        if (options.color) {
-            outputMessage = chalk[options.color](outputMessage);
-        }
-        console.log(outputMessage);
-        return this;
-    }
-    startSpinner(message, options = { color: 'green' }) {
-        const spinnerMessage = options.color ? chalk[options.color](message) : message;
-        this.spinner = ora(spinnerMessage).start();
-        return this;
-    }
-    stopSpinner(message = '', options = { mode: 'succeed', color: 'green' }) {
-        const spinnerMessage = options?.color ? chalk[options.color](message) : message;
-        this.spinner?.[options.mode || 'succeed'](spinnerMessage);
-        this.spinner = null;
-        return this;
-    }
+    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.  
@@ -511,368 +870,52 @@ function getStatus(file, location = 'index') {
         switch (statusCode) {
             case 'A':
                 return 'added';
-            case 'D':
-                return 'deleted';
-            case 'M':
-                return 'modified';
-            case 'R':
-                return 'renamed';
-            case '?':
-                return 'untracked';
-            default:
-                return 'unknown';
-        }
-    }
-    else if ('changes' in file && 'binary' in file) {
-        if (file.changes === 0)
-            return 'untracked';
-        if (file.file.includes('=>'))
-            return 'renamed';
-        if (file.deletions === 0 && file.insertions > 0)
-            return 'added';
-        if (file.insertions === 0 && file.deletions > 0)
-            return 'deleted';
-        if ((file.insertions > 0 && file.deletions > 0) || file.changes > 0)
-            return 'modified';
-        return 'unknown';
-    }
-    else {
-        throw new Error('Invalid file type');
-    }
-}
-
-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}`;
-}
-
-/**
- * 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));
-}
-
-/**
- * Default Config
- *
- * @type {Config}
- */
-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',
-};
-/**
- * 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[]}
- */
-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++;
-            }
-            newLines.push(endComment);
-            continue;
-        }
-        if (!foundSection || lines[i].trim() !== endComment) {
-            newLines.push(lines[i]);
-        }
-    }
-    // If section wasn't found, append it at the end
-    if (!foundSection) {
-        newLines.push('\n' + startComment);
-        const newContent = await getNewContent();
-        newLines.push(newContent);
-        newLines.push(endComment);
-    }
-    // Write the updated contents back to the file
-    fs__default.writeFileSync(filePath, newLines.join('\n'));
-}
-
-/**
- * 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);
-    }
-    else if ((key === 'ignoredFiles' || key === 'ignoredExtensions') &&
-        typeof value === 'string' &&
-        value.includes(',')) {
-        return value.split(',');
-    }
-    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();
-    }
-}
-function formatEnvValue(value) {
-    if (typeof value === 'number') {
-        return `${value}`;
-    }
-    else if (Array.isArray(value)) {
-        return `${value.join(',')}`;
-    }
-    else if (typeof value === 'string') {
-        // Escape newlines and tabs in strings
-        return `${value.replace(/\n/g, '\\n').replace(/\t/g, '\\t')}`;
-    }
-    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);
-};
-
-/**
- * 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,
-        };
-    }
-    return config;
-}
-/**
- * Appends the provided configuration to a git config file.
- *
- * @param filePath - The path to the .gitconfig
- * @param config - The configuration object to append.
- */
-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]}`);
+            case 'D':
+                return 'deleted';
+            case 'M':
+                return 'modified';
+            case 'R':
+                return 'renamed';
+            case '?':
+                return 'untracked';
+            default:
+                return 'unknown';
         }
-        return contentLines.join('\n');
-    };
-    // Use the updateFileSection utility
-    await updateFileSection(filePath, startComment, endComment, getNewContent);
-};
-
-/**
- * Load .gitignore in project root
- *
- * @param {Config} config
- * @returns
- */
-function loadGitignore(config) {
-    if (fs.existsSync('.gitignore')) {
-        const gitignoreContent = fs.readFileSync('.gitignore', 'utf-8');
-        config.ignoredFiles = [
-            ...(config?.ignoredFiles || []),
-            ...gitignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
-        ];
     }
-    return config;
-}
-/**
- * Load .ignore in project root
- *
- * @param {Config} config
- * @returns
- */
-function loadIgnore(config) {
-    if (fs.existsSync('.ignore')) {
-        const ignoreContent = fs.readFileSync('.ignore', 'utf-8');
-        config.ignoredFiles = [
-            ...(config?.ignoredFiles || []),
-            ...ignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
-        ];
+    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();
@@ -960,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`);
 }
@@ -1146,7 +1184,7 @@ async function handleResult({ result, mode, interactiveHandler }) {
                 await interactiveHandler(result);
             }
             else {
-                console.error('No result handler provided for interactive mode');
+                console.warn('No result handler provided for interactive mode.');
                 logSuccess();
             }
             break;
@@ -1184,11 +1222,10 @@ async function createCommit(commitMsg, git) {
     return await git.commit(commitMsg);
 }
 
-async function handler$2(argv) {
+const handler$2 = async (argv, logger) => {
     const git = getRepo();
     const options = loadConfig(argv);
     const { service } = options;
-    const logger = new Logger(options);
     const key = getApiKeyForModel(service, options);
     const tokenizer = await getTokenCounter(getModelFromService(service));
     if (!key) {
@@ -1200,6 +1237,9 @@ async function handler$2(argv) {
         maxConcurrency: 10,
     });
     const INTERACTIVE = isInteractive(options);
+    if (INTERACTIVE) {
+        logger.log(LOGO);
+    }
     async function factory() {
         const changes = await getChanges({ git });
         return changes.staged;
@@ -1255,7 +1295,7 @@ async function handler$2(argv) {
         },
         mode: MODE,
     });
-}
+};
 
 /**
  * Command line options via yargs
@@ -1314,7 +1354,7 @@ var commit = {
     command: 'commit',
     desc: 'Generate commit message',
     builder: builder$2,
-    handler: handler$2,
+    handler: commandExecutor(handler$2),
     options: options$2,
 };
 
@@ -1391,9 +1431,8 @@ 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.service, options);
     if (!key) {
@@ -1405,6 +1444,9 @@ async function handler$1(argv) {
         maxConcurrency: 10,
     });
     const INTERACTIVE = isInteractive(options);
+    if (INTERACTIVE) {
+        logger.log(LOGO);
+    }
     async function factory() {
         if (options.range) {
             const [from, to] = options.range?.split(':');
@@ -1452,7 +1494,7 @@ async function handler$1(argv) {
             interactive: INTERACTIVE,
             review: {
                 enableFullRetry: false,
-            }
+            },
         },
     });
     const MODE = (INTERACTIVE && 'interactive') || (options.commit && 'interactive') || options?.mode || 'stdout';
@@ -1463,7 +1505,7 @@ async function handler$1(argv) {
         },
         mode: MODE,
     });
-}
+};
 
 /**
  * Command line options via yargs
@@ -1522,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: [
@@ -1572,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
@@ -1673,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')) {
@@ -1685,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);
 };
@@ -1749,7 +1861,7 @@ var init = {
     command: 'init',
     desc: 'Setup coco for a new project or system',
     builder,
-    handler,
+    handler: commandExecutor(handler),
     options,
 };