@agentproto/worktree 0.14.3 → 0.14.4

package/README.md

@@ -234,7 +234,10 @@ in place rather than silently cleaned up.
 merged worktrees on a schedule, so a long-running workspace doesn't accumulate
 stale `_worktrees/*` trees and dead `wt/*` branches. It fires the `worktree_gc`
 tool (the daemon's MCP/HTTP surface over `planGc` / `applyGc` in `src/gc.ts`)
-with `apply: true`, `salvageDirty: false` on a daily cron (`0 4 * * *`, UTC).
+with `apply: true`, `salvageDirty: false`, `wait: true` on a daily cron (`0 4 * * *`, UTC).
+`wait: true` makes the cron run block for the real outcomes; without it a big
+repo outlasts the tool's 25 s default `waitMs`, the run records a bare jobId
+as success, and a failed apply never reaches `on_failure`.
 
 **It ships disabled (`enabled: false`)** — it registers but never fires until
 you turn it on. To activate it in a workspace:

package/dist/index.d.ts

@@ -2141,6 +2141,17 @@ 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>;
+    /** Tip sha → `git merge-base baseSha tip`, filled by the same pass as
+     *  `related` — saves the ladder's second `merge-base` per related tip. */
+    mergeBases?: ReadonlyMap<string, string>;
+    /**
+     * Memoized `git patch-id --stable` of non-merge commits (the key `git
+     * cherry` matches on), batched and shared across tips: `git cherry` re-did
+     * the patch-id of every base commit since the merge-base for EVERY tip.
+     * `null` for a commit with no patch (empty diff) and `null` for the whole
+     * call when git failed — both mean "ask `git cherry` itself".
+     */
+    patchIds?: (shas: readonly string[]) => Promise<Map<string, string | null> | null>;
     /**
      * Memoized set of every commit reachable from `cmp` (at most two distinct
      * values: `baseSha` and the anchor) — ONE `git rev-list <cmp>` replaces one
@@ -2149,7 +2160,7 @@ interface LadderContext {
      */
     ancestorsOf?: (cmp: string) => Promise<Set<string> | null>;
 }
-declare function createLadderContext(repoRoot: string, baseRef: string, anchor: string | null, related?: ReadonlyMap<string, boolean>): Promise<LadderContext>;
+declare function createLadderContext(repoRoot: string, baseRef: string, anchor: string | null, related?: ReadonlyMap<string, boolean>, mergeBases?: ReadonlyMap<string, string>): Promise<LadderContext>;
 /**
  * Run the ladder for one tip against `ctx`'s base. Pure read. A tip with no
  * history in common with base is checked against the anchor when there is one
@@ -2173,7 +2184,9 @@ declare function classifyTipAgainstBase(repoRoot: string, baseRef: string, tip:
 declare function detectAnchor(repoRoot: string, baseSha: string, tips: readonly string[], 
 /** Filled with every tip's answer (`true` = shares history with base) for
  *  the ladder to reuse — see {@link LadderContext.related}. */
