napistu 0.2.5.dev7__py3-none-any.whl → 0.3.1.dev1__py3-none-any.whl

napistu/mcp/health.py

@@ -131,99 +131,81 @@ async def initialize_components() -> bool:
         return False
 
 
-def _check_component_health(
-    component_name: str, module_name: str, cache_attr: str
-) -> Dict[str, str]:
+def _check_component_health(component_name: str, module_path: str) -> Dict[str, Any]:
     """
-    Check the health of a single MCP component by verifying its cache is initialized and contains data.
+    Check the health of a single MCP component using the component class pattern.
 
     Parameters
     ----------
     component_name : str
-        Name of the component (for importing)
-    module_name : str
-        Full module path for importing
-    cache_attr : str
-        Name of the cache/context attribute to check
+        Name of the component (for logging)
+    module_path : str
+        Full module path for importing the component
 
     Returns
     -------
-    Dict[str, str]
-        Dictionary containing component health status:
-            - status : str
-                One of: 'healthy', 'inactive', or 'unavailable'
-            - error : str, optional
-                Error message if status is 'unavailable'
+    Dict[str, Any]
+        Dictionary containing component health status from the component's state
     """
     try:
-        module = __import__(module_name, fromlist=[component_name])
-        cache = getattr(module, cache_attr, None)
-        logger.info(
-            f"Checking {component_name} health - Cache exists: {cache is not None}"
-        )
-
-        # Component specific checks for actual data
-        if cache:
-            if component_name == "documentation":
-                # Check if any documentation section has content
-                has_data = any(bool(section) for section in cache.values())
-                logger.info(f"Documentation sections: {list(cache.keys())}")
-            elif component_name == "codebase":
-                # Check if any codebase section has content
-                has_data = any(bool(section) for section in cache.values())
-                logger.info(f"Codebase sections: {list(cache.keys())}")
-            elif component_name == "tutorials":
-                # Check if tutorials section has content
-                has_data = bool(cache.get("tutorials", {}))
-                logger.info(f"Tutorials cache: {bool(cache.get('tutorials', {}))}")
-            elif component_name == "execution":
-                # Check if session context has more than just napistu module
-                has_data = len(cache) > 0
-                logger.info(f"Execution context: {list(cache.keys())}")
-            else:
-                has_data = bool(cache)
-
-            if has_data:
-                logger.info(f"{component_name} is healthy")
-                return {"status": "healthy"}
-
-        logger.info(f"{component_name} is inactive")
-        return {"status": "inactive"}
+        # Import the component module
+        module = __import__(module_path, fromlist=[component_name])
+
+        # Use the new component class pattern
+        if hasattr(module, "get_component"):
+            try:
+                component = module.get_component()
+                state = component.get_state()
+                health_status = state.get_health_status()
+                logger.info(f"{component_name} health: {health_status}")
+                return health_status
+            except RuntimeError as e:
+                # Handle execution component that might not be created yet
+                if "not created" in str(e):
+                    logger.warning(f"{component_name} not initialized yet")
+                    return {
+                        "status": "initializing",
+                        "message": "Component not created",
+                    }
+                else:
+                    raise
+        else:
+            # Component doesn't follow the new pattern
+            logger.warning(f"{component_name} doesn't use component class pattern")
+            return {"status": "unknown", "message": "Component using legacy pattern"}
+
+    except ImportError as e:
+        logger.error(f"Could not import {component_name}: {str(e)}")
+        return {"status": "unavailable", "error": f"Import failed: {str(e)}"}
     except Exception as e:
-        logger.error(f"{component_name} check failed: {str(e)}")
+        logger.error(f"{component_name} health check failed: {str(e)}")
         return {"status": "unavailable", "error": str(e)}
 
 
 async def _check_components() -> Dict[str, Dict[str, Any]]:
     """
-    Check the health of individual MCP components by verifying their caches.
+    Check the health of individual MCP components using their component classes.
 
     Returns
     -------
     Dict[str, Dict[str, Any]]
-        Dictionary mapping component names to their health status:
-            - {component_name} : Dict[str, str]
-                Health status for each component, containing:
-                    - status : str
-                        One of: 'healthy', 'inactive', or 'unavailable'
-                    - error : str, optional
-                        Error message if status is 'unavailable'
+        Dictionary mapping component names to their health status
     """
