/*---------------------------------------------------------------------------------------------

* Copyright (c) Microsoft Corporation. All rights reserved.

* Licensed under the MIT License. See License.txt in the project root for license information.

*--------------------------------------------------------------------------------------------*/

import * as fs from 'fs';

import * as path from 'path';

import * as os from 'os';

import * as cp from 'child_process';

import * as which from 'which';

import { EventEmitter } from 'events';

import iconv = require('iconv-lite');

import * as filetype from 'file-type';

import { assign, groupBy, denodeify, IDisposable, toDisposable, dispose, mkdirp, readBytes, detectUnicodeEncoding, Encoding, onceEvent, splitInChunks, Limiter } from './util';

import { CancellationToken } from 'vscode';

import { URI } from 'vscode-uri';

import { detectEncoding } from './encoding';

import { Ref, RefType, Branch, Remote, GitErrorCodes, LogOptions, Change, Status } from './api/git';

// https://github.com/microsoft/vscode/issues/65693

const MAX_CLI_LENGTH = 30000;

const readfile = denodeify<string, string | null, string>(fs.readFile);

export interface IGit {

path: string;

version: string;

}

export interface IFileStatus {

x: string;

y: string;

path: string;

rename?: string;

}

export interface Stash {

index: number;

description: string;

}

interface MutableRemote extends Remote {

fetchUrl?: string;

pushUrl?: string;

isReadOnly: boolean;

}

function parseVersion(raw: string): string {

return raw.replace(/^git version /, '');

}

function findSpecificGit(path: string, onLookup: (path: string) => void): Promise<IGit> {

return new Promise<IGit>((c, e) => {

onLookup(path);

const buffers: Buffer[] = [];

const child = cp.spawn(path, ['--version']);

child.stdout.on('data', (b: Buffer) => buffers.push(b));

child.on('error', cpErrorHandler(e));

child.on('exit', code => code ? e(new Error('Not found')) : c({ path, version: parseVersion(Buffer.concat(buffers).toString('utf8').trim()) }));

});

}

function findGitDarwin(onLookup: (path: string) => void): Promise<IGit> {

return new Promise<IGit>((c, e) => {

cp.exec('which git', (err, gitPathBuffer) => {

if (err) {

return e('git not found');

}

const path = gitPathBuffer.toString().replace(/^\s+|\s+$/g, '');

function getVersion(path: string) {

onLookup(path);

// make sure git executes

cp.exec('git --version', (err, stdout) => {

if (err) {

return e('git not found');

}

return c({ path, version: parseVersion(stdout.trim()) });

});

}

if (path !== '/usr/bin/git') {

return getVersion(path);

}

// must check if XCode is installed

cp.exec('xcode-select -p', (err: any) => {

if (err && err.code === 2) {

// git is not installed, and launching /usr/bin/git

// will prompt the user to install it

return e('git not found');

}

getVersion(path);

});

});

});

}

function findSystemGitWin32(base: string, onLookup: (path: string) => void): Promise<IGit> {

if (!base) {

return Promise.reject<IGit>('Not found');

}

return findSpecificGit(path.join(base, 'Git', 'cmd', 'git.exe'), onLookup);

}

function findGitWin32InPath(onLookup: (path: string) => void): Promise<IGit> {

const whichPromise = new Promise<string>((c, e) => which('git.exe', (err, path) => err ? e(err) : c(path)));

return whichPromise.then(path => findSpecificGit(path, onLookup));

}

function findGitWin32(onLookup: (path: string) => void): Promise<IGit> {

return findSystemGitWin32(process.env['ProgramW6432'] as string, onLookup)

.then(undefined, () => findSystemGitWin32(process.env['ProgramFiles(x86)'] as string, onLookup))

.then(undefined, () => findSystemGitWin32(process.env['ProgramFiles'] as string, onLookup))

.then(undefined, () => findSystemGitWin32(path.join(process.env['LocalAppData'] as string, 'Programs'), onLookup))

.then(undefined, () => findGitWin32InPath(onLookup));

}

