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

golf/commands/build.py

@@ -4,26 +4,26 @@ This module implements the `golf build` command which generates a standalone
 FastMCP application from a GolfMCP project.
 """
 
-from pathlib import Path
 import argparse
+from pathlib import Path
 
 from rich.console import Console
 
-from golf.core.config import Settings, load_settings
 from golf.core.builder import build_project as core_build_project
+from golf.core.config import Settings, load_settings
 
 console = Console()
 
 
 def build_project(
-    project_path: Path, 
-    settings: Settings, 
+    project_path: Path,
+    settings: Settings,
     output_dir: Path,
     build_env: str = "prod",
-    copy_env: bool = False
+    copy_env: bool = False,
 ) -> None:
     """Build a standalone FastMCP application from a GolfMCP project.
-    
+
     Args:
         project_path: Path to the project root
         settings: Project settings
@@ -32,47 +32,53 @@ def build_project(
         copy_env: Whether to copy environment variables to the built app
     """
     # Call the centralized build function from core.builder
-    core_build_project(project_path, settings, output_dir, build_env=build_env, copy_env=copy_env)
+    core_build_project(
+        project_path, settings, output_dir, build_env=build_env, copy_env=copy_env
+    )
 
 
 # Add a main section to run the build_project function when this module is executed directly
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Build a standalone FastMCP application")
+    parser = argparse.ArgumentParser(
+        description="Build a standalone FastMCP application"
+    )
     parser.add_argument(
-        "--project-path", "-p", 
-        type=Path, 
+        "--project-path",
+        "-p",
+        type=Path,
         default=Path.cwd(),
-        help="Path to the project root (default: current directory)"
+        help="Path to the project root (default: current directory)",
     )
     parser.add_argument(
-        "--output-dir", "-o", 
-        type=Path, 
+        "--output-dir",
+        "-o",
+        type=Path,
         default=Path.cwd() / "dist",
-        help="Directory to output the built project (default: ./dist)"
+        help="Directory to output the built project (default: ./dist)",
     )
     parser.add_argument(
         "--build-env",
         type=str,
         default="prod",
         choices=["dev", "prod"],
-        help="Build environment to use (default: prod)"
+        help="Build environment to use (default: prod)",
     )
     parser.add_argument(
         "--copy-env",
         action="store_true",
-        help="Copy environment variables to the built application"
+        help="Copy environment variables to the built application",
     )
-    
+
     args = parser.parse_args()
-    
+
     # Load settings from the project path
     settings = load_settings(args.project_path)
-    
+
     # Execute the build
     build_project(
-        args.project_path, 
-        settings, 
-        args.output_dir, 
-        build_env=args.build_env, 
-        copy_env=args.copy_env
-    ) 
+        args.project_path,
+        settings,
+        args.output_dir,
+        build_env=args.build_env,
+        copy_env=args.copy_env,
+    )

golf/commands/init.py

@@ -1,15 +1,13 @@
 """Project initialization command implementation."""
 
-import os
 import shutil
 from pathlib import Path
-from typing import Optional
 
 from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
-from golf.core.telemetry import track_event
+from golf.core.telemetry import track_command, track_event
 
 console = Console()
 
@@ -20,83 +18,110 @@ def initialize_project(
     template: str = "basic",
 ) -> None:
     """Initialize a new GolfMCP project with the specified template.
-    
+
     Args:
         project_name: Name of the project
         output_dir: Directory where the project will be created
         template: Template to use (basic or api_key)
     """
-    # Validate template
-    valid_templates = ("basic", "api_key")
-    if template not in valid_templates:
-        console.print(f"[bold red]Error:[/bold red] Unknown template '{template}'")
-        console.print(f"Available templates: {', '.join(valid_templates)}")
-        track_event("cli_init_failed", {"success": False})
-        return
-    
-    # Check if directory exists
-    if output_dir.exists():
-        if not output_dir.is_dir():
-            console.print(
-                f"[bold red]Error:[/bold red] '{output_dir}' exists but is not a directory."
+    try:
+        # Validate template
+        valid_templates = ("basic", "api_key")
+        if template not in valid_templates:
+            console.print(f"[bold red]Error:[/bold red] Unknown template '{template}'")
+            console.print(f"Available templates: {', '.join(valid_templates)}")
+            track_command(
+                "init",
+                success=False,
+                error_type="InvalidTemplate",
+                error_message=f"Unknown template: {template}",
             )
-            track_event("cli_init_failed", {"success": False})
             return
-        
-        # Check if directory is empty
-        if any(output_dir.iterdir()):
-            if not Confirm.ask(
+
+        # Check if directory exists
+        if output_dir.exists():
+            if not output_dir.is_dir():
+                console.print(
+                    f"[bold red]Error:[/bold red] '{output_dir}' exists but is not a directory."
+                )
+                track_command(
+                    "init",
+                    success=False,
+                    error_type="NotADirectory",
+                    error_message="Target exists but is not a directory",
+                )
+                return
+
+            # Check if directory is empty
+            if any(output_dir.iterdir()) and not Confirm.ask(
                 f"Directory '{output_dir}' is not empty. Continue anyway?",
                 default=False,
             ):
                 console.print("Initialization cancelled.")
                 track_event("cli_init_cancelled", {"success": False})
                 return
-    else:
-        # Create the directory
-        output_dir.mkdir(parents=True)
-    
-    # Find template directory within the installed package
-    import golf
-    package_init_file = Path(golf.__file__)
-    # The 'examples' directory is now inside the 'golf' package directory
-    # e.g. golf/examples/basic, so go up one from __init__.py to get to 'golf'
-    template_dir = package_init_file.parent / "examples" / template
-    
-    if not template_dir.exists():
+        else:
+            # Create the directory
+            output_dir.mkdir(parents=True)
+
+        # Find template directory within the installed package
+        import golf
+
+        package_init_file = Path(golf.__file__)
+        # The 'examples' directory is now inside the 'golf' package directory
+        # e.g. golf/examples/basic, so go up one from __init__.py to get to 'golf'
+        template_dir = package_init_file.parent / "examples" / template
+
+        if not template_dir.exists():
+            console.print(
+                f"[bold red]Error:[/bold red] Could not find template '{template}'"
+            )
+            track_command(
+                "init",
+                success=False,
+                error_type="TemplateNotFound",
+                error_message=f"Template directory not found: {template}",
+            )
+            return
+
+        # Copy template files
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold green]Creating project structure...[/bold green]"),
+            transient=True,
+        ) as progress:
+            progress.add_task("copying", total=None)
+
+            # Copy directory structure
+            _copy_template(template_dir, output_dir, project_name)
+
+        # Create virtual environment
+        console.print("[bold green]Project initialized successfully![/bold green]")
+        console.print("\nTo get started, run:")
+        console.print(f"  cd {output_dir.name}")
+        console.print("  golf build dev")
+
+        # Track successful initialization
+        track_event("cli_init_success", {"success": True, "template": template})
+    except Exception as e:
+        # Capture error details for telemetry
+        error_type = type(e).__name__
+        error_message = str(e)
+
         console.print(
-            f"[bold red]Error:[/bold red] Could not find template '{template}'"
+            f"[bold red]Error during initialization:[/bold red] {error_message}"
+        )
+        track_command(
+            "init", success=False, error_type=error_type, error_message=error_message
         )
-        track_event("cli_init_failed", {"success": False})
-        return
-    
-    # Copy template files
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[bold green]Creating project structure...[/bold green]"),
-        transient=True,
-    ) as progress:
-        progress.add_task("copying", total=None)
-        
-        # Copy directory structure
-        _copy_template(template_dir, output_dir, project_name)
-    
-    # Create virtual environment
-    console.print("[bold green]Project initialized successfully![/bold green]")
-    console.print(f"\nTo get started, run:")
-    console.print(f"  cd {output_dir.name}")
-    console.print(f"  golf build dev")
-    
-    # Track successful initialization
-    track_event("cli_init_success", {
-        "success": True,
-        "template": template
-    })
+
+        # Re-raise to maintain existing behavior
+        raise
 
 
 def _copy_template(source_dir: Path, target_dir: Path, project_name: str) -> None:
     """Copy template files to the target directory, with variable substitution.
-    
+
     Args:
         source_dir: Source template directory
         target_dir: Target project directory
@@ -106,42 +131,44 @@ def _copy_template(source_dir: Path, target_dir: Path, project_name: str) -> Non
     (target_dir / "tools").mkdir(exist_ok=True)
     (target_dir / "resources").mkdir(exist_ok=True)
     (target_dir / "prompts").mkdir(exist_ok=True)
-    
+
     # Copy all files from the template
     for source_path in source_dir.glob("**/*"):
         # Skip if directory (we'll create directories as needed)
         if source_path.is_dir():
             continue
-        
+
         # Compute relative path
         rel_path = source_path.relative_to(source_dir)
         target_path = target_dir / rel_path
-        
+
         # Create parent directories if needed
         target_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         # Copy and substitute content for text files
         if _is_text_file(source_path):
-            with open(source_path, "r", encoding="utf-8") as f:
+            with open(source_path, encoding="utf-8") as f:
                 content = f.read()
-            
+
             # Replace template variables
             content = content.replace("{{project_name}}", project_name)
-            content = content.replace("{{project_name_lowercase}}", project_name.lower())
-            
+            content = content.replace(
+                "{{project_name_lowercase}}", project_name.lower()
+            )
+
             with open(target_path, "w", encoding="utf-8") as f:
                 f.write(content)
         else:
             # Binary file, just copy
             shutil.copy2(source_path, target_path)
-    
+
     # Create .env file
     env_file = target_dir / ".env"
     with open(env_file, "w", encoding="utf-8") as f:
         f.write(f"GOLF_NAME={project_name}\n")
         f.write("GOLF_HOST=127.0.0.1\n")
         f.write("GOLF_PORT=3000\n")
-    
+
     # Create a .gitignore if it doesn't exist
     gitignore_file = target_dir / ".gitignore"
     if not gitignore_file.exists():
@@ -182,31 +209,43 @@ def _copy_template(source_dir: Path, target_dir: Path, project_name: str) -> Non
 
 def _is_text_file(path: Path) -> bool:
     """Check if a file is a text file that needs variable substitution.
-    
+
     Args:
         path: Path to check
-        
+
     Returns:
         True if the file is a text file
     """
     # List of known text file extensions
     text_extensions = {
-        ".py", ".md", ".txt", ".html", ".css", ".js", ".json", 
-        ".yml", ".yaml", ".toml", ".ini", ".cfg", ".env", ".example"
+        ".py",
+        ".md",
+        ".txt",
+        ".html",
+        ".css",
+        ".js",
+        ".json",
+        ".yml",
+        ".yaml",
+        ".toml",
+        ".ini",
+        ".cfg",
+        ".env",
+        ".example",
     }
-    
+
     # Check if the file has a text extension
     if path.suffix in text_extensions:
         return True
-    
+
     # Check specific filenames without extensions
     if path.name in {".gitignore", "README", "LICENSE"}:
         return True
-    
+
     # Try to detect if it's a text file by reading a bit of it
     try:
-        with open(path, "r", encoding="utf-8") as f:
+        with open(path, encoding="utf-8") as f:
             f.read(1024)
         return True
     except UnicodeDecodeError:
-        return False 
+        return False

golf/commands/run.py

@@ -4,7 +4,6 @@ import os
 import subprocess
 import sys
 from pathlib import Path
-from typing import Optional
 
 from rich.console import Console
 
@@ -16,44 +15,46 @@ console = Console()
 def run_server(
     project_path: Path,
     settings: Settings,
-    dist_dir: Optional[Path] = None,
-    host: Optional[str] = None,
-    port: Optional[int] = None,
+    dist_dir: Path | None = None,
+    host: str | None = None,
+    port: int | None = None,
 ) -> int:
     """Run the built FastMCP server.
-    
+
     Args:
         project_path: Path to the project root
         settings: Project settings
         dist_dir: Path to the directory containing the built server (defaults to project_path/dist)
         host: Host to bind the server to (overrides settings)
         port: Port to bind the server to (overrides settings)
-        
+
     Returns:
         Process return code
     """
     # Set default dist directory if not specified
     if dist_dir is None:
         dist_dir = project_path / "dist"
-    
+
     # Check if server file exists
     server_path = dist_dir / "server.py"
     if not server_path.exists():
-        console.print(f"[bold red]Error: Server file {server_path} not found.[/bold red]")
+        console.print(
+            f"[bold red]Error: Server file {server_path} not found.[/bold red]"
+        )
         return 1
-    
+
     # Prepare environment variables
     env = os.environ.copy()
     if host is not None:
         env["HOST"] = host
     elif settings.host:
         env["HOST"] = settings.host
-        
+
     if port is not None:
         env["PORT"] = str(port)
     elif settings.port:
         env["PORT"] = str(settings.port)
-    
+
     # Run the server
     try:
         # Using subprocess to properly handle signals (Ctrl+C)
@@ -62,11 +63,11 @@ def run_server(
             cwd=dist_dir,
             env=env,
         )
-        
+
         return process.returncode
     except KeyboardInterrupt:
         console.print("\n[yellow]Server stopped by user[/yellow]")
         return 0
     except Exception as e:
         console.print(f"\n[bold red]Error running server:[/bold red] {e}")
-        return 1 
+        return 1

golf/core/__init__.py

@@ -1 +1 @@
-"""Core functionality for the GolfMCP framework.""" 
+"""Core functionality for the GolfMCP framework."""