workspace-tools 0.38.6 → 0.40.2

package/lib/git/gitUtilities.js

@@ -5,57 +5,59 @@
 //
 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 config_1 = require("./config");
 const git_1 = require("./git");
-/**
- * Get a list of files with untracked changes.
- * Throws an error on failure.
- *
- * @returns An array of file paths with untracked changes
- */
-function getUntrackedChanges(cwd) {
-    try {
-        return processGitOutput((0, git_1.git)(["ls-files", "--others", "--exclude-standard"], { cwd }));
-    }
-    catch (e) {
-        throw new git_1.GitError(`Cannot gather information about untracked changes`, e);
-    }
+const diffArgs = ["--no-pager", "diff", "--name-only", "--relative"];
+function getUntrackedChanges(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
+    const results = (0, git_1.git)(["ls-files", "--others", "--exclude-standard"], {
+        description: "Gathering information about untracked changes",
+        throwOnError: true,
+        ...options,
+    });
+    return (0, git_1.processGitOutput)(results, { excludeNodeModules: true });
 }
 exports.getUntrackedChanges = getUntrackedChanges;
-/**
- * Fetch from the given remote.
- * Throws an error on failure.
- */
-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}"`);
-    }
+function fetchRemote(remoteOrOptions, cwd) {
+    const { remote, remoteBranch, options, ...gitOptions } = typeof remoteOrOptions === "string"
+        ? ({ remote: remoteOrOptions, cwd: cwd })
+        : remoteOrOptions;
+    if (remoteBranch && !remote) {
+        throw new Error('Must provide "remote" when using "remoteBranch" option');
+    }
+    const fetchArgs = [
+        "fetch",
+        "--",
+        ...(remote ? [remote] : []),
+        ...(remoteBranch ? [remoteBranch] : []),
+        ...(options || []),
+    ];
+    (0, git_1.git)(fetchArgs, {
+        description: remote
+            ? `Fetching ${remoteBranch ? `branch "${remoteBranch}" from ` : ""}remote "${remote}"`
+            : "Fetching all remotes",
+        throwOnError: true,
+        ...gitOptions,
+    });
 }
 exports.fetchRemote = fetchRemote;
 /**
- * Fetch from the given remote and branch.
- * Throws an error on failure.
+ * Fetch from the given remote and branch. Throws an error on failure.
+ * @deprecated Use `fetchRemote({ remote, remoteBranch, cwd })`
  */
+// TODO: move to fetch.ts
 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}"`);
-    }
+    fetchRemote({ remote, remoteBranch, cwd, throwOnError: true });
 }
 exports.fetchRemoteBranch = fetchRemoteBranch;
-/**
- * Gets file paths with changes that have not been staged yet.
- * Throws an error on failure.
- *
- * @returns An array of relative file paths with unstaged changes
- */
-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);
-    }
+function getUnstagedChanges(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
+    const results = (0, git_1.git)(diffArgs, {
+        description: "Gathering information about unstaged changes",
+        throwOnError: true,
+        ...options,
+    });
+    return (0, git_1.processGitOutput)(results, { excludeNodeModules: true });
 }
 exports.getUnstagedChanges = getUnstagedChanges;
 /**
@@ -63,259 +65,157 @@ exports.getUnstagedChanges = getUnstagedChanges;
  * Throws an error on failure.
  *
  * @returns An array of relative file paths that have changed
+ * @deprecated Use `getBranchChanges({ branch, cwd })`
  */
+// TODO: move to getChanges.ts
 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);
-    }
+    return getChangesBetweenRefs({ fromRef: branch, cwd, throwOnError: true });
 }
 exports.getChanges = getChanges;