export function findGit(hint: string | undefined, onLookup: (path: string) => void): Promise<IGit> {

const first = hint ? findSpecificGit(hint, onLookup) : Promise.reject<IGit>(null);

return first

.then(undefined, () => {

switch (process.platform) {

case 'darwin': return findGitDarwin(onLookup);

case 'win32': return findGitWin32(onLookup);

default: return findSpecificGit('git', onLookup);

}

})

.then(null, () => Promise.reject(new Error('Git installation not found.')));

}

export interface IExecutionResult<T extends string | Buffer> {

exitCode: number;

stdout: T;

stderr: string;

}

function cpErrorHandler(cb: (reason?: any) => void): (reason?: any) => void {

return err => {

if (/ENOENT/.test(err.message)) {

err = new GitError({

error: err,

message: 'Failed to execute git (ENOENT)',

gitErrorCode: GitErrorCodes.NotAGitRepository

});

}

cb(err);

};

}

export interface SpawnOptions extends cp.SpawnOptions {

input?: string;

encoding?: string;

log?: boolean;

cancellationToken?: CancellationToken;

}

async function exec(child: cp.ChildProcess, cancellationToken?: CancellationToken): Promise<IExecutionResult<Buffer>> {

if (!child.stdout || !child.stderr) {

throw new GitError({ message: 'Failed to get stdout or stderr from git process.' });

}

if (cancellationToken && cancellationToken.isCancellationRequested) {

throw new GitError({ message: 'Cancelled' });

}

const disposables: IDisposable[] = [];

const once = (ee: NodeJS.EventEmitter, name: string, fn: (...args: any[]) => void) => {

ee.once(name, fn);

disposables.push(toDisposable(() => ee.removeListener(name, fn)));

};

const on = (ee: NodeJS.EventEmitter, name: string, fn: (...args: any[]) => void) => {

ee.on(name, fn);

disposables.push(toDisposable(() => ee.removeListener(name, fn)));

};

let result = Promise.all<any>([

new Promise<number>((c, e) => {

once(child, 'error', cpErrorHandler(e));

once(child, 'exit', c);

}),

new Promise<Buffer>(c => {

const buffers: Buffer[] = [];

on(child.stdout, 'data', (b: Buffer) => buffers.push(b));

once(child.stdout, 'close', () => c(Buffer.concat(buffers)));

}),

new Promise<string>(c => {

const buffers: Buffer[] = [];

on(child.stderr, 'data', (b: Buffer) => buffers.push(b));

once(child.stderr, 'close', () => c(Buffer.concat(buffers).toString('utf8')));

})

]) as Promise<[number, Buffer, string]>;

if (cancellationToken) {

const cancellationPromise = new Promise<[number, Buffer, string]>((_, e) => {

onceEvent(cancellationToken.onCancellationRequested)(() => {

try {

child.kill();

} catch (err) {

// noop

}

e(new GitError({ message: 'Cancelled' }));

});

});

result = Promise.race([result, cancellationPromise]);

}

try {

const [exitCode, stdout, stderr] = await result;

return { exitCode, stdout, stderr };

} finally {

dispose(disposables);

}

}

export interface IGitErrorData {

error?: Error;

message?: string;

stdout?: string;

stderr?: string;

exitCode?: number;

gitErrorCode?: string;

gitCommand?: string;

}

export class GitError {

error?: Error;

message: string;

stdout?: string;

stderr?: string;

exitCode?: number;

gitErrorCode?: string;

gitCommand?: string;

constructor(data: IGitErrorData) {

if (data.error) {

this.error = data.error;

this.message = data.error.message;

} else {

this.error = undefined;

this.message = '';

}

this.message = this.message || data.message || 'Git error';

this.stdout = data.stdout;

this.stderr = data.stderr;

this.exitCode = data.exitCode;

this.gitErrorCode = data.gitErrorCode;

this.gitCommand = data.gitCommand;

}

toString(): string {

let result = this.message + ' ' + JSON.stringify({

exitCode: this.exitCode,

gitErrorCode: this.gitErrorCode,

gitCommand: this.gitCommand,

stdout: this.stdout,

stderr: this.stderr

}, null, 2);

if (this.error) {

result += (<any>this.error).stack;

}

return result;

}

}

