Pull Request Automation

def _prepare_welcome_comment(self) -> str:
    # ...
    return f"""
{self.github_webhook.issue_url_for_welcome_msg}

## Welcome! 🎉

This pull request will be automatically processed with the following features:{auto_verified_note}

### 🔄 Automatic Actions
* **Reviewer Assignment**: Reviewers are automatically assigned based on the OWNERS file in the repository root
* **Size Labeling**: PR size labels (XS, S, M, L, XL, XXL) are automatically applied based on changes
{issue_creation_note}
{self._prepare_pre_commit_welcome_line}\
* **Branch Labeling**: Branch-specific labels are applied to track the target branch
* **Auto-verification**: Auto-verified users have their PRs automatically marked as verified
{self._prepare_labels_config_welcome_section}\

### 📋 Available Commands
#### PR Status Management
{self._prepare_pr_status_commands_section}

#### Review & Approval
* `/lgtm` - Approve changes (looks good to me)
* `/approve` - Approve PR (approvers only)
{self._prepare_automerge_command_line}\
* `/assign-reviewers` - Assign reviewers based on OWNERS file
* `/assign-reviewer @username` - Assign specific reviewer
* `/check-can-merge` - Check if PR meets merge requirements
"""

async def create_issue_for_new_pull_request(self, pull_request: PullRequest) -> None:
    if not self.github_webhook.create_issue_for_new_pr:
        self.logger.info(f"{self.log_prefix} Issue creation for new PRs is disabled for this repository")
        return

    if self.github_webhook.parent_committer in self.github_webhook.auto_verified_and_merged_users:
        self.logger.info(
            f"{self.log_prefix} Committer {self.github_webhook.parent_committer} is part of "
            f"{self.github_webhook.auto_verified_and_merged_users}, will not create issue."
        )
        return

    await asyncio.to_thread(
        self.repository.create_issue,
        title=self._generate_issue_title(pull_request=pull_request),
        body=self._generate_issue_body(pull_request=pull_request),
        assignee=pull_request.user.login,
    )

async def set_pull_request_automerge(self, pull_request: PullRequest) -> None:
    set_auto_merge_base_branch = pull_request.base.ref in self.github_webhook.set_auto_merge_prs
    parent_committer_in_auto_merge_users = (
        self.github_webhook.parent_committer in self.github_webhook.auto_verified_and_merged_users
    )
    auto_merge = set_auto_merge_base_branch or parent_committer_in_auto_merge_users

    if auto_merge and not pull_request.raw_data.get("auto_merge"):
        await asyncio.to_thread(pull_request.enable_automerge, merge_method="SQUASH")

if _command == AUTOMERGE_LABEL_STR:
    if reviewed_user not in (
        await self.owners_file_handler.get_all_repository_maintainers()
        + self.owners_file_handler.all_repository_approvers
    ):
        msg = "Only maintainers or approvers can set pull request to auto-merge"
        await asyncio.to_thread(pull_request.create_issue_comment, body=msg)
        return

    await self.labels_handler._add_label(pull_request=pull_request, label=AUTOMERGE_LABEL_STR)

# ...

elif _command == WIP_STR:
    wip_for_title: str = f"{WIP_STR.upper()}:"
    if remove:
        label_changed = await self.labels_handler._remove_label(pull_request=pull_request, label=WIP_STR)
        if label_changed:
            pr_title = await asyncio.to_thread(lambda: pull_request.title)
            if pr_title.upper().startswith("WIP: "):
                await asyncio.to_thread(pull_request.edit, title=pr_title[5:])
            elif pr_title.upper().startswith("WIP:"):
                await asyncio.to_thread(pull_request.edit, title=pr_title[4:])
    else:
        label_changed = await self.labels_handler._add_label(pull_request=pull_request, label=WIP_STR)
        if label_changed and not pr_title.upper().startswith("WIP:"):
            await asyncio.to_thread(pull_request.edit, title=f"{wip_for_title} {pr_title}")

