quickcall-integrations 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

mcp_server/__init__.py

@@ -3,4 +3,10 @@ MCP Server for QuickCall
 GitHub integration tools for AI assistant
 """
 
-__version__ = "0.1.8"
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("quickcall-integrations")
+except PackageNotFoundError:
+    # Package not installed (development mode)
+    __version__ = "0.0.0-dev"

mcp_server/api_clients/github_client.py

@@ -578,6 +578,114 @@ class GitHubClient:
 
         return branches
 
+    # ========================================================================
+    # Issue Operations
+    # ========================================================================
+
+    def _issue_to_dict(self, issue) -> Dict[str, Any]:
+        """Convert PyGithub Issue to dict."""
+        return {
+            "number": issue.number,
+            "title": issue.title,
+            "body": issue.body,
+            "state": issue.state,
+            "html_url": issue.html_url,
+            "labels": [label.name for label in issue.labels],
+            "assignees": [a.login for a in issue.assignees],
+            "created_at": issue.created_at.isoformat(),
+        }
+
+    def create_issue(
+        self,
+        title: str,
+        body: Optional[str] = None,
+        labels: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a GitHub issue."""
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.create_issue(
+            title=title,
+            body=body or "",
+            labels=labels or [],
+            assignees=assignees or [],
+        )
+        return self._issue_to_dict(issue)
+
+    def update_issue(
+        self,
+        issue_number: int,
+        title: Optional[str] = None,
+        body: Optional[str] = None,
+        labels: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Update a GitHub issue."""
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.get_issue(issue_number)
+
+        kwargs = {}
+        if title is not None:
+            kwargs["title"] = title
+        if body is not None:
+            kwargs["body"] = body
+        if labels is not None:
+            kwargs["labels"] = labels
+        if assignees is not None:
+            kwargs["assignees"] = assignees
+
+        if kwargs:
+            issue.edit(**kwargs)
+
+        return self._issue_to_dict(issue)
+
+    def close_issue(
+        self,
+        issue_number: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Close a GitHub issue."""
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.get_issue(issue_number)
+        issue.edit(state="closed")
+        return self._issue_to_dict(issue)
+
+    def reopen_issue(
+        self,
+        issue_number: int,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Reopen a GitHub issue."""
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.get_issue(issue_number)
+        issue.edit(state="open")
+        return self._issue_to_dict(issue)
+
+    def comment_on_issue(
+        self,
+        issue_number: int,
+        body: str,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Add a comment to a GitHub issue."""
+        gh_repo = self._get_repo(owner, repo)
+        issue = gh_repo.get_issue(issue_number)
+        comment = issue.create_comment(body)
+        return {
+            "id": comment.id,
+            "body": comment.body,
+            "html_url": comment.html_url,
+            "created_at": comment.created_at.isoformat(),
+            "issue_number": issue_number,
+        }
+
     # ========================================================================
     # Search Operations (for Appraisals)
     # ========================================================================

mcp_server/auth/credentials.py

@@ -353,9 +353,9 @@ class CredentialStore:
             api_creds = self.get_api_credentials(force_refresh=True)
             result["github"] = {
                 "connected": api_creds.github_connected if api_creds else False,
-                "mode": "github_app"
-                if (api_creds and api_creds.github_connected)
-                else None,
+                "mode": (
+                    "github_app" if (api_creds and api_creds.github_connected) else None
+                ),
                 "username": api_creds.github_username if api_creds else None,
             }
             result["slack"] = {

mcp_server/resources/github_resources.py

@@ -0,0 +1,147 @@
+"""
+GitHub MCP Resources - Exposes GitHub data for Claude's context.
+
+Resources are automatically available in Claude's context when connected.
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+import yaml
+from fastmcp import FastMCP
+
+from mcp_server.auth import get_credential_store, get_github_pat
+from mcp_server.auth.credentials import _find_project_root, _parse_env_file
+
+logger = logging.getLogger(__name__)
+
+
+def _load_issue_templates_config() -> Optional[Dict[str, Any]]:
+    """
+    Load issue templates from ISSUE_TEMPLATE_PATH in .quickcall.env.
+    Returns None if not configured or file doesn't exist.
+    """
+    import os
+    from pathlib import Path
+
+    template_path = os.getenv("ISSUE_TEMPLATE_PATH")
+
+    # Check .quickcall.env in project root
+    if not template_path:
+        project_root = _find_project_root()
+        if project_root:
+            config_path = project_root / ".quickcall.env"
+            if config_path.exists():
+                env_vars = _parse_env_file(config_path)
+                if "ISSUE_TEMPLATE_PATH" in env_vars:
+                    template_path = env_vars["ISSUE_TEMPLATE_PATH"]
+                    if not Path(template_path).is_absolute():
+                        template_path = str(project_root / template_path)
+
+    if not template_path:
+        return None
+
+    try:
+        with open(template_path) as f:
+            return yaml.safe_load(f) or {}
+    except Exception as e:
+        logger.warning(f"Failed to load issue templates: {e}")
+        return None
+
+
+def create_github_resources(mcp: FastMCP) -> None:
+    """Add GitHub resources to the MCP server."""
+
+    @mcp.resource("github://repositories")
+    def get_github_repositories() -> str:
+        """
+        List of GitHub repositories the user has access to.
+
+        Use these when working with GitHub operations.
+        """
+        store = get_credential_store()
+
+        # Check if authenticated via PAT or QuickCall
+        pat_token, pat_source = get_github_pat()
+        has_pat = pat_token is not None
+
+        if not has_pat and not store.is_authenticated():
+            return "GitHub not connected. Options:\n- Run connect_github_via_pat with a Personal Access Token\n- Run connect_quickcall to use QuickCall"
+
+        # Check QuickCall GitHub App connection
+        has_app = False
+        if store.is_authenticated():
+            creds = store.get_api_credentials()
+            if creds and creds.github_connected and creds.github_token:
+                has_app = True
+
+        if not has_pat and not has_app:
+            return "GitHub not connected. Connect at quickcall.dev/assistant or use connect_github_via_pat."
+
+        try:
+            # Import here to avoid circular imports
+            from mcp_server.tools.github_tools import _get_client
+
+            client = _get_client()
+            repos = client.list_repos(limit=50)
+
+            # Determine auth mode for display
+            auth_mode = "PAT" if has_pat else "GitHub App"
+
+            lines = [f"GitHub Repositories (via {auth_mode}):", ""]
+            for repo in repos:
+                visibility = "private" if repo.private else "public"
+                lines.append(f"- {repo.full_name} ({visibility})")
+
+            if len(repos) >= 50:
+                lines.append("")
+                lines.append("(Showing first 50 repos)")
+
+            return "\n".join(lines)
+        except Exception as e:
+            logger.error(f"Failed to fetch GitHub repositories: {e}")
+            return f"Error fetching repositories: {str(e)}"
+
+    @mcp.resource("github://issue-templates")
+    def get_issue_templates() -> str:
+        """
+        Available issue templates from project configuration.
+
+        Use template names when creating issues with manage_issues.
+        """
+        config = _load_issue_templates_config()
+
+        if not config:
+            return "No issue templates configured.\n\nTo configure:\n1. Create a YAML file with your templates\n2. Add ISSUE_TEMPLATE_PATH=/path/to/templates.yaml to .quickcall.env"
+
+        templates = config.get("templates", {})
+        defaults = config.get("defaults", {})
+
+        if not templates:
+            lines = ["Issue Templates:", ""]
+            if defaults:
+                labels = defaults.get("labels", [])
+                lines.append("Default template:")
+                if labels:
+                    lines.append(f"  Labels: {', '.join(labels)}")
+                if defaults.get("body"):
+                    lines.append(f"  Body template: {defaults['body'][:100]}...")
+            return "\n".join(lines)
+
+        lines = ["Available Issue Templates:", ""]
+
+        for name, template in templates.items():
+            labels = template.get("labels", [])
+            body_preview = template.get("body", "")[:80]
+            lines.append(f"- {name}")
+            if labels:
+                lines.append(f"    Labels: {', '.join(labels)}")
+            if body_preview:
+                lines.append(f"    Body: {body_preview}...")
+
+        lines.append("")
+        lines.append(
+            "Usage: manage_issues(action='create', title='...', template='<name>')"
+        )
+
+        return "\n".join(lines)

mcp_server/server.py

@@ -24,6 +24,7 @@ from mcp_server.tools.github_tools import create_github_tools
 from mcp_server.tools.slack_tools import create_slack_tools
 from mcp_server.tools.auth_tools import create_auth_tools
 from mcp_server.resources.slack_resources import create_slack_resources
+from mcp_server.resources.github_resources import create_github_resources
 
 # Configure logging
 logging.basicConfig(
@@ -57,6 +58,7 @@ def create_server() -> FastMCP:
 
     # Register resources (available in Claude's context)
     create_slack_resources(mcp)
+    create_github_resources(mcp)
 
     # Log current status
     if is_authenticated:

mcp_server/tools/github_tools.py

@@ -2,95 +2,173 @@
 GitHub Tools - Pull requests and commits via GitHub API.
 
 Authentication (in priority order):
-1. QuickCall GitHub App (preferred) - connect via connect_quickcall
-2. Personal Access Token (PAT) - set GITHUB_TOKEN env var or use .quickcall.env file
-
-PAT fallback is useful for:
-- Users at organizations that can't install the GitHub App
-- Personal repositories without app installation
-- Testing and development
+1. Personal Access Token (PAT) - more permissions, user's default choice
+   - Set via connect_github_via_pat command
+   - Or GITHUB_TOKEN env var / .quickcall.env file
+2. QuickCall GitHub App - fallback if no PAT configured
+
+PAT is preferred because:
+- Users have direct control over permissions
+- Works with any repository the user has access to
+- No GitHub App installation required
 """
 
-from typing import List, Optional, Tuple
 import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
 
+import yaml
 from fastmcp import FastMCP
 from fastmcp.exceptions import ToolError
 from pydantic import Field
 
+from mcp_server.api_clients.github_client import GitHubClient
 from mcp_server.auth import (
     get_credential_store,
     get_github_pat,
     get_github_pat_username,
 )
-from mcp_server.api_clients.github_client import GitHubClient
+from mcp_server.auth.credentials import _find_project_root, _parse_env_file
 
 logger = logging.getLogger(__name__)
 
 
+# ============================================================================
+# Issue Template Support
+# ============================================================================
+
+DEFAULT_ISSUE_TEMPLATE: Dict[str, Any] = {
+    "labels": [],
+    "body": "## Description\n\n## Details\n",
+}
+
+
+def _load_issue_template(template_type: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Load issue template from ISSUE_TEMPLATE_PATH in .quickcall.env.
+    Returns defaults if not configured.
+    """
+    template_path = os.getenv("ISSUE_TEMPLATE_PATH")
+
+    # Check .quickcall.env in project root
+    if not template_path:
+        project_root = _find_project_root()
+        if project_root:
+            config_path = project_root / ".quickcall.env"
+            if config_path.exists():
+                env_vars = _parse_env_file(config_path)
+                if "ISSUE_TEMPLATE_PATH" in env_vars:
+                    template_path = env_vars["ISSUE_TEMPLATE_PATH"]
+                    if not Path(template_path).is_absolute():
+                        template_path = str(project_root / template_path)
+
+    if not template_path:
+        return DEFAULT_ISSUE_TEMPLATE
+
+    try:
+        with open(template_path) as f:
+            config = yaml.safe_load(f) or {}
+
+        # If template_type specified, look for it in templates section
+        if template_type and "templates" in config:
+            return config["templates"].get(
+                template_type, config.get("defaults", DEFAULT_ISSUE_TEMPLATE)
+            )
+
+        return config.get("defaults", DEFAULT_ISSUE_TEMPLATE)
+    except Exception as e:
+        logger.warning(f"Failed to load issue template: {e}")
+        return DEFAULT_ISSUE_TEMPLATE
+
+
 # Track whether we're using PAT mode for status reporting
 _using_pat_mode: bool = False
 _pat_source: Optional[str] = None
 
+# Module-level client cache (keyed by token hash for security)
+_client_cache: Optional[Tuple[int, GitHubClient]] = None
+
 
 def _get_client() -> GitHubClient:
     """
     Get the GitHub client using the best available authentication method.
 
     Authentication priority:
-    1. QuickCall GitHub App (if connected and working)
-    2. Personal Access Token from environment/config file
+    1. Personal Access Token (PAT) - preferred, more permissions
+    2. QuickCall GitHub App - fallback if no PAT
+
+    Uses cached client if token hasn't changed.
 
     Raises:
         ToolError: If no authentication method is available
     """
-    global _using_pat_mode, _pat_source
+    global _using_pat_mode, _pat_source, _client_cache
 
     store = get_credential_store()
 
-    # Try QuickCall GitHub App first (preferred)
+    # Try PAT first (preferred - user has more control)
+    pat_token, pat_source_str = get_github_pat()
+    if pat_token:
+        token_hash = hash(pat_token)
+
+        # Return cached client if token matches
+        if _client_cache and _client_cache[0] == token_hash:
+            return _client_cache[1]
+
+        _using_pat_mode = True
+        _pat_source = pat_source_str
+        pat_username = get_github_pat_username()
+        logger.info(f"Using GitHub PAT from {pat_source_str}")
+
+        client = GitHubClient(
+            token=pat_token,
+            default_owner=pat_username,
+            installation_id=None,  # No installation ID for PAT
+        )
+        _client_cache = (token_hash, client)
+        return client
+
+    # Fall back to QuickCall GitHub App
     if store.is_authenticated():
         creds = store.get_api_credentials()
         if creds and creds.github_connected and creds.github_token:
+            token_hash = hash(creds.github_token)
+
+            # Return cached client if token matches
+            if _client_cache and _client_cache[0] == token_hash:
+                return _client_cache[1]
+
             _using_pat_mode = False
             _pat_source = None
-            return GitHubClient(
+
+            client = GitHubClient(
                 token=creds.github_token,
                 default_owner=creds.github_username,
                 installation_id=creds.github_installation_id,
             )
-
-    # Try PAT fallback
-    pat_token, pat_source = get_github_pat()
-    if pat_token:
-        _using_pat_mode = True
-        _pat_source = pat_source
-        pat_username = get_github_pat_username()
-        logger.info(f"Using GitHub PAT from {pat_source}")
-        return GitHubClient(
-            token=pat_token,
-            default_owner=pat_username,
-            installation_id=None,  # No installation ID for PAT
-        )
+            _client_cache = (token_hash, client)
+            return client
 
     # No authentication available - provide helpful error message
     _using_pat_mode = False
     _pat_source = None
+    _client_cache = None
 
     if store.is_authenticated():
         # Connected to QuickCall but GitHub not connected
         raise ToolError(
             "GitHub not connected. Options:\n"
-            "1. Connect GitHub App at quickcall.dev/assistant (recommended)\n"
-            "2. Run connect_github_via_pat with your Personal Access Token\n"
+            "1. Run connect_github_via_pat with your Personal Access Token (recommended)\n"
+            "2. Connect GitHub App at quickcall.dev/assistant\n"
             "3. Set GITHUB_TOKEN environment variable"
         )
     else:
         # Not connected to QuickCall at all
         raise ToolError(
             "GitHub authentication required. Options:\n"
-            "1. Run connect_quickcall to use QuickCall (full access to GitHub + Slack)\n"
-            "2. Run connect_github_via_pat with a Personal Access Token (GitHub only)\n"
+            "1. Run connect_github_via_pat with a Personal Access Token (recommended)\n"
+            "2. Run connect_quickcall to use QuickCall (GitHub App + Slack)\n"
             "3. Set GITHUB_TOKEN environment variable\n\n"
             "For PAT: Create token at https://github.com/settings/tokens\n"
             "Required scopes: repo (private) or public_repo (public only)"
@@ -389,6 +467,128 @@ def create_github_tools(mcp: FastMCP) -> None:
         except Exception as e:
             raise ToolError(f"Failed to list branches: {str(e)}")
 
+    @mcp.tool(tags={"github", "issues"})
+    def manage_issues(
+        action: str = Field(
+            ...,
+            description="Action: 'create', 'update', 'close', 'reopen', or 'comment'",
+        ),
+        issue_numbers: Optional[List[int]] = Field(
+            default=None,
+            description="Issue number(s). Required for update/close/reopen/comment. Supports bulk operations.",
+        ),
+        title: Optional[str] = Field(
+            default=None,
+            description="Issue title (for 'create' or 'update')",
+        ),
+        body: Optional[str] = Field(
+            default=None,
+            description="Issue body (for 'create'/'update') or comment text (for 'comment')",
+        ),
+        labels: Optional[List[str]] = Field(
+            default=None,
+            description="Labels (for 'create' or 'update')",
+        ),
+        assignees: Optional[List[str]] = Field(
+            default=None,
+            description="GitHub usernames to assign",
+        ),
+        template: Optional[str] = Field(
+            default=None,
+            description="Template name for 'create' (e.g., 'bug', 'feature')",
+        ),
+        owner: Optional[str] = Field(
+            default=None,
+            description="Repository owner",
+        ),
+        repo: Optional[str] = Field(
+            default=None,
+            description="Repository name. Required.",
+        ),
+    ) -> dict:
+        """
+        Manage GitHub issues: create, update, close, reopen, or comment.
+
+        Supports bulk operations for close/reopen/comment via issue_numbers list.
+
+        Examples:
+        - create: manage_issues(action="create", title="Bug", template="bug")
+        - close multiple: manage_issues(action="close", issue_numbers=[1, 2, 3])
+        - comment: manage_issues(action="comment", issue_numbers=[42], body="Fixed!")
+        """
+        try:
+            client = _get_client()
+
+            if action == "create":
+                if not title:
+                    raise ToolError("'title' is required for 'create' action")
+
+                tpl = _load_issue_template(template)
+                final_body = body if body is not None else tpl.get("body", "")
+                final_labels = labels if labels is not None else tpl.get("labels", [])
+
+                issue = client.create_issue(
+                    title=title,
+                    body=final_body,
+                    labels=final_labels,
+                    assignees=assignees,
+                    owner=owner,
+                    repo=repo,
+                )
+                return {"action": "created", "issue": issue}
+
+            # All other actions require issue_numbers
+            if not issue_numbers:
+                raise ToolError(f"'issue_numbers' required for '{action}' action")
+
+            results = []
+            for issue_number in issue_numbers:
+                if action == "update":
+                    client.update_issue(
+                        issue_number=issue_number,
+                        title=title,
+                        body=body,
+                        labels=labels,
+                        assignees=assignees,
+                        owner=owner,
+                        repo=repo,
+                    )
+                    results.append({"number": issue_number, "status": "updated"})
+
+                elif action == "close":
+                    client.close_issue(issue_number, owner=owner, repo=repo)
+                    results.append({"number": issue_number, "status": "closed"})
+
+                elif action == "reopen":
+                    client.reopen_issue(issue_number, owner=owner, repo=repo)
+                    results.append({"number": issue_number, "status": "reopened"})
+
+                elif action == "comment":
+                    if not body:
+                        raise ToolError("'body' is required for 'comment' action")
+                    comment = client.comment_on_issue(
+                        issue_number, body=body, owner=owner, repo=repo
+                    )
+                    results.append(
+                        {
+                            "number": issue_number,
+                            "status": "commented",
+                            "comment_url": comment["html_url"],
+                        }
+                    )
+
+                else:
+                    raise ToolError(f"Invalid action: {action}")
+
+            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} issue(s): {str(e)}")
+
     @mcp.tool(tags={"github", "prs", "appraisal"})
     def prepare_appraisal_data(
         author: Optional[str] = Field(

mcp_server/tools/utility_tools.py

@@ -5,6 +5,7 @@ Provides datetime helpers useful for constructing queries:
 - Get current datetime
 - Calculate date ranges (e.g., "last 7 days")
 - Add/subtract time from dates
+- Get MCP server version
 """
 
 from datetime import datetime, timezone, timedelta
@@ -13,6 +14,8 @@ from typing import Optional
 from fastmcp import FastMCP
 from pydantic import Field
 
+from mcp_server import __version__
+
 
 def create_utility_tools(mcp: FastMCP) -> None:
     """
@@ -113,3 +116,19 @@ def create_utility_tools(mcp: FastMCP) -> None:
             "base_date": base.isoformat().replace("+00:00", "Z"),
             "offset": f"{days} days, {hours} hours",
         }
+
+    @mcp.tool(tags={"utility", "version"})
+    def get_mcp_version() -> dict:
+        """
+        Get the QuickCall MCP server version.
+
+        Returns the version from pyproject.toml (single source of truth).
+        Useful for debugging and verifying which version is running.
+
+        Returns:
+            Version info including version string and package name
+        """
+        return {
+            "package": "quickcall-integrations",
+            "version": __version__,
+        }

{quickcall_integrations-0.3.3.dist-info → quickcall_integrations-0.3.4.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: quickcall-integrations
-Version: 0.3.3
+Version: 0.3.4
 Summary: MCP server with developer integrations for Claude Code and Cursor
 Requires-Python: >=3.10
 Requires-Dist: fastmcp>=2.13.0
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pygithub>=2.8.1
+Requires-Dist: pyyaml>=6.0
 Requires-Dist: rapidfuzz>=3.0.0
 Description-Content-Type: text/markdown
 

{quickcall_integrations-0.3.3.dist-info → quickcall_integrations-0.3.4.dist-info}/RECORD

@@ -1,20 +1,21 @@
-mcp_server/__init__.py,sha256=UJBr5BLG_aU2S4s2fEbRBZYd7GUWDVejxBpqezNBo8Q,98
-mcp_server/server.py,sha256=zGrrYwp7H24pJAAGAVkHDk7Y6IydOR_wo5hIL-e6_50,3001
+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=shaBgAtTXUM-LZ7e5obuIRWylkOqBrim3_DapIN4rYI,25861
+mcp_server/api_clients/github_client.py,sha256=HBLKgwZpbbdhroladE0l4mGjmuoa8uKCTf3oEL6S_P4,29298
 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
+mcp_server/auth/credentials.py,sha256=sDS0W5c16i_UGvhG8Sh1RO93FxRn-hHVAdI9hlWuhx0,20011
 mcp_server/auth/device_flow.py,sha256=NXNWHzd-CA4dlhEVCgUhwfpe9TpMKpLSJuyFCh70xKs,8371
 mcp_server/resources/__init__.py,sha256=JrMa3Kf-DmeCB4GwVNfmfw9OGnxF9pJJxCw9Y7u7ujQ,35
+mcp_server/resources/github_resources.py,sha256=gS0mTe7UHySAKiD4AqsFZ6pf7ua8Cq9dDrUqRu72_QM,5180
 mcp_server/resources/slack_resources.py,sha256=b_CPxAicwkF3PsBXIat4QoLbDUHM2g_iPzgzvVpwjaw,1687
 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=HEp0YoihI3te4l-6bWb-trtQySuCo73-2ZWLc70Of6Y,22531
+mcp_server/tools/github_tools.py,sha256=x6aRg03QQd6QV-PePHLUZyOSuKDv06LIVUUCE5qXycU,29951
 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.3.3.dist-info/METADATA,sha256=fd1nVZVj0hMuDBgCERVn-DQxkWv43Yr3otNZ2oJQ4PE,7043
-quickcall_integrations-0.3.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-quickcall_integrations-0.3.3.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
-quickcall_integrations-0.3.3.dist-info/RECORD,,
+mcp_server/tools/utility_tools.py,sha256=oxAXpdqtPeB5Ug5dvk54V504r-8v1AO4_px-sO6LFOw,3910
+quickcall_integrations-0.3.4.dist-info/METADATA,sha256=JRc32RU12a6wnPLT9pQBWdkMCwSx7bS2ycNaPchQvc8,7070
+quickcall_integrations-0.3.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quickcall_integrations-0.3.4.dist-info/entry_points.txt,sha256=kkcunmJUzncYvQ1rOR35V2LPm2HcFTKzdI2l3n7NwiM,66
+quickcall_integrations-0.3.4.dist-info/RECORD,,