git-coco 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 'use strict';
 
-var nodegit = require('nodegit');
 var prompts$1 = require('@inquirer/prompts');
 var fs = require('fs');
 var os = require('os');
@@ -10,19 +9,18 @@ var ini = require('ini');
 var yargs = require('yargs');
 var helpers = require('yargs/helpers');
 var prompts = require('langchain/prompts');
-var PQueue = require('p-queue');
+var pQueue = require('p-queue');
 var chalk = require('chalk');
 var ora = require('ora');
 var now = require('performance-now');
 var prettyMilliseconds = require('pretty-ms');
 var document = require('langchain/document');
-var diff = require('diff');
-var util = require('util');
 var chains = require('langchain/chains');
 var openai = require('langchain/llms/openai');
 var text_splitter = require('langchain/text_splitter');
+var diff = require('diff');
 var GPT3NodeTokenizer = require('gpt3-tokenizer');
-var minimatch = require('minimatch');
+var simpleGit = require('simple-git');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -41,12 +39,10 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
-var nodegit__namespace = /*#__PURE__*/_interopNamespaceDefault(nodegit);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 var ini__namespace = /*#__PURE__*/_interopNamespaceDefault(ini);
-var util__namespace = /*#__PURE__*/_interopNamespaceDefault(util);
 
 /**
  * Returns a new object with all undefined keys removed
@@ -444,7 +440,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`;
@@ -453,7 +449,7 @@ const defaultOutputCallback = (group) => {
 };
 async function summarizeDiffs(rootDiffNode, { tokenizer, maxTokens = 2048, textSplitter, chain, handleOutput = defaultOutputCallback, }) {
     const logger = new Logger(config);
-    const queue = new PQueue({ concurrency: 8 });
+    const queue = new pQueue({ concurrency: 8 });
     logger.startTimer().startSpinner(`Organizing Diffs...`, { color: 'blue' });
     const directoryDiffs = createDirectoryDiffs(rootDiffNode);
     // Sort by token count descending
@@ -568,61 +564,6 @@ async function collectDiffs(node, getFileDiff, tokenizer, logger = new Logger(co
     };
 }
 
-const readFile = util__namespace.promisify(fs__namespace.readFile);
-
-const parseDefaultFileDiff = async (nodeFile, repo, headTree, index) => {
-    let result = '';
-    const diff = await nodegit.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 nodegit.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 = diff.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.OpenAI(fields, configuration);
@@ -663,12 +604,54 @@ 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.diff(['HEAD', '-M', '--', oldFilepath]),
+            // git.diff(['-z', '-M', '--staged', nodeFile.filepath]),
+            git.show([`HEAD:${oldFilepath}`]),
+            git.show([`:${nodeFile.filepath}`]),
+            // readFile(nodeFile.filepath),
+        ]);
+        if (headContent !== indexContent) {
+            result = diff.createTwoFilesPatch(oldFilepath, nodeFile.filepath, headContent, indexContent.toString(), '', '', {
+                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' });
+        console.log(err);
+        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',
@@ -680,7 +663,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();
@@ -691,6 +674,7 @@ const fileChangeParser = async (changes, { tokenizer, repo, model }) => {
         chain: summarizationChain,
     });
     logger.stopTimer(`\nSummary generated for ${changes.length} staged files`, { color: 'green' });
+    logger.verbose(`\nSummary:\n${summary}`, { color: 'blue' });
     return summary;
 };
 
@@ -724,102 +708,47 @@ 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 chains.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.minimatch(filepath, pattern)))
-        return false;
-    return true;
-});
+const getSummaryText = (file, change) => {
+    const status = change.status || getStatus(file);
+    if (change.oldFilepath) {
+        return `${status}: ${change.oldFilepath} -> ${file.path}`;
+    }
+    return `${status}: ${file.path}`;
+};
 
 const DEFAULT_IGNORED_FILES = [
     ...(config?.ignoredFiles?.length && config?.ignoredFiles?.length > 0 ? config.ignoredFiles : []),
@@ -829,92 +758,55 @@ const DEFAULT_IGNORED_EXTENSIONS = [
         ? 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() : nodegit.Tree.lookup(repo, EMPTY_GIT_TREE_HASH));
-    let unstaged = [];
-    let untracked = [];
-    if (!ignoreUnstaged) {
-        const unstagedDiff = await nodegit.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 nodegit.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 nodegit.Diff.treeToIndex(repo, tree, index);
-    await diff.findSimilar({
-        flags: 1 /* Diff.FIND.RENAMES */,
+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) => {
+        // console.log({ 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.extname(file.filepath).toLowerCase();
+        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.includes(file.filepath);
+    });
+    const filteredUnstaged = unstaged.filter((file) => {
+        const extension = path.extname(file.filepath).toLowerCase();
+        return !ignoredExtensionsSet.has(extension) && !ignoredFiles.includes(file.filepath);
     });