export interface IGitOptions {

gitPath: string;

version: string;

env?: any;

}

function getGitErrorCode(stderr: string): string | undefined {

if (/Another git process seems to be running in this repository|If no other git process is currently running/.test(stderr)) {

return GitErrorCodes.RepositoryIsLocked;

} else if (/Authentication failed/.test(stderr)) {

return GitErrorCodes.AuthenticationFailed;

} else if (/Not a git repository/i.test(stderr)) {

return GitErrorCodes.NotAGitRepository;

} else if (/bad config file/.test(stderr)) {

return GitErrorCodes.BadConfigFile;

} else if (/cannot make pipe for command substitution|cannot create standard input pipe/.test(stderr)) {

return GitErrorCodes.CantCreatePipe;

} else if (/Repository not found/.test(stderr)) {

return GitErrorCodes.RepositoryNotFound;

} else if (/unable to access/.test(stderr)) {

return GitErrorCodes.CantAccessRemote;

} else if (/branch '.+' is not fully merged/.test(stderr)) {

return GitErrorCodes.BranchNotFullyMerged;

} else if (/Couldn\'t find remote ref/.test(stderr)) {

return GitErrorCodes.NoRemoteReference;

} else if (/A branch named '.+' already exists/.test(stderr)) {

return GitErrorCodes.BranchAlreadyExists;

} else if (/'.+' is not a valid branch name/.test(stderr)) {

return GitErrorCodes.InvalidBranchName;

} else if (/Please,? commit your changes or stash them/.test(stderr)) {

return GitErrorCodes.DirtyWorkTree;

}

return undefined;

}

const COMMIT_FORMAT = '%H\n%ae\n%P\n%B';