-    # Define component configurations - cache vars that indicate initialization
+    # Define component configurations
     component_configs = {
-        "documentation": ("napistu.mcp.documentation", "_docs_cache"),
-        "codebase": ("napistu.mcp.codebase", "_codebase_cache"),
-        "tutorials": ("napistu.mcp.tutorials", "_tutorial_cache"),
-        "execution": ("napistu.mcp.execution", "_session_context"),
+        "documentation": "napistu.mcp.documentation",
+        "codebase": "napistu.mcp.codebase",
+        "tutorials": "napistu.mcp.tutorials",
+        "execution": "napistu.mcp.execution",
     }
 
     logger.info("Starting component health checks...")
     logger.info(f"Checking components: {list(component_configs.keys())}")
 
-    # Check each component's cache
+    # Check each component using their state objects
     results = {
-        name: _check_component_health(name, module_path, cache_attr)
-        for name, (module_path, cache_attr) in component_configs.items()
+        name: _check_component_health(name, module_path)
+        for name, module_path in component_configs.items()
     }
 
     logger.info(f"Health check results: {results}")

napistu/mcp/profiles.py

@@ -1,5 +1,7 @@
 from typing import Dict, Any
 
+from napistu.mcp.constants import MCP_PROFILES
+
 
 class ServerProfile:
     """Base profile for MCP server configuration."""
@@ -31,9 +33,11 @@ class ServerProfile:
 
 
 # Pre-defined profiles
-LOCAL_PROFILE = ServerProfile(server_name="napistu-local", enable_execution=True)
+EXECUTION_PROFILE = ServerProfile(
+    server_name="napistu-execution", enable_execution=True
+)
 
