claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/mcp_gateway/registry/service_registry.py

@@ -12,17 +12,14 @@ import logging
 from threading import RLock
 from typing import Any, Dict, List, Optional, Type, TypeVar
 
-from claude_mpm.core.logger import get_logger
-from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
-from claude_mpm.services.shared import ManagerBase
 from claude_mpm.services.mcp_gateway.core.interfaces import (
     IMCPCommunication,
     IMCPConfiguration,
     IMCPGateway,
     IMCPLifecycle,
-    IMCPToolAdapter,
     IMCPToolRegistry,
 )
+from claude_mpm.services.shared import ManagerBase
 
 T = TypeVar("T")
 
@@ -324,10 +321,10 @@ class MCPServiceRegistry(ManagerBase):
         """
         with self._lock:
             services = set()
-            services.update(interface.__name__ for interface in self._services.keys())
-            services.update(interface.__name__ for interface in self._factories.keys())
-            services.update(interface.__name__ for interface in self._singletons.keys())
-            return sorted(list(services))
+            services.update(interface.__name__ for interface in self._services)
+            services.update(interface.__name__ for interface in self._factories)
+            services.update(interface.__name__ for interface in self._singletons)
+            return sorted(services)
 
     def clear(self) -> None:
         """Clear all service registrations."""

claude_mpm/services/mcp_gateway/registry/tool_registry.py

@@ -321,7 +321,7 @@ class ToolRegistry(BaseMCPService, IMCPToolRegistry):
             return result
 
         except Exception as e:
-            error_msg = f"Exception invoking tool {tool_name}: {str(e)}"
+            error_msg = f"Exception invoking tool {tool_name}: {e!s}"
             self.log_error(error_msg)
             self.log_error(f"Traceback: {traceback.format_exc()}")
 

claude_mpm/services/mcp_gateway/server/__init__.py

@@ -9,7 +9,7 @@ from .mcp_gateway import MCPGateway
 from .stdio_handler import AlternativeStdioHandler, StdioHandler
 
 __all__ = [
+    "AlternativeStdioHandler",
     "MCPGateway",
     "StdioHandler",
-    "AlternativeStdioHandler",
 ]

claude_mpm/services/mcp_gateway/server/mcp_gateway.py

@@ -13,28 +13,27 @@ Part of ISS-0035: MCP Gateway Implementation - Core Gateway and Tool Registry
 """
 
 import asyncio
+import contextlib
 import json
 import traceback
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Set, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 # Import from the official MCP package
-from mcp.server import NotificationOptions, Server
+from mcp.server import Server
 from mcp.types import (
     EmbeddedResource,
     ImageContent,
-    InitializeResult,
     TextContent,
     Tool,
 )
 
-from claude_mpm.services.mcp_gateway.core.base import BaseMCPService, MCPServiceState
+from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
 from claude_mpm.services.mcp_gateway.core.interfaces import (
     IMCPCommunication,
     IMCPGateway,
     IMCPToolRegistry,
     MCPToolInvocation,
-    MCPToolResult,
 )
 
 
@@ -166,18 +165,14 @@ class MCPGateway(BaseMCPService, IMCPGateway):
                     # Return successful result
                     if isinstance(result.data, str):
                         return [TextContent(type="text", text=result.data)]
-                    else:
-                        return [
-                            TextContent(
-                                type="text", text=json.dumps(result.data, indent=2)
-                            )
-                        ]
-                else:
-                    # Return error
-                    return [TextContent(type="text", text=f"Error: {result.error}")]
+                    return [
+                        TextContent(type="text", text=json.dumps(result.data, indent=2))
+                    ]
+                # Return error
+                return [TextContent(type="text", text=f"Error: {result.error}")]
 
             except Exception as e:
-                error_msg = f"Failed to invoke tool {name}: {str(e)}"
+                error_msg = f"Failed to invoke tool {name}: {e!s}"
                 self.log_error(error_msg)
                 self._metrics["errors"] += 1
                 return [TextContent(type="text", text=f"Error: {error_msg}")]
@@ -267,10 +262,8 @@ class MCPGateway(BaseMCPService, IMCPGateway):
         # Cancel run task if active
         if self._run_task and not self._run_task.done():
             self._run_task.cancel()
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 await self._run_task
-            except asyncio.CancelledError:
-                pass
 
         # Clean up resources
         if self._tool_registry:
