@getpaseo/server 0.1.58 → 0.1.60

package/dist/server/utils/checkout-git.js

@@ -1,12 +1,11 @@
 import { resolve, dirname, basename } from "path";
 import { existsSync, realpathSync } from "fs";
-import { open as openFile, stat as statFile } from "fs/promises";
+import { open as openFile, readFile, stat as statFile } from "fs/promises";
 import { TTLCache } from "@isaacs/ttlcache";
 import { parseAndHighlightDiff } from "../server/utils/diff-highlighter.js";
-import { findExecutable } from "./executable.js";
+import { GitHubAuthenticationError, GitHubCliMissingError, createGitHubService, resolveGitHubRepo, } from "../services/github-service.js";
 import { parseGitRevParsePath, resolveGitRevParsePath } from "./git-rev-parse-path.js";
 import { runGitCommand } from "./run-git-command.js";
-import { execCommand } from "./spawn.js";
 import { isPaseoOwnedWorktreeCwd } from "./worktree.js";
 import { requirePaseoWorktreeBaseRefName } from "./worktree-metadata.js";
 const READ_ONLY_GIT_ENV = {
@@ -15,10 +14,14 @@ const READ_ONLY_GIT_ENV = {
 };
 const DEFAULT_PULL_REQUEST_STATUS_CACHE_TTL_MS = 30000;
 const PULL_REQUEST_STATUS_CACHE_MAX = 1000;
+const DEFAULT_SHORTSTAT_CACHE_TTL_MS = 15000;
+const SHORTSTAT_CACHE_MAX = 1000;
 let pullRequestStatusCacheTtlMs = DEFAULT_PULL_REQUEST_STATUS_CACHE_TTL_MS;
 let pullRequestStatusCache = createPullRequestStatusCache(pullRequestStatusCacheTtlMs);
 const pullRequestStatusInFlight = new Map();
-let cachedGhPath = undefined;
+let shortstatCacheTtlMs = DEFAULT_SHORTSTAT_CACHE_TTL_MS;
+let shortstatCache = createShortstatCache(shortstatCacheTtlMs);
+const shortstatInFlight = new Map();
 function createPullRequestStatusCache(ttlMs) {
     return new TTLCache({
         ttl: ttlMs,
@@ -26,9 +29,19 @@ function createPullRequestStatusCache(ttlMs) {
         checkAgeOnGet: true,
     });
 }
+function createShortstatCache(ttlMs) {
+    return new TTLCache({
+        ttl: ttlMs,
+        max: SHORTSTAT_CACHE_MAX,
+        checkAgeOnGet: true,
+    });
+}
 function getPullRequestStatusCacheKey(cwd) {
     return resolve(cwd);
 }
+function getShortstatCacheKey(cwd) {
+    return resolve(cwd);
+}
 export function __resetPullRequestStatusCacheForTests() {
     pullRequestStatusCache.clear();
     pullRequestStatusCache.cancelTimer();
@@ -43,11 +56,22 @@ export function __setPullRequestStatusCacheTtlForTests(ttlMs) {
     pullRequestStatusCache = createPullRequestStatusCache(ttlMs);
     pullRequestStatusInFlight.clear();
 }
-export function __resetGhPathCacheForTests() {
-    cachedGhPath = undefined;
+export function __resetCheckoutShortstatCacheForTests() {
+    shortstatCache.clear();
+    shortstatCache.cancelTimer();
+    shortstatCacheTtlMs = DEFAULT_SHORTSTAT_CACHE_TTL_MS;
+    shortstatCache = createShortstatCache(shortstatCacheTtlMs);
+    shortstatInFlight.clear();
+}
+export function __setCheckoutShortstatCacheTtlForTests(ttlMs) {
+    shortstatCache.clear();
+    shortstatCache.cancelTimer();
+    shortstatCacheTtlMs = ttlMs;
+    shortstatCache = createShortstatCache(ttlMs);
+    shortstatInFlight.clear();
 }
-export function __setGhPathForTests(path) {
-    cachedGhPath = path;
+function getCheckoutDiffRefArgs(refs) {
+    return [refs.baseRef, ...(refs.targetRef ? [refs.targetRef] : [])];
 }
 function normalizeBranchSuggestionName(raw) {
     const trimmed = raw.trim();
@@ -126,7 +150,8 @@ export async function listBranchSuggestions(cwd, options) {
             continue;
         const existing = branchMeta.get(normalized);
         branchMeta.set(normalized, {
-            isLocal: true,
+            hasLocal: true,
+            hasRemote: existing?.hasRemote ?? false,
             committerDate: Math.max(ref.committerDate, existing?.committerDate ?? 0),
         });
     }
@@ -136,11 +161,16 @@ export async function listBranchSuggestions(cwd, options) {
             continue;
         const existing = branchMeta.get(normalized);
         if (!existing) {
-            branchMeta.set(normalized, { isLocal: false, committerDate: ref.committerDate });
+            branchMeta.set(normalized, {
+                hasLocal: false,
+                hasRemote: true,
+                committerDate: ref.committerDate,
+            });
         }
         else {
             branchMeta.set(normalized, {
                 ...existing,
+                hasRemote: true,
                 committerDate: Math.max(ref.committerDate, existing.committerDate),
             });
         }
@@ -150,13 +180,71 @@ export async function listBranchSuggestions(cwd, options) {
         return [];
     }
     const ordered = sortBranchSuggestions(filteredNames, branchMeta, query);
-    return ordered.slice(0, limit);
+    return ordered.slice(0, limit).map((name) => {
+        const meta = branchMeta.get(name);
+        return {
+            name,
+            committerDate: meta?.committerDate ?? 0,
+            hasLocal: meta?.hasLocal ?? false,
+            hasRemote: meta?.hasRemote ?? false,
+        };
+    });
 }
-async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
+export async function resolveBranchCheckout(cwd, name) {
+    await requireGitRepo(cwd);
+    const normalized = normalizeBranchSuggestionName(name);
+    if (!normalized) {
+        return { kind: "not-found" };
+    }
+    const localRef = `refs/heads/${normalized}`;
+    const localResult = await runGitCommand(["rev-parse", "--verify", "--quiet", localRef], {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+        acceptExitCodes: [0, 1],
+    });
+    const hasLocal = localResult.exitCode === 0;
+    if (hasLocal) {
+        return { kind: "local", name: normalized };
+    }
+    const remoteRef = `origin/${normalized}`;
+    const remoteRefPath = `refs/remotes/${remoteRef}`;
+    const remoteResult = await runGitCommand(["rev-parse", "--verify", "--quiet", remoteRefPath], {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+        acceptExitCodes: [0, 1],
+    });
+    const hasRemote = remoteResult.exitCode === 0;
+    if (hasRemote) {
+        return { kind: "remote-only", name: normalized, remoteRef };
+    }
+    return { kind: "not-found" };
+}
+export async function checkoutResolvedBranch(input) {
+    const { cwd, resolution } = input;
+    switch (resolution.kind) {
+        case "local": {
+            const { stdout } = await runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+            const current = stdout.trim();
+            if (current === resolution.name) {
+                return { source: "local" };
+            }
+            await runGitCommand(["checkout", resolution.name], { cwd });
+            return { source: "local" };
+        }
+        case "remote-only":
+            await runGitCommand(["checkout", "-b", resolution.name, "--track", resolution.remoteRef], {
+                cwd,
+            });
+            return { source: "remote" };
+        case "not-found":
+            throw new Error(`Branch not found: ${input.requestedBranch ?? "unknown"}`);
+    }
+}
+async function listCheckoutFileChanges(cwd, refs, ignoreWhitespace = false) {
     const changes = [];
     const { stdout: nameStatusOut } = await runGitCommand(buildGitDiffArgs({
         ignoreWhitespace,
-        extra: ["--name-status", ref],
+        extra: ["--name-status", ...getCheckoutDiffRefArgs(refs)],
     }), { cwd, env: READ_ONLY_GIT_ENV });
     for (const line of nameStatusOut
         .split("\n")
@@ -192,21 +280,23 @@ async function listCheckoutFileChanges(cwd, ref, ignoreWhitespace = false) {
             isDeleted: code === "D",
         });
     }
-    const { stdout: untrackedOut } = await runGitCommand(["ls-files", "--others", "--exclude-standard"], {
-        cwd,
-        env: READ_ONLY_GIT_ENV,
-    });
-    for (const file of untrackedOut
-        .split("\n")
-        .map((l) => l.trim())
-        .filter(Boolean)) {
-        changes.push({
-            path: file,
-            status: "U",
-            isNew: true,
-            isDeleted: false,
-            isUntracked: true,
+    if (refs.includeUntracked) {
+        const { stdout: untrackedOut } = await runGitCommand(["ls-files", "--others", "--exclude-standard"], {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
         });
+        for (const file of untrackedOut
+            .split("\n")
+            .map((l) => l.trim())
+            .filter(Boolean)) {
+            changes.push({
+                path: file,
+                status: "U",
+                isNew: true,
+                isDeleted: false,
+                isUntracked: true,
+            });
+        }
     }
     // Deduplicate by path (prefer tracked status over untracked marker if both appear).
     const byPath = new Map();
@@ -264,10 +354,10 @@ function buildGitDiffArgs(args) {
 }
 const TRACKED_DIFF_NUMSTAT_MAX_BYTES = 2 * 1024 * 1024; // 2MB
 const TRACKED_MAX_CHANGED_LINES = 40000;
-async function getTrackedNumstatByPath(cwd, ref, ignoreWhitespace = false) {
+async function getTrackedNumstatByPath(cwd, refs, ignoreWhitespace = false) {
     const result = await runGitCommand(buildGitDiffArgs({
         ignoreWhitespace,
-        extra: ["--numstat", ref],
+        extra: ["--numstat", ...getCheckoutDiffRefArgs(refs)],
     }), {
         cwd,
         env: READ_ONLY_GIT_ENV,
@@ -358,12 +448,34 @@ export async function getCurrentBranch(cwd) {
             env: READ_ONLY_GIT_ENV,
         });
         const branch = stdout.trim();
+        if (branch === "HEAD") {
+            return await getRebaseHeadBranch(cwd);
+        }
         return branch.length > 0 ? branch : null;
     }
     catch {
         return null;
     }
 }
+async function getRebaseHeadBranch(cwd) {
+    for (const path of ["rebase-merge/head-name", "rebase-apply/head-name"]) {
+        try {
+            const { stdout } = await runGitCommand(["rev-parse", "--git-path", path], {
+                cwd,
+                env: READ_ONLY_GIT_ENV,
+            });
+            const headName = (await readFile(resolve(cwd, stdout.trim()), "utf8")).trim();
+            if (headName.startsWith("refs/heads/")) {
+                return headName.slice("refs/heads/".length) || null;
+            }
+            return headName || null;
+        }
+        catch {
+            // Try the other rebase backend.
+        }
+    }
+    return null;
+}
 async function getWorktreeRoot(cwd) {
     try {
         const { stdout } = await runGitCommand(["rev-parse", "--show-toplevel"], {
@@ -598,21 +710,47 @@ async function resolveBaseRef(repoRoot) {
     return resolveRepositoryDefaultBranch(repoRoot);
 }
 function normalizeLocalBranchRefName(input) {
-    return input.startsWith("origin/") ? input.slice("origin/".length) : input;
+    if (input.startsWith("refs/remotes/origin/")) {
+        return input.slice("refs/remotes/origin/".length);
+    }
+    if (input.startsWith("refs/heads/")) {
+        return input.slice("refs/heads/".length);
+    }
+    if (input.startsWith("origin/")) {
+        return input.slice("origin/".length);
+    }
+    return input;
+}
+function normalizeComparisonBaseRefName(input) {
+    const localName = normalizeLocalBranchRefName(input);
+    return { localName, originRef: `origin/${localName}` };
 }
 async function doesGitRefExist(cwd, fullRef) {
-    try {
-        await runGitCommand(["show-ref", "--verify", "--quiet", fullRef], {
-            cwd,
-            env: READ_ONLY_GIT_ENV,
-        });
-        return true;
+    const result = await runGitCommand(["show-ref", "--verify", "--quiet", fullRef], {
+        cwd,
+        env: READ_ONLY_GIT_ENV,
+        acceptExitCodes: [0, 1],
+    });
+    return result.exitCode === 0;
+}
+async function resolveBestComparisonBaseRef(cwd, baseRef) {
+    const normalized = normalizeComparisonBaseRefName(baseRef);
+    const [hasLocal, hasOrigin] = await Promise.all([
+        doesGitRefExist(cwd, `refs/heads/${normalized.localName}`),
+        doesGitRefExist(cwd, `refs/remotes/origin/${normalized.localName}`),
+    ]);
+    if (hasOrigin) {
+        return normalized.originRef;
     }
-    catch {
-        return false;
+    if (hasLocal) {
+        return normalized.localName;
     }
+    const refName = baseRef.startsWith("origin/") || baseRef.startsWith("refs/remotes/origin/")
+        ? normalized.originRef
+        : normalized.localName;
+    throw new Error(`Base branch not found locally or on origin: ${refName}`);
 }
-async function resolveBestComparisonBaseRef(cwd, normalizedBaseRef) {
+async function resolveMostAheadBaseRef(cwd, normalizedBaseRef) {
     const [hasLocal, hasOrigin] = await Promise.all([
         doesGitRefExist(cwd, `refs/heads/${normalizedBaseRef}`),
         doesGitRefExist(cwd, `refs/remotes/origin/${normalizedBaseRef}`),
@@ -626,18 +764,15 @@ async function resolveBestComparisonBaseRef(cwd, normalizedBaseRef) {
     if (!hasLocal && !hasOrigin) {
         throw new Error(`Base branch not found locally or on origin: ${normalizedBaseRef}`);
     }
-    // Both exist: choose the ref with more unique commits compared to the other.
-    try {
-        const { stdout } = await runGitCommand(["rev-list", "--left-right", "--count", `${normalizedBaseRef}...origin/${normalizedBaseRef}`], { cwd, env: READ_ONLY_GIT_ENV });
-        const [localOnlyRaw, originOnlyRaw] = stdout.trim().split(/\s+/);
-        const localOnly = Number.parseInt(localOnlyRaw ?? "0", 10);
-        const originOnly = Number.parseInt(originOnlyRaw ?? "0", 10);
-        if (!Number.isNaN(localOnly) && !Number.isNaN(originOnly) && originOnly > localOnly) {
-            return `origin/${normalizedBaseRef}`;
-        }
+    const { stdout } = await runGitCommand(["rev-list", "--left-right", "--count", `${normalizedBaseRef}...origin/${normalizedBaseRef}`], { cwd, env: READ_ONLY_GIT_ENV });
+    const [localOnlyRaw, originOnlyRaw] = stdout.trim().split(/\s+/);
+    const localOnly = Number.parseInt(localOnlyRaw ?? "0", 10);
+    const originOnly = Number.parseInt(originOnlyRaw ?? "0", 10);
+    if (Number.isNaN(localOnly) || Number.isNaN(originOnly)) {
+        return normalizedBaseRef;
     }
-    catch {
-        // ignore and fall back to local
+    if (originOnly > localOnly) {
+        return `origin/${normalizedBaseRef}`;
     }
     return normalizedBaseRef;
 }
@@ -646,7 +781,7 @@ async function getAheadBehind(cwd, baseRef, currentBranch) {
     if (!normalizedBaseRef || !currentBranch || normalizedBaseRef === currentBranch) {
         return null;
     }
-    const comparisonBaseRef = await resolveBestComparisonBaseRef(cwd, normalizedBaseRef);
+    const comparisonBaseRef = await resolveBestComparisonBaseRef(cwd, baseRef);
     const { stdout } = await runGitCommand(["rev-list", "--left-right", "--count", `${comparisonBaseRef}...${currentBranch}`], { cwd, env: READ_ONLY_GIT_ENV });
     const [behindRaw, aheadRaw] = stdout.trim().split(/\s+/);
     const behind = Number.parseInt(behindRaw ?? "0", 10);
@@ -852,7 +987,27 @@ export async function getCheckoutStatus(cwd, context) {
         isPaseoOwnedWorktree: false,
     };
 }
-export async function getCheckoutShortstat(cwd, context) {
+function parseCheckoutShortstat(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return null;
+    }
+    let additions = 0;
+    let deletions = 0;
+    const addMatch = trimmed.match(/(\d+)\s+insertion/);
+    if (addMatch) {
+        additions = Number.parseInt(addMatch[1], 10);
+    }
+    const delMatch = trimmed.match(/(\d+)\s+deletion/);
+    if (delMatch) {
+        deletions = Number.parseInt(delMatch[1], 10);
+    }
+    if (additions === 0 && deletions === 0) {
+        return null;
+    }
+    return { additions, deletions };
+}
+async function getCheckoutShortstatUncached(cwd, context) {
     try {
         await requireGitRepo(cwd);
     }
@@ -862,70 +1017,91 @@ export async function getCheckoutShortstat(cwd, context) {
     const configured = await getConfiguredBaseRefForCwd(cwd, context);
     const localBaseRef = configured.baseRef ?? (await resolveBaseRef(cwd));
     const currentBranch = await getCurrentBranch(cwd);
-    let diffTarget;
+    let comparisonRef;
     if (currentBranch && localBaseRef && currentBranch !== localBaseRef) {
-        // Feature branch: diff against the merge-base with the base branch
-        const comparisonBaseRef = await resolveBestComparisonBaseRef(cwd, normalizeLocalBranchRefName(localBaseRef));
         try {
-            const { stdout } = await runGitCommand(["merge-base", "HEAD", comparisonBaseRef], {
-                cwd,
-                env: READ_ONLY_GIT_ENV,
-            });
-            const mergeBase = stdout.trim();
-            if (!mergeBase) {
-                return null;
-            }
-            diffTarget = mergeBase;
+            comparisonRef = await resolveBestComparisonBaseRef(cwd, localBaseRef);
         }
         catch {
             return null;
         }
     }
     else if (currentBranch) {
-        // On the base branch (or no base ref configured): diff against remote tracking branch
         const hasOrigin = await doesGitRefExist(cwd, `refs/remotes/origin/${currentBranch}`);
         if (!hasOrigin) {
             return null;
         }
-        diffTarget = `origin/${currentBranch}`;
+        comparisonRef = `origin/${currentBranch}`;
     }
     else {
         return null;
     }
     try {
-        // Omit HEAD so the diff includes uncommitted (staged + unstaged) changes
-        const { stdout } = await runGitCommand(["diff", "--shortstat", diffTarget], {
+        const { stdout: mergeBaseOut } = await runGitCommand(["merge-base", "HEAD", comparisonRef], {
             cwd,
             env: READ_ONLY_GIT_ENV,
         });
-        const text = stdout.trim();
-        if (!text) {
+        const mergeBase = mergeBaseOut.trim();
+        if (!mergeBase) {
             return null;
         }
-        let additions = 0;
-        let deletions = 0;
-        const addMatch = text.match(/(\d+)\s+insertion/);
-        if (addMatch) {
-            additions = Number.parseInt(addMatch[1], 10);
-        }
-        const delMatch = text.match(/(\d+)\s+deletion/);
-        if (delMatch) {
-            deletions = Number.parseInt(delMatch[1], 10);
-        }
-        if (additions === 0 && deletions === 0) {
-            return null;
-        }
-        return { additions, deletions };
+        const { stdout } = await runGitCommand(["diff", "--shortstat", mergeBase], {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        return parseCheckoutShortstat(stdout);
     }
     catch {
         return null;
     }
 }
+function getOrLoadCheckoutShortstat(cwd, context, options) {
+    const cacheKey = getShortstatCacheKey(cwd);
+    if (!options?.force) {
+        const cached = shortstatCache.get(cacheKey);
+        if (cached !== undefined) {
+            return Promise.resolve(cached);
+        }
+        const existing = shortstatInFlight.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+    }
+    const load = getCheckoutShortstatUncached(cwd, context)
+        .then((shortstat) => {
+        shortstatCache.set(cacheKey, shortstat);
+        return shortstat;
+    })
+        .finally(() => {
+        shortstatInFlight.delete(cacheKey);
+    });
+    shortstatInFlight.set(cacheKey, load);
+    return load;
+}
+export async function getCheckoutShortstat(cwd, context, options) {
+    return getOrLoadCheckoutShortstat(cwd, context, options);
+}
+export function getCachedCheckoutShortstat(cwd) {
+    return shortstatCache.get(getShortstatCacheKey(cwd));
+}
+export function warmCheckoutShortstatInBackground(cwd, context, onComplete) {
+    const cacheKey = getShortstatCacheKey(cwd);
+    if (shortstatCache.get(cacheKey) !== undefined || shortstatInFlight.has(cacheKey)) {
+        return;
+    }
+    void getOrLoadCheckoutShortstat(cwd, context)
+        .then(() => {
+        onComplete?.();
+    })
+        .catch(() => {
+        // Non-critical: keep listing path resilient even if git commands fail.
+    });
+}
 export async function getCheckoutDiff(cwd, compare, context) {
     await requireGitRepo(cwd);
-    let refForDiff;
+    let refsForDiff;
     if (compare.mode === "uncommitted") {
-        refForDiff = "HEAD";
+        refsForDiff = { baseRef: "HEAD", includeUntracked: true };
     }
     else {
         const configured = await getConfiguredBaseRefForCwd(cwd, context);
@@ -936,12 +1112,15 @@ export async function getCheckoutDiff(cwd, compare, context) {
         if (configured.isPaseoOwnedWorktree && compare.baseRef && compare.baseRef !== baseRef) {
             throw new Error(`Base ref mismatch: expected ${baseRef}, got ${compare.baseRef}`);
         }
-        const normalizedBaseRef = normalizeLocalBranchRefName(baseRef);
-        const bestBaseRef = await resolveBestComparisonBaseRef(cwd, normalizedBaseRef);
-        refForDiff = (await tryResolveMergeBase(cwd, bestBaseRef)) ?? bestBaseRef;
+        const bestBaseRef = await resolveBestComparisonBaseRef(cwd, baseRef);
+        refsForDiff = {
+            baseRef: (await tryResolveMergeBase(cwd, bestBaseRef)) ?? bestBaseRef,
+            targetRef: "HEAD",
+            includeUntracked: false,
+        };
     }
     const ignoreWhitespace = compare.ignoreWhitespace === true;
-    const changes = await listCheckoutFileChanges(cwd, refForDiff, ignoreWhitespace);
+    const changes = await listCheckoutFileChanges(cwd, refsForDiff, ignoreWhitespace);
     changes.sort((a, b) => {
         if (a.path === b.path)
             return 0;
@@ -971,7 +1150,7 @@ export async function getCheckoutDiff(cwd, compare, context) {
     const untrackedChanges = changes.filter((change) => change.isUntracked === true);
     const trackedChangeByPath = new Map(trackedChanges.map((change) => [change.path, change]));
     const trackedNumstatByPath = trackedChanges.length > 0
-        ? await getTrackedNumstatByPath(cwd, refForDiff, ignoreWhitespace)
+        ? await getTrackedNumstatByPath(cwd, refsForDiff, ignoreWhitespace)
         : new Map();
     const trackedDiffPaths = [];
     const trackedPlaceholderByPath = new Map();
@@ -992,7 +1171,7 @@ export async function getCheckoutDiff(cwd, compare, context) {
     if (trackedDiffPaths.length > 0) {
         const trackedDiffResult = await runGitCommand(buildGitDiffArgs({
             ignoreWhitespace,
-            extra: [refForDiff, "--", ...trackedDiffPaths],
+            extra: [...getCheckoutDiffRefArgs(refsForDiff), "--", ...trackedDiffPaths],
         }), {
             cwd,
             env: READ_ONLY_GIT_ENV,
@@ -1021,7 +1200,13 @@ export async function getCheckoutDiff(cwd, compare, context) {
                         return null;
                     }
                     const refPath = change.oldPath ?? change.path;
-                    return readGitFileContentAtRef(cwd, refForDiff, refPath);
+                    return readGitFileContentAtRef(cwd, refsForDiff.baseRef, refPath);
+                },
+                getNewFileContent: async (file) => {
+                    if (!refsForDiff.targetRef) {
+                        return null;
+                    }
+                    return readGitFileContentAtRef(cwd, refsForDiff.targetRef, file.path);
                 },
             })
             : [];
@@ -1051,7 +1236,10 @@ export async function getCheckoutDiff(cwd, compare, context) {
             // `git diff -w --name-status` can still report a modified path even when the
             // whitespace-filtered patch and numstat are both empty. Skip emitting a
             // structured placeholder in that case so whitespace-only edits truly disappear.
-            if (ignoreWhitespace && !trackedDiffTruncated && stat === null) {
+            if (ignoreWhitespace &&
+                !trackedDiffTruncated &&
+                change.status.startsWith("M") &&
+                (!stat || (!stat.isBinary && stat.additions === 0 && stat.deletions === 0))) {
                 continue;
             }
             structured.push({
@@ -1153,10 +1341,10 @@ export async function mergeToBase(cwd, options = {}, context) {
     }
     let normalizedBaseRef = baseRef;
     normalizedBaseRef = normalizeLocalBranchRefName(normalizedBaseRef);
+    const currentWorktreeRoot = (await getWorktreeRoot(cwd)) ?? cwd;
     if (normalizedBaseRef === currentBranch) {
-        return;
+        return currentWorktreeRoot;
     }
-    const currentWorktreeRoot = (await getWorktreeRoot(cwd)) ?? cwd;
     const baseWorktree = await getWorktreePathForBranch(cwd, normalizedBaseRef);
     const operationCwd = baseWorktree ?? currentWorktreeRoot;
     const isSameCheckout = resolve(operationCwd) === resolve(currentWorktreeRoot);
@@ -1246,6 +1434,7 @@ export async function mergeToBase(cwd, options = {}, context) {
             }
         }
     }
+    return operationCwd;
 }
 export async function mergeFromBase(cwd, options = {}, context) {
     await requireGitRepo(cwd);
@@ -1272,7 +1461,7 @@ export async function mergeFromBase(cwd, options = {}, context) {
         }
     }
     const normalizedBaseRef = normalizeLocalBranchRefName(baseRef);
-    const bestBaseRef = await resolveBestComparisonBaseRef(cwd, normalizedBaseRef);
+    const bestBaseRef = await resolveMostAheadBaseRef(cwd, normalizedBaseRef);
     if (bestBaseRef === currentBranch) {
         return;
     }
@@ -1331,7 +1520,7 @@ export async function mergeFromBase(cwd, options = {}, context) {
         throw error;
     }
 }
-export async function pullCurrentBranch(cwd) {
+export async function pullCurrentBranch(cwd, github) {
     await requireGitRepo(cwd);
     const currentBranch = await getCurrentBranch(cwd);
     if (!currentBranch || currentBranch === "HEAD") {
@@ -1343,13 +1532,14 @@ export async function pullCurrentBranch(cwd) {
     }
     try {
         await runGitCommand(["pull"], { cwd, timeout: 120000 });
+        github?.invalidate({ cwd });
     }
     catch (error) {
         await abortGitPullConflictState(cwd);
         throw error;
     }
 }
-export async function pushCurrentBranch(cwd) {
+export async function pushCurrentBranch(cwd, github) {
     await requireGitRepo(cwd);
     const currentBranch = await getCurrentBranch(cwd);
     if (!currentBranch || currentBranch === "HEAD") {
@@ -1360,80 +1550,11 @@ export async function pushCurrentBranch(cwd) {
         throw new Error("Remote 'origin' is not configured.");
     }
     await runGitCommand(["push", "-u", "origin", currentBranch], { cwd, timeout: 120000 });
+    github?.invalidate({ cwd });
 }
-export async function resolveGhPath() {
-    if (cachedGhPath === undefined) {
-        cachedGhPath = await findExecutable("gh");
-    }
-    if (cachedGhPath === null) {
-        throw new Error("GitHub CLI (gh) is not installed or not in PATH");
-    }
-    return cachedGhPath;
-}
-function getCommandErrorText(error) {
-    if (!(error instanceof Error)) {
-        return String(error);
-    }
-    const stderr = typeof error?.stderr === "string" ? error.stderr : "";
-    const stdout = typeof error?.stdout === "string" ? error.stdout : "";
-    return `${error.message}\n${stderr}\n${stdout}`.toLowerCase();
-}
-function isGhAuthError(error) {
-    const text = getCommandErrorText(error);
-    return (text.includes("gh auth login") ||
-        text.includes("not logged into any github hosts") ||
-        text.includes("authentication failed") ||
-        text.includes("authentication required") ||
-        text.includes("bad credentials") ||
-        text.includes("http 401"));
-}
-async function resolveGitHubRepo(cwd) {
-    try {
-        const { stdout } = await runGitCommand(["config", "--get", "remote.origin.url"], {
-            cwd,
-            env: READ_ONLY_GIT_ENV,
-        });
-        const url = stdout.trim();
-        if (!url) {
-            return null;
-        }
-        let cleaned = url;
-        if (cleaned.startsWith("git@github.com:")) {
-            cleaned = cleaned.slice("git@github.com:".length);
-        }
-        else if (cleaned.startsWith("https://github.com/")) {
-            cleaned = cleaned.slice("https://github.com/".length);
-        }
-        else if (cleaned.startsWith("http://github.com/")) {
-            cleaned = cleaned.slice("http://github.com/".length);
-        }
-        else {
-            const marker = "github.com/";
-            const index = cleaned.indexOf(marker);
-            if (index !== -1) {
-                cleaned = cleaned.slice(index + marker.length);
-            }
-            else {
-                return null;
-            }
-        }
-        if (cleaned.endsWith(".git")) {
-            cleaned = cleaned.slice(0, -".git".length);
-        }
-        if (!cleaned.includes("/")) {
-            return null;
-        }
-        return cleaned;
-    }
-    catch {
-        // ignore
-    }
-    return null;
-}
-export async function createPullRequest(cwd, options) {
+export async function createPullRequest(cwd, options, github = createGitHubService(), workspaceGitService) {
     await requireGitRepo(cwd);
-    const ghPath = await resolveGhPath();
-    const repo = await resolveGitHubRepo(cwd);
+    const repo = await resolveGitHubRepo(cwd, { workspaceGitService });
     if (!repo) {
         throw new Error("Unable to determine GitHub repo from git remote");
     }
@@ -1451,31 +1572,30 @@ export async function createPullRequest(cwd, options) {
         throw new Error(`Base ref mismatch: expected ${base}, got ${options.base}`);
     }
     await runGitCommand(["push", "-u", "origin", head], { cwd, timeout: 120000 });
-    const ghEnv = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
-    const args = ["api", "-X", "POST", `repos/${repo}/pulls`, "-f", `title=${options.title}`];
-    args.push("-f", `head=${head}`);
-    args.push("-f", `base=${normalizedBase}`);
-    if (options.body) {
-        args.push("-f", `body=${options.body}`);
-    }
-    const { stdout } = await execCommand(ghPath, args, { cwd, env: ghEnv });
-    const parsed = JSON.parse(stdout.trim());
-    if (!parsed?.url || !parsed?.number) {
-        throw new Error("GitHub CLI did not return PR url/number");
-    }
-    return { url: parsed.url, number: parsed.number };
+    const result = await github.createPullRequest({
+        cwd,
+        repo,
+        title: options.title,
+        body: options.body,
+        head,
+        base: normalizedBase,
+    });
+    github.invalidate({ cwd });
+    return result;
 }
-export async function getPullRequestStatus(cwd) {
+export async function getPullRequestStatus(cwd, github = createGitHubService(), options) {
     const cacheKey = getPullRequestStatusCacheKey(cwd);
-    const cached = pullRequestStatusCache.get(cacheKey);
-    if (cached) {
-        return cached;
-    }
-    const existing = pullRequestStatusInFlight.get(cacheKey);
-    if (existing) {
-        return existing;
+    if (!options?.force) {
+        const cached = pullRequestStatusCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const existing = pullRequestStatusInFlight.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
     }
-    const lookup = getPullRequestStatusUncached(cwd)
+    const lookup = getPullRequestStatusUncached(cwd, github, options)
         .then((status) => {
         pullRequestStatusCache.set(cacheKey, status);
         return status;
@@ -1486,7 +1606,7 @@ export async function getPullRequestStatus(cwd) {
     pullRequestStatusInFlight.set(cacheKey, lookup);
     return lookup;
 }
-async function getPullRequestStatusUncached(cwd) {
+async function getPullRequestStatusUncached(cwd, github, options) {
     await requireGitRepo(cwd);
     const head = await getCurrentBranch(cwd);
     if (!head) {
@@ -1495,49 +1615,21 @@ async function getPullRequestStatusUncached(cwd) {
             githubFeaturesEnabled: false,
         };
     }
-    let ghPath;
-    try {
-        ghPath = await resolveGhPath();
-    }
-    catch {
-        return {
-            status: null,
-            githubFeaturesEnabled: false,
-        };
-    }
     try {
-        const { stdout } = await execCommand(ghPath, ["pr", "view", "--json", "url,title,state,baseRefName,headRefName,mergedAt"], { cwd, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } });
-        const pr = JSON.parse(stdout.trim());
-        if (!pr || typeof pr !== "object" || !pr.url || !pr.title) {
-            return { status: null, githubFeaturesEnabled: true };
-        }
-        const mergedAt = typeof pr.mergedAt === "string" && pr.mergedAt.trim().length > 0 ? pr.mergedAt : null;
-        const state = mergedAt !== null
-            ? "merged"
-            : typeof pr.state === "string" && pr.state.trim().length > 0
-                ? pr.state.toLowerCase()
-                : "";
+        const status = await github.getCurrentPullRequestStatus({
+            cwd,
+            headRef: head,
+            reason: options?.reason,
+        });
         return {
-            status: {
-                url: pr.url,
-                title: pr.title,
-                state,
-                baseRefName: pr.baseRefName ?? "",
-                headRefName: pr.headRefName ?? head,
-                isMerged: mergedAt !== null,
-            },
+            status,
             githubFeaturesEnabled: true,
         };
     }
     catch (error) {
-        if (isGhAuthError(error)) {
+        if (error instanceof GitHubCliMissingError || error instanceof GitHubAuthenticationError) {
             return { status: null, githubFeaturesEnabled: false };
         }
-        // gh pr view exits non-zero when no PR exists for the branch
-        const message = error instanceof Error ? error.message : String(error);
-        if (message.includes("no pull requests found") || message.includes("Could not resolve")) {
-            return { status: null, githubFeaturesEnabled: true };
-        }
         throw error;
     }
 }