golf-mcp 0.1.0__py3-none-any.whl

golf/core/builder_auth.py

@@ -0,0 +1,157 @@
+"""Authentication integration for the GolfMCP build process.
+
+This module adds support for injecting authentication configuration
+into the generated FastMCP application during the build process.
+"""
+
+from golf.auth import get_auth_config
+
+
+def generate_auth_code(server_name: str, host: str = "127.0.0.1", port: int = 3000, https: bool = False) -> str:
+    """Generate code for setting up authentication in the FastMCP app.
+    This code string will be injected into the generated server.py and executed at its runtime.
+    """
+    original_provider_config, required_scopes_from_config = get_auth_config()
+    
+    if not original_provider_config:
+        # If no auth config from pre_build.py, just generate basic FastMCP instantiation
+        return f"mcp = FastMCP({repr(server_name)}) # No authentication configured"
+
+    # This list will hold lines of Python code to be written into server.py
+    generated_code_lines = []
+
+    # Imports needed at the top of server.py for the auth setup block
+    # Note: FastMCP itself is imported by the main server generation logic later.
+    generated_code_lines.extend([
+        "import os",
+        "import sys  # For stderr output",
+        "from mcp.server.auth.settings import AuthSettings, ClientRegistrationOptions",
+        "from golf.auth.provider import ProviderConfig as GolfProviderConfigInternal # Alias to avoid conflict if user also has ProviderConfig",
+        "from golf.auth.oauth import GolfOAuthProvider",
+        "# get_access_token and create_callback_handler are used by generated auth_routes",
+        "from golf.auth import get_access_token, create_callback_handler",
+        "",
+    ])
+
+    # Code to determine runtime server address configuration
+    generated_code_lines.extend([
+        "# Determine runtime server address configuration",
+        f"runtime_host = os.environ.get('HOST', {repr(host)})",
+        f"runtime_port = int(os.environ.get('PORT', {repr(port)}))",
+        f"runtime_protocol = 'https' if os.environ.get('HTTPS', {repr(str(https)).lower()}).lower() in ('1', 'true', 'yes') else 'http'",
+        "",
+        "# Determine proper issuer URL at runtime for this server instance",
+        "include_port = (runtime_protocol == 'http' and runtime_port != 80) or (runtime_protocol == 'https' and runtime_port != 443)",
+        "if include_port:",
+        "    runtime_issuer_url = f'{runtime_protocol}://{runtime_host}:{runtime_port}'",
+        "else:",
+        "    runtime_issuer_url = f'{runtime_protocol}://{runtime_host}'",
+        "",
+    ])
+
+    # Code to load secrets from environment variables AT RUNTIME in server.py
+    generated_code_lines.extend([
+        "# Load secrets from environment variables using names specified in pre_build.py ProviderConfig",
+        f"runtime_client_id = os.environ.get({repr(original_provider_config.client_id_env_var)})",
+        f"runtime_client_secret = os.environ.get({repr(original_provider_config.client_secret_env_var)})",
+        f"runtime_jwt_secret = os.environ.get({repr(original_provider_config.jwt_secret_env_var)})",
+        "",
+        "# Check and warn if essential secrets are missing",
+        "if not runtime_client_id:",
+        f"    print(f\"AUTH WARNING: Environment variable '{original_provider_config.client_id_env_var}' for OAuth Client ID is not set. Authentication will likely fail.\", file=sys.stderr)",
+        "if not runtime_client_secret:",
+        f"    print(f\"AUTH WARNING: Environment variable '{original_provider_config.client_secret_env_var}' for OAuth Client Secret is not set. Authentication will likely fail.\", file=sys.stderr)",
+        "if not runtime_jwt_secret:",
+        f"    print(f\"AUTH WARNING: Environment variable '{original_provider_config.jwt_secret_env_var}' for JWT Secret is not set. Using a default insecure fallback. DO NOT USE IN PRODUCTION.\", file=sys.stderr)",
+        f"    runtime_jwt_secret = {repr(f'fallback-dev-jwt-secret-for-{server_name}-!PLEASE-CHANGE-THIS!')}", # Fixed fallback string
+        "",
+    ])
+
+    # Code to instantiate ProviderConfig using runtime-loaded secrets and other baked-in non-secrets
+    generated_code_lines.extend([
+        "# Instantiate ProviderConfig with runtime-resolved secrets and other pre-configured values",
+        f"provider_config_instance = GolfProviderConfigInternal(", # Use aliased import
+        f"    provider={repr(original_provider_config.provider)},",
+        f"    client_id_env_var={repr(original_provider_config.client_id_env_var)},",
+        f"    client_secret_env_var={repr(original_provider_config.client_secret_env_var)},",
+        f"    jwt_secret_env_var={repr(original_provider_config.jwt_secret_env_var)},",
+        f"    client_id=runtime_client_id,",
+        f"    client_secret=runtime_client_secret,",
+        f"    jwt_secret=runtime_jwt_secret,",
+        f"    authorize_url={repr(original_provider_config.authorize_url)},",
+        f"    token_url={repr(original_provider_config.token_url)},",
+        f"    userinfo_url={repr(original_provider_config.userinfo_url)},",
+        f"    jwks_uri={repr(original_provider_config.jwks_uri)},",
+        f"    scopes={repr(original_provider_config.scopes)},",
+        f"    issuer_url=runtime_issuer_url,",
+        f"    callback_path={repr(original_provider_config.callback_path)},",
+        f"    token_expiration={original_provider_config.token_expiration}",
+        ")",
+        "",
+        "auth_provider = GolfOAuthProvider(provider_config_instance)",
+        "from golf.auth.helpers import _set_active_golf_oauth_provider  # Ensure helper is imported",
+        "_set_active_golf_oauth_provider(auth_provider)  # Make provider instance available",
+        "",
+    ])
+
+    # AuthSettings and FastMCP instantiation
+    generated_code_lines.extend([
+        "# Create auth settings for FastMCP",
+        "auth_settings = AuthSettings(",
+        "    issuer_url=runtime_issuer_url,",
+        "    client_registration_options=ClientRegistrationOptions(",
+        "        enabled=True,",
+        f"        valid_scopes={repr(original_provider_config.scopes)},",
+        f"        default_scopes={repr(original_provider_config.scopes)}",
+        "    ),",
+        f"    required_scopes={repr(required_scopes_from_config) if required_scopes_from_config else None}",
+        ")",
+        "",
+        "# Create FastMCP instance with auth configuration",
+        f"mcp = FastMCP({repr(server_name)}, auth_server_provider=auth_provider, auth=auth_settings)"
+    ])
+    
+    return "\n".join(generated_code_lines)
+
+
+def generate_auth_routes() -> str:
+    """Generate code for OAuth routes in the FastMCP app.
+    These routes are added to the FastMCP instance (`mcp`) created by `generate_auth_code`.
+    """
+    provider_config, _ = get_auth_config() # Used to check if auth is enabled generally
+    if not provider_config:
+        return ""
+        
+    auth_routes_list = [
+        "",
+        "# Auth-specific routes, using the 'auth_provider' instance defined in the auth setup code",
+        "@mcp.custom_route('/auth/callback', methods=['GET'])",
+        "async def oauth_callback(request):",
+        "    # create_callback_handler is imported in the auth setup code block",
+        "    handler = create_callback_handler(auth_provider)", 
+        "    return await handler(request)",
+        "",
+        "@mcp.custom_route('/login', methods=['GET'])",
+        "async def login(request):",
+        "    from starlette.responses import RedirectResponse",
+        "    import urllib.parse",
+        "    default_redirect_uri = urllib.parse.quote_plus(\"http://localhost:5173/callback\")",
+        "    authorize_url = f\"/mcp/auth/authorize?client_id=default&response_type=code&redirect_uri={default_redirect_uri}\"",
+        "    return RedirectResponse(authorize_url)",
+        "",
+        "@mcp.custom_route('/auth-error', methods=['GET'])",
+        "async def auth_error(request):",
+        "    from starlette.responses import HTMLResponse",
+        "    error = request.query_params.get('error', 'unknown_error')",
+        "    error_desc = request.query_params.get('error_description', 'An authentication error occurred')",
+        "    html_content = f\"\"\"",
+        "    <!DOCTYPE html>",
+        "    <html><head><title>Authentication Error</title>",
+        "    <style> body {{ font-family: system-ui, sans-serif; padding: 2rem; max-width: 600px; margin: auto; }} h1 {{ color: #c53030; }} .error-box {{ background-color: #fed7d7; border: 1px solid #f56565; border-radius: 0.25rem; padding: 1rem; margin: 1rem 0; }} .btn {{ background-color: #4299e1; color: white; border: none; padding: 0.5rem 1rem; border-radius: 0.25rem; cursor: pointer; text-decoration: none; display: inline-block; margin-top: 1rem; }} .btn:hover {{ background-color: #2b6cb0; }} </style>",
+        "    </head><body><h1>Authentication Failed</h1><div class='error-box'>",
+        "    <p><strong>Error:</strong> {error}</p><p><strong>Description:</strong> {error_desc}</p></div>",
+        "    <a href='/login' class='btn'>Try Again</a></body></html>\"\"\"",
+        "    return HTMLResponse(content=html_content)",
+        "",
+    ]
+    return "\n".join(auth_routes_list) 