@@ -328,7 +321,7 @@ class MCPGateway(BaseMCPService, IMCPGateway):
             return {
                 "jsonrpc": "2.0",
                 "id": request.get("id"),
-                "error": {"code": -32603, "message": f"Internal error: {str(e)}"},
+                "error": {"code": -32603, "message": f"Internal error: {e!s}"},
             }
 
     async def run(self) -> None:

claude_mpm/services/mcp_gateway/server/stdio_handler.py

@@ -11,13 +11,14 @@ Part of ISS-0035: MCP Server Implementation - Core Server and Tool Registry
 import asyncio
 import json
 import sys
-import traceback
-from asyncio import StreamReader, StreamWriter
-from typing import Any, Callable, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
 from claude_mpm.services.mcp_gateway.core.interfaces import IMCPCommunication
 
+if TYPE_CHECKING:
+    from asyncio import StreamReader, StreamWriter
+
 
 class StdioHandler(BaseMCPService, IMCPCommunication):
     """

claude_mpm/services/mcp_gateway/server/stdio_server.py

@@ -13,13 +13,11 @@ use JSON-RPC protocol, and exit cleanly when stdin closes.
 """
 
 import asyncio
-import json
 import logging
 import os
 import sys
 import time
-from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
 # Import MCP SDK components
 from mcp.server import NotificationOptions, Server
@@ -28,10 +26,7 @@ from mcp.server.stdio import stdio_server
 from mcp.types import TextContent, Tool
 
 # Import pydantic for model patching
-from pydantic import BaseModel
-
 from claude_mpm.core.logger import get_logger
-from claude_mpm.services.mcp_gateway.core.singleton_manager import get_gateway_manager
 
 # Import unified ticket tool if available
 try:
@@ -47,72 +42,89 @@ except ImportError:
 def apply_backward_compatibility_patches():
     """
     Apply backward compatibility patches for MCP protocol differences.
-    
+
     This function patches the MCP Server to handle missing clientInfo
     in initialize requests from older Claude Code versions.
     """
     try:
         from mcp.server import Server
-        
+
         logger = get_logger("MCPPatcher")
-        logger.info("Applying MCP Server message handling patch for backward compatibility")
-        
+        logger.info(
+            "Applying MCP Server message handling patch for backward compatibility"
+        )
+
         # Store the original _handle_message method
         original_handle_message = Server._handle_message
-        
-        async def patched_handle_message(self, message, session, lifespan_context, raise_exceptions=False):
+
+        async def patched_handle_message(
+            self, message, session, lifespan_context, raise_exceptions=False
+        ):
             """Patched message handler that adds clientInfo if missing from initialize requests."""
             try:
                 # Check if this is a request responder with initialize method
-                if hasattr(message, 'request') and hasattr(message.request, 'method'):
+                if hasattr(message, "request") and hasattr(message.request, "method"):
                     request = message.request
-                    if (request.method == 'initialize' and 
-                        hasattr(request, 'params') and 
-                        request.params is not None):
-                        
+                    if (
+                        request.method == "initialize"
+                        and hasattr(request, "params")
+                        and request.params is not None
+                    ):
+
                         # Convert params to dict to check for clientInfo
                         params_dict = request.params
-                        if hasattr(params_dict, 'model_dump'):
+                        if hasattr(params_dict, "model_dump"):
                             params_dict = params_dict.model_dump()
-                        elif hasattr(params_dict, 'dict'):
+                        elif hasattr(params_dict, "dict"):
                             params_dict = params_dict.dict()
-                        
-                        if isinstance(params_dict, dict) and 'clientInfo' not in params_dict:
-                            logger.info("Adding default clientInfo for backward compatibility")
-                            
+
+                        if (
+                            isinstance(params_dict, dict)
+                            and "clientInfo" not in params_dict
+                        ):
+                            logger.info(
+                                "Adding default clientInfo for backward compatibility"
+                            )
+
                             # Add default clientInfo
