napistu 0.2.5.dev5__tar.gz → 0.2.5.dev7__tar.gz

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napistu
-Version: 0.2.5.dev5
+Version: 0.2.5.dev7
 Summary: Connecting high-dimensional data to curated pathways
 Home-page: https://github.com/napistu/napistu-py
 Author: Sean Hackett

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = napistu
-version = 0.2.5.dev5
+version = 0.2.5.dev7
 description = Connecting high-dimensional data to curated pathways
 long_description = file: README.md
 long_description_content_type = text/markdown

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/src/napistu/mcp/codebase.py

@@ -45,7 +45,7 @@ async def initialize_components() -> bool:
 
 def register_components(mcp: FastMCP):
     """
-    Register codebase exploration components with the MCP server.
+    Register codebase components with the MCP server.
 
     Args:
         mcp: FastMCP server instance
@@ -54,22 +54,14 @@ def register_components(mcp: FastMCP):
 
     # Register resources
     @mcp.resource("napistu://codebase/summary")
-    async def get_codebase_summary() -> Dict[str, Any]:
+    async def get_codebase_summary():
         """
-        Get a summary of the Napistu codebase structure.
+        Get a summary of all available codebase information.
         """
         return {
             "modules": list(_codebase_cache["modules"].keys()),
-            "top_level_classes": [
-                class_name
-                for class_name, info in _codebase_cache["classes"].items()
-                if "." not in class_name  # Only include top-level classes
-            ],
-            "top_level_functions": [
-                func_name
-                for func_name, info in _codebase_cache["functions"].items()
-                if "." not in func_name  # Only include top-level functions
-            ],
+            "classes": list(_codebase_cache["classes"].keys()),
+            "functions": list(_codebase_cache["functions"].keys()),
         }
 
     @mcp.resource("napistu://codebase/modules/{module_name}")

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/src/napistu/mcp/documentation.py

@@ -136,7 +136,7 @@ def register_components(mcp: FastMCP):
         return await documentation_utils.get_issue(repo, number)
 
     # Register tools
-    @mcp.tool("search_documentation")
+    @mcp.tool()
     async def search_documentation(query: str):
         """
         Search all documentation for a specific query.

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/src/napistu/mcp/execution.py

@@ -62,8 +62,8 @@ def register_components(mcp, session_context=None, object_registry=None):
     _session_context["napistu"] = napistu
 
     # Register resources
-    @mcp.resource("napistu-local://registry")
-    async def get_registry_summary() -> Dict[str, Any]:
+    @mcp.resource("napistu://execution/registry")
+    async def get_registry():
         """
         Get a summary of all objects registered with the server.
         """
@@ -75,7 +75,7 @@ def register_components(mcp, session_context=None, object_registry=None):
             },
         }
 
-    @mcp.resource("napistu-local://environment")
+    @mcp.resource("napistu://execution/environment")
     async def get_environment_info() -> Dict[str, Any]:
         """
         Get information about the local Python environment.

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/src/napistu/mcp/health.py

@@ -35,8 +35,8 @@ def register_components(mcp: FastMCP) -> None:
         """
         return _health_cache
 
-    @mcp.tool("napistu://health/check")
-    async def check_current_health() -> Dict[str, Any]:
+    @mcp.tool()
+    async def check_health() -> Dict[str, Any]:
         """
         Tool to actively check current component health.
         This performs real-time checks and updates the cached status.

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/src/napistu/mcp/server.py

@@ -188,5 +188,4 @@ def start_mcp_server(
     logger.info("🚀 Starting MCP server...")
     logger.info(f"Using HTTP transport on http://{env_host}:{env_port}")
 
-    # Simple, standard FastMCP run - no custom parameters
-    mcp.run(transport="streamable-http", host=env_host, port=env_port)
+    mcp.run(transport="streamable-http")

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/src/napistu/mcp/tutorials.py

@@ -50,7 +50,7 @@ def register_components(mcp: FastMCP) -> None:
 
     # Register resources
     @mcp.resource("napistu://tutorials/index")
-    async def get_tutorial_index() -> List[Dict[str, Any]]:
+    async def get_tutorials_index() -> List[Dict[str, Any]]:
         """
         Get the index of all available tutorials.
 

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/src/napistu.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napistu
-Version: 0.2.5.dev5
+Version: 0.2.5.dev7
 Summary: Connecting high-dimensional data to curated pathways
 Home-page: https://github.com/napistu/napistu-py
 Author: Sean Hackett

{napistu-0.2.5.dev5 → napistu-0.2.5.dev7}/src/napistu.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ src/tests/test_identifiers.py
 src/tests/test_igraph.py
 src/tests/test_indices.py
 src/tests/test_mcp_documentation_utils.py
+src/tests/test_mcp_server.py
 src/tests/test_mechanism_matching.py
 src/tests/test_net_propagation.py
 src/tests/test_net_utils.py

napistu-0.2.5.dev7/src/tests/test_mcp_server.py

