fix(git): diff a branch name against its upstream when the local copy is stale

packages/git/src/diff.ts

@@ -1,4 +1,4 @@
-import { exec, execLarge, execLines, execWithStdin } from './exec.js';
+import { exec, execLarge, execLines, execWithStdin, git } from './exec.js';
 
 /**
  * Flags that neutralize user git config which would otherwise alter the diff
@@ -120,6 +120,48 @@ export function getMergeBase(a: string, b: string): string {
   return exec(`git merge-base ${a} ${b}`);
 }
 
+function isLocalBranch(ref: string): boolean {
+  try {
+    git(['show-ref', '--verify', '--quiet', `refs/heads/${ref}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getUpstream(ref: string): string | null {
+  try {
+    return git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', `${ref}@{upstream}`]) || null;
+  } catch {
+    return null;
+  }
+}
+
+function isBehind(ref: string, other: string): boolean {
+  return Number(git(['rev-list', '--count', `${ref}..${other}`])) > 0;
+}
+
+/**
+ * "What changed since master" means since the master everyone else has, not since the copy
+ * in this checkout — which is usually behind, and every commit it is missing would otherwise
+ * show up as part of the change set.
+ *
+ * Only bare local branch names are redirected: a range, a tag or a commit is taken as pinned
+ * on purpose.
+ */
+export function resolveThroughUpstream(ref: string): string {
+  if (!isLocalBranch(ref)) {
+    return ref;
+  }
+
+  const upstream = getUpstream(ref);
+  if (!upstream) {
+    return ref;
+  }
+
+  return isBehind(ref, upstream) ? upstream : ref;
+}
+
 export function normalizeRef(ref: string): string {
   if (ref.includes('...')) {
     return ref;
@@ -131,7 +173,7 @@ export function normalizeRef(ref: string): string {
     const base = getMergeBase(left, right);
     return `${base}..${right}`;
   }
-  return getMergeBase(ref, 'HEAD');
+  return getMergeBase(resolveThroughUpstream(ref), 'HEAD');
 }
 
 export const WORKING_TREE_REFS = new Set(['work', '.', 'staged', 'unstaged']);
@@ -155,7 +197,7 @@ export function resolveBaseRef(ref: string): string {
     return getMergeBase(left, right);
   }
 
-  return getMergeBase(ref, 'HEAD');
+  return getMergeBase(resolveThroughUpstream(ref), 'HEAD');
 }
 
 export function getFileContent(path: string, ref = 'HEAD'): string {

packages/git/src/exec.ts

@@ -50,6 +50,22 @@ export function execFileLarge(command: string, args: string[]): string {
   }).trim();
 }
 
+/**
+ * Runs git without a shell. Preferred over the string forms for anything whose arguments
+ * come from a ref, a path or a search term.
+ */
+export function git(args: string[]): string {
+  return execFileLarge('git', args);
+}
+
+export function gitLines(args: string[]): string[] {
+  const output = git(args);
+  if (!output) {
+    return [];
+  }
+  return output.split('\n');
+}
+
 export function execLines(cmd: string): string[] {
   const output = exec(cmd);
   if (!output) {

packages/git/src/index.ts

@@ -1,7 +1,7 @@
 export type { Commit, RepoInfo } from './types.js';
 export type { RefCapabilities } from './repo.js';
 export { isGitRepo, getRepoRoot, getRepoName, getCurrentBranch, getRepoInfo, getHeadHash, getDiffityDir, getDiffityDirPath, getRefCapabilities, isValidGitRef } from './repo.js';
-export { getDiff, getDiffFiles, getDiffStat, getDiffStatForRef, getUntrackedFiles, getUntrackedDiff, getFileContent, getFileLineCount, getMergeBase, normalizeRef, resolveBaseRef, resolveDiffArgs, resolveRef, revertFile, revertHunk, WORKING_TREE_REFS } from './diff.js';
+export { getDiff, getDiffFiles, getDiffStat, getDiffStatForRef, getUntrackedFiles, getUntrackedDiff, getFileContent, getFileLineCount, getMergeBase, normalizeRef, resolveBaseRef, resolveThroughUpstream, resolveDiffArgs, resolveRef, revertFile, revertHunk, WORKING_TREE_REFS } from './diff.js';
 export type { RefDiffArgs } from './diff.js';
 export { getStagedFiles, getUnstagedFiles, isDirty } from './status.js';
 export { getRecentCommits } from './commits.js';

packages/git/tests/resolve-upstream.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+let root: string;
+let repoDir: string;
+let origCwd: string;
+
+function git(args: string[], cwd = repoDir): string {
+  return execFileSync('git', args, { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim();
+}
+
+function commit(name: string, content: string): void {
+  writeFileSync(join(repoDir, name), content);
+  git(['add', '.']);
+  git(['commit', '-m', `add ${content}`]);
+}
+
+beforeAll(() => {
+  origCwd = process.cwd();
+  root = mkdtempSync(join(tmpdir(), 'diffity-upstream-'));
+  repoDir = join(root, 'repo');
+  const remoteDir = join(root, 'remote.git');
+
+  execFileSync('git', ['init', '--bare', remoteDir], { stdio: 'pipe' });
+  execFileSync('git', ['init', '-b', 'main', repoDir], { stdio: 'pipe' });
+  git(['config', 'user.email', 'test@test.com']);
+  git(['config', 'user.name', 'Test']);
+
+  commit('a.txt', 'a');
+  git(['remote', 'add', 'origin', remoteDir]);
+  git(['push', '-u', 'origin', 'main']);
+
+  // The remote moves on, and a feature branch is cut from that newer main...
+  commit('b.txt', 'b');
+  git(['push', 'origin', 'main']);
+  git(['checkout', '-b', 'feature']);
+  commit('c.txt', 'c');
+
+  // ...while the local main is left where it was, two commits behind.
+  git(['checkout', 'main']);
+  git(['reset', '--hard', 'HEAD~1']);
+  git(['checkout', 'feature']);
+
+  process.chdir(repoDir);
+});
+
+afterAll(() => {
+  process.chdir(origCwd);
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe('resolveThroughUpstream', () => {
+  it('redirects a local branch that is behind its upstream', async () => {
+    const { resolveThroughUpstream } = await import('../src/diff.js');
+
+    expect(resolveThroughUpstream('main')).toBe('origin/main');
+  });
+
+  it('leaves a branch that is level with its upstream alone', async () => {
+    const { resolveThroughUpstream } = await import('../src/diff.js');
+    git(['checkout', 'main']);
+    git(['pull', '--ff-only']);
+    git(['checkout', 'feature']);
+
+    expect(resolveThroughUpstream('main')).toBe('main');
+  });
+
+  it('leaves a branch with no upstream alone', async () => {
+    const { resolveThroughUpstream } = await import('../src/diff.js');
+
+    expect(resolveThroughUpstream('feature')).toBe('feature');
+  });
+
+  it('leaves a commit alone', async () => {
+    const { resolveThroughUpstream } = await import('../src/diff.js');
+    const sha = git(['rev-parse', 'HEAD']);
+
+    expect(resolveThroughUpstream(sha)).toBe(sha);
+  });
+});
+
+describe('normalizeRef', () => {
+  it('bases the diff on the upstream when the local branch is stale', async () => {
+    const { normalizeRef } = await import('../src/diff.js');
+    git(['checkout', 'main']);
+    git(['reset', '--hard', 'HEAD~1']);
+    git(['checkout', 'feature']);
+
+    const expected = git(['merge-base', 'origin/main', 'HEAD']);
+
+    expect(normalizeRef('main')).toBe(expected);
+    expect(normalizeRef('main')).not.toBe(git(['merge-base', 'main', 'HEAD']));
+  });
+});