@apexdevtools/git-ops 1.4.0 → 1.4.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # git-ops - Changelog
 
+## 1.4.2 - 2026-06-14
+
+- Refresh TypeScript, lint, package manager, and GitHub Actions tooling.
+
+## 1.4.1 - 2024-11-22
+
+- Fix missing deploy error reporting
+
 ## 1.4.0 - 2024-02-07
 
 - Add `getDeployableClasses` API for native based tracking

package/lib/{src/changes.js → changes.js}

@@ -2,20 +2,15 @@
 /*
  * Copyright (c) 2024 Certinia Inc. All rights reserved.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDeployableClasses = exports.getLocalChanges = exports.getDiffRange = exports.getDefaultBranchDiffByRef = exports.getDefaultBranchDiff = void 0;
+exports.getDefaultBranchDiff = getDefaultBranchDiff;
+exports.getDefaultBranchDiffByRef = getDefaultBranchDiffByRef;
+exports.getDiffRange = getDiffRange;
+exports.getLocalChanges = getLocalChanges;
+exports.getDeployableClasses = getDeployableClasses;
 const path_1 = __importDefault(require("path"));
 const git_1 = require("./git");
 /**
@@ -23,12 +18,9 @@ const git_1 = require("./git");
  * @param dir: string of the directory thr operation should be performed on
  * @returns set of absolute paths of changed files
  */
-function getDefaultBranchDiff(dir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return getDefaultBranchDiffByRef(dir, 'HEAD');
-    });
+async function getDefaultBranchDiff(dir) {
+    return getDefaultBranchDiffByRef(dir, 'HEAD');
 }
-exports.getDefaultBranchDiff = getDefaultBranchDiff;
 /**
  * Works out changed files using the default branch in that repo given a ref.
  * This find the default branch in the repo using `git symbolic-ref 'refs/remotes/origin/HEAD'`
@@ -39,18 +31,15 @@ exports.getDefaultBranchDiff = getDefaultBranchDiff;
  * @param refTo: string git ref. i.e HEAD, or commit hash
  * @returns set of absolute paths of changed files
  */
-function getDefaultBranchDiffByRef(dir, refTo) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const git = new git_1.Git(dir);
-        return git
-            .getDefaultBranchName()
-            .then(branch => getDiffRange(dir, branch, refTo))
-            .catch(er => {
-            throw new NoLocalBranchException(er);
-        });
+async function getDefaultBranchDiffByRef(dir, refTo) {
+    const git = new git_1.Git(dir);
+    return git
+        .getDefaultBranchName()
+        .then(branch => getDiffRange(dir, branch, refTo))
+        .catch(er => {
+        throw new NoLocalBranchException(er);
     });
 }
-exports.getDefaultBranchDiffByRef = getDefaultBranchDiffByRef;
 /**
  * Works out the diff between a given range. Equivalent to `git diff ref1...ref2`
  * @param dir string of the directory thr operation should be performed on
@@ -58,37 +47,31 @@ exports.getDefaultBranchDiffByRef = getDefaultBranchDiffByRef;
  * @param toRef string git ref. i.e HEAD, or commit hash
  * @returns set of absolute paths of changed files
  */
-function getDiffRange(dir, fromRef, toRef) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const git = new git_1.Git(dir);
-        const root = yield git.gitRoot();
-        return getDiffChanges(git, fromRef, toRef)
-            .then(changes => resolvePaths(changes, root))
-            .catch(er => {
-            throw new DiffFailedException(er);
-        });
+async function getDiffRange(dir, fromRef, toRef) {
+    const git = new git_1.Git(dir);
+    const root = await git.gitRoot();
+    return getDiffChanges(git, fromRef, toRef)
+        .then(changes => resolvePaths(changes, root))
+        .catch(er => {
+        throw new DiffFailedException(er);
     });
 }
-exports.getDiffRange = getDiffRange;
 /**
  * Get the local changes that not have been committed. Equivalent to `git status`
  * Files with the status of deleted (`D`) and ignored (`!`) will not be included in the change set.
  * @param dir tring of the directory thr operation should be performed on
  * @returns set of absolute paths of un committed files
  */
