autopilot-code 0.0.15 → 0.0.17

package/.autopilot/autopilot.json

@@ -2,6 +2,8 @@
   "enabled": true,
   "repo": "bakkensoftware/autopilot",
   "agent": "opencode",
+  "autoMerge": true,
+  "mergeMethod": "squash",
   "allowedMergeUsers": [
     "kellyelton"
   ],
@@ -26,5 +28,7 @@
   "branchPrefix": "autopilot/",
   "allowedBaseBranch": "main",
   "autoResolveConflicts": true,
-  "conflictResolutionMaxAttempts": 3
+  "conflictResolutionMaxAttempts": 3,
+  "autoFixChecks": true,
+  "autoFixChecksMaxAttempts": 3
 }

package/README.md

@@ -22,7 +22,8 @@ Example:
   "enabled": true,
   "repo": "bakkensoftware/autopilot",
   "agent": "opencode",
-  "autoMerge": false,
+  "autoMerge": true,
+  "mergeMethod": "squash",
   "allowedMergeUsers": ["github-username"],
   "issueLabels": {
     "queue": ["autopilot:todo"],
@@ -31,19 +32,31 @@ Example:
     "done": "autopilot:done"
   },
   "priorityLabels": ["p0", "p1", "p2"],
+  "minPriority": null,
+  "ignoreIssueLabels": ["autopilot:backlog"],
   "maxParallel": 1,
   "heartbeatMaxAgeSecs": 3600,
   "branchPrefix": "autopilot/",
-  "allowedBaseBranch": "main"
+  "allowedBaseBranch": "main",
+  "autoResolveConflicts": true,
+  "conflictResolutionMaxAttempts": 3,
+  "autoFixChecks": true,
+  "autoFixChecksMaxAttempts": 3
 }
 ```
 
 Notes:
 - `repo` must be the GitHub `owner/name`.
 - `agent` (optional, default `"none"`): set to `"opencode"` to enable OpenCode integration after claiming issues.
-- `autoMerge` (optional, default `false`): if `true`, autopilot will automatically merge PRs after they are created.
+- `autoMerge` (optional, default `true`): if `true`, autopilot will automatically merge PRs after checks pass.
+- `mergeMethod` (optional, default `"squash"`): merge strategy to use. Options: `"squash"`, `"merge"`, or `"rebase"`.
 - `allowedMergeUsers` (required when `autoMerge=true`): list of GitHub usernames allowed to auto-merge. The runner verifies the authenticated GitHub user is in this list before merging.
+- `minPriority` (optional, default `null`): minimum priority to work on. For example, set to `"p1"` to only work on `p0` and `p1` issues. Uses `priorityLabels` array for priority order.
 - `ignoreIssueLabels` (optional, default `["autopilot:backlog"]`): issues with any of these labels will be ignored by the runner.
+- `autoResolveConflicts` (optional, default `true`): if `true`, autopilot will attempt to automatically resolve merge conflicts.
+- `conflictResolutionMaxAttempts` (optional, default `3`): maximum number of attempts to resolve merge conflicts.
+- `autoFixChecks` (optional, default `true`): if `true`, autopilot will attempt to automatically fix failing CI checks.
+- `autoFixChecksMaxAttempts` (optional, default `3`): maximum number of attempts to fix failing checks.
 - `heartbeatMaxAgeSecs` controls how long an in-progress issue can go without a heartbeat before it's considered stale.
 
 ## Workflow (labels)

package/package.json

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

package/scripts/run_autopilot.py

@@ -317,6 +317,286 @@ def list_in_progress_issues(cfg: RepoConfig, limit: int = 20) -> list[dict[str,
     return json.loads(raw)
 
 
+def check_pr_for_issue(cfg: RepoConfig, issue_number: int) -> dict[str, Any] | None:
+    """Check if there's a PR for this issue and return its status."""
+    branch = f"autopilot/issue-{issue_number}"
+    cmd = [
+        "gh",
+        "pr",
+        "list",
+        "--repo",
+        cfg.repo,
+        "--head",
+        branch,
+        "--json",
+        "number,title,state,mergeable,mergeStateStatus,url,merged,closed,headRefName",
+        "--limit",
+        "1",
+    ]
+    try:
+        raw = sh(cmd, check=False)
+        prs = json.loads(raw)
+        return prs[0] if prs else None
+    except Exception:
+        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"]
+    pr_url = pr["url"]
+    
+    # If already merged or closed, mark issue as done
+    if pr.get("merged") or pr.get("closed"):
+        print(f"[{cfg.repo}] PR #{pr_number} is already merged/closed, marking issue #{issue_number} as done", flush=True)
+        sh(["gh", "issue", "edit", str(issue_number), "--repo", cfg.repo, 
+            "--add-label", cfg.label_done, "--remove-label", cfg.label_in_progress])
+        sh(["gh", "issue", "close", str(issue_number), "--repo", cfg.repo, "--reason", "completed"])
+        return True
+    
+    # Check if PR is mergeable
+    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
+    
+    # Get PR check status
+    cmd = [
+        "gh", "pr", "view", str(pr_number), "--repo", cfg.repo,
+        "--json", "statusCheckRollup",
+    ]
+    try:
+        pr_details = json.loads(sh(cmd))
+        checks = pr_details.get("statusCheckRollup", [])
+        
+        if not checks:
+            # No checks configured, can merge
+            check_status = "PASSED"
+        else:
+            # Check if any checks are pending or failed
+            has_failure = any(c.get("conclusion") == "FAILURE" for c in checks)
+            has_pending = any(c.get("conclusion") in ("PENDING", "QUEUED", None) for c in checks)
+            
+            if has_failure:
+                check_status = "FAILED"
+            elif has_pending:
+                check_status = "PENDING"
+            else:
+                check_status = "PASSED"
+        
+        if check_status != "PASSED":
+            print(f"[{cfg.repo}] PR #{pr_number} checks not ready (status: {check_status})", flush=True)
+            return False
+        
+        # Checks passed, attempt merge
+        print(f"[{cfg.repo}] PR #{pr_number} is ready, attempting merge...", flush=True)
+        
+        merge_method = "squash"  # Default, could be read from config if needed
+        merge_cmd = ["gh", "pr", "merge", pr_url, "--delete-branch", f"--{merge_method}"]
+        
+        try:
+            sh(merge_cmd)
+            print(f"[{cfg.repo}] Successfully merged PR #{pr_number}!", flush=True)
+            
+            # Comment and close issue
+            success_msg = f"✅ Autopilot successfully merged PR #{pr_number} using {merge_method} method.\n\nThe fix has been merged to the main branch."
+            sh(["gh", "issue", "comment", str(issue_number), "--repo", cfg.repo, "--body", success_msg])
+            sh(["gh", "issue", "edit", str(issue_number), "--repo", cfg.repo, 
+                "--add-label", cfg.label_done, "--remove-label", cfg.label_in_progress])
+            sh(["gh", "issue", "close", str(issue_number), "--repo", cfg.repo, "--reason", "completed"])
+            
+            return True
+        except Exception as e:
+            print(f"[{cfg.repo}] Failed to merge PR #{pr_number}: {e}", flush=True)
+            return False
+            
+    except Exception as e:
+        print(f"[{cfg.repo}] Error checking PR #{pr_number}: {e}", flush=True)
+        return False
+
+
+def clean_completed_issues_from_state(cfg: RepoConfig) -> None:
+    """Remove completed issues from state.json."""
+    state = load_state(cfg.root)
+    active_issues = state.get("activeIssues", {})
+    
+    if not isinstance(active_issues, dict):
+        return
+    
+    # Check each issue to see if it's still open
+    issues_to_remove = []
+    for issue_num_str, issue_data in active_issues.items():
+        if not isinstance(issue_data, dict):
+            continue
+        
+        issue_num = int(issue_data.get("number", -1))
+        if issue_num <= 0:
+            continue
+        
+        # Check if issue is closed
+        try:
+            cmd = ["gh", "issue", "view", str(issue_num), "--repo", cfg.repo, "--json", "state,closed"]
+            result = json.loads(sh(cmd, check=False))
+            if result.get("state") == "CLOSED" or result.get("closed"):
+                print(f"[{cfg.repo}] Issue #{issue_num} is closed, removing from state", flush=True)
+                issues_to_remove.append(issue_num_str)
+        except Exception:
+            pass
+    
+    # Remove completed issues
+    for issue_num_str in issues_to_remove:
+        del active_issues[issue_num_str]
+    
+    if issues_to_remove:
+        state["activeIssues"] = active_issues
+        write_state(cfg.root, state)
+
+
 def maybe_mark_blocked(cfg: RepoConfig, issue: dict[str, Any]) -> None:
     num = int(issue["number"])
     if is_heartbeat_fresh(cfg, num):
@@ -358,12 +638,33 @@ def run_cycle(
 
     for cfg in all_configs:
         print(f"[{cfg.repo}] Scanning for issues...", flush=True)
-        # 1) First, check any in-progress issues and mark blocked if stale.
+        
+        # 0) Clean up completed issues from state
+        if not dry_run:
+            clean_completed_issues_from_state(cfg)
+        
+        # 1) Check in-progress issues
         inprog = list_in_progress_issues(cfg)
         for it in inprog:
-            # This is conservative: only mark blocked if we have no fresh local heartbeat.
+            issue_num = int(it["number"])
+            
+            # First check if we should mark as blocked due to stale heartbeat
             if not dry_run:
-                maybe_mark_blocked(cfg, it)
+                # Only mark blocked if heartbeat is stale
+                if not is_heartbeat_fresh(cfg, issue_num):
+                    maybe_mark_blocked(cfg, it)
+                    continue
+                
+                # If heartbeat is fresh and autoMerge is enabled, try to merge PR
+                if cfg.auto_merge:
+                    pr = check_pr_for_issue(cfg, issue_num)
+                    if pr:
+                        print(f"[{cfg.repo}] Found PR for issue #{issue_num}, checking if ready to merge...", flush=True)
+                        if try_merge_pr(cfg, issue_num, pr):
+                            print(f"[{cfg.repo}] Issue #{issue_num} completed!", flush=True)
+                        else:
+                            # Touch heartbeat to keep it alive while waiting for checks
+                            touch_heartbeat(cfg, issue_num)
 
         # 2) Count active issues with fresh heartbeats from local state
         state = load_state(cfg.root)

package/scripts/run_opencode_issue.sh

@@ -15,6 +15,7 @@ cd "$REPO_DIR"
 if command -v jq >/dev/null 2>&1; then
   REPO=$(jq -r '.repo' < .autopilot/autopilot.json)
   AUTO_MERGE=$(jq -r '.autoMerge // true' < .autopilot/autopilot.json)
+  MERGE_METHOD=$(jq -r '.mergeMethod // "squash"' < .autopilot/autopilot.json)
   AUTO_RESOLVE_CONFLICTS=$(jq -r '.autoResolveConflicts // true' < .autopilot/autopilot.json)
   CONFLICT_RESOLUTION_MAX_ATTEMPTS=$(jq -r '.conflictResolutionMaxAttempts // 3' < .autopilot/autopilot.json)
   AUTO_FIX_CHECKS=$(jq -r '.autoFixChecks // true' < .autopilot/autopilot.json)
@@ -23,6 +24,7 @@ if command -v jq >/dev/null 2>&1; then
 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))')
+  MERGE_METHOD=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("mergeMethod", "squash"))')
   AUTO_RESOLVE_CONFLICTS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoResolveConflicts", True))')
   CONFLICT_RESOLUTION_MAX_ATTEMPTS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("conflictResolutionMaxAttempts", 3))')
   AUTO_FIX_CHECKS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoFixChecks", True))')
@@ -360,6 +362,58 @@ if [[ "$AUTO_MERGE" == "true" ]] && [[ -n "$PR_URL" ]]; then
         sleep "$POLL_INTERVAL"
       fi
     done
+    
+    # After polling loop: merge if checks passed
+    if [[ "$CHECK_STATUS" == "PASSED" ]]; then
+      echo "[run_opencode_issue.sh] Merging PR using method: $MERGE_METHOD"
+      
+      # Build merge command based on method
+      MERGE_CMD="gh pr merge $PR_URL --delete-branch"
+      case "$MERGE_METHOD" in
+        squash)
+          MERGE_CMD="$MERGE_CMD --squash"
+          ;;
+        merge)
+          MERGE_CMD="$MERGE_CMD --merge"
+          ;;
+        rebase)
+          MERGE_CMD="$MERGE_CMD --rebase"
+          ;;
+        *)
+          echo "[run_opencode_issue.sh] Unknown merge method '$MERGE_METHOD', defaulting to squash"
+          MERGE_CMD="$MERGE_CMD --squash"
+          ;;
+      esac
+      
+      # Attempt merge
+      if eval "$MERGE_CMD"; then
+        echo "[run_opencode_issue.sh] PR merged successfully!"
+        
+        # Update issue with success message and mark as done
+        SUCCESS_MSG="✅ Autopilot successfully merged PR #${PR_URL##*/} using $MERGE_METHOD method.\n\nThe fix has been merged to the main branch."
+        gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "$SUCCESS_MSG" || true
+        
+        # Get done label and mark issue as done
+        if command -v jq >/dev/null 2>&1; then
+          LABEL_DONE=$(jq -r '.issueLabels.done' < .autopilot/autopilot.json)
+          LABEL_IN_PROGRESS=$(jq -r '.issueLabels.inProgress' < .autopilot/autopilot.json)
+        else
+          LABEL_DONE=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json"))["issueLabels"]["done"])')
+          LABEL_IN_PROGRESS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json"))["issueLabels"]["inProgress"])')
+        fi
+        
+        gh issue edit "$ISSUE_NUMBER" --repo "$REPO" --add-label "$LABEL_DONE" --remove-label "$LABEL_IN_PROGRESS" || true
+        gh issue close "$ISSUE_NUMBER" --repo "$REPO" --reason completed || true
+      else
+        echo "[run_opencode_issue.sh] Failed to merge PR"
+        MERGE_FAIL_MSG="❌ Autopilot failed to merge PR automatically.\n\nThe PR is ready (checks passed) but the merge operation failed. You may need to merge manually."
+        gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "$MERGE_FAIL_MSG" || true
+      fi
+    elif [[ $POLL_ATTEMPT -ge $MAX_POLL_ATTEMPTS ]]; then
+      echo "[run_opencode_issue.sh] Timed out waiting for checks to pass"
+      TIMEOUT_MSG="⏱️ Autopilot timed out waiting for PR checks to complete.\n\nThe PR will remain open for manual review."
+      gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "$TIMEOUT_MSG" || true
+    fi
   else
     BLOCKED_MSG="❌ Autopilot cannot auto-merge PR: authenticated user '$AUTH_USER' is not in the allowedMergeUsers list."
     gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "$BLOCKED_MSG" || true