export class Git {

readonly path: string;

private env: any;

private _onOutput = new EventEmitter();

get onOutput(): EventEmitter { return this._onOutput; }

constructor(options: IGitOptions) {

this.path = options.gitPath;

this.env = options.env || {};

}

open(repository: string, dotGit: string): Repository {

return new Repository(this, repository, dotGit);

}

async init(repository: string): Promise<void> {

await this.exec(repository, ['init']);

return;

}

async clone(url: string, parentPath: string, cancellationToken?: CancellationToken): Promise<string> {

let baseFolderName = decodeURI(url).replace(/[\/]+$/, '').replace(/^.*[\/\\]/, '').replace(/\.git$/, '') || 'repository';

let folderName = baseFolderName;

let folderPath = path.join(parentPath, folderName);

let count = 1;

while (count < 20 && await new Promise(c => fs.exists(folderPath, c))) {

folderName = `${baseFolderName}-${count++}`;

folderPath = path.join(parentPath, folderName);

}

await mkdirp(parentPath);

try {

await this.exec(parentPath, ['clone', url.includes(' ') ? encodeURI(url) : url, folderPath], { cancellationToken });

} catch (err) {

if (err.stderr) {

err.stderr = err.stderr.replace(/^Cloning.+$/m, '').trim();

err.stderr = err.stderr.replace(/^ERROR:\s+/, '').trim();

}

throw err;

}

return folderPath;

}

async getRepositoryRoot(repositoryPath: string): Promise<string> {

const result = await this.exec(repositoryPath, ['rev-parse', '--show-toplevel']);

return path.normalize(result.stdout.trim());

}

async getRepositoryDotGit(repositoryPath: string): Promise<string> {

const result = await this.exec(repositoryPath, ['rev-parse', '--git-dir']);

let dotGitPath = result.stdout.trim();

if (!path.isAbsolute(dotGitPath)) {

dotGitPath = path.join(repositoryPath, dotGitPath);

}

return path.normalize(dotGitPath);

}

async exec(cwd: string, args: string[], options: SpawnOptions = {}): Promise<IExecutionResult<string>> {

options = assign({ cwd }, options || {});

return await this._exec(args, options);

}

async exec2(args: string[], options: SpawnOptions = {}): Promise<IExecutionResult<string>> {

return await this._exec(args, options);

}

stream(cwd: string, args: string[], options: SpawnOptions = {}): cp.ChildProcess {

options = assign({ cwd }, options || {});

return this.spawn(args, options);

}

private async _exec(args: string[], options: SpawnOptions = {}): Promise<IExecutionResult<string>> {

const child = this.spawn(args, options);

if (options.input) {

child.stdin.end(options.input, 'utf8');

}

const bufferResult = await exec(child, options.cancellationToken);

if (options.log !== false && bufferResult.stderr.length > 0) {

this.log(`${bufferResult.stderr}\n`);

}

let encoding = options.encoding || 'utf8';

encoding = iconv.encodingExists(encoding) ? encoding : 'utf8';

const result: IExecutionResult<string> = {

exitCode: bufferResult.exitCode,

stdout: iconv.decode(bufferResult.stdout, encoding),

stderr: bufferResult.stderr

};

if (bufferResult.exitCode) {

return Promise.reject<IExecutionResult<string>>(new GitError({

message: 'Failed to execute git',

stdout: result.stdout,

stderr: result.stderr,

exitCode: result.exitCode,

gitErrorCode: getGitErrorCode(result.stderr),

gitCommand: args[0]

}));

}

return result;

}

spawn(args: string[], options: SpawnOptions = {}): cp.ChildProcess {

if (!this.path) {

throw new Error('git could not be found in the system.');

}

if (!options) {

options = {};

}

if (!options.stdio && !options.input) {

options.stdio = ['ignore', null, null]; // Unless provided, ignore stdin and leave default streams for stdout and stderr

}

options.env = assign({}, process.env, this.env, options.env || {}, {

VSCODE_GIT_COMMAND: args[0],

LC_ALL: 'en_US.UTF-8',

LANG: 'en_US.UTF-8'

});

if (options.log !== false) {

this.log(`> git ${args.join(' ')}\n`);

}

return cp.spawn(this.path, args, options);

}

private log(output: string): void {

this._onOutput.emit('log', output);

}

}

export interface Commit {

hash: string;

message: string;

parents: string[];

authorEmail?: string | undefined;

}

export class GitStatusParser {

private lastRaw = '';

private result: IFileStatus[] = [];

get status(): IFileStatus[] {

return this.result;

}

update(raw: string): void {

let i = 0;

let nextI: number | undefined;

raw = this.lastRaw + raw;

while ((nextI = this.parseEntry(raw, i)) !== undefined) {

i = nextI;

}

this.lastRaw = raw.substr(i);

}

private parseEntry(raw: string, i: number): number | undefined {

if (i + 4 >= raw.length) {

return;

}

let lastIndex: number;

const entry: IFileStatus = {

x: raw.charAt(i++),

y: raw.charAt(i++),

rename: undefined,

path: ''

};

// space

i++;

if (entry.x === 'R' || entry.x === 'C') {

lastIndex = raw.indexOf('\0', i);

if (lastIndex === -1) {

return;

}

entry.rename = raw.substring(i, lastIndex);

i = lastIndex + 1;

}

lastIndex = raw.indexOf('\0', i);

if (lastIndex === -1) {

return;

}

entry.path = raw.substring(i, lastIndex);

// If path ends with slash, it must be a nested git repo

if (entry.path[entry.path.length - 1] !== '/') {

this.result.push(entry);

}

return lastIndex + 1;

}

}

export interface Submodule {

name: string;

path: string;

url: string;

}

