golf-mcp 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

golf/examples/api_key/tools/issues/create.py

@@ -1,55 +1,55 @@
 """Create a new issue in a GitHub repository."""
 
-from typing import Annotated, List, Optional
-from pydantic import BaseModel, Field
+from typing import Annotated
+
 import httpx
+from pydantic import BaseModel, Field
 
 from golf.auth import get_api_key
 
 
 class Output(BaseModel):
     """Response from creating an issue."""
+
     success: bool
-    issue_number: Optional[int] = None
-    issue_url: Optional[str] = None
-    error: Optional[str] = None
+    issue_number: int | None = None
+    issue_url: str | None = None
+    error: str | None = None
 
 
 async def create(
     repo: Annotated[str, Field(description="Repository name in format 'owner/repo'")],
     title: Annotated[str, Field(description="Issue title")],
-    body: Annotated[str, Field(description="Issue description/body (supports Markdown)")] = "",
-    labels: Annotated[Optional[List[str]], Field(description="List of label names to apply")] = None
+    body: Annotated[
+        str, Field(description="Issue description/body (supports Markdown)")
+    ] = "",
+    labels: Annotated[
+        list[str] | None, Field(description="List of label names to apply")
+    ] = None,
 ) -> Output:
     """Create a new issue.
-    
+
     Requires authentication with appropriate permissions.
     """
     github_token = get_api_key()
-    
+
     if not github_token:
         return Output(
             success=False,
-            error="Authentication required. Please provide a GitHub token."
+            error="Authentication required. Please provide a GitHub token.",
         )
-    
+
     # Validate repo format
-    if '/' not in repo:
-        return Output(
-            success=False,
-            error="Repository must be in format 'owner/repo'"
-        )
-    
+    if "/" not in repo:
+        return Output(success=False, error="Repository must be in format 'owner/repo'")
+
     url = f"https://api.github.com/repos/{repo}/issues"
-    
+
     # Build request payload
-    payload = {
-        "title": title,
-        "body": body
-    }
+    payload = {"title": title, "body": body}
     if labels:
         payload["labels"] = labels
