quickcall-integrations 0.2.0__py3-none-any.whl → 0.3.1__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."""
 
@@ -298,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.
 
@@ -307,9 +331,11 @@ 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 = []
@@ -319,7 +345,10 @@ class GitHubClient:
             for i, pr in enumerate(pulls):
                 if i >= limit:
                     break
-                prs.append(self._convert_pr(pr))
+                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
@@ -353,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,
@@ -376,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
     # ========================================================================
@@ -388,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.
 
@@ -399,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)
 
@@ -427,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
 
@@ -533,6 +589,7 @@ class GitHubClient:
         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.
@@ -545,10 +602,11 @@ class GitHubClient:
             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 with: number, title, body, merged_at,
-            labels, repo, owner, html_url
+            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"]
@@ -596,19 +654,35 @@ class GitHubClient:
                 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"),
-                    }
-                )
+                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
 
@@ -618,3 +692,60 @@ class GitHubClient:
         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/tools/github_tools.py

@@ -11,7 +11,7 @@ PAT fallback is useful for:
 - Testing and development
 """
 
-from typing import Optional, Tuple
+from typing import List, Optional, Tuple
 import logging
 
 from fastmcp import FastMCP
@@ -154,19 +154,34 @@ def create_github_tools(mcp: FastMCP) -> None:
             default=20,
             description="Maximum number of PRs to return (default: 20)",
         ),
+        detail_level: str = Field(
+            default="summary",
+            description="'summary' for minimal fields (~200 bytes/PR: number, title, state, author, merged_at, html_url), "
+            "'full' for all fields (~2KB/PR). Use 'summary' for large result sets, 'full' for detailed analysis.",
+        ),
     ) -> dict:
         """
         List pull requests for a GitHub repository.
 
         Returns PRs sorted by last updated.
         Requires QuickCall authentication with GitHub connected.
+
+        Use detail_level='summary' (default) to avoid context overflow with large result sets.
+        Use get_pr(number) to get full details for specific PRs when needed.
         """
         try:
             client = _get_client()
-            prs = client.list_prs(owner=owner, repo=repo, state=state, limit=limit)
+            prs = client.list_prs(
+                owner=owner,
+                repo=repo,
+                state=state,
+                limit=limit,
+                detail_level=detail_level,
+            )
 
             return {
                 "count": len(prs),
+                "detail_level": detail_level,
                 "prs": [pr.model_dump() for pr in prs],
             }
         except ToolError:
@@ -180,40 +195,60 @@ def create_github_tools(mcp: FastMCP) -> None:
             raise ToolError(f"Failed to list pull requests: {str(e)}")
 
     @mcp.tool(tags={"github", "prs"})