elif _command == HOLD_LABEL_STR:
    if reviewed_user not in self.owners_file_handler.all_pull_request_approvers:
        await asyncio.to_thread(
            pull_request.create_issue_comment,
            f"{reviewed_user} is not part of the approver, only approvers can mark pull request with hold",
        )
    else:
        if remove:
            await self.labels_handler._remove_label(pull_request=pull_request, label=HOLD_LABEL_STR)
        else:
            await self.labels_handler._add_label(pull_request=pull_request, label=HOLD_LABEL_STR)

elif _command == VERIFIED_LABEL_STR:
    if remove:
        await self.labels_handler._remove_label(pull_request=pull_request, label=VERIFIED_LABEL_STR)
        await self.check_run_handler.set_check_queued(name=VERIFIED_LABEL_STR)
    else:
        await self.labels_handler._add_label(pull_request=pull_request, label=VERIFIED_LABEL_STR)
        await self.check_run_handler.set_check_success(name=VERIFIED_LABEL_STR)

async def _process_verified_for_update_or_new_pull_request(self, pull_request: PullRequest) -> None:
    if not self.github_webhook.verified_job:
        return

    labels = await asyncio.to_thread(lambda: list(pull_request.labels))

    is_ai_resolved = any(label.name == AI_RESOLVED_CONFLICTS_LABEL for label in labels)
    if is_ai_resolved:
        await self.labels_handler._remove_label(pull_request=pull_request, label=VERIFIED_LABEL_STR)
        await self.check_run_handler.set_check_queued(name=VERIFIED_LABEL_STR)
        return

    is_cherry_picked = any(label.name.startswith(CHERRY_PICKED_LABEL) for label in labels)
    if is_cherry_picked and not self.github_webhook.auto_verify_cherry_picked_prs:
        await self.labels_handler._remove_label(pull_request=pull_request, label=VERIFIED_LABEL_STR)
        await self.check_run_handler.set_check_queued(name=VERIFIED_LABEL_STR)
        return

    if self.github_webhook.parent_committer in self.github_webhook.auto_verified_and_merged_users:
        await self.labels_handler._add_label(pull_request=pull_request, label=VERIFIED_LABEL_STR)
        await self.check_run_handler.set_check_success(name=VERIFIED_LABEL_STR)
    else:
        await self.labels_handler._remove_label(pull_request=pull_request, label=VERIFIED_LABEL_STR)
        await self.check_run_handler.set_check_queued(name=VERIFIED_LABEL_STR)

async def add_pull_request_owner_as_assingee(self, pull_request: PullRequest) -> None:
    try:
        await asyncio.to_thread(pull_request.add_to_assignees, pull_request.user.login)
    except Exception:
        if self.owners_file_handler.root_approvers:
            await asyncio.to_thread(pull_request.add_to_assignees, self.owners_file_handler.root_approvers[0])

if check_run_name == CAN_BE_MERGED_STR:
    if getattr(self, "labels_handler", None) and pull_request and check_run_conclusion == SUCCESS_STR:
        if await self.labels_handler.label_exists_in_pull_request(
            label=AUTOMERGE_LABEL_STR, pull_request=pull_request
        ):
            try:
                await asyncio.to_thread(pull_request.merge, merge_method="SQUASH")
                self.logger.info(
                    f"{self.log_prefix} Successfully auto-merged pull request #{pull_request.number}"
                )

await self.labels_handler.manage_reviewed_by_label(
    pull_request=pull_request,
    review_state=review_state,
    action=ADD_STR,
    reviewed_user=reviewed_user,
)

if body := self.hook_data["review"]["body"]:
    # In this project, "approved" means a maintainer uses the /approve command
    # (which adds an approved-<user> label), NOT GitHub's review approval state.
    if any(line.strip() == f"/{APPROVE_STR}" for line in body.splitlines()):
        await self.labels_handler.label_by_user_comment(
            pull_request=pull_request,
            user_requested_label=APPROVE_STR,
            remove=False,
            reviewed_user=reviewed_user,
        )

