quickcall-integrations 0.3.2__tar.gz → 0.3.4__tar.gz

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: quickcall-integrations
-Version: 0.3.2
+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.4/mcp_server/__init__.py

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

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/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)
     # ========================================================================

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/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"] = {

quickcall_integrations-0.3.4/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)

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/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:

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/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)"
@@ -164,10 +242,8 @@ def create_github_tools(mcp: FastMCP) -> None:
         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.
+        Use detail_level='summary' (default) to avoid context overflow.
+        Use get_prs() to fetch full details for specific PRs.
         """
         try:
             client = _get_client()
@@ -286,10 +362,8 @@ def create_github_tools(mcp: FastMCP) -> None:
         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.
+        Use detail_level='summary' (default) to avoid context overflow.
+        Use get_commit(sha) for full details on a specific commit.
         """
         try:
             client = _get_client()
@@ -393,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(
@@ -413,18 +609,17 @@ def create_github_tools(mcp: FastMCP) -> None:
         ),
     ) -> dict:
         """
-        Prepare appraisal data by fetching ALL merged PRs with full details.
-
-        USE THIS TOOL FOR APPRAISALS AND PERFORMANCE REVIEWS!
+        Fetch all merged PRs for appraisals/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
+        Returns:
+        - file_path: temp file with full PR data (additions, deletions, files)
+        - pr_titles: list of {number, title, repo} for Claude to review
+        - count: total PRs found
 
-        DO NOT use search_merged_prs for appraisals - it doesn't include stats
-        and causes context overflow with large result sets.
+        Workflow:
+        1. Call this tool → get file_path and pr_titles
+        2. Review pr_titles, pick significant PRs
+        3. Call get_appraisal_pr_details(file_path, [pr_numbers]) for full details
         """
         import json
         import tempfile
@@ -533,13 +728,12 @@ def create_github_tools(mcp: FastMCP) -> None:
         ),
     ) -> dict:
         """
-        Get full PR details from the appraisal data dump.
+        Read full PR details from the appraisal data file.
 
-        This reads from the local file created by prepare_appraisal_data.
-        NO API CALLS are made - all data comes from the cached dump.
+        Call this after prepare_appraisal_data with selected PR numbers.
+        Reads from the cached file - no API calls made.
 
-        Use this after prepare_appraisal_data to get full details for specific PRs
-        that Claude has identified as important for the appraisal.
+        Returns: additions, deletions, files changed, body for selected PRs.
         """
         import json
 

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/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.2 → quickcall_integrations-0.3.4}/plugins/quickcall/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "quickcall",
   "description": "Integrate quickcall into dev workflows - eliminate interruptions for developers. Ask about your work, get instant answers. No more context switching.",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "author": {
     "name": "Sagar Sarkale"
   }

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/plugins/quickcall/commands/appraisal.md

@@ -16,11 +16,10 @@ Parse `$ARGUMENTS` for time period:
 
 ## Instructions
 
-**IMPORTANT:** Only use these two MCP tools for appraisals:
-1. `prepare_appraisal_data` - fetches and dumps all PR data to a temp file
-2. `get_appraisal_pr_details` - reads specific PRs from that file (no API calls)
+**Two-step flow (avoids context overflow):**
 
-Do NOT use `get_prs`, `list_prs`, or any other tools - they will overflow context.
+1. `prepare_appraisal_data` → fetches all PRs, dumps to file, returns titles + PR numbers
+2. `get_appraisal_pr_details` → Claude picks which PRs to get details for, reads from file
 
 ---
 
@@ -28,9 +27,8 @@ Do NOT use `get_prs`, `list_prs`, or any other tools - they will overflow contex
 
    **Option A - GitHub API (preferred):**
    - Call `prepare_appraisal_data(days=X)` with the parsed time period
-   - This fetches ALL merged PRs with full stats in PARALLEL
-   - Dumps everything to a temp file (avoids context overflow)
-   - Returns: `file_path` + list of `pr_titles` (number, title, repo only)
+   - This fetches ALL merged PRs with full stats in PARALLEL and dumps to a temp file
+   - Returns: `file_path` + `pr_titles` (number, title, repo for each PR)
    - Optional: pass `org` or `repo` parameter to filter
 
    **Option B - Local Git (fallback):**
@@ -44,11 +42,10 @@ Do NOT use `get_prs`, `list_prs`, or any other tools - they will overflow contex
    - **Bug fixes**: (fix:, bugfix:, hotfix:, resolve, patch)
    - **Chores**: Maintenance work (docs:, test:, ci:, chore:, refactor:, bump)
 
-3. **Get details for top accomplishments:**
-   - Pick the top 5-10 significant PRs from the categorized list
-   - Call `get_appraisal_pr_details(file_path, [pr_numbers])`
-   - This reads from the temp file - NO additional API calls
-   - Returns full details: additions, deletions, files, body
+3. **Get full details for selected PRs:**
+   - Based on the titles, pick the top 5-10 significant PRs worth highlighting
+   - Call `get_appraisal_pr_details(file_path, [pr_numbers])` with the selected PR numbers
+   - Returns: full details (additions, deletions, files, body) for those PRs only
 
 4. **Calculate summary metrics:**
    - Total PRs merged by category

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quickcall-integrations"
-version = "0.3.2"
+version = "0.3.4"
 description = "MCP server with developer integrations for Claude Code and Cursor"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -8,6 +8,7 @@ dependencies = [
     "fastmcp>=2.13.0",
     "pydantic>=2.11.7",
     "PyGithub>=2.8.1",
+    "PyYAML>=6.0",
     "httpx>=0.28.0",
     "rapidfuzz>=3.0.0",
 ]

{quickcall_integrations-0.3.2 → quickcall_integrations-0.3.4}/uv.lock

@@ -1459,13 +1459,14 @@ wheels = [
 
 [[package]]
 name = "quickcall-integrations"
-version = "0.3.0"
+version = "0.3.4"
 source = { editable = "." }
 dependencies = [
     { name = "fastmcp" },
     { name = "httpx" },
     { name = "pydantic" },
     { name = "pygithub" },
+    { name = "pyyaml" },
     { name = "rapidfuzz" },
 ]
 
@@ -1484,6 +1485,7 @@ requires-dist = [
     { name = "httpx", specifier = ">=0.28.0" },
     { name = "pydantic", specifier = ">=2.11.7" },
     { name = "pygithub", specifier = ">=2.8.1" },
+    { name = "pyyaml", specifier = ">=6.0" },
     { name = "rapidfuzz", specifier = ">=3.0.0" },
 ]
 

quickcall_integrations-0.3.2/mcp_server/__init__.py

@@ -1,6 +0,0 @@
-"""
-MCP Server for QuickCall
-GitHub integration tools for AI assistant
-"""
-
-__version__ = "0.1.8"