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

mcp_server/tools/auth_tools.py

@@ -3,6 +3,8 @@ Authentication tools for QuickCall MCP.
 
 Provides tools for users to connect, check status, and disconnect
 their QuickCall account from the CLI.
+
+Also provides GitHub PAT authentication for users who can't install the GitHub App.
 """
 
 import os
@@ -11,11 +13,12 @@ import webbrowser
 from typing import Dict, Any
 
 import httpx
+from github import Github, Auth, GithubException
 from fastmcp import FastMCP
+from pydantic import Field
 
 from mcp_server.auth import (
     get_credential_store,
-    is_authenticated,
     DeviceFlowAuth,
 )
 
@@ -100,46 +103,75 @@ def create_auth_tools(mcp: FastMCP):
         Check your QuickCall connection status.
 
         Shows:
-        - Whether you're connected
+        - Whether you're connected to QuickCall
         - Your account info
-        - GitHub connection status
+        - GitHub connection status (via App or PAT)
         - Slack connection status
 
         Returns:
             Current authentication and integration status
         """
         store = get_credential_store()
-
-        if not store.is_authenticated():
-            return {
-                "connected": False,
-                "message": "Not connected to QuickCall",
-                "hint": "Use connect_quickcall to authenticate.",
-            }
-
         status = store.get_status()
 
