Support compare URLs in extract_upstream_repository

Fetch commit lists from compare URLs for cherry-pick workflow.

Author: opohorel

agents/tools/upstream_tools.py

@@ -22,10 +22,14 @@ class ExtractUpstreamRepositoryInput(BaseModel):
 class UpstreamRepository(BaseModel):
     """Represents an upstream git repository and commit information."""
     repo_url: str = Field(description="Git clone URL of the upstream repository")
-    commit_hash: str = Field(description="Commit hash to cherry-pick")
+    commit_hash: str = Field(description="Commit hash to cherry-pick (for single commits) or target ref (for compare URLs)")
     original_url: str = Field(description="Original upstream fix URL")
     pr_number: str | None = Field(default=None, description="Pull request or merge request number if this is a PR/MR URL, None otherwise")
     is_pr: bool = Field(default=False, description="True if this is a pull request or merge request URL")
+    is_compare: bool = Field(default=False, description="True if this is a compare/diff URL between two refs")
+    base_ref: str | None = Field(default=None, description="Base reference for compare URLs (e.g., v3.7.0)")
+    target_ref: str | None = Field(default=None, description="Target reference for compare URLs (e.g., v3.7.1)")
+    compare_commits: list[str] | None = Field(default=None, description="List of commit hashes in the compare range (ordered oldest to newest)")
 
 
 class ExtractUpstreamRepositoryOutput(JSONToolOutput[UpstreamRepository]):
@@ -35,15 +39,17 @@ class ExtractUpstreamRepositoryOutput(JSONToolOutput[UpstreamRepository]):
 class ExtractUpstreamRepositoryTool(Tool[ExtractUpstreamRepositoryInput, ToolRunOptions, ExtractUpstreamRepositoryOutput]):
     name = "extract_upstream_repository"
     description = """
-    Extract upstream repository URL and commit hash from a commit or pull request URL.
+    Extract upstream repository URL and commit information from a commit, pull request, or compare URL.
 
     Supports common formats:
     - GitHub/GitLab commit: https://domain.com/owner/repo/commit/hash or /-/commit/hash
     - GitHub/GitLab PR: https://domain.com/owner/repo/pull/123 or /merge_requests/123
+    - GitHub/GitLab compare: https://domain.com/owner/repo/compare/ref1...ref2 or /-/compare/ref1...ref2
     - Query param formats: ?id=hash or ?h=hash (for cgit/gitweb)
 
     For pull requests, fetches the head commit SHA from the PR.
-    Returns the git clone URL and commit hash needed for cherry-picking.
+    For compare URLs, fetches all commits in the range and returns them ordered oldest to newest.
+    Returns the git clone URL and commit information needed for cherry-picking.
     """
     input_schema = ExtractUpstreamRepositoryInput
 
@@ -59,7 +65,7 @@ async def _run(
         try:
             parsed = urlparse(tool_input.upstream_fix_url)
 
-            # Check if this is a pull request URL and extract owner/repo/PR number in one match
+            # Check if this is a pull request URL and extract owner/repo/PR number in one match.
             pr_match = re.search(r'/([\w\-\.]+)/([\w\-\.]+)/pull/(\d+)(?:\.patch)?', parsed.path)
             mr_match = re.search(r'/([\w\-\.]+)/([\w\-\.]+)/-/merge_requests/(\d+)(?:\.patch)?', parsed.path)
 
@@ -117,49 +123,132 @@ async def _run(
                     )
                 )
 