golf/core/builder_telemetry.py

@@ -0,0 +1,208 @@
+"""OpenTelemetry integration for the GolfMCP build process.
+
+This module provides functions for generating OpenTelemetry initialization
+and instrumentation code for FastMCP servers built with GolfMCP.
+"""
+
+from golf import __version__
+
+def generate_otel_lifespan_code(default_exporter: str = "console", project_name: str = "UnknownGolfService") -> str:
+    """Generate code for the OpenTelemetry lifespan function.
+    
+    Args:
+        default_exporter: Default exporter type to use if OTEL_TRACES_EXPORTER is not set
+        project_name: The name of the project, used as default for OTEL_SERVICE_NAME
+        
+    Returns:
+        Python code string for the OpenTelemetry lifespan function
+    """
+    return f"""
+# --- OpenTelemetry Lifespan Start ---
+# These variables are global within the generated server.py module scope
+_golf_otel_provider_global = None
+_golf_otel_initialized_flag = False
+
+from contextlib import asynccontextmanager
+import os
+import sys
+import logging
+from opentelemetry import trace
+from opentelemetry.trace import NoOpTracerProvider
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+from opentelemetry.sdk.resources import Resource as OtelResource
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+
+# Optional: Configure OpenTelemetry's own logger to be less verbose
+# logging.getLogger('opentelemetry').setLevel(logging.WARNING)
+
+@asynccontextmanager
+async def otel_lifespan(app): # 'app' is the FastMCP instance passed by _lifespan_wrapper
+    global _golf_otel_provider_global, _golf_otel_initialized_flag
+
+    # These will be resolved when otel_lifespan runs in the generated server.py
+    # .format() inserts build-time fallbacks {project_name} and {default_exporter}
+    service_name_to_use = os.environ.get("OTEL_SERVICE_NAME", "{project_name}")
+    exporter_type_to_use = os.environ.get("OTEL_TRACES_EXPORTER", "{default_exporter}").lower()
+    
+    # Local variable for the provider created in this specific call, if any.
+    local_provider_instance_for_shutdown = None
+
+    try:
+        if not _golf_otel_initialized_flag:
+            # Double check if a real provider is already globally set by another mechanism
+            # trace.get_tracer_provider() returns a NoOpTracerProvider by default.
+            current_global_otel_provider = trace.get_tracer_provider()
+            if isinstance(current_global_otel_provider, NoOpTracerProvider):
+                print(f"[OTel] Initializing OpenTelemetry Globals (service={{service_name_to_use}}, exporter={{exporter_type_to_use}})...", file=sys.stderr)
+                
+                resource = OtelResource.create({{"service.name": service_name_to_use}})
+                provider_to_set = TracerProvider(resource=resource)
+                
+                exporter = None
+                if exporter_type_to_use == "otlp_http":
+                    endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
+                    exporter = OTLPSpanExporter(endpoint=endpoint) if endpoint else OTLPSpanExporter()
+                else: # Default to console
+                    exporter = ConsoleSpanExporter(out=sys.stderr) # Ensure console output goes to stderr
+                    
+                processor = BatchSpanProcessor(exporter)
+                provider_to_set.add_span_processor(processor)
+                
+                trace.set_tracer_provider(provider_to_set)
+                _golf_otel_provider_global = provider_to_set # Store it globally
+                _golf_otel_initialized_flag = True
+                local_provider_instance_for_shutdown = provider_to_set # Mark for shutdown by this invocation
+                print(f"[OTel] Global OpenTelemetry provider SET (service={{service_name_to_use}}, exporter={{exporter_type_to_use}})", file=sys.stderr)
+            else:
+                # A real provider is already set globally. Do not override.
+                # Assign it to _golf_otel_provider_global if not already assigned, for consistency,
+                # but don't mark it for shutdown by this specific lifespan invocation.
+                if _golf_otel_provider_global is None:
+                    _golf_otel_provider_global = current_global_otel_provider
+                _golf_otel_initialized_flag = True # Mark as initialized to prevent re-entry by this mechanism
+                print(f"[OTel] Global OpenTelemetry provider was ALREADY SET by another mechanism. Using existing.", file=sys.stderr)
+        else:
+            # print(f"[OTel Lifespan DEBUG] Already initialized by this mechanism. Yielding.", file=sys.stderr)
+            pass # Already initialized by this mechanism in a previous entry
+
+        yield {{}} # Application runs here
+        
+    except Exception as e:
+        print("[OTel] ERROR during OpenTelemetry setup/yield: " + str(e), file=sys.stderr)
+        import traceback
+        print(traceback.format_exc(), file=sys.stderr)
+        raise 
+    finally:
+        # Only the instance of otel_lifespan that successfully initialized the provider
+        # should be responsible for its shutdown.
+        if local_provider_instance_for_shutdown:
+            # print(f"[OTel Lifespan DEBUG] Shutting down OTel Provider for service={{service_name_to_use}}.", file=sys.stderr)
+            local_provider_instance_for_shutdown.shutdown()
+            _golf_otel_initialized_flag = False # Allow re-init if server process truly restarts
+            _golf_otel_provider_global = None
+            print("[OTel] Provider shut down by this lifespan instance.", file=sys.stderr)
+# --- OpenTelemetry Lifespan End ---
+"""
+
+def generate_otel_instrumentation_code() -> str:
+    """Generate code for instrumenting the FastMCP instance.
+    
+    Returns:
+        Python code string for instrumenting FastMCP methods
+    """
+    return f"""
+# Instrument FastMCP instance
+import wrapt
+import json
+import sys # For debug prints
+from opentelemetry import trace as otel_trace
+from opentelemetry.trace import SpanKind, Status, StatusCode
+
+print("[OTel Instrumentation] Applying FastMCP method wrappers...", file=sys.stderr)
+
+# Create a tracer for the instrumentation
+otel_tracer = otel_trace.get_tracer("golfmcp.fastmcp", "{__version__}")
+print(f"[OTel Instrumentation] Acquired tracer: {{str(otel_tracer)}}", file=sys.stderr)
+
+def otel_operation_wrapper(operation_name_suffix):
+    def wrapper(wrapped, instance, args, kwargs):
+        component_name = args[0] if args else "unknown"
+        span_name = "mcp." + operation_name_suffix
+        # print(f"[OTel Instrumentation DEBUG] Wrapping: {{instance.name}}.{{operation_name_suffix}} for component: {{component_name}}", file=sys.stderr)
+        
+        with otel_tracer.start_as_current_span(span_name, kind=SpanKind.SERVER) as span:
+            # print(f"[OTel Instrumentation DEBUG] Started span: {{span_name}}, Trace ID: {{span.get_span_context().trace_id}}", file=sys.stderr)
+            span.set_attribute("rpc.system", "mcp")
+            span.set_attribute("rpc.method", operation_name_suffix)
+            span.set_attribute("rpc.service", instance.name)
+            
+            # Set operation-specific attributes
+            if component_name != "unknown":
+                component_type = operation_name_suffix.split("_")[1] if "_" in operation_name_suffix else "component"
+                span.set_attribute("mcp." + component_type + ".name", str(component_name))
+            
+            # For call_tool, add parameters (carefully, to avoid sensitive data)
+            if operation_name_suffix == "call_tool" and len(args) > 1 and args[1]:
+                try:
+                    params_str = json.dumps(args[1])
+                    # Truncate long parameter strings to avoid huge spans
+                    span.set_attribute("mcp.request.arguments", params_str[:1024] if len(params_str) > 1024 else params_str)
+                except Exception:
+                    span.set_attribute("mcp.request.arguments", "[serialization_error]")
+            
+            try:
+                # Call the original method
+                result = wrapped(*args, **kwargs)
+                
+                # Set success status
+                span.set_status(Status(StatusCode.OK))
+                
+                # Add result count for list operations
+                if "list" in operation_name_suffix and isinstance(result, list):
+                    span.set_attribute("mcp.response.count", len(result))
+                
+                return result
+            except Exception as e:
+                # Record the exception and set error status
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
+    
+    return wrapper
+
+# Define the methods to instrument
+methods_to_patch = [
+    ("_mcp_call_tool", "call_tool"),
+    ("_mcp_read_resource", "read_resource"),
+    ("_mcp_get_prompt", "get_prompt"),
+    ("_mcp_list_tools", "list_tools"),
+    ("_mcp_list_resources", "list_resources"),
+    ("_mcp_list_resource_templates", "list_resource_templates"),
+    ("_mcp_list_prompts", "list_prompts")
+]
+
+# Apply instrumentation to each method
+# This code runs in server.py *after* 'mcp' is defined.
+# The 'mcp' variable needs to be in the scope where this instrumentation code is placed.
+for method_name, operation_suffix in methods_to_patch:
+    if hasattr(mcp, method_name): # 'mcp' should be the FastMCP instance
+        # print(f"[OTel Instrumentation DEBUG] Patching {{method_name}} on {{mcp}}", file=sys.stderr)
+        wrapt.wrap_function_wrapper(mcp, method_name, otel_operation_wrapper(operation_name_suffix))
+
+print("[OTel Instrumentation] MCP method instrumentation attempted.", file=sys.stderr)
+"""
+
+def get_otel_dependencies() -> list[str]:
+    """Get list of OpenTelemetry dependencies to add to pyproject.toml.
+    
+    Returns:
+        List of package requirements strings
+    """
+    return [
+        "opentelemetry-api>=1.18.0",
+        "opentelemetry-sdk>=1.18.0",
+        "opentelemetry-instrumentation-asgi>=0.40b0",
+        "opentelemetry-exporter-otlp-proto-http>=0.40b0",
+        "wrapt>=1.14.0",
+    ]