-/**
- * Gets file paths with changes between the branch and the merge-base.
- *
- * @returns An array of relative file paths that have changed
- */
-function getBranchChanges(branch, cwd) {
-    return getChangesBetweenRefs(/*from*/ branch, /*to*/ "", /*options*/ [], /*file pattern*/ "", cwd);
+function getBranchChanges(branchOrOptions, cwd) {
+    const { branch, ...options } = typeof branchOrOptions === "string" ? { branch: branchOrOptions, cwd: cwd } : branchOrOptions;
+    return getChangesBetweenRefs({ fromRef: branch, throwOnError: true, ...options });
 }
 exports.getBranchChanges = getBranchChanges;
-/**
- * Gets file paths with changes between two git references (commits, branches, tags).
- * Throws an error on failure.
- *
- * @param fromRef - The starting reference
- * @param toRef - The ending reference
- * @param options - Additional git diff options
- * @param pattern - Optional file pattern to filter results
- * @param cwd - The working directory
- * @returns An array of file paths that have changed
- */
 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);
-    }
+    let gitOptions;
+    if (typeof fromRef === "string") {
+        gitOptions = { cwd: cwd };
+    }
+    else {
+        ({ fromRef, toRef, options, pattern, ...gitOptions } = fromRef);
+    }
+    const range = `${fromRef}...${toRef || ""}`;
+    const results = (0, git_1.git)([...diffArgs, ...(options || []), range, ...(pattern ? ["--", pattern] : [])], {
+        description: `Gathering information about changes between refs (${range})`,
+        throwOnError: true,
+        ...gitOptions,
+    });
+    return (0, git_1.processGitOutput)(results, { excludeNodeModules: true });
 }
 exports.getChangesBetweenRefs = getChangesBetweenRefs;
-/**
- * Gets all files with staged changes (files added to the index).
- * Throws an error on failure.
- *
- * @returns An array of relative file paths that have been staged
- */
-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);
-    }
+function getStagedChanges(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
+    const results = (0, git_1.git)([...diffArgs, "--staged"], {
+        description: "Gathering information about staged changes",
+        throwOnError: true,
+        ...options,
+    });
+    return (0, git_1.processGitOutput)(results, { excludeNodeModules: true });
 }
 exports.getStagedChanges = getStagedChanges;
-/**
- * Gets recent commit messages between the specified branch and HEAD.
- * Returns an empty array if the operation fails.
- *
- * @returns An array of commit message strings
- */
-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())
-            .filter((line) => !!line);
-    }
-    catch (e) {
-        throw new git_1.GitError(`Cannot gather information about recent commits`, e);
-    }
+function getRecentCommitMessages(branchOrOptions, cwd) {
+    const { branch, ...options } = typeof branchOrOptions === "string" ? { branch: branchOrOptions, cwd: cwd } : branchOrOptions;
+    const results = (0, git_1.git)(["log", "--decorate", "--pretty=format:%s", `${branch}..HEAD`], {
+        description: `Getting recent commit messages for branch "${branch}"`,
+        ...options,
+    });
+    return (0, git_1.processGitOutput)(results);
 }
 exports.getRecentCommitMessages = getRecentCommitMessages;
-/**
- * Gets the user email from the git config.
- * @returns The email string if found, null otherwise
- */
-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);
-    }
+function getUserEmail(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
+    return (0, config_1.getConfigValue)({ key: "user.email", ...options });
 }
 exports.getUserEmail = getUserEmail;
-/**
- * Gets the current branch name.
- * @returns The branch name if successful, null otherwise
- */
-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);
-    }
+function getBranchName(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
+    const results = (0, git_1.git)(["rev-parse", "--abbrev-ref", "HEAD"], {
+        description: "Getting current branch name",
+        ...options,
+    });
+    return results.success ? results.stdout : null;
 }
 exports.getBranchName = getBranchName;
-/**
- * Gets the full reference path for a given branch.
- * @param branch - The short branch name (e.g., `branch-name`)
- * @returns The full branch reference (e.g., `refs/heads/branch-name`) if found, null otherwise
- */
-function getFullBranchRef(branch, cwd) {
-    const showRefResults = (0, git_1.git)(["show-ref", "--heads", branch], { cwd });
+function getFullBranchRef(branchOrOptions, cwd) {
+    const { branch, ...options } = typeof branchOrOptions === "string" ? { branch: branchOrOptions, cwd: cwd } : branchOrOptions;
+    const showRefResults = (0, git_1.git)(["show-ref", "--heads", branch], options);
     return showRefResults.success ? showRefResults.stdout.split(" ")[1] : null;
 }
 exports.getFullBranchRef = getFullBranchRef;
-/**
- * Gets the short branch name from a full branch reference.
- * Note this may not work properly for the current branch.
- * @param fullBranchRef - The full branch reference (e.g., `refs/heads/branch-name`)
- * @returns The short branch name if successful, null otherwise
- */
-function getShortBranchName(fullBranchRef, cwd) {
-    const showRefResults = (0, git_1.git)(["name-rev", "--name-only", fullBranchRef], {
-        cwd,
-    });
-    return showRefResults.success ? showRefResults.stdout : null;
+function getShortBranchName(refOrOptions, cwd) {
+    const { fullBranchRef, ...options } = typeof refOrOptions === "string" ? { fullBranchRef: refOrOptions, cwd: cwd } : refOrOptions;
+    // The original command `git name-rev --name-only` returned unreliable results if multiple
+    // named refs point to the same commit as the branch.
+    const showRefResults = (0, git_1.git)(["rev-parse", "--abbrev-ref", fullBranchRef], options);
+    return showRefResults.success ? showRefResults.stdout || null : null;
 }
 exports.getShortBranchName = getShortBranchName;
-/**
- * Gets the current commit hash (SHA).
- * @returns The hash if successful, null otherwise
- */
-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);
-    }
+function getCurrentHash(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
+    const results = (0, git_1.git)(["rev-parse", "HEAD"], {
+        description: "Getting current git hash",
+        ...options,
+    });
+    return results.success ? results.stdout : null;
 }
 exports.getCurrentHash = getCurrentHash;
-/**
- * Get the commit hash in which the file was first added.
- * @returns The commit hash if found, undefined otherwise
- */
-function getFileAddedHash(filename, cwd) {
-    const results = (0, git_1.git)(["rev-list", "--max-count=1", "HEAD", filename], { cwd });
-    if (results.success) {
-        return results.stdout.trim();
-    }
-    return undefined;
+function getFileAddedHash(filenameOrOptions, cwd) {
+    const { filename, ...options } = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions, cwd: cwd } : filenameOrOptions;
+    const results = (0, git_1.git)(["rev-list", "--max-count=1", "HEAD", filename], options);
+    return results.success ? results.stdout.trim() : undefined;
 }
 exports.getFileAddedHash = getFileAddedHash;
-/**
- * Initializes a git repository in the specified directory.
- * Optionally sets user email and username if not already configured.
- * Throws an error if required email or username is not provided and not already configured.
- *
- * @param cwd - The directory to initialize the git repository in
- * @param email - Optional email to set in git config
- * @param username - Optional username to set in git config
- */
-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"))) {
+function init(cwdOrOptions, _email, _username) {
+    const { email, username, ...options } = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions, email: _email, username: _username } : cwdOrOptions;
+    (0, git_1.git)(["init"], { ...options, throwOnError: true });
+    if (!(0, config_1.getConfigValue)({ key: "user.name", ...options })) {
         if (!username) {
-            throw new git_1.GitError("must include a username when initializing git repo");
+            throw new Error("must include a username when initializing git repo");
         }
-        (0, git_1.git)(["config", "user.name", username], { cwd });
+        (0, git_1.git)(["config", "user.name", username], options);
     }
-    if (!configLines.find((line) => line.includes("user.email"))) {
+    if (!getUserEmail(options)) {
         if (!email) {
             throw new Error("must include a email when initializing git repo");
         }
-        (0, git_1.git)(["config", "user.email", email], { cwd });
+        (0, git_1.git)(["config", "user.email", email], options);
     }
 }
 exports.init = init;