-related?: Map<string, boolean>): Promise<string | null>;
+related?: Map<string, boolean>, 
+/** Filled with `merge-base baseSha tip` for every related tip — see {@link LadderContext.mergeBases}. */
+mergeBases?: Map<string, string>): Promise<string | null>;
 declare const DEFAULT_BRANCH_GC_MIN_AGE_DAYS = 3;
 interface PlanBranchGcInput {
     repoRoot: string;

package/dist/index.mjs

@@ -503,7 +503,7 @@ async function indexTree(repoRoot, sha) {
   const names = new Set([...byPath.keys()].map(basenameOf));
   return { byPath, blobs: new Set(byPath.values()), names };
 }
-async function createLadderContext(repoRoot, baseRef, anchor, related) {
+async function createLadderContext(repoRoot, baseRef, anchor, related, mergeBases) {
   const baseSha = (await gitOk(repoRoot, ["rev-parse", "--verify", `${baseRef}^{commit}`])).trim();
   const baseTree = (await gitOk(repoRoot, ["rev-parse", `${baseSha}^{tree}`])).trim();
   let idx = null;
@@ -522,6 +522,33 @@ async function createLadderContext(repoRoot, baseRef, anchor, related) {
     }
     return p;
   };
+  const patchIdCache = /* @__PURE__ */ new Map();
+  const patchIds = async (shas) => {
+    const fresh = [...new Set(shas)].filter((sha) => !patchIdCache.has(sha));
+    if (fresh.length) {
+      const settle = /* @__PURE__ */ new Map();
+      for (const sha of fresh) {
+        const p = new Promise((resolve4, reject) => settle.set(sha, { resolve: resolve4, reject }));
+        p.catch(() => patchIdCache.delete(sha));
+        patchIdCache.set(sha, p);
+      }
+      await pool(chunk(fresh, PATCH_ID_BATCH), 2, async (batch) => {
+        try {
+          const got = await patchIdsOf(repoRoot, batch);
+          for (const sha of batch) settle.get(sha)?.resolve(got.get(sha) ?? null);
+        } catch (err) {
+          for (const sha of batch) settle.get(sha)?.reject(err);
+        }
+      });
+    }
+    try {
+      const out = /* @__PURE__ */ new Map();
+      for (const sha of shas) out.set(sha, await patchIdCache.get(sha) ?? null);
+      return out;
+    } catch {
+      return null;
+    }
+  };
   return {
     repoRoot,
     baseSha,
@@ -529,11 +556,96 @@ async function createLadderContext(repoRoot, baseRef, anchor, related) {
     anchor,
     index: () => idx ??= indexTree(repoRoot, baseSha),
     ancestorsOf,
-    ...related ? { related } : {}
+    patchIds,
+    ...related ? { related } : {},
+    ...mergeBases ? { mergeBases } : {}
   };
 }
-async function sharesHistory(repoRoot, baseSha, tip) {
-  return (await git(repoRoot, ["merge-base", baseSha, tip])).exitCode === 0;
+var PATCH_ID_BATCH = 500;
+function patchIdsOf(repoRoot, shas) {
+  return new Promise((resolvePromise, reject) => {
+    const log = spawn(
+      "git",
+      [
+        "-C",
+        repoRoot,
+        "-c",
+        "diff.noprefix=false",
+        "-c",
+        "diff.mnemonicPrefix=false",
+        "log",
+        "--no-walk=unsorted",
+        "--stdin",
+        "-p",
+        "--no-color",
+        "--no-renames",
+        "--no-textconv",
+        "--no-ext-diff"
+      ],
+      { cwd: repoRoot, stdio: ["pipe", "pipe", "pipe"] }
+    );
+    const pid = spawn("git", ["-C", repoRoot, "patch-id", "--stable"], { cwd: repoRoot, stdio: ["pipe", "pipe", "pipe"] });
+    let out = "";
+    let logCode = null;
+    let pidCode = null;
+    let failed = false;
+    const fail = (err) => {
+      if (failed) return;
+      failed = true;
+      log.kill();
+      pid.kill();
+      reject(err instanceof Error ? err : new Error(String(err)));
+    };
+    const done = () => {
+      if (failed || logCode === null || pidCode === null) return;
+      if (logCode !== 0 || pidCode !== 0) return fail(new Error(`patch-id batch failed (log exit ${logCode}, patch-id exit ${pidCode})`));
+      const ids = /* @__PURE__ */ new Map();
+      for (const line of out.split("\n")) {
+        const [id, commit] = line.split(" ");
+        if (id && commit) ids.set(commit, id);
+      }
+      resolvePromise(ids);
+    };
+    log.stdout.pipe(pid.stdin);
+    log.stdout.on("error", fail);
+    pid.stdin.on("error", () => {
+    });
+    pid.stdout.on("data", (d) => out += d.toString("utf8"));
+    log.stderr.resume();
+    pid.stderr.resume();
+    log.on("error", fail);
+    pid.on("error", fail);
+    log.on("close", (code) => {
+      logCode = code ?? -1;
+      done();
+    });
+    pid.on("close", (code) => {
+      pidCode = code ?? -1;
+      done();
+    });
+    log.stdin.on("error", () => {
+    });
+    log.stdin.end(shas.join("\n") + "\n");
+  });
+}
+async function allPatchEquivalent(ctx, cmp, tip) {
+  if (!ctx.patchIds) return null;
+  const lines = async (range) => (await gitOk(ctx.repoRoot, ["rev-list", "--no-merges", range])).split("\n").filter(Boolean);
+  const [tipOnly, upstreamOnly] = await Promise.all([lines(`${cmp}..${tip}`), lines(`${tip}..${cmp}`)]);
+  const ids = await ctx.patchIds([...tipOnly, ...upstreamOnly]);
+  if (!ids) return null;
+  const upstream = /* @__PURE__ */ new Set();
+  for (const sha of upstreamOnly) {
+    const id = ids.get(sha);
+    if (id) upstream.add(id);
+  }
+  let unknown = false;
+  for (const sha of tipOnly) {
+    const id = ids.get(sha);
+    if (!id) unknown = true;
+    else if (!upstream.has(id)) return false;
+  }
+  return unknown ? null : true;
 }
 var NULL_SHA_RE = /^0+$/;
 async function changedBlobs(repoRoot, mergeBase, tip) {
@@ -592,7 +704,13 @@ async function coverage(ctx, tip, mergeBase) {
 }
 async function classifyTip(ctx, tip) {
   const { repoRoot, baseSha, baseTree, anchor } = ctx;
-  const related = ctx.related?.get(tip) ?? await sharesHistory(repoRoot, baseSha, tip);
+  let relatedMergeBase = ctx.mergeBases?.get(tip);
+  let related = ctx.related?.get(tip);
+  if (related === void 0) {
+    const res = await git(repoRoot, ["merge-base", baseSha, tip]);
+    related = res.exitCode === 0;
+    if (related) relatedMergeBase = res.stdout.trim();
+  }
   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;
@@ -604,13 +722,13 @@ async function classifyTip(ctx, tip) {
   const counts = (await gitOk(repoRoot, ["rev-list", "--left-right", "--count", `${cmp}...${tip}`])).trim().split(/\s+/);
   const behind = Number(counts[0]);
   const ahead = Number(counts[1]);
-  const mergeBase = (await git(repoRoot, ["merge-base", cmp, tip])).stdout.trim();
+  const mergeBase = (related ? relatedMergeBase : void 0) ?? (await git(repoRoot, ["merge-base", cmp, tip])).stdout.trim();
   const mtArgs = related ? [baseSha, tip] : [`--merge-base=${mergeBase}`, baseSha, tip];
   const mt = await git(repoRoot, ["merge-tree", "--write-tree", "--no-messages", ...mtArgs]);
   const mergedTree = (mt.stdout.split("\n")[0] ?? "").trim();
   const conflicts = mt.exitCode !== 0;
   if (!conflicts && mergedTree === baseTree) return { status: "squash-merged", history, ahead, behind, conflicts };
-  if (conflicts) {
+  if (conflicts && await allPatchEquivalent(ctx, cmp, tip) !== false) {
     const cherry = await gitOk(repoRoot, ["cherry", cmp, tip]);
     if (!cherry.split("\n").some((l) => l.startsWith("+"))) return { status: "patch-merged", history, ahead, behind, conflicts };
   }
@@ -653,14 +771,18 @@ async function classifyTipAgainstBase(repoRoot, baseRef, tip) {
   }
   return classifyTip(await ctx, tip);
 }
-async function detectAnchor(repoRoot, baseSha, tips, related) {
+async function detectAnchor(repoRoot, baseSha, tips, related, mergeBases) {
   const roots = (await gitOk(repoRoot, ["rev-list", "--max-parents=0", baseSha])).trim().split("\n").filter(Boolean);
   if (roots.length !== 1) return null;
   const root = roots[0];
   const unique = [...new Set(tips)];
-  const shares = await pool(unique, 8, (sha) => sharesHistory(repoRoot, baseSha, sha));
-  const unrelated = unique.filter((_, i) => !shares[i]);
-  if (related) unique.forEach((sha, i) => related.set(sha, shares[i]));
+  const bases = await pool(unique, 8, async (sha) => {
+    const res = await git(repoRoot, ["merge-base", baseSha, sha]);
+    return res.exitCode === 0 ? res.stdout.trim() : null;
+  });
+  const unrelated = unique.filter((_, i) => bases[i] === null);
+  if (related) unique.forEach((sha, i) => related.set(sha, bases[i] !== null));
+  if (mergeBases) unique.forEach((sha, i) => bases[i] !== null && mergeBases.set(sha, bases[i]));
   if (!unrelated.length) return null;
   const rootDate = (await gitOk(repoRoot, ["log", "-1", "--format=%cI", root])).trim();
   const since = new Date(new Date(rootDate).getTime() - 3 * 864e5).toISOString();
@@ -835,10 +957,11 @@ async function snapshot(input) {
   const baseSha = (await gitOk(input.repoRoot, ["rev-parse", "--verify", `${input.base}^{commit}`])).trim();
   let anchor;
   const related = /* @__PURE__ */ new Map();
-  if (input.anchor === "auto") anchor = await detectAnchor(input.repoRoot, baseSha, refs.map((r) => r.sha), related);
+  const mergeBases = /* @__PURE__ */ new Map();
+  if (input.anchor === "auto") anchor = await detectAnchor(input.repoRoot, baseSha, refs.map((r) => r.sha), related, mergeBases);
   else if (input.anchor) anchor = (await gitOk(input.repoRoot, ["rev-parse", "--verify", `${input.anchor}^{commit}`])).trim();
   else anchor = null;
-  const ctx = await createLadderContext(input.repoRoot, baseSha, anchor, related);
+  const ctx = await createLadderContext(input.repoRoot, baseSha, anchor, related, mergeBases);
   const remoteRefs = refs.filter((r) => r.kind === "remote");
   const MAX_REACHABLE = 5e5;
   const revListSet = async (args) => {