quickcall-integrations 0.1.8__py3-none-any.whl → 0.3.0__py3-none-any.whl

mcp_server/api_clients/github_client.py

@@ -6,6 +6,7 @@ Focuses on PRs and commits for minimal implementation.
 """
 
 import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import List, Optional, Dict, Any
 from datetime import datetime
 
@@ -22,7 +23,7 @@ logger = logging.getLogger(__name__)
 
 
 class Commit(BaseModel):
-    """Represents a GitHub commit."""
+    """Represents a GitHub commit (full details)."""
 
     sha: str
     message: str
@@ -31,8 +32,18 @@ class Commit(BaseModel):
     html_url: str
 
 
+class CommitSummary(BaseModel):
+    """Represents a GitHub commit (summary - minimal fields for list operations)."""
+
+    sha: str
+    message_title: str  # First line only
+    author: str
+    date: datetime
+    html_url: str
+
+
 class PullRequest(BaseModel):
-    """Represents a GitHub pull request."""
+    """Represents a GitHub pull request (full details)."""
 
     number: int
     title: str
@@ -55,6 +66,18 @@ class PullRequest(BaseModel):
     reviewers: List[str] = []
 
 
+class PullRequestSummary(BaseModel):
+    """Represents a GitHub pull request (summary - minimal fields for list operations)."""
+
+    number: int
+    title: str
+    state: str
+    author: str
+    created_at: datetime
+    merged_at: Optional[datetime] = None
+    html_url: str
+
+
 class Repository(BaseModel):
     """Represents a GitHub repository."""
 
@@ -78,6 +101,10 @@ class GitHubClient:
 
     Provides simplified interface for GitHub operations.
     Focuses on PRs and commits.
+
+    Supports both:
+    - GitHub App installation tokens (via QuickCall)
+    - Personal Access Tokens (PAT fallback)
     """
 
     def __init__(
@@ -91,16 +118,19 @@ class GitHubClient:
         Initialize GitHub API client.
 
         Args:
-            token: GitHub installation access token
+            token: GitHub access token (installation token or PAT)
             default_owner: Default repository owner (optional)
             default_repo: Default repository name (optional)
-            installation_id: GitHub App installation ID (for listing repos)
+            installation_id: GitHub App installation ID (None for PAT mode)
         """
         self.token = token
         self.default_owner = default_owner
         self.default_repo = default_repo
         self.installation_id = installation_id
 
+        # Detect if this is a PAT (no installation_id means PAT mode)
+        self._is_pat_mode = installation_id is None
+
         # Initialize PyGithub client
         auth = Auth.Token(token)
         self.gh = Github(auth=auth)
@@ -108,6 +138,11 @@ class GitHubClient:
         # Cache for repo objects
         self._repo_cache: Dict[str, Any] = {}
 
+    @property
+    def is_pat_mode(self) -> bool:
+        """Check if client is using PAT authentication."""
+        return self._is_pat_mode
+
     def _get_repo(self, owner: Optional[str] = None, repo: Optional[str] = None):
         """Get PyGithub repo object, using defaults if not specified."""
         owner = owner or self.default_owner
@@ -127,36 +162,50 @@ class GitHubClient:
     def health_check(self) -> bool:
         """Check if GitHub API is accessible with the token."""
         try:
-            # Use installation/repositories endpoint - works with GitHub App tokens
-            with httpx.Client() as client:
-                response = client.get(
-                    "https://api.github.com/installation/repositories",
-                    headers={
-                        "Authorization": f"Bearer {self.token}",
-                        "Accept": "application/vnd.github+json",
-                        "X-GitHub-Api-Version": "2022-11-28",
-                    },
-                    params={"per_page": 1},
-                )
-                return response.status_code == 200
+            if self._is_pat_mode:
+                # For PAT, use /user endpoint
+                user = self.gh.get_user()
+                _ = user.login  # This will trigger the API call
+                return True
+            else:
+                # For installation tokens, use /installation/repositories endpoint
+                with httpx.Client() as client:
+                    response = client.get(
+                        "https://api.github.com/installation/repositories",
+                        headers={
+                            "Authorization": f"Bearer {self.token}",
+                            "Accept": "application/vnd.github+json",
+                            "X-GitHub-Api-Version": "2022-11-28",
+                        },
+                        params={"per_page": 1},
+                    )
+                    return response.status_code == 200
         except Exception:
             return False
 
     def get_authenticated_user(self) -> str:
         """
-        Get the GitHub username associated with this installation.
+        Get the GitHub username for the authenticated user/installation.
 
-        Note: GitHub App installation tokens can't access /user endpoint.
-        We return the installation owner instead.
+        For PAT: Returns the user's login
+        For GitHub App: Returns the installation owner
         """
-        # Try to get from first repo's owner
-        try:
-            repos = self.list_repos(limit=1)
-            if repos:
-                return repos[0].owner.login
-        except Exception:
-            pass
-        return "GitHub App"  # Fallback
+        if self._is_pat_mode:
+            try:
+                user = self.gh.get_user()
+                return user.login
+            except Exception:
+                return self.default_owner or "unknown"
+        else:
+            # GitHub App installation tokens can't access /user endpoint
+            # Try to get from first repo's owner
+            try:
+                repos = self.list_repos(limit=1)
+                if repos:
+                    return repos[0].owner
+            except Exception:
+                pass
+            return self.default_owner or "GitHub App"
 
     def close(self):
         """Close GitHub API client."""
@@ -168,7 +217,10 @@ class GitHubClient:
 
     def list_repos(self, limit: int = 20) -> List[Repository]:
         """
-        List repositories accessible to the GitHub App installation.
+        List repositories accessible to the authenticated user/installation.
+
+        For PAT mode: Lists user's repositories
+        For GitHub App: Lists installation repositories
 
         Args:
             limit: Maximum repositories to return
@@ -177,43 +229,70 @@ class GitHubClient:
             List of repositories
         """
         repos = []
-        try:
-            # Installation tokens can't use PyGithub's user.get_repos() endpoint
-            # Must use /installation/repositories endpoint directly (same as backend)
-            # https://docs.github.com/en/rest/apps/installations#list-repositories-accessible-to-the-app-installation
-            with httpx.Client() as client:
-                response = client.get(
-                    "https://api.github.com/installation/repositories",
-                    headers={
-                        "Authorization": f"Bearer {self.token}",
-                        "Accept": "application/vnd.github+json",
-                        "X-GitHub-Api-Version": "2022-11-28",
-                    },
-                    params={"per_page": limit},
-                )
-                response.raise_for_status()
-                data = response.json()
 
-                for repo_data in data.get("repositories", [])[:limit]:
+        if self._is_pat_mode:
+            # PAT mode: Use PyGithub's user.get_repos()
+            try:
+                user = self.gh.get_user()
+                for i, gh_repo in enumerate(user.get_repos(sort="updated")):
+                    if i >= limit:
+                        break
                     repos.append(
                         Repository(
-                            name=repo_data["name"],
-                            owner=repo_data["owner"]["login"],
-                            full_name=repo_data["full_name"],
-                            html_url=repo_data["html_url"],
-                            description=repo_data.get("description") or "",
-                            default_branch=repo_data.get("default_branch", "main"),
-                            private=repo_data.get("private", False),
+                            name=gh_repo.name,
+                            owner=gh_repo.owner.login,
+                            full_name=gh_repo.full_name,
+                            html_url=gh_repo.html_url,
+                            description=gh_repo.description or "",
+                            default_branch=gh_repo.default_branch,
+                            private=gh_repo.private,
                         )
                     )
-        except httpx.HTTPStatusError as e:
-            logger.error(
-                f"Failed to list installation repos: HTTP {e.response.status_code}"
-            )
-            raise GithubException(e.response.status_code, e.response.json())
-        except Exception as e:
-            logger.error(f"Failed to list installation repos: {e}")
-            raise
+            except GithubException as e:
+                logger.error(f"Failed to list user repos: {e}")
+                raise
+            except Exception as e:
+                logger.error(f"Failed to list user repos: {e}")
+                raise
+        else:
+            # GitHub App mode: Use /installation/repositories endpoint
+            try:
+                # Installation tokens can't use PyGithub's user.get_repos() endpoint
+                # Must use /installation/repositories endpoint directly (same as backend)
+                # https://docs.github.com/en/rest/apps/installations#list-repositories-accessible-to-the-app-installation
+                with httpx.Client() as client:
+                    response = client.get(
+                        "https://api.github.com/installation/repositories",
+                        headers={
+                            "Authorization": f"Bearer {self.token}",
+                            "Accept": "application/vnd.github+json",
+                            "X-GitHub-Api-Version": "2022-11-28",
+                        },
+                        params={"per_page": limit},
+                    )
+                    response.raise_for_status()
+                    data = response.json()
+
+                    for repo_data in data.get("repositories", [])[:limit]:
+                        repos.append(
+                            Repository(
+                                name=repo_data["name"],
+                                owner=repo_data["owner"]["login"],
+                                full_name=repo_data["full_name"],
+                                html_url=repo_data["html_url"],
+                                description=repo_data.get("description") or "",
+                                default_branch=repo_data.get("default_branch", "main"),
+                                private=repo_data.get("private", False),
+                            )
+                        )
+            except httpx.HTTPStatusError as e:
+                logger.error(
+                    f"Failed to list installation repos: HTTP {e.response.status_code}"
+                )
+                raise GithubException(e.response.status_code, e.response.json())
+            except Exception as e:
+                logger.error(f"Failed to list installation repos: {e}")
+                raise
 
         return repos
 
@@ -242,7 +321,8 @@ class GitHubClient:
         repo: Optional[str] = None,
         state: str = "open",
         limit: int = 20,
-    ) -> List[PullRequest]:
+        detail_level: str = "summary",
+    ) -> List[PullRequest] | List[PullRequestSummary]:
         """
         List pull requests.
 
@@ -251,17 +331,27 @@ class GitHubClient:
             repo: Repository name
             state: PR state: 'open', 'closed', or 'all'
             limit: Maximum PRs to return
+            detail_level: 'summary' for minimal fields (~200 bytes/PR),
+                         'full' for all fields (~2KB/PR)
 
         Returns:
-            List of pull requests
+            List of pull requests (summary or full based on detail_level)
         """
         gh_repo = self._get_repo(owner, repo)
         prs = []
 
-        for pr in gh_repo.get_pulls(state=state, sort="updated", direction="desc")[
-            :limit
-        ]:
-            prs.append(self._convert_pr(pr))
+        try:
+            pulls = gh_repo.get_pulls(state=state, sort="updated", direction="desc")
+            for i, pr in enumerate(pulls):
+                if i >= limit:
+                    break
+                if detail_level == "full":
+                    prs.append(self._convert_pr(pr))
+                else:
+                    prs.append(self._convert_pr_summary(pr))
+        except IndexError:
+            # Empty repo or no PRs - return empty list
+            pass
 
         return prs
 
@@ -292,7 +382,7 @@ class GitHubClient:
             raise
 
     def _convert_pr(self, pr) -> PullRequest:
-        """Convert PyGithub PullRequest to Pydantic model."""
+        """Convert PyGithub PullRequest to Pydantic model (full details)."""
         return PullRequest(
             number=pr.number,
             title=pr.title,
@@ -315,6 +405,18 @@ class GitHubClient:
             reviewers=[r.login for r in pr.requested_reviewers],
         )
 
+    def _convert_pr_summary(self, pr) -> PullRequestSummary:
+        """Convert PyGithub PullRequest to summary model (minimal fields)."""
+        return PullRequestSummary(
+            number=pr.number,
+            title=pr.title,
+            state=pr.state,
+            author=pr.user.login if pr.user else "unknown",
+            created_at=pr.created_at,
+            merged_at=pr.merged_at,
+            html_url=pr.html_url,
+        )
+
     # ========================================================================
     # Commit Operations
     # ========================================================================
@@ -327,7 +429,8 @@ class GitHubClient:
         author: Optional[str] = None,
         since: Optional[str] = None,
         limit: int = 20,
-    ) -> List[Commit]:
+        detail_level: str = "summary",
+    ) -> List[Commit] | List[CommitSummary]:
         """
         List commits.
 
@@ -338,9 +441,10 @@ class GitHubClient:
             author: Filter by author username
             since: ISO datetime - only commits after this date
             limit: Maximum commits to return
+            detail_level: 'summary' for minimal fields, 'full' for all fields
 
         Returns:
-            List of commits
+            List of commits (summary or full based on detail_level)
         """
         gh_repo = self._get_repo(owner, repo)
 
@@ -366,15 +470,28 @@ class GitHubClient:
             if author and author.lower() != commit_author.lower():
                 continue
 
-            commits.append(
-                Commit(
-                    sha=commit.sha,
-                    message=commit.commit.message,
-                    author=commit_author,
-                    date=commit.commit.author.date,
-                    html_url=commit.html_url,
+            if detail_level == "full":
+                commits.append(
+                    Commit(
+                        sha=commit.sha,
+                        message=commit.commit.message,
+                        author=commit_author,
+                        date=commit.commit.author.date,
+                        html_url=commit.html_url,
+                    )
+                )
+            else:
+                # Summary: just first line of message
+                message_title = commit.commit.message.split("\n")[0][:100]
+                commits.append(
+                    CommitSummary(
+                        sha=commit.sha[:7],  # Short SHA for summary
+                        message_title=message_title,
+                        author=commit_author,
+                        date=commit.commit.author.date,
+                        html_url=commit.html_url,
+                    )
                 )
-            )
 
         return commits
 
@@ -460,3 +577,175 @@ class GitHubClient:
             )
 
         return branches
+
+    # ========================================================================
+    # Search Operations (for Appraisals)
+    # ========================================================================
+
+    def search_merged_prs(
+        self,
+        author: Optional[str] = None,
+        since_date: Optional[str] = None,
+        org: Optional[str] = None,
+        repo: Optional[str] = None,
+        limit: int = 100,
+        detail_level: str = "summary",
+    ) -> List[Dict[str, Any]]:
+        """
+        Search for merged pull requests using GitHub Search API.
+
+        Ideal for gathering contribution data for appraisals/reviews.
+
+        Args:
+            author: GitHub username to filter by
+            since_date: ISO date string (YYYY-MM-DD) - only PRs merged after this date
+            org: GitHub org to search within
+            repo: Specific repo in "owner/repo" format (overrides org if specified)
+            limit: Maximum PRs to return (max 100 per page)
+            detail_level: 'summary' for minimal fields, 'full' for all fields
+
+        Returns:
+            List of merged PR dicts. Summary includes: number, title, merged_at,
+            repo, owner, html_url, author. Full adds: body, labels.
+        """
+        # Build search query
+        query_parts = ["is:pr", "is:merged"]
+
+        if author:
+            query_parts.append(f"author:{author}")
+
+        if since_date:
+            query_parts.append(f"merged:>={since_date}")
+
+        # repo takes precedence over org
+        if repo:
+            query_parts.append(f"repo:{repo}")
+        elif org:
+            query_parts.append(f"org:{org}")
+
+        query = " ".join(query_parts)
+
+        try:
+            with httpx.Client() as client:
+                response = client.get(
+                    "https://api.github.com/search/issues",
+                    headers={
+                        "Authorization": f"Bearer {self.token}",
+                        "Accept": "application/vnd.github+json",
+                        "X-GitHub-Api-Version": "2022-11-28",
+                    },
+                    params={
+                        "q": query,
+                        "sort": "updated",
+                        "order": "desc",
+                        "per_page": min(limit, 100),
+                    },
+                    timeout=30.0,
+                )
+                response.raise_for_status()
+                data = response.json()
+
+            # Convert to simplified format
+            prs = []
+            for item in data.get("items", [])[:limit]:
+                # Extract repo info from repository_url
+                # Format: https://api.github.com/repos/owner/repo
+                repo_url_parts = item.get("repository_url", "").split("/")
+                repo_owner = repo_url_parts[-2] if len(repo_url_parts) >= 2 else ""
+                repo_name = repo_url_parts[-1] if len(repo_url_parts) >= 1 else ""
+
+                if detail_level == "full":
+                    prs.append(
+                        {
+                            "number": item["number"],
+                            "title": item["title"],
+                            "body": item.get("body") or "",
+                            "merged_at": item.get("pull_request", {}).get("merged_at"),
+                            "html_url": item["html_url"],
+                            "labels": [
+                                label["name"] for label in item.get("labels", [])
+                            ],
+                            "repo": repo_name,
+                            "owner": repo_owner,
+                            "author": item.get("user", {}).get("login", "unknown"),
+                        }
+                    )
+                else:
+                    # Summary: skip body and labels
+                    prs.append(
+                        {
+                            "number": item["number"],
+                            "title": item["title"],
+                            "merged_at": item.get("pull_request", {}).get("merged_at"),
+                            "html_url": item["html_url"],
+                            "repo": repo_name,
+                            "owner": repo_owner,
+                            "author": item.get("user", {}).get("login", "unknown"),
+                        }
+                    )
+
+            return prs
+
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Failed to search PRs: HTTP {e.response.status_code}")
+            raise GithubException(e.response.status_code, e.response.json())
+        except Exception as e:
+            logger.error(f"Failed to search PRs: {e}")
+            raise
+
+    def fetch_prs_parallel(
+        self,
+        pr_refs: List[Dict[str, Any]],
+        max_workers: int = 10,
+    ) -> List[Dict[str, Any]]:
+        """
+        Fetch full PR details for multiple PRs in parallel.
+
+        Args:
+            pr_refs: List of dicts with 'owner', 'repo', 'number' keys
+            max_workers: Max concurrent requests (default: 10)
+
+        Returns:
+            List of full PR details with stats (additions, deletions, files)
+        """
+        results = []
+        errors = []
+
+        def fetch_single_pr(pr_ref: Dict[str, Any]) -> Dict[str, Any] | None:
+            try:
+                owner = pr_ref["owner"]
+                repo = pr_ref["repo"]
+                number = pr_ref["number"]
+                pr = self.get_pr(number, owner=owner, repo=repo)
+                if pr:
+                    pr_dict = pr.model_dump()
+                    # Add owner/repo for context
+                    pr_dict["owner"] = owner
+                    pr_dict["repo"] = repo
+                    return pr_dict
+                return None
+            except Exception as e:
+                logger.warning(f"Failed to fetch PR {pr_ref}: {e}")
+                return None
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = {
+                executor.submit(fetch_single_pr, pr_ref): pr_ref for pr_ref in pr_refs
+            }
+
+            for future in as_completed(futures):
+                pr_ref = futures[future]
+                try:
+                    result = future.result()
+                    if result:
+                        results.append(result)
+                    else:
+                        errors.append(pr_ref)
+                except Exception as e:
+                    logger.error(f"Error fetching {pr_ref}: {e}")
+                    errors.append(pr_ref)
+
+        if errors:
+            logger.warning(f"Failed to fetch {len(errors)} PRs: {errors[:5]}...")
+
+        return results

mcp_server/auth/__init__.py

@@ -3,22 +3,30 @@ QuickCall Authentication Module
 
 Handles OAuth device flow authentication for CLI/MCP clients.
 Stores credentials locally and fetches fresh tokens from quickcall.dev API.
+
+Also supports GitHub PAT fallback for users without GitHub App access.
 """
 
 from mcp_server.auth.credentials import (
     CredentialStore,
+    GitHubPATCredentials,
     get_credential_store,
     is_authenticated,
     get_credentials,
     clear_credentials,
+    get_github_pat,
+    get_github_pat_username,
 )
 from mcp_server.auth.device_flow import DeviceFlowAuth
 
 __all__ = [
     "CredentialStore",
+    "GitHubPATCredentials",
     "get_credential_store",
     "is_authenticated",
     "get_credentials",
     "clear_credentials",
+    "get_github_pat",
+    "get_github_pat_username",
     "DeviceFlowAuth",
 ]