-    const patches = await diff.patches();
     return {
-        staged: await parsePatches(patches, { ignoredFiles, ignoredExtensions }),
-        unstaged,
+        staged: filteredStaged,
+        unstaged: filteredUnstaged,
         untracked,
     };
 }
 
-async function createCommit(commitMsg, repo) {
-    const author = await nodegit__namespace.Signature.default(repo);
-    const index = await repo.refreshIndex();
-    await index.addAll();
-    await index.write();
-    const oid = await index.writeTree();
-    const head = await nodegit__namespace.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 chains.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' });
@@ -937,25 +829,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.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 nodegit.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 || '';
@@ -965,11 +858,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) {
@@ -1084,7 +977,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':

package/dist/lib/parsers/noResult.d.ts

@@ -1,8 +1,6 @@
-import { Repository } from 'nodegit';
 import { Logger } from '../utils/logger';
-type NoResultInput = {
-    repo: Repository;
+import { SimpleGit } from 'simple-git';
+export declare const noResult: ({ git, logger }: {
+    git: SimpleGit;
     logger: Logger;
-};
-export declare const noResult: ({ repo, logger }: NoResultInput) => Promise<never>;
-export {};
+}) => Promise<never>;

package/dist/lib/simple-git/createCommit.d.ts

@@ -0,0 +1,2 @@
+import { CommitResult, SimpleGit } from 'simple-git';
+export declare function createCommit(commitMsg: string, git: SimpleGit): Promise<CommitResult>;

package/dist/lib/simple-git/getChanges.d.ts

@@ -0,0 +1,12 @@
+import { SimpleGit } from 'simple-git';
+import { FileChange } from '../types';
+export type GetChangesArgs = {
+    ignoredFiles?: string[];
+    ignoredExtensions?: string[];
+};
+export type GetChangesResult = {
+    staged: FileChange[];
+    unstaged?: FileChange[];
+    untracked?: FileChange[];
+};
+export declare function getChanges(git: SimpleGit, options?: GetChangesArgs): Promise<GetChangesResult>;

package/dist/lib/simple-git/getDiff.d.ts

@@ -0,0 +1,7 @@
+import { SimpleGit } from 'simple-git';
+import { FileChange } from '../types';
+import { Logger } from '../utils/logger';
+export declare const getDiff: (nodeFile: FileChange, { git, logger, }: {
+    git: SimpleGit;
+    logger: Logger;
+}) => Promise<string>;

package/dist/lib/simple-git/getStatus.d.ts

@@ -0,0 +1,3 @@
+import { FileChangeStatus } from '../types';
+import { FileStatusResult } from 'simple-git';
+export declare const getStatus: (file: FileStatusResult, location?: 'index' | 'working_dir') => FileChangeStatus;

package/dist/lib/simple-git/getSummaryText.d.ts

@@ -0,0 +1,3 @@
+import { FileStatusResult } from 'simple-git';
+import { FileChange } from '../types';
+export declare const getSummaryText: (file: FileStatusResult, change: Partial<FileChange>) => string;

package/dist/lib/types.d.ts

@@ -1,7 +1,7 @@
 import GPT3Tokenizer from 'gpt3-tokenizer';
-import { Repository } from 'nodegit';
 import { getModel } from './langchain/utils';
-export type FileChangeStatus = 'modified' | 'renamed' | 'added' | 'new file' | 'deleted' | 'untracked' | 'unknown';
+import { SimpleGit } from 'simple-git';
+export type FileChangeStatus = 'modified' | 'renamed' | 'added' | 'deleted' | 'untracked' | 'unknown';
 export interface FileChange {
     summary: string;
     filepath: string;
@@ -29,6 +29,6 @@ export interface BaseParser {
     (changes: FileChange[], options: {
         tokenizer: GPT3Tokenizer;
         model: ReturnType<typeof getModel>;
-        repo: Repository;
+        git: SimpleGit;
     }): Promise<string>;
 }