@agentproto/worktree 0.9.0 → 0.10.0

package/dist/index.d.ts

@@ -1694,6 +1694,8 @@ interface BranchGcPlan {
     generatedAt: string;
     /** Refs of OTHER configured remotes: never classified, never touched. */
     otherRemoteRefs: number;
+    /** true = `git fetch --prune` of the base remote succeeded; false = it failed; null = skipped (opt-out or no remote). */
+    fetched: boolean | null;
     entries: BranchGcPlanEntry[];
 }
 /** Base content index, built once per base: path→blob, every blob, every basename. */
@@ -1713,6 +1715,13 @@ interface LadderContext {
      *  plan's anchor detection asks the same question of every tip) — saves
      *  the ladder's first `merge-base` per tip. */
     related?: ReadonlyMap<string, boolean>;
+    /**
+     * Memoized set of every commit reachable from `cmp` (at most two distinct
+     * values: `baseSha` and the anchor) — ONE `git rev-list <cmp>` replaces one
+     * `merge-base --is-ancestor` per tip. `null` above 500 000 commits (or on a
+     * git failure) = fall back to the per-tip call.
+     */
+    ancestorsOf?: (cmp: string) => Promise<Set<string> | null>;
 }
 declare function createLadderContext(repoRoot: string, baseRef: string, anchor: string | null, related?: ReadonlyMap<string, boolean>): Promise<LadderContext>;
 /**
@@ -1760,6 +1769,8 @@ interface PlanBranchGcInput {
     nowMs?: number;
     /** Parallel ladder runs. Default 8. */
     concurrency?: number;
+    /** Run `git fetch --prune <baseRemote>` before classifying. Default true. */
+    fetch?: boolean;
 }
 /** The dry-run plan: classify every ref in `scopes`, mutate nothing. */
 declare function planBranchGc(input: PlanBranchGcInput): Promise<BranchGcPlan>;