-    def get_pr(
-        pr_number: int = Field(..., description="Pull request number", gt=0),
-        owner: Optional[str] = Field(
-            default=None,
-            description="Repository owner. Uses your GitHub username if not specified.",
-        ),
-        repo: Optional[str] = Field(
-            default=None,
-            description="Repository name. Required.",
+    def get_prs(
+        pr_refs: List[dict] = Field(
+            ...,
+            description="List of PR references. Each item should have 'owner', 'repo', and 'number' keys. "
+            "Example: [{'owner': 'org', 'repo': 'myrepo', 'number': 123}, ...]",
         ),
     ) -> dict:
         """
-        Get detailed information about a specific pull request.
+        Get detailed information about one or more pull requests.
+
+        Works for single or multiple PRs - fetches in parallel when multiple.
+        Each PR ref needs owner, repo, and number.
 
-        Includes title, description, status, files changed, and review status.
+        Returns full PR details including additions, deletions, and files changed.
         Requires QuickCall authentication with GitHub connected.
         """
         try:
             client = _get_client()
-            pr = client.get_pr(pr_number, owner=owner, repo=repo)
 
-            if not pr:
-                raise ToolError(f"Pull request #{pr_number} not found")
+            # Validate input
+            validated_refs = []
+            for ref in pr_refs:
+                if not isinstance(ref, dict):
+                    raise ToolError(f"Invalid PR ref (must be dict): {ref}")
+                if "number" not in ref:
+                    raise ToolError(f"Missing 'number' in PR ref: {ref}")
+                if "owner" not in ref or "repo" not in ref:
+                    raise ToolError(
+                        f"Missing 'owner' or 'repo' in PR ref: {ref}. "
+                        "Each ref must have owner, repo, and number."
+                    )
+                validated_refs.append(
+                    {
+                        "owner": ref["owner"],
+                        "repo": ref["repo"],
+                        "number": int(ref["number"]),
+                    }
+                )
+
+            if not validated_refs:
+                return {"count": 0, "prs": []}
 
-            return {"pr": pr.model_dump()}
+            # Fetch all PRs in parallel
+            prs = client.fetch_prs_parallel(validated_refs, max_workers=10)
+
+            return {
+                "count": len(prs),
+                "requested": len(validated_refs),
+                "prs": prs,
+            }
         except ToolError:
             raise
-        except ValueError as e:
-            raise ToolError(
-                f"Repository not specified: {str(e)}. "
-                f"Please provide both owner and repo parameters."
-            )
         except Exception as e:
-            raise ToolError(f"Failed to get pull request #{pr_number}: {str(e)}")
+            raise ToolError(f"Failed to fetch PRs: {str(e)}")
 
     @mcp.tool(tags={"github", "commits"})
     def list_commits(
@@ -241,12 +276,20 @@ def create_github_tools(mcp: FastMCP) -> None:
             default=20,
             description="Maximum number of commits to return (default: 20)",
         ),
+        detail_level: str = Field(
+            default="summary",
+            description="'summary' for minimal fields (short sha, message title, author, date, url), "
+            "'full' for all fields including full commit message. Use 'summary' for large result sets.",
+        ),
     ) -> dict:
         """
         List commits for a GitHub repository.
 
         Returns commits sorted by date (newest first).
         Requires QuickCall authentication with GitHub connected.
+
+        Use detail_level='summary' (default) to avoid context overflow with large result sets.
+        Use get_commit(sha) to get full details for specific commits when needed.
         """
         try:
             client = _get_client()
@@ -257,10 +300,12 @@ def create_github_tools(mcp: FastMCP) -> None:
                 author=author,
                 since=since,
                 limit=limit,
+                detail_level=detail_level,
             )
 
             return {
                 "count": len(commits),
+                "detail_level": detail_level,
                 "commits": [commit.model_dump() for commit in commits],
             }
         except ToolError:
@@ -348,7 +393,7 @@ def create_github_tools(mcp: FastMCP) -> None:
         except Exception as e:
             raise ToolError(f"Failed to list branches: {str(e)}")
 
-    @mcp.tool(tags={"github", "prs", "appraisal"})
+    @mcp.tool(tags={"github", "prs"})
     def search_merged_prs(
         author: Optional[str] = Field(
             default=None,
@@ -370,28 +415,20 @@ def create_github_tools(mcp: FastMCP) -> None:
             default=100,
             description="Maximum PRs to return (default: 100)",
         ),
+        detail_level: str = Field(
+            default="summary",
+            description="'summary' for minimal fields (number, title, merged_at, repo, owner, html_url, author), "
+            "'full' adds body and labels. Use 'summary' for large result sets.",
+        ),
     ) -> dict:
         """
         Search for merged pull requests by author within a time period.
 
-        USE FOR APPRAISALS: This tool is ideal for gathering contribution data
-        for performance reviews. Returns basic PR info - use get_pr for full
-        details (additions, deletions, files) on specific PRs.
-
-        Claude should analyze the returned PRs to:
-
-        1. CATEGORIZE by type (look at PR title/labels):
-           - Features: "feat:", "add:", "implement", "new", "create"
-           - Enhancements: "improve:", "update:", "perf:", "optimize", "enhance"
-           - Bug fixes: "fix:", "bugfix:", "hotfix:", "resolve", "patch"
-           - Chores: "chore:", "docs:", "test:", "ci:", "refactor:", "bump"
-
-        2. IDENTIFY top PRs worth highlighting (call get_pr for detailed metrics)
-
-        3. SUMMARIZE for appraisal with accomplishments grouped by category
+        NOTE: For appraisals/performance reviews, use prepare_appraisal_data instead!
+        It fetches all PRs with full stats in parallel and avoids context overflow.
 
-        Returns: number, title, body, merged_at, labels, repo, owner, html_url, author.
-        For full stats (additions, deletions, files), call get_pr on specific PRs.
+        This tool returns basic PR info without stats (additions, deletions).
+        Use detail_level='summary' (default) for large result sets.
 
         Requires QuickCall authentication with GitHub connected.
         """
