git-coco 0.1.0

package/dist/index.esm.mjs

@@ -0,0 +1,1074 @@
+#!/usr/bin/env node
+import * as nodegit from 'nodegit';
+import { Diff, Blob, Tree, Repository } from 'nodegit';
+import { select, editor } from '@inquirer/prompts';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as ini from 'ini';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { PromptTemplate } from 'langchain/prompts';
+import PQueue from 'p-queue';
+import chalk from 'chalk';
+import ora from 'ora';
+import now from 'performance-now';
+import prettyMilliseconds from 'pretty-ms';
+import { Document } from 'langchain/document';
+import { createTwoFilesPatch } from 'diff';
+import * as util from 'util';
+import { loadSummarizationChain, LLMChain } from 'langchain/chains';
+import { OpenAI } from 'langchain/llms/openai';
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+import GPT3NodeTokenizer from 'gpt3-tokenizer';
+import { minimatch } from 'minimatch';
+
+/**
+ * Returns a new object with all undefined keys removed
+ *
+ * @param obj Object to remove undefined keys from
+ * @returns
+ */
+function removeUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}
+
+/**
+ * Load environment variables
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadEnvConfig(config) {
+    const envConfig = {
+        openAIApiKey: process.env.OPENAI_API_KEY || undefined,
+        tokenLimit: process.env.COCO_TOKEN_LIMIT
+            ? parseInt(process.env.COCO_TOKEN_LIMIT)
+            : undefined,
+        prompt: process.env.COCO_PROMPT,
+        mode: process.env.COCO_MODE,
+        summarizePrompt: process.env.COCO_SUMMARIZE_PROMPT,
+        ignoredFiles: process.env.COCO_IGNORED_FILES
+            ? process.env.COCO_IGNORED_FILES.split(',')
+            : undefined,
+        ignoredExtensions: process.env.COCO_IGNORED_EXTENSIONS
+            ? process.env.COCO_IGNORED_EXTENSIONS.split(',')
+            : undefined,
+    };
+    config = { ...config, ...removeUndefined(envConfig) };
+    return config;
+}
+
+/**
+ * Load git profile config (from ~/.gitconfig)
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadGitConfig(config) {
+    const gitConfigPath = path.join(os.homedir(), '.gitconfig');
+    if (fs.existsSync(gitConfigPath)) {
+        const gitConfigRaw = fs.readFileSync(gitConfigPath, 'utf-8');
+        const gitConfigParsed = ini.parse(gitConfigRaw);
+        config = {
+            ...config,
+            openAIApiKey: gitConfigParsed.coco?.openAIApiKey || config.openAIApiKey,
+            tokenLimit: parseInt(gitConfigParsed.coco?.tokenLimit) || config.tokenLimit,
+            prompt: gitConfigParsed.coco?.prompt || config.prompt,
+            mode: gitConfigParsed.coco?.mode || config.mode,
+            temperature: gitConfigParsed.coco?.temperature || config.temperature,
+            summarizePrompt: gitConfigParsed.coco?.summarizePrompt || config.summarizePrompt,
+            ignoredFiles: gitConfigParsed.coco?.ignoredFiles || config.ignoredFiles,
+            ignoredExtensions: gitConfigParsed.coco?.ignoredExtensions || config.ignoredExtensions,
+        };
+    }
+    return config;
+}
+
+/**
+ * Load .gitignore in project root
+ *
+ * @param {Config} config
+ * @returns
+ */
+function loadGitignore(config) {
+    if (fs.existsSync('.gitignore')) {
+        const gitignoreContent = fs.readFileSync('.gitignore', 'utf-8');
+        config.ignoredFiles = [
+            ...(config?.ignoredFiles || []),
+            ...gitignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
+        ];
+    }
+    return config;
+}
+/**
+ * Load .ignore in project root
+ *
+ * @param {Config} config
+ * @returns
+ */
+function loadIgnore(config) {
+    if (fs.existsSync('.ignore')) {
+        const ignoreContent = fs.readFileSync('.ignore', 'utf-8');
+        config.ignoredFiles = [
+            ...(config?.ignoredFiles || []),
+            ...ignoreContent.split('\n').filter((line) => line.trim() !== '' && !line.startsWith('#')),
+        ];
+    }
+    return config;
+}
+
+/**
+ * Load project config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadProjectConfig(config) {
+    if (fs.existsSync('.coco.config.json')) {
+        const projectConfig = JSON.parse(fs.readFileSync('.coco.config.json', 'utf-8'));
+        config = { ...config, ...projectConfig };
+    }
+    return config;
+}
+
+/**
+ * Load XDG config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ */
+function loadXDGConfig(config) {
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    const xdgConfigPath = path.join(xdgConfigHome, 'coco', 'config.json');
+    if (fs.existsSync(xdgConfigPath)) {
+        const xdgConfig = JSON.parse(fs.readFileSync(xdgConfigPath, 'utf-8'));
+        config = { ...config, ...xdgConfig };
+    }
+    return config;
+}
+
+/**
+ * Command line options via yargs
+ */
+const options = {
+    openAIApiKey: { type: 'string', description: 'OpenAI API Key' },
+    tokenLimit: { type: 'number', description: 'Token limit' },
+    prompt: {
+        type: 'string',
+        alias: 'p',
+        description: 'Commit message prompt',
+    },
+    interactive: {
+        type: 'boolean',
+        alias: 'i',
+        description: 'Toggle interactive mode',
+    },
+    commit: {
+        type: 'boolean',
+        alias: 's',
+        description: 'Commit staged changes with generated commit message',
+        default: false,
+    },
+    openInEditor: {
+        type: 'boolean',
+        alias: 'e',
+        description: 'Open commit message in editor before proceeding',
+    },
+    verbose: {
+        type: 'boolean',
+        description: 'Enable verbose logging',
+    },
+    summarizePrompt: {
+        type: 'string',
+        description: 'Large file summary prompt',
+    },
+    ignoredFiles: {
+        type: 'array',
+        description: 'Ignored files',
+    },
+    ignoredExtensions: {
+        type: 'array',
+        description: 'Ignored extensions',
+    },
+};
+/**
+ * Load command line flags via yargs
+ *
+ * @returns {Partial<Config>} Updated config
+ */
+const loadArgv = () => {
+    return yargs(hideBin(process.argv)).options(options).parseSync();
+};
+/**
+ * Load command line flags
+ *
+ * Note: Arugments are parsed using yargs.
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+function loadCmdLineFlags(config) {
+    const argv = loadArgv();
+    config = { ...config, ...argv };
+    return config;
+}
+
+const template$1 = `Write informative git commit message based on the diffs & file changes provided in the "Diff Summary" section.  
+Commit Messages must have a short description that is less than 50 characters followed by a newline character and then a more verbose detailed description.
+- Write concisely using an informal tone
+- List significant changes
+- DO NOT use phrases like "this commit", "this change", etc.
+- DO NOT use specific names or files from the code
+- Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
+
+"""{summary}"""
+
+Commit:`;
+const inputVariables$1 = ['summary'];
+const COMMIT_PROMPT = new PromptTemplate({
+    template: template$1,
+    inputVariables: inputVariables$1,
+});
+
+const template = `GOAL: Use functional abstractions to summarize the following text
+
+RULES: Avoid phrases like  "this change", "this code", or "this function" etc. Instead refer to the function, variable, or class by name.
+
+TEXT:"""{text}"""
+`;
+const inputVariables = ['text'];
+const SUMMARIZE_PROMPT = new PromptTemplate({
+    template,
+    inputVariables,
+});
+
+/**
+ * Default Config
+ *
+ * @type {Config}
+ */
+const DEFAULT_CONFIG = {
+    openAIApiKey: '',
+    verbose: false,
+    tokenLimit: 1024,
+    prompt: COMMIT_PROMPT.template,
+    summarizePrompt: SUMMARIZE_PROMPT.template,
+    temperature: 0.4,
+    mode: 'stdout',
+    ignoredFiles: ['package-lock.json'],
+    ignoredExtensions: ['.map', '.lock'],
+};
+
+/**
+ * Load application config
+ *
+ * Merge config from multiple sources.
+ *
+ * \* Order of precedence:
+ * \* 1. Command line flags
+ * \* 2. Environment variables
+ * \* 3. Project config
+ * \* 4. Git config
+ * \* 5. XDG config
+ * \* 6. .gitignore
+ * \* 7. .ignore
+ * \* 8. Default config
+ *
+ * @returns {Config} application config
+ **/
+function loadConfig() {
+    // Default config
+    let config = DEFAULT_CONFIG;
+    config = loadGitignore(config);
+    config = loadIgnore(config);
+    config = loadXDGConfig(config);
+    config = loadGitConfig(config);
+    config = loadProjectConfig(config);
+    config = loadEnvConfig(config);
+    config = loadCmdLineFlags(config);
+    return config;
+}
+const config = loadConfig();
+
+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;
+    }
+}
+
+/**
+ * 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.encode(directorySummary).text.length;
+        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:${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, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
+    const logger = new Logger(config);
+    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);
+    }
+    getPath() {
+        return this.path.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,
+        });
+    }
+    return root;
+};
+
+/**
+ * Asynchronously collect diffs for a given node and its children.
+ */
+async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(config)) {
+    // 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,
+        };
+    });
+    // Collect diffs for the children of the current node
+    const childrenPromises = Array.from(node.children.values()).map(async (child) => collectDiffs(child, getFileDiff, tokenizer));
+    const [diffs, children] = await Promise.all([
+        Promise.all(diffPromises),
+        Promise.all(childrenPromises),
+    ]);
+    return {
+        path: node.getPath(),
+        diffs,
+        children,
+    };
+}
+
+const readFile = util.promisify(fs.readFile);
+
+const parseDefaultFileDiff = async (nodeFile, repo, headTree, index) => {
+    let result = '';
+    const diff = await Diff.treeToIndex(repo, headTree, index, {
+        flags: 33554432 /* Diff.OPTION.SHOW_UNTRACKED_CONTENT */ | 16 /* Diff.OPTION.RECURSE_UNTRACKED_DIRS */,
+        pathspec: nodeFile.filepath,
+    });
+    const patches = await diff.patches();
+    for (const patch of patches) {
+        const hunks = await patch.hunks();
+        for (const hunk of hunks) {
+            const lines = await hunk.lines();
+            result += lines.map((line) => String.fromCharCode(line.origin()) + line.content()).join('');
+        }
+    }
+    return result;
+};
+const parseRenamedFileDiff = async (nodeFile, repo, headTree, index, logger) => {
+    let result = '';
+    const oldFilepath = nodeFile?.oldFilepath || nodeFile.filepath;
+    try {
+        const headEntry = await headTree.entryByPath(oldFilepath); // use old name to look up in latest commit
+        const indexEntry = index.getByPath(nodeFile.filepath); // use new name to look up in index
+        // Compare the file contents in the latest commit and index
+        const headBlob = await Blob.lookup(repo, headEntry.sha());
+        const indexBlobContent = await readFile(indexEntry.path); // read file from filesystem
+        const headContent = headBlob.content().toString();
+        const indexContent = indexBlobContent.toString();
+        if (headContent !== indexContent) {
+            result = createTwoFilesPatch(oldFilepath, nodeFile.filepath, headContent, indexContent, '', '', { 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;
+};
+const parseFileDiff = async (nodeFile, repo, headTree, index, logger) => {
+    if (nodeFile.status === 'deleted') {
+        return 'This file has been deleted.';
+    }
+    if (nodeFile.status === 'renamed' && nodeFile.oldFilepath) {
+        return parseRenamedFileDiff(nodeFile, repo, headTree, index, logger);
+    }
+    // If not deleted or renamed, get the diff from the index
+    return parseDefaultFileDiff(nodeFile, repo, headTree, index);
+};
+
+// TODO: Extend this to support other models! 🎉
+function getModel(fields, configuration) {
+    return new OpenAI(fields, configuration);
+    // return new HuggingFaceInference({
+    //   // model: 'gpt2',
+    //   // model: 'bigcode/starcoder',
+    //   model: 'bigscience/bloom',
+    //   apiKey: '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',
+    //   maxConcurrency: 4,
+    //   cache: true,
+    //   // maxTokens: 2046,
+    // })
+}
+function getTextSplitter(options = {}) {
+    return new RecursiveCharacterTextSplitter(options);
+}
+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);
+}
+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 MAX_TOKENS_PER_SUMMARY = 2048;
+const fileChangeParser = async (changes, { tokenizer, repo, model }) => {
+    const logger = new Logger(config);
+    const head = await repo.getHeadCommit();
+    const headTree = await head.getTree();
+    const index = await repo.refreshIndex();
+    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) => parseFileDiff(path, repo, headTree, index, 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.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
+    return summary;
+};
+
+const SEPERATOR = chalk.blue('----------------');
+const logCommit = (commit) => {
+    console.log(`\n${chalk.bgBlue(chalk.bold('Proposed Commit:'))}\n${SEPERATOR}\n${commit}\n${SEPERATOR}\n`);
+};
+const logSuccess = () => {
+    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
+};
+
+/**
+ * Wrapper around GPT3NodeTokenizer to handle default export.
+ *
+ * @see https://github.com/botisan-ai/gpt3-tokenizer/issues/18
+ *
+ * @returns {GPT3NodeTokenizer} The GPT3NodeTokenizer instance.
+ */
+const getTokenizer = () => {
+    let tokenizer;
+    // eslint-disable-next-line
+    // @ts-ignore
+    if (GPT3NodeTokenizer.default) {
+        // eslint-disable-next-line
+        // @ts-ignore
+        tokenizer = new GPT3NodeTokenizer.default({ type: 'gpt3' });
+    }
+    else {
+        tokenizer = new GPT3NodeTokenizer({ type: 'gpt3' });
+    }
+    return tokenizer;
+};
+
+const EMPTY_GIT_TREE_HASH = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+
+const getSummaryText = (patch) => {
+    const oldFilePath = patch.oldFile().path();
+    const newFilePath = patch.newFile().path();
+    let summary;
+    if (patch.isAdded()) {
+        summary = `added: ${newFilePath}`;
+    }
+    else if (patch.isDeleted()) {
+        summary = `deleted: ${oldFilePath}`;
+    }
+    else if (patch.isModified()) {
+        summary = `modified: ${newFilePath}`;
+    }
+    else if (patch.isRenamed()) {
+        summary = `renamed: ${oldFilePath} -> ${newFilePath}`;
+    }
+    else if (patch.isUntracked()) {
+        summary = `untracked: ${newFilePath}`;
+    }
+    else {
+        summary = `unknown: ${newFilePath}`;
+    }
+    return summary;
+};
+
+const getStatus = (patch) => {
+    let status;
+    if (patch.isAdded()) {
+        status = 'added';
+    }
+    else if (patch.isDeleted()) {
+        status = 'deleted';
+    }
+    else if (patch.isModified()) {
+        status = 'modified';
+    }
+    else if (patch.isRenamed()) {
+        status = 'renamed';
+    }
+    else if (patch.isUntracked()) {
+        status = 'untracked';
+    }
+    else if (patch.newFile()) {
+        status = 'new file';
+    }
+    else {
+        status = 'unknown';
+    }
+    return status;
+};
+
+const DEFAULT_IGNORED_FILES$1 = [
+    ...(config?.ignoredFiles?.length && config?.ignoredFiles?.length > 0 ? config.ignoredFiles : []),
+];
+const DEFAULT_IGNORED_EXTENSIONS$1 = [
+    ...(config?.ignoredExtensions?.length && config?.ignoredExtensions?.length > 0
+        ? config.ignoredExtensions
+        : []),
+];
+/**
+ * Parse patches from a git diff.
+ *
+ * @param {ConvenientPatch[]} patches - An array of git patches.
+ * @param {string[]} [options.ignoredFiles] - An optional array of file patterns to ignore.
+ *   If not provided, it defaults to the `ignoredFiles` configuration value from the app's config.
+ * @param {string[]} [options.ignoredExtensions] - An optional array of file extensions to ignore.
+ *  If not provided, it defaults to the `ignoredExtensions` configuration value from the app's config.
+ * @returns {Promise<FileChange[]>} A Promise that resolves to an array of file changes.
+ **/
+const parsePatches = async (patches, { ignoredFiles = DEFAULT_IGNORED_FILES$1, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS$1, }) => patches
+    .map((patch) => {
+    const summary = getSummaryText(patch);
+    const status = getStatus(patch);
+    return {
+        filepath: patch.newFile().path(),
+        oldFilepath: status === 'renamed' ? patch.oldFile().path() : undefined,
+        summary,
+        status,
+    };
+})
+    .filter(Boolean)
+    // Filter out ignored files & extensions...
+    .filter(({ filepath }) => {
+    if (!filepath)
+        return false;
+    const extension = filepath.split('.').pop();
+    // Remove ignored extensions
+    if (extension && ignoredExtensions.includes(extension))
+        return false;
+    // Remove ignored files
+    if (ignoredFiles.some((pattern) => minimatch(filepath, pattern)))
+        return false;
+    return true;
+});
+
+const DEFAULT_IGNORED_FILES = [
+    ...(config?.ignoredFiles?.length && config?.ignoredFiles?.length > 0 ? config.ignoredFiles : []),
+];
+const DEFAULT_IGNORED_EXTENSIONS = [
+    ...(config?.ignoredExtensions?.length && config?.ignoredExtensions?.length > 0
+        ? config.ignoredExtensions
+        : []),
+];
+/**
+ * The 'git status' for coco
+ *
+ * Get paths of changed files in the Git repository, excluding ignored files and extensions.
+ *
+ * @param {string[]} [options.ignoredFiles] - An optional array of file patterns to ignore.
+ *    If not provided, it defaults to the `ignoredFiles` configuration value from the app's config.
+ * @param {string[]} [options.ignoredExtensions] - An optional array of file extensions to ignore.
+ *   If not provided, it defaults to the `ignoredExtensions` configuration value from the app's config.
+ * @returns {Promise<GetChangesResult>} A Promise that resolves to an array of changed file paths.
+ *
+ * @example
+ * const changes = await getStagedChanges()
+ * console.log(changes)
+ * // {
+ * //   staged: [
+ * //     {
+ * //       filepath: 'src/index.ts',
+ * //       action: 'modified'
+ * //     },
+ * //   ],
+ * //   unstaged: [
+ * //     {
+ * //       filepath: 'src/index.test.ts',
+ * //       action: 'added'
+ * //     }
+ * //   ]
+ * // }
+ */
+async function getChanges(repo, options = {}) {
+    const { ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS, ignoreUnstaged, ignoreUntracked, } = options;
+    const head = await repo.getHeadCommit();
+    const index = await repo.refreshIndex();
+    const tree = await (head ? await head.getTree() : Tree.lookup(repo, EMPTY_GIT_TREE_HASH));
+    let unstaged = [];
+    let untracked = [];
+    if (!ignoreUnstaged) {
+        const unstagedDiff = await Diff.indexToWorkdir(repo, index, {
+            flags: 16 /* Diff.OPTION.RECURSE_UNTRACKED_DIRS */,
+        });
+        const unstagedPatches = await unstagedDiff.patches();
+        unstaged = await parsePatches(unstagedPatches, { ignoredFiles, ignoredExtensions });
+    }
+    if (!ignoreUntracked) {
+        const untrackedDiff = await Diff.treeToWorkdirWithIndex(repo, tree, {
+            flags: 33554432 /* Diff.OPTION.SHOW_UNTRACKED_CONTENT */,
+        });
+        const untrackedPatches = await untrackedDiff.patches();
+        untracked = (await parsePatches(untrackedPatches, { ignoredFiles, ignoredExtensions })).filter(({ status }) => status === 'untracked');
+    }
+    const diff = await Diff.treeToIndex(repo, tree, index);
+    await diff.findSimilar({
+        flags: 1 /* Diff.FIND.RENAMES */,
+    });
+    const patches = await diff.patches();
+    return {
+        staged: await parsePatches(patches, { ignoredFiles, ignoredExtensions }),
+        unstaged,
+        untracked,
+    };
+}
+
+async function createCommit(commitMsg, repo) {
+    const author = await nodegit.Signature.default(repo);
+    const index = await repo.refreshIndex();
+    await index.addAll();
+    await index.write();
+    const oid = await index.writeTree();
+    const head = await nodegit.Reference.nameToId(repo, "HEAD");
+    const parent = await repo.getCommit(head);
+    return await repo.createCommit("HEAD", author, author, commitMsg, oid, [parent]);
+}
+
+const llm = async ({ llm, prompt, variables }) => {
+    const chain = new LLMChain({ llm, prompt });
+    const res = await chain.call(variables);
+    if (res.error)
+        throw new Error(res.error);
+    return res.text.trim();
+};
+
+const noResult = async ({ repo, logger }) => {
+    const { staged, unstaged, untracked } = await getChanges(repo, {
+        ignoreUnstaged: false,
+        ignoreUntracked: false,
+    });
+    if (staged.length > 0) {
+        logger.log(`Staged files detected, but no summary generated...`, { color: 'red' });
+        logger.log(`Files are likely either:\n  • changed files are ignored\n  • file diff is too large.`, { color: 'yellow' });
+    }
+    else if (unstaged && unstaged.length > 0) {
+        logger.log('No staged files detected, but unstaged files detected.', { color: 'yellow' });
+        logger.verbose(`\n Unstaged Changes: \n ${unstaged.map(({ summary }) => summary).join('\n ')}`, {
+            color: 'yellow',
+        });
+    }
+    else if (untracked && untracked.length > 0) {
+        logger.log('No staged files detected, but untracked files detected.', { color: 'yellow' });
+        logger.verbose(`\n Untracked Changes: \n ${untracked.map(({ summary }) => summary).join('\n ')}`, {
+            color: 'yellow',
+        });
+    }
+    else {
+        logger.log('No repo changes detected.', { color: 'yellow' });
+    }
+    process.exit(0);
+};
+
+const argv = loadArgv();
+const tokenizer = getTokenizer();
+async function main(options) {
+    const logger = new Logger(config);
+    if (!config.openAIApiKey) {
+        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
+        process.exit(1);
+    }
+    const repo = await Repository.open('.');
+    const model = getModel({
+        temperature: 0.4,
+        maxConcurrency: 10,
+        openAIApiKey: config.openAIApiKey,
+    });
+    const INTERACTIVE = config?.mode === 'interactive' || options.interactive;
+    const { staged: changes } = await getChanges(repo, {
+        ignoreUnstaged: true,
+        ignoreUntracked: true,
+    });
+    let summary = '';
+    let commitMsg = '';
+    let promptTemplate = config?.prompt || '';
+    let modifyPrompt = false;
+    while (true) {
+        if (changes.length !== 0 && !summary.length) {
+            logger.verbose(`\nChanged Files: \n ${changes.map(({ summary }) => summary).join('\n ')}`, {
+                color: 'blue',
+            });
+            summary = await fileChangeParser(changes, { tokenizer, repo, model });
+        }
+        // Handle empty summary
+        if (!summary.length) {
+            noResult({ repo, logger });
+        }
+        // Prompt user for commit template prompt, if necessary
+        if (modifyPrompt) {
+            promptTemplate = await editor({
+                message: 'Edit the prompt',
+                default: promptTemplate.length ? promptTemplate : COMMIT_PROMPT.template,
+                waitForUseInput: false,
+                validate: (text) => validatePromptTemplate(text, COMMIT_PROMPT.inputVariables),
+            });
+        }
+        logger.startTimer().startSpinner(`Generating Commit Message\n`, {
+            color: 'blue',
+        });
+        commitMsg = await llm({
+            llm: model,
+            prompt: getPrompt({
+                template: promptTemplate,
+                variables: COMMIT_PROMPT.inputVariables,
+                fallback: COMMIT_PROMPT,
+            }),
+            variables: { summary },
+        });
+        if (!commitMsg) {
+            logger.stopSpinner('💀 Failed to generate commit message.', {
+                mode: 'fail',
+                color: 'red',
+            });
+            process.exit(0);
+        }
+        logger
+            .stopSpinner('Generated Commit Message', {
+            color: 'green',
+            mode: 'succeed',
+        })
+            .stopTimer();
+        if (INTERACTIVE) {
+            logCommit(commitMsg);
+            const reviewAnswer = await select({
+                message: 'Would you like to make any changes to the commit message?',
+                choices: [
+                    {
+                        name: '✨ Looks good!',
+                        value: 'approve',
+                        description: 'Commit staged changes with generated commit message',
+                    },
+                    {
+                        name: '📝 Edit',
+                        value: 'edit',
+                        description: 'Edit the commit message before proceeding',
+                    },
+                    {
+                        name: '🪶  Modify Prompt',
+                        value: 'modifyPrompt',
+                        description: 'Modify the prompt template and regenerate the commit message',
+                    },
+                    {
+                        name: '🔄 Retry - Message Only',
+                        value: 'retryMessageOnly',
+                        description: 'Restart the function execution from generating the commit message',
+                    },
+                    {
+                        name: '🔄 Retry - Full',
+                        value: 'retryFull',
+                        description: 'Restart the function execution from the beginning, regenerating both the diff summary and commit message',
+                    },
+                    {
+                        name: '💣 Cancel',
+                        value: 'cancel',
+                    },
+                ],
+            });
+            if (reviewAnswer === 'cancel') {
+                process.exit(0);
+            }
+            if (reviewAnswer === 'edit') {
+                config.openInEditor = true;
+            }
+            if (reviewAnswer === 'retryFull') {
+                summary = '';
+                commitMsg = '';
+                promptTemplate = '';
+                continue;
+            }
+            if (reviewAnswer === 'retryMessageOnly') {
+                modifyPrompt = false;
+                commitMsg = '';
+                continue;
+            }
+            if (reviewAnswer === 'modifyPrompt') {
+                modifyPrompt = true;
+                commitMsg = '';
+                continue;
+            }
+        }
+        if (config.openInEditor) {
+            commitMsg = await editor({
+                message: 'Edit the commit message',
+                default: commitMsg,
+                waitForUseInput: false,
+                validate: (text) => {
+                    if (!text) {
+                        return 'Commit message cannot be empty';
+                    }
+                    return true;
+                },
+            });
+        }
+        const MODE = (options.interactive && 'interactive') ||
+            (options.commit && 'interactive') ||
+            config?.mode ||
+            'stdout';
+        // Handle resulting commit message
+        switch (MODE) {
+            case 'interactive':
+                await createCommit(commitMsg, repo);
+                logSuccess();
+                break;
+            case 'stdout':
+            default:
+                process.stdout.write(commitMsg, 'utf8');
+                break;
+        }
+        process.exit(0);
+    }
+}
+main(argv).catch(console.error);
+//# sourceMappingURL=index.esm.mjs.map