@@ -1873,6 +1884,8 @@ interface ApplyBranchGcOptions {
     nowMs?: number;
     /** Remote refs per `git push --delete`. Default 50. */
     remoteBatchSize?: number;
+    /** Run `git fetch --prune <baseRemote>` before re-deriving entries. Default true. */
+    fetch?: boolean;
 }
 interface BranchGcApplyResult {
     outcomes: BranchGcApplyOutcome[];

package/dist/index.mjs

@@ -507,12 +507,28 @@ async function createLadderContext(repoRoot, baseRef, anchor, related) {
   const baseSha = (await gitOk(repoRoot, ["rev-parse", "--verify", `${baseRef}^{commit}`])).trim();
   const baseTree = (await gitOk(repoRoot, ["rev-parse", `${baseSha}^{tree}`])).trim();
   let idx = null;
+  const ancestors = /* @__PURE__ */ new Map();
+  const ancestorsOf = (cmp) => {
+    let p = ancestors.get(cmp);
+    if (!p) {
+      p = (async () => {
+        const res = await git(repoRoot, ["rev-list", cmp]);
+        if (res.exitCode !== 0) return null;
+        const shas = res.stdout.split("\n");
+        if (shas.length > 5e5) return null;
+        return new Set(shas.filter(Boolean));
+      })();
+      ancestors.set(cmp, p);
+    }
+    return p;
+  };
   return {
     repoRoot,
     baseSha,
     baseTree,
     anchor,
     index: () => idx ??= indexTree(repoRoot, baseSha),
+    ancestorsOf,
     ...related ? { related } : {}
   };
 }
@@ -580,7 +596,9 @@ async function classifyTip(ctx, tip) {
   if (!related && !anchor) return { status: "unmerged", history: "unrelated", conflicts: true, ahead: null, behind: null };
   const history = related ? "current" : "pre-rewrite";
   const cmp = related ? baseSha : anchor;
-  if ((await git(repoRoot, ["merge-base", "--is-ancestor", tip, cmp])).exitCode === 0) {
+  const ancestors = ctx.ancestorsOf ? await ctx.ancestorsOf(cmp) : null;
+  const isAncestor = ancestors ? ancestors.has(tip) : (await git(repoRoot, ["merge-base", "--is-ancestor", tip, cmp])).exitCode === 0;
+  if (isAncestor) {
     return { status: "merged", history, ahead: 0, behind: null };
   }
   const counts = (await gitOk(repoRoot, ["rev-list", "--left-right", "--count", `${cmp}...${tip}`])).trim().split(/\s+/);
@@ -736,12 +754,19 @@ async function pushStateOf(b, env) {
   if (b.kind === "local") {
     if (env.remoteShas.has(b.sha)) return "same-tip-on-remote";
     if (env.remote) {
-      const contained = await git(repoRoot, ["for-each-ref", "--contains", b.sha, "--format=x", `refs/remotes/${env.remote}`]);
-      if (contained.stdout.trim()) return "contained-in-remote";
+      const reachable = env.remoteReachable ? await env.remoteReachable() : null;
+      if (reachable) {
+        if (reachable.has(b.sha)) return "contained-in-remote";
+      } else {
+        const contained = await git(repoRoot, ["for-each-ref", "--contains", b.sha, "--format=x", `refs/remotes/${env.remote}`]);
+        if (contained.stdout.trim()) return "contained-in-remote";
+      }
     }
     return env.remoteNames.has(b.name) ? "diverged-from-remote" : "local-only";
   }
   if (b.kind === "orphan") {
+    const reachable = env.localOrRemoteReachable ? await env.localOrRemoteReachable() : null;
+    if (reachable) return reachable.has(b.sha) ? "contained-elsewhere" : "only-copy";
     const scopes = ["refs/heads", ...env.remote ? [`refs/remotes/${env.remote}`] : []];
     const contained = await git(repoRoot, ["for-each-ref", "--contains", b.sha, "--format=x", ...scopes]);
     return contained.stdout.trim() ? "contained-elsewhere" : "only-copy";
@@ -797,6 +822,10 @@ async function classifyRef(b, env) {
 async function snapshot(input) {
   const remotes = await configuredRemotes(input.repoRoot);
   const remote = baseRemoteOf(input.base, remotes);
+  let fetched = null;
+  if (remote && input.fetch !== false) {
+    fetched = (await git(input.repoRoot, ["fetch", "--prune", "--quiet", remote])).exitCode === 0;
+  }
   const [{ refs, otherRemoteRefs }, worktrees, prs, mergedPrs] = await Promise.all([
     listBranchRefs(input.repoRoot, remote, remotes),
     worktreeBranches(input.repoRoot),
@@ -811,9 +840,20 @@ async function snapshot(input) {
   else anchor = null;
   const ctx = await createLadderContext(input.repoRoot, baseSha, anchor, related);
   const remoteRefs = refs.filter((r) => r.kind === "remote");
+  const MAX_REACHABLE = 5e5;
+  const revListSet = async (args) => {
+    const res = await git(input.repoRoot, ["rev-list", ...args]);
+    if (res.exitCode !== 0) return null;
+    const shas = res.stdout.split("\n");
+    if (shas.length > MAX_REACHABLE) return null;
+    return new Set(shas.filter(Boolean));
+  };
+  let remoteReachableP = null;
+  let localOrRemoteP = null;
   return {
     refs,
     otherRemoteRefs,
+    fetched,
     env: {
       ctx,
       tips: /* @__PURE__ */ new Map(),
@@ -824,6 +864,10 @@ async function snapshot(input) {
       mergedPrShas: mergedPrs,
       remoteShas: new Set(remoteRefs.map((r) => r.sha)),
       remoteNames: new Set(remoteRefs.map((r) => r.name)),
+      ...remote ? {
+        remoteReachable: () => remoteReachableP ??= revListSet([`--glob=refs/remotes/${remote}/*`]),
+        localOrRemoteReachable: () => localOrRemoteP ??= revListSet(["--branches", `--glob=refs/remotes/${remote}/*`])
+      } : {},
       minAgeDays: input.minAgeDays,
       includeReviewed: input.includeReviewed,
       ...input.verdicts ? { verdicts: input.verdicts } : {},
@@ -857,7 +901,8 @@ async function planBranchGc(input) {
     ...input.verdicts ? { verdicts: input.verdicts } : {},
     minAgeDays,
     includeReviewed,
-    nowMs
+    nowMs,
+    ...input.fetch === false ? { fetch: false } : {}
   });
   const inScope = snap.refs.filter((r) => scopes.includes(r.kind));
   const entries = await pool(inScope, input.concurrency ?? 8, (r) => classifyRef(r, snap.env));
@@ -875,6 +920,7 @@ async function planBranchGc(input) {
     includeReviewed,
     generatedAt: new Date(nowMs).toISOString(),
     otherRemoteRefs: snap.otherRemoteRefs,
+    fetched: snap.fetched,
     entries
   };
 }
@@ -963,7 +1009,8 @@ async function applyBranchGc(plan, options) {
     ...options.verdicts ? { verdicts: options.verdicts } : {},
     minAgeDays: plan.minAgeDays,
     includeReviewed: plan.includeReviewed,
-    nowMs: options.nowMs ?? Date.now()
+    nowMs: options.nowMs ?? Date.now(),
+    ...options.fetch === false ? { fetch: false } : {}
   });
   const current = new Map(snap.refs.map((r) => [r.ref, r]));
   const outcomes = [];
@@ -1025,22 +1072,33 @@ async function applyBranchGc(plan, options) {
   for (const [remote, list] of byRemote) {
     const failedBatches = [];
     for (const batch of chunk(list, options.remoteBatchSize ?? 50)) {
-      const res = await git(repoRoot, ["push", remote, "--delete", ...batch.map((e) => e.name)]);
+      const res = await git(repoRoot, ["push", "--no-verify", remote, "--delete", ...batch.map((e) => e.name)]);
       if (res.exitCode === 0) for (const e of batch) results.set(e.ref, { ok: true });
       else failedBatches.push({ batch, res });
     }
     await git(repoRoot, ["fetch", "--prune", "--quiet", remote]);
-    let retried = false;
+    const stillThere = [];
     for (const { batch } of failedBatches) {
       for (const e of batch) {
-        if ((await git(repoRoot, ["rev-parse", "--verify", "--quiet", e.ref])).exitCode !== 0) {
-          results.set(e.ref, { ok: true });
-          continue;
-        }
-        const one = await git(repoRoot, ["push", remote, "--delete", e.name]);
-        results.set(e.ref, one.exitCode === 0 ? { ok: true } : fail(one));
-        retried = true;
+        if ((await git(repoRoot, ["rev-parse", "--verify", "--quiet", e.ref])).exitCode === 0) stillThere.push(e);
+        else results.set(e.ref, { ok: true });
+      }
+    }
+    const failedAgain = [];
+    for (const batch of chunk(stillThere, options.remoteBatchSize ?? 50)) {
+      const retry = await git(repoRoot, ["push", "--no-verify", remote, "--delete", ...batch.map((e) => e.name)]);
+      if (retry.exitCode === 0) for (const e of batch) results.set(e.ref, { ok: true });
+      else failedAgain.push(...batch);
+    }
+    const retried = failedAgain.length > 0;
+    if (retried) await git(repoRoot, ["fetch", "--prune", "--quiet", remote]);
+    for (const e of failedAgain) {
+      if ((await git(repoRoot, ["rev-parse", "--verify", "--quiet", e.ref])).exitCode !== 0) {
+        results.set(e.ref, { ok: true });
+        continue;
       }
+      const one = await git(repoRoot, ["push", "--no-verify", remote, "--delete", e.name]);
+      results.set(e.ref, one.exitCode === 0 ? { ok: true } : fail(one));
     }
     if (retried) await git(repoRoot, ["fetch", "--prune", "--quiet", remote]);
   }