π OpenHands: AI-Driven Development
Refactor: Modularize GitHubService into feature mixins (#10492)
Rohit Malhotrac648b6f74f16
diff --git a/openhands/integrations/github/github_service.py b/openhands/integrations/github/github_service.pyindex b062bfd974..11c35c514a 100644--- a/openhands/integrations/github/github_service.py+++ b/openhands/integrations/github/github_service.py@@ -1,44 +1,35 @@-import base64-import jsonimport os-from datetime import datetime-from typing import Any-import httpxfrom pydantic import SecretStr-from openhands.core.logger import openhands_logger as logger-from openhands.integrations.github.queries import (- get_review_threads_graphql_query,- get_thread_comments_graphql_query,- get_thread_from_comment_graphql_query,- search_branches_graphql_query,- suggested_task_issue_graphql_query,- suggested_task_pr_graphql_query,+from openhands.integrations.github.service import (+ GitHubBranchesMixin,+ GitHubFeaturesMixin,+ GitHubPRsMixin,+ GitHubReposMixin,+ GitHubResolverMixin,)from openhands.integrations.service_types import (BaseGitService,- Branch,- Comment,GitService,InstallationsService,- OwnerType,- PaginatedBranchesResponse,ProviderType,- Repository,- RequestMethod,- SuggestedTask,- TaskType,- UnknownException,- User,)-from openhands.microagent.types import MicroagentContentResponse-from openhands.server.types import AppModefrom openhands.utils.import_utils import get_impl-class GitHubService(BaseGitService, GitService, InstallationsService):- """Default implementation of GitService for GitHub integration.+class GitHubService(+ GitHubBranchesMixin,+ GitHubFeaturesMixin,+ GitHubPRsMixin,+ GitHubReposMixin,+ GitHubResolverMixin,+ BaseGitService,+ GitService,+ InstallationsService,+):+ """+ Assembled GitHub service class combining mixins by feature area.TODO: This doesn't seem a good candidate for the get_impl() pattern. What are the abstract methods we should actually separate and implement here?This is an extension point in OpenHands that allows applications to customize GitHub@@ -62,7 +53,7 @@ class GitHubService(BaseGitService, GitService, InstallationsService):token: SecretStr | None = None,external_token_manager: bool = False,base_domain: str | None = None,- ):+ ) -> None:self.user_id = user_idself.external_token_manager = external_token_manager@@ -79,991 +70,6 @@ class GitHubService(BaseGitService, GitService, InstallationsService):def provider(self) -> str:return ProviderType.GITHUB.value- async def _get_github_headers(self) -> dict:- """Retrieve the GH Token from settings store to construct the headers."""- if not self.token:- latest_token = await self.get_latest_token()- if latest_token:- self.token = latest_token-- return {- 'Authorization': f'Bearer {self.token.get_secret_value() if self.token else ""}',- 'Accept': 'application/vnd.github.v3+json',- }-- def _has_token_expired(self, status_code: int) -> bool:- return status_code == 401-- async def get_latest_token(self) -> SecretStr | None:- return self.token-- async def _get_cursorrules_url(self, repository: str) -> str:- """Get the URL for checking .cursorrules file."""- return f'{self.BASE_URL}/repos/{repository}/contents/.cursorrules'-- async def _get_microagents_directory_url(- self, repository: str, microagents_path: str- ) -> str:- """Get the URL for checking microagents directory."""- return f'{self.BASE_URL}/repos/{repository}/contents/{microagents_path}'-- def _is_valid_microagent_file(self, item: dict) -> bool:- """Check if an item represents a valid microagent file."""- return (- item['type'] == 'file'- and item['name'].endswith('.md')- and item['name'] != 'README.md'- )-- def _get_file_name_from_item(self, item: dict) -> str:- """Extract file name from directory item."""- return item['name']-- def _get_file_path_from_item(self, item: dict, microagents_path: str) -> str:- """Extract file path from directory item."""- return f'{microagents_path}/{item["name"]}'-- def _get_microagents_directory_params(self, microagents_path: str) -> dict | None:- """Get parameters for the microagents directory request. Return None if no parameters needed."""- return None-- async def _make_request(- self,- url: str,- params: dict | None = None,- method: RequestMethod = RequestMethod.GET,- ) -> tuple[Any, dict]:- try:- async with httpx.AsyncClient() as client:- github_headers = await self._get_github_headers()-- # Make initial request- response = await self.execute_request(- client=client,- url=url,- headers=github_headers,- params=params,- method=method,- )-- # Handle token refresh if needed- if self.refresh and self._has_token_expired(response.status_code):- await self.get_latest_token()- github_headers = await self._get_github_headers()- response = await self.execute_request(- client=client,- url=url,- headers=github_headers,- params=params,- method=method,- )-- response.raise_for_status()- headers = {}- if 'Link' in response.headers:- headers['Link'] = response.headers['Link']-- return response.json(), headers-- except httpx.HTTPStatusError as e:- raise self.handle_http_status_error(e)- except httpx.HTTPError as e:- raise self.handle_http_error(e)-- async def get_user(self) -> User:- url = f'{self.BASE_URL}/user'- response, _ = await self._make_request(url)-- return User(- id=str(response.get('id', '')),- login=response.get('login'),- avatar_url=response.get('avatar_url'),- company=response.get('company'),- name=response.get('name'),- email=response.get('email'),- )-- async def verify_access(self) -> bool:- """Verify if the token is valid by making a simple request."""- url = f'{self.BASE_URL}'- await self._make_request(url)- return True-- async def _fetch_paginated_repos(- self, url: str, params: dict, max_repos: int, extract_key: str | None = None- ) -> list[dict]:- """Fetch repositories with pagination support.-- Args:- url: The API endpoint URL- params: Query parameters for the request- max_repos: Maximum number of repositories to fetch- extract_key: If provided, extract repositories from this key in the response-- Returns:- List of repository dictionaries- """- repos: list[dict] = []- page = 1-- while len(repos) < max_repos:- page_params = {**params, 'page': str(page)}- response, headers = await self._make_request(url, page_params)-- # Extract repositories from response- page_repos = response.get(extract_key, []) if extract_key else response-- if not page_repos: # No more repositories- break-- repos.extend(page_repos)- page += 1-- # Check if we've reached the last page- link_header = headers.get('Link', '')- if 'rel="next"' not in link_header:- break-- return repos[:max_repos] # Trim to max_repos if needed-- def parse_pushed_at_date(self, repo):- ts = repo.get('pushed_at')- return datetime.strptime(ts, '%Y-%m-%dT%H:%M:%SZ') if ts else datetime.min-- def _parse_repository(- self, repo: dict, link_header: str | None = None- ) -> Repository:- """Parse a GitHub API repository response into a Repository object.-- Args:- repo: Repository data from GitHub API- link_header: Optional link header for pagination-- Returns:- Repository object- """- return Repository(- id=str(repo.get('id')), # type: ignore[arg-type]- full_name=repo.get('full_name'), # type: ignore[arg-type]- stargazers_count=repo.get('stargazers_count'),- git_provider=ProviderType.GITHUB,- is_public=not repo.get('private', True),- owner_type=(- OwnerType.ORGANIZATION- if repo.get('owner', {}).get('type') == 'Organization'- else OwnerType.USER- ),- link_header=link_header,- main_branch=repo.get('default_branch'),- )-- async def get_paginated_repos(- self,- page: int,- per_page: int,- sort: str,- installation_id: str | None,- query: str | None = None,- ):- params = {'page': str(page), 'per_page': str(per_page)}- if installation_id:- url = f'{self.BASE_URL}/user/installations/{installation_id}/repositories'- response, headers = await self._make_request(url, params)- response = response.get('repositories', [])- else:- url = f'{self.BASE_URL}/user/repos'- params['sort'] = sort- response, headers = await self._make_request(url, params)-- next_link: str = headers.get('Link', '')- return [- self._parse_repository(repo, link_header=next_link) for repo in response- ]-- async def get_all_repositories(- self, sort: str, app_mode: AppMode- ) -> list[Repository]:- MAX_REPOS = 1000- PER_PAGE = 100 # Maximum allowed by GitHub API- all_repos: list[dict] = []-- if app_mode == AppMode.SAAS:- # Get all installation IDs and fetch repos for each one- installation_ids = await self.get_installations()-- # Iterate through each installation ID- for installation_id in installation_ids:- params = {'per_page': str(PER_PAGE)}- url = (- f'{self.BASE_URL}/user/installations/{installation_id}/repositories'- )-- # Fetch repositories for this installation- installation_repos = await self._fetch_paginated_repos(- url, params, MAX_REPOS - len(all_repos), extract_key='repositories'- )-- all_repos.extend(installation_repos)-- # If we've already reached MAX_REPOS, no need to check other installations- if len(all_repos) >= MAX_REPOS:- break-- if sort == 'pushed':- all_repos.sort(key=self.parse_pushed_at_date, reverse=True)- else:- # Original behavior for non-SaaS mode- params = {'per_page': str(PER_PAGE), 'sort': sort}- url = f'{self.BASE_URL}/user/repos'-- # Fetch user repositories- all_repos = await self._fetch_paginated_repos(url, params, MAX_REPOS)-- # Convert to Repository objects- return [self._parse_repository(repo) for repo in all_repos]-- async def get_installations(self) -> list[str]:- url = f'{self.BASE_URL}/user/installations'- response, _ = await self._make_request(url)- installations = response.get('installations', [])- return [str(i['id']) for i in installations]-- async def get_user_organizations(self) -> list[str]:- """Get list of organization logins that the user is a member of."""- url = f'{self.BASE_URL}/user/orgs'- try:- response, _ = await self._make_request(url)- orgs = [org['login'] for org in response]- return orgs- except Exception as e:- logger.warning(f'Failed to get user organizations: {e}')- return []-- def _fuzzy_match_org_name(self, query: str, org_name: str) -> bool:- """Check if query fuzzy matches organization name."""- query_lower = query.lower().replace('-', '').replace('_', '').replace(' ', '')- org_lower = org_name.lower().replace('-', '').replace('_', '').replace(' ', '')-- # Exact match after normalization- if query_lower == org_lower:- return True-- # Query is a substring of org name- if query_lower in org_lower:- return True-- # Org name is a substring of query (less common but possible)- if org_lower in query_lower:- return True-- return False-- async def search_repositories(- self, query: str, per_page: int, sort: str, order: str, public: bool- ) -> list[Repository]:- url = f'{self.BASE_URL}/search/repositories'- params = {- 'per_page': per_page,- 'sort': sort,- 'order': order,- }-- if public:- url_parts = query.split('/')- if len(url_parts) < 4:- return []-- org = url_parts[3]- repo_name = url_parts[4]- # Add is:public to the query to ensure we only search for public repositories- params['q'] = f'in:name {org}/{repo_name} is:public'-- # Handle private repository searches- if not public and '/' in query:- org, repo_query = query.split('/', 1)- query_with_user = f'org:{org} in:name {repo_query}'- params['q'] = query_with_user- elif not public:- # Expand search scope to include user's repositories and organizations they're a member of- user = await self.get_user()- user_orgs = await self.get_user_organizations()-- # Search in user repos and org repos separately- all_repos = []-- # Search in user repositories- user_query = f'{query} user:{user.login}'- user_params = params.copy()- user_params['q'] = user_query-- try:- user_response, _ = await self._make_request(url, user_params)- user_items = user_response.get('items', [])- all_repos.extend(user_items)- except Exception as e:- logger.warning(f'User search failed: {e}')-- # Search for repos named "query" in each organization- for org in user_orgs:- org_query = f'{query} org:{org}'- org_params = params.copy()- org_params['q'] = org_query-- try:- org_response, _ = await self._make_request(url, org_params)- org_items = org_response.get('items', [])- all_repos.extend(org_items)- except Exception as e:- logger.warning(f'Org {org} search failed: {e}')-- # Also search for top repos from orgs that match the query name- for org in user_orgs:- if self._fuzzy_match_org_name(query, org):- org_repos_query = f'org:{org}'- org_repos_params = params.copy()- org_repos_params['q'] = org_repos_query- org_repos_params['sort'] = 'stars'- org_repos_params['per_page'] = 2 # Limit to first 2 repos-- try:- org_repos_response, _ = await self._make_request(- url, org_repos_params- )- org_repo_items = org_repos_response.get('items', [])- all_repos.extend(org_repo_items)- except Exception as e:- logger.warning(f'Org repos search for {org} failed: {e}')-- return [self._parse_repository(repo) for repo in all_repos]-- # Default case (public search or slash query)- response, _ = await self._make_request(url, params)- repo_items = response.get('items', [])- return [self._parse_repository(repo) for repo in repo_items]-- async def execute_graphql_query(- self, query: str, variables: dict[str, Any]- ) -> dict[str, Any]:- """Execute a GraphQL query against the GitHub API."""- try:- async with httpx.AsyncClient() as client:- github_headers = await self._get_github_headers()- response = await client.post(- f'{self.BASE_URL}/graphql',- headers=github_headers,- json={'query': query, 'variables': variables},- )- response.raise_for_status()-- result = response.json()- if 'errors' in result:- raise UnknownException(- f'GraphQL query error: {json.dumps(result["errors"])}'- )-- return dict(result)-- except httpx.HTTPStatusError as e:- raise self.handle_http_status_error(e)- except httpx.HTTPError as e:- raise self.handle_http_error(e)-- async def get_suggested_tasks(self) -> list[SuggestedTask]:- """Get suggested tasks for the authenticated user across all repositories.-- Returns:- - PRs authored by the user.- - Issues assigned to the user.-- Note: Queries are split to avoid timeout issues.- """- # Get user info to use in queries- user = await self.get_user()- login = user.login- tasks: list[SuggestedTask] = []- variables = {'login': login}-- try:- pr_response = await self.execute_graphql_query(- suggested_task_pr_graphql_query, variables- )- pr_data = pr_response['data']['user']-- # Process pull requests- for pr in pr_data['pullRequests']['nodes']:- repo_name = pr['repository']['nameWithOwner']-- # Start with default task type- task_type = TaskType.OPEN_PR-- # Check for specific states- if pr['mergeable'] == 'CONFLICTING':- task_type = TaskType.MERGE_CONFLICTS- elif (- pr['commits']['nodes']- and pr['commits']['nodes'][0]['commit']['statusCheckRollup']- and pr['commits']['nodes'][0]['commit']['statusCheckRollup'][- 'state'- ]- == 'FAILURE'- ):- task_type = TaskType.FAILING_CHECKS- elif any(- review['state'] in ['CHANGES_REQUESTED', 'COMMENTED']- for review in pr['reviews']['nodes']- ):- task_type = TaskType.UNRESOLVED_COMMENTS-- # Only add the task if it's not OPEN_PR- if task_type != TaskType.OPEN_PR:- tasks.append(- SuggestedTask(- git_provider=ProviderType.GITHUB,- task_type=task_type,- repo=repo_name,- issue_number=pr['number'],- title=pr['title'],- )- )-- except Exception as e:- logger.info(- f'Error fetching suggested task for PRs: {e}',- extra={- 'signal': 'github_suggested_tasks',- 'user_id': self.external_auth_id,- },- )-- try:- # Execute issue query- issue_response = await self.execute_graphql_query(- suggested_task_issue_graphql_query, variables- )- issue_data = issue_response['data']['user']-- # Process issues- for issue in issue_data['issues']['nodes']:- repo_name = issue['repository']['nameWithOwner']- tasks.append(- SuggestedTask(- git_provider=ProviderType.GITHUB,- task_type=TaskType.OPEN_ISSUE,- repo=repo_name,- issue_number=issue['number'],- title=issue['title'],- )- )-- return tasks-- except Exception as e:- logger.info(- f'Error fetching suggested task for issues: {e}',- extra={- 'signal': 'github_suggested_tasks',- 'user_id': self.external_auth_id,- },- )-- return tasks-- async def get_repository_details_from_repo_name(- self, repository: str- ) -> Repository:- url = f'{self.BASE_URL}/repos/{repository}'- repo, _ = await self._make_request(url)-- return self._parse_repository(repo)-- async def get_branches(self, repository: str) -> list[Branch]:- """Get branches for a repository"""- url = f'{self.BASE_URL}/repos/{repository}/branches'-- # Set maximum branches to fetch (100 per page)- MAX_BRANCHES = 5_000- PER_PAGE = 100-- all_branches: list[Branch] = []- page = 1-- # Fetch up to 10 pages of branches- while len(all_branches) < MAX_BRANCHES:- params = {'per_page': str(PER_PAGE), 'page': str(page)}- response, headers = await self._make_request(url, params)-- if not response: # No more branches- break-- for branch_data in response:- # Extract the last commit date if available- last_push_date = None- if branch_data.get('commit') and branch_data['commit'].get('commit'):- commit_info = branch_data['commit']['commit']- if commit_info.get('committer') and commit_info['committer'].get(- 'date'- ):- last_push_date = commit_info['committer']['date']-- branch = Branch(- name=branch_data.get('name'),- commit_sha=branch_data.get('commit', {}).get('sha', ''),- protected=branch_data.get('protected', False),- last_push_date=last_push_date,- )- all_branches.append(branch)-- page += 1-- # Check if we've reached the last page- link_header = headers.get('Link', '')- if 'rel="next"' not in link_header:- break-- return all_branches-- async def get_paginated_branches(- self, repository: str, page: int = 1, per_page: int = 30- ) -> PaginatedBranchesResponse:- """Get branches for a repository with pagination"""- url = f'{self.BASE_URL}/repos/{repository}/branches'-- params = {'per_page': str(per_page), 'page': str(page)}- response, headers = await self._make_request(url, params)-- branches: list[Branch] = []- for branch_data in response:- # Extract the last commit date if available- last_push_date = None- if branch_data.get('commit') and branch_data['commit'].get('commit'):- commit_info = branch_data['commit']['commit']- if commit_info.get('committer') and commit_info['committer'].get(- 'date'- ):- last_push_date = commit_info['committer']['date']-- branch = Branch(- name=branch_data.get('name'),- commit_sha=branch_data.get('commit', {}).get('sha', ''),- protected=branch_data.get('protected', False),- last_push_date=last_push_date,- )- branches.append(branch)-- # Parse Link header to determine if there's a next page- has_next_page = False- if 'Link' in headers:- link_header = headers['Link']- has_next_page = 'rel="next"' in link_header-- return PaginatedBranchesResponse(- branches=branches,- has_next_page=has_next_page,- current_page=page,- per_page=per_page,- total_count=None, # GitHub doesn't provide total count in branch API- )-- async def search_branches(- self, repository: str, query: str, per_page: int = 30- ) -> list[Branch]:- """Search branches by name using GitHub GraphQL with a partial query."""- # Require a non-empty query- if not query:- return []-- # Clamp per_page to GitHub GraphQL limits- per_page = min(max(per_page, 1), 100)-- # Extract owner and repo name from the repository string- parts = repository.split('/')- if len(parts) < 2:- return []- owner, name = parts[-2], parts[-1]-- variables = {- 'owner': owner,- 'name': name,- 'query': query or '',- 'perPage': per_page,- }-- try:- result = await self.execute_graphql_query(- search_branches_graphql_query, variables- )- except Exception as e:- logger.warning(f'Failed to search for branches: {e}')- # Fallback to empty result on any GraphQL error- return []-- repo = result.get('data', {}).get('repository')- if not repo or not repo.get('refs'):- return []-- branches: list[Branch] = []- for node in repo['refs'].get('nodes', []):- bname = node.get('name') or ''- target = node.get('target') or {}- typename = target.get('__typename')- commit_sha = ''- last_push_date = None- if typename == 'Commit':- commit_sha = target.get('oid', '') or ''- last_push_date = target.get('committedDate')-- protected = node.get('branchProtectionRule') is not None-- branches.append(- Branch(- name=bname,- commit_sha=commit_sha,- protected=protected,- last_push_date=last_push_date,- )- )-- return branches-- async def create_pr(- self,- repo_name: str,- source_branch: str,- target_branch: str,- title: str,- body: str | None = None,- draft: bool = True,- labels: list[str] | None = None,- ) -> str:- """Creates a PR using user credentials-- Args:- repo_name: The full name of the repository (owner/repo)- source_branch: The name of the branch where your changes are implemented- target_branch: The name of the branch you want the changes pulled into- title: The title of the pull request (optional, defaults to a generic title)- body: The body/description of the pull request (optional)- draft: Whether to create the PR as a draft (optional, defaults to False)- labels: A list of labels to apply to the pull request (optional)-- Returns:- - PR URL when successful- - Error message when unsuccessful- """- url = f'{self.BASE_URL}/repos/{repo_name}/pulls'-- # Set default body if none provided- if not body:- body = f'Merging changes from {source_branch} into {target_branch}'-- # Prepare the request payload- payload = {- 'title': title,- 'head': source_branch,- 'base': target_branch,- 'body': body,- 'draft': draft,- }-- # Make the POST request to create the PR- response, _ = await self._make_request(- url=url, params=payload, method=RequestMethod.POST- )-- # Add labels if provided (PRs are a type of issue in GitHub's API)- if labels and len(labels) > 0:- pr_number = response['number']- labels_url = f'{self.BASE_URL}/repos/{repo_name}/issues/{pr_number}/labels'- labels_payload = {'labels': labels}- await self._make_request(- url=labels_url, params=labels_payload, method=RequestMethod.POST- )-- # Return the HTML URL of the created PR- return response['html_url']-- async def get_pr_details(self, repository: str, pr_number: int) -> dict:- """Get detailed information about a specific pull request-- Args:- repository: Repository name in format 'owner/repo'- pr_number: The pull request number-- Returns:- Raw GitHub API response for the pull request- """- url = f'{self.BASE_URL}/repos/{repository}/pulls/{pr_number}'- pr_data, _ = await self._make_request(url)-- return pr_data-- async def get_microagent_content(- self, repository: str, file_path: str- ) -> MicroagentContentResponse:- """Fetch individual file content from GitHub repository.-- Args:- repository: Repository name in format 'owner/repo'- file_path: Path to the file within the repository-- Returns:- MicroagentContentResponse with parsed content and triggers-- Raises:- RuntimeError: If file cannot be fetched or doesn't exist- """- file_url = f'{self.BASE_URL}/repos/{repository}/contents/{file_path}'-- file_data, _ = await self._make_request(file_url)- file_content = base64.b64decode(file_data['content']).decode('utf-8')-- # Parse the content to extract triggers from frontmatter- return self._parse_microagent_content(file_content, file_path)-- async def is_pr_open(self, repository: str, pr_number: int) -> bool:- """Check if a GitHub PR is still active (not closed/merged).-- Args:- repository: Repository name in format 'owner/repo'- pr_number: The PR number to check-- Returns:- True if PR is active (open), False if closed/merged- """- try:- pr_details = await self.get_pr_details(repository, pr_number)-- # GitHub API response structure- # https://docs.github.com/en/rest/pulls/pulls#get-a-pull-request- if 'state' in pr_details:- return pr_details['state'] == 'open'- elif 'merged' in pr_details and 'closed_at' in pr_details:- # Check if PR is merged or closed- return not (pr_details['merged'] or pr_details['closed_at'])-- # If we can't determine the state, assume it's active (safer default)- logger.warning(- f'Could not determine GitHub PR status for {repository}#{pr_number}. '- f'Response keys: {list(pr_details.keys())}. Assuming PR is active.'- )- return True-- except Exception as e:- logger.warning(- f'Could not determine GitHub PR status for {repository}#{pr_number}: {e}. '- f'Including conversation to be safe.'- )- # If we can't determine the PR status, include the conversation to be safe- return True-- async def get_issue_or_pr_comments(- self, repository: str, issue_number: int, max_comments: int = 10- ) -> list[Comment]:- """Get comments for an issue.-- Args:- repository: Repository name in format 'owner/repo'- issue_number: The issue number- discussion_id: Not used for GitHub (kept for compatibility with GitLab)-- Returns:- List of Comment objects ordered by creation date- """- url = f'{self.BASE_URL}/repos/{repository}/issues/{issue_number}/comments'- page = 1- all_comments: list[dict] = []-- while len(all_comments) < max_comments:- params = {- 'per_page': 10,- 'sort': 'created',- 'direction': 'asc',- 'page': page,- }- response, headers = await self._make_request(url, params=params)- all_comments.extend(response or [])-- # Parse the Link header for rel="next"- link_header = headers.get('Link', '')- if 'rel="next"' not in link_header:- break-- page += 1-- return self._process_raw_comments(all_comments)-- async def get_issue_or_pr_title_and_body(- self, repository: str, issue_number: int- ) -> tuple[str, str]:- """Get the title and body of an issue.-- Args:- repository: Repository name in format 'owner/repo'- issue_number: The issue number-- Returns:- A tuple of (title, body)- """- url = f'{self.BASE_URL}/repos/{repository}/issues/{issue_number}'- response, _ = await self._make_request(url)- title = response.get('title') or ''- body = response.get('body') or ''- return title, body-- async def get_review_thread_comments(- self,- comment_id: str,- repository: str,- pr_number: int,- ) -> list[Comment]:- """Get all comments in a review thread starting from a specific comment.-- Uses GraphQL to traverse the reply chain from the given comment up to the root- comment, then finds the review thread and returns all comments in the thread.-- Args:- comment_id: The GraphQL node ID of any comment in the thread- repo: Repository name- pr_number: Pull request number-- Returns:- List of Comment objects representing the entire thread- """-- # Step 1: Use existing GraphQL query to get the comment and check for replyTo- variables = {'commentId': comment_id}- data = await self.execute_graphql_query(- get_thread_from_comment_graphql_query, variables- )-- comment_node = data.get('data', {}).get('node')- if not comment_node:- return []-- # Step 2: If replyTo exists, traverse to the root comment- root_comment_id = comment_id- reply_to = comment_node.get('replyTo')- if reply_to:- root_comment_id = reply_to['id']-- # Step 3: Get all review threads and find the one containing our root comment- owner, repo = repository.split('/')- thread_id = None- after_cursor = None- has_next_page = True-- while has_next_page and not thread_id:- threads_variables: dict[str, Any] = {- 'owner': owner,- 'repo': repo,- 'number': pr_number,- 'first': 50,- }- if after_cursor:- threads_variables['after'] = after_cursor-- threads_data = await self.execute_graphql_query(- get_review_threads_graphql_query, threads_variables- )-- review_threads_data = (- threads_data.get('data', {})- .get('repository', {})- .get('pullRequest', {})- .get('reviewThreads', {})- )-- review_threads = review_threads_data.get('nodes', [])- page_info = review_threads_data.get('pageInfo', {})-- # Search for the thread containing our root comment- for thread in review_threads:- first_comments = thread.get('comments', {}).get('nodes', [])- for first_comment in first_comments:- if first_comment.get('id') == root_comment_id:- thread_id = thread.get('id')- break- if thread_id:- break-- # Update pagination variables- has_next_page = page_info.get('hasNextPage', False)- after_cursor = page_info.get('endCursor')-- if not thread_id:- # Fallback: return just the comments we found during traversal- logger.warning(- f'Could not find review thread for comment {comment_id}, returning traversed comments'- )- return []-- # Step 4: Get all comments from the review thread using the thread ID- all_thread_comments = []- after_cursor = None- has_next_page = True-- while has_next_page:- comments_variables: dict[str, Any] = {}- comments_variables['threadId'] = thread_id- comments_variables['page'] = 50- if after_cursor:- comments_variables['after'] = after_cursor-- thread_comments_data = await self.execute_graphql_query(- get_thread_comments_graphql_query, comments_variables- )-- thread_node = thread_comments_data.get('data', {}).get('node')- if not thread_node:- break-- comments_data = thread_node.get('comments', {})- comments_nodes = comments_data.get('nodes', [])- page_info = comments_data.get('pageInfo', {})-- all_thread_comments.extend(comments_nodes)-- has_next_page = page_info.get('hasNextPage', False)- after_cursor = page_info.get('endCursor')-- return self._process_raw_comments(all_thread_comments)-- def _process_raw_comments(- self, comments_data: list, max_comments: int = 10- ) -> list[Comment]:- """Convert raw comment data to Comment objects."""- comments: list[Comment] = []- for comment in comments_data:- author = 'unknown'-- if comment.get('author'):- author = comment.get('author', {}).get('login', 'unknown')- elif comment.get('user'):- author = comment.get('user', {}).get('login', 'unknown')-- comments.append(- Comment(- id=str(comment.get('id', 'unknown')),- body=self._truncate_comment(comment.get('body', '')),- author=author,- created_at=datetime.fromisoformat(- comment.get('createdAt', '').replace('Z', '+00:00')- )- if comment.get('createdAt')- else datetime.fromtimestamp(0),- updated_at=datetime.fromisoformat(- comment.get('updatedAt', '').replace('Z', '+00:00')- )- if comment.get('updatedAt')- else datetime.fromtimestamp(0),- system=False,- )- )-- # Sort comments by creation date to maintain chronological order- comments.sort(key=lambda c: c.created_at)- return comments[-max_comments:]-github_service_cls = os.environ.get('OPENHANDS_GITHUB_SERVICE_CLS',diff --git a/openhands/integrations/github/service/__init__.py b/openhands/integrations/github/service/__init__.pynew file mode 100644index 0000000000..ea0bef7d64--- /dev/null+++ b/openhands/integrations/github/service/__init__.py@@ -0,0 +1,15 @@+# openhands/integrations/github/service/__init__.py++from .branches_prs import GitHubBranchesMixin+from .features import GitHubFeaturesMixin+from .prs import GitHubPRsMixin+from .repos import GitHubReposMixin+from .resolver import GitHubResolverMixin++__all__ = [+ 'GitHubBranchesMixin',+ 'GitHubFeaturesMixin',+ 'GitHubPRsMixin',+ 'GitHubReposMixin',+ 'GitHubResolverMixin',+]diff --git a/openhands/integrations/github/service/base.py b/openhands/integrations/github/service/base.pynew file mode 100644index 0000000000..e7f4b74930--- /dev/null+++ b/openhands/integrations/github/service/base.py@@ -0,0 +1,125 @@+import json+from typing import Any, cast++import httpx+from pydantic import SecretStr++from openhands.integrations.service_types import (+ BaseGitService,+ RequestMethod,+ UnknownException,+ User,+)+++class GitHubMixinBase(BaseGitService):+ """+ Declares common attributes and method signatures used across mixins.+ """++ BASE_URL: str+ token: SecretStr+ refresh: bool+ external_auth_id: str | None++ async def _get_github_headers(self) -> dict:+ """Retrieve the GH Token from settings store to construct the headers."""+ if not self.token:+ latest_token = await self.get_latest_token()+ if latest_token:+ self.token = latest_token++ return {+ 'Authorization': f'Bearer {self.token.get_secret_value() if self.token else ""}',+ 'Accept': 'application/vnd.github.v3+json',+ }++ async def get_latest_token(self) -> SecretStr | None: # type: ignore[override]+ return self.token++ async def _make_request(+ self,+ url: str,+ params: dict | None = None,+ method: RequestMethod = RequestMethod.GET,+ ) -> tuple[Any, dict]: # type: ignore[override]+ try:+ async with httpx.AsyncClient() as client:+ github_headers = await self._get_github_headers()++ # Make initial request+ response = await self.execute_request(+ client=client,+ url=url,+ headers=github_headers,+ params=params,+ method=method,+ )++ # Handle token refresh if needed+ if self.refresh and self._has_token_expired(response.status_code):+ await self.get_latest_token()+ github_headers = await self._get_github_headers()+ response = await self.execute_request(+ client=client,+ url=url,+ headers=github_headers,+ params=params,+ method=method,+ )++ response.raise_for_status()+ headers: dict = {}+ if 'Link' in response.headers:+ headers['Link'] = response.headers['Link']++ return response.json(), headers++ except httpx.HTTPStatusError as e:+ raise self.handle_http_status_error(e)+ except httpx.HTTPError as e:+ raise self.handle_http_error(e)++ async def execute_graphql_query(+ self, query: str, variables: dict[str, Any]+ ) -> dict[str, Any]:+ try:+ async with httpx.AsyncClient() as client:+ github_headers = await self._get_github_headers()+ response = await client.post(+ f'{self.BASE_URL}/graphql',+ headers=github_headers,+ json={'query': query, 'variables': variables},+ )+ response.raise_for_status()++ result = response.json()+ if 'errors' in result:+ raise UnknownException(+ f'GraphQL query error: {json.dumps(result["errors"])}'+ )++ return dict(result)++ except httpx.HTTPStatusError as e:+ raise self.handle_http_status_error(e)+ except httpx.HTTPError as e:+ raise self.handle_http_error(e)++ async def verify_access(self) -> bool:+ url = f'{self.BASE_URL}'+ await self._make_request(url)+ return True++ async def get_user(self):+ url = f'{self.BASE_URL}/user'+ response, _ = await self._make_request(url)++ return User(+ id=str(response.get('id', '')),+ login=cast(str, response.get('login') or ''),+ avatar_url=cast(str, response.get('avatar_url') or ''),+ company=response.get('company'),+ name=response.get('name'),+ email=response.get('email'),+ )diff --git a/openhands/integrations/github/service/branches_prs.py b/openhands/integrations/github/service/branches_prs.pynew file mode 100644index 0000000000..4437c33d41--- /dev/null+++ b/openhands/integrations/github/service/branches_prs.py@@ -0,0 +1,161 @@+from openhands.core.logger import openhands_logger as logger+from openhands.integrations.github.queries import (+ search_branches_graphql_query,+)+from openhands.integrations.github.service.base import GitHubMixinBase+from openhands.integrations.service_types import Branch, PaginatedBranchesResponse+++class GitHubBranchesMixin(GitHubMixinBase):+ """+ Methods for interacting with branches for a repo+ """++ async def get_branches(self, repository: str) -> list[Branch]:+ """Get branches for a repository"""+ url = f'{self.BASE_URL}/repos/{repository}/branches'++ # Set maximum branches to fetch (100 per page)+ MAX_BRANCHES = 5_000+ PER_PAGE = 100++ all_branches: list[Branch] = []+ page = 1++ # Fetch up to 10 pages of branches+ while len(all_branches) < MAX_BRANCHES:+ params = {'per_page': str(PER_PAGE), 'page': str(page)}+ response, headers = await self._make_request(url, params)++ if not response: # No more branches+ break++ for branch_data in response:+ # Extract the last commit date if available+ last_push_date = None+ if branch_data.get('commit') and branch_data['commit'].get('commit'):+ commit_info = branch_data['commit']['commit']+ if commit_info.get('committer') and commit_info['committer'].get(+ 'date'+ ):+ last_push_date = commit_info['committer']['date']++ branch = Branch(+ name=branch_data.get('name'),+ commit_sha=branch_data.get('commit', {}).get('sha', ''),+ protected=branch_data.get('protected', False),+ last_push_date=last_push_date,+ )+ all_branches.append(branch)++ page += 1++ # Check if we've reached the last page+ link_header = headers.get('Link', '')+ if 'rel="next"' not in link_header:+ break++ return all_branches++ async def get_paginated_branches(+ self, repository: str, page: int = 1, per_page: int = 30+ ) -> PaginatedBranchesResponse:+ """Get branches for a repository with pagination"""+ url = f'{self.BASE_URL}/repos/{repository}/branches'++ params = {'per_page': str(per_page), 'page': str(page)}+ response, headers = await self._make_request(url, params)++ branches: list[Branch] = []+ for branch_data in response:+ # Extract the last commit date if available+ last_push_date = None+ if branch_data.get('commit') and branch_data['commit'].get('commit'):+ commit_info = branch_data['commit']['commit']+ if commit_info.get('committer') and commit_info['committer'].get(+ 'date'+ ):+ last_push_date = commit_info['committer']['date']++ branch = Branch(+ name=branch_data.get('name'),+ commit_sha=branch_data.get('commit', {}).get('sha', ''),+ protected=branch_data.get('protected', False),+ last_push_date=last_push_date,+ )+ branches.append(branch)++ # Parse Link header to determine if there's a next page+ has_next_page = False+ if 'Link' in headers:+ link_header = headers['Link']+ has_next_page = 'rel="next"' in link_header++ return PaginatedBranchesResponse(+ branches=branches,+ has_next_page=has_next_page,+ current_page=page,+ per_page=per_page,+ total_count=None, # GitHub doesn't provide total count in branch API+ )++ async def search_branches(+ self, repository: str, query: str, per_page: int = 30+ ) -> list[Branch]:+ """Search branches by name using GitHub GraphQL with a partial query."""+ # Require a non-empty query+ if not query:+ return []++ # Clamp per_page to GitHub GraphQL limits+ per_page = min(max(per_page, 1), 100)++ # Extract owner and repo name from the repository string+ parts = repository.split('/')+ if len(parts) < 2:+ return []+ owner, name = parts[-2], parts[-1]++ variables = {+ 'owner': owner,+ 'name': name,+ 'query': query or '',+ 'perPage': per_page,+ }++ try:+ result = await self.execute_graphql_query(+ search_branches_graphql_query, variables+ )+ except Exception as e:+ logger.warning(f'Failed to search for branches: {e}')+ # Fallback to empty result on any GraphQL error+ return []++ repo = result.get('data', {}).get('repository')+ if not repo or not repo.get('refs'):+ return []++ branches: list[Branch] = []+ for node in repo['refs'].get('nodes', []):+ bname = node.get('name') or ''+ target = node.get('target') or {}+ typename = target.get('__typename')+ commit_sha = ''+ last_push_date = None+ if typename == 'Commit':+ commit_sha = target.get('oid', '') or ''+ last_push_date = target.get('committedDate')++ protected = node.get('branchProtectionRule') is not None++ branches.append(+ Branch(+ name=bname,+ commit_sha=commit_sha,+ protected=protected,+ last_push_date=last_push_date,+ )+ )++ return branchesdiff --git a/openhands/integrations/github/service/features.py b/openhands/integrations/github/service/features.pynew file mode 100644index 0000000000..e8ff9b9e41--- /dev/null+++ b/openhands/integrations/github/service/features.py@@ -0,0 +1,177 @@+import base64++from openhands.core.logger import openhands_logger as logger+from openhands.integrations.github.queries import (+ suggested_task_issue_graphql_query,+ suggested_task_pr_graphql_query,+)+from openhands.integrations.github.service.base import GitHubMixinBase+from openhands.integrations.service_types import (+ MicroagentContentResponse,+ ProviderType,+ SuggestedTask,+ TaskType,+)+++class GitHubFeaturesMixin(GitHubMixinBase):+ """+ Methods used for custom features in UI driven via GitHub integration+ """++ async def get_suggested_tasks(self) -> list[SuggestedTask]:+ """Get suggested tasks for the authenticated user across all repositories.++ Returns:+ - PRs authored by the user.+ - Issues assigned to the user.++ Note: Queries are split to avoid timeout issues.+ """+ # Get user info to use in queries+ user = await self.get_user()+ login = user.login+ tasks: list[SuggestedTask] = []+ variables = {'login': login}++ try:+ pr_response = await self.execute_graphql_query(+ suggested_task_pr_graphql_query, variables+ )+ pr_data = pr_response['data']['user']++ # Process pull requests+ for pr in pr_data['pullRequests']['nodes']:+ repo_name = pr['repository']['nameWithOwner']++ # Start with default task type+ task_type = TaskType.OPEN_PR++ # Check for specific states+ if pr['mergeable'] == 'CONFLICTING':+ task_type = TaskType.MERGE_CONFLICTS+ elif (+ pr['commits']['nodes']+ and pr['commits']['nodes'][0]['commit']['statusCheckRollup']+ and pr['commits']['nodes'][0]['commit']['statusCheckRollup'][+ 'state'+ ]+ == 'FAILURE'+ ):+ task_type = TaskType.FAILING_CHECKS+ elif any(+ review['state'] in ['CHANGES_REQUESTED', 'COMMENTED']+ for review in pr['reviews']['nodes']+ ):+ task_type = TaskType.UNRESOLVED_COMMENTS++ # Only add the task if it's not OPEN_PR+ if task_type != TaskType.OPEN_PR:+ tasks.append(+ SuggestedTask(+ git_provider=ProviderType.GITHUB,+ task_type=task_type,+ repo=repo_name,+ issue_number=pr['number'],+ title=pr['title'],+ )+ )++ except Exception as e:+ logger.info(+ f'Error fetching suggested task for PRs: {e}',+ extra={+ 'signal': 'github_suggested_tasks',+ 'user_id': self.external_auth_id,+ },+ )++ try:+ # Execute issue query+ issue_response = await self.execute_graphql_query(+ suggested_task_issue_graphql_query, variables+ )+ issue_data = issue_response['data']['user']++ # Process issues+ for issue in issue_data['issues']['nodes']:+ repo_name = issue['repository']['nameWithOwner']+ tasks.append(+ SuggestedTask(+ git_provider=ProviderType.GITHUB,+ task_type=TaskType.OPEN_ISSUE,+ repo=repo_name,+ issue_number=issue['number'],+ title=issue['title'],+ )+ )++ return tasks++ except Exception as e:+ logger.info(+ f'Error fetching suggested task for issues: {e}',+ extra={+ 'signal': 'github_suggested_tasks',+ 'user_id': self.external_auth_id,+ },+ )++ return tasks++ """+ Methods specifically for microagent management page+ """++ async def _get_cursorrules_url(self, repository: str) -> str:+ """Get the URL for checking .cursorrules file."""+ return f'{self.BASE_URL}/repos/{repository}/contents/.cursorrules'++ async def _get_microagents_directory_url(+ self, repository: str, microagents_path: str+ ) -> str:+ """Get the URL for checking microagents directory."""+ return f'{self.BASE_URL}/repos/{repository}/contents/{microagents_path}'++ def _is_valid_microagent_file(self, item: dict) -> bool:+ """Check if an item represents a valid microagent file."""+ return (+ item['type'] == 'file'+ and item['name'].endswith('.md')+ and item['name'] != 'README.md'+ )++ def _get_file_name_from_item(self, item: dict) -> str:+ """Extract file name from directory item."""+ return item['name']++ def _get_file_path_from_item(self, item: dict, microagents_path: str) -> str:+ """Extract file path from directory item."""+ return f'{microagents_path}/{item["name"]}'++ def _get_microagents_directory_params(self, microagents_path: str) -> dict | None:+ """Get parameters for the microagents directory request. Return None if no parameters needed."""+ return None++ async def get_microagent_content(+ self, repository: str, file_path: str+ ) -> MicroagentContentResponse:+ """Fetch individual file content from GitHub repository.++ Args:+ repository: Repository name in format 'owner/repo'+ file_path: Path to the file within the repository++ Returns:+ MicroagentContentResponse with parsed content and triggers++ Raises:+ RuntimeError: If file cannot be fetched or doesn't exist+ """+ file_url = f'{self.BASE_URL}/repos/{repository}/contents/{file_path}'++ file_data, _ = await self._make_request(file_url)+ file_content = base64.b64decode(file_data['content']).decode('utf-8')++ # Parse the content to extract triggers from frontmatter+ return self._parse_microagent_content(file_content, file_path)diff --git a/openhands/integrations/github/service/prs.py b/openhands/integrations/github/service/prs.pynew file mode 100644index 0000000000..8192d69079--- /dev/null+++ b/openhands/integrations/github/service/prs.py@@ -0,0 +1,117 @@+from openhands.core.logger import openhands_logger as logger+from openhands.integrations.github.service.base import GitHubMixinBase+from openhands.integrations.service_types import RequestMethod+++class GitHubPRsMixin(GitHubMixinBase):+ """+ Methods for interacting with GitHub PRs+ """++ async def create_pr(+ self,+ repo_name: str,+ source_branch: str,+ target_branch: str,+ title: str,+ body: str | None = None,+ draft: bool = True,+ labels: list[str] | None = None,+ ) -> str:+ """Creates a PR using user credentials++ Args:+ repo_name: The full name of the repository (owner/repo)+ source_branch: The name of the branch where your changes are implemented+ target_branch: The name of the branch you want the changes pulled into+ title: The title of the pull request (optional, defaults to a generic title)+ body: The body/description of the pull request (optional)+ draft: Whether to create the PR as a draft (optional, defaults to False)+ labels: A list of labels to apply to the pull request (optional)++ Returns:+ - PR URL when successful+ - Error message when unsuccessful+ """+ url = f'{self.BASE_URL}/repos/{repo_name}/pulls'++ # Set default body if none provided+ if not body:+ body = f'Merging changes from {source_branch} into {target_branch}'++ # Prepare the request payload+ payload = {+ 'title': title,+ 'head': source_branch,+ 'base': target_branch,+ 'body': body,+ 'draft': draft,+ }++ # Make the POST request to create the PR+ response, _ = await self._make_request(+ url=url, params=payload, method=RequestMethod.POST+ )++ # Add labels if provided (PRs are a type of issue in GitHub's API)+ if labels and len(labels) > 0:+ pr_number = response['number']+ labels_url = f'{self.BASE_URL}/repos/{repo_name}/issues/{pr_number}/labels'+ labels_payload = {'labels': labels}+ await self._make_request(+ url=labels_url, params=labels_payload, method=RequestMethod.POST+ )++ # Return the HTML URL of the created PR+ return response['html_url']++ async def get_pr_details(self, repository: str, pr_number: int) -> dict:+ """Get detailed information about a specific pull request++ Args:+ repository: Repository name in format 'owner/repo'+ pr_number: The pull request number++ Returns:+ Raw GitHub API response for the pull request+ """+ url = f'{self.BASE_URL}/repos/{repository}/pulls/{pr_number}'+ pr_data, _ = await self._make_request(url)++ return pr_data++ async def is_pr_open(self, repository: str, pr_number: int) -> bool:+ """Check if a GitHub PR is still active (not closed/merged).++ Args:+ repository: Repository name in format 'owner/repo'+ pr_number: The PR number to check++ Returns:+ True if PR is active (open), False if closed/merged+ """+ try:+ pr_details = await self.get_pr_details(repository, pr_number)++ # GitHub API response structure+ # https://docs.github.com/en/rest/pulls/pulls#get-a-pull-request+ if 'state' in pr_details:+ return pr_details['state'] == 'open'+ elif 'merged' in pr_details and 'closed_at' in pr_details:+ # Check if PR is merged or closed+ return not (pr_details['merged'] or pr_details['closed_at'])++ # If we can't determine the state, assume it's active (safer default)+ logger.warning(+ f'Could not determine GitHub PR status for {repository}#{pr_number}. '+ f'Response keys: {list(pr_details.keys())}. Assuming PR is active.'+ )+ return True++ except Exception as e:+ logger.warning(+ f'Could not determine GitHub PR status for {repository}#{pr_number}: {e}. '+ f'Including conversation to be safe.'+ )+ # If we can't determine the PR status, include the conversation to be safe+ return Truediff --git a/openhands/integrations/github/service/repos.py b/openhands/integrations/github/service/repos.pynew file mode 100644index 0000000000..6d9f6d7232--- /dev/null+++ b/openhands/integrations/github/service/repos.py@@ -0,0 +1,272 @@+from datetime import datetime++from openhands.core.logger import openhands_logger as logger+from openhands.integrations.github.service.base import GitHubMixinBase+from openhands.integrations.service_types import OwnerType, ProviderType, Repository+from openhands.server.types import AppMode+++class GitHubReposMixin(GitHubMixinBase):+ """+ Methods for interacting with GitHub repositories (from both personal and app installations)+ """++ async def get_installations(self) -> list[str]:+ url = f'{self.BASE_URL}/user/installations'+ response, _ = await self._make_request(url)+ installations = response.get('installations', [])+ return [str(i['id']) for i in installations]++ async def _fetch_paginated_repos(+ self, url: str, params: dict, max_repos: int, extract_key: str | None = None+ ) -> list[dict]:+ """Fetch repositories with pagination support.++ Args:+ url: The API endpoint URL+ params: Query parameters for the request+ max_repos: Maximum number of repositories to fetch+ extract_key: If provided, extract repositories from this key in the response++ Returns:+ List of repository dictionaries+ """+ repos: list[dict] = []+ page = 1++ while len(repos) < max_repos:+ page_params = {**params, 'page': str(page)}+ response, headers = await self._make_request(url, page_params)++ # Extract repositories from response+ page_repos = response.get(extract_key, []) if extract_key else response++ if not page_repos: # No more repositories+ break++ repos.extend(page_repos)+ page += 1++ # Check if we've reached the last page+ link_header = headers.get('Link', '')+ if 'rel="next"' not in link_header:+ break++ return repos[:max_repos] # Trim to max_repos if needed++ def parse_pushed_at_date(self, repo):+ ts = repo.get('pushed_at')+ return datetime.strptime(ts, '%Y-%m-%dT%H:%M:%SZ') if ts else datetime.min++ def _parse_repository(+ self, repo: dict, link_header: str | None = None+ ) -> Repository:+ """Parse a GitHub API repository response into a Repository object.++ Args:+ repo: Repository data from GitHub API+ link_header: Optional link header for pagination++ Returns:+ Repository object+ """+ return Repository(+ id=str(repo.get('id')), # type: ignore[arg-type]+ full_name=repo.get('full_name'), # type: ignore[arg-type]+ stargazers_count=repo.get('stargazers_count'),+ git_provider=ProviderType.GITHUB,+ is_public=not repo.get('private', True),+ owner_type=(+ OwnerType.ORGANIZATION+ if repo.get('owner', {}).get('type') == 'Organization'+ else OwnerType.USER+ ),+ link_header=link_header,+ main_branch=repo.get('default_branch'),+ )++ async def get_paginated_repos(+ self,+ page: int,+ per_page: int,+ sort: str,+ installation_id: str | None,+ query: str | None = None,+ ):+ params = {'page': str(page), 'per_page': str(per_page)}+ if installation_id:+ url = f'{self.BASE_URL}/user/installations/{installation_id}/repositories'+ response, headers = await self._make_request(url, params)+ response = response.get('repositories', [])+ else:+ url = f'{self.BASE_URL}/user/repos'+ params['sort'] = sort+ response, headers = await self._make_request(url, params)++ next_link: str = headers.get('Link', '')+ return [+ self._parse_repository(repo, link_header=next_link) for repo in response+ ]++ async def get_all_repositories(+ self, sort: str, app_mode: AppMode+ ) -> list[Repository]:+ MAX_REPOS = 1000+ PER_PAGE = 100 # Maximum allowed by GitHub API+ all_repos: list[dict] = []++ if app_mode == AppMode.SAAS:+ # Get all installation IDs and fetch repos for each one+ installation_ids = await self.get_installations()++ # Iterate through each installation ID+ for installation_id in installation_ids:+ params = {'per_page': str(PER_PAGE)}+ url = (+ f'{self.BASE_URL}/user/installations/{installation_id}/repositories'+ )++ # Fetch repositories for this installation+ installation_repos = await self._fetch_paginated_repos(+ url, params, MAX_REPOS - len(all_repos), extract_key='repositories'+ )++ all_repos.extend(installation_repos)++ # If we've already reached MAX_REPOS, no need to check other installations+ if len(all_repos) >= MAX_REPOS:+ break++ if sort == 'pushed':+ all_repos.sort(key=self.parse_pushed_at_date, reverse=True)+ else:+ # Original behavior for non-SaaS mode+ params = {'per_page': str(PER_PAGE), 'sort': sort}+ url = f'{self.BASE_URL}/user/repos'++ # Fetch user repositories+ all_repos = await self._fetch_paginated_repos(url, params, MAX_REPOS)++ # Convert to Repository objects+ return [self._parse_repository(repo) for repo in all_repos]++ async def get_user_organizations(self) -> list[str]:+ """Get list of organization logins that the user is a member of."""+ url = f'{self.BASE_URL}/user/orgs'+ try:+ response, _ = await self._make_request(url)+ orgs = [org['login'] for org in response]+ return orgs+ except Exception as e:+ logger.warning(f'Failed to get user organizations: {e}')+ return []++ def _fuzzy_match_org_name(self, query: str, org_name: str) -> bool:+ """Check if query fuzzy matches organization name."""+ query_lower = query.lower().replace('-', '').replace('_', '').replace(' ', '')+ org_lower = org_name.lower().replace('-', '').replace('_', '').replace(' ', '')++ # Exact match after normalization+ if query_lower == org_lower:+ return True++ # Query is a substring of org name+ if query_lower in org_lower:+ return True++ # Org name is a substring of query (less common but possible)+ if org_lower in query_lower:+ return True++ return False++ async def search_repositories(+ self, query: str, per_page: int, sort: str, order: str, public: bool+ ) -> list[Repository]:+ url = f'{self.BASE_URL}/search/repositories'+ params = {+ 'per_page': per_page,+ 'sort': sort,+ 'order': order,+ }++ if public:+ url_parts = query.split('/')+ if len(url_parts) < 4:+ return []++ org = url_parts[3]+ repo_name = url_parts[4]+ # Add is:public to the query to ensure we only search for public repositories+ params['q'] = f'in:name {org}/{repo_name} is:public'++ # Handle private repository searches+ if not public and '/' in query:+ org, repo_query = query.split('/', 1)+ query_with_user = f'org:{org} in:name {repo_query}'+ params['q'] = query_with_user+ elif not public:+ # Expand search scope to include user's repositories and organizations they're a member of+ user = await self.get_user()+ user_orgs = await self.get_user_organizations()++ # Search in user repos and org repos separately+ all_repos = []++ # Search in user repositories+ user_query = f'{query} user:{user.login}'+ user_params = params.copy()+ user_params['q'] = user_query++ try:+ user_response, _ = await self._make_request(url, user_params)+ user_items = user_response.get('items', [])+ all_repos.extend(user_items)+ except Exception as e:+ logger.warning(f'User search failed: {e}')++ # Search for repos named "query" in each organization+ for org in user_orgs:+ org_query = f'{query} org:{org}'+ org_params = params.copy()+ org_params['q'] = org_query++ try:+ org_response, _ = await self._make_request(url, org_params)+ org_items = org_response.get('items', [])+ all_repos.extend(org_items)+ except Exception as e:+ logger.warning(f'Org {org} search failed: {e}')++ # Also search for top repos from orgs that match the query name+ for org in user_orgs:+ if self._fuzzy_match_org_name(query, org):+ org_repos_query = f'org:{org}'+ org_repos_params = params.copy()+ org_repos_params['q'] = org_repos_query+ org_repos_params['sort'] = 'stars'+ org_repos_params['per_page'] = 2 # Limit to first 2 repos++ try:+ org_repos_response, _ = await self._make_request(+ url, org_repos_params+ )+ org_repo_items = org_repos_response.get('items', [])+ all_repos.extend(org_repo_items)+ except Exception as e:+ logger.warning(f'Org repos search for {org} failed: {e}')++ return [self._parse_repository(repo) for repo in all_repos]++ # Default case (public search or slash query)+ response, _ = await self._make_request(url, params)+ repo_items = response.get('items', [])+ return [self._parse_repository(repo) for repo in repo_items]++ async def get_repository_details_from_repo_name(+ self, repository: str+ ) -> Repository:+ url = f'{self.BASE_URL}/repos/{repository}'+ repo, _ = await self._make_request(url)++ return self._parse_repository(repo)diff --git a/openhands/integrations/github/service/resolver.py b/openhands/integrations/github/service/resolver.pynew file mode 100644index 0000000000..f8013d2dec--- /dev/null+++ b/openhands/integrations/github/service/resolver.py@@ -0,0 +1,225 @@+from datetime import datetime+from typing import Any++from openhands.core.logger import openhands_logger as logger+from openhands.integrations.github.queries import (+ get_review_threads_graphql_query,+ get_thread_comments_graphql_query,+ get_thread_from_comment_graphql_query,+)+from openhands.integrations.github.service.base import GitHubMixinBase+from openhands.integrations.service_types import Comment+++class GitHubResolverMixin(GitHubMixinBase):+ """+ Helper methods used for the GitHub Resolver+ """++ async def get_issue_or_pr_title_and_body(+ self, repository: str, issue_number: int+ ) -> tuple[str, str]:+ """Get the title and body of an issue.++ Args:+ repository: Repository name in format 'owner/repo'+ issue_number: The issue number++ Returns:+ A tuple of (title, body)+ """+ url = f'{self.BASE_URL}/repos/{repository}/issues/{issue_number}'+ response, _ = await self._make_request(url)+ title = response.get('title') or ''+ body = response.get('body') or ''+ return title, body++ async def get_issue_or_pr_comments(+ self, repository: str, issue_number: int, max_comments: int = 10+ ) -> list[Comment]:+ """Get comments for an issue.++ Args:+ repository: Repository name in format 'owner/repo'+ issue_number: The issue number+ discussion_id: Not used for GitHub (kept for compatibility with GitLab)++ Returns:+ List of Comment objects ordered by creation date+ """+ url = f'{self.BASE_URL}/repos/{repository}/issues/{issue_number}/comments'+ page = 1+ all_comments: list[dict] = []++ while len(all_comments) < max_comments:+ params = {+ 'per_page': 10,+ 'sort': 'created',+ 'direction': 'asc',+ 'page': page,+ }+ response, headers = await self._make_request(url, params=params)+ all_comments.extend(response or [])++ # Parse the Link header for rel="next"+ link_header = headers.get('Link', '')+ if 'rel="next"' not in link_header:+ break++ page += 1++ return self._process_raw_comments(all_comments)++ async def get_review_thread_comments(+ self,+ comment_id: str,+ repository: str,+ pr_number: int,+ ) -> list[Comment]:+ """Get all comments in a review thread starting from a specific comment.++ Uses GraphQL to traverse the reply chain from the given comment up to the root+ comment, then finds the review thread and returns all comments in the thread.++ Args:+ comment_id: The GraphQL node ID of any comment in the thread+ repo: Repository name+ pr_number: Pull request number++ Returns:+ List of Comment objects representing the entire thread+ """++ # Step 1: Use existing GraphQL query to get the comment and check for replyTo+ variables = {'commentId': comment_id}+ data = await self.execute_graphql_query(+ get_thread_from_comment_graphql_query, variables+ )++ comment_node = data.get('data', {}).get('node')+ if not comment_node:+ return []++ # Step 2: If replyTo exists, traverse to the root comment+ root_comment_id = comment_id+ reply_to = comment_node.get('replyTo')+ if reply_to:+ root_comment_id = reply_to['id']++ # Step 3: Get all review threads and find the one containing our root comment+ owner, repo = repository.split('/')+ thread_id = None+ after_cursor = None+ has_next_page = True++ while has_next_page and not thread_id:+ threads_variables: dict[str, Any] = {+ 'owner': owner,+ 'repo': repo,+ 'number': pr_number,+ 'first': 50,+ }+ if after_cursor:+ threads_variables['after'] = after_cursor++ threads_data = await self.execute_graphql_query(+ get_review_threads_graphql_query, threads_variables+ )++ review_threads_data = (+ threads_data.get('data', {})+ .get('repository', {})+ .get('pullRequest', {})+ .get('reviewThreads', {})+ )++ review_threads = review_threads_data.get('nodes', [])+ page_info = review_threads_data.get('pageInfo', {})++ # Search for the thread containing our root comment+ for thread in review_threads:+ first_comments = thread.get('comments', {}).get('nodes', [])+ for first_comment in first_comments:+ if first_comment.get('id') == root_comment_id:+ thread_id = thread.get('id')+ break+ if thread_id:+ break++ # Update pagination variables+ has_next_page = page_info.get('hasNextPage', False)+ after_cursor = page_info.get('endCursor')++ if not thread_id:+ # Fallback: return just the comments we found during traversal+ logger.warning(+ f'Could not find review thread for comment {comment_id}, returning traversed comments'+ )+ return []++ # Step 4: Get all comments from the review thread using the thread ID+ all_thread_comments = []+ after_cursor = None+ has_next_page = True++ while has_next_page:+ comments_variables: dict[str, Any] = {}+ comments_variables['threadId'] = thread_id+ comments_variables['page'] = 50+ if after_cursor:+ comments_variables['after'] = after_cursor++ thread_comments_data = await self.execute_graphql_query(+ get_thread_comments_graphql_query, comments_variables+ )++ thread_node = thread_comments_data.get('data', {}).get('node')+ if not thread_node:+ break++ comments_data = thread_node.get('comments', {})+ comments_nodes = comments_data.get('nodes', [])+ page_info = comments_data.get('pageInfo', {})++ all_thread_comments.extend(comments_nodes)++ has_next_page = page_info.get('hasNextPage', False)+ after_cursor = page_info.get('endCursor')++ return self._process_raw_comments(all_thread_comments)++ def _process_raw_comments(+ self, comments_data: list, max_comments: int = 10+ ) -> list[Comment]:+ """Convert raw comment data to Comment objects."""+ comments: list[Comment] = []+ for comment in comments_data:+ author = 'unknown'++ if comment.get('author'):+ author = comment.get('author', {}).get('login', 'unknown')+ elif comment.get('user'):+ author = comment.get('user', {}).get('login', 'unknown')++ comments.append(+ Comment(+ id=str(comment.get('id', 'unknown')),+ body=self._truncate_comment(comment.get('body', '')),+ author=author,+ created_at=datetime.fromisoformat(+ comment.get('createdAt', '').replace('Z', '+00:00')+ )+ if comment.get('createdAt')+ else datetime.fromtimestamp(0),+ updated_at=datetime.fromisoformat(+ comment.get('updatedAt', '').replace('Z', '+00:00')+ )+ if comment.get('updatedAt')+ else datetime.fromtimestamp(0),+ system=False,+ )+ )++ # Sort comments by creation date to maintain chronological order+ comments.sort(key=lambda c: c.created_at)+ return comments[-max_comments:]diff --git a/openhands/integrations/service_types.py b/openhands/integrations/service_types.pyindex b5734b9f35..613ee69270 100644--- a/openhands/integrations/service_types.py+++ b/openhands/integrations/service_types.py@@ -462,6 +462,9 @@ class BaseGitService(ABC):return comment_body[:max_comment_length] + '...'return comment_body+ def _has_token_expired(self, status_code: int) -> bool:+ return status_code == 401+class InstallationsService(Protocol):async def get_installations(self) -> list[str]: