Centralize git invocations behind git()/gitChecked() wrappers

Route every git call through thin git()/gitChecked() helpers in util.ts (the only place the 'git' literal now lives) and drop the setOriginRemote add-or-update dance in favor of configuring origin once at repo creation.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: l0lawrence

eng/emitter-diff/src/baseline-cache.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join, resolve, sep } from "node:path";
 
 import type { Logger } from "./types.js";
-import { ensureDir, run } from "./util.js";
+import { ensureDir, git } from "./util.js";
 
 export interface BaselineCacheProfileInput {
   emitter?: string;
@@ -37,7 +37,7 @@ export function computeBaselineProfileKey(input: BaselineCacheProfileInput): str
 }
 
 export async function detectBaselineIdentity(dir: string): Promise<string> {
-  const gitHead = await run("git", ["rev-parse", "--verify", "HEAD"], { cwd: dir });
+  const gitHead = await git(["rev-parse", "--verify", "HEAD"], { cwd: dir });
   const sha = gitHead.code === 0 ? gitHead.stdout.trim() : "";
   if (sha) return `git:${sha}`;
 

eng/emitter-diff/src/cli.ts

@@ -33,7 +33,7 @@ import {
   resolveGithubIdentity,
 } from "./resolver.js";
 import type { ClassifiedRef, EmitterConfig, Logger } from "./types.js";
-import { color, createLogger, ensureDir, run, runChecked } from "./util.js";
+import { color, createLogger, ensureDir, git, gitChecked, runChecked } from "./util.js";
 
 function shouldUseBaselineCache(ciMode: boolean): { enabled: boolean; reason?: string } {
   if (ciMode) {
@@ -94,7 +94,7 @@ ${color.bold("Options:")}
 async function resolveDefaultBaselineRef(repoRoot: string): Promise<string> {
   // Pin the branch name from origin/HEAD (handles non-`main` defaults), falling
   // back to `main`.
-  const originHead = await run("git", ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"], {
+  const originHead = await git(["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"], {
     cwd: repoRoot,
   });
   const branch =
@@ -255,7 +255,7 @@ async function main(): Promise<number> {
   if (!config) return 2;
 
   // Repo root = current git working tree.
-  const repoRoot = (await runChecked("git", ["rev-parse", "--show-toplevel"])).stdout.trim();
+  const repoRoot = (await gitChecked(["rev-parse", "--show-toplevel"])).stdout.trim();
 
   const workDir = ensureDir(values["work-dir"] ?? defaultWorkDir());
   log.info(`${color.dim("work dir:")} ${workDir}`);
@@ -318,11 +318,6 @@ async function main(): Promise<number> {
     const generatedDir = join(runDir, config.generatedCodePath);
     const inherit = logPrefix === undefined;
     if (runSetup && config.setup && config.setup.length > 0) {
-      // Setup runs in a tree the tool materialized from GitHub. A cached worktree
-      // is reused across runs, so a sentinel keyed on the setup commands lets us
-      // prep it exactly once — re-running full setup (e.g. an isolated wheel
-      // build) on an already-prepared tree is both wasteful and flaky. Changing
-      // the setup commands changes the key and forces a re-prep.
       const setupKey = createHash("sha256").update(JSON.stringify(config.setup)).digest("hex");
       const sentinel = join(tree, ".emitter-diff-setup-done");
       const alreadyPrepared =

eng/emitter-diff/src/diff.ts

@@ -9,7 +9,7 @@ import { basename, dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import type { Logger } from "./types.js";
-import { color, run } from "./util.js";
+import { color, git } from "./util.js";
 
 export interface DiffResult {
   /** The unified patch text (empty when there are no differences). */
@@ -43,7 +43,7 @@ export async function diffDirs(
     : ["diff", "--no-index", "--no-color", "--", baselineDir, headDir];
 
   // `git diff --no-index` exits 1 when there are differences — that is not an error.
-  const result = await run("git", args, { cwd: sharesParent ? parent : undefined });
+  const result = await git(args, { cwd: sharesParent ? parent : undefined });
   if (result.code > 1) {
     throw new Error(`git diff failed (${result.code}): ${result.stderr}`);
   }

eng/emitter-diff/src/resolver.ts

@@ -11,7 +11,7 @@ import { tmpdir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 
 import type { ClassifiedRef, Logger } from "./types.js";
-import { ensureDir, run, runChecked } from "./util.js";
+import { ensureDir, git, gitChecked } from "./util.js";
 
 /**
  * Classify a ref string. Explicit prefixes (`local:`, `github:`, `gh:`) are
@@ -95,7 +95,7 @@ const FALLBACK_REPO = "microsoft/typespec";
 async function detectOriginRepo(repoRoot: string | undefined, log: Logger): Promise<string> {
   if (!repoRoot) return FALLBACK_REPO;
   try {
-    const res = await run("git", ["remote", "get-url", "origin"], { cwd: repoRoot });
+    const res = await git(["remote", "get-url", "origin"], { cwd: repoRoot });
     if (res.code === 0) {
       const parsed = parseOwnerRepoFromUrl(res.stdout.trim());
       if (parsed) return parsed;
@@ -114,7 +114,7 @@ async function detectOriginRepo(repoRoot: string | undefined, log: Logger): Prom
  * origin.
  */
 export async function getRemoteRepo(repoRoot: string, remote: string): Promise<string | undefined> {
-  const res = await run("git", ["remote", "get-url", remote], { cwd: repoRoot });
+  const res = await git(["remote", "get-url", remote], { cwd: repoRoot });
   if (res.code !== 0) return undefined;
   return parseOwnerRepoFromUrl(res.stdout.trim());
 }
@@ -199,21 +199,20 @@ async function cloneGithub(
   const cloneUrl = `https://github.com/${repo}.git`;
 
   log.step(`Fetching ${repo}@${gitRef}`);
-  // Shallow-init and fetch the requested ref.
-  await runChecked("git", ["init", "-q"], { cwd: dest });
-  // Ignore failure when origin already exists (dest dir reused from a prior fetch).
-  await runChecked("git", ["remote", "add", "origin", cloneUrl], { cwd: dest }).catch(() => {});
-  const fetched = await runChecked("git", ["fetch", "--depth", "1", "origin", gitRef], {
-    cwd: dest,
-  }).catch(() => undefined);
-  if (fetched) {
+  // Shallow-init and configure origin once, on first creation of this dir.
+  if (!existsSync(join(dest, ".git"))) {
+    await gitChecked(["init", "-q"], { cwd: dest });
+    await gitChecked(["remote", "add", "origin", cloneUrl], { cwd: dest });
+  }
+  const fetched = await git(["fetch", "--depth", "1", "origin", gitRef], { cwd: dest });
+  if (fetched.code === 0) {
     // Targeted fetch resolves to FETCH_HEAD.
-    await runChecked("git", ["checkout", "-q", "FETCH_HEAD"], { cwd: dest });
+    await gitChecked(["checkout", "-q", "FETCH_HEAD"], { cwd: dest });
   } else {
     // Some servers reject bare SHA fetches; full-fetch and checkout by ref name.
     // `--end-of-options` prevents treating the ref as a flag.
-    await runChecked("git", ["fetch", "origin"], { cwd: dest });
-    await runChecked("git", ["checkout", "-q", "--end-of-options", gitRef], { cwd: dest });
+    await gitChecked(["fetch", "origin"], { cwd: dest });
+    await gitChecked(["checkout", "-q", "--end-of-options", gitRef], { cwd: dest });
   }
   return dest;
 }
@@ -233,7 +232,7 @@ async function checkoutCachedWorktree(repo: string, gitRef: string, log: Logger)
 
   ensureDir(cacheRoot);
   log.step(`Creating cached worktree ${repo}@${sha}`);
-  await runChecked("git", ["worktree", "add", "--detach", dest, sha], { cwd: cacheRepo });
+  await gitChecked(["worktree", "add", "--detach", dest, sha], { cwd: cacheRepo });
   return dest;
 }
 
@@ -242,21 +241,19 @@ async function ensureCacheRepo(repo: string, _log: Logger): Promise<string> {
   const gitDir = join(repoRoot, ".git");
   const cloneUrl = `https://github.com/${repo}.git`;
 
+  // Init and configure origin once, on first creation of the cache repo.
   if (!existsSync(gitDir)) {
-    await runChecked("git", ["init", "-q"], { cwd: repoRoot });
+    await gitChecked(["init", "-q"], { cwd: repoRoot });
+    await gitChecked(["remote", "add", "origin", cloneUrl], { cwd: repoRoot });
   }
-
-  // Ensure remote points at the expected repo, without failing if it already exists.
-  await runChecked("git", ["remote", "add", "origin", cloneUrl], { cwd: repoRoot }).catch(() => {});
-  await runChecked("git", ["remote", "set-url", "origin", cloneUrl], { cwd: repoRoot });
   return repoRoot;
 }
 
 async function fetchAndResolveCommit(cacheRepo: string, gitRef: string): Promise<string> {
   // Resolve an immutable commit SHA from FETCH_HEAD.
-  await runChecked("git", ["fetch", "--depth", "1", "origin", gitRef], { cwd: cacheRepo });
+  await gitChecked(["fetch", "--depth", "1", "origin", gitRef], { cwd: cacheRepo });
   const sha = (
-    await runChecked("git", ["rev-parse", "--verify", "FETCH_HEAD"], { cwd: cacheRepo })
+    await gitChecked(["rev-parse", "--verify", "FETCH_HEAD"], { cwd: cacheRepo })
   ).stdout.trim();
   if (!sha) {
     throw new Error(`Could not resolve git ref '${gitRef}' from FETCH_HEAD.`);

eng/emitter-diff/src/util.ts

@@ -47,6 +47,14 @@ export interface RunResult {
   stderr: string;
 }
 
+/** Options shared by {@link run}, {@link runChecked}, and the git wrappers. */
+export interface RunOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  inherit?: boolean;
+  prefix?: string;
+}
+
 /**
  * Spawn a command and resolve with its captured output. Never rejects on a
  * non-zero exit; inspect {@link RunResult.code}. Set `inherit` to stream
@@ -55,11 +63,7 @@ export interface RunResult {
  * when several children run concurrently and their logs would otherwise
  * interleave unintelligibly. `prefix` is ignored when `inherit` is set.
  */
-export function run(
-  cmd: string,
-  args: string[],
-  opts: { cwd?: string; env?: NodeJS.ProcessEnv; inherit?: boolean; prefix?: string } = {},
-): Promise<RunResult> {
+export function run(cmd: string, args: string[], opts: RunOptions = {}): Promise<RunResult> {
   return new Promise((resolve, reject) => {
     // Only route through a shell for Windows .cmd shims (npm/pnpm/npx/code/yarn).
     // Native binaries like git/node are spawned directly to avoid the shell
@@ -156,7 +160,7 @@ function quoteForShell(s: string): string {
 export async function runChecked(
   cmd: string,
   args: string[],
-  opts: { cwd?: string; env?: NodeJS.ProcessEnv; inherit?: boolean; prefix?: string } = {},
+  opts: RunOptions = {},
 ): Promise<RunResult> {
   const result = await run(cmd, args, opts);
   if (result.code !== 0) {
@@ -165,3 +169,13 @@ export async function runChecked(
   }
   return result;
 }
+
+/** Run `git` with the given args, capturing output (never throws on non-zero). */
+export function git(args: string[], opts: RunOptions = {}): Promise<RunResult> {
+  return run("git", args, opts);
+}
+
+/** Run `git` and throw if it exits non-zero. */
+export function gitChecked(args: string[], opts: RunOptions = {}): Promise<RunResult> {
+  return runChecked("git", args, opts);
+}