fix: prevent has-conflicts label flapping when mergeable is None

webhook_server/libs/handlers/pull_request_handler.py

@@ -8,6 +8,7 @@
 from github import GithubException
 from github.PullRequest import PullRequest
 from github.Repository import Repository
+from timeout_sampler import TimeoutExpiredError, TimeoutSampler
 
 from webhook_server.libs.handlers.check_run_handler import CheckRunHandler, CheckRunOutput
 from webhook_server.libs.handlers.labels_handler import LabelsHandler
@@ -563,7 +564,7 @@ async def label_all_opened_pull_requests_merge_state_after_merged(self) -> None:
         pulls = await asyncio.to_thread(lambda: list(self.repository.get_pulls(state="open")))
         for pull_request in pulls:
             self.logger.info(f"{self.log_prefix} check label pull request after merge")
-            await self.label_pull_request_by_merge_state(pull_request=pull_request)
+            await self.label_pull_request_by_merge_state(pull_request=pull_request, add_only=True)
 
     async def delete_remote_tag_for_merged_or_closed_pr(self, pull_request: PullRequest) -> None:
         self.logger.debug(f"{self.log_prefix} Checking if need to delete remote tag for {pull_request.number}")
@@ -978,13 +979,16 @@ async def _compare_branches(self, base_ref: str, head_ref_full: str) -> dict[str
             self.logger.exception(f"{self.log_prefix} Unexpected error calling Compare API")
             return None
 
-    async def label_pull_request_by_merge_state(self, pull_request: PullRequest) -> None:
+    async def label_pull_request_by_merge_state(self, pull_request: PullRequest, add_only: bool = False) -> None:
         """Label pull request based on merge state.
 
-        Simple flow:
+        Flow:
             1. Check pull_request.mergeable for conflicts
-            2. If has conflicts → add has-conflicts, exit
-            3. Else → remove has-conflicts, check Compare API for rebase status
+            2. If has conflicts → add has-conflicts label, exit
+            3. If mergeable unknown → skip has-conflicts update
+            4. If no conflicts and not add_only → remove has-conflicts
+            5. Check Compare API for rebase status
+            6. Update needs-rebase label (add only when add_only=True)
 
         Uses both GitHub APIs for accurate labeling:
         - has-conflicts: pull_request.mergeable == False (true merge conflict detection)
@@ -994,6 +998,8 @@ async def label_pull_request_by_merge_state(self, pull_request: PullRequest) ->
 
         Args:
             pull_request: The GitHub pull request object to label.
+            add_only: When True, only add labels, never remove them. Used when
+                checking all open PRs after a merge, where GitHub data may be stale.
         """
         if self.ctx:
             self.ctx.start_step("label_merge_state")
@@ -1005,25 +1011,58 @@ async def label_pull_request_by_merge_state(self, pull_request: PullRequest) ->
             needs_rebase_label_exists = NEEDS_REBASE_LABEL_STR in current_labels
 
             # Step 1: Check for conflicts first
+            # GitHub may return mergeable=None while computing - poll until definitive
             mergeable = await asyncio.to_thread(lambda: pull_request.mergeable)
-            has_conflicts = mergeable is False
 
-            if has_conflicts:
-                # Has conflicts - add has-conflicts label and exit
-                self.logger.debug(f"{self.log_prefix} PR has conflicts. {mergeable=}")
+            if mergeable is None:
+                self.logger.debug(
+                    f"{self.log_prefix} PR mergeable status is None, polling until GitHub computes status"
+                )
+                pr_number = pull_request.number
+                repository = self.github_webhook.repository
+
+                def _poll_mergeable() -> bool | None:
+                    for sample in TimeoutSampler(
+                        wait_timeout=30,
+                        sleep=5,
+                        func=lambda: repository.get_pull(pr_number).mergeable,
+                    ):
+                        if sample is not None:
+                            return sample
+                    return None  # pragma: no cover
+
+                try:
+                    mergeable = await asyncio.to_thread(_poll_mergeable)
+                except asyncio.CancelledError:
+                    raise
+                except TimeoutExpiredError:
+                    self.logger.warning(
+                        f"{self.log_prefix} PR mergeable status still None after retries, skipping label update"
+                    )
+                    if self.ctx:
+                        self.ctx.complete_step("label_merge_state", mergeable_unknown=True)
 
-                if not has_conflicts_label_exists:
-                    self.logger.debug(f"{self.log_prefix} Adding {HAS_CONFLICTS_LABEL_STR} label")
-                    await self.labels_handler._add_label(pull_request=pull_request, label=HAS_CONFLICTS_LABEL_STR)
+            if mergeable is not None:
+                has_conflicts = mergeable is False
 
-                if self.ctx:
-                    self.ctx.complete_step("label_merge_state", has_conflicts=True, needs_rebase=False)
-                return  # Exit early - conflicts take precedence
+                if has_conflicts:
+                    # Has conflicts - add has-conflicts label and exit
+                    self.logger.debug(f"{self.log_prefix} PR has conflicts. {mergeable=}")
 
-            # Step 2: No conflicts - remove has-conflicts label if present
-            if has_conflicts_label_exists:
-                self.logger.debug(f"{self.log_prefix} Removing {HAS_CONFLICTS_LABEL_STR} label")
-                await self.labels_handler._remove_label(pull_request=pull_request, label=HAS_CONFLICTS_LABEL_STR)
+                    if not has_conflicts_label_exists:
+                        self.logger.debug(f"{self.log_prefix} Adding {HAS_CONFLICTS_LABEL_STR} label")
+                        await self.labels_handler._add_label(pull_request=pull_request, label=HAS_CONFLICTS_LABEL_STR)
+
+                    if self.ctx:
+                        self.ctx.complete_step("label_merge_state", has_conflicts=True)
+                    return  # Exit early - conflicts take precedence
+
+                # No conflicts - remove has-conflicts label if present (skip in add_only mode)
+                if has_conflicts_label_exists and not add_only:
+                    self.logger.debug(f"{self.log_prefix} Removing {HAS_CONFLICTS_LABEL_STR} label")
+                    await self.labels_handler._remove_label(pull_request=pull_request, label=HAS_CONFLICTS_LABEL_STR)
+            else:
+                self.logger.debug(f"{self.log_prefix} Mergeable status unknown, skipping has-conflicts label update")
 
             # Step 3: Check if needs rebase via Compare API
             base_ref, head_user_login, head_ref = await asyncio.gather(
@@ -1054,7 +1093,7 @@ async def label_pull_request_by_merge_state(self, pull_request: PullRequest) ->
             if needs_rebase and not needs_rebase_label_exists:
                 self.logger.debug(f"{self.log_prefix} Adding {NEEDS_REBASE_LABEL_STR} label")
                 await self.labels_handler._add_label(pull_request=pull_request, label=NEEDS_REBASE_LABEL_STR)
-            elif not needs_rebase and needs_rebase_label_exists:
+            elif not needs_rebase and needs_rebase_label_exists and not add_only:
                 self.logger.debug(f"{self.log_prefix} Removing {NEEDS_REBASE_LABEL_STR} label")
                 await self.labels_handler._remove_label(pull_request=pull_request, label=NEEDS_REBASE_LABEL_STR)