export function parseGitmodules(raw: string): Submodule[] {

const regex = /\r?\n/g;

let position = 0;

let match: RegExpExecArray | null = null;

const result: Submodule[] = [];

let submodule: Partial<Submodule> = {};

function parseLine(line: string): void {

const sectionMatch = /^\s*\[submodule "([^"]+)"\]\s*$/.exec(line);

if (sectionMatch) {

if (submodule.name && submodule.path && submodule.url) {

result.push(submodule as Submodule);

}

const name = sectionMatch[1];

if (name) {

submodule = { name };

return;

}

}

if (!submodule) {

return;

}

const propertyMatch = /^\s*(\w+)\s+=\s+(.*)$/.exec(line);

if (!propertyMatch) {

return;

}

const [, key, value] = propertyMatch;

switch (key) {

case 'path': submodule.path = value; break;

case 'url': submodule.url = value; break;

}

}

while (match = regex.exec(raw)) {

parseLine(raw.substring(position, match.index));

position = match.index + match[0].length;

}

parseLine(raw.substring(position));

if (submodule.name && submodule.path && submodule.url) {

result.push(submodule as Submodule);

}

return result;

}

export function parseGitCommit(raw: string): Commit | null {

const match = /^([0-9a-f]{40})\n(.*)\n(.*)(\n([^]*))?$/m.exec(raw.trim());

if (!match) {

return null;

}

const parents = match[3] ? match[3].split(' ') : [];

return { hash: match[1], message: match[5], parents, authorEmail: match[2] };

}

interface LsTreeElement {

mode: string;

type: string;

object: string;

size: string;

file: string;

}

export function parseLsTree(raw: string): LsTreeElement[] {

return raw.split('\n')

.filter(l => !!l)

.map(line => /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.*)$/.exec(line)!)

.filter(m => !!m)

.map(([, mode, type, object, size, file]) => ({ mode, type, object, size, file }));

}

interface LsFilesElement {

mode: string;

object: string;

stage: string;

file: string;

}

export function parseLsFiles(raw: string): LsFilesElement[] {

return raw.split('\n')

.filter(l => !!l)

.map(line => /^(\S+)\s+(\S+)\s+(\S+)\s+(.*)$/.exec(line)!)

.filter(m => !!m)

.map(([, mode, object, stage, file]) => ({ mode, object, stage, file }));

}

export interface CommitOptions {

all?: boolean | 'tracked';

amend?: boolean;

signoff?: boolean;

signCommit?: boolean;

empty?: boolean;

}

export interface PullOptions {

unshallow?: boolean;

tags?: boolean;

readonly cancellationToken?: CancellationToken;

}

export enum ForcePushMode {

Force,

ForceWithLease

}

