Offer to fetch more history when merge base fails in shallow clones

When getMergeBase fails and the repository is a shallow clone,
prompt the user to progressively deepen the clone until the
merge base is found. Uses the VS Code Git API for fetching
(proper auth support). Falls back to unshallowing as last resort.

Also:
- Limit diff entries to 10,000 to avoid performance issues
- Add timing to git command log output

Author: letmaik

CHANGELOG.md

@@ -1,6 +1,8 @@
 ## 1.20.0
 
 * Add file filter functionality to tree view
+* Automatically offer to fetch more history when merge base cannot be found in shallow clones
+* Limit displayed diff entries to 10,000 to avoid performance issues
 
 ## 1.19.0
 

package.json

@@ -2,7 +2,7 @@
     "name": "git-tree-compare",
     "displayName": "Git Tree Compare",
     "description": "Diff your worktree against a branch, tag, or commit in a tree -- especially useful for pull request preparation or merge preview",
-    "version": "1.19.0",
+    "version": "1.20.0",
     "author": {
         "name": "Maik Riechert",
         "url": "https://github.com/letmaik"

src/deepenHelper.ts

@@ -0,0 +1,284 @@
+import * as path from 'path';
+import { promises as fs } from 'fs';
+
+import { window, ProgressLocation } from 'vscode';
+import { Repository } from './git/git';
+import { Repository as GitAPIRepository } from './typings/git';
+import { getAbsGitCommonDir } from './gitHelper';
+
+type LogFn = (msg: string) => void;
+
+interface FetchTarget {
+    remote: string;
+    branch: string;
+    estimatedDepth: number;
+}
+
+const DEPTH_FLOOR = 1024;
+const DEPTH_STEPS = 4;
+const DEPTH_CAP = 1_000_000;
+
+/**
+ * If a merge base could not be determined and the repository is a shallow clone,
+ * offers the user the option to fetch more history (and as a last resort, unshallow)
+ * to resolve the merge base.
+ *
+ * Returns the discovered merge base, or undefined if the repository is not shallow,
+ * the user declined, the user cancelled, or all attempts failed.
+ */
+export async function tryDeepenForMergeBase(
+    repository: Repository,
+    gitApiRepo: GitAPIRepository,
+    headRef: string,
+    headBranchName: string | undefined,
+    baseRef: string,
+    log: LogFn,
+): Promise<string | undefined> {
+    const commonDir = await getAbsGitCommonDir(repository);
+    const shallowBoundary = await readShallowBoundary(commonDir);
+    if (!shallowBoundary) {
+        // not a shallow clone; deepening cannot help
+        return undefined;
+    }
+    log(`Repository is a shallow clone (${shallowBoundary.length} boundary commit(s))`);
+
+    const baseTarget = await resolveFetchTarget(repository, baseRef, log);
+    if (baseTarget) {
+        log(`Base ref "${baseRef}" resolved to fetchable target: ${baseTarget.remote}/${baseTarget.branch}`);
+    } else {
+        log(`Base ref "${baseRef}" could not be resolved to a fetchable target`);
+    }
+    const headTarget = headBranchName
+        ? await resolveFetchTarget(repository, headBranchName, log)
+        : undefined;
+    if (headBranchName) {
+        if (headTarget) {
+            log(`HEAD ref "${headBranchName}" resolved to fetchable target: ${headTarget.remote}/${headTarget.branch}`);
+        } else {
+            log(`HEAD ref "${headBranchName}" could not be resolved to a fetchable target`);
+        }
+    } else {
+        log('HEAD is detached, skipping HEAD target resolution');
+    }
+
+    if (!baseTarget && !headTarget) {
+        log('Neither base nor HEAD ref maps to a fetchable remote; cannot deepen.');
+        return undefined;
+    }
+
+    const targets: FetchTarget[] = [];
+    if (baseTarget) targets.push(baseTarget);
+    if (headTarget && !sameTarget(headTarget, baseTarget)) targets.push(headTarget);
+
+    const action = 'Fetch more history';
+    const choice = await window.showErrorMessage(
+        `No merge base could be found between "${headRef}" and "${baseRef}". ` +
+        `The repository is a shallow clone — fetching more history may resolve this.`,
+        action);
+    if (choice !== action) {
+        return undefined;
+    }
+
+    const headDepth = await estimateTargetDepths(repository, shallowBoundary, targets, log);
+    // Sort shallowest first — that's the side most likely to need deepening.
+    targets.sort((a, b) => a.estimatedDepth - b.estimatedDepth);
+    // Schedule is based on the shallowest depth across all sides (including HEAD,
+    // even if it's not a fetchable target), because the merge base can't be found
+    // until the shallow side has enough history.
+    const minDepth = Math.min(headDepth, ...targets.map(t => t.estimatedDepth));
+    const schedule = buildSchedule(minDepth);
+    log(`HEAD depth: ${headDepth}`);
+    log(`Target depths: ${targets.map(t => `${t.remote}/${t.branch}=${t.estimatedDepth}`).join(', ')}`);
+    log(`Min depth (for schedule): ${minDepth}`);
+    log(`Deepening schedule: [${schedule.join(', ')}]`);
+
+    const found = await window.withProgress({
+        location: ProgressLocation.Notification,
+        title: 'Fetching more history',
+        cancellable: true,
+    }, async (progress, token) => {
+        for (const depth of schedule) {
+            if (token.isCancellationRequested) return undefined;
+            for (const target of targets) {
+                if (token.isCancellationRequested) return undefined;
+                if (target.estimatedDepth >= depth) {
+                    log(`Skipping ${target.remote}/${target.branch} (estimated depth ${target.estimatedDepth} >= ${depth})`);
+                    continue;
+                }
+                progress.report({ message: `Fetching ${target.remote}/${target.branch} at depth ${depth}...` });
+                try {
+                    log(`Fetching ${target.remote} ${target.branch} --depth=${depth}`);
+                    await gitApiRepo.fetch(target.remote, target.branch, depth);
+                } catch (e: any) {
+                    log(`Fetch failed: ${e.message || e}`);
+                    // continue with the next target / depth
+                }
+            }
+            if (token.isCancellationRequested) return undefined;
+            const mb = await tryGetMergeBase(repository, headRef, baseRef, log);
+            if (mb) return mb;
+        }
+        return undefined;
+    });
+
+    if (found) return found;
+
+    // Last resort: offer to unshallow.
+    const unshallow = 'Unshallow';
+    const finalChoice = await window.showErrorMessage(
+        `Still no merge base found between "${headRef}" and "${baseRef}". ` +
+        `Fetch the full repository history?`,
+        unshallow);
+    if (finalChoice !== unshallow) {
+        return undefined;
+    }
+
+    return await window.withProgress({
+        location: ProgressLocation.Notification,
+        title: 'Unshallowing repository',
+        cancellable: true,
+    }, async (progress, token) => {
+        progress.report({ message: 'Fetching full history...' });
+        try {
+            log('Unshallowing repository (git pull --unshallow)');
+            await gitApiRepo.pull(true);
+        } catch (e: any) {
+            log(`Unshallow failed: ${e.message || e}`);
+            return undefined;
+        }
+        if (token.isCancellationRequested) return undefined;
+        return await tryGetMergeBase(repository, headRef, baseRef, log);
+    });
+}
+
+async function tryGetMergeBase(repository: Repository, ref1: string, ref2: string, log: LogFn): Promise<string | undefined> {
+    try {
+        const mb = await repository.getMergeBase(ref1, ref2);
+        if (mb) {
+            log(`Merge base found after deepening: ${mb}`);
+            return mb;
+        }
+    } catch (e: any) {
+        log(`getMergeBase still failing: ${e.message || e}`);
+    }
+    return undefined;
+}
+
+/**
+ * Reads .git/shallow (in the common gitdir) and returns the boundary commit hashes,
+ * or undefined if the repository is not shallow.
+ */
+async function readShallowBoundary(commonDir: string): Promise<string[] | undefined> {
+    const shallowPath = path.join(commonDir, 'shallow');
+    let content: string;
+    try {
+        content = await fs.readFile(shallowPath, 'utf8');
+    } catch (e: any) {
+        if (e.code === 'ENOENT') return undefined;
+        throw e;
+    }
+    const lines = content.split('\n').map(l => l.trim()).filter(l => l.length > 0);
+    if (lines.length === 0) return undefined;
+    return lines;
+}
+
+/**
+ * Resolves a ref to a (remote, branch) pair suitable for `git fetch <remote> <branch>`.
+ * Handles:
+ *   - remote-tracking refs like "origin/main" or "origin/feature/foo"
+ *   - local branches with a configured upstream
+ * Returns undefined for detached HEAD, local branches without upstream, or unknown refs.
+ */
+async function resolveFetchTarget(repository: Repository, ref: string, log: LogFn): Promise<FetchTarget | undefined> {
+    let remotes: { name: string }[];
+    try {
+        remotes = await repository.getRemotes();
+    } catch (e: any) {
+        log(`Could not list remotes: ${e.message || e}`);
+        return undefined;
+    }
+    if (remotes.length === 0) return undefined;
+
+    // Match against remote-tracking ref pattern: <remote>/<branch...>
+    // Sort by name length descending so a remote named "origin/foo" would be matched
+    // before "origin", although such names are unusual.
+    const sorted = [...remotes].sort((a, b) => b.name.length - a.name.length);
+    for (const r of sorted) {
+        const prefix = r.name + '/';
+        if (ref.startsWith(prefix)) {
+            const branch = ref.substring(prefix.length);
+            if (branch.length > 0) {
+                return { remote: r.name, branch, estimatedDepth: 0 };
+            }
+        }
+    }
+
+    // Try as local branch with upstream
+    try {
+        const branch = await repository.getBranch(ref);
+        if (branch.upstream && branch.upstream.remote && branch.upstream.name) {
+            return { remote: branch.upstream.remote, branch: branch.upstream.name, estimatedDepth: 0 };
+        }
+    } catch (e: any) {
+        // not a branch, or no upstream; ignore
+    }
+
+    // Last resort: speculatively assume the branch exists on a remote.
+    // A failed fetch is handled gracefully (caught and logged).
+    if (sorted.length > 0) {
+        return { remote: sorted[sorted.length - 1].name, branch: ref, estimatedDepth: 0 };
+    }
+    return undefined;
+}
+
+function sameTarget(a: FetchTarget, b: FetchTarget | undefined): boolean {
+    return !!b && a.remote === b.remote && a.branch === b.branch;
+}
+
+/**
+ * Estimates the current shallow depth for each fetch target and stores it
+ * on the target's `estimatedDepth` field. Also probes HEAD.
+ * Best-effort: targets default to 0 on failure.
+ * Returns the estimated HEAD depth.
+ */
+async function estimateTargetDepths(
+    repository: Repository,
+    boundary: string[],
+    targets: FetchTarget[],
+    log: LogFn,
+): Promise<number> {
+    // Also probe HEAD to get the best estimate for the head-side target.
+    const headDepth = await countCommitsToBoundary(repository, 'HEAD', boundary, log) ?? 0;
+    for (const t of targets) {
+        const refDepth = await countCommitsToBoundary(
+            repository, `refs/remotes/${t.remote}/${t.branch}`, boundary, log) ?? 0;
+        // For the head-side target, the remote-tracking ref may not exist yet
+        // (e.g. local branch). Use HEAD depth as a better proxy in that case.
+        t.estimatedDepth = Math.max(refDepth, refDepth === 0 ? headDepth : 0);
+    }
+    return headDepth;
+}
+
+async function countCommitsToBoundary(repository: Repository, ref: string, boundary: string[], log: LogFn): Promise<number | undefined> {
+    const args = ['rev-list', '--count', '--first-parent', ref, ...boundary.map(s => '^' + s)];
+    try {
+        const result = await repository.exec(args);
+        const n = parseInt(result.stdout.trim(), 10);
+        if (!isNaN(n)) return n;
+    } catch (e: any) {
+        log(`Could not count commits for ${ref}: ${e.message || e}`);
+    }
+    return undefined;
+}
+
+function buildSchedule(startDepth: number): number[] {
+    const schedule: number[] = [];
+    let depth = Math.max(DEPTH_FLOOR, startDepth * 2);
+    for (let i = 0; i < DEPTH_STEPS; i++) {
+        depth = Math.min(depth, DEPTH_CAP);
+        schedule.push(depth);
+        if (depth >= DEPTH_CAP) break;
+        depth *= 2;
+    }
+    return schedule;
+}

src/git/git.ts

@@ -531,7 +531,13 @@ export class Git {
 			child.stdin!.end(options.input, 'utf8');
 		}
 
+		const startTime = Date.now();
 		const bufferResult = await exec(child, options.cancellationToken);
+		const elapsedMs = Date.now() - startTime;
+
+		if (options.log !== false) {
+			this.log(`  [${elapsedMs}ms]\n`);
+		}
 
 		if (options.log !== false && bufferResult.stderr.length > 0) {
 			this.log(`${bufferResult.stderr}\n`);