merge-steward 0.8.5 → 0.8.7

package/dist/github/shell-git.d.ts

@@ -4,13 +4,27 @@ export declare class ShellGitOperations implements GitOperations, SpeculativeBra
     private readonly clonePath;
     private readonly repoFullName;
     private readonly gitBin;
+    private readonly worktreeBase;
     constructor(clonePath: string, repoFullName: string, gitBin?: string);
     private git;
+    /** Run a git command in a specific directory (worktree). */
+    private gitIn;
     fetch(remote?: string): Promise<void>;
     headSha(branch: string): Promise<string>;
     isAncestor(ancestor: string, descendant: string): Promise<boolean>;
-    mergeBaseInto(branch: string, base: string): Promise<MergeResult>;
     push(branch: string, force?: boolean, targetBranch?: string): Promise<void>;
+    /**
+     * Build a speculative merge branch using an isolated git worktree.
+     * Each call gets its own working directory — no shared mutable state.
+     * The worktree is removed after the merge; the branch ref persists
+     * so the reconciler can push it and reference its SHA.
+     */
     buildSpeculative(prBranch: string, baseBranch: string, specName: string): Promise<MergeResult>;
+    /**
+     * During a merge conflict, check if the only unmerged files are lockfiles
+     * (package-lock.json). If so, resolve by regenerating from the merged
+     * package.json via `npm install --package-lock-only`.
+     */
+    private tryResolveLockfileConflict;
     deleteSpeculative(specName: string): Promise<void>;
 }

package/dist/github/shell-git.js

@@ -1,3 +1,5 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
 import { exec } from "../exec.js";
 /** Extract conflict file names from git merge stderr. */
 function parseConflicts(stderr) {
@@ -14,10 +16,12 @@ export class ShellGitOperations {
     clonePath;
     repoFullName;
     gitBin;
+    worktreeBase;
     constructor(clonePath, repoFullName, gitBin = "git") {
         this.clonePath = clonePath;
         this.repoFullName = repoFullName;
         this.gitBin = gitBin;
+        this.worktreeBase = `${clonePath}-worktrees`;
     }
     git(args, opts) {
         return exec(this.gitBin, ["-C", this.clonePath, ...args], {
@@ -26,6 +30,14 @@ export class ShellGitOperations {
             githubRepoFullName: this.repoFullName,
         });
     }
+    /** Run a git command in a specific directory (worktree). */
+    gitIn(cwd, args, opts) {
+        return exec(this.gitBin, ["-C", cwd, ...args], {
+            timeoutMs: opts?.timeoutMs ?? 120_000,
+            allowNonZero: opts?.allowNonZero,
+            githubRepoFullName: this.repoFullName,
+        });
+    }
     async fetch(remote = "origin") {
         await this.git(["fetch", remote], { timeoutMs: 60_000 });
     }
@@ -41,23 +53,6 @@ export class ShellGitOperations {
             return false;
         throw new Error(`git merge-base --is-ancestor failed: ${result.stderr || result.stdout}`);
     }
-    async mergeBaseInto(branch, base) {
-        const remoteBranchRef = `refs/remotes/origin/${branch}`;
-        const remoteBranchExists = await this.git(["show-ref", "--verify", remoteBranchRef], { allowNonZero: true });
-        if (remoteBranchExists.exitCode === 0) {
-            await this.git(["checkout", "-B", branch, `origin/${branch}`]);
-        }
-        else {
-            await this.git(["checkout", branch]);
-        }
-        const result = await this.git(["merge", "--no-ff", "--no-edit", base], { allowNonZero: true });
-        if (result.exitCode !== 0) {
-            await this.git(["merge", "--abort"], { allowNonZero: true });
-            return { success: false, conflictFiles: parseConflicts(result.stderr) };
-        }
-        const newSha = await this.headSha("HEAD");
-        return { success: true, sha: newSha };
-    }
     async push(branch, force = false, targetBranch) {
         const args = ["push"];
         if (force)
@@ -67,21 +62,75 @@ export class ShellGitOperations {
         await this.git(args, { timeoutMs: 60_000 });
     }
     // ─── SpeculativeBranchBuilder ───────────────────────────────
+    /**
+     * Build a speculative merge branch using an isolated git worktree.
+     * Each call gets its own working directory — no shared mutable state.
+     * The worktree is removed after the merge; the branch ref persists
+     * so the reconciler can push it and reference its SHA.
+     */
     async buildSpeculative(prBranch, baseBranch, specName) {
+        const wtPath = join(this.worktreeBase, specName);
+        // Clean up any leftover worktree/branch from a previous run.
+        await this.git(["worktree", "remove", "--force", wtPath], { allowNonZero: true });
         await this.git(["branch", "-D", specName], { allowNonZero: true });
-        await this.git(["checkout", "-B", specName, baseBranch]);
-        const result = await this.git(["merge", "--no-ff", prBranch], { allowNonZero: true });
+        await this.git(["worktree", "prune"], { allowNonZero: true });
+        // Create isolated worktree with spec branch starting at baseBranch.
+        mkdirSync(this.worktreeBase, { recursive: true });
+        await this.git(["worktree", "add", "-B", specName, wtPath, baseBranch]);
+        // Merge PR into spec branch inside the worktree.
+        const result = await this.gitIn(wtPath, ["merge", "--no-ff", prBranch], { allowNonZero: true });
         if (result.exitCode !== 0) {
             const conflictFiles = parseConflicts(result.stderr);
-            await this.git(["merge", "--abort"], { allowNonZero: true });
-            await this.git(["checkout", "-"], { allowNonZero: true });
+            // Lockfile-only conflicts can be auto-resolved by regenerating.
+            if (await this.tryResolveLockfileConflict(wtPath)) {
+                const sha = (await this.gitIn(wtPath, ["rev-parse", "HEAD"])).stdout.trim();
+                await this.git(["worktree", "remove", "--force", wtPath], { allowNonZero: true });
+                return { success: true, sha };
+            }
+            await this.gitIn(wtPath, ["merge", "--abort"], { allowNonZero: true });
+            await this.git(["worktree", "remove", "--force", wtPath], { allowNonZero: true });
+            await this.git(["branch", "-D", specName], { allowNonZero: true });
             return { success: false, conflictFiles };
         }
-        const sha = (await this.git(["rev-parse", "HEAD"])).stdout.trim();
-        await this.git(["checkout", "-"], { allowNonZero: true });
+        const sha = (await this.gitIn(wtPath, ["rev-parse", "HEAD"])).stdout.trim();
+        // Remove worktree but keep the branch — reconciler needs it for push/CI.
+        await this.git(["worktree", "remove", "--force", wtPath], { allowNonZero: true });
         return { success: true, sha };
     }
+    /**
+     * During a merge conflict, check if the only unmerged files are lockfiles
+     * (package-lock.json). If so, resolve by regenerating from the merged
+     * package.json via `npm install --package-lock-only`.
+     */
+    async tryResolveLockfileConflict(wtPath) {
+        try {
+            const unmerged = await this.gitIn(wtPath, ["diff", "--name-only", "--diff-filter=U"]);
+            const files = unmerged.stdout.trim().split("\n").filter(Boolean);
+            if (files.length === 0 || !files.every((f) => f.endsWith("package-lock.json"))) {
+                return false;
+            }
+            for (const file of files) {
+                await this.gitIn(wtPath, ["checkout", "--ours", "--", file]);
+            }
+            const npmResult = await exec("npm", ["install", "--package-lock-only"], {
+                cwd: wtPath,
+                timeoutMs: 60_000,
+            });
+            if (npmResult.exitCode !== 0)
+                return false;
+            for (const file of files) {
+                await this.gitIn(wtPath, ["add", file]);
+            }
+            const commitResult = await this.gitIn(wtPath, ["commit", "--no-edit"], { allowNonZero: true });
+            return commitResult.exitCode === 0;
+        }
+        catch {
+            return false;
+        }
+    }
     async deleteSpeculative(specName) {
+        const wtPath = join(this.worktreeBase, specName);
+        await this.git(["worktree", "remove", "--force", wtPath], { allowNonZero: true });
         await this.git(["branch", "-D", specName], { allowNonZero: true });
     }
 }

package/dist/reconciler.js

@@ -159,7 +159,6 @@ async function prepareEntry(ctx, entry, isHead, prevEntry) {
         }
         // Gate: non-spinning — skip if base hasn't changed since last conflict.
         if (isRetryGated(entry, baseSha)) {
-            emit(ctx, entry, "retry_gated", { baseSha, detail: "base unchanged since last conflict" });
             try {
                 const prStatus = await ctx.github.getStatus(entry.prNumber);
                 if (prStatus.mergeStateStatus === "DIRTY") {
@@ -168,10 +167,18 @@ async function prepareEntry(ctx, entry, isHead, prevEntry) {
                         detail: "retry gated and GitHub still reports merge conflict",
                     });
                     await evictEntry(ctx, entry, "integration_conflict");
+                    return;
                 }
+                // GitHub says CLEAN but local clone conflicted — the conflict was
+                // likely transient (stale clone state). Clear the gate and retry.
+                emit(ctx, entry, "retry_gated", { baseSha, detail: "local conflict but GitHub reports CLEAN, retrying" });
+                ctx.store.transition(entry.id, "preparing_head", {
+                    lastFailedBaseSha: null, ...CLEAN_CI, ...CLEAN_SPEC,
+                }, "GitHub reports CLEAN, clearing retry gate");
             }
             catch {
-                // Best-effort check.
+                // GitHub probe failed — hold the gate.
+                emit(ctx, entry, "retry_gated", { baseSha, detail: "base unchanged since last conflict" });
             }
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-steward",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "Serial merge queue for GitHub — rebase, CI-gate, and merge PRs one at a time",
   "type": "module",
   "repository": {