-REMOTE_PROFILE = ServerProfile(
+DOCS_PROFILE = ServerProfile(
     server_name="napistu-docs",
     enable_documentation=True,
     enable_codebase=True,
@@ -54,16 +58,16 @@ def get_profile(profile_name: str, **overrides) -> ServerProfile:
     Get a predefined profile with optional overrides.
 
     Args:
-        profile_name: Name of the profile ('local', 'remote', or 'full')
+        profile_name: Name of the profile ('execution', 'docs', or 'full')
         **overrides: Configuration overrides
 
     Returns:
         ServerProfile instance
     """
     profiles = {
-        "local": LOCAL_PROFILE,
-        "remote": REMOTE_PROFILE,
-        "full": FULL_PROFILE,
+        MCP_PROFILES.EXECUTION: EXECUTION_PROFILE,
+        MCP_PROFILES.DOCS: DOCS_PROFILE,
+        MCP_PROFILES.FULL: FULL_PROFILE,
     }
 
     if profile_name not in profiles:

napistu/mcp/server.py

@@ -1,11 +1,9 @@
-# src/napistu/mcp/server.py
 """
 Core MCP server implementation for Napistu.
 """
 
 import asyncio
 import logging
-import os
 
 from mcp.server import FastMCP
 
@@ -16,20 +14,60 @@ from napistu.mcp import tutorials
 from napistu.mcp import health
 
 from napistu.mcp.profiles import ServerProfile, get_profile
+from napistu.mcp.constants import MCP_DEFAULTS
+from napistu.mcp.config import MCPServerConfig
 
 logger = logging.getLogger(__name__)
 
 
-def create_server(profile: ServerProfile, **kwargs) -> FastMCP:
+def _register_component(
+    name: str, module, config_key: str, config: dict, mcp: FastMCP, **kwargs
+) -> None:
+    """
+    Register a single component with the MCP server.
+
+    Parameters
+    ----------
+    name : str
+        Component name for logging
+    module : module
+        Component module with get_component() function or create_component() for execution
+    config_key : str
+        Configuration key to check if component is enabled
+    config : dict
+        Server configuration
+    mcp : FastMCP
+        FastMCP server instance
+    **kwargs : dict
+        Additional arguments for component creation (used by execution component)
+    """
+    if not config.get(config_key, False):
+        return  # Skip disabled components
+
+    logger.info(f"Registering {name} components")
+
+    if name == "execution":
+        # Special handling for execution component which needs session context
+        component = module.create_component(
+            session_context=kwargs.get("session_context"),
+            object_registry=kwargs.get("object_registry"),
+        )
+    else:
+        component = module.get_component()
+
+    component.register(mcp)
+
+
+def create_server(profile: ServerProfile, server_config: MCPServerConfig) -> FastMCP:
     """
-    Create an MCP server based on a profile configuration.
+    Create an MCP server based on a profile configuration and server config.
 
     Parameters
     ----------
     profile : ServerProfile
-        Server profile to use. All configuration must be set in the profile.
-    **kwargs
-        Additional arguments to pass to the FastMCP constructor such as host and port.
+        Server profile to use. All configuration must be set in the profile. (Valid profiles: 'execution', 'docs', 'full')
+    server_config : MCPServerConfig
+        Server configuration with validated host, port, and server name.
 
     Returns
     -------
@@ -39,26 +77,30 @@ def create_server(profile: ServerProfile, **kwargs) -> FastMCP:
 
     config = profile.get_config()
 
-    # Create the server with FastMCP-specific parameters
-    # Pass all kwargs directly to the FastMCP constructor
-    mcp = FastMCP(config["server_name"], **kwargs)
-
-    if config["enable_documentation"]:
-        logger.info("Registering documentation components")
-        documentation.register_components(mcp)
-    if config["enable_codebase"]:
-        logger.info("Registering codebase components")
-        codebase.register_components(mcp)
-    if config["enable_execution"]:
-        logger.info("Registering execution components")
-        execution.register_components(
+    # Create the server with validated configuration
+    mcp = FastMCP(
+        server_config.server_name, host=server_config.host, port=server_config.port
+    )
+
+    # Define component configurations
+    component_configs = [
+        ("documentation", documentation, "enable_documentation"),
+        ("codebase", codebase, "enable_codebase"),
+        ("tutorials", tutorials, "enable_tutorials"),
+        ("execution", execution, "enable_execution"),
+    ]
+
+    # Register all components
+    for name, module, config_key in component_configs:
+        _register_component(
+            name,
+            module,
+            config_key,
+            config,
             mcp,
-            session_context=config["session_context"],
-            object_registry=config["object_registry"],
+            session_context=config.get("session_context"),
+            object_registry=config.get("object_registry"),
         )
-    if config["enable_tutorials"]:
-        logger.info("Registering tutorials components")
-        tutorials.register_components(mcp)
 
     # Always register health components
     health.register_components(mcp)
@@ -67,9 +109,44 @@ def create_server(profile: ServerProfile, **kwargs) -> FastMCP:
     return mcp
 
 
+async def _initialize_component(
+    name: str, module, config_key: str, config: dict
+) -> bool:
+    """
+    Initialize a single component with error handling.
+
+    Parameters
+    ----------
+    name : str
+        Component name for logging
+    module : module
+        Component module with get_component() function
+    config_key : str
+        Configuration key to check if component is enabled
+    config : dict
+        Server configuration
+
+    Returns
+    -------
+    bool
+        True if initialization successful
+    """
+    if not config.get(config_key, False):
+        return True  # Skip disabled components
+
+    logger.info(f"Initializing {name} components")
+    try:
+        component = module.get_component()
+        result = await component.safe_initialize()
+        return result
+    except Exception as e:
+        logger.error(f"❌ {name.title()} components failed to initialize: {e}")
+        return False
+
+
 async def initialize_components(profile: ServerProfile) -> None:
     """
-    Asynchronously initialize all enabled components for the MCP server, using the provided ServerProfile.
+    Asynchronously initialize all enabled components for the MCP server.
 
     Parameters
     ----------
@@ -82,51 +159,61 @@ async def initialize_components(profile: ServerProfile) -> None:
     """
     config = profile.get_config()
 
-    if config["enable_documentation"]:
-        logger.info("Initializing documentation components")
-        await documentation.initialize_components()
-    if config["enable_codebase"]:
-        logger.info("Initializing codebase components")
-        await codebase.initialize_components()
-    if config["enable_tutorials"]:
-        logger.info("Initializing tutorials components")
-        await tutorials.initialize_components()
-    if config["enable_execution"]:
-        logger.info("Initializing execution components")
-        await execution.initialize_components()
+    # Define component configurations
+    component_configs = [
+        ("documentation", documentation, "enable_documentation"),
+        ("codebase", codebase, "enable_codebase"),
+        ("tutorials", tutorials, "enable_tutorials"),
+        ("execution", execution, "enable_execution"),
+    ]
+
+    # Initialize all components
+    initialization_results = {}
+
+    for name, module, config_key in component_configs:
+        result = await _initialize_component(name, module, config_key, config)
+        initialization_results[name] = result
 
     # Initialize health components last since they monitor the other components
     logger.info("Initializing health components")
-    await health.initialize_components()
+    try:
+        result = await health.initialize_components()
+        initialization_results["health"] = result
+        if result:
+            logger.info("✅ Health components initialized successfully")
+        else:
+            logger.warning("⚠️ Health components initialized with issues")
+    except Exception as e:
+        logger.error(f"❌ Health components failed to initialize: {e}")
+        initialization_results["health"] = False
+
+    # Summary of initialization
+    successful = sum(1 for success in initialization_results.values() if success)
+    total = len(initialization_results)
+    logger.info(
+        f"Component initialization complete: {successful}/{total} components successful"
+    )
 
+    if successful == 0:
+        logger.error(
+            "❌ All components failed to initialize - server may not function correctly"
+        )
+    elif successful < total:
+        logger.warning(
+            "⚠️ Some components failed to initialize - server running in degraded mode"
+        )
 
-def start_mcp_server(
-    profile_name: str = "remote",
-    host: str = "0.0.0.0",
-    port: int = 8080,
-    server_name: str | None = None,
-) -> None:
+
+def start_mcp_server(profile_name: str, server_config: MCPServerConfig) -> None:
     """
     Start MCP server - main entry point for server startup.
 
-    The server will be started with HTTP transport on the specified host and port.
-    Environment variables can override the default configuration:
-    - MCP_PROFILE: Server profile to use
-    - HOST: Host to bind to
-    - PORT: Port to bind to
-    - MCP_SERVER_NAME: Name of the MCP server
-
     Parameters
     ----------
-    profile_name : str, optional
-        Server profile to use ('local', 'remote', 'full'). Defaults to 'remote'.
-    host : str, optional
-        Host address to bind the server to. Defaults to '0.0.0.0'.
-    port : int, optional
-        Port number to listen on. Defaults to 8080.
-    server_name : str | None, optional
-        Custom name for the MCP server. If None, will be generated from profile name.
-        Defaults to None.
+    profile_name : str
+        Server profile to use ('local', 'remote', 'full').
+    server_config : MCPServerConfig
+        Validated server configuration.
 
     Returns
     -------
@@ -143,20 +230,12 @@ def start_mcp_server(
     logging.basicConfig(level=logging.INFO)
     logger = logging.getLogger("napistu")
 
-    # Get configuration from environment variables (for Cloud Run)
-    env_profile = os.getenv("MCP_PROFILE", profile_name)
-    env_host = os.getenv("HOST", host)
-    env_port = int(os.getenv("PORT", port))
-    env_server_name = os.getenv(
-        "MCP_SERVER_NAME", server_name or f"napistu-{env_profile}"
-    )
-
     logger.info("Starting Napistu MCP Server")
-    logger.info(f"  Profile: {env_profile}")
-    logger.info(f"  Host: {env_host}")
-    logger.info(f"  Port: {env_port}")
-    logger.info(f"  Server Name: {env_server_name}")
-    logger.info("  Transport: streamable-http")
+    logger.info(f"  Profile: {profile_name}")
+    logger.info(f"  Host: {server_config.host}")
+    logger.info(f"  Port: {server_config.port}")
+    logger.info(f"  Server Name: {server_config.server_name}")
+    logger.info(f"  Transport: {MCP_DEFAULTS.TRANSPORT}")
 
     # Create session context for execution components
     session_context = {}
@@ -164,14 +243,14 @@ def start_mcp_server(
 
     # Get profile with configuration
     profile: ServerProfile = get_profile(
-        env_profile,
+        profile_name,
         session_context=session_context,
         object_registry=object_registry,
-        server_name=env_server_name,
+        server_name=server_config.server_name,
     )
 
-    # Create server with Cloud Run proxy settings
-    mcp = create_server(profile, host=env_host, port=env_port)
+    # Create server with validated configuration
+    mcp = create_server(profile, server_config)
 
     # Initialize components first (separate async call)
     async def init_components():
@@ -186,6 +265,8 @@ def start_mcp_server(
     logger.info(f"Server settings: {mcp.settings}")
 
     logger.info("🚀 Starting MCP server...")
-    logger.info(f"Using HTTP transport on http://{env_host}:{env_port}")
+    logger.info(
+        f"Using {MCP_DEFAULTS.TRANSPORT} transport on http://{server_config.host}:{server_config.port}"
+    )
 
-    mcp.run(transport="streamable-http")
+    mcp.run(transport=MCP_DEFAULTS.TRANSPORT)