autopilot-code 0.0.16 → 0.0.18

package/package.json

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

package/scripts/run_autopilot.py

@@ -24,6 +24,7 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
+import shutil
 
 STATE_DIR = ".autopilot"
 STATE_FILE = "state.json"
@@ -329,7 +330,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 +342,146 @@ def check_pr_for_issue(cfg: RepoConfig, issue_number: int) -> dict[str, Any] | N
         return None
 
 
+def find_opencode() -> str | None:
+    """Find opencode binary in PATH or common locations."""
+    # 1. Check PATH first
+    opencode = shutil.which("opencode")
+    if opencode:
+        return opencode
+    
+    # 2. Check common nvm locations
+    home = Path.home()
+    nvm_dir = home / ".nvm" / "versions" / "node"
+    if nvm_dir.exists():
+        for node_version in sorted(nvm_dir.iterdir(), reverse=True):
+            candidate = node_version / "bin" / "opencode"
+            if candidate.exists() and candidate.is_file():
+                return str(candidate)
+    
+    # 3. Other common locations
+    for path in [
+        home / ".local" / "bin" / "opencode",
+        Path("/usr/local/bin/opencode"),
+        home / ".npm-global" / "bin" / "opencode",
+    ]:
+        if path.exists() and path.is_file():
+            return str(path)
+    
+    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
+    
+    opencode_bin = find_opencode()
+    if not opencode_bin:
+        print(f"[{cfg.repo}] Cannot resolve conflicts: opencode not found", 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)
+    print(f"[{cfg.repo}] Using opencode: {opencode_bin}", 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_bin, "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 +499,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

package/scripts/run_opencode_issue.sh

@@ -21,6 +21,7 @@ if command -v jq >/dev/null 2>&1; then
   AUTO_FIX_CHECKS=$(jq -r '.autoFixChecks // true' < .autopilot/autopilot.json)
   AUTO_FIX_CHECKS_MAX_ATTEMPTS=$(jq -r '.autoFixChecksMaxAttempts // 3' < .autopilot/autopilot.json)
   ALLOWED_USERS=$(jq -r '.allowedMergeUsers[]' < .autopilot/autopilot.json 2>/dev/null || true)
+  AGENT_PATH=$(jq -r '.agentPath // ""' < .autopilot/autopilot.json)
 else
   REPO=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json"))["repo"])')
   AUTO_MERGE=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoMerge", True))')
@@ -30,8 +31,49 @@ else
   AUTO_FIX_CHECKS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoFixChecks", True))')
   AUTO_FIX_CHECKS_MAX_ATTEMPTS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoFixChecksMaxAttempts", 3))')
   ALLOWED_USERS=$(python3 -c 'import json,sys; users=json.load(open(".autopilot/autopilot.json")).get("allowedMergeUsers", []); print("\n".join(users))' 2>/dev/null || true)
+  AGENT_PATH=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("agentPath", ""))' 2>/dev/null || true)
 fi
 
+# Find opencode binary - check config, PATH, then common locations
+find_opencode() {
+  # 1. Config-specified path
+  if [[ -n "$AGENT_PATH" ]] && [[ -x "$AGENT_PATH" ]]; then
+    echo "$AGENT_PATH"
+    return
+  fi
+  
+  # 2. Already in PATH
+  if command -v opencode >/dev/null 2>&1; then
+    command -v opencode
+    return
+  fi
+  
+  # 3. Common nvm locations
+  for node_dir in "$HOME/.nvm/versions/node"/*/bin; do
+    if [[ -x "$node_dir/opencode" ]]; then
+      echo "$node_dir/opencode"
+      return
+    fi
+  done
+  
+  # 4. Other common locations
+  for path in "$HOME/.local/bin/opencode" "/usr/local/bin/opencode" "$HOME/.npm-global/bin/opencode"; do
+    if [[ -x "$path" ]]; then
+      echo "$path"
+      return
+    fi
+  done
+  
+  # Not found
+  return 1
+}
+
+OPENCODE_BIN=$(find_opencode) || {
+  echo "[run_opencode_issue.sh] ERROR: opencode not found. Set 'agentPath' in autopilot.json or ensure opencode is installed." >&2
+  exit 1
+}
+echo "[run_opencode_issue.sh] Using opencode: $OPENCODE_BIN"
+
 WORKTREE="/tmp/autopilot-issue-$ISSUE_NUMBER"
 BRANCH="autopilot/issue-$ISSUE_NUMBER"
 
@@ -73,7 +115,7 @@ Work rules:
 - If the issue is a simple file-addition, just do it directly (no extra refactors)."
 # 4. Run opencode inside worktree
 cd "$WORKTREE"
-opencode run "$PROMPT"
+"$OPENCODE_BIN" run "$PROMPT"
 
 # 5. Commit any changes OpenCode made
 if [[ -n "$(git status --porcelain)" ]]; then
@@ -190,7 +232,7 @@ if [[ "$AUTO_RESOLVE_CONFLICTS" == "true" ]] && [[ -n "$PR_URL" ]]; then
 
 After resolving all conflicts, report the files that were resolved."
           
-          if opencode run "$CONFLICT_PROMPT"; then
+          if "$OPENCODE_BIN" run "$CONFLICT_PROMPT"; then
             # Check if there are still conflicts
             if [[ -z "$(git diff --name-only --diff-filter=U)" ]]; then
               echo "[run_opencode_issue.sh] Conflicts resolved by agent."
@@ -316,7 +358,7 @@ if [[ "$AUTO_MERGE" == "true" ]] && [[ -n "$PR_URL" ]]; then
           
           # Run opencode to fix the issue
           cd "$WORKTREE"
-          if opencode run "$REPAIR_PROMPT"; then
+          if "$OPENCODE_BIN" run "$REPAIR_PROMPT"; then
             # Commit any changes
             if [[ -n "$(git status --porcelain)" ]]; then
               git add -A