@@ -0,0 +1,219 @@
+"""
+Tests to validate MCP tool and resource naming conventions.
+"""
+
+import re
+from typing import List, Tuple
+from fastmcp import FastMCP
+
+from napistu.mcp import (
+    documentation,
+    codebase,
+    tutorials,
+    execution,
+    health,
+)
+
+# Regex patterns for validation
+VALID_RESOURCE_PATH = re.compile(
+    r"^napistu://[a-zA-Z][a-zA-Z0-9_]*(?:/[a-zA-Z0-9_{}.-]+)*$"
+)
+VALID_TOOL_NAME = re.compile(r"^[a-zA-Z][a-zA-Z0-9_]*$")
+
+
+def collect_resources_and_tools(mcp: FastMCP) -> Tuple[List[str], List[str]]:
+    """
+    Collect all registered resource paths and tool names from an MCP server instance.
+
+    Args:
+        mcp: FastMCP server instance
+
+    Returns:
+        Tuple of (resource_paths, tool_names)
+    """
+    # Get all registered resources and tools
+    resources = mcp._resource_manager.get_resources()
+    tool_names = mcp._tool_manager.get_tools()
+
+    # Extract resource paths from the resource objects
+    resource_paths = []
+
+    # Add all resources (including parameterized ones)
+    for resource in resources.values():
+        resource_paths.append(str(resource.uri))
+
+    return resource_paths, tool_names
+
+
+def test_documentation_naming():
+    """Test that documentation component uses valid names."""
+    mcp = FastMCP("test")
+    documentation.register_components(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_codebase_naming():
+    """Test that codebase component uses valid names."""
+    mcp = FastMCP("test")
+    codebase.register_components(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_tutorials_naming():
+    """Test that tutorials component uses valid names."""
+    mcp = FastMCP("test")
+    tutorials.register_components(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_execution_naming():
+    """Test that execution component uses valid names."""
+    mcp = FastMCP("test")
+    execution.register_components(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_health_naming():
+    """Test that health component uses valid names."""
+    mcp = FastMCP("test")
+    health.register_components(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check resource paths
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+
+    # Check tool names
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+
+
+def test_all_components_naming():
+    """Test that all components together use valid names without conflicts."""
+    mcp = FastMCP("test")
+
+    # Register all components
+    documentation.register_components(mcp)
+    codebase.register_components(mcp)
+    tutorials.register_components(mcp)
+    execution.register_components(mcp)
+    health.register_components(mcp)
+
+    resource_paths, tool_names = collect_resources_and_tools(mcp)
+
+    # Check for duplicate resource paths
+    path_counts = {}
+    for path in resource_paths:
+        assert VALID_RESOURCE_PATH.match(path), f"Invalid resource path: {path}"
+        path_counts[path] = path_counts.get(path, 0) + 1
+        assert path_counts[path] == 1, f"Duplicate resource path: {path}"
+
+    # Check for duplicate tool names
+    name_counts = {}
+    for name in tool_names:
+        assert VALID_TOOL_NAME.match(name), f"Invalid tool name: {name}"
+        name_counts[name] = name_counts.get(name, 0) + 1
+        assert name_counts[name] == 1, f"Duplicate tool name: {name}"
+
+
+def test_expected_resources_exist():
+    """Test that all expected resources are registered."""
+    mcp = FastMCP("test")
+
+    # Register all components
+    documentation.register_components(mcp)
+    codebase.register_components(mcp)
+    tutorials.register_components(mcp)
+    execution.register_components(mcp)
+    health.register_components(mcp)
+
+    resource_paths, _ = collect_resources_and_tools(mcp)
+
+    # Debug: Print all registered resources
+    print("\nRegistered resources:")
+    for path in sorted(resource_paths):
+        print(f"  {path}")
+    print()
+
+    # List of expected base resources (no templates)
+    expected_resources = {
+        "napistu://documentation/summary",
+        "napistu://codebase/summary",
+        "napistu://tutorials/index",
+        "napistu://execution/registry",
+        "napistu://execution/environment",
+        "napistu://health",
+    }
+
+    # Check that each expected resource exists
+    for resource in expected_resources:
+        assert resource in resource_paths, f"Missing expected resource: {resource}"
+
+
+def test_expected_tools_exist():
+    """Test that all expected tools are registered."""
+    mcp = FastMCP("test")
+
+    # Register all components
+    documentation.register_components(mcp)
+    codebase.register_components(mcp)
+    tutorials.register_components(mcp)
+    execution.register_components(mcp)
+    health.register_components(mcp)
+
+    _, tool_names = collect_resources_and_tools(mcp)
+
+    # List of expected tools
+    expected_tools = {
+        "search_documentation",
+        "search_codebase",
+        "get_function_documentation",
+        "get_class_documentation",
+        "search_tutorials",
+        "list_registry",
+        "describe_object",
+        "execute_function",
+        "search_paths",
+        "check_health",
+    }
+
+    # Check that all expected tools exist
+    for tool in expected_tools:
+        assert tool in tool_names, f"Missing expected tool: {tool}"