async def process_cherry_pick_command(
    self, pull_request: PullRequest, command_args: str, reviewed_user: str
) -> None:
    _target_branches: list[str] = command_args.split()
    _exits_target_branches: set[str] = set()
    _non_exits_target_branches_msg: str = ""

    for _target_branch in _target_branches:
        try:
            await asyncio.to_thread(self.repository.get_branch, _target_branch)
            _exits_target_branches.add(_target_branch)
        except Exception:
            _non_exits_target_branches_msg += f"Target branch `{_target_branch}` does not exist\n"

    cp_labels: list[str] = [
        f"{CHERRY_PICK_LABEL_PREFIX}{_target_branch}" for _target_branch in _exits_target_branches
    ]

    if _exits_target_branches:
        if not self.hook_data["issue"].get("pull_request", {}).get("merged_at"):
            info_msg: str = f"""
Cherry-pick requested for PR: `{pull_request.title}` by user `{reviewed_user}`
Adding label/s `{" ".join([_cp_label for _cp_label in cp_labels])}` for automatic cheery-pick once the PR is merged
"""
            await asyncio.to_thread(pull_request.create_issue_comment, info_msg)
        else:
            for _exits_target_branch in _exits_target_branches:
                await self.runner_handler.cherry_pick(
                    pull_request=pull_request,
                    target_branch=_exits_target_branch,
                    assign_to_pr_owner=self.github_webhook.cherry_pick_assign_to_pr_author,
                )

        for _cp_label in cp_labels:
            await self.labels_handler._add_label(pull_request=pull_request, label=_cp_label)

if cherry_pick_had_conflicts:
    ai_config = self.github_webhook.ai_features
    ai_result = get_ai_config(ai_config)
    ai_provider, ai_model = ai_result if ai_result else ("unknown", "unknown")
    await asyncio.to_thread(
        pull_request.create_issue_comment,
        f"**Cherry-pick conflicts were resolved by AI**\n\n"
        f"Cherry-picked PR {pull_request.title} into {target_branch}: {cherry_pick_pr_url}\n"
        f"Conflicts were automatically resolved by AI ({ai_provider}/{ai_model}).\n\n"
        f"**Manual verification is required** — please review the changes and test before merging.",
    )
else:
    await asyncio.to_thread(
        pull_request.create_issue_comment,
        f"Cherry-picked PR {pull_request.title} into {target_branch}: {cherry_pick_pr_url}",
    )

auto-verified-and-merged-users:
  - "renovate[bot]"
  - "pre-commit-ci[bot]"

auto-verify-cherry-picked-prs: true # Default: true - automatically verify cherry-picked PRs. Set to false to require manual verification.

create-issue-for-new-pr: true # Global default: create tracking issues for new PRs

cherry-pick-assign-to-pr-author: true # Default: true - assign cherry-pick PRs to the original PR author

# Commands allowed on draft PRs (optional)
# If not set: commands are blocked on draft PRs (default behavior)
# If empty list []: all commands allowed on draft PRs
# If list with values: only those commands allowed on draft PRs
# allow-commands-on-draft-prs: []  # Uncomment to allow all commands on draft PRs

labels:
  enabled-labels:
    - verified
    - hold
    - wip
    - needs-rebase
    - has-conflicts
    - can-be-merged
    - size
    - branch
    - cherry-pick
    - automerge

auto-verified-and-merged-users:
  - "renovate[bot]"
  - "dependabot[bot]"
  - "trusted-user"

auto-verify-cherry-picked-prs: false # Set to false to require manual verification for cherry-picked PRs

branch-protection:
  strict: true
  require_code_owner_reviews: true
  dismiss_stale_reviews: false
  required_approving_review_count: 1
  required_linear_history: true
  required_conversation_resolution: true

# Auto-merge configuration
set-auto-merge-prs:
  - main
  - develop

# Minimum LGTM count required
minimum-lgtm: 2

# Issue creation for new pull requests
create-issue-for-new-pr: true # Create tracking issues for new PRs

cherry-pick-assign-to-pr-author: true # Assign cherry-pick PRs to the original PR author (default: true)