-        return {
-            "connected": True,
-            "user": {
+        # Build result with both QuickCall and PAT status
+        result = {
+            "quickcall_connected": status.get("quickcall_authenticated", False),
+            "credentials_file": status.get("credentials_file"),
+        }
+
+        # QuickCall user info
+        if status.get("quickcall_authenticated"):
+            result["user"] = {
                 "id": status.get("user_id"),
                 "email": status.get("email"),
                 "username": status.get("username"),
-            },
-            "authenticated_at": status.get("authenticated_at"),
-            "integrations": {
-                "github": {
-                    "connected": status.get("github", {}).get("connected", False),
-                    "username": status.get("github", {}).get("username"),
-                },
-                "slack": {
-                    "connected": status.get("slack", {}).get("connected", False),
-                    "team_name": status.get("slack", {}).get("team_name"),
-                },
-            },
-            "credentials_file": status.get("credentials_file"),
+            }
+            result["authenticated_at"] = status.get("authenticated_at")
+
+        # GitHub status (can be via App or PAT)
+        github_status = status.get("github", {})
+        result["github"] = {
+            "connected": github_status.get("connected", False),
+            "mode": github_status.get("mode"),  # "github_app" or "pat"
+            "username": github_status.get("username"),
+        }
+
+        # PAT-specific info if configured
+        github_pat = status.get("github_pat", {})
+        if github_pat.get("configured"):
+            result["github_pat"] = {
+                "configured": True,
+                "username": github_pat.get("username"),
+                "configured_at": github_pat.get("configured_at"),
+            }
+
+        # Slack status (requires QuickCall)
+        slack_status = status.get("slack", {})
+        result["slack"] = {
+            "connected": slack_status.get("connected", False),
+            "team_name": slack_status.get("team_name"),
         }
 
+        # Add helpful message based on status
+        if not status.get("quickcall_authenticated") and not github_pat.get(
+            "configured"
+        ):
+            result["message"] = "Not connected to QuickCall or GitHub"
+            result["hint"] = (
+                "Use connect_quickcall for full access, or connect_github_via_pat for GitHub only."
+            )
+        elif not status.get("quickcall_authenticated") and github_pat.get("configured"):
+            result["message"] = "GitHub connected via PAT (QuickCall not connected)"
+            result["hint"] = "Use connect_quickcall to also access Slack tools."
+        elif status.get("quickcall_authenticated"):
+            result["message"] = "Connected to QuickCall"
+
+        # Legacy compatibility
+        result["connected"] = status.get("quickcall_authenticated", False)
+
+        return result
+
     @mcp.tool(tags={"auth", "quickcall"})
     def disconnect_quickcall() -> Dict[str, Any]:
         """
@@ -493,3 +525,138 @@ def create_auth_tools(mcp: FastMCP):
                 "status": "error",
                 "message": f"Failed to reconnect Slack: {e}",
             }
+
+    # ========================================================================
+    # GitHub PAT Authentication (alternative to QuickCall GitHub App)
+    # ========================================================================
+
+    @mcp.tool(tags={"auth", "github"})
+    def connect_github_via_pat(
+        token: str = Field(
+            ...,
+            description="GitHub Personal Access Token (ghp_xxx or github_pat_xxx)",
+        ),
+    ) -> Dict[str, Any]:
+        """
+        Connect GitHub using a Personal Access Token (PAT).
+
+        Use this if your organization can't install the QuickCall GitHub App.
+        This is an alternative to the standard connect_github flow.
+
+        This command:
+        1. Validates your PAT by calling GitHub API
+        2. Auto-detects your GitHub username
+        3. Stores the PAT securely in ~/.quickcall/credentials.json
+
+        After connecting, you can use GitHub tools like list_repos, list_prs, etc.
+
+        Create a PAT at: https://github.com/settings/tokens
+        Required scopes:
+        - repo (full access to private repos)
+        - OR public_repo (public repos only)
+
+        Note: PAT mode works independently of QuickCall. You don't need
+        to run connect_quickcall first. However, Slack tools still require
+        QuickCall authentication.
+        """
+        store = get_credential_store()
+
+        # Check if already configured via stored PAT
+        if store.has_github_pat():
+            pat_creds = store.get_github_pat_credentials()
+            return {
+                "status": "already_connected",
+                "message": f"GitHub PAT is already configured (username: {pat_creds.username})",
+                "configured_at": pat_creds.configured_at,
+                "hint": "Use disconnect_github_pat to remove it, then connect again with a new token.",
+            }
+
+        # Validate token format
+        if not token.startswith(("ghp_", "github_pat_")):
+            return {
+                "status": "error",
+                "message": "Invalid token format. GitHub PATs start with 'ghp_' or 'github_pat_'",
+                "hint": "Create a new token at https://github.com/settings/tokens",
+            }
+
+        # Validate token by calling GitHub API
+        try:
+            auth = Auth.Token(token)
+            gh = Github(auth=auth)
+            user = gh.get_user()
+            username = user.login
+            gh.close()
+        except GithubException as e:
+            if e.status == 401:
+                return {
+                    "status": "error",
+                    "message": "Invalid or expired token.",
+                    "hint": "Check your token at https://github.com/settings/tokens",
+                }
+            return {
+                "status": "error",
+                "message": f"GitHub API error: {e.data.get('message', str(e))}",
+            }
+        except Exception as e:
+            logger.error(f"Failed to validate GitHub PAT: {e}")
+            return {
+                "status": "error",
+                "message": f"Failed to validate token: {e}",
+            }
+
+        # Store the PAT
+        try:
+            store.save_github_pat(token=token, username=username)
+        except Exception as e:
+            logger.error(f"Failed to save GitHub PAT: {e}")
+            return {
+                "status": "error",
+                "message": f"Failed to save token: {e}",
+            }
+
+        return {
+            "status": "success",
+            "message": f"Successfully connected GitHub as {username}!",
+            "username": username,
+            "mode": "pat",
+            "hint": "You can now use GitHub tools. Run check_github_connection to verify.",
+        }
+
+    @mcp.tool(tags={"auth", "github"})
+    def disconnect_github_pat() -> Dict[str, Any]:
+        """
+        Disconnect GitHub PAT authentication.
+
+        This removes only the stored PAT. If you also have QuickCall
+        connected, that connection remains intact.
+
+        After disconnecting:
+        - If you have QuickCall GitHub App connected, it will be used instead
+        - Otherwise, GitHub tools will be unavailable until you reconnect
+        """
+        store = get_credential_store()
+
+        if not store.has_github_pat():
+            return {
+                "status": "not_connected",
+                "message": "No GitHub PAT is configured.",
+                "hint": "Use connect_github_via_pat to set up PAT authentication.",
+            }
+
+        try:
+            pat_creds = store.get_github_pat_credentials()
+            username = pat_creds.username if pat_creds else "unknown"
+
+            store.clear_github_pat()
+
+            return {
+                "status": "disconnected",
+                "message": f"Disconnected GitHub PAT ({username})",
+                "hint": "Use connect_github_via_pat to reconnect, or connect_github to use the QuickCall GitHub App instead.",
+            }
+        except Exception as e:
+            logger.error(f"Failed to disconnect GitHub PAT: {e}")
+            return {
+                "status": "error",
+                "message": f"Failed to disconnect: {e}",
+            }

mcp_server/tools/git_tools.py

@@ -4,6 +4,7 @@ Git Tools - Simple tools for viewing repository changes.
 
 from typing import Optional, List
 import subprocess
+import re
 
 from fastmcp import FastMCP
 from fastmcp.exceptions import ToolError
@@ -230,3 +231,176 @@ def create_git_tools(mcp: FastMCP) -> None:
             raise
         except Exception as e:
             raise ToolError(f"Failed to get updates: {str(e)}")
+
+    @mcp.tool(tags={"git", "appraisal"})
+    def get_local_contributions(
+        path: str = Field(
+            ...,
+            description="Path to git repository.",
+        ),
+        days: int = Field(
+            default=180,
+            description="Number of days to look back (default: 180 for 6 months)",
+        ),
+        author: Optional[str] = Field(
+            default=None,
+            description="Filter by author name/email. If not specified, uses git config user.email",
+        ),
+    ) -> dict:
+        """
+        Get contributions from local git history for appraisals.
+
+        Returns commits with:
+        - commit message (for Claude to categorize: feat, fix, chore, etc.)
+        - PR number (extracted from merge commits if available)
+        - stats (additions, deletions)
+        - date range
+
+        Claude should analyze commit messages to categorize contributions.
+        This tool does NOT do any categorization - it returns raw data.
+
+        Use this for appraisals when:
+        - GitHub App is not connected
+        - You want local repo contributions only
+        - Testing appraisal features on cloned repos
+        """
+        try:
+            repo_info = _get_repo_info(path)
+            repo_name = (
+                f"{repo_info['owner']}/{repo_info['repo']}"
+                if repo_info["owner"]
+                else repo_info["root"]
+            )
+
+            # Get author from git config if not specified
+            if not author:
+                try:
+                    author = _run_git(["config", "user.email"], path)
+                except ToolError:
+                    pass
+
+            since_date = f"{days} days ago"
+
+            # Get all commits by author
+            log_format = "--pretty=format:%H|%an|%ae|%ad|%s|%b---COMMIT_END---"
+            log_args = [
+                "log",
+                log_format,
+                "--date=iso",
+                f"--since={since_date}",
+            ]
+            if author:
+                log_args.extend(["--author", author])
+
+            log_output = _run_git(log_args, path)
+
+            commits = []
+            merge_commits = []
+
+            # Parse commits
+            for commit_block in log_output.split("---COMMIT_END---"):
+                if not commit_block.strip():
+                    continue
+
+                lines = commit_block.strip().split("|", 5)
+                if len(lines) < 5:
+                    continue
+
+                sha = lines[0]
+                author_name = lines[1]
+                author_email = lines[2]
+                date = lines[3]
+                subject = lines[4]
+                body = lines[5] if len(lines) > 5 else ""
+
+                # Extract PR number from merge commit message
+                pr_number = None
+                merge_match = re.search(r"Merge pull request #(\d+)", subject)
+                if merge_match:
+                    pr_number = int(merge_match.group(1))
+                else:
+                    # Also check for GitHub's squash merge format
+                    squash_match = re.search(r"\(#(\d+)\)$", subject)
+                    if squash_match:
+                        pr_number = int(squash_match.group(1))
+
+                commit_data = {
+                    "sha": sha[:7],
+                    "full_sha": sha,
+                    "author": author_name,
+                    "email": author_email,
+                    "date": date,
+                    "message": subject,
+                    "body": body.strip()[:500] if body else "",
+                    "pr_number": pr_number,
+                }
+
+                commits.append(commit_data)
+
+                if pr_number:
+                    merge_commits.append(commit_data)
+
+            # Get stats for commits if we have any
+            stats = {"total_additions": 0, "total_deletions": 0, "files_changed": set()}
+
+            if commits:
+                # Get numstat for all commits by this author
+                numstat_args = [
+                    "log",
+                    "--numstat",
+                    "--pretty=format:",
+                    f"--since={since_date}",
+                ]
+                if author:
+                    numstat_args.extend(["--author", author])
+
+                try:
+                    numstat_output = _run_git(numstat_args, path)
+                    for line in numstat_output.split("\n"):
+                        if not line.strip():
+                            continue
+                        parts = line.split("\t")
+                        if len(parts) >= 3:
+                            adds = int(parts[0]) if parts[0] != "-" else 0
+                            dels = int(parts[1]) if parts[1] != "-" else 0
+                            stats["total_additions"] += adds
+                            stats["total_deletions"] += dels
+                            stats["files_changed"].add(parts[2])
+                except ToolError:
+                    pass
+
+            # Calculate date range
+            if commits:
+                dates = [c["date"] for c in commits]
+                earliest = min(dates)
+                latest = max(dates)
+            else:
+                earliest = latest = None
+
+            return {
+                "repository": repo_name,
+                "branch": repo_info["branch"],
+                "author": author,
+                "period_days": days,
+                "date_range": {
+                    "earliest": earliest,
+                    "latest": latest,
+                },
+                "summary": {
+                    "total_commits": len(commits),
+                    "merge_commits": len(merge_commits),
+                    "unique_prs": len(
+                        set(c["pr_number"] for c in merge_commits if c["pr_number"])
+                    ),
+                    "total_additions": stats["total_additions"],
+                    "total_deletions": stats["total_deletions"],
+                    "files_touched": len(stats["files_changed"]),
+                },
+                "commits": commits,
+                "pr_commits": merge_commits,
+            }
+
+        except ToolError:
+            raise
+        except Exception as e:
+            raise ToolError(f"Failed to get contributions: {str(e)}")