git-coco 0.1.1 → 0.2.1

package/README.md

@@ -1,6 +1,14 @@
-# `coco` 🤖🦍
+# `coco` 🤖 🦍
+
+[![GitHub issues](https://img.shields.io/github/issues/gfargo/coco)](https://github.com/gfargo/coco/issues)
+[![GitHub pull requests](https://img.shields.io/github/issues-pr/gfargo/coco)](https://github.com/gfargo/coco/pulls)
+[![Last Commit](https://img.shields.io/github/last-commit/gfargo/coco)](https://github.com/gfargo/coco/tree/main)
+[![NPM Version](https://img.shields.io/npm/v/git-coco.svg)](https://www.npmjs.com/package/git-coco)
+[![NPM Downloads](https://img.shields.io/npm/dt/git-coco.svg)](https://www.npmjs.com/package/git-coco)
+
+Commit Copilot, or `coco`, is your personal scribe for git commit messages. Leveraging the power of [LangChain🦜🔗](https://js.langchain.com/) and LLMs to encapsulate your staged changes into meaningful commit messages!
+
 
-Commit Copilot, or `coco`, is your personal scribe for git commit messages. Using [LangChain🦜🔗](https://js.langchain.com/) to automate the task of creating meaningful commit messages based on your staged changes!
 
 ## Installation
 

package/dist/index.esm.mjs

@@ -1,10 +1,9 @@
 #!/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 path__default from 'path';
 import * as ini from 'ini';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -15,13 +14,13 @@ 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 { createTwoFilesPatch } from 'diff';
 import GPT3NodeTokenizer from 'gpt3-tokenizer';
 import { minimatch } from 'minimatch';
+import { simpleGit } from 'simple-git';
 
 /**
  * Returns a new object with all undefined keys removed
@@ -419,7 +418,7 @@ 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`;
+        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`;
@@ -543,61 +542,6 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(co
     };
 }
 
-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);
@@ -638,12 +582,50 @@ function validatePromptTemplate(text, inputVariables) {
     return true;
 }
 
+const parseDefaultFileDiff = async (nodeFile, git) => {
+    return await git.diff(['--staged', nodeFile.filepath]);
+};
+const parseRenamedFileDiff = async (nodeFile, git, logger) => {
+    let result = '';
+    const oldFilepath = nodeFile?.oldFilepath || nodeFile.filepath;
+    try {
+        const [headContent, indexContent] = await Promise.all([
+            git.show([`HEAD:${oldFilepath}`]),
+            git.show([`:${nodeFile.filepath}`]),
+        ]);
+        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 getDiff = async (nodeFile, { git, logger, }) => {
+    if (nodeFile.status === 'deleted') {
+        return 'This file has been deleted.';
+    }
+    if (nodeFile.status === 'renamed' && nodeFile.oldFilepath) {
+        const renamedDiff = await parseRenamedFileDiff(nodeFile, git, logger);
+        return renamedDiff;
+    }
+    // If not deleted or renamed, get the diff from the index
+    const defaultDiff = await parseDefaultFileDiff(nodeFile, git);
+    return defaultDiff;
+};
+
 const MAX_TOKENS_PER_SUMMARY = 2048;
-const fileChangeParser = async (changes, { tokenizer, repo, model }) => {
+const fileChangeParser = async (changes, { tokenizer, git, 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',
@@ -655,7 +637,7 @@ const fileChangeParser = async (changes, { tokenizer, repo, model }) => {
     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);
+    const diffs = await collectDiffs(rootTreeNode, (path) => getDiff(path, { git, logger }), tokenizer, logger);
     logger.stopSpinner('Diffs Collected').stopTimer();
     // Summarize diffs
     logger.startTimer();
@@ -699,197 +681,102 @@ const getTokenizer = () => {
     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 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 getStatus = (patch) => {
+const getStatus = (file, location = 'index') => {
+    const statusCode = file[location] ? file[location] : file.index;
     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';
+    switch (statusCode) {
+        case 'A':
+            status = 'added';
+            break;
+        case 'D':
+            status = 'deleted';
+            break;
+        case 'M':
+            status = 'modified';
+            break;
+        case 'R':
+            status = 'renamed';
+            break;
+        case '?':
+            status = 'untracked';
+            break;
+        default:
+            status = 'unknown';
+            break;
     }
     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 getSummaryText = (file, change) => {
+    const status = change.status || getStatus(file);
+    if (change.oldFilepath) {
+        return `${status}: ${change.oldFilepath} -> ${file.path}`;
     }
-    const diff = await Diff.treeToIndex(repo, tree, index);
-    await diff.findSimilar({
-        flags: 1 /* Diff.FIND.RENAMES */,
+    return `${status}: ${file.path}`;
+};
+
+const DEFAULT_IGNORED_FILES = config?.ignoredFiles?.length ? config.ignoredFiles : [];
+const DEFAULT_IGNORED_EXTENSIONS = config?.ignoredExtensions?.length ? config.ignoredExtensions : [];
+async function getChanges(git, options = {}) {
+    const { ignoredFiles = DEFAULT_IGNORED_FILES, ignoredExtensions = DEFAULT_IGNORED_EXTENSIONS } = options;
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    const status = await git.status();
+    status.files.forEach((file) => {
+        const fileChange = {
+            filepath: file.path,
+            oldFilepath: status.renamed.filter((renamed) => renamed.to === file.path)[0]?.from,
+        };
+        // Unstaged files
+        if (file.working_dir !== '?' && file.working_dir !== ' ') {
+            fileChange.status = getStatus(file, 'working_dir');
+            fileChange.summary = getSummaryText(file, fileChange);
+            unstaged.push(fileChange);
+        }
+        // Staged files
+        if (file.index !== ' ' && file.index !== '?') {
+            fileChange.status = getStatus(file);
+            fileChange.summary = getSummaryText(file, fileChange);
+            staged.push(fileChange);
+        }
+        // Untracked files
+        if (file.working_dir === '?' && file.index === '?') {
+            fileChange.status = 'added';
+            fileChange.summary = getSummaryText(file, fileChange);
+            untracked.push(fileChange);
+        }
+    });
+    const ignoredExtensionsSet = new Set(ignoredExtensions.map((extension) => extension.toLowerCase()));
+    const filteredStaged = staged.filter((file) => {
+        const extension = path__default.extname(file.filepath).toLowerCase();
+        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch(file.filepath, ignoredPattern));
+    });
+    const filteredUnstaged = unstaged.filter((file) => {
+        const extension = path__default.extname(file.filepath).toLowerCase();
+        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch(file.filepath, ignoredPattern));
+    });
+    const filteredUntracked = untracked.filter((file) => {
+        const extension = path__default.extname(file.filepath).toLowerCase();
+        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.some(ignoredPattern => minimatch(file.filepath, ignoredPattern));
     });
-    const patches = await diff.patches();
     return {
-        staged: await parsePatches(patches, { ignoredFiles, ignoredExtensions }),
-        unstaged,
-        untracked,
+        staged: filteredStaged,
+        unstaged: filteredUnstaged,
+        untracked: filteredUntracked,
     };
 }
 
-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,
-    });
+const noResult = async ({ git, logger }) => {
+    const { staged, unstaged, untracked } = await getChanges(git);
     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' });
@@ -912,25 +799,26 @@ const noResult = async ({ repo, logger }) => {
     process.exit(0);
 };
 
+async function createCommit(commitMsg, git) {
+    return await git.commit(commitMsg);
+}
+
 const argv = loadArgv();
 const tokenizer = getTokenizer();
+const git = simpleGit();
 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,
-    });
+    const { staged: changes } = await getChanges(git);
     let summary = '';
     let commitMsg = '';
     let promptTemplate = config?.prompt || '';
@@ -940,11 +828,11 @@ async function main(options) {
             logger.verbose(`\nChanged Files: \n ${changes.map(({ summary }) => summary).join('\n ')}`, {
                 color: 'blue',
             });
-            summary = await fileChangeParser(changes, { tokenizer, repo, model });
+            summary = await fileChangeParser(changes, { tokenizer, git, model });
         }
         // Handle empty summary
         if (!summary.length) {
-            noResult({ repo, logger });
+            noResult({ git, logger });
         }
         // Prompt user for commit template prompt, if necessary
         if (modifyPrompt) {
@@ -1059,7 +947,7 @@ async function main(options) {
         // Handle resulting commit message
         switch (MODE) {
             case 'interactive':
-                await createCommit(commitMsg, repo);
+                await createCommit(commitMsg, git);
                 logSuccess();
                 break;
             case 'stdout':