golf-mcp 0.1.11__py3-none-any.whl → 0.1.13__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, track_command
+from golf.core.telemetry import track_command, track_event
 
 console = Console()
 
@@ -20,7 +18,7 @@ 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
@@ -32,45 +30,60 @@ def initialize_project(
         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_command(
+                "init",
+                success=False,
+                error_type="InvalidTemplate",
+                error_message=f"Unknown template: {template}",
+            )
             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."
                 )
-                track_command("init", success=False, error_type="NotADirectory", error_message="Target 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()):
-                if 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
+            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():
             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}")
+            track_command(
+                "init",
+                success=False,
+                error_type="TemplateNotFound",
+                error_message=f"Template directory not found: {template}",
+            )
             return
-        
+
         # Copy template files
         with Progress(
             SpinnerColumn(),
@@ -78,36 +91,37 @@ def initialize_project(
             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("\nTo get started, run:")
         console.print(f"  cd {output_dir.name}")
-        console.print(f"  golf build dev")
-        
+        console.print("  golf build dev")
+
         # Track successful initialization
-        track_event("cli_init_success", {
-            "success": True,
-            "template": template
-        })
+        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 during initialization:[/bold red] {error_message}")
-        track_command("init", success=False, error_type=error_type, error_message=error_message)
-        
+
+        console.print(
+            f"[bold red]Error during initialization:[/bold red] {error_message}"
+        )
+        track_command(
+            "init", success=False, error_type=error_type, error_message=error_message
+        )
+
         # 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
@@ -117,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():
@@ -193,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,25 @@ def run_server(
             cwd=dist_dir,
             env=env,
         )
-        
+
+        # Provide more context about the exit
+        if process.returncode == 0:
+            console.print("[green]Server stopped successfully[/green]")
+        elif process.returncode == 130:
+            console.print("[yellow]Server stopped by user interrupt (Ctrl+C)[/yellow]")
+        elif process.returncode == 143:
+            console.print("[yellow]Server stopped by SIGTERM (graceful shutdown)[/yellow]")
+        elif process.returncode == 137:
+            console.print("[yellow]Server stopped by SIGKILL (forced shutdown)[/yellow]")
+        elif process.returncode in [1, 2]:
+            console.print(f"[red]Server exited with error code {process.returncode}[/red]")
+        else:
+            console.print(f"[orange]Server exited with code {process.returncode}[/orange]")
+
         return process.returncode
     except KeyboardInterrupt:
-        console.print("\n[yellow]Server stopped by user[/yellow]")
-        return 0
+        console.print("\n[yellow]Server stopped by user (Ctrl+C)[/yellow]")
+        return 130  # Standard exit code for SIGINT
     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."""