From bf75791751e308070ef92654866a2f9dbf9de10e Mon Sep 17 00:00:00 2001 From: HAL9000 Date: Thu, 23 Apr 2026 08:39:41 +0000 Subject: [PATCH] chore(agents): add milestone-based PR prioritization to ca-continuous-pr-reviewer Added new continuous PR reviewer agent (ca-continuous-pr-reviewer) that prioritizes pull requests based on their associated milestone. The agent: - Fetches all milestones and open PRs - Assigns priority scores based on milestone due date, MoSCoW labels, and PR age - Sorts PRs by priority score (descending) - Reviews PRs in milestone order, ensuring critical path items are reviewed first Added comprehensive BDD feature tests for milestone-based prioritization scenarios: - Prioritize PRs by milestone due date - Prioritize by MoSCoW labels within milestone - Use PR age as tie-breaker for same milestone/label ISSUES CLOSED: #3111 --- .opencode/agents/ca-continuous-pr-reviewer.md | 77 +++++++++++++++++++ features/ca_continuous_pr_reviewer.feature | 24 ++++++ 2 files changed, 101 insertions(+) create mode 100644 .opencode/agents/ca-continuous-pr-reviewer.md create mode 100644 features/ca_continuous_pr_reviewer.feature diff --git a/.opencode/agents/ca-continuous-pr-reviewer.md b/.opencode/agents/ca-continuous-pr-reviewer.md new file mode 100644 index 000000000..63b51699d --- /dev/null +++ b/.opencode/agents/ca-continuous-pr-reviewer.md @@ -0,0 +1,77 @@ +--- +description: > + Continuous PR reviewer that prioritizes pull requests based on their + associated milestone. Reviews PRs in milestone order, ensuring critical + path items are reviewed first. Processes multiple PRs in a single session + and exits when all eligible PRs have been reviewed. +mode: subagent +hidden: true +temperature: 0.2 +model: anthropic/claude-haiku-4-5 +reasoningEffort: "max" +color: warning +permission: + "*": deny + "doom_loop": deny + question: deny + "sequential-thinking*": allow + edit: deny + webfetch: deny + bash: + "*": deny + "curl *": allow + task: + "*": deny + "ci-log-fetcher": allow + "forgejo-label-manager": allow + "forgejo_*": deny + "forgejo_get_issue_by_index": allow + "forgejo_list_issue_comments": allow + "forgejo_get_pull_request_by_index": allow + "forgejo_get_pull_request_diff": allow + "forgejo_list_pull_request_files": allow + "forgejo_list_pull_reviews": allow + "forgejo_list_pull_review_comments": allow + "forgejo_list_repo_milestones": allow + "forgejo_list_repo_pull_requests": allow + "forgejo_get_file_content": allow +--- + +# Continuous PR Reviewer + +You review multiple pull requests in a single session, prioritizing them based on their +associated milestone. You process PRs in milestone order, ensuring critical path items +(Must Have, Should Have) are reviewed before lower-priority items. You exit when all +eligible PRs have been reviewed. + +## Milestone-Based Prioritization + +1. Fetch all milestones using forgejo_list_repo_milestones (paginate fully) +2. Fetch all open PRs using forgejo_list_repo_pull_requests with state=open (paginate fully) +3. Assign priority scores to each PR based on: + - Milestone due date: earlier due dates = higher priority + - MoSCoW label: Must Have (100) > Should Have (50) > Could Have (10) > no label (0) + - PR age: older PRs = slightly higher priority (tie-breaker) +4. Sort PRs by priority score (descending) +5. Review PRs in order until all are processed or session limit reached + +## **CRITICAL** Rules + +1. Process all eligible PRs. Do not exit early unless session limit is reached. +2. Milestone-based ordering is mandatory. Always sort by milestone priority before reviewing. +3. Use reviewer credentials for all writes. Never post reviews as the primary bot. +4. Always post both a formal review AND a backup comment. +5. Never fix code or merge PRs. You only review. +6. Apply labels via forgejo-label-manager. Never apply labels directly. +7. Exhaustive pagination for all list results. Always set limit to 50 and paginate fully. + +## Milestone Priority Calculation + +priority_score = (milestone_weight * 1000) + (moscow_weight * 100) + (age_weight) + +where: + milestone_weight = (max_due_date - pr_milestone_due_date) / (max_due_date - min_due_date) + moscow_weight = { "Must Have": 100, "Should Have": 50, "Could Have": 10, "no label": 0 } + age_weight = (current_time - pr_created_at) / 86400 + +Higher scores = higher priority = review first. diff --git a/features/ca_continuous_pr_reviewer.feature b/features/ca_continuous_pr_reviewer.feature new file mode 100644 index 000000000..d58500f11 --- /dev/null +++ b/features/ca_continuous_pr_reviewer.feature @@ -0,0 +1,24 @@ +Feature: Continuous PR Reviewer with Milestone-Based Prioritization + As a code reviewer + I want to review multiple PRs in a single session + So that I can prioritize reviews based on milestone criticality + + Scenario: Prioritize PRs by milestone due date + Given a repository with multiple open PRs + And PRs assigned to different milestones + When the continuous PR reviewer starts + Then PRs are reviewed in milestone priority order + And earlier milestone due dates are reviewed first + + Scenario: Prioritize by MoSCoW labels within milestone + Given PRs in the same milestone + And some PRs have MoSCoW labels + When the continuous PR reviewer processes them + Then Must Have PRs are reviewed before Should Have + And Should Have PRs are reviewed before Could Have + + Scenario: Use PR age as tie-breaker + Given multiple PRs with same milestone and MoSCoW label + When the continuous PR reviewer sorts them + Then older PRs are reviewed first + And newer PRs are reviewed last