golf/core/config.py

@@ -0,0 +1,205 @@
+"""Configuration management for GolfMCP."""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union, Tuple
+
+from pydantic import BaseModel, Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from rich.console import Console
+
+console = Console()
+
+
+class AuthConfig(BaseModel):
+    """Authentication configuration."""
+
+    provider: str = Field(
+        ..., description="Authentication provider (e.g., 'jwks', 'google', 'github')"
+    )
+    scopes: List[str] = Field(default_factory=list, description="Required OAuth scopes")
+    client_id_env: Optional[str] = Field(
+        None, description="Environment variable name for client ID"
+    )
+    client_secret_env: Optional[str] = Field(
+        None, description="Environment variable name for client secret"
+    )
+    redirect_uri: Optional[str] = Field(
+        None, description="OAuth redirect URI (defaults to localhost callback)"
+    )
+
+    @field_validator("provider")
+    @classmethod
+    def validate_provider(cls, value: str) -> str:
+        """Validate the provider value."""
+        valid_providers = {"jwks", "google", "github", "custom"}
+        if value not in valid_providers and not value.startswith("custom:"):
+            raise ValueError(
+                f"Invalid provider '{value}'. Must be one of {valid_providers} "
+                "or start with 'custom:'"
+            )
+        return value
+
+
+class DeployConfig(BaseModel):
+    """Deployment configuration."""
+
+    default: str = Field("vercel", description="Default deployment target")
+    options: Dict[str, Any] = Field(
+        default_factory=dict, description="Target-specific options"
+    )
+
+
+class Settings(BaseSettings):
+    """GolfMCP application settings."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="GOLF_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    # Project metadata
+    name: str = Field("GolfMCP Project", description="FastMCP instance name")
+    description: Optional[str] = Field(None, description="Project description")
+    
+    # Build settings
+    output_dir: str = Field("build", description="Build artifact folder")
+    
+    # Server settings
+    host: str = Field("127.0.0.1", description="Server host")
+    port: int = Field(3000, description="Server port")
+    transport: str = Field("streamable-http", description="Transport protocol (streamable-http, sse, stdio)")
+    
+    # Auth settings
+    auth: Optional[Union[str, AuthConfig]] = Field(
+        None, description="Authentication configuration or URI"
+    )
+    
+    # Deploy settings
+    deploy: DeployConfig = Field(
+        default_factory=DeployConfig, description="Deployment configuration"
+    )
+    
+    # Feature flags
+    telemetry: bool = Field(True, description="Enable anonymous telemetry")
+    hot_reload: bool = Field(True, description="Enable hot reload in dev mode")
+    
+    # Project paths
+    tools_dir: str = Field("tools", description="Directory containing tools")
+    resources_dir: str = Field("resources", description="Directory containing resources")
+    prompts_dir: str = Field("prompts", description="Directory containing prompts")
+
+    # OpenTelemetry config
+    opentelemetry_enabled: bool = Field(False, description="Enable OpenTelemetry tracing")
+    opentelemetry_default_exporter: str = Field("console", description="Default OpenTelemetry exporter type")
+
+
+def find_config_path(start_path: Optional[Path] = None) -> Optional[Path]:
+    """Find the golf config file by searching upwards from the given path.
+    
+    Args:
+        start_path: Path to start searching from (defaults to current directory)
+        
+    Returns:
+        Path to the config file if found, None otherwise
+    """
+    if start_path is None:
+        start_path = Path.cwd()
+    
+    current = start_path.absolute()
+    
+    # Don't search above the home directory
+    home = Path.home().absolute()
+    
+    while current != current.parent and current != home:
+        # Check for JSON config first (preferred)
+        json_config = current / "golf.json"
+        if json_config.exists():
+            return json_config
+            
+        # Fall back to TOML config
+        toml_config = current / "golf.toml"
+        if toml_config.exists():
+            return toml_config
+            
+        current = current.parent
+    
+    return None
+
+
+def find_project_root(start_path: Optional[Path] = None) -> Tuple[Optional[Path], Optional[Path]]:
+    """Find a GolfMCP project root by searching for a config file.
+    
+    This is the central project discovery function that should be used by all commands.
+    
+    Args:
+        start_path: Path to start searching from (defaults to current directory)
+        
+    Returns:
+        Tuple of (project_root, config_path) if a project is found, or (None, None) if not
+    """
+    config_path = find_config_path(start_path)
+    if config_path:
+        return config_path.parent, config_path
+    return None, None
+
+
+def load_settings(project_path: Union[str, Path]) -> Settings:
+    """Load settings from a project directory.
+    
+    Args:
+        project_path: Path to the project directory
+        
+    Returns:
+        Settings object with values loaded from config files
+    """
+    # Convert to Path if needed
+    if isinstance(project_path, str):
+        project_path = Path(project_path)
+    
+    # Create default settings
+    settings = Settings()
+    
+    # Check for .env file
+    env_file = project_path / ".env"
+    if env_file.exists():
+        settings = Settings(_env_file=env_file)
+    
+    # Try to load JSON config file first
+    json_config_path = project_path / "golf.json"
+    if json_config_path.exists():
+        return _load_json_settings(json_config_path, settings)
+    
+    # Fall back to TOML config file if JSON not found
+    toml_config_path = project_path / "golf.toml"
+    if toml_config_path.exists():
+        console.print("[yellow]Warning: Using .toml configuration is deprecated. Please migrate to .json format.[/yellow]")
+        return _load_toml_settings(toml_config_path, settings)
+    
+    # No config file found, use defaults
+    return settings
+
+
+def _load_json_settings(path: Path, settings: Settings) -> Settings:
+    """Load settings from a JSON file."""
+    try:
+        import json
+        with open(path, "r") as f:
+            config_data = json.load(f)
+        
+        # Update settings from config data
+        for key, value in config_data.items():
+            if hasattr(settings, key):
+                setattr(settings, key, value)
+        
+        return settings
+    except Exception as e:
+        console.print(f"[bold red]Error loading JSON config from {path}: {e}[/bold red]")
+        return settings
+
+
+def _load_toml_settings(path: Path, settings: Settings) -> Settings:
+    """Load settings from a TOML file."""
+    
+    return settings