-function getLocalChanges(dir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const git = new git_1.Git(dir);
-        const root = yield git.gitRoot();
-        return git
-            .getLocalChangedAndCreated()
-            .then(changes => resolvePaths(changes, root))
-            .catch(er => {
-            throw new LocalChangeException(er);
-        });
+async function getLocalChanges(dir) {
+    const git = new git_1.Git(dir);
+    const root = await git.gitRoot();
+    return git
+        .getLocalChangedAndCreated()
+        .then(changes => resolvePaths(changes, root))
+        .catch(er => {
+        throw new LocalChangeException(er);
     });
 }
-exports.getLocalChanges = getLocalChanges;
 /**
  * Get the locally changed class files, based on source tracking repo. Note that it does
  * not respect the `.forceignore` yet.
@@ -97,40 +80,35 @@ exports.getLocalChanges = getLocalChanges;
  * @param orgId SF org ID, used to select tracking repo
  * @returns paths of class files that may need deploying
  */
-function getDeployableClasses(projectDir, orgId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const git = new git_1.Git(projectDir);
-        const trackingDir = getTrackingGitDir(projectDir, orgId);
-        const stats = [
-            git_1.FileStatus.Modified,
-            git_1.FileStatus.Added,
-            git_1.FileStatus.Renamed,
-            git_1.FileStatus.Copied,
-            git_1.FileStatus.Untracked,
-        ];
-        return git
-            .getFilteredStatus(f => f.path.endsWith('.cls') && stats.includes(f.working_dir), trackingDir)
-            .then(changes => resolvePaths(changes, projectDir))
-            .catch(er => {
-            throw new LocalChangeException(er);
-        });
+async function getDeployableClasses(projectDir, orgId) {
+    const git = new git_1.Git(projectDir);
+    const trackingDir = getTrackingGitDir(projectDir, orgId);
+    const stats = [
+        git_1.FileStatus.Modified,
+        git_1.FileStatus.Added,
+        git_1.FileStatus.Renamed,
+        git_1.FileStatus.Copied,
+        git_1.FileStatus.Untracked,
+    ];
+    return git
+        .getFilteredStatus(f => f.path.endsWith('.cls') && stats.includes(f.working_dir), trackingDir)
+        .then(changes => resolvePaths(changes, projectDir))
+        .catch(er => {
+        throw new LocalChangeException(er);
     });
 }
-exports.getDeployableClasses = getDeployableClasses;
 function resolvePaths(paths, root) {
     const fullPaths = [...paths].map(p => path_1.default.resolve(root, p));
     return new Set(fullPaths);
 }
-function getDiffChanges(git, ref1, ref2) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const changes = yield Promise.all([
-            git.diffRange(ref1, ref2),
-            git.getLocalChangedAndCreated(),
-        ]);
-        const allChanges = new Set();
-        changes.forEach(set => set.forEach(file => allChanges.add(file)));
-        return allChanges;
-    });
+async function getDiffChanges(git, ref1, ref2) {
+    const changes = await Promise.all([
+        git.diffRange(ref1, ref2),
+        git.getLocalChangedAndCreated(),
+    ]);
+    const allChanges = new Set();
+    changes.forEach(set => set.forEach(file => allChanges.add(file)));
+    return allChanges;
 }
 function getTrackingGitDir(projectDir, orgId) {
     return path_1.default.resolve(projectDir, '.sf', 'orgs', orgId, 'localSourceTracking');

package/lib/{src/git.d.ts → git.d.ts}

@@ -23,5 +23,5 @@ export declare class Git {
     getDefaultBranchName(): Promise<string>;
     diffRange(fromRef: string, toRef: string): Promise<Set<string>>;
     getLocalChangedAndCreated(): Promise<Set<string>>;
-    getFilteredStatus(filterFn: (result: FileStatusResult) => boolean, gitDir?: string | undefined): Promise<Set<string>>;
+    getFilteredStatus(filterFn: (result: FileStatusResult) => boolean, gitDir?: string): Promise<Set<string>>;
 }

package/lib/git.js

@@ -0,0 +1,93 @@
+"use strict";
+/*
+ * Copyright (c) 2024 Certinia Inc. All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Git = exports.FileStatus = void 0;
+const simple_git_1 = require("simple-git");
+var FileStatus;
+(function (FileStatus) {
+    FileStatus["Unmodified"] = " ";
+    FileStatus["Modified"] = "M";
+    FileStatus["TypeChanged"] = "T";
+    FileStatus["Added"] = "A";
+    FileStatus["Deleted"] = "D";
+    FileStatus["Renamed"] = "R";
+    FileStatus["Copied"] = "C";
+    FileStatus["Updated"] = "U";
+    FileStatus["Untracked"] = "?";
+    FileStatus["Ignore"] = "!";
+})(FileStatus || (exports.FileStatus = FileStatus = {}));
+class Git {
+    static MIN_GIT_VERSION_MAJOR = 2;
+    static MIN_GIT_VERSION_MINOR = 20;
+    gitInstance = undefined;
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    static async versionCheck(git) {
+        const version = await git.version();
+        const isSupported = version.major >= this.MIN_GIT_VERSION_MAJOR &&
+            version.minor >= this.MIN_GIT_VERSION_MINOR;
+        if (!version.installed) {
+            throw new Error('"git" is not installed or available on the PATH');
+        }
+        if (!isSupported)
+            throw new Error(`Unsupported version of git. Min version must be ${this.MIN_GIT_VERSION_MAJOR}.${this.MIN_GIT_VERSION_MINOR}`);
+    }
+    get git() {
+        if (this.gitInstance)
+            return Promise.resolve(this.gitInstance);
+        const git = (0, simple_git_1.simpleGit)(this.dir);
+        return Git.versionCheck(git).then(() => {
+            this.gitInstance = git;
+            return git;
+        });
+    }
+    async gitRoot() {
+        return (await this.git).revparse('--show-toplevel');
+    }
+    async getDefaultBranchName() {
+        return this.git
+            .then(git => git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD', '--short']))
+            .catch(error => {
+            if (error instanceof Error)
+                throw Error(`Failed to find symbolic ref no remote HEAD with message: '${error.message.trim()}'`);
+            else
+                throw new Error('Failed to find symbolic ref no remote HEAD');
+        })
+            .then(branch => {
+            if (branch.startsWith('origin/'))
+                return branch.trim();
+            else
+                throw new Error(`Expected default branch '${branch}' to start with 'origin/'`);
+        });
+    }
+    async diffRange(fromRef, toRef) {
+        return this.git
+            .then(git => git.diff([`${fromRef}...${toRef}`, '--name-only', '-z']))
+            .then(diff => {
+            const files = diff
+                .split('\u0000')
+                .map(s => s.trim())
+                .filter(s => s); //Removes any falsy values
+            return new Set([...files]);
+        });
+    }
+    async getLocalChangedAndCreated() {
+        const excludeStatus = [FileStatus.Deleted, FileStatus.Ignore];
+        return this.getFilteredStatus(f => !excludeStatus.includes(f.index) &&
+            !excludeStatus.includes(f.working_dir));
+    }
+    async getFilteredStatus(filterFn, gitDir) {
+        return this.git
+            .then(git => {
+            return gitDir ? git.env('GIT_DIR', gitDir).status() : git.status();
+        })
+            .then(status => {
+            return new Set(...[status.files.filter(filterFn).map(f => f.path)]);
+        });
+    }
+}
+exports.Git = Git;

package/lib/{src/tracking.d.ts → tracking.d.ts}

@@ -35,6 +35,8 @@ export declare class OrgTracking {
     getLocalStatus(withConflicts?: boolean): Promise<SyncStatus>;
     deployAndUpdateSourceTracking(paths: Array<string>): Promise<void>;
     private deploy;
+    private reportDeployStatus;
+    private reportDeployErrors;
     private updateSourceTracking;
     private toSyncStatusRow;
     private withWorkingDir;

package/lib/tracking.js

@@ -0,0 +1,154 @@
+"use strict";
+/*
+ * Copyright (c) 2024 Certinia Inc. All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgTracking = exports.FileState = void 0;
+const core_1 = require("@salesforce/core");
+const process_1 = require("process");
+const source_tracking_1 = require("@salesforce/source-tracking");
+const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
+var FileState;
+(function (FileState) {
+    FileState["Added"] = "add";
+    FileState["Modified"] = "modify";
+    FileState["Deleted"] = "delete";
+    FileState["NonDelete"] = "nondelete";
+    FileState["Ignored"] = "ignore";
+    FileState["Conflicted"] = "conflict";
+})(FileState || (exports.FileState = FileState = {}));
+class OrgTracking {
+    options;
+    logger;
+    constructor(options) {
+        this.options = options;
+        this.logger = options.logger;
+    }
+    async getLocalStatus(withConflicts = false) {
+        // source-tracking currently brings its own @salesforce/core type graph,
+        // so keep the runtime object and relax the compile-time boundary here.
+        const project = core_1.SfProject.getInstance(this.options.projectDir);
+        const org = (await core_1.Org.create({
+            connection: this.options.connection,
+        }));
+        return await this.withWorkingDir(this.options.projectDir, async () => {
+            const tracking = await source_tracking_1.SourceTracking.create({
+                org,
+                project,
+                ignoreLocalCache: true,
+            });
+            await tracking.ensureRemoteTracking(true);
+            const initValue = { local: [], remote: [] };
+            const status = await tracking
+                .getStatus({ local: true, remote: false })
+                .then(async (res) => {
+                if (withConflicts) {
+                    //Taken from sourceTracking.ts from the @salesforce/source-tracking lib
+                    const conflictFiles = (await tracking.getConflicts())
+                        .flatMap(conflict => conflict.filenames)
+                        .filter((value) => typeof value === 'string');
+                    res = res.map(row => ({
+                        ...row,
+                        conflict: !!row.filePath && conflictFiles.includes(row.filePath),
+                    }));
+                }
+                return res;
+            })
+                .catch(e => {
+                this.logger.logError(e);
+                return [];
+            });
+            return status.reduce((acc, row) => {
+                acc[row.origin].push(this.toSyncStatusRow(row));
+                return acc;
+            }, initValue);
+        });
+    }
+    async deployAndUpdateSourceTracking(paths) {
+        return await this.withWorkingDir(this.options.projectDir, async () => {
+            try {
+                this.logger.logDeployProgress('Starting deploy');
+                const result = await this.deploy(paths);
+                if (result.response.success) {
+                    await this.updateSourceTracking(result);
+                }
+                else {
+                    this.reportDeployErrors(result);
+                }
+                this.logger.logDeployProgress('Finished deploy');
+            }
+            catch (e) {
+                this.logger.logError(e);
+            }
+        });
+    }
+    async deploy(paths) {
+        const deploy = await source_deploy_retrieve_1.ComponentSet.fromSource(paths).deploy({
+            usernameOrConnection: this.options.connection,
+        });
+        deploy.onUpdate(response => this.reportDeployStatus(response));
+        const result = await deploy.pollStatus();
+        this.reportDeployStatus(result.response);
+        return result;
+    }
+    reportDeployStatus(response) {
+        const { status, numberComponentsDeployed, numberComponentsTotal, numberComponentErrors, } = response;
+        const progress = `${numberComponentsDeployed}/${numberComponentsTotal}`;
+        const message = `Status: ${status} | Progress: ${progress} | Errors: ${numberComponentErrors}`;
+        this.logger.logDeployProgress(message);
+    }
+    reportDeployErrors(result) {
+        const errors = result.getFileResponses().reduce((a, c) => {
+            if (c.state === source_deploy_retrieve_1.ComponentStatus.Failed) {
+                a.push(new Error(`${c.fullName}: ${c.error}`));
+            }
+            return a;
+        }, []);
+        if (errors.length) {
+            this.logger.logDeployProgress('Deploy errors:');
+            errors.forEach(err => this.logger.logError(err));
+        }
+    }
+    async updateSourceTracking(result) {
+        this.logger.logDeployProgress('Starting source tracking update');
+        const project = core_1.SfProject.getInstance(this.options.projectDir);
+        const org = (await core_1.Org.create({
+            connection: this.options.connection,
+        }));
+        const tracking = await source_tracking_1.SourceTracking.create({
+            org,
+            project,
+            ignoreLocalCache: true,
+        });
+        await tracking.updateTrackingFromDeploy(result);
+        this.logger.logDeployProgress('Finished source tracking update');
+    }
+    toSyncStatusRow(from) {
+        const state = [];
+        if (from.ignored) {
+            state.push(FileState.Ignored);
+        }
+        if (from.conflict) {
+            state.push(FileState.Conflicted);
+        }
+        state.push(from.state);
+        return {
+            fullName: from.fullName,
+            path: from.filePath,
+            state: state,
+            type: from.type,
+            origin: from.origin,
+        };
+    }
+    async withWorkingDir(path, op) {
+        const startDir = (0, process_1.cwd)();
+        (0, process_1.chdir)(path);
+        try {
+            return await op();
+        }
+        finally {
+            (0, process_1.chdir)(startDir);
+        }
+    }
+}
+exports.OrgTracking = OrgTracking;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apexdevtools/git-ops",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Library to do git operations to find changed files in a given git repository",
   "author": {
     "name": "Apex Dev Tools Team",
@@ -25,7 +25,9 @@
     "url": "https://github.com/apex-dev-tools/git-ops/issues"
   },
   "homepage": "https://github.com/apex-dev-tools/git-ops#readme",
-  "packageManager": "pnpm@8.9.2",
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  },
   "dependencies": {
     "@salesforce/core": "^4.3.11",
     "@salesforce/source-deploy-retrieve": "^9.2.8",
@@ -33,22 +35,20 @@
     "simple-git": "^3.16.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@ryansonshine/commitizen": "^4.2.8",
     "@ryansonshine/cz-conventional-changelog": "^3.3.4",
-    "@types/jest": "^29.5.0",
-    "@types/node": "^18.15.11",
-    "@typescript-eslint/eslint-plugin": "^5.59.8",
-    "@typescript-eslint/parser": "^5.59.8",
-    "eslint": "^8.41.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "husky": "^8.0.3",
-    "jest": "^29.5.0",
-    "lint-staged": "^13.2.2",
-    "prettier": "^2.8.8",
-    "ts-jest": "^29.1.0",
-    "typescript": "^4.9.5"
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.19.17",
+    "eslint": "^10.2.1",
+    "eslint-config-prettier": "^10.1.8",
+    "husky": "^9.1.7",
+    "jest": "^30.3.0",
+    "lint-staged": "^17.0.2",
+    "prettier": "^3.8.3",
+    "ts-jest": "^29.4.5",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.0"
   },
   "config": {
     "commitizen": {
@@ -62,7 +62,7 @@
     "build": "tsc",
     "clean": "rm -rf ./lib/",
     "commit": "cz",
-    "lint": "eslint ./src/ --fix",
+    "lint": "eslint --cache --cache-location .eslintcache ./src --fix",
     "test": "jest --coverage --runInBand",
     "test:watch": "jest --watch"
   }

package/lib/src/git.js

@@ -1,114 +0,0 @@
-"use strict";
-/*
- * Copyright (c) 2024 Certinia Inc. All rights reserved.
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Git = exports.FileStatus = void 0;
-const simple_git_1 = require("simple-git");
-var FileStatus;
-(function (FileStatus) {
-    FileStatus["Unmodified"] = " ";
-    FileStatus["Modified"] = "M";
-    FileStatus["TypeChanged"] = "T";
-    FileStatus["Added"] = "A";
-    FileStatus["Deleted"] = "D";
-    FileStatus["Renamed"] = "R";
-    FileStatus["Copied"] = "C";
-    FileStatus["Updated"] = "U";
-    FileStatus["Untracked"] = "?";
-    FileStatus["Ignore"] = "!";
-})(FileStatus = exports.FileStatus || (exports.FileStatus = {}));
-class Git {
-    constructor(dir) {
-        this.gitInstance = undefined;
-        this.dir = dir;
-    }
-    static versionCheck(git) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const version = yield git.version();
-            const isSupported = version.major >= this.MIN_GIT_VERSION_MAJOR &&
-                version.minor >= this.MIN_GIT_VERSION_MINOR;
-            if (!version.installed) {
-                throw new Error('"git" is not installed or available on the PATH');
-            }
-            if (!isSupported)
-                throw new Error(`Unsupported version of git. Min version must be ${this.MIN_GIT_VERSION_MAJOR}.${this.MIN_GIT_VERSION_MINOR}`);
-        });
-    }
-    get git() {
-        if (this.gitInstance)
-            return Promise.resolve(this.gitInstance);
-        //eslint-disable-next-line
-        const git = (0, simple_git_1.simpleGit)(this.dir);
-        return Git.versionCheck(git).then(() => {
-            this.gitInstance = git;
-            return git;
-        });
-    }
-    gitRoot() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.git).revparse('--show-toplevel');
-        });
-    }
-    getDefaultBranchName() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.git
-                .then(git => git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD', '--short']))
-                .catch(error => {
-                if (error instanceof Error)
-                    throw Error(`Failed to find symbolic ref no remote HEAD with message: '${error.message.trim()}'`);
-                else
-                    throw new Error('Failed to find symbolic ref no remote HEAD');
-            })
-                .then(branch => {
-                if (branch.startsWith('origin/'))
-                    return branch.trim();
-                else
-                    throw new Error(`Expected default branch '${branch}' to start with 'origin/'`);
-            });
-        });
-    }
-    diffRange(fromRef, toRef) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.git
-                .then(git => git.diff([`${fromRef}...${toRef}`, '--name-only', '-z']))
-                .then(diff => {
-                const files = diff
-                    .split('\u0000')
-                    .map(s => s.trim())
-                    .filter(s => s); //Removes any falsy values
-                return new Set([...files]);
-            });
-        });
-    }
-    getLocalChangedAndCreated() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const excludeStatus = [FileStatus.Deleted, FileStatus.Ignore];
-            return this.getFilteredStatus(f => !excludeStatus.includes(f.index) &&
-                !excludeStatus.includes(f.working_dir));
-        });
-    }
-    getFilteredStatus(filterFn, gitDir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.git
-                .then(git => {
-                return gitDir ? git.env('GIT_DIR', gitDir).status() : git.status();
-            })
-                .then(status => {
-                return new Set(...[status.files.filter(filterFn).map(f => f.path)]);
-            });
-        });
-    }
-}
-exports.Git = Git;
-Git.MIN_GIT_VERSION_MAJOR = 2;
-Git.MIN_GIT_VERSION_MINOR = 20;