-    
+
     try:
         async with httpx.AsyncClient() as client:
             response = await client.post(
@@ -57,38 +57,37 @@ async def create(
                 headers={
                     "Authorization": f"Bearer {github_token}",
                     "Accept": "application/vnd.github.v3+json",
-                    "User-Agent": "Golf-GitHub-MCP-Server"
+                    "User-Agent": "Golf-GitHub-MCP-Server",
                 },
                 json=payload,
-                timeout=10.0
+                timeout=10.0,
             )
-            
+
             response.raise_for_status()
             issue_data = response.json()
-            
+
             return Output(
                 success=True,
                 issue_number=issue_data["number"],
-                issue_url=issue_data["html_url"]
+                issue_url=issue_data["html_url"],
             )
-            
+
     except httpx.HTTPStatusError as e:
         error_messages = {
             401: "Invalid or missing authentication token",
             403: "Insufficient permissions to create issues in this repository",
             404: "Repository not found",
-            422: "Invalid request data"
+            422: "Invalid request data",
         }
         return Output(
             success=False,
-            error=error_messages.get(e.response.status_code, f"GitHub API error: {e.response.status_code}")
+            error=error_messages.get(
+                e.response.status_code, f"GitHub API error: {e.response.status_code}"
+            ),
         )
     except Exception as e:
-        return Output(
-            success=False,
-            error=f"Failed to create issue: {str(e)}"
-        )
+        return Output(success=False, error=f"Failed to create issue: {str(e)}")
 
 
 # Export the function to be used as the tool
-export = create 
+export = create

golf/examples/api_key/tools/issues/list.py

@@ -1,87 +1,92 @@
 """List issues in a GitHub repository."""
 
-from typing import Annotated, List, Optional, Dict, Any
-from pydantic import BaseModel, Field
+from typing import Annotated, Any
+
 import httpx
+from pydantic import BaseModel, Field
 
 from golf.auth import get_api_key
 
 
 class Output(BaseModel):
     """List of issues from the repository."""
-    issues: List[Dict[str, Any]]
+
+    issues: list[dict[str, Any]]
     total_count: int
 
 
 async def list(
     repo: Annotated[str, Field(description="Repository name in format 'owner/repo'")],
-    state: Annotated[str, Field(description="Filter by state - 'open', 'closed', or 'all'")] = "open",
-    labels: Annotated[Optional[str], Field(description="Comma-separated list of label names to filter by")] = None,
-    per_page: Annotated[int, Field(description="Number of results per page (max 100)")] = 20
+    state: Annotated[
+        str, Field(description="Filter by state - 'open', 'closed', or 'all'")
+    ] = "open",
+    labels: Annotated[
+        str | None,
+        Field(description="Comma-separated list of label names to filter by"),
+    ] = None,
+    per_page: Annotated[
+        int, Field(description="Number of results per page (max 100)")
+    ] = 20,
 ) -> Output:
     """List issues in a repository.
-    
+
     Returns issues with their number, title, state, and other metadata.
     Pull requests are filtered out from the results.
     """
     github_token = get_api_key()
-    
+
     # Validate repo format
-    if '/' not in repo:
+    if "/" not in repo:
         return Output(issues=[], total_count=0)
-    
+
     url = f"https://api.github.com/repos/{repo}/issues"
-    
+
     # Prepare headers
     headers = {
         "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "Golf-GitHub-MCP-Server"
+        "User-Agent": "Golf-GitHub-MCP-Server",
     }
     if github_token:
         headers["Authorization"] = f"Bearer {github_token}"
-    
+
     # Build query parameters
-    params = {
-        "state": state,
-        "per_page": min(per_page, 100)
-    }
+    params = {"state": state, "per_page": min(per_page, 100)}
     if labels:
         params["labels"] = labels
-    
+
     try:
         async with httpx.AsyncClient() as client:
             response = await client.get(
-                url,
-                headers=headers,
-                params=params,
-                timeout=10.0
+                url, headers=headers, params=params, timeout=10.0
             )
-            
+
             response.raise_for_status()
             issues_data = response.json()
-            
+
             # Filter out pull requests and format issues
             issues = []
             for issue in issues_data:
                 # Skip pull requests (they appear in issues endpoint too)
                 if "pull_request" in issue:
                     continue
-                
-                issues.append({
-                    "number": issue["number"],
-                    "title": issue["title"],
-                    "body": issue.get("body", ""),
-                    "state": issue["state"],
-                    "url": issue["html_url"],
-                    "user": issue["user"]["login"],
-                    "labels": [label["name"] for label in issue.get("labels", [])]
-                })
-            
+
+                issues.append(
+                    {
+                        "number": issue["number"],
+                        "title": issue["title"],
+                        "body": issue.get("body", ""),
+                        "state": issue["state"],
+                        "url": issue["html_url"],
+                        "user": issue["user"]["login"],
+                        "labels": [label["name"] for label in issue.get("labels", [])],
+                    }
+                )
+
             return Output(issues=issues, total_count=len(issues))
-            
+
     except Exception:
         return Output(issues=[], total_count=0)
 
 
 # Export the function to be used as the tool
-export = list 
+export = list

golf/examples/api_key/tools/repos/list.py

@@ -1,31 +1,50 @@
 """List GitHub repositories for a user or organization."""
 
-from typing import Annotated, List, Optional, Dict, Any
-from pydantic import BaseModel, Field
+from typing import Annotated, Any
+
 import httpx
+from pydantic import BaseModel, Field
 
 from golf.auth import get_api_key
 
 
 class Output(BaseModel):
     """List of repositories."""
-    repositories: List[Dict[str, Any]]
+
+    repositories: list[dict[str, Any]]
     total_count: int
 
 
 async def list(
-    username: Annotated[Optional[str], Field(description="GitHub username (lists public repos, or all repos if authenticated as this user)")] = None,
-    org: Annotated[Optional[str], Field(description="GitHub organization name (lists public repos, or all repos if authenticated member)")] = None,
-    sort: Annotated[str, Field(description="How to sort results - 'created', 'updated', 'pushed', 'full_name'")] = "updated",
-    per_page: Annotated[int, Field(description="Number of results per page (max 100)")] = 20
+    username: Annotated[
+        str | None,
+        Field(
+            description="GitHub username (lists public repos, or all repos if authenticated as this user)"
+        ),
+    ] = None,
+    org: Annotated[
+        str | None,
+        Field(
+            description="GitHub organization name (lists public repos, or all repos if authenticated member)"
+        ),
+    ] = None,
+    sort: Annotated[
+        str,
+        Field(
+            description="How to sort results - 'created', 'updated', 'pushed', 'full_name'"
+        ),
+    ] = "updated",
+    per_page: Annotated[
+        int, Field(description="Number of results per page (max 100)")
+    ] = 20,
 ) -> Output:
     """List GitHub repositories.
-    
+
     If neither username nor org is provided, lists repositories for the authenticated user.
     """
     # Get the GitHub token from the request context
     github_token = get_api_key()
-    
+
     # Determine the API endpoint
     if org:
         url = f"https://api.github.com/orgs/{org}/repos"
@@ -36,15 +55,15 @@ async def list(
         if not github_token:
             return Output(repositories=[], total_count=0)
         url = "https://api.github.com/user/repos"
-    
+
     # Prepare headers
     headers = {
         "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "Golf-GitHub-MCP-Server"
+        "User-Agent": "Golf-GitHub-MCP-Server",
     }
     if github_token:
         headers["Authorization"] = f"Bearer {github_token}"
-    
+
     try:
         async with httpx.AsyncClient() as client:
             response = await client.get(
@@ -53,30 +72,32 @@ async def list(
                 params={
                     "sort": sort,
                     "per_page": min(per_page, 100),
-                    "type": "all" if not username and not org else None
+                    "type": "all" if not username and not org else None,
                 },
-                timeout=10.0
+                timeout=10.0,
             )
-            
+
             response.raise_for_status()
             repos_data = response.json()
-            
+
             # Format repositories
             repositories = []
             for repo in repos_data:
-                repositories.append({
-                    "name": repo["name"],
-                    "full_name": repo["full_name"],
-                    "description": repo.get("description", ""),
-                    "private": repo.get("private", False),
-                    "stars": repo.get("stargazers_count", 0),
-                    "forks": repo.get("forks_count", 0),
-                    "language": repo.get("language", ""),
-                    "url": repo["html_url"]
-                })
-            
+                repositories.append(
+                    {
+                        "name": repo["name"],
+                        "full_name": repo["full_name"],
+                        "description": repo.get("description", ""),
+                        "private": repo.get("private", False),
+                        "stars": repo.get("stargazers_count", 0),
+                        "forks": repo.get("forks_count", 0),
+                        "language": repo.get("language", ""),
+                        "url": repo["html_url"],
+                    }
+                )
+
             return Output(repositories=repositories, total_count=len(repositories))
-            
+
     except httpx.HTTPStatusError as e:
         if e.response.status_code in [401, 404]:
             return Output(repositories=[], total_count=0)
@@ -87,4 +108,4 @@ async def list(
 
 
 # Export the function to be used as the tool
-export = list 
+export = list

golf/examples/api_key/tools/search/code.py

@@ -1,32 +1,49 @@
 """Search GitHub code."""
 
-from typing import Annotated, List, Optional, Dict, Any
-from pydantic import BaseModel, Field
+from typing import Annotated, Any
+
 import httpx
+from pydantic import BaseModel, Field
 
 from golf.auth import get_api_key
 
 
 class Output(BaseModel):
     """Code search results."""
-    results: List[Dict[str, Any]]
+
+    results: list[dict[str, Any]]
     total_count: int
 
 
 async def search(
-    query: Annotated[str, Field(description="Search query (e.g., 'addClass', 'TODO', etc.)")],
-    language: Annotated[Optional[str], Field(description="Filter by programming language (e.g., 'python', 'javascript')")] = None,
-    repo: Annotated[Optional[str], Field(description="Search within a specific repository (format: 'owner/repo')")] = None,
-    org: Annotated[Optional[str], Field(description="Search within repositories of a specific organization")] = None,
-    per_page: Annotated[int, Field(description="Number of results per page (max 100)")] = 10
+    query: Annotated[
+        str, Field(description="Search query (e.g., 'addClass', 'TODO', etc.)")
+    ],
+    language: Annotated[
+        str | None,
+        Field(
+            description="Filter by programming language (e.g., 'python', 'javascript')"
+        ),
+    ] = None,
+    repo: Annotated[
+        str | None,
+        Field(description="Search within a specific repository (format: 'owner/repo')"),
+    ] = None,
+    org: Annotated[
+        str | None,
+        Field(description="Search within repositories of a specific organization"),
+    ] = None,
+    per_page: Annotated[
+        int, Field(description="Number of results per page (max 100)")
+    ] = 10,
 ) -> Output:
     """Search for code on GitHub.
-    
+
     Without authentication, you're limited to 10 requests per minute.
     With authentication, you can make up to 30 requests per minute.
     """
     github_token = get_api_key()
-    
+
     # Build the search query
     search_parts = [query]
     if language:
@@ -35,54 +52,50 @@ async def search(
         search_parts.append(f"repo:{repo}")
     if org:
         search_parts.append(f"org:{org}")
-    
+
     search_query = " ".join(search_parts)
-    
+
     url = "https://api.github.com/search/code"
-    
+
     # Prepare headers
     headers = {
         "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "Golf-GitHub-MCP-Server"
+        "User-Agent": "Golf-GitHub-MCP-Server",
     }
     if github_token:
         headers["Authorization"] = f"Bearer {github_token}"
-    
+
     try:
         async with httpx.AsyncClient() as client:
             response = await client.get(
                 url,
                 headers=headers,
-                params={
-                    "q": search_query,
-                    "per_page": min(per_page, 100)
-                },
-                timeout=10.0
+                params={"q": search_query, "per_page": min(per_page, 100)},
+                timeout=10.0,
             )
-            
+
             if response.status_code == 403:
                 # Rate limit exceeded
                 return Output(results=[], total_count=0)
-            
+
             response.raise_for_status()
             data = response.json()
-            
+
             # Format results
             results = []
             for item in data.get("items", []):
-                results.append({
-                    "name": item["name"],
-                    "path": item["path"],
-                    "repository": item["repository"]["full_name"],
-                    "url": item["html_url"],
-                    "score": item.get("score", 0.0)
-                })
-            
-            return Output(
-                results=results,
-                total_count=data.get("total_count", 0)
-            )
-            
+                results.append(
+                    {
+                        "name": item["name"],
+                        "path": item["path"],
+                        "repository": item["repository"]["full_name"],
+                        "url": item["html_url"],
+                        "score": item.get("score", 0.0),
+                    }
+                )
+
+            return Output(results=results, total_count=data.get("total_count", 0))
+
     except httpx.HTTPStatusError:
         return Output(results=[], total_count=0)
     except Exception:
@@ -90,4 +103,4 @@ async def search(
 
 
 # Export the function to be used as the tool
-export = search 
+export = search

golf/examples/api_key/tools/users/get.py

@@ -1,28 +1,33 @@
 """Get GitHub user information."""
 
-from typing import Annotated, Optional, Dict, Any
-from pydantic import BaseModel, Field
+from typing import Annotated, Any
+
 import httpx
+from pydantic import BaseModel, Field
 
 from golf.auth import get_api_key
 
 
 class Output(BaseModel):
     """User information result."""
+
     found: bool
-    user: Optional[Dict[str, Any]] = None
+    user: dict[str, Any] | None = None
 
 
 async def get(
-    username: Annotated[Optional[str], Field(description="GitHub username (if not provided, gets authenticated user)")] = None
+    username: Annotated[
+        str | None,
+        Field(description="GitHub username (if not provided, gets authenticated user)"),
+    ] = None,
 ) -> Output:
     """Get information about a GitHub user.
-    
+
     If no username is provided, returns information about the authenticated user.
     This is useful for testing if authentication is working correctly.
     """
     github_token = get_api_key()
-    
+
     # Determine the API endpoint
     if username:
         url = f"https://api.github.com/users/{username}"
@@ -31,26 +36,22 @@ async def get(
         if not github_token:
             return Output(found=False)
         url = "https://api.github.com/user"
-    
+
     # Prepare headers
     headers = {
         "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "Golf-GitHub-MCP-Server"
+        "User-Agent": "Golf-GitHub-MCP-Server",
     }
     if github_token:
         headers["Authorization"] = f"Bearer {github_token}"
-    
+
     try:
         async with httpx.AsyncClient() as client:
-            response = await client.get(
-                url,
-                headers=headers,
-                timeout=10.0
-            )
-            
+            response = await client.get(url, headers=headers, timeout=10.0)
+
             response.raise_for_status()
             user_data = response.json()
-            
+
             return Output(
                 found=True,
                 user={
@@ -64,10 +65,10 @@ async def get(
                     "followers": user_data.get("followers", 0),
                     "following": user_data.get("following", 0),
                     "created_at": user_data["created_at"],
-                    "url": user_data["html_url"]
-                }
+                    "url": user_data["html_url"],
+                },
             )
-            
+
     except httpx.HTTPStatusError as e:
         if e.response.status_code in [401, 404]:
             return Output(found=False)
@@ -78,4 +79,4 @@ async def get(
 
 
 # Export the function to be used as the tool
-export = get 
+export = get

golf/examples/basic/pre_build.py

@@ -16,13 +16,13 @@ github_provider = ProviderConfig(
     token_url="https://github.com/login/oauth/access_token",
     userinfo_url="https://api.github.com/user",
     scopes=["read:user", "user:email"],
-    issuer_url="http://127.0.0.1:3000", # This should be your Golf server's accessible URL
-    callback_path="/auth/callback",     # Golf's callback path
-    token_expiration=3600  # 1 hour
+    issuer_url="http://127.0.0.1:3000",  # This should be your Golf server's accessible URL
+    callback_path="/auth/callback",  # Golf's callback path
+    token_expiration=3600,  # 1 hour
 )
 
 # Configure authentication with the provider
 configure_auth(
     provider=github_provider,
     required_scopes=["read:user"],  # Require read:user scope for protected endpoints
-)
+)