-            else:
-                # Handle regular commit URLs
-                commit_hash = None
-                repo_path = None
-
-                # Pattern 1: /commit/hash or /-/commit/hash in the path (capture repo path and commit hash together)
-                commit_match = re.search(r'^(.*?)(?:/(?:-/)?commit(?:s)?/([a-f0-9]{7,40})(?:\.patch)?)', parsed.path)
-                if commit_match:
-                    repo_path = commit_match.group(1).strip('/')
-                    commit_hash = commit_match.group(2)
-
-                # Pattern 2: query parameters (?id=hash or &h=hash for cgit/gitweb, ?p=repo for repo path)
-                if not commit_hash and parsed.query:
-                    query_match = re.search(r'(?:id|h)=([a-f0-9]{7,40})', parsed.query)
-                    if query_match:
-                        commit_hash = query_match.group(1)
-                        # Extract repo from ?p= parameter
-                        repo_query_match = re.search(r'[?&]p=([^;&]+)', parsed.query)
-                        if repo_query_match:
-                            repo_path = repo_query_match.group(1)
-
-                if not commit_hash:
-                    raise ToolError(f"Could not extract commit hash from URL: {tool_input.upstream_fix_url}")
-
-                if not repo_path:
-                    raise ToolError(f"Could not extract repository path from URL: {tool_input.upstream_fix_url}")
+            # Try to match compare URL
+            compare_match = re.search(r'/([\w\-\.]+)/([\w\-\.]+)/(?:-/)?compare/(.+?)(\.{2,3})([^\s\?#]+)', parsed.path)
+            if compare_match:
+                # Handle GitHub/GitLab Compare URLs
+                owner = compare_match.group(1)
+                repo = compare_match.group(2)
+                base_ref = compare_match.group(3)
+                # Group 4 is the separator (.. or ...) - not used, we always use ... for APIs
+                target_ref = compare_match.group(5).rstrip('.patch')  # Remove .patch if present
+                
+                # Construct repository URL
+                repo_url = f"https://{parsed.netloc}/{owner}/{repo}.git"
+                
+                # Determine if this is GitHub or GitLab based on the URL pattern
+                is_github = '/-/' not in parsed.path
+                
+                # Fetch compare information to get the list of commits
+                if is_github:
+                    # GitHub API - note: GitHub uses ... for compare
+                    api_url = f"https://api.github.com/repos/{owner}/{repo}/compare/{base_ref}...{target_ref}"
+                else:
+                    # GitLab API
+                    api_url = f"https://{parsed.netloc}/api/v4/projects/{owner}%2F{repo}/repository/compare?from={base_ref}&to={target_ref}"
+                
+                headers = {
+                    'Accept': 'application/json',
+                    'User-Agent': 'RHEL-Backport-Agent'
+                }
+                
+                try:
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(api_url, headers=headers, timeout=aiohttp.ClientTimeout(total=15)) as response:
+                            response.raise_for_status()
+                            data = await response.json()
+                            
+                            # Extract commits from API response
+                            if is_github:
+                                # GitHub: commits are in 'commits' array (oldest first)
+                                commits = [commit['sha'] for commit in data.get('commits', [])]
+                            else:
+                                # GitLab: commits are in 'commits' array (newest first)
+                                commits = [commit['id'] for commit in data.get('commits', [])]
+                                # Reverse to get oldest first
+                                commits = list(reversed(commits))
+                            
+                            # Use the last commit (newest) as the default commit_hash
+                            commit_hash = commits[-1] if commits else target_ref
+                            
+                except (aiohttp.ClientError, KeyError) as e:
+                    # If API fails, fall back to using target_ref as commit_hash
+                    # This allows the tool to still work even if API is unavailable
+                    commit_hash = target_ref
+                    commits = []
+                
+                # Return with compare information
+                return ExtractUpstreamRepositoryOutput(
+                    result=UpstreamRepository(
+                        repo_url=repo_url,
+                        commit_hash=commit_hash,
+                        original_url=tool_input.upstream_fix_url,
+                        pr_number=None,
+                        is_pr=False,
+                        is_compare=True,
+                        base_ref=base_ref,
+                        target_ref=target_ref,
+                        compare_commits=commits if commits else None
+                    )
+                )
 
+            # Try to match regular commit URL
+            commit_match = re.search(r'^(.*?)(?:/(?:-/)?commit(?:s)?/([a-f0-9]{7,40})(?:\.patch)?)', parsed.path)
+            if commit_match:
+                repo_path = commit_match.group(1).strip('/')
+                commit_hash = commit_match.group(2)
+                
                 # Construct clone URL
                 scheme = parsed.scheme or 'https'
                 repo_url = f"{scheme}://{parsed.netloc}/{repo_path}"
                 if not repo_url.endswith('.git'):
                     repo_url += '.git'
 
-            # Return for non-PR commits
-            return ExtractUpstreamRepositoryOutput(
-                result=UpstreamRepository(
-                    repo_url=repo_url,
-                    commit_hash=commit_hash,
-                    original_url=tool_input.upstream_fix_url,
-                    pr_number=None,
-                    is_pr=False
+                # Return for regular commit URLs
+                return ExtractUpstreamRepositoryOutput(
+                    result=UpstreamRepository(
+                        repo_url=repo_url,
+                        commit_hash=commit_hash,
+                        original_url=tool_input.upstream_fix_url,
+                        pr_number=None,
+                        is_pr=False
+                    )
                 )
-            )
+
+            # Try to match query parameter format (fourth priority - cgit/gitweb)
+            if parsed.query:
+                query_match = re.search(r'(?:id|h)=([a-f0-9]{7,40})', parsed.query)
+                if query_match:
+                    commit_hash = query_match.group(1)
+                    
+                    # Extract repo from ?p= parameter
+                    repo_path = None
+                    repo_query_match = re.search(r'[?&]p=([^;&]+)', parsed.query)
+                    if repo_query_match:
+                        repo_path = repo_query_match.group(1)
+                    
+                    if not repo_path:
+                        raise ToolError(f"Could not extract repository path from URL: {tool_input.upstream_fix_url}")
+                    
+                    # Construct clone URL
+                    scheme = parsed.scheme or 'https'
+                    repo_url = f"{scheme}://{parsed.netloc}/{repo_path}"
+                    if not repo_url.endswith('.git'):
+                        repo_url += '.git'
+
+                    # Return for query parameter URLs
+                    return ExtractUpstreamRepositoryOutput(
+                        result=UpstreamRepository(
+                            repo_url=repo_url,
+                            commit_hash=commit_hash,
+                            original_url=tool_input.upstream_fix_url,
+                            pr_number=None,
+                            is_pr=False
+                        )
+                    )
+
+            # If we got here, we couldn't match any pattern
+            raise ToolError(f"Could not extract commit hash from URL: {tool_input.upstream_fix_url}")
 
         except ToolError:
             raise