如何用NodeGit获取提交创建所属分支（非HEAD）？

Awesome question—this is one of those tricky Git details because, as you pointed out, branches are just lightweight pointers, not something hardcoded into commits themselves. Let’s break down how to tackle this with NodeGit and other tools.

First, a quick Git reality check: Commits don’t store their "original branch" natively. Branches are just movable labels pointing to commits, so Git doesn’t track which branch spawned a commit long-term. That said, we can still get close to what you need—either finding all branches that contain the commit (matching git branch --contains) or making an educated guess at the original branch using reflogs.

Option 1: Simulate git branch --contains with NodeGit #

To replicate the git branch --contains <commit> behavior (finding all branches where the commit is part of the branch’s history), you can iterate through all local/remote branches and check if the target commit is an ancestor of the branch’s HEAD. Here’s how to do it:

const NodeGit = require("nodegit");

async function getBranchesContainingCommit(repoPath, commitHash) {
  // Open the repository
  const repo = await NodeGit.Repository.open(repoPath);
  // Fetch the target commit
  const targetCommit = await repo.getCommit(commitHash);
  
  const containingBranches = [];

  // Check local branches
  const localBranches = await NodeGit.Branch.list(repo, NodeGit.Branch.BRANCH.LOCAL);
  for (const branchName of localBranches) {
    const branch = await NodeGit.Branch.lookup(repo, branchName, NodeGit.Branch.BRANCH.LOCAL);
    const branchHead = await branch.getTarget();
    
    // Check if target commit is an ancestor of the branch's HEAD (including the HEAD itself)
    if (await targetCommit.isAncestorOf(branchHead)) {
      containingBranches.push(branchName);
    }
  }

  // Check remote branches (optional)
  const remoteBranches = await NodeGit.Branch.list(repo, NodeGit.Branch.BRANCH.REMOTE);
  for (const branchName of remoteBranches) {
    const branch = await NodeGit.Branch.lookup(repo, branchName, NodeGit.Branch.BRANCH.REMOTE);
    const branchHead = await branch.getTarget();
    
    if (await targetCommit.isAncestorOf(branchHead)) {
      containingBranches.push(branchName);
    }
  }

  return containingBranches;
}

// Usage example
getBranchesContainingCommit("./my-git-repo", "a1b2c3d")
  .then(branches => console.log("Branches with this commit:", branches))
  .catch(err => console.error("Error:", err));

This code will return every branch (local or remote) that includes the commit in its history—exactly what git branch --contains does.

Option 2: Guess the Original Branch Using Reflogs #

If you specifically need the branch the commit was created on (not just any branch that contains it), you’ll have to rely on Git’s reflog. Reflogs track local changes to branch pointers, so they might show when a commit was added to a branch. Note that reflogs are local-only and expire after 90 days by default, so this won’t work for old commits or freshly cloned repos.

Here’s a NodeGit example to check reflogs for the original branch:

const NodeGit = require("nodegit");

async function guessOriginalBranchFromReflog(repoPath, commitHash) {
  const repo = await NodeGit.Repository.open(repoPath);
  const targetCommitId = await repo.getId(commitHash);

  // Check reflogs for all local branches
  const localBranches = await NodeGit.Branch.list(repo, NodeGit.Branch.BRANCH.LOCAL);
  for (const branchName of localBranches) {
    const refPath = `refs/heads/${branchName}`;
    try {
      const reflog = await NodeGit.Reflog.read(repo, refPath);
      // Iterate through reflog entries to find when this commit was added
      for (const entry of reflog.entries()) {
        if (entry.id().equal(targetCommitId)) {
          // Found the branch where this commit was first referenced
          return branchName;
        }
      }
    } catch (err) {
      // Some branches might not have a reflog—skip them
      continue;
    }
  }

  // If no match found in branch reflogs, check HEAD reflog
  const headReflog = await NodeGit.Reflog.read(repo, "HEAD");
  for (const entry of headReflog.entries()) {
    if (entry.id().equal(targetCommitId)) {
      // Couldn't pinpoint a branch, but HEAD was pointing to this commit at some point
      return "HEAD (no specific branch found)";
    }
  }

  return null; // No reflog entry found for this commit
}

// Usage example
guessOriginalBranchFromReflog("./my-git-repo", "a1b2c3d")
  .then(branch => console.log("Original branch guess:", branch))
  .catch(err => console.error("Error:", err));

Alternative: Use Isomorphic-Git (Browser/Node.js Compatible) #

If you need a cross-platform solution, isomorphic-git works in both Node.js and browsers. Here’s a quick snippet to find branches containing a commit:

const git = require("isomorphic-git");
const fs = require("fs");

async function getBranchesContainingCommitIsomorphic(repoPath, commitHash) {
  const branches = await git.listBranches({ fs, dir: repoPath });
  const containingBranches = [];

  for (const branch of branches) {
    // Fetch the commit history for the branch
    const log = await git.log({ fs, dir: repoPath, ref: branch, depth: Infinity });
    // Check if the target commit is in the log
    if (log.some(entry => entry.oid === commitHash)) {
      containingBranches.push(branch);
    }
  }

  return containingBranches;
}

Key Takeaways #

• git branch --contains doesn’t return the "original" branch—it returns all branches that include the commit in their history. NodeGit can replicate this with isAncestorOf.
• To find the branch a commit was created on, you need to use reflogs, but this only works for recent commits in local repos.
• No tool can definitively tell you the original branch for old or shared commits, since Git doesn’t store that metadata.

内容的提问来源于stack exchange，提问作者R00t