-/**
- * Stages files matching the given patterns.
- */
-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);
+function stage(patternsOrOptions, cwd) {
+    const { patterns, ...options } = Array.isArray(patternsOrOptions)
+        ? { patterns: patternsOrOptions, cwd: cwd }
+        : patternsOrOptions;
+    for (const pattern of patterns) {
+        (0, git_1.git)(["add", pattern], { ...options, description: `Staging changes (git add ${pattern})` });
     }
 }
 exports.stage = stage;
-/**
- * Creates a commit with the given message and optional git commit options.
- * Throws an error on failure.
- *
- * @param message - The commit message
- * @param cwd - The working directory
- * @param options - Additional git commit options
- */
-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);
-    }
+function commit(messageOrOptions, _cwd, _options) {
+    const { message, options, ...gitOptions } = typeof messageOrOptions === "string"
+        ? { message: messageOrOptions, cwd: _cwd, options: _options }
+        : messageOrOptions;
+    (0, git_1.git)(["commit", "-m", message, ...(options || [])], {
+        throwOnError: true,
+        description: "Committing changes",
+        ...gitOptions,
+    });
 }
 exports.commit = commit;
-/**
- * Stages files matching the given patterns and creates a commit with the specified message.
- * Convenience function that combines `stage()` and `commit()`.
- * Throws an error on commit failure.
- *
- * @param patterns - File patterns to stage
- * @param message - The commit message
- * @param cwd - The working directory
- * @param commitOptions - Additional git commit options
- */
-function stageAndCommit(patterns, message, cwd, commitOptions = []) {
-    stage(patterns, cwd);
-    commit(message, cwd, commitOptions);
+function stageAndCommit(patternsOrOptions, message, cwd, commitOptions) {
+    const options = Array.isArray(patternsOrOptions)
+        ? { patterns: patternsOrOptions, message: message, cwd: cwd, options: commitOptions }
+        : patternsOrOptions;
+    stage(options);
+    commit(options);
 }
 exports.stageAndCommit = stageAndCommit;
-/**
- * Reverts all local changes (both staged and unstaged) by stashing them and then dropping the stash.
- * @returns True if the revert was successful, false otherwise
- */
-function revertLocalChanges(cwd) {
+function revertLocalChanges(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
     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 (!(0, git_1.git)(["stash", "push", "-u", "-m", stash], options).success) {
+        return false;
+    }
+    const results = (0, git_1.git)(["stash", "list"], options);
     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;
-            }
+        const matched = results.stdout
+            .split(/\n/)
+            .find((line) => line.includes(stash))
+            ?.match(/^[^:]+/);
+        if (matched) {
+            (0, git_1.git)(["stash", "drop", matched[0]], options);
+            return true;
         }
     }
     return false;
@@ -323,11 +223,11 @@ function revertLocalChanges(cwd) {
 exports.revertLocalChanges = revertLocalChanges;
 /**
  * Attempts to determine the parent branch of the current branch using `git show-branch`.
- *
  * @returns The parent branch name if found, null otherwise
+ * @deprecated Does not appear to be used
  */
 function getParentBranch(cwd) {
-    const branchName = getBranchName(cwd);
+    const branchName = getBranchName({ cwd });
     if (!branchName || branchName === "HEAD") {
         return null;
     }
@@ -341,75 +241,48 @@ function getParentBranch(cwd) {
     return null;
 }
 exports.getParentBranch = getParentBranch;
-/**
- * Gets the remote tracking branch for the specified branch.
- *
- * @returns The remote branch name (e.g., `origin/main`) if found, null otherwise
- */
-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;
+function getRemoteBranch(branchOrOptions, cwd) {
+    const options = typeof branchOrOptions === "string" ? { branch: branchOrOptions, cwd: cwd } : branchOrOptions;
+    const results = (0, git_1.git)(["rev-parse", "--abbrev-ref", "--symbolic-full-name", `${options.branch}@\{u\}`], options);
+    return results.success ? results.stdout.trim() : null;
 }
 exports.getRemoteBranch = getRemoteBranch;
-/**
- * Parses a remote branch string (e.g., `origin/main`) into its components.
- *
- * @param branch - The remote branch string to parse (e.g., `origin/main`)
- */
-function parseRemoteBranch(branch) {
-    const firstSlashPos = branch.indexOf("/", 0);
-    const remote = branch.substring(0, firstSlashPos);
-    const remoteBranch = branch.substring(firstSlashPos + 1);
-    return {
-        remote,
-        remoteBranch,
-    };
+function parseRemoteBranch(branchOrOptions) {
+    if (typeof branchOrOptions === "string") {
+        const branch = branchOrOptions;
+        const firstSlashPos = branch.indexOf("/", 0);
+        return {
+            remote: branch.substring(0, firstSlashPos),
+            remoteBranch: branch.substring(firstSlashPos + 1),
+        };
+    }
+    const { branch, knownRemotes = ["origin", "upstream"], ...options } = branchOrOptions;
+    if (!branch.includes("/")) {
+        return { remote: "", remoteBranch: branch };
+    }
+    let remote = knownRemotes.find((remote) => branch.startsWith(`${remote}/`));
+    if (!remote) {
+        const remotes = (0, git_1.git)(["remote"], options).stdout.trim().split(/\n/);
+        remote = remotes.find((remote) => branch.startsWith(`${remote}/`));
+    }
+    if (remote) {
+        return { remote, remoteBranch: branch.slice(remote.length + 1) };
+    }
+    return { remote: "", remoteBranch: branch };
 }
 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 });
+function getDefaultBranch(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? { cwd: cwdOrOptions } : cwdOrOptions;
     // Default to the legacy 'master' for backwards compat and old git clients
-    return result.success ? result.stdout.trim() : "master";
+    return (0, config_1.getConfigValue)({ key: "init.defaultBranch", ...options }) || "master";
 }
 exports.getDefaultBranch = getDefaultBranch;
-/**
- * Lists all tracked files matching the given patterns.
- *
- * @param patterns - File patterns to match (passed to git ls-files)
- * @param cwd - The working directory
- * @returns An array of file paths, or an empty array if no files are found
- */
-function listAllTrackedFiles(patterns, cwd) {
-    const results = (0, git_1.git)(["ls-files", ...patterns], { cwd });
-    return results.success && results.stdout.trim() ? results.stdout.trim().split(/\n/) : [];
+function listAllTrackedFiles(patternsOrOptions, cwd) {
+    const { patterns, ...options } = Array.isArray(patternsOrOptions)
+        ? { patterns: patternsOrOptions, cwd: cwd }
+        : patternsOrOptions;
+    const results = (0, git_1.git)(["ls-files", ...patterns], { throwOnError: true, ...options });
+    return (0, git_1.processGitOutput)(results);
 }
 exports.listAllTrackedFiles = listAllTrackedFiles;
-/**
- * Processes git command output by splitting it into lines and filtering out empty lines and `node_modules`.
- *
- * If the command failed with stderr output, an error is thrown.
- *
- * @param output - The git command output to process
- * @returns An array of lines (presumably file paths), or an empty array if the command failed
- * without stderr output.
- */
-function processGitOutput(output) {
-    if (!output.success) {
-        if (output.stderr) {
-            throw new Error(output.stderr);
-        }
-        // TODO: this inconsistency seems maybe not desirable?
-        return [];
-    }
-    return output.stdout
-        .split(/\n/)
-        .map((line) => line.trim())
-        .filter((line) => !!line && !line.includes("node_modules"));
-}
 //# sourceMappingURL=gitUtilities.js.map