workspace-tools 0.23.3 → 0.24.0

package/CHANGELOG.json

@@ -2,7 +2,22 @@
   "name": "workspace-tools",
   "entries": [
     {
-      "date": "Fri, 15 Jul 2022 07:09:46 GMT",
+      "date": "Wed, 20 Jul 2022 22:31:28 GMT",
+      "tag": "workspace-tools_v0.24.0",
+      "version": "0.24.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "elcraig@microsoft.com",
+            "package": "workspace-tools",
+            "comment": "Make getDefaultRemote properly handle more combinations of URL formats, and add more logging to encourage defining the `repository` property in package.json for more accurate detection",
+            "commit": "4bffdc45ceb49ca49f28ebc788e5c2cbe71e3a9f"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Fri, 15 Jul 2022 07:09:50 GMT",
       "tag": "workspace-tools_v0.23.3",
       "version": "0.23.3",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,20 @@
 # Change Log - workspace-tools
 
-This log was last generated on Fri, 15 Jul 2022 07:09:46 GMT and should not be manually modified.
+This log was last generated on Wed, 20 Jul 2022 22:31:28 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.24.0
+
+Wed, 20 Jul 2022 22:31:28 GMT
+
+### Minor changes
+
+- Make getDefaultRemote properly handle more combinations of URL formats, and add more logging to encourage defining the `repository` property in package.json for more accurate detection (elcraig@microsoft.com)
+
 ## 0.23.3
 
-Fri, 15 Jul 2022 07:09:46 GMT
+Fri, 15 Jul 2022 07:09:50 GMT
 
 ### Patches
 

package/lib/git/getDefaultRemote.d.ts

@@ -0,0 +1,28 @@
+export declare type GetDefaultRemoteOptions = {
+    /** Get repository info relative to this directory. */
+    cwd: string;
+    /**
+     * If true, throw an error if remote info can't be found, or if a `repository` is not specified
+     * in package.json and no matching remote is found.
+     */
+    strict?: boolean;
+    /** If true, log debug messages about how the remote was chosen */
+    verbose?: boolean;
+};
+/**
+ * Get the name of the default remote: the one matching the `repository` field in package.json.
+ * Throws if `options.cwd` is not in a git repo or there's no package.json at the repo root.
+ *
+ * The order of preference for returned remotes is:
+ * 1. If `repository` is defined in package.json, the remote with a matching URL (if `options.strict`
+ *    is true, throws an error if no matching remote exists)
+ * 2. `upstream` if defined
+ * 3. `origin` if defined
+ * 4. The first defined remote
+ * 5. If there are no defined remotes: throws an error if `options.strict` is true; otherwise returns `origin`
+ *
+ * @returns The name of the inferred default remote.
+ */
+export declare function getDefaultRemote(options: GetDefaultRemoteOptions): string;
+/** @deprecated Use the object param version */
+export declare function getDefaultRemote(cwd: string): string;

package/lib/git/getDefaultRemote.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRemote = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+const getRepositoryName_1 = require("./getRepositoryName");
+const git_1 = require("./git");
+function getDefaultRemote(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
+    const { cwd, strict, verbose } = options;
+    const log = (message) => verbose && console.log(message);
+    const logOrThrow = (message) => {
+        if (strict) {
+            throw new Error(message);
+        }
+        log(message);
+    };
+    const gitRoot = (0, paths_1.findGitRoot)(cwd);
+    if (!gitRoot) {
+        throw new Error(`Directory "${cwd}" does not appear to be in a git repository`);
+    }
+    let packageJson = {};
+    const packageJsonPath = path_1.default.join(gitRoot, "package.json");
+    try {
+        packageJson = fs_extra_1.default.readJSONSync(packageJsonPath);
+    }
+    catch (e) {
+        throw new Error(`Could not read "${packageJsonPath}"`);
+    }
+    const { repository } = packageJson;
+    const repositoryUrl = typeof repository === "string" ? repository : (repository && repository.url) || "";
+    if (!repositoryUrl) {
+        // This is always logged because it's strongly recommended to fix
+        console.log(`Valid "repository" key not found in "${packageJsonPath}". Consider adding this info for more accurate git remote detection.`);
+    }
+    /** Repository full name (owner and repo name) specified in package.json */
+    const repositoryName = (0, getRepositoryName_1.getRepositoryName)(repositoryUrl);
+    const remotesResult = (0, git_1.git)(["remote", "-v"], { cwd });
+    if (!remotesResult.success) {
+        logOrThrow(`Could not determine available git remotes under "${cwd}"`);
+    }
+    /** Mapping from remote URL to full name (owner and repo name) */
+    const remotes = {};
+    remotesResult.stdout.split("\n").forEach((line) => {
+        const [remoteName, remoteUrl] = line.split(/\s+/);
+        const remoteRepoName = (0, getRepositoryName_1.getRepositoryName)(remoteUrl);
+        if (remoteRepoName) {
+            remotes[remoteRepoName] = remoteName;
+        }
+    });
+    if (repositoryName) {
+        // If the repository name was found in package.json, check for a matching remote
+        if (remotes[repositoryName]) {
+            return remotes[repositoryName];
+        }
+        // If `strict` is true, and repositoryName is found, there MUST be a matching remote
+        logOrThrow(`Could not find remote pointing to repository "${repositoryName}".`);
+    }
+    // Default to upstream or origin if available, or the first remote otherwise
+    const allRemoteNames = Object.values(remotes);
+    const fallbacks = ["upstream", "origin", ...allRemoteNames];
+    for (const fallback of fallbacks) {
+        if (allRemoteNames.includes(fallback)) {
+            log(`Default to remote "${fallback}"`);
+            return fallback;
+        }
+    }
+    // If we get here, no git remotes were found. This should probably always be an error (since
+    // subsequent operations which require a remote likely won't work), but to match old behavior,
+    // still default to "origin" unless `strict` is true.
+    logOrThrow(`Could not find any remotes in git repo at "${gitRoot}".`);
+    log(`Assuming default remote "origin".`);
+    return "origin";
+}
+exports.getDefaultRemote = getDefaultRemote;

package/lib/git/getDefaultRemoteBranch.d.ts

@@ -0,0 +1,18 @@
+import { GetDefaultRemoteOptions } from "./getDefaultRemote";
+export declare type GetDefaultRemoteBranchOptions = GetDefaultRemoteOptions & {
+    /** Name of branch to use. If undefined, uses the default branch name (falling back to `master`). */
+    branch?: string;
+};
+/**
+ * Gets a reference to `options.branch` or the default branch relative to the default remote.
+ * (See {@link getDefaultRemote} for how the default remote is determined.)
+ * Throws if `options.cwd` is not in a git repo or there's no package.json at the repo root.
+ * @returns A branch reference like `upstream/master` or `origin/master`.
+ */
+export declare function getDefaultRemoteBranch(options: GetDefaultRemoteBranchOptions): string;
+/**
+ * First param: `branch`. Second param: `cwd`. See {@link GetDefaultRemoteBranchOptions} for more info.
+ * (This had to be changed to `...args` to avoid a conflict with the object param version.)
+ * @deprecated Use the object param version
+ */
+export declare function getDefaultRemoteBranch(...args: string[]): string;

package/lib/git/getDefaultRemoteBranch.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRemoteBranch = void 0;
+const getDefaultRemote_1 = require("./getDefaultRemote");
+const git_1 = require("./git");
+const gitUtilities_1 = require("./gitUtilities");
+function getDefaultRemoteBranch(...args) {
+    var _a;
+    const [branchOrOptions, argsCwd] = args;
+    const options = typeof branchOrOptions === "string"
+        ? { branch: branchOrOptions, cwd: argsCwd }
+        : branchOrOptions;
+    const { cwd, branch } = options;
+    const defaultRemote = (0, getDefaultRemote_1.getDefaultRemote)(options);
+    if (branch) {
+        return `${defaultRemote}/${branch}`;
+    }
+    const showRemote = (0, git_1.git)(["remote", "show", defaultRemote], { cwd });
+    let remoteDefaultBranch;
+    if (showRemote.success) {
+        /**
+         * `showRemote.stdout` is something like this:
+         *
+         * * remote origin
+         *   Fetch URL: .../monorepo-upstream
+         *   Push  URL: .../monorepo-upstream
+         *   HEAD branch: main
+         */
+        remoteDefaultBranch = (_a = showRemote.stdout
+            .split(/\n/)
+            .find((line) => line.includes("HEAD branch"))) === null || _a === void 0 ? void 0 : _a.replace(/^\s*HEAD branch:\s+/, "");
+    }
+    return `${defaultRemote}/${remoteDefaultBranch || (0, gitUtilities_1.getDefaultBranch)(cwd)}`;
+}
+exports.getDefaultRemoteBranch = getDefaultRemoteBranch;

package/lib/git/getRepositoryName.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Get a repository full name (owner and repo, plus organization for ADO/VSO) from a repository URL,
+ * including special handling for the many ADO/VSO URL formats.
+ *
+ * Examples:
+ * - returns `microsoft/workspace-tools` for `https://github.com/microsoft/workspace-tools.git`
+ * - returns `foo/bar/some-repo` for `https://dev.azure.com/foo/bar/_git/some-repo`
+ */
+export declare function getRepositoryName(url: string): string;

package/lib/git/getRepositoryName.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRepositoryName = void 0;
+const git_url_parse_1 = __importDefault(require("git-url-parse"));
+/**
+ * Get a repository full name (owner and repo, plus organization for ADO/VSO) from a repository URL,
+ * including special handling for the many ADO/VSO URL formats.
+ *
+ * Examples:
+ * - returns `microsoft/workspace-tools` for `https://github.com/microsoft/workspace-tools.git`
+ * - returns `foo/bar/some-repo` for `https://dev.azure.com/foo/bar/_git/some-repo`
+ */
+function getRepositoryName(url) {
+    var _a;
+    try {
+        // Mostly use this standard library, but fix some VSO/ADO-specific quirks to account for the
+        // fact that all of the following URLs should be considered to point to the same repo:
+        // https://foo.visualstudio.com/bar/_git/some-repo
+        // https://foo.visualstudio.com/DefaultCollection/bar/_git/some-repo
+        // https://user:token@foo.visualstudio.com/DefaultCollection/bar/_git/some-repo
+        // https://foo.visualstudio.com/DefaultCollection/bar/_git/_optimized/some-repo
+        // foo@vs-ssh.visualstudio.com:v3/foo/bar/some-repo
+        // https://dev.azure.com/foo/bar/_git/some-repo
+        // https://dev.azure.com/foo/bar/_git/_optimized/some-repo
+        // https://user@dev.azure.com/foo/bar/_git/some-repo
+        // git@ssh.dev.azure.com:v3/foo/bar/some-repo
+        let fixedUrl = url.replace("/_optimized/", "/").replace("/DefaultCollection/", "/");
+        const parsedUrl = (0, git_url_parse_1.default)(fixedUrl);
+        const isVSO = fixedUrl.includes(".visualstudio.com");
+        const isADO = fixedUrl.includes("dev.azure.com");
+        if (!isVSO && !isADO) {
+            return parsedUrl.full_name;
+        }
+        // As of writing, ADO and VSO SSH URLs are parsed completely wrong
+        const sshMatch = parsedUrl.full_name.match(/(vs-ssh\.visualstudio\.com|ssh\.dev\.azure\.com):v\d+\/([^/]+)\/([^/]+)/);
+        if (sshMatch) {
+            return `${sshMatch[2]}/${sshMatch[3]}/${parsedUrl.name}`;
+        }
+        // As of writing, full_name is wrong for enough variants of ADO and VSO URLs that it
+        // makes more sense to just build it manually.
+        let organization = parsedUrl.organization;
+        if (!organization && isVSO) {
+            // organization is missing or wrong for VSO
+            organization = (_a = parsedUrl.resource.match(/([^.@]+)\.visualstudio\.com/)) === null || _a === void 0 ? void 0 : _a[1];
+        }
+        return `${organization}/${parsedUrl.owner}/${parsedUrl.name}`;
+    }
+    catch (err) {
+        return "";
+    }
+}
+exports.getRepositoryName = getRepositoryName;

package/lib/git/git.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { SpawnSyncOptions } from "child_process";
+export declare class GitError extends Error {
+    originalError: unknown;
+    constructor(message: string, originalError?: unknown);
+}
+export declare type GitProcessOutput = {
+    stderr: string;
+    stdout: string;
+    success: boolean;
+};
+/** Observes the git operations called from `git()` or `gitFailFast()` */
+declare type GitObserver = (args: string[], output: GitProcessOutput) => void;
+/**
+ * Adds an observer for the git operations, e.g. for testing
+ * @param observer
+ */
+export declare function addGitObserver(observer: GitObserver): void;
+/**
+ * Runs git command - use this for read-only commands
+ */
+export declare function git(args: string[], options?: SpawnSyncOptions): GitProcessOutput;
+/**
+ * Runs git command - use this for commands that make changes to the filesystem
+ */
+export declare function gitFailFast(args: string[], options?: SpawnSyncOptions & {
+    noExitCode?: boolean;
+}): void;
+export {};

package/lib/git/git.js

@@ -0,0 +1,72 @@
+"use strict";
+//
+// Basic git wrappers
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitFailFast = exports.git = exports.addGitObserver = exports.GitError = void 0;
+const child_process_1 = require("child_process");
+class GitError extends Error {
+    constructor(message, originalError) {
+        if (originalError instanceof Error) {
+            super(`${message}: ${originalError.message}`);
+        }
+        else {
+            super(message);
+        }
+        this.originalError = originalError;
+    }
+}
+exports.GitError = GitError;
+/**
+ * A global maxBuffer override for all git operations.
+ * Bumps up the default to 500MB instead of 1MB.
+ * Override this value with the `GIT_MAX_BUFFER` environment variable.
+ */
+const defaultMaxBuffer = process.env.GIT_MAX_BUFFER ? parseInt(process.env.GIT_MAX_BUFFER) : 500 * 1024 * 1024;
+const observers = [];
+let observing;
+/**
+ * Adds an observer for the git operations, e.g. for testing
+ * @param observer
+ */
+function addGitObserver(observer) {
+    observers.push(observer);
+}
+exports.addGitObserver = addGitObserver;
+/**
+ * Runs git command - use this for read-only commands
+ */
+function git(args, options) {
+    const results = (0, child_process_1.spawnSync)("git", args, Object.assign({ maxBuffer: defaultMaxBuffer }, options));
+    const output = {
+        stderr: results.stderr.toString().trimRight(),
+        stdout: results.stdout.toString().trimRight(),
+        success: results.status === 0,
+    };
+    // notify observers, flipping the observing bit to prevent infinite loops
+    if (!observing) {
+        observing = true;
+        for (const observer of observers) {
+            observer(args, output);
+        }
+        observing = false;
+    }
+    return output;
+}
+exports.git = git;
+/**
+ * Runs git command - use this for commands that make changes to the filesystem
+ */
+function gitFailFast(args, options) {
+    var _a, _b;
+    const gitResult = git(args, options);
+    if (!gitResult.success) {
+        if (!(options === null || options === void 0 ? void 0 : options.noExitCode)) {
+            process.exitCode = 1;
+        }
+        throw new GitError(`CRITICAL ERROR: running git command: git ${args.join(" ")}!
+    ${(_a = gitResult.stdout) === null || _a === void 0 ? void 0 : _a.toString().trimRight()}
+    ${(_b = gitResult.stderr) === null || _b === void 0 ? void 0 : _b.toString().trimRight()}`);
+    }
+}
+exports.gitFailFast = gitFailFast;

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

@@ -1,25 +1,3 @@
-/// <reference types="node" />
-import { SpawnSyncOptions } from "child_process";
-declare type ProcessOutput = {
-    stderr: string;
-    stdout: string;
-    success: boolean;
-};
-/** Observes the git operations called from `git()` or `gitFailFast()` */
-declare type GitObserver = (args: string[], output: ProcessOutput) => void;
-/**
- * Adds an observer for the git operations, e.g. for testing
- * @param observer
- */
-export declare function addGitObserver(observer: GitObserver): void;
-/**
- * Runs git command - use this for read-only commands
- */
-export declare function git(args: string[], options?: SpawnSyncOptions): ProcessOutput;
-/**
- * Runs git command - use this for commands that make changes to the filesystem
- */
-export declare function gitFailFast(args: string[], options?: SpawnSyncOptions): void;
 export declare function getUntrackedChanges(cwd: string): string[];
 export declare function fetchRemote(remote: string, cwd: string): void;
 export declare function fetchRemoteBranch(remote: string, remoteBranch: string, cwd: string): void;
@@ -31,8 +9,6 @@ export declare function getUnstagedChanges(cwd: string): string[];
 export declare function getChanges(branch: string, cwd: string): string[];
 /**
  * Gets all the changes between the branch and the merge-base
- * @param branch
- * @param cwd
  */
 export declare function getBranchChanges(branch: string, cwd: string): string[];
 export declare function getChangesBetweenRefs(fromRef: string, toRef: string, options: string[], pattern: string, cwd: string): string[];
@@ -58,8 +34,8 @@ export declare function parseRemoteBranch(branch: string): {
     remote: string;
     remoteBranch: string;
 };
-export declare function getDefaultRemoteBranch(branch: string | undefined, cwd: string): string;
+/**
+ * Gets the default branch based on `git config init.defaultBranch`, falling back to `master`.
+ */
 export declare function getDefaultBranch(cwd: string): string;
-export declare function getDefaultRemote(cwd: string): string;
 export declare function listAllTrackedFiles(patterns: string[], cwd: string): string[];
-export {};

package/lib/git/gitUtilities.js

@@ -0,0 +1,286 @@
+"use strict";
+//
+// Assorted other git utilities
+// (could be split into separate files later if desired)
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAllTrackedFiles = exports.getDefaultBranch = exports.parseRemoteBranch = exports.getRemoteBranch = exports.getParentBranch = exports.revertLocalChanges = exports.stageAndCommit = exports.commit = exports.stage = exports.init = exports.getFileAddedHash = exports.getCurrentHash = exports.getShortBranchName = exports.getFullBranchRef = exports.getBranchName = exports.getUserEmail = exports.getRecentCommitMessages = exports.getStagedChanges = exports.getChangesBetweenRefs = exports.getBranchChanges = exports.getChanges = exports.getUnstagedChanges = exports.fetchRemoteBranch = exports.fetchRemote = exports.getUntrackedChanges = void 0;
+const git_1 = require("./git");
+function getUntrackedChanges(cwd) {
+    try {
+        const results = (0, git_1.git)(["status", "--short"], { cwd });
+        if (!results.success || !results.stdout) {
+            return [];
+        }
+        const lines = results.stdout.split(/[\r\n]+/).filter((line) => line);
+        const untracked = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line[0] === " " || line[0] === "?") {
+                untracked.push(line.substring(3));
+            }
+            else if (line[0] === "R") {
+                i++;
+            }
+        }
+        return untracked;
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about untracked changes`, e);
+    }
+}
+exports.getUntrackedChanges = getUntrackedChanges;
+function fetchRemote(remote, cwd) {
+    const results = (0, git_1.git)(["fetch", "--", remote], { cwd });
+    if (!results.success) {
+        throw new git_1.GitError(`Cannot fetch remote "${remote}"`);
+    }
+}
+exports.fetchRemote = fetchRemote;
+function fetchRemoteBranch(remote, remoteBranch, cwd) {
+    const results = (0, git_1.git)(["fetch", "--", remote, remoteBranch], { cwd });
+    if (!results.success) {
+        throw new git_1.GitError(`Cannot fetch branch "${remoteBranch}" from remote "${remote}"`);
+    }
+}
+exports.fetchRemoteBranch = fetchRemoteBranch;
+/**
+ * Gets all the changes that have not been staged yet
+ * @param cwd
+ */
+function getUnstagedChanges(cwd) {
+    try {
+        return processGitOutput((0, git_1.git)(["--no-pager", "diff", "--name-only", "--relative"], { cwd }));
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about unstaged changes`, e);
+    }
+}
+exports.getUnstagedChanges = getUnstagedChanges;
+function getChanges(branch, cwd) {
+    try {
+        return processGitOutput((0, git_1.git)(["--no-pager", "diff", "--relative", "--name-only", branch + "..."], { cwd }));
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about changes`, e);
+    }
+}
+exports.getChanges = getChanges;
+/**
+ * Gets all the changes between the branch and the merge-base
+ */
+function getBranchChanges(branch, cwd) {
+    return getChangesBetweenRefs(branch, "", [], "", cwd);
+}
+exports.getBranchChanges = getBranchChanges;
+function getChangesBetweenRefs(fromRef, toRef, options, pattern, cwd) {
+    try {
+        return processGitOutput((0, git_1.git)([
+            "--no-pager",
+            "diff",
+            "--name-only",
+            "--relative",
+            ...options,
+            `${fromRef}...${toRef}`,
+            ...(pattern ? ["--", pattern] : []),
+        ], { cwd }));
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about change between refs changes (${fromRef} to ${toRef})`, e);
+    }
+}
+exports.getChangesBetweenRefs = getChangesBetweenRefs;
+function getStagedChanges(cwd) {
+    try {
+        return processGitOutput((0, git_1.git)(["--no-pager", "diff", "--relative", "--staged", "--name-only"], { cwd }));
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about staged changes`, e);
+    }
+}
+exports.getStagedChanges = getStagedChanges;
+function getRecentCommitMessages(branch, cwd) {
+    try {
+        const results = (0, git_1.git)(["log", "--decorate", "--pretty=format:%s", `${branch}..HEAD`], { cwd });
+        if (!results.success) {
+            return [];
+        }
+        return results.stdout.split(/\n/).map((line) => line.trim());
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about recent commits`, e);
+    }
+}
+exports.getRecentCommitMessages = getRecentCommitMessages;
+function getUserEmail(cwd) {
+    try {
+        const results = (0, git_1.git)(["config", "user.email"], { cwd });
+        return results.success ? results.stdout : null;
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot gather information about user.email`, e);
+    }
+}
+exports.getUserEmail = getUserEmail;
+function getBranchName(cwd) {
+    try {
+        const results = (0, git_1.git)(["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+        return results.success ? results.stdout : null;
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot get branch name`, e);
+    }
+}
+exports.getBranchName = getBranchName;
+function getFullBranchRef(branch, cwd) {
+    const showRefResults = (0, git_1.git)(["show-ref", "--heads", branch], { cwd });
+    return showRefResults.success ? showRefResults.stdout.split(" ")[1] : null;
+}
+exports.getFullBranchRef = getFullBranchRef;
+function getShortBranchName(fullBranchRef, cwd) {
+    const showRefResults = (0, git_1.git)(["name-rev", "--name-only", fullBranchRef], {
+        cwd,
+    });
+    return showRefResults.success ? showRefResults.stdout : null;
+}
+exports.getShortBranchName = getShortBranchName;
+function getCurrentHash(cwd) {
+    try {
+        const results = (0, git_1.git)(["rev-parse", "HEAD"], { cwd });
+        return results.success ? results.stdout : null;
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot get current git hash`, e);
+    }
+}
+exports.getCurrentHash = getCurrentHash;
+/**
+ * Get the commit hash in which the file was first added.
+ */
+function getFileAddedHash(filename, cwd) {
+    const results = (0, git_1.git)(["rev-list", "HEAD", filename], { cwd });
+    if (results.success) {
+        return results.stdout.trim().split("\n").slice(-1)[0];
+    }
+    return undefined;
+}
+exports.getFileAddedHash = getFileAddedHash;
+function init(cwd, email, username) {
+    (0, git_1.git)(["init"], { cwd });
+    const configLines = (0, git_1.git)(["config", "--list"], { cwd }).stdout.split("\n");
+    if (!configLines.find((line) => line.includes("user.name"))) {
+        if (!username) {
+            throw new git_1.GitError("must include a username when initializing git repo");
+        }
+        (0, git_1.git)(["config", "user.name", username], { cwd });
+    }
+    if (!configLines.find((line) => line.includes("user.email"))) {
+        if (!email) {
+            throw new Error("must include a email when initializing git repo");
+        }
+        (0, git_1.git)(["config", "user.email", email], { cwd });
+    }
+}
+exports.init = init;
+function stage(patterns, cwd) {
+    try {
+        patterns.forEach((pattern) => {
+            (0, git_1.git)(["add", pattern], { cwd });
+        });
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot stage changes`, e);
+    }
+}
+exports.stage = stage;
+function commit(message, cwd, options = []) {
+    try {
+        const commitResults = (0, git_1.git)(["commit", "-m", message, ...options], { cwd });
+        if (!commitResults.success) {
+            throw new Error(`Cannot commit changes: ${commitResults.stdout} ${commitResults.stderr}`);
+        }
+    }
+    catch (e) {
+        throw new git_1.GitError(`Cannot commit changes`, e);
+    }
+}
+exports.commit = commit;
+function stageAndCommit(patterns, message, cwd, commitOptions = []) {
+    stage(patterns, cwd);
+    commit(message, cwd, commitOptions);
+}
+exports.stageAndCommit = stageAndCommit;
+function revertLocalChanges(cwd) {
+    const stash = `workspace-tools_${new Date().getTime()}`;
+    (0, git_1.git)(["stash", "push", "-u", "-m", stash], { cwd });
+    const results = (0, git_1.git)(["stash", "list"]);
+    if (results.success) {
+        const lines = results.stdout.split(/\n/);
+        const foundLine = lines.find((line) => line.includes(stash));
+        if (foundLine) {
+            const matched = foundLine.match(/^[^:]+/);
+            if (matched) {
+                (0, git_1.git)(["stash", "drop", matched[0]]);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+exports.revertLocalChanges = revertLocalChanges;
+function getParentBranch(cwd) {
+    const branchName = getBranchName(cwd);
+    if (!branchName || branchName === "HEAD") {
+        return null;
+    }
+    const showBranchResult = (0, git_1.git)(["show-branch", "-a"], { cwd });
+    if (showBranchResult.success) {
+        const showBranchLines = showBranchResult.stdout.split(/\n/);
+        const parentLine = showBranchLines.find((line) => line.includes("*") && !line.includes(branchName) && !line.includes("publish_"));
+        const matched = parentLine === null || parentLine === void 0 ? void 0 : parentLine.match(/\[(.*)\]/);
+        return matched ? matched[1] : null;
+    }
+    return null;
+}
+exports.getParentBranch = getParentBranch;
+function getRemoteBranch(branch, cwd) {
+    const results = (0, git_1.git)(["rev-parse", "--abbrev-ref", "--symbolic-full-name", `${branch}@\{u\}`], { cwd });
+    if (results.success) {
+        return results.stdout.trim();
+    }
+    return null;
+}
+exports.getRemoteBranch = getRemoteBranch;
+function parseRemoteBranch(branch) {
+    const firstSlashPos = branch.indexOf("/", 0);
+    const remote = branch.substring(0, firstSlashPos);
+    const remoteBranch = branch.substring(firstSlashPos + 1);
+    return {
+        remote,
+        remoteBranch,
+    };
+}
+exports.parseRemoteBranch = parseRemoteBranch;
+/**
+ * Gets the default branch based on `git config init.defaultBranch`, falling back to `master`.
+ */
+function getDefaultBranch(cwd) {
+    const result = (0, git_1.git)(["config", "init.defaultBranch"], { cwd });
+    // Default to the legacy 'master' for backwards compat and old git clients
+    return result.success ? result.stdout.trim() : "master";
+}
+exports.getDefaultBranch = getDefaultBranch;
+function listAllTrackedFiles(patterns, cwd) {
+    const results = (0, git_1.git)(["ls-files", ...patterns], { cwd });
+    return results.success ? results.stdout.split(/\n/) : [];
+}
+exports.listAllTrackedFiles = listAllTrackedFiles;
+function processGitOutput(output) {
+    if (!output.success) {
+        return [];
+    }
+    return output.stdout
+        .split(/\n/)
+        .map((line) => line.trim())
+        .filter((line) => !!line && !line.includes("node_modules"));
+}

package/lib/git/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./git";
+export * from "./getDefaultRemote";
+export * from "./getDefaultRemoteBranch";
+export * from "./gitUtilities";

package/lib/git/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./git"), exports);
+__exportStar(require("./getDefaultRemote"), exports);
+__exportStar(require("./getDefaultRemoteBranch"), exports);
+__exportStar(require("./gitUtilities"), exports);
+// getRepositoryName is not currently exported; could be changed if it would be useful externally

package/lib/helpers/setupFixture.d.ts

@@ -1,7 +1,13 @@
+import { PackageInfo } from "../types/PackageInfo";
 /**
  * Create a temp directory containing the given fixture name in a git repo.
  * Be sure to call `cleanupFixtures()` after all tests to clean up temp directories.
  */
-export declare function setupFixture(fixtureName: string): string;
+export declare function setupFixture(fixtureName?: string): string;
+/**
+ * `tmp` is not always reliable about cleanup even with appropriate options, so it's recommended to
+ * call this function in `afterAll`.
+ */
 export declare function cleanupFixtures(): void;
-export declare function setupLocalRemote(cwd: string, remoteName: string, fixtureName: string): void;
+export declare function setupPackageJson(cwd: string, packageJson?: Partial<PackageInfo>): void;
+export declare function setupLocalRemote(cwd: string, remoteName: string, fixtureName?: string): void;

package/lib/helpers/setupFixture.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupLocalRemote = exports.cleanupFixtures = exports.setupFixture = void 0;
+exports.setupLocalRemote = exports.setupPackageJson = exports.cleanupFixtures = exports.setupFixture = void 0;
 const path_1 = __importDefault(require("path"));
 const find_up_1 = __importDefault(require("find-up"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -13,6 +13,7 @@ const git_1 = require("../git");
 // So we attempt to use its built-in cleanup mechanisms, but tests should ideally do their own cleanup too.
 tmp_1.default.setGracefulCleanup();
 let fixturesRoot;
+// Temp directories are created under tempRoot.name with incrementing numeric sub-directories
 let tempRoot;
 let tempNumber = 0;
 /**
@@ -20,20 +21,23 @@ let tempNumber = 0;
  * Be sure to call `cleanupFixtures()` after all tests to clean up temp directories.
  */
 function setupFixture(fixtureName) {
-    if (!fixturesRoot) {
-        fixturesRoot = find_up_1.default.sync("__fixtures__", { cwd: __dirname, type: "directory" });
-    }
-    const fixturePath = path_1.default.join(fixturesRoot, fixtureName);
-    if (!fs_extra_1.default.existsSync(fixturePath)) {
-        throw new Error(`Couldn't find fixture "${fixtureName}" under "${fixturesRoot}"`);
+    let fixturePath;
+    if (fixtureName) {
+        if (!fixturesRoot) {
+            fixturesRoot = find_up_1.default.sync("__fixtures__", { cwd: __dirname, type: "directory" });
+        }
+        fixturePath = path_1.default.join(fixturesRoot, fixtureName);
+        if (!fs_extra_1.default.existsSync(fixturePath)) {
+            throw new Error(`Couldn't find fixture "${fixtureName}" under "${fixturesRoot}"`);
+        }
     }
     if (!tempRoot) {
         // Create a shared root temp directory for fixture files
         tempRoot = tmp_1.default.dirSync({ unsafeCleanup: true }); // clean up even if files are left
     }
-    const cwd = path_1.default.join(tempRoot.name, String(tempNumber++), fixtureName);
+    // Make the directory and git init
+    const cwd = path_1.default.join(tempRoot.name, String(tempNumber++), fixtureName || "");
     fs_extra_1.default.mkdirpSync(cwd);
-    fs_extra_1.default.copySync(fixturePath, cwd);
     (0, git_1.init)(cwd, "test@test.email", "test user");
     // Ensure GPG signing doesn't interfere with tests
     (0, git_1.gitFailFast)(["config", "commit.gpgsign", "false"], { cwd });
@@ -43,10 +47,18 @@ function setupFixture(fixtureName) {
     // a 'fixed' value for our tests, regardless of user configuration
     (0, git_1.gitFailFast)(["symbolic-ref", "HEAD", "refs/heads/main"], { cwd });
     (0, git_1.gitFailFast)(["config", "init.defaultBranch", "main"], { cwd });
-    (0, git_1.stageAndCommit)(["."], "test", cwd);
+    // Copy and commit the fixture if requested
+    if (fixturePath) {
+        fs_extra_1.default.copySync(fixturePath, cwd);
+        (0, git_1.stageAndCommit)(["."], "test", cwd);
+    }
     return cwd;
 }
 exports.setupFixture = setupFixture;
+/**
+ * `tmp` is not always reliable about cleanup even with appropriate options, so it's recommended to
+ * call this function in `afterAll`.
+ */
 function cleanupFixtures() {
     if (tempRoot) {
         tempRoot.removeCallback();
@@ -54,16 +66,21 @@ function cleanupFixtures() {
     }
 }
 exports.cleanupFixtures = cleanupFixtures;
+function setupPackageJson(cwd, packageJson = {}) {
+    const pkgJsonPath = path_1.default.join(cwd, "package.json");
+    let oldPackageJson;
+    if (fs_extra_1.default.existsSync(pkgJsonPath)) {
+        oldPackageJson = JSON.parse(fs_extra_1.default.readFileSync(pkgJsonPath, "utf-8"));
+    }
+    fs_extra_1.default.writeFileSync(pkgJsonPath, JSON.stringify(Object.assign(Object.assign({}, oldPackageJson), packageJson), null, 2));
+}
+exports.setupPackageJson = setupPackageJson;
 function setupLocalRemote(cwd, remoteName, fixtureName) {
     // Create a seperate repo and configure it as a remote
     const remoteCwd = setupFixture(fixtureName);
     const remoteUrl = remoteCwd.replace(/\\/g, "/");
     (0, git_1.gitFailFast)(["remote", "add", remoteName, remoteUrl], { cwd });
     // Configure url in package.json
-    const pkgJsonPath = path_1.default.join(cwd, "package.json");
-    const pkgJson = JSON.parse(fs_extra_1.default.readFileSync(pkgJsonPath, "utf-8"));
-    fs_extra_1.default.writeFileSync(pkgJsonPath, JSON.stringify(Object.assign(Object.assign({}, pkgJson), { repository: {
-            url: remoteUrl,
-        } }), null, 2));
+    setupPackageJson(cwd, { repository: { url: remoteUrl, type: "git" } });
 }
 exports.setupLocalRemote = setupLocalRemote;

package/lib/types/PackageInfo.d.ts

@@ -14,11 +14,14 @@ export interface PackageInfo {
     private?: boolean;
     group?: string;
     scripts?: {
-        [dep: string]: string;
+        [scriptName: string]: string;
     };
-    [key: string]: string | boolean | string[] | {
-        [dep: string]: string;
-    } | undefined;
+    repository?: string | {
+        type: string;
+        url: string;
+        directory?: string;
+    };
+    [key: string]: any;
 }
 export interface PackageInfos {
     [pkgName: string]: PackageInfo;

package/lib/workspaces/getChangedPackages.js

@@ -50,7 +50,7 @@ exports.getChangedPackagesBetweenRefs = getChangedPackagesBetweenRefs;
  * @returns string[] of package names that have changed
  */
 function getChangedPackages(cwd, target, ignoreGlobs = []) {
-    const targetBranch = target || (0, git_1.getDefaultRemoteBranch)(undefined, cwd);
+    const targetBranch = target || (0, git_1.getDefaultRemoteBranch)({ cwd });
     let changes = [
         ...new Set([
             ...((0, git_1.getUntrackedChanges)(cwd) || []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workspace-tools",
-  "version": "0.23.3",
+  "version": "0.24.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/lib/git.js

@@ -1,442 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listAllTrackedFiles = exports.getDefaultRemote = exports.getDefaultBranch = exports.getDefaultRemoteBranch = exports.parseRemoteBranch = exports.getRemoteBranch = exports.getParentBranch = exports.revertLocalChanges = exports.stageAndCommit = exports.commit = exports.stage = exports.init = exports.getFileAddedHash = exports.getCurrentHash = exports.getShortBranchName = exports.getFullBranchRef = exports.getBranchName = exports.getUserEmail = exports.getRecentCommitMessages = exports.getStagedChanges = exports.getChangesBetweenRefs = exports.getBranchChanges = exports.getChanges = exports.getUnstagedChanges = exports.fetchRemoteBranch = exports.fetchRemote = exports.getUntrackedChanges = exports.gitFailFast = exports.git = exports.addGitObserver = void 0;
-const child_process_1 = require("child_process");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const paths_1 = require("./paths");
-const git_url_parse_1 = __importDefault(require("git-url-parse"));
-function gitError(message, e) {
-    if (e && e instanceof Error) {
-        return new Error(`${message}: ${e.message}`);
-    }
-    return new Error(message);
-}
-/**
- * A global maxBuffer override for all git operations.
- * Bumps up the default to 500MB instead of 1MB.
- * Override this value with the `GIT_MAX_BUFFER` environment variable.
- */
-const defaultMaxBuffer = process.env.GIT_MAX_BUFFER ? parseInt(process.env.GIT_MAX_BUFFER) : 500 * 1024 * 1024;
-const observers = [];
-let observing;
-/**
- * Adds an observer for the git operations, e.g. for testing
- * @param observer
- */
-function addGitObserver(observer) {
-    observers.push(observer);
-}
-exports.addGitObserver = addGitObserver;
-/**
- * Runs git command - use this for read-only commands
- */
-function git(args, options) {
-    const results = (0, child_process_1.spawnSync)("git", args, Object.assign({ maxBuffer: defaultMaxBuffer }, options));
-    const output = {
-        stderr: results.stderr.toString().trimRight(),
-        stdout: results.stdout.toString().trimRight(),
-        success: results.status === 0
-    };
-    // notify observers, flipping the observing bit to prevent infinite loops
-    if (!observing) {
-        observing = true;
-        for (const observer of observers) {
-            observer(args, output);
-        }
-        observing = false;
-    }
-    return output;
-}
-exports.git = git;
-/**
- * Runs git command - use this for commands that make changes to the filesystem
- */
-function gitFailFast(args, options) {
-    const gitResult = git(args, options);
-    if (!gitResult.success) {
-        process.exitCode = 1;
-        throw gitError(`CRITICAL ERROR: running git command: git ${args.join(" ")}!
-    ${gitResult.stdout && gitResult.stdout.toString().trimRight()}
-    ${gitResult.stderr && gitResult.stderr.toString().trimRight()}`);
-    }
-}
-exports.gitFailFast = gitFailFast;
-function getUntrackedChanges(cwd) {
-    try {
-        const results = git(["status", "--short"], { cwd });
-        if (!results.success) {
-            return [];
-        }
-        const changes = results.stdout;
-        if (changes.length == 0) {
-            return [];
-        }
-        const lines = changes.split(/[\r\n]+/).filter((line) => line) || [];
-        const untracked = [];
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (line[0] === " " || line[0] === "?") {
-                untracked.push(line.substr(3));
-            }
-            else if (line[0] === "R") {
-                i++;
-            }
-        }
-        return untracked;
-    }
-    catch (e) {
-        throw gitError(`Cannot gather information about untracked changes`, e);
-    }
-}
-exports.getUntrackedChanges = getUntrackedChanges;
-function fetchRemote(remote, cwd) {
-    const results = git(["fetch", "--", remote], { cwd });
-    if (!results.success) {
-        throw gitError(`Cannot fetch remote: ${remote}`);
-    }
-}
-exports.fetchRemote = fetchRemote;
-function fetchRemoteBranch(remote, remoteBranch, cwd) {
-    const results = git(["fetch", "--", remote, remoteBranch], { cwd });
-    if (!results.success) {
-        throw gitError(`Cannot fetch remote: ${remote} ${remoteBranch}`);
-    }
-}
-exports.fetchRemoteBranch = fetchRemoteBranch;
-/**
- * Gets all the changes that have not been staged yet
- * @param cwd
- */
-function getUnstagedChanges(cwd) {
-    try {
-        return processGitOutput(git(["--no-pager", "diff", "--name-only", "--relative"], { cwd }));
-    }
-    catch (e) {
-        throw gitError(`Cannot gather information about unstaged changes`, e);
-    }
-}
-exports.getUnstagedChanges = getUnstagedChanges;
-function getChanges(branch, cwd) {
-    try {
-        return processGitOutput(git(["--no-pager", "diff", "--relative", "--name-only", branch + "..."], { cwd }));
-    }
-    catch (e) {
-        throw gitError(`Cannot gather information about changes`, e);
-    }
-}
-exports.getChanges = getChanges;
-/**
- * Gets all the changes between the branch and the merge-base
- * @param branch
- * @param cwd
- */
-function getBranchChanges(branch, cwd) {
-    return getChangesBetweenRefs(branch, "", [], "", cwd);
-}
-exports.getBranchChanges = getBranchChanges;
-function getChangesBetweenRefs(fromRef, toRef, options, pattern, cwd) {
-    try {
-        return processGitOutput(git(["--no-pager", "diff", "--name-only", "--relative", ...options, `${fromRef}...${toRef}`, ...(pattern ? ["--", pattern] : [])], {
-            cwd,
-        }));
-    }
-    catch (e) {
-        throw gitError(`Cannot gather information about change between refs changes (${fromRef} to ${toRef})`, e);
-    }
-}
-exports.getChangesBetweenRefs = getChangesBetweenRefs;
-function getStagedChanges(cwd) {
-    try {
-        return processGitOutput(git(["--no-pager", "diff", "--relative", "--staged", "--name-only"], { cwd }));
-    }
-    catch (e) {
-        throw gitError(`Cannot gather information about staged changes`, e);
-    }
-}
-exports.getStagedChanges = getStagedChanges;
-function getRecentCommitMessages(branch, cwd) {
-    try {
-        const results = git(["log", "--decorate", "--pretty=format:%s", `${branch}..HEAD`], { cwd });
-        if (!results.success) {
-            return [];
-        }
-        let changes = results.stdout;
-        let lines = changes.split(/\n/) || [];
-        return lines.map((line) => line.trim());
-    }
-    catch (e) {
-        throw gitError(`Cannot gather information about recent commits`, e);
-    }
-}
-exports.getRecentCommitMessages = getRecentCommitMessages;
-function getUserEmail(cwd) {
-    try {
-        const results = git(["config", "user.email"], { cwd });
-        if (!results.success) {
-            return null;
-        }
-        return results.stdout;
-    }
-    catch (e) {
-        throw gitError(`Cannot gather information about user.email`, e);
-    }
-}
-exports.getUserEmail = getUserEmail;
-function getBranchName(cwd) {
-    try {
-        const results = git(["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
-        if (results.success) {
-            return results.stdout;
-        }
-    }
-    catch (e) {
-        throw gitError(`Cannot get branch name`, e);
-    }
-    return null;
-}
-exports.getBranchName = getBranchName;
-function getFullBranchRef(branch, cwd) {
-    const showRefResults = git(["show-ref", "--heads", branch], { cwd });
-    if (showRefResults.success) {
-        return showRefResults.stdout.split(" ")[1];
-    }
-    return null;
-}
-exports.getFullBranchRef = getFullBranchRef;
-function getShortBranchName(fullBranchRef, cwd) {
-    const showRefResults = git(["name-rev", "--name-only", fullBranchRef], {
-        cwd,
-    });
-    if (showRefResults.success) {
-        return showRefResults.stdout;
-    }
-    return null;
-}
-exports.getShortBranchName = getShortBranchName;
-function getCurrentHash(cwd) {
-    try {
-        const results = git(["rev-parse", "HEAD"], { cwd });
-        if (results.success) {
-            return results.stdout;
-        }
-    }
-    catch (e) {
-        throw gitError(`Cannot get current git hash`, e);
-    }
-    return null;
-}
-exports.getCurrentHash = getCurrentHash;
-/**
- * Get the commit hash in which the file was first added.
- */
-function getFileAddedHash(filename, cwd) {
-    const results = git(["rev-list", "HEAD", filename], { cwd });
-    if (results.success) {
-        return results.stdout.trim().split("\n").slice(-1)[0];
-    }
-    return undefined;
-}
-exports.getFileAddedHash = getFileAddedHash;
-function init(cwd, email, username) {
-    git(["init"], { cwd });
-    const configLines = git(["config", "--list"], { cwd }).stdout.split("\n");
-    if (!configLines.find((line) => line.includes("user.name"))) {
-        if (!username) {
-            throw gitError("must include a username when initializing git repo");
-        }
-        git(["config", "user.name", username], { cwd });
-    }
-    if (!configLines.find((line) => line.includes("user.email"))) {
-        if (!email) {
-            throw new Error("must include a email when initializing git repo");
-        }
-        git(["config", "user.email", email], { cwd });
-    }
-}
-exports.init = init;
-function stage(patterns, cwd) {
-    try {
-        patterns.forEach((pattern) => {
-            git(["add", pattern], { cwd });
-        });
-    }
-    catch (e) {
-        throw gitError(`Cannot stage changes`, e);
-    }
-}
-exports.stage = stage;
-function commit(message, cwd, options = []) {
-    try {
-        const commitResults = git(["commit", "-m", message, ...options], { cwd });
-        if (!commitResults.success) {
-            throw new Error(`Cannot commit changes: ${commitResults.stdout} ${commitResults.stderr}`);
-        }
-    }
-    catch (e) {
-        throw gitError(`Cannot commit changes`, e);
-    }
-}
-exports.commit = commit;
-function stageAndCommit(patterns, message, cwd, commitOptions = []) {
-    stage(patterns, cwd);
-    commit(message, cwd, commitOptions);
-}
-exports.stageAndCommit = stageAndCommit;
-function revertLocalChanges(cwd) {
-    const stash = `beachball_${new Date().getTime()}`;
-    git(["stash", "push", "-u", "-m", stash], { cwd });
-    const results = git(["stash", "list"]);
-    if (results.success) {
-        const lines = results.stdout.split(/\n/);
-        const foundLine = lines.find((line) => line.includes(stash));
-        if (foundLine) {
-            const matched = foundLine.match(/^[^:]+/);
-            if (matched) {
-                git(["stash", "drop", matched[0]]);
-                return true;
-            }
-        }
-    }
-    return false;
-}
-exports.revertLocalChanges = revertLocalChanges;
-function getParentBranch(cwd) {
-    const branchName = getBranchName(cwd);
-    if (!branchName || branchName === "HEAD") {
-        return null;
-    }
-    const showBranchResult = git(["show-branch", "-a"], { cwd });
-    if (showBranchResult.success) {
-        const showBranchLines = showBranchResult.stdout.split(/\n/);
-        const parentLine = showBranchLines.find((line) => line.indexOf("*") > -1 && line.indexOf(branchName) < 0 && line.indexOf("publish_") < 0);
-        if (!parentLine) {
-            return null;
-        }
-        const matched = parentLine.match(/\[(.*)\]/);
-        if (!matched) {
-            return null;
-        }
-        return matched[1];
-    }
-    return null;
-}
-exports.getParentBranch = getParentBranch;
-function getRemoteBranch(branch, cwd) {
-    const results = git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", `${branch}@\{u\}`], { cwd });
-    if (results.success) {
-        return results.stdout.trim();
-    }
-    return null;
-}
-exports.getRemoteBranch = getRemoteBranch;
-function parseRemoteBranch(branch) {
-    const firstSlashPos = branch.indexOf("/", 0);
-    const remote = branch.substring(0, firstSlashPos);
-    const remoteBranch = branch.substring(firstSlashPos + 1);
-    return {
-        remote,
-        remoteBranch,
-    };
-}
-exports.parseRemoteBranch = parseRemoteBranch;
-function normalizeRepoUrl(repositoryUrl) {
-    try {
-        const parsed = (0, git_url_parse_1.default)(repositoryUrl);
-        return parsed
-            .toString("https")
-            .replace(/\.git$/, "")
-            .toLowerCase();
-    }
-    catch (e) {
-        return "";
-    }
-}
-function getDefaultRemoteBranch(branch, cwd) {
-    const defaultRemote = getDefaultRemote(cwd);
-    const showRemote = git(["remote", "show", defaultRemote], { cwd });
-    /**
-     * The `showRemote` returns something like this in stdout:
-     *
-     * * remote origin
-     *   Fetch URL: ../monorepo-upstream/
-     *   Push  URL: ../monorepo-upstream/
-     *   HEAD branch: main
-     *
-     */
-    const headBranchLine = showRemote.stdout.split(/\n/).find((line) => line.includes("HEAD branch"));
-    let remoteDefaultBranch;
-    if (headBranchLine) {
-        remoteDefaultBranch = headBranchLine.replace(/^\s*HEAD branch:\s+/, "");
-    }
-    branch = branch || remoteDefaultBranch || getDefaultBranch(cwd);
-    return `${defaultRemote}/${branch}`;
-}
-exports.getDefaultRemoteBranch = getDefaultRemoteBranch;
-function getDefaultBranch(cwd) {
-    const result = git(["config", "init.defaultBranch"], { cwd });
-    if (!result.success) {
-        // Default to the legacy 'master' for backwards compat and old git clients
-        return "master";
-    }
-    return result.stdout.trim();
-}
-exports.getDefaultBranch = getDefaultBranch;
-function getDefaultRemote(cwd) {
-    let packageJson;
-    try {
-        packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join((0, paths_1.findGitRoot)(cwd), "package.json")).toString());
-    }
-    catch (e) {
-        throw new Error("invalid package.json detected");
-    }
-    const { repository } = packageJson;
-    let repositoryUrl = "";
-    if (typeof repository === "string") {
-        repositoryUrl = repository;
-    }
-    else if (repository && repository.url) {
-        repositoryUrl = repository.url;
-    }
-    const normalizedUrl = normalizeRepoUrl(repositoryUrl);
-    const remotesResult = git(["remote", "-v"], { cwd });
-    if (remotesResult.success) {
-        const allRemotes = {};
-        remotesResult.stdout.split("\n").forEach((line) => {
-            const parts = line.split(/\s+/);
-            allRemotes[normalizeRepoUrl(parts[1])] = parts[0];
-        });
-        if (Object.keys(allRemotes).length > 0) {
-            const remote = allRemotes[normalizedUrl];
-            if (remote) {
-                return remote;
-            }
-        }
-    }
-    return "origin";
-}
-exports.getDefaultRemote = getDefaultRemote;
-function listAllTrackedFiles(patterns, cwd) {
-    if (patterns) {
-        const results = git(["ls-files", ...patterns], { cwd });
-        if (results.success) {
-            return results.stdout.split(/\n/);
-        }
-    }
-    return [];
-}
-exports.listAllTrackedFiles = listAllTrackedFiles;
-function processGitOutput(output) {
-    if (!output.success) {
-        return [];
-    }
-    let stdout = output.stdout;
-    let lines = stdout.split(/\n/) || [];
-    return lines
-        .filter((line) => line.trim() !== "")
-        .map((line) => line.trim())
-        .filter((line) => !line.includes("node_modules"));
-}