-                            params_dict['clientInfo'] = {
-                                'name': 'claude-desktop',
-                                'version': 'unknown'
+                            params_dict["clientInfo"] = {
+                                "name": "claude-desktop",
+                                "version": "unknown",
                             }
-                            
+
                             # Try to update the params object
-                            if hasattr(request.params, '__dict__'):
-                                request.params.clientInfo = params_dict['clientInfo']
-                            
+                            if hasattr(request.params, "__dict__"):
+                                request.params.clientInfo = params_dict["clientInfo"]
+
                 # Call the original handler
-                return await original_handle_message(self, message, session, lifespan_context, raise_exceptions)
-                
+                return await original_handle_message(
+                    self, message, session, lifespan_context, raise_exceptions
+                )
+
             except Exception as e:
                 logger.warning(f"Error in patched message handler: {e}")
                 # Fall back to original handler
-                return await original_handle_message(self, message, session, lifespan_context, raise_exceptions)
-        
+                return await original_handle_message(
+                    self, message, session, lifespan_context, raise_exceptions
+                )
+
         # Apply the patch
         Server._handle_message = patched_handle_message
         logger.info("Applied MCP Server message handling patch")
         return True
-        
+
     except ImportError as e:
-        get_logger("MCPPatcher").warning(f"Could not import MCP Server for patching: {e}")
+        get_logger("MCPPatcher").warning(
+            f"Could not import MCP Server for patching: {e}"
+        )
         return False
     except Exception as e:
-        get_logger("MCPPatcher").error(f"Failed to apply backward compatibility patch: {e}")
+        get_logger("MCPPatcher").error(
+            f"Failed to apply backward compatibility patch: {e}"
+        )
         return False
 
 
-
-
 class SimpleMCPServer:
     """
     A simple stdio-based MCP server implementation.
@@ -140,20 +152,20 @@ class SimpleMCPServer:
         self.version = version
         self.logger = get_logger("MCPStdioServer")
         self.startup_time = time.time()
-        
+
         # Log startup timing
         self.logger.info(f"Initializing MCP server {name} v{version}")
         start_time = time.time()
 
         # Apply backward compatibility patches before creating server
         apply_backward_compatibility_patches()
-        
+
         # Create MCP server instance
         self.server = Server(name)
 
         # Register default tools
         self._register_tools()
-        
+
         # Log initialization time
         init_time = time.time() - start_time
         self.logger.info(f"MCP server initialized in {init_time:.2f} seconds")
@@ -187,21 +199,20 @@ class SimpleMCPServer:
             # Brief: First and last portions with key sentences
             return self._create_brief_summary(sentences, max_length)
 
-        elif style == "detailed":
+        if style == "detailed":
             # Detailed: More comprehensive with section preservation
             return self._create_detailed_summary(sentences, content, max_length)
 
-        elif style == "bullet_points":
+        if style == "bullet_points":
             # Extract key points as bullet list
             return self._create_bullet_summary(sentences, content, max_length)
 
-        elif style == "executive":
+        if style == "executive":
             # Executive: Summary + key findings + recommendations
             return self._create_executive_summary(sentences, content, max_length)
 
-        else:
-            # Default to brief
-            return self._create_brief_summary(sentences, max_length)
+        # Default to brief
+        return self._create_brief_summary(sentences, max_length)
 
     def _create_brief_summary(self, sentences: list[str], max_length: int) -> str:
         """Create a brief summary by selecting most important sentences."""
@@ -298,7 +309,7 @@ class SimpleMCPServer:
 
         # Summarize each paragraph
         summary_parts = []
-        words_per_para = max_length // len(paragraphs)
+        max_length // len(paragraphs)
 
         for para in paragraphs:
             if not para.strip():
@@ -378,7 +389,6 @@ class SimpleMCPServer:
             sections.append(f"OVERVIEW:\n{overview}")
 
         # Key Findings
-        import re
 
         findings = []
 
@@ -402,7 +412,7 @@ class SimpleMCPServer:
                     break
 
         if findings:
-            sections.append(f"\nKEY FINDINGS:\n• " + "\n• ".join(findings[:3]))
+            sections.append("\nKEY FINDINGS:\n• " + "\n• ".join(findings[:3]))
 
         # Recommendations (look for action-oriented sentences)
         action_patterns = [
@@ -424,9 +434,7 @@ class SimpleMCPServer:
                     break
 
         if recommendations:
-            sections.append(
-                f"\nRECOMMENDATIONS:\n• " + "\n• ".join(recommendations[:3])
-            )
+            sections.append("\nRECOMMENDATIONS:\n• " + "\n• ".join(recommendations[:3]))
 
         # If no sections were created, fall back to brief summary
         if not sections:
@@ -449,14 +457,14 @@ class SimpleMCPServer:
         # NOTE: Defer initialization to avoid event loop issues
         self.unified_ticket_tool = None
         self._ticket_tool_initialized = False
-        
+
         @self.server.list_tools()
         async def handle_list_tools() -> list[Tool]:
             """List available tools."""
             # Initialize ticket tool lazily if needed
             if not self._ticket_tool_initialized and TICKET_TOOLS_AVAILABLE:
                 await self._initialize_ticket_tool()
-            
+
             tools = [
                 Tool(
                     name="status",
@@ -519,7 +527,6 @@ class SimpleMCPServer:
             self.logger.info(f"Listing {len(tools)} available tools")
             return tools
 
-
         @self.server.call_tool()
         async def handle_call_tool(
             name: str, arguments: Dict[str, Any]
@@ -544,11 +551,11 @@ class SimpleMCPServer:
 
                         result = f"Working Directory: {os.getcwd()}"
                     elif info_type == "all":
+                        import datetime
+                        import os
                         import platform
                         import sys
-                        import os
-                        import datetime
-                        
+
                         result = (
                             f"=== System Status ===\n"
                             f"Platform: {platform.system()} {platform.release()}\n"
@@ -572,7 +579,7 @@ class SimpleMCPServer:
                     # Initialize ticket tool lazily if needed
                     if not self._ticket_tool_initialized and TICKET_TOOLS_AVAILABLE:
                         await self._initialize_ticket_tool()
-                    
+
                     if self.unified_ticket_tool:
                         # Handle unified ticket tool invocations
                         from claude_mpm.services.mcp_gateway.core.interfaces import (
@@ -605,26 +612,25 @@ class SimpleMCPServer:
                 return [TextContent(type="text", text=result)]
 
             except Exception as e:
-                error_msg = f"Error executing tool {name}: {str(e)}"
+                error_msg = f"Error executing tool {name}: {e!s}"
                 self.logger.error(error_msg)
                 return [TextContent(type="text", text=error_msg)]
 
-
     async def _initialize_ticket_tool(self):
         """
         Initialize the unified ticket tool asynchronously.
-        
+
         This is called lazily when the tool is first needed,
         ensuring an event loop is available.
         """
         if self._ticket_tool_initialized or not TICKET_TOOLS_AVAILABLE:
             return
-        
+
         try:
             self.logger.info("Initializing unified ticket tool...")
             self.unified_ticket_tool = UnifiedTicketTool()
             # If the tool has an async init method, call it
-            if hasattr(self.unified_ticket_tool, 'initialize'):
+            if hasattr(self.unified_ticket_tool, "initialize"):
                 await self.unified_ticket_tool.initialize()
             self._ticket_tool_initialized = True
             self.logger.info("Unified ticket tool initialized successfully")
@@ -680,15 +686,15 @@ async def main():
         level=logging.INFO,
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
         stream=sys.stderr,
-        force=True  # Force reconfiguration even if already configured
+        force=True,  # Force reconfiguration even if already configured
     )
-    
+
     # Ensure all loggers output to stderr
     for logger_name in logging.Logger.manager.loggerDict:
         logger = logging.getLogger(logger_name)
         for handler in logger.handlers[:]:
             # Remove any handlers that might write to stdout
-            if hasattr(handler, 'stream') and handler.stream == sys.stdout:
+            if hasattr(handler, "stream") and handler.stream == sys.stdout:
                 logger.removeHandler(handler)
 
     # Create and run server
@@ -699,14 +705,16 @@ async def main():
 def main_sync():
     """Synchronous entry point for use as a console script."""
     import os
+
     # Disable telemetry by default
-    os.environ.setdefault('DISABLE_TELEMETRY', '1')
+    os.environ.setdefault("DISABLE_TELEMETRY", "1")
     asyncio.run(main())
 
 
 if __name__ == "__main__":
     import os
+
     # Disable telemetry by default
-    os.environ.setdefault('DISABLE_TELEMETRY', '1')
+    os.environ.setdefault("DISABLE_TELEMETRY", "1")
     # Run the async main function
     main_sync()

claude_mpm/services/mcp_gateway/tools/__init__.py

@@ -16,9 +16,9 @@ from .unified_ticket_tool import UnifiedTicketTool
 
 __all__ = [
     "BaseToolAdapter",
-    "EchoToolAdapter",
     "CalculatorToolAdapter",
-    "SystemInfoToolAdapter",
     "DocumentSummarizerTool",
+    "EchoToolAdapter",
+    "SystemInfoToolAdapter",
     "UnifiedTicketTool",
 ]

claude_mpm/services/mcp_gateway/tools/base_adapter.py

@@ -7,10 +7,9 @@ Base class for MCP tool adapters and example implementations.
 Part of ISS-0035: MCP Server Implementation - Core Server and Tool Registry
 """
 
-import traceback
 from abc import ABC
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
 from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
 from claude_mpm.services.mcp_gateway.core.interfaces import (
@@ -266,7 +265,7 @@ class EchoToolAdapter(BaseToolAdapter):
 
             return MCPToolResult(
                 success=False,
-                error=f"Echo tool failed: {str(e)}",
+                error=f"Echo tool failed: {e!s}",
                 execution_time=execution_time,
             )
 
@@ -368,7 +367,7 @@ class CalculatorToolAdapter(BaseToolAdapter):
 
             return MCPToolResult(
                 success=False,
-                error=f"Calculator tool failed: {str(e)}",
+                error=f"Calculator tool failed: {e!s}",
                 execution_time=execution_time,
             )
 
@@ -471,7 +470,7 @@ class SystemInfoToolAdapter(BaseToolAdapter):
 
             return MCPToolResult(
                 success=False,
-                error=f"System info tool requires psutil: {str(e)}",
+                error=f"System info tool requires psutil: {e!s}",
                 execution_time=execution_time,
             )
         except Exception as e:
@@ -481,6 +480,6 @@ class SystemInfoToolAdapter(BaseToolAdapter):
 
             return MCPToolResult(
                 success=False,
-                error=f"System info tool failed: {str(e)}",
+                error=f"System info tool failed: {e!s}",
                 execution_time=execution_time,
             )

claude_mpm/services/mcp_gateway/tools/document_summarizer.py

@@ -8,20 +8,15 @@ Supports multiple file formats and summarization strategies.
 Part of ISS-0037: Document Summarizer Tool - Intelligent Document Processing
 """
 
-import csv
 import hashlib
-import json
 import mimetypes
 import os
 import re
 from collections import OrderedDict
 from datetime import datetime
-from functools import lru_cache
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
-import yaml
-
 from claude_mpm.services.mcp_gateway.core.interfaces import (
     MCPToolDefinition,
     MCPToolInvocation,
@@ -483,8 +478,7 @@ class DocumentSummarizerTool(BaseToolAdapter):
             result = "\n".join(key_lines)
             if len(result) <= max_chars:
                 return result
-            else:
-                return self._truncate_at_sentence(result, max_chars)
+            return self._truncate_at_sentence(result, max_chars)
 
         # Fallback to brief summary if no key points found
         return self._summarize_brief(text, max_chars)
@@ -556,7 +550,7 @@ class DocumentSummarizerTool(BaseToolAdapter):
         # Add some code blocks if space allows
         if preserve_code and code_blocks:
             result_parts.append("# Code Samples")
-            for i, block in enumerate(code_blocks[:3]):  # Limit to first 3 blocks
+            for _i, block in enumerate(code_blocks[:3]):  # Limit to first 3 blocks
                 if len("\n".join(result_parts)) + len(block) < max_chars * 0.8:
                     result_parts.append(block)
 
@@ -671,20 +665,17 @@ class DocumentSummarizerTool(BaseToolAdapter):
                 summary = self._process_chunks(
                     content, mode, max_chars_per_chunk, preserve_code
                 )
+            # Process entire file
+            elif mode == "brief":
+                summary = self._summarize_brief(content, max_chars)
+            elif mode == "detailed":
+                summary = self._summarize_detailed(content, max_chars)
+            elif mode == "key_points":
+                summary = self._summarize_key_points(content, max_chars)
+            elif mode == "technical":
+                summary = self._summarize_technical(content, max_chars, preserve_code)
             else:
-                # Process entire file
-                if mode == "brief":
-                    summary = self._summarize_brief(content, max_chars)
-                elif mode == "detailed":
-                    summary = self._summarize_detailed(content, max_chars)
-                elif mode == "key_points":
-                    summary = self._summarize_key_points(content, max_chars)
-                elif mode == "technical":
-                    summary = self._summarize_technical(
-                        content, max_chars, preserve_code
-                    )
-                else:
-                    summary = self._summarize_brief(content, max_chars)
+                summary = self._summarize_brief(content, max_chars)
 
             # Calculate metrics
             summary_size = len(summary)
@@ -747,7 +738,7 @@ class DocumentSummarizerTool(BaseToolAdapter):
 
             return MCPToolResult(
                 success=False,
-                error=f"Document summarizer failed: {str(e)}",
+                error=f"Document summarizer failed: {e!s}",
                 execution_time=execution_time,
                 metadata={
                     "tool": "document_summarizer",