quickcall-integrations 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

mcp_server/api_clients/github_client.py

@@ -417,6 +417,549 @@ class GitHubClient:
             html_url=pr.html_url,
         )
 
+    def create_pr(
+        self,
+        title: str,
+        head: str,
+        base: str,
+        body: Optional[str] = None,
+        draft: bool = False,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> PullRequest:
+        """
+        Create a new pull request.
+
+        Args:
+            title: PR title
+            head: Branch containing changes (e.g., "feature-branch")
+            base: Branch to merge into (e.g., "main")
+            body: PR description
+            draft: Create as draft PR
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Created PullRequest
+        """
+        gh_repo = self._get_repo(owner, repo)
+        pr = gh_repo.create_pull(
+            title=title,
+            head=head,
+            base=base,
+            body=body or "",
+            draft=draft,
+        )
+        return self._convert_pr(pr)
+
+    def update_pr(
+        self,
+        pr_number: int,
+        title: Optional[str] = None,
+        body: Optional[str] = None,
+        state: Optional[str] = None,
+        base: Optional[str] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> PullRequest:
+        """
+        Update an existing pull request.
+
+        Args:
+            pr_number: PR number
+            title: New title
+            body: New description
+            state: New state ('open' or 'closed')
+            base: New base branch
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Updated PullRequest
+        """
+        gh_repo = self._get_repo(owner, repo)
+        pr = gh_repo.get_pull(pr_number)
+
+        kwargs = {}
+        if title is not None:
+            kwargs["title"] = title
+        if body is not None:
+            kwargs["body"] = body
+        if state is not None:
+            kwargs["state"] = state
+        if base is not None:
+            kwargs["base"] = base
+
+        if kwargs:
+            pr.edit(**kwargs)
+
+        return self._convert_pr(pr)
+
+    def merge_pr(
+        self,
+        pr_number: int,
+        commit_title: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        merge_method: str = "merge",
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Merge a pull request.
+
+        Args:
+            pr_number: PR number
+            commit_title: Custom commit title (for squash/merge)
+            commit_message: Custom commit message
+            merge_method: 'merge', 'squash', or 'rebase'
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with merge status and SHA
+        """
+        gh_repo = self._get_repo(owner, repo)
+        pr = gh_repo.get_pull(pr_number)
+
+        # Check if PR is mergeable
+        if pr.merged:
+            return {
+                "merged": True,
+                "message": "PR was already merged",
+                "sha": pr.merge_commit_sha,
+            }
+
+        if not pr.mergeable:
+            return {
+                "merged": False,
+                "message": "PR is not mergeable (conflicts or checks failing)",
+                "sha": None,
+            }
+
+        # Merge the PR
+        result = pr.merge(
+            commit_title=commit_title,
+            commit_message=commit_message,
+            merge_method=merge_method,
+        )
+
+        return {
+            "merged": result.merged,
+            "message": result.message,
+            "sha": result.sha,
+        }
+
+    def close_pr(
+        self,
+        pr_number: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> PullRequest:
+        """Close a pull request without merging."""
+        gh_repo = self._get_repo(owner, repo)
+        pr = gh_repo.get_pull(pr_number)
+        pr.edit(state="closed")
+        return self._convert_pr(pr)
+
+    def reopen_pr(
+        self,
+        pr_number: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> PullRequest:
+        """Reopen a closed pull request."""
+        gh_repo = self._get_repo(owner, repo)
+        pr = gh_repo.get_pull(pr_number)
+        pr.edit(state="open")
+        return self._convert_pr(pr)
+
+    def add_pr_comment(
+        self,
+        pr_number: int,
+        body: str,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Add a comment to a pull request.
+
+        Args:
+            pr_number: PR number
+            body: Comment text
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Comment details
+        """
+        gh_repo = self._get_repo(owner, repo)
+        # PRs use the issue comment API
+        issue = gh_repo.get_issue(pr_number)
+        comment = issue.create_comment(body)
+        return {
+            "id": comment.id,
+            "body": comment.body,
+            "html_url": comment.html_url,
+            "created_at": comment.created_at.isoformat(),
+            "pr_number": pr_number,
+        }
+
+    def request_reviewers(
+        self,
+        pr_number: int,
+        reviewers: Optional[List[str]] = None,
+        team_reviewers: Optional[List[str]] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Request reviewers for a pull request.
+
+        Args:
+            pr_number: PR number
+            reviewers: List of GitHub usernames
+            team_reviewers: List of team slugs (org teams)
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with requested reviewers
+        """
+        gh_repo = self._get_repo(owner, repo)
+        pr = gh_repo.get_pull(pr_number)
+
+        # Create review request
+        pr.create_review_request(
+            reviewers=reviewers or [],
+            team_reviewers=team_reviewers or [],
+        )
+
+        # Re-fetch to get updated reviewers
+        pr = gh_repo.get_pull(pr_number)
+        return {
+            "pr_number": pr_number,
+            "requested_reviewers": [r.login for r in pr.requested_reviewers],
+            "requested_teams": [t.slug for t in pr.requested_teams],
+        }
+
+    def submit_pr_review(
+        self,
+        pr_number: int,
+        event: str,
+        body: Optional[str] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Submit a review on a pull request.
+
+        Args:
+            pr_number: PR number
+            event: Review event - 'APPROVE', 'REQUEST_CHANGES', or 'COMMENT'
+            body: Review comment (required for REQUEST_CHANGES)
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Review details
+        """
+        gh_repo = self._get_repo(owner, repo)
+        pr = gh_repo.get_pull(pr_number)
+
+        review = pr.create_review(
+            body=body or "",
+            event=event,
+        )
+
+        return {
+            "id": review.id,
+            "state": review.state,
+            "body": review.body,
+            "html_url": review.html_url,
+            "pr_number": pr_number,
+        }
+
+    def convert_pr_to_draft(
+        self,
+        pr_number: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Convert a PR to draft status using GraphQL API.
+
+        Args:
+            pr_number: PR number
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with success status
+        """
+        owner = owner or self.default_owner
+        repo = repo or self.default_repo
+
+        if not owner or not repo:
+            raise ValueError("Repository owner and name must be specified")
+
+        # Get PR node ID
+        query = """
+        query($owner: String!, $repo: String!, $number: Int!) {
+            repository(owner: $owner, name: $repo) {
+                pullRequest(number: $number) {
+                    id
+                    isDraft
+                }
+            }
+        }
+        """
+        data = self._graphql_request(
+            query, {"owner": owner, "repo": repo, "number": pr_number}
+        )
+        repository = data.get("repository")
+        if not repository:
+            raise GithubException(
+                404, {"message": f"Repository {owner}/{repo} not found"}
+            )
+        pr_data = repository.get("pullRequest")
+        if not pr_data:
+            raise GithubException(404, {"message": f"PR #{pr_number} not found"})
+
+        if pr_data.get("isDraft"):
+            return {
+                "pr_number": pr_number,
+                "is_draft": True,
+                "message": "PR is already a draft",
+            }
+
+        pr_node_id = pr_data["id"]
+
+        # Convert to draft
+        mutation = """
+        mutation($pullRequestId: ID!) {
+            convertPullRequestToDraft(input: {pullRequestId: $pullRequestId}) {
+                pullRequest {
+                    id
+                    isDraft
+                }
+            }
+        }
+        """
+        result = self._graphql_request(mutation, {"pullRequestId": pr_node_id})
+        converted = result.get("convertPullRequestToDraft", {}).get("pullRequest", {})
+
+        return {
+            "pr_number": pr_number,
+            "is_draft": converted.get("isDraft", True),
+            "message": "PR converted to draft",
+        }
+
+    def mark_pr_ready_for_review(
+        self,
+        pr_number: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Mark a draft PR as ready for review using GraphQL API.
+
+        Args:
+            pr_number: PR number
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with success status
+        """
+        owner = owner or self.default_owner
+        repo = repo or self.default_repo
+
+        if not owner or not repo:
+            raise ValueError("Repository owner and name must be specified")
+
+        # Get PR node ID
+        query = """
+        query($owner: String!, $repo: String!, $number: Int!) {
+            repository(owner: $owner, name: $repo) {
+                pullRequest(number: $number) {
+                    id
+                    isDraft
+                }
+            }
+        }
+        """
+        data = self._graphql_request(
+            query, {"owner": owner, "repo": repo, "number": pr_number}
+        )
+        repository = data.get("repository")
+        if not repository:
+            raise GithubException(
+                404, {"message": f"Repository {owner}/{repo} not found"}
+            )
+        pr_data = repository.get("pullRequest")
+        if not pr_data:
+            raise GithubException(404, {"message": f"PR #{pr_number} not found"})
+
+        if not pr_data.get("isDraft"):
+            return {
+                "pr_number": pr_number,
+                "is_draft": False,
+                "message": "PR is already ready for review",
+            }
+
+        pr_node_id = pr_data["id"]
+
+        # Mark ready for review
+        mutation = """
+        mutation($pullRequestId: ID!) {
+            markPullRequestReadyForReview(input: {pullRequestId: $pullRequestId}) {
+                pullRequest {
+                    id
+                    isDraft
+                }
+            }
+        }
+        """
+        result = self._graphql_request(mutation, {"pullRequestId": pr_node_id})
+        converted = result.get("markPullRequestReadyForReview", {}).get(
+            "pullRequest", {}
+        )
+
+        return {
+            "pr_number": pr_number,
+            "is_draft": converted.get("isDraft", False),
+            "message": "PR marked ready for review",
+        }
+
+    def add_pr_labels(
+        self,
+        pr_number: int,
+        labels: List[str],
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Add labels to a pull request.
+
+        Args:
+            pr_number: PR number
+            labels: List of label names
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with updated labels
+        """
+        gh_repo = self._get_repo(owner, repo)
+        # PRs use the issue API for labels
+        issue = gh_repo.get_issue(pr_number)
+        issue.add_to_labels(*labels)
+
+        return {
+            "pr_number": pr_number,
+            "labels": [label.name for label in issue.labels],
+        }
+
+    def remove_pr_labels(
+        self,
+        pr_number: int,
+        labels: List[str],
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Remove labels from a pull request.
+
+        Args:
+            pr_number: PR number
+            labels: List of label names to remove
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with updated labels
+        """
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.get_issue(pr_number)
+
+        for label in labels:
+            try:
+                issue.remove_from_labels(label)
+            except GithubException as e:
+                if e.status != 404:  # Ignore if label not present
+                    raise
+
+        # Re-fetch to get updated labels
+        issue = gh_repo.get_issue(pr_number)
+        return {
+            "pr_number": pr_number,
+            "labels": [label.name for label in issue.labels],
+        }
+
+    def add_pr_assignees(
+        self,
+        pr_number: int,
+        assignees: List[str],
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Add assignees to a pull request.
+
+        Args:
+            pr_number: PR number
+            assignees: List of GitHub usernames
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with updated assignees
+        """
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.get_issue(pr_number)
+        issue.add_to_assignees(*assignees)
+
+        return {
+            "pr_number": pr_number,
+            "assignees": [a.login for a in issue.assignees],
+        }
+
+    def remove_pr_assignees(
+        self,
+        pr_number: int,
+        assignees: List[str],
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Remove assignees from a pull request.
+
+        Args:
+            pr_number: PR number
+            assignees: List of GitHub usernames to remove
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with updated assignees
+        """
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.get_issue(pr_number)
+
+        for assignee in assignees:
+            try:
+                issue.remove_from_assignees(assignee)
+            except GithubException as e:
+                if e.status != 404:  # Ignore if not assigned
+                    raise
+
+        # Re-fetch to get updated assignees
+        issue = gh_repo.get_issue(pr_number)
+        return {
+            "pr_number": pr_number,
+            "assignees": [a.login for a in issue.assignees],
+        }
+
     # ========================================================================
     # Commit Operations
     # ========================================================================
@@ -758,6 +1301,145 @@ class GitHubClient:
             "issue_number": issue_number,
         }
 
+    def list_issue_comments(
+        self,
+        issue_number: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+        limit: int = 10,
+        order: str = "asc",
+    ) -> List[Dict[str, Any]]:
+        """
+        List comments on a GitHub issue.
+
+        Args:
+            issue_number: Issue number
+            owner: Repository owner
+            repo: Repository name
+            limit: Maximum comments to return (default: 10)
+            order: 'asc' for oldest first, 'desc' for newest first (default: 'asc')
+
+        Returns:
+            List of comment dicts with id, body, author, timestamps, url
+        """
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.get_issue(issue_number)
+
+        comments = []
+        all_comments = list(issue.get_comments())
+
+        # Apply order
+        if order == "desc":
+            all_comments = all_comments[::-1]
+
+        # Apply limit
+        for comment in all_comments[:limit]:
+            comments.append(
+                {
+                    "id": comment.id,
+                    "body": comment.body,
+                    "author": comment.user.login if comment.user else "unknown",
+                    "created_at": comment.created_at.isoformat(),
+                    "updated_at": comment.updated_at.isoformat()
+                    if comment.updated_at
+                    else None,
+                    "html_url": comment.html_url,
+                }
+            )
+
+        return comments
+
+    def get_issue_comment(
+        self,
+        comment_id: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get a specific comment by ID.
+
+        Args:
+            comment_id: Comment ID
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Comment dict with id, body, author, timestamps, url
+        """
+        gh_repo = self._get_repo(owner, repo)
+        comment = gh_repo.get_issue_comment(comment_id)
+
+        return {
+            "id": comment.id,
+            "body": comment.body,
+            "author": comment.user.login if comment.user else "unknown",
+            "created_at": comment.created_at.isoformat(),
+            "updated_at": comment.updated_at.isoformat()
+            if comment.updated_at
+            else None,
+            "html_url": comment.html_url,
+        }
+
+    def update_issue_comment(
+        self,
+        comment_id: int,
+        body: str,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update an existing comment.
+
+        Args:
+            comment_id: Comment ID
+            body: New comment body
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Updated comment dict
+        """
+        gh_repo = self._get_repo(owner, repo)
+        comment = gh_repo.get_issue_comment(comment_id)
+        comment.edit(body)
+
+        return {
+            "id": comment.id,
+            "body": comment.body,
+            "author": comment.user.login if comment.user else "unknown",
+            "created_at": comment.created_at.isoformat(),
+            "updated_at": comment.updated_at.isoformat()
+            if comment.updated_at
+            else None,
+            "html_url": comment.html_url,
+        }
+
+    def delete_issue_comment(
+        self,
+        comment_id: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Delete a comment.
+
+        Args:
+            comment_id: Comment ID
+            owner: Repository owner
+            repo: Repository name
+
+        Returns:
+            Dict with deleted comment_id
+        """
+        gh_repo = self._get_repo(owner, repo)
+        comment = gh_repo.get_issue_comment(comment_id)
+        comment.delete()
+
+        return {
+            "deleted": True,
+            "comment_id": comment_id,
+        }
+
     def get_issue(
         self,
         issue_number: int,

mcp_server/tools/github_tools.py

@@ -571,11 +571,12 @@ def create_github_tools(mcp: FastMCP) -> None:
         action: str = Field(
             ...,
             description="Action: 'list', 'view', 'create', 'update', 'close', 'reopen', 'comment', "
+            "'list_comments', 'update_comment', 'delete_comment', "
             "'add_sub_issue', 'remove_sub_issue', 'list_sub_issues'",
         ),
         issue_numbers: Optional[List[int]] = Field(
             default=None,
-            description="Issue number(s). Required for view/update/close/reopen/comment/sub-issue/project ops.",
+            description="Issue number(s). Required for view/update/close/reopen/comment/sub-issue/comment ops.",
         ),
         title: Optional[str] = Field(
             default=None,
@@ -583,7 +584,7 @@ def create_github_tools(mcp: FastMCP) -> None:
         ),
         body: Optional[str] = Field(
             default=None,
-            description="Issue body (for 'create'/'update') or comment text (for 'comment')",
+            description="Issue body (for 'create'/'update') or comment text (for 'comment'/'update_comment')",
         ),
         labels: Optional[List[str]] = Field(
             default=None,
@@ -602,6 +603,18 @@ def create_github_tools(mcp: FastMCP) -> None:
             description="Parent issue number. For 'create': attach new issue as sub-issue. "
             "For 'add_sub_issue'/'remove_sub_issue'/'list_sub_issues': the parent issue.",
         ),
+        comment_id: Optional[int] = Field(
+            default=None,
+            description="Comment ID for 'update_comment' or 'delete_comment' actions.",
+        ),
+        comments_limit: Optional[int] = Field(
+            default=10,
+            description="Max comments to return for 'list_comments' (default: 10).",
+        ),
+        comments_order: Optional[str] = Field(
+            default="asc",
+            description="Comment order for 'list_comments': 'asc' (oldest first) or 'desc' (newest first).",
+        ),
         owner: Optional[str] = Field(
             default=None,
             description="Repository owner",
@@ -644,6 +657,10 @@ def create_github_tools(mcp: FastMCP) -> None:
         - create as sub-issue: manage_issues(action="create", title="Task 1", parent_issue=42)
         - close multiple: manage_issues(action="close", issue_numbers=[1, 2, 3])
         - comment: manage_issues(action="comment", issue_numbers=[42], body="Fixed!")
+        - list comments: manage_issues(action="list_comments", issue_numbers=[42], comments_limit=5)
+        - list newest comments: manage_issues(action="list_comments", issue_numbers=[42], comments_order="desc")
+        - update comment: manage_issues(action="update_comment", issue_numbers=[42], comment_id=123, body="Updated")
+        - delete comment: manage_issues(action="delete_comment", issue_numbers=[42], comment_id=123)
         - add sub-issues: manage_issues(action="add_sub_issue", issue_numbers=[43,44], parent_issue=42)
         - remove sub-issue: manage_issues(action="remove_sub_issue", issue_numbers=[43], parent_issue=42)
         - list sub-issues: manage_issues(action="list_sub_issues", parent_issue=42)
@@ -830,6 +847,66 @@ def create_github_tools(mcp: FastMCP) -> None:
                         }
                     )
 
+                # === LIST COMMENTS ACTION ===
+                elif action == "list_comments":
+                    comments = client.list_issue_comments(
+                        issue_number=issue_number,
+                        owner=owner,
+                        repo=repo,
+                        limit=comments_limit or 10,
+                        order=comments_order or "asc",
+                    )
+                    results.append(
+                        {
+                            "number": issue_number,
+                            "comments_count": len(comments),
+                            "comments": comments,
+                        }
+                    )
+
+                # === UPDATE COMMENT ACTION ===
+                elif action == "update_comment":
+                    if not comment_id:
+                        raise ToolError(
+                            "'comment_id' is required for 'update_comment' action"
+                        )
+                    if not body:
+                        raise ToolError(
+                            "'body' is required for 'update_comment' action"
+                        )
+                    updated = client.update_issue_comment(
+                        comment_id=comment_id,
+                        body=body,
+                        owner=owner,
+                        repo=repo,
+                    )
+                    results.append(
+                        {
+                            "number": issue_number,
+                            "status": "comment_updated",
+                            "comment": updated,
+                        }
+                    )
+
+                # === DELETE COMMENT ACTION ===
+                elif action == "delete_comment":
+                    if not comment_id:
+                        raise ToolError(
+                            "'comment_id' is required for 'delete_comment' action"
+                        )
+                    client.delete_issue_comment(
+                        comment_id=comment_id,
+                        owner=owner,
+                        repo=repo,
+                    )
+                    results.append(
+                        {
+                            "number": issue_number,
+                            "status": "comment_deleted",
+                            "comment_id": comment_id,
+                        }
+                    )
+
                 else:
                     raise ToolError(f"Invalid action: {action}")
 
@@ -841,6 +918,13 @@ def create_github_tools(mcp: FastMCP) -> None:
                     "issues": results,
                 }
 
+            if action == "list_comments":
+                return {
+                    "action": "list_comments",
+                    "count": len(results),
+                    "issues": results,
+                }
+
             return {"action": action, "count": len(results), "results": results}
 
         except ToolError:
@@ -850,6 +934,404 @@ def create_github_tools(mcp: FastMCP) -> None:
         except Exception as e:
             raise ToolError(f"Failed to {action} issue(s): {str(e)}")
 
+    @mcp.tool(tags={"github", "prs"})
+    def manage_prs(
+        action: str = Field(
+            ...,
+            description="Action: 'list', 'view', 'create', 'update', 'merge', 'close', 'reopen', "
+            "'comment', 'request_reviewers', 'review', 'to_draft', 'ready_for_review', "
+            "'add_labels', 'remove_labels', 'add_assignees', 'remove_assignees'",
+        ),
+        pr_numbers: Optional[List[int]] = Field(
+            default=None,
+            description="PR number(s). Required for view/update/merge/close/reopen/comment/review/labels/assignees actions.",
+        ),
+        title: Optional[str] = Field(
+            default=None,
+            description="PR title (for 'create' or 'update')",
+        ),
+        body: Optional[str] = Field(
+            default=None,
+            description="PR body/description (for 'create'/'update') or comment text (for 'comment')",
+        ),
+        head: Optional[str] = Field(
+            default=None,
+            description="Source branch containing changes (for 'create')",
+        ),
+        base: Optional[str] = Field(
+            default=None,
+            description="Target branch to merge into (for 'create', default: repo default branch)",
+        ),
+        draft: Optional[bool] = Field(
+            default=None,
+            description="Create as draft PR (for 'create')",
+        ),
+        merge_method: Optional[str] = Field(
+            default="merge",
+            description="Merge strategy: 'merge', 'squash', or 'rebase' (for 'merge' action)",
+        ),
+        reviewers: Optional[List[str]] = Field(
+            default=None,
+            description="GitHub usernames to request review from (for 'request_reviewers')",
+        ),
+        team_reviewers: Optional[List[str]] = Field(
+            default=None,
+            description="Team slugs to request review from (for 'request_reviewers')",
+        ),
+        review_event: Optional[str] = Field(
+            default=None,
+            description="Review event: 'APPROVE', 'REQUEST_CHANGES', or 'COMMENT' (for 'review' action)",
+        ),
+        labels: Optional[List[str]] = Field(
+            default=None,
+            description="Labels (for 'add_labels' or 'remove_labels')",
+        ),
+        assignees: Optional[List[str]] = Field(
+            default=None,
+            description="GitHub usernames for assignees. For 'create': defaults to self if not specified. "
+            "For 'add_assignees'/'remove_assignees': required.",
+        ),
+        owner: Optional[str] = Field(
+            default=None,
+            description="Repository owner",
+        ),
+        repo: Optional[str] = Field(
+            default=None,
+            description="Repository name. Required.",
+        ),
+        state: Optional[str] = Field(
+            default="open",
+            description="PR state filter for 'list': 'open', 'closed', or 'all' (default: 'open')",
+        ),
+        limit: Optional[int] = Field(
+            default=20,
+            description="Maximum PRs to return for 'list' action (default: 20)",
+        ),
+    ) -> dict:
+        """
+        Manage GitHub pull requests: list, view, create, update, merge, close, reopen, comment, and review.
+
+        Supports bulk operations for view/close/reopen/comment via pr_numbers list.
+
+        Examples:
+        - list: manage_prs(action="list", state="open")
+        - view: manage_prs(action="view", pr_numbers=[42])
+        - create: manage_prs(action="create", title="Feature X", head="feature-branch", base="main")
+        - create draft: manage_prs(action="create", title="WIP", head="wip-branch", draft=True)
+        - update: manage_prs(action="update", pr_numbers=[42], title="New title", body="Updated desc")
+        - merge: manage_prs(action="merge", pr_numbers=[42], merge_method="squash")
+        - close: manage_prs(action="close", pr_numbers=[42])
+        - reopen: manage_prs(action="reopen", pr_numbers=[42])
+        - comment: manage_prs(action="comment", pr_numbers=[42], body="LGTM!")
+        - request review: manage_prs(action="request_reviewers", pr_numbers=[42], reviewers=["user1"])
+        - approve: manage_prs(action="review", pr_numbers=[42], review_event="APPROVE", body="Looks good!")
+        - to draft: manage_prs(action="to_draft", pr_numbers=[42])
+        - ready: manage_prs(action="ready_for_review", pr_numbers=[42])
+        - add labels: manage_prs(action="add_labels", pr_numbers=[42], labels=["bug", "urgent"])
+        - remove labels: manage_prs(action="remove_labels", pr_numbers=[42], labels=["wip"])
+        - add assignees: manage_prs(action="add_assignees", pr_numbers=[42], assignees=["user1"])
+        - remove assignees: manage_prs(action="remove_assignees", pr_numbers=[42], assignees=["user1"])
+        """
+        try:
+            client = _get_client()
+
+            # === LIST ACTION ===
+            if action == "list":
+                prs = client.list_prs(
+                    owner=owner,
+                    repo=repo,
+                    state=state or "open",
+                    limit=limit or 20,
+                    detail_level="summary",
+                )
+                return {
+                    "action": "list",
+                    "state": state or "open",
+                    "count": len(prs),
+                    "prs": [pr.model_dump() for pr in prs],
+                }
+
+            # === CREATE ACTION ===
+            if action == "create":
+                if not title:
+                    raise ToolError("'title' is required for 'create' action")
+                if not head:
+                    raise ToolError(
+                        "'head' (source branch) is required for 'create' action"
+                    )
+
+                pr = client.create_pr(
+                    title=title,
+                    head=head,
+                    base=base or "main",
+                    body=body,
+                    draft=draft or False,
+                    owner=owner,
+                    repo=repo,
+                )
+
+                result = {
+                    "action": "created",
+                    "pr": pr.model_dump(),
+                }
+
+                # Auto-assign to self if assignees not specified
+                pr_assignees = assignees
+                if pr_assignees is None:
+                    # Default to current user
+                    current_user = client.get_authenticated_user()
+                    if current_user:
+                        pr_assignees = [current_user]
+
+                if pr_assignees:
+                    try:
+                        assign_result = client.add_pr_assignees(
+                            pr.number, assignees=pr_assignees, owner=owner, repo=repo
+                        )
+                        result["assignees"] = assign_result["assignees"]
+                    except Exception as e:
+                        result["assignee_error"] = str(e)
+
+                return result
+
+            # === ALL OTHER ACTIONS REQUIRE pr_numbers ===
+            if not pr_numbers:
+                raise ToolError(f"'pr_numbers' required for '{action}' action")
+
+            results = []
+            for pr_number in pr_numbers:
+                # === VIEW ACTION ===
+                if action == "view":
+                    pr_data = client.get_pr(
+                        pr_number=pr_number,
+                        owner=owner,
+                        repo=repo,
+                    )
+                    if pr_data:
+                        results.append(pr_data.model_dump())
+                    else:
+                        results.append({"number": pr_number, "error": "PR not found"})
+
+                # === UPDATE ACTION ===
+                elif action == "update":
+                    pr_data = client.update_pr(
+                        pr_number=pr_number,
+                        title=title,
+                        body=body,
+                        base=base,
+                        owner=owner,
+                        repo=repo,
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "updated",
+                            "pr": pr_data.model_dump(),
+                        }
+                    )
+
+                # === MERGE ACTION ===
+                elif action == "merge":
+                    merge_result = client.merge_pr(
+                        pr_number=pr_number,
+                        merge_method=merge_method or "merge",
+                        owner=owner,
+                        repo=repo,
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "merged" if merge_result["merged"] else "failed",
+                            "message": merge_result["message"],
+                            "sha": merge_result["sha"],
+                        }
+                    )
+
+                # === CLOSE ACTION ===
+                elif action == "close":
+                    client.close_pr(pr_number, owner=owner, repo=repo)
+                    results.append({"number": pr_number, "status": "closed"})
+
+                # === REOPEN ACTION ===
+                elif action == "reopen":
+                    client.reopen_pr(pr_number, owner=owner, repo=repo)
+                    results.append({"number": pr_number, "status": "reopened"})
+
+                # === COMMENT ACTION ===
+                elif action == "comment":
+                    if not body:
+                        raise ToolError("'body' is required for 'comment' action")
+                    comment = client.add_pr_comment(
+                        pr_number, body=body, owner=owner, repo=repo
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "commented",
+                            "comment_url": comment["html_url"],
+                        }
+                    )
+
+                # === REQUEST REVIEWERS ACTION ===
+                elif action == "request_reviewers":
+                    if not reviewers and not team_reviewers:
+                        raise ToolError(
+                            "'reviewers' or 'team_reviewers' required for 'request_reviewers' action"
+                        )
+                    review_result = client.request_reviewers(
+                        pr_number,
+                        reviewers=reviewers,
+                        team_reviewers=team_reviewers,
+                        owner=owner,
+                        repo=repo,
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "reviewers_requested",
+                            "requested_reviewers": review_result["requested_reviewers"],
+                            "requested_teams": review_result["requested_teams"],
+                        }
+                    )
+
+                # === REVIEW ACTION ===
+                elif action == "review":
+                    if not review_event:
+                        raise ToolError(
+                            "'review_event' (APPROVE, REQUEST_CHANGES, COMMENT) required for 'review' action"
+                        )
+                    if review_event == "REQUEST_CHANGES" and not body:
+                        raise ToolError("'body' is required when requesting changes")
+                    review_result = client.submit_pr_review(
+                        pr_number,
+                        event=review_event,
+                        body=body,
+                        owner=owner,
+                        repo=repo,
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "reviewed",
+                            "review_state": review_result["state"],
+                            "review_url": review_result["html_url"],
+                        }
+                    )
+
+                # === TO DRAFT ACTION ===
+                elif action == "to_draft":
+                    draft_result = client.convert_pr_to_draft(
+                        pr_number, owner=owner, repo=repo
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "converted_to_draft",
+                            "is_draft": draft_result["is_draft"],
+                            "message": draft_result["message"],
+                        }
+                    )
+
+                # === READY FOR REVIEW ACTION ===
+                elif action == "ready_for_review":
+                    ready_result = client.mark_pr_ready_for_review(
+                        pr_number, owner=owner, repo=repo
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "marked_ready",
+                            "is_draft": ready_result["is_draft"],
+                            "message": ready_result["message"],
+                        }
+                    )
+
+                # === ADD LABELS ACTION ===
+                elif action == "add_labels":
+                    if not labels:
+                        raise ToolError("'labels' is required for 'add_labels' action")
+                    label_result = client.add_pr_labels(
+                        pr_number, labels=labels, owner=owner, repo=repo
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "labels_added",
+                            "labels": label_result["labels"],
+                        }
+                    )
+
+                # === REMOVE LABELS ACTION ===
+                elif action == "remove_labels":
+                    if not labels:
+                        raise ToolError(
+                            "'labels' is required for 'remove_labels' action"
+                        )
+                    label_result = client.remove_pr_labels(
+                        pr_number, labels=labels, owner=owner, repo=repo
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "labels_removed",
+                            "labels": label_result["labels"],
+                        }
+                    )
+
+                # === ADD ASSIGNEES ACTION ===
+                elif action == "add_assignees":
+                    if not assignees:
+                        raise ToolError(
+                            "'assignees' is required for 'add_assignees' action"
+                        )
+                    assign_result = client.add_pr_assignees(
+                        pr_number, assignees=assignees, owner=owner, repo=repo
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "assignees_added",
+                            "assignees": assign_result["assignees"],
+                        }
+                    )
+
+                # === REMOVE ASSIGNEES ACTION ===
+                elif action == "remove_assignees":
+                    if not assignees:
+                        raise ToolError(
+                            "'assignees' is required for 'remove_assignees' action"
+                        )
+                    assign_result = client.remove_pr_assignees(
+                        pr_number, assignees=assignees, owner=owner, repo=repo
+                    )
+                    results.append(
+                        {
+                            "number": pr_number,
+                            "status": "assignees_removed",
+                            "assignees": assign_result["assignees"],
+                        }
+                    )
+
+                else:
+                    raise ToolError(f"Invalid action: {action}")
+
+            # Return format depends on action
+            if action == "view":
+                return {
+                    "action": "view",
+                    "count": len(results),
+                    "prs": results,
+                }
+
+            return {"action": action, "count": len(results), "results": results}
+
+        except ToolError:
+            raise
+        except ValueError as e:
+            raise ToolError(f"Repository not specified: {str(e)}")
+        except Exception as e:
+            raise ToolError(f"Failed to {action} PR(s): {str(e)}")
+
     @mcp.tool(tags={"github", "prs", "appraisal"})
     def prepare_appraisal_data(
         author: Optional[str] = Field(

{quickcall_integrations-0.4.0.dist-info → quickcall_integrations-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quickcall-integrations
-Version: 0.4.0
+Version: 0.6.0
 Summary: MCP server with developer integrations for Claude Code and Cursor
 Requires-Python: >=3.10
 Requires-Dist: fastmcp>=2.13.0
@@ -90,7 +90,7 @@ Add to MCP config (`~/.cursor/mcp.json` or `.cursor/mcp.json`):
 | **Slack** | Read/send messages, threads, channels | Yes |
 
 <details>
-<summary><strong>Available Tools (24)</strong></summary>
+<summary><strong>Available Tools (26)</strong></summary>
 
 ### Git
 | Tool | Description |
@@ -107,6 +107,8 @@ Add to MCP config (`~/.cursor/mcp.json` or `.cursor/mcp.json`):
 | `get_commit` | Get commit details (message, stats, files) |
 | `list_branches` | List repository branches |
 | `manage_issues` | List, view, create, update, close, reopen, comment on issues + sub-issues |
+| `manage_prs` | Full PR lifecycle: create, update, merge, close, review, comment, labels, assignees |
+| `manage_projects` | GitHub Projects V2: add issues, update fields (Status, Priority, etc.) |
 | `check_github_connection` | Verify GitHub connection |
 
 ### Slack
@@ -193,6 +195,8 @@ GITHUB_USERNAME=your-username  # Optional: for better UX
 | `/quickcall:status` | Show connection status |
 | `/quickcall:updates` | Get git updates (default: 1 day) |
 | `/quickcall:updates 7d` | Get updates for last 7 days |
+| `/quickcall:pr-summary` | List open PRs for a repo |
+| `/quickcall:pr-summary owner/repo` | List PRs for specific repo |
 | `/quickcall:slack-summary` | Summarize Slack messages (default: 1 day) |
 | `/quickcall:slack-summary 7d` | Summarize last 7 days |
 
@@ -248,10 +252,28 @@ The `manage_issues` tool provides full issue lifecycle management:
 | `close` | Close issue(s) |
 | `reopen` | Reopen issue(s) |
 | `comment` | Add comment to issue(s) |
+| `list_comments` | List comments with limit and order |
+| `update_comment` | Edit existing comment by ID |
+| `delete_comment` | Delete comment by ID |
 | `add_sub_issue` | Add child issue to parent |
 | `remove_sub_issue` | Remove child from parent |
 | `list_sub_issues` | List sub-issues of a parent |
 
+### Comment Management
+
+| Parameter | Description |
+|-----------|-------------|
+| `comment_id` | Comment ID for update/delete operations |
+| `comments_limit` | Max comments to return (default: 10) |
+| `comments_order` | `'asc'` (oldest first) or `'desc'` (newest first) |
+
+**Examples:**
+```
+List last 5 comments on issue #42 (newest first)
+Update comment 123456 on issue #42 with new text
+Delete comment 123456 from issue #42
+```
+
 ### List Filters
 
 | Filter | Description |
@@ -327,6 +349,46 @@ Create a bug report issue titled "Login fails on Safari"
 Create issue with feature_request template
 ```
 
+## PR Management
+
+The `manage_prs` tool provides full pull request lifecycle management:
+
+### Actions
+
+| Action | Description |
+|--------|-------------|
+| `list` | List PRs with state filter |
+| `view` | View PR details |
+| `create` | Create PR (auto-assigns to self) |
+| `update` | Update title, body, base branch |
+| `merge` | Merge PR (merge/squash/rebase) |
+| `close` | Close PR without merging |
+| `reopen` | Reopen closed PR |
+| `comment` | Add comment to PR |
+| `request_reviewers` | Request user/team reviewers |
+| `review` | Submit review (APPROVE, REQUEST_CHANGES, COMMENT) |
+| `to_draft` | Convert PR to draft |
+| `ready_for_review` | Mark draft as ready |
+| `add_labels` | Add labels to PR |
+| `remove_labels` | Remove labels from PR |
+| `add_assignees` | Add assignees |
+| `remove_assignees` | Remove assignees |
+
+### Examples
+
+```
+List open PRs on my-repo
+Create a PR from feature-branch to main titled "Add new feature"
+Merge PR #42 with squash
+Request review from @alice on PR #42
+Approve PR #42 with comment "LGTM!"
+Add labels bug and urgent to PR #42
+```
+
+### Auto-assign
+
+When creating a PR, it automatically assigns to the current user unless `assignees` is explicitly provided.
+
 ## Troubleshooting
 
 ### Clean Reinstall

{quickcall_integrations-0.4.0.dist-info → quickcall_integrations-0.6.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 mcp_server/__init__.py,sha256=6KGzjSPyVB6vQh150DwBjINM_CsZNDhOzwSQFWpXz0U,301
 mcp_server/server.py,sha256=kv5hh0J-M7yENUBBNI1bkq1y7MB0zn5R_-R1tib6_sk,3108
 mcp_server/api_clients/__init__.py,sha256=kOG5_sxIVpAx_tvf1nq_P0QCkqojAVidRE-wenLS-Wc,207
-mcp_server/api_clients/github_client.py,sha256=Y3P2yRRv8GxG0xjql6IaVB5aodGDeTPQUC_lHQmgVWM,70829
+mcp_server/api_clients/github_client.py,sha256=oKB7NyjuCvs9-BI2061XRxfxIM6lMrrBJJfbCgUxizE,90249
 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=sDS0W5c16i_UGvhG8Sh1RO93FxRn-hHVAdI9hlWuhx0,20011
@@ -12,10 +12,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=BPuj9M0pZOvvWHxH0HPdiVm-Y6DJyD-PEvtrIh68vbc,25409
 mcp_server/tools/git_tools.py,sha256=jyCTQR2eSzUFXMt0Y8x66758-VY8YCY14DDUJt7GY2U,13957
-mcp_server/tools/github_tools.py,sha256=U1auskC17nJWVmqFO9EITe-OcDSeDBuhM3d4iox7Ix8,50007
+mcp_server/tools/github_tools.py,sha256=scfgo48_-uvuj5ehWaoB-VtKx5RqSME8fetpMphVh-w,70461
 mcp_server/tools/slack_tools.py,sha256=-HVE_x3Z1KMeYGi1xhyppEwz5ZF-I-ZD0-Up8yBeoYE,11796
 mcp_server/tools/utility_tools.py,sha256=oxAXpdqtPeB5Ug5dvk54V504r-8v1AO4_px-sO6LFOw,3910
-quickcall_integrations-0.4.0.dist-info/METADATA,sha256=pOcoe0a2JKylPL6tpzYk2lUor_hgfsXPyDgjwjn45JM,9415
-quickcall_integrations-0.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-quickcall_integrations-0.4.0.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
-quickcall_integrations-0.4.0.dist-info/RECORD,,
+quickcall_integrations-0.6.0.dist-info/METADATA,sha256=IG765WJlLD7A98ikmPH2Ru8fRQhcMFbanKS8eeQn-v4,11519
+quickcall_integrations-0.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quickcall_integrations-0.6.0.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
+quickcall_integrations-0.6.0.dist-info/RECORD,,