golf-mcp 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

golf/core/transformer.py

@@ -6,21 +6,23 @@ into explicit FastMCP component registrations.
 
 import ast
 from pathlib import Path
-from typing import Dict, Any
+from typing import Any
 
 from golf.core.parser import ParsedComponent
 
 
 class ImportTransformer(ast.NodeTransformer):
     """AST transformer for rewriting imports in component files."""
-    
-    def __init__(self, 
-                 original_path: Path, 
-                 target_path: Path,
-                 import_map: Dict[str, str],
-                 project_root: Path):
+
+    def __init__(
+        self,
+        original_path: Path,
+        target_path: Path,
+        import_map: dict[str, str],
+        project_root: Path,
+    ) -> None:
         """Initialize the import transformer.
-        
+
         Args:
             original_path: Path to the original file
             target_path: Path to the target file
@@ -31,39 +33,35 @@ class ImportTransformer(ast.NodeTransformer):
         self.target_path = target_path
         self.import_map = import_map
         self.project_root = project_root
-    
+
     def visit_Import(self, node: ast.Import) -> Any:
         """Transform import statements."""
         return node
-    
+
     def visit_ImportFrom(self, node: ast.ImportFrom) -> Any:
         """Transform import from statements."""
         if node.module is None:
             return node
-            
+
         # Handle relative imports
         if node.level > 0:
             # Calculate the source module path
             source_dir = self.original_path.parent
             for _ in range(node.level - 1):
                 source_dir = source_dir.parent
-                
+
             if node.module:
                 source_module = source_dir / node.module.replace(".", "/")
             else:
                 source_module = source_dir
-                
+
             # Check if this is a common module import
             source_str = str(source_module.relative_to(self.project_root))
             if source_str in self.import_map:
                 # Replace with absolute import
                 new_module = self.import_map[source_str]
-                return ast.ImportFrom(
-                    module=new_module,
-                    names=node.names,
-                    level=0
-                )
-                
+                return ast.ImportFrom(module=new_module, names=node.names, level=0)
+
         return node
 
 
@@ -71,18 +69,18 @@ def transform_component(
     component: ParsedComponent,
     output_file: Path,
     project_path: Path,
-    import_map: Dict[str, str],
+    import_map: dict[str, str],
     source_file: Path = None,
 ) -> str:
     """Transform a GolfMCP component into a standalone FastMCP component.
-    
+
     Args:
         component: Parsed component to transform
         output_file: Path to write the transformed component to
         project_path: Path to the project root
         import_map: Mapping of original module paths to generated paths
         source_file: Optional path to source file (for common.py files)
-        
+
     Returns:
         Generated component code
     """
@@ -93,43 +91,41 @@ def transform_component(
         file_path = Path(component.file_path)
     else:
         raise ValueError("Either component or source_file must be provided")
-        
-    with open(file_path, "r") as f:
+
+    with open(file_path) as f:
         source_code = f.read()
-        
+
     # Parse the source code into an AST
     tree = ast.parse(source_code)
-    
+
     # Transform imports
-    transformer = ImportTransformer(
-        file_path,
-        output_file,
-        import_map,
-        project_path
-    )
+    transformer = ImportTransformer(file_path, output_file, import_map, project_path)
     tree = transformer.visit(tree)
-    
+
     # Get all imports and docstring
     imports = []
     docstring = None
-    
+
     # Find the module docstring if present
-    if (len(tree.body) > 0 and isinstance(tree.body[0], ast.Expr) and 
-        isinstance(tree.body[0].value, ast.Constant) and 
-        isinstance(tree.body[0].value.value, str)):
+    if (
+        len(tree.body) > 0
+        and isinstance(tree.body[0], ast.Expr)
+        and isinstance(tree.body[0].value, ast.Constant)
+        and isinstance(tree.body[0].value.value, str)
+    ):
         docstring = tree.body[0].value.value
-    
+
     # Find imports
     for node in tree.body:
-        if isinstance(node, (ast.Import, ast.ImportFrom)):
+        if isinstance(node, ast.Import | ast.ImportFrom):
             imports.append(node)
-    
-   # Generate the transformed code
+
+    # Generate the transformed code
     transformed_imports = ast.unparse(ast.Module(body=imports, type_ignores=[]))
-    
+
     # Build full transformed code
     transformed_code = transformed_imports + "\n\n"
-    
+
     # Add docstring if present, using proper triple quotes for multi-line docstrings
     if docstring:
         # Check if docstring contains newlines
@@ -139,30 +135,32 @@ def transform_component(
         else:
             # Use single quotes for single-line docstrings
             transformed_code += f'"{docstring}"\n\n'
-    
+
     # Add the rest of the code except imports and the original docstring
     remaining_nodes = []
     for node in tree.body:
         # Skip imports
-        if isinstance(node, (ast.Import, ast.ImportFrom)):
+        if isinstance(node, ast.Import | ast.ImportFrom):
             continue
-            
+
         # Skip the original docstring
-        if (isinstance(node, ast.Expr) and 
-            isinstance(node.value, ast.Constant) and 
-            isinstance(node.value.value, str)):
+        if (
+            isinstance(node, ast.Expr)
+            and isinstance(node.value, ast.Constant)
+            and isinstance(node.value.value, str)
+        ):
             continue
-            
+
         remaining_nodes.append(node)
-        
+
     remaining_code = ast.unparse(ast.Module(body=remaining_nodes, type_ignores=[]))
     transformed_code += remaining_code
-    
+
     # Ensure the directory exists
     output_file.parent.mkdir(parents=True, exist_ok=True)
-    
+
     # Write the transformed code to the output file
     with open(output_file, "w") as f:
         f.write(transformed_code)
-    
-    return transformed_code
+
+    return transformed_code

golf/examples/__init__.py

@@ -1 +0,0 @@
- 

golf/examples/api_key/pre_build.py

@@ -7,5 +7,5 @@ from golf.auth import configure_api_key
 configure_api_key(
     header_name="Authorization",
     header_prefix="Bearer ",  # Will handle both "Bearer " and "token " prefixes
-    required=True  # Reject requests without a valid API key
-)
+    required=True,  # Reject requests without a valid API key
+)

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