quickcall-integrations 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

mcp_server/__init__.py

@@ -3,4 +3,4 @@ MCP Server for QuickCall
 GitHub integration tools for AI assistant
 """
 
-__version__ = "0.1.7"
+__version__ = "0.1.8"

mcp_server/api_clients/github_client.py

@@ -78,6 +78,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 +95,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 +115,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 +139,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 +194,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 +206,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
 
@@ -258,10 +314,15 @@ class GitHubClient:
         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
+                prs.append(self._convert_pr(pr))
+        except IndexError:
+            # Empty repo or no PRs - return empty list
+            pass
 
         return prs
 
@@ -460,3 +521,100 @@ 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,
+    ) -> 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)
+
+        Returns:
+            List of merged PR dicts with: number, title, body, merged_at,
+            labels, repo, owner, html_url
+        """
+        # 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 ""
+
+                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"),
+                    }
+                )
+
+            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

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",
 ]