export class Repository {

constructor(

private _git: Git,

private repositoryRoot: string,

readonly dotGit: string

) { }

get git(): Git {

return this._git;

}

get root(): string {

return this.repositoryRoot;

}

// TODO@Joao: rename to exec

async run(args: string[], options: SpawnOptions = {}): Promise<IExecutionResult<string>> {

return await this.git.exec(this.repositoryRoot, args, options);

}

stream(args: string[], options: SpawnOptions = {}): cp.ChildProcess {

return this.git.stream(this.repositoryRoot, args, options);

}

spawn(args: string[], options: SpawnOptions = {}): cp.ChildProcess {

return this.git.spawn(args, options);

}

async config(scope: string, key: string, value: any = null, options: SpawnOptions = {}): Promise<string> {

const args = ['config'];

if (scope) {

args.push('--' + scope);

}

args.push(key);

if (value) {

args.push(value);

}

const result = await this.run(args, options);

return result.stdout.trim();

}

async getConfigs(scope: string): Promise<{ key: string; value: string; }[]> {

const args = ['config'];

if (scope) {

args.push('--' + scope);

}

args.push('-l');

const result = await this.run(args);

const lines = result.stdout.trim().split(/\r|\r\n|\n/);

return lines.map(entry => {

const equalsIndex = entry.indexOf('=');

return { key: entry.substr(0, equalsIndex), value: entry.substr(equalsIndex + 1) };

});

}

async log(options?: LogOptions): Promise<Commit[]> {

const maxEntries = options && typeof options.maxEntries === 'number' && options.maxEntries > 0 ? options.maxEntries : 32;

const args = ['log', '-' + maxEntries, `--pretty=format:${COMMIT_FORMAT}%x00%x00`];

const gitResult = await this.run(args);

if (gitResult.exitCode) {

// An empty repo.

return [];

}

const s = gitResult.stdout;

const result: Commit[] = [];

let index = 0;

while (index < s.length) {

let nextIndex = s.indexOf('\x00\x00', index);

if (nextIndex === -1) {

nextIndex = s.length;

}

let entry = s.substr(index, nextIndex - index);

if (entry.startsWith('\n')) {

entry = entry.substring(1);

}

const commit = parseGitCommit(entry);

if (!commit) {

break;

}

result.push(commit);

index = nextIndex + 2;

}

return result;

}

async bufferString(object: string, encoding: string = 'utf8', autoGuessEncoding = false): Promise<string> {

const stdout = await this.buffer(object);

if (autoGuessEncoding) {

encoding = detectEncoding(stdout) || encoding;

}

encoding = iconv.encodingExists(encoding) ? encoding : 'utf8';

return iconv.decode(stdout, encoding);

}

async buffer(object: string): Promise<Buffer> {

const child = this.stream(['show', object]);

if (!child.stdout) {

return Promise.reject<Buffer>('Can\'t open file from git');

}

const { exitCode, stdout, stderr } = await exec(child);

if (exitCode) {

const err = new GitError({

message: 'Could not show object.',

exitCode

});

if (/exists on disk, but not in/.test(stderr)) {

err.gitErrorCode = GitErrorCodes.WrongCase;

}

return Promise.reject<Buffer>(err);

}

return stdout;

}

async getObjectDetails(treeish: string, path: string): Promise<{ mode: string, object: string, size: number }> {

if (!treeish) { // index

const elements = await this.lsfiles(path);

if (elements.length === 0) {

throw new GitError({ message: 'Path not known by git', gitErrorCode: GitErrorCodes.UnknownPath });

}

const { mode, object } = elements[0];

const catFile = await this.run(['cat-file', '-s', object]);

const size = parseInt(catFile.stdout);

return { mode, object, size };

}

const elements = await this.lstree(treeish, path);

if (elements.length === 0) {

throw new GitError({ message: 'Path not known by git', gitErrorCode: GitErrorCodes.UnknownPath });

}

const { mode, object, size } = elements[0];

return { mode, object, size: parseInt(size) };

}

async lstree(treeish: string, path: string): Promise<LsTreeElement[]> {

const { stdout } = await this.run(['ls-tree', '-l', treeish, '--', path]);

return parseLsTree(stdout);

}

async lsfiles(path: string): Promise<LsFilesElement[]> {

const { stdout } = await this.run(['ls-files', '--stage', '--', path]);

return parseLsFiles(stdout);

}

async getGitRelativePath(ref: string, relativePath: string): Promise<string> {

const relativePathLowercase = relativePath.toLowerCase();

const dirname = path.posix.dirname(relativePath) + '/';

const elements: { file: string; }[] = ref ? await this.lstree(ref, dirname) : await this.lsfiles(dirname);

const element = elements.filter(file => file.file.toLowerCase() === relativePathLowercase)[0];

if (!element) {

throw new GitError({ message: 'Git relative path not found.' });

}

return element.file;

}

async detectObjectType(object: string): Promise<{ mimetype: string, encoding?: string }> {

const child = await this.stream(['show', object]);

const buffer = await readBytes(child.stdout, 4100);

try {

child.kill();

} catch (err) {

// noop

}

const encoding = detectUnicodeEncoding(buffer);

let isText = true;

if (encoding !== Encoding.UTF16be && encoding !== Encoding.UTF16le) {

for (let i = 0; i < buffer.length; i++) {

if (buffer.readInt8(i) === 0) {

isText = false;

break;

}

}

}

if (!isText) {

const result = filetype(buffer);

if (!result) {

return { mimetype: 'application/octet-stream' };

} else {

return { mimetype: result.mime };

}

}

if (encoding) {

return { mimetype: 'text/plain', encoding };

} else {

// TODO@JOAO: read the setting OUTSIDE!

return { mimetype: 'text/plain' };

}

}

async apply(patch: string, reverse?: boolean): Promise<void> {

const args = ['apply', patch];

if (reverse) {

args.push('-R');

}

try {

await this.run(args);

} catch (err) {

if (/patch does not apply/.test(err.stderr)) {

err.gitErrorCode = GitErrorCodes.PatchDoesNotApply;

}

throw err;

}

}

async diff(cached = false): Promise<string> {

const args = ['diff'];

if (cached) {

args.push('--cached');

}

const result = await this.run(args);

return result.stdout;

}

diffWithHEAD(): Promise<Change[]>;

diffWithHEAD(path: string): Promise<string>;

diffWithHEAD(path?: string | undefined): Promise<string | Change[]>;

async diffWithHEAD(path?: string | undefined): Promise<string | Change[]> {

if (!path) {

return await this.diffFiles(false);

}

const args = ['diff', '--', path];

const result = await this.run(args);

return result.stdout;

}

diffWith(ref: string): Promise<Change[]>;

diffWith(ref: string, path: string): Promise<string>;

diffWith(ref: string, path?: string | undefined): Promise<string | Change[]>;

async diffWith(ref: string, path?: string): Promise<string | Change[]> {

if (!path) {

return await this.diffFiles(false, ref);

}

const args = ['diff', ref, '--', path];

const result = await this.run(args);

return result.stdout;

}

diffIndexWithHEAD(): Promise<Change[]>;

diffIndexWithHEAD(path: string): Promise<string>;

diffIndexWithHEAD(path?: string | undefined): Promise<string | Change[]>;

async diffIndexWithHEAD(path?: string): Promise<string | Change[]> {

if (!path) {

return await this.diffFiles(true);

}

const args = ['diff', '--cached', '--', path];

const result = await this.run(args);

return result.stdout;

}

diffIndexWith(ref: string): Promise<Change[]>;

diffIndexWith(ref: string, path: string): Promise<string>;

diffIndexWith(ref: string, path?: string | undefined): Promise<string | Change[]>;

async diffIndexWith(ref: string, path?: string): Promise<string | Change[]> {

if (!path) {

return await this.diffFiles(true, ref);

}

const args = ['diff', '--cached', ref, '--', path];

const result = await this.run(args);

return result.stdout;

}

async diffBlobs(object1: string, object2: string): Promise<string> {

const args = ['diff', object1, object2];

const result = await this.run(args);

return result.stdout;

}

diffBetween(ref1: string, ref2: string): Promise<Change[]>;

diffBetween(ref1: string, ref2: string, path: string): Promise<string>;

diffBetween(ref1: string, ref2: string, path?: string | undefined): Promise<string | Change[]>;

async diffBetween(ref1: string, ref2: string, path?: string): Promise<string | Change[]> {

const range = `${ref1}...${ref2}`;

if (!path) {

return await this.diffFiles(false, range);

}

const args = ['diff', range, '--', path];

const result = await this.run(args);

return result.stdout.trim();

}

private async diffFiles(cached: boolean, ref?: string): Promise<Change[]> {

const args = ['diff', '--name-status', '-z', '--diff-filter=ADMR'];

if (cached) {

args.push('--cached');

}

if (ref) {

args.push(ref);

}

const gitResult = await this.run(args);

if (gitResult.exitCode) {