@@ -399,9 +436,11 @@ def create_github_tools(mcp: FastMCP) -> None:
             client = _get_client()
 
             # Calculate since_date from days
-            from datetime import datetime, timedelta
+            from datetime import datetime, timedelta, timezone
 
-            since_date = (datetime.utcnow() - timedelta(days=days)).strftime("%Y-%m-%d")
+            since_date = (datetime.now(timezone.utc) - timedelta(days=days)).strftime(
+                "%Y-%m-%d"
+            )
 
             # Use authenticated user if author not specified
             if not author:
@@ -415,10 +454,12 @@ def create_github_tools(mcp: FastMCP) -> None:
                 org=org,
                 repo=repo,
                 limit=limit,
+                detail_level=detail_level,
             )
 
             return {
                 "count": len(prs),
+                "detail_level": detail_level,
                 "period": f"Last {days} days",
                 "author": author,
                 "org": org,
@@ -430,6 +471,178 @@ def create_github_tools(mcp: FastMCP) -> None:
         except Exception as e:
             raise ToolError(f"Failed to search merged PRs: {str(e)}")
 
+    @mcp.tool(tags={"github", "prs", "appraisal"})
+    def prepare_appraisal_data(
+        author: Optional[str] = Field(
+            default=None,
+            description="GitHub username. Defaults to authenticated user.",
+        ),
+        days: int = Field(
+            default=180,
+            description="Number of days to look back (default: 180 for ~6 months)",
+        ),
+        org: Optional[str] = Field(
+            default=None,
+            description="GitHub org to search within.",
+        ),
+        repo: Optional[str] = Field(
+            default=None,
+            description="Specific repo in 'owner/repo' format.",
+        ),
+    ) -> dict:
+        """
+        Prepare appraisal data by fetching ALL merged PRs with full details.
+
+        USE THIS TOOL FOR APPRAISALS AND PERFORMANCE REVIEWS!
+
+        This is the recommended tool for gathering contribution data because it:
+        1. Fetches ALL merged PRs with full stats (additions, deletions) in PARALLEL
+        2. Dumps everything to a local file (avoids context overflow)
+        3. Returns just PR titles for you to review
+        4. Then use get_appraisal_pr_details(file_path, pr_numbers) for selected PRs
+
+        DO NOT use search_merged_prs for appraisals - it doesn't include stats
+        and causes context overflow with large result sets.
+        """
+        import json
+        import tempfile
+        from datetime import datetime, timedelta, timezone
+
+        try:
+            client = _get_client()
+
+            since_date = (datetime.now(timezone.utc) - timedelta(days=days)).strftime(
+                "%Y-%m-%d"
+            )
+
+            # Use authenticated user if author not specified
+            if not author:
+                creds = get_credential_store().get_api_credentials()
+                if creds and creds.github_username:
+                    author = creds.github_username
+
+            # Step 1: Get list of merged PRs
+            pr_list = client.search_merged_prs(
+                author=author,
+                since_date=since_date,
+                org=org,
+                repo=repo,
+                limit=100,
+                detail_level="full",  # Get body/labels from search
+            )
+
+            if not pr_list:
+                return {
+                    "count": 0,
+                    "message": "No merged PRs found for the specified criteria",
+                    "author": author,
+                    "period": f"Last {days} days",
+                }
+
+            # Step 2: Prepare refs for parallel fetch
+            pr_refs = [
+                {"owner": pr["owner"], "repo": pr["repo"], "number": pr["number"]}
+                for pr in pr_list
+            ]
+
+            # Step 3: Fetch full details in parallel
+            full_prs = client.fetch_prs_parallel(pr_refs, max_workers=10)
+
+            # Step 4: Merge search data with full PR data
+            # (search has body/labels, full PR has additions/deletions/files)
+            pr_lookup = {(pr["owner"], pr["repo"], pr["number"]): pr for pr in pr_list}
+            for pr in full_prs:
+                key = (pr["owner"], pr["repo"], pr["number"])
+                if key in pr_lookup:
+                    # Add labels from search (not in PyGithub response for some reason)
+                    search_pr = pr_lookup[key]
+                    if "labels" in search_pr:
+                        pr["labels"] = search_pr["labels"]
+
+            # Step 5: Dump to file
+            dump_data = {
+                "author": author,
+                "period": f"Last {days} days",
+                "org": org,
+                "repo": repo,
+                "fetched_at": datetime.now(timezone.utc).isoformat(),
+                "count": len(full_prs),
+                "prs": full_prs,
+            }
+
+            # Create temp file that persists
+            fd, file_path = tempfile.mkstemp(suffix=".json", prefix="appraisal_")
+            with open(file_path, "w") as f:
+                json.dump(dump_data, f, indent=2, default=str)
+
+            # Step 6: Return file path + just titles for Claude to scan
+            pr_titles = [
+                {
+                    "number": pr["number"],
+                    "title": pr["title"],
+                    "repo": f"{pr['owner']}/{pr['repo']}",
+                }
+                for pr in full_prs
+            ]
+
+            return {
+                "file_path": file_path,
+                "count": len(full_prs),
+                "author": author,
+                "period": f"Last {days} days",
+                "pr_titles": pr_titles,
+                "next_step": "Review titles above, then call "
+                "get_appraisal_pr_details(file_path, pr_numbers) for full details on selected PRs.",
+            }
+
+        except ToolError:
+            raise
+        except Exception as e:
+            raise ToolError(f"Failed to prepare appraisal data: {str(e)}")
+
+    @mcp.tool(tags={"github", "prs", "appraisal"})
+    def get_appraisal_pr_details(
+        file_path: str = Field(
+            ...,
+            description="Path to the appraisal data file from prepare_appraisal_data",
+        ),
+        pr_numbers: List[int] = Field(
+            ..., description="List of PR numbers to get full details for"
+        ),
+    ) -> dict:
+        """
+        Get full PR details from the appraisal data dump.
+
+        This reads from the local file created by prepare_appraisal_data.
+        NO API CALLS are made - all data comes from the cached dump.
+
+        Use this after prepare_appraisal_data to get full details for specific PRs
+        that Claude has identified as important for the appraisal.
+        """
+        import json
+
+        try:
+            with open(file_path) as f:
+                data = json.load(f)
+
+            pr_numbers_set = set(pr_numbers)
+            selected_prs = [
+                pr for pr in data.get("prs", []) if pr["number"] in pr_numbers_set
+            ]
+
+            return {
+                "count": len(selected_prs),
+                "requested": len(pr_numbers),
+                "prs": selected_prs,
+            }
+
+        except FileNotFoundError:
+            raise ToolError(f"Appraisal data file not found: {file_path}")
+        except json.JSONDecodeError:
+            raise ToolError(f"Invalid JSON in appraisal data file: {file_path}")
+        except Exception as e:
+            raise ToolError(f"Failed to read appraisal data: {str(e)}")
+
     @mcp.tool(tags={"github", "status"})
     def check_github_connection() -> dict:
         """

{quickcall_integrations-0.2.0.dist-info → quickcall_integrations-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quickcall-integrations
-Version: 0.2.0
+Version: 0.3.1
 Summary: MCP server with developer integrations for Claude Code and Cursor
 Requires-Python: >=3.10
 Requires-Dist: fastmcp>=2.13.0

{quickcall_integrations-0.2.0.dist-info → quickcall_integrations-0.3.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 mcp_server/__init__.py,sha256=UJBr5BLG_aU2S4s2fEbRBZYd7GUWDVejxBpqezNBo8Q,98
 mcp_server/server.py,sha256=zGrrYwp7H24pJAAGAVkHDk7Y6IydOR_wo5hIL-e6_50,3001
 mcp_server/api_clients/__init__.py,sha256=kOG5_sxIVpAx_tvf1nq_P0QCkqojAVidRE-wenLS-Wc,207
-mcp_server/api_clients/github_client.py,sha256=Ddnekr2Jz4_dOpf1lmgdhBHB2Kr5WjC67-W_j2AZkK0,20772
+mcp_server/api_clients/github_client.py,sha256=shaBgAtTXUM-LZ7e5obuIRWylkOqBrim3_DapIN4rYI,25861
 mcp_server/api_clients/slack_client.py,sha256=w3rcGghttfYw8Ird2beNo2LEYLc3rCTbUKMH4X7QQuQ,16447
 mcp_server/auth/__init__.py,sha256=D-JS0Qe7FkeJjYx92u_AqPx8ZRoB3dKMowzzJXlX6cc,780
 mcp_server/auth/credentials.py,sha256=1e1FpiaPPVc5hVdLlvIU2JbhbdHbXH9pzYBDPsUr0hI,20003
@@ -11,10 +11,10 @@ mcp_server/resources/slack_resources.py,sha256=b_CPxAicwkF3PsBXIat4QoLbDUHM2g_iP
 mcp_server/tools/__init__.py,sha256=vIR2ujAaTXm2DgpTsVNz3brI4G34p-Jeg44Qe0uvWc0,405
 mcp_server/tools/auth_tools.py,sha256=kCPjPC1jrVz0XaRAwPea-ue8ybjLLTxyILplBDJ9Mv4,24477
 mcp_server/tools/git_tools.py,sha256=jyCTQR2eSzUFXMt0Y8x66758-VY8YCY14DDUJt7GY2U,13957
-mcp_server/tools/github_tools.py,sha256=r5HgYQIxdV8KQO5G5lAR3z3XK9moyrQgA84IH0hJKI4,17727
+mcp_server/tools/github_tools.py,sha256=Dcwhok30dpEePlm77--ynnQmkEmQkG_X625076n3F3A,25900
 mcp_server/tools/slack_tools.py,sha256=-HVE_x3Z1KMeYGi1xhyppEwz5ZF-I-ZD0-Up8yBeoYE,11796
 mcp_server/tools/utility_tools.py,sha256=1WiOpJivu6Ug9OLajm77lzsmFfBPgWHs8e1hNCEX_Aw,3359
-quickcall_integrations-0.2.0.dist-info/METADATA,sha256=y_LgEAseZRBLdxQGRiIl9kjlfDe6rtSY5SmEtnV6VCU,7043
-quickcall_integrations-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-quickcall_integrations-0.2.0.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
-quickcall_integrations-0.2.0.dist-info/RECORD,,
+quickcall_integrations-0.3.1.dist-info/METADATA,sha256=_HB-u8R1Wr9qk4sAB9YefLDElDUKYEvavYrNO1V4YY0,7043
+quickcall_integrations-0.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quickcall_integrations-0.3.1.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
+quickcall_integrations-0.3.1.dist-info/RECORD,,