autopilot-code 0.0.16 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "private": false,
   "description": "Repo-issue–driven autopilot runner",
   "license": "MIT",

package/scripts/run_autopilot.py

@@ -329,7 +329,7 @@ def check_pr_for_issue(cfg: RepoConfig, issue_number: int) -> dict[str, Any] | N
         "--head",
         branch,
         "--json",
-        "number,title,state,mergeable,mergeStateStatus,url,merged,closed",
+        "number,title,state,mergeable,mergeStateStatus,url,merged,closed,headRefName",
         "--limit",
         "1",
     ]
@@ -341,6 +341,112 @@ def check_pr_for_issue(cfg: RepoConfig, issue_number: int) -> dict[str, Any] | N
         return None
 
 
+def resolve_merge_conflicts(cfg: RepoConfig, issue_number: int, pr: dict[str, Any], attempt: int) -> bool:
+    """Attempt to resolve merge conflicts using the coding agent. Returns True if resolved."""
+    if cfg.agent != "opencode":
+        print(f"[{cfg.repo}] Cannot resolve conflicts: agent '{cfg.agent}' not supported (only 'opencode')", flush=True)
+        return False
+    
+    pr_number = pr["number"]
+    branch = pr.get("headRefName", f"autopilot/issue-{issue_number}")
+    worktree = Path(f"/tmp/autopilot-issue-{issue_number}")
+    
+    print(f"[{cfg.repo}] Attempting to resolve merge conflicts for PR #{pr_number} (attempt {attempt}/{cfg.conflict_resolution_max_attempts})", flush=True)
+    
+    # Ensure worktree exists and is up to date
+    if not worktree.exists():
+        print(f"[{cfg.repo}] Creating worktree at {worktree}", flush=True)
+        try:
+            sh(["git", "worktree", "add", str(worktree), branch], cwd=cfg.root)
+        except Exception as e:
+            print(f"[{cfg.repo}] Failed to create worktree: {e}", flush=True)
+            return False
+    
+    # Fetch latest and attempt rebase/merge
+    try:
+        sh(["git", "fetch", "origin", "main"], cwd=worktree)
+        
+        # Try to rebase onto main
+        rebase_result = subprocess.run(
+            ["git", "rebase", "origin/main"],
+            cwd=str(worktree),
+            capture_output=True,
+            text=True
+        )
+        
+        if rebase_result.returncode == 0:
+            # No conflicts, push and we're done
+            sh(["git", "push", "-f", "origin", branch], cwd=worktree)
+            print(f"[{cfg.repo}] Rebase successful, no conflicts to resolve", flush=True)
+            return True
+        
+        # There are conflicts - abort the rebase first
+        subprocess.run(["git", "rebase", "--abort"], cwd=str(worktree), capture_output=True)
+        
+        # Get list of files that would conflict
+        merge_base = sh(["git", "merge-base", "HEAD", "origin/main"], cwd=worktree).strip()
+        diff_output = sh(["git", "diff", "--name-only", merge_base, "origin/main"], cwd=worktree, check=False)
+        conflicting_files = diff_output.strip().split("\n") if diff_output.strip() else []
+        
+        # Build prompt for the agent
+        conflict_prompt = f"""This PR has merge conflicts with main. Please resolve them.
+
+Branch: {branch}
+Files potentially conflicting: {', '.join(conflicting_files[:10])}
+
+Steps:
+1. Run `git fetch origin main`
+2. Run `git rebase origin/main` to start the rebase
+3. When conflicts occur, examine the conflicted files
+4. Edit the files to resolve conflicts (remove conflict markers, keep correct code)
+5. Run `git add <resolved-files>` for each resolved file
+6. Run `git rebase --continue`
+7. Repeat until rebase is complete
+8. Run `git push -f origin {branch}` to update the PR
+
+Work rules:
+- Focus only on resolving conflicts, don't make unrelated changes
+- Preserve the intent of both the PR changes and main branch changes
+- If unsure about a conflict, prefer the PR's changes but ensure compatibility
+"""
+        
+        print(f"[{cfg.repo}] Running opencode to resolve conflicts...", flush=True)
+        
+        # Run opencode in the worktree
+        agent_result = subprocess.run(
+            ["opencode", "run", conflict_prompt],
+            cwd=str(worktree),
+            capture_output=True,
+            text=True,
+            timeout=600  # 10 minute timeout
+        )
+        
+        if agent_result.returncode != 0:
+            print(f"[{cfg.repo}] Opencode failed: {agent_result.stderr[:500]}", flush=True)
+            return False
+        
+        # Check if conflicts are resolved by checking PR status
+        time.sleep(5)  # Give GitHub time to update
+        cmd = ["gh", "pr", "view", str(pr_number), "--repo", cfg.repo, "--json", "mergeable,mergeStateStatus"]
+        pr_status = json.loads(sh(cmd))
+        
+        if pr_status.get("mergeable") == "MERGEABLE":
+            print(f"[{cfg.repo}] Conflicts resolved successfully!", flush=True)
+            sh(["gh", "issue", "comment", str(issue_number), "--repo", cfg.repo, 
+                "--body", f"✅ Autopilot resolved merge conflicts (attempt {attempt})."])
+            return True
+        else:
+            print(f"[{cfg.repo}] Conflicts still present after resolution attempt", flush=True)
+            return False
+            
+    except subprocess.TimeoutExpired:
+        print(f"[{cfg.repo}] Conflict resolution timed out", flush=True)
+        return False
+    except Exception as e:
+        print(f"[{cfg.repo}] Error resolving conflicts: {e}", flush=True)
+        return False
+
+
 def try_merge_pr(cfg: RepoConfig, issue_number: int, pr: dict[str, Any]) -> bool:
     """Attempt to merge a PR if it's ready. Returns True if merged or closed."""
     pr_number = pr["number"]
@@ -358,6 +464,43 @@ def try_merge_pr(cfg: RepoConfig, issue_number: int, pr: dict[str, Any]) -> bool
     mergeable = pr.get("mergeable")
     merge_state = pr.get("mergeStateStatus")
     
+    # Handle merge conflicts
+    if mergeable == "CONFLICTING" or merge_state == "DIRTY":
+        print(f"[{cfg.repo}] PR #{pr_number} has merge conflicts", flush=True)
+        
+        if not cfg.auto_resolve_conflicts:
+            print(f"[{cfg.repo}] Auto-resolve conflicts disabled, skipping", flush=True)
+            return False
+        
+        # Load state to track resolution attempts
+        state = load_state(cfg.root)
+        conflict_key = f"conflict_attempts_{issue_number}"
+        attempts = state.get(conflict_key, 0)
+        
+        if attempts >= cfg.conflict_resolution_max_attempts:
+            print(f"[{cfg.repo}] Max conflict resolution attempts ({cfg.conflict_resolution_max_attempts}) reached", flush=True)
+            if attempts == cfg.conflict_resolution_max_attempts:
+                # Only notify once when we hit the limit
+                sh(["gh", "issue", "comment", str(issue_number), "--repo", cfg.repo,
+                    "--body", f"❌ Autopilot failed to resolve merge conflicts after {attempts} attempts. Manual resolution required."])
+                state[conflict_key] = attempts + 1  # Increment to avoid repeat notifications
+                write_state(cfg.root, state)
+            return False
+        
+        # Attempt to resolve
+        attempts += 1
+        state[conflict_key] = attempts
+        write_state(cfg.root, state)
+        
+        if resolve_merge_conflicts(cfg, issue_number, pr, attempts):
+            # Reset attempts on success
+            del state[conflict_key]
+            write_state(cfg.root, state)
+            # Re-check the PR - it might be ready to merge now
+            return False  # Return False to re-check on next cycle
+        else:
+            return False
+    
     if mergeable != "MERGEABLE":
         print(f"[{cfg.repo}] PR #{pr_number} is not mergeable (state: {mergeable}/{merge_state}), skipping", flush=True)
         return False