claude-mpm 4.0.19__py3-none-any.whl → 4.0.22__py3-none-any.whl

claude_mpm/services/mcp_gateway/server/stdio_server.py

@@ -16,7 +16,7 @@ import asyncio
 import json
 import logging
 import sys
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 # Import MCP SDK components
 from mcp.server import NotificationOptions, Server
@@ -190,7 +190,7 @@ class SimpleMCPServer:
             # Default to brief
             return self._create_brief_summary(sentences, max_length)
 
-    def _create_brief_summary(self, sentences: List[str], max_length: int) -> str:
+    def _create_brief_summary(self, sentences: list[str], max_length: int) -> str:
         """Create a brief summary by selecting most important sentences."""
         if not sentences:
             return ""
@@ -272,7 +272,7 @@ class SimpleMCPServer:
         return " ".join(s[1] for s in selected)
 
     def _create_detailed_summary(
-        self, sentences: List[str], content: str, max_length: int
+        self, sentences: list[str], content: str, max_length: int
     ) -> str:
         """Create a detailed summary preserving document structure."""
         import re
@@ -303,7 +303,7 @@ class SimpleMCPServer:
         return " ".join(words) + ("..." if len(result.split()) > max_length else "")
 
     def _create_bullet_summary(
-        self, sentences: List[str], content: str, max_length: int
+        self, sentences: list[str], content: str, max_length: int
     ) -> str:
         """Extract key points as a bullet list."""
         import re
@@ -347,7 +347,7 @@ class SimpleMCPServer:
         return "\n".join(result_lines)
 
     def _create_executive_summary(
-        self, sentences: List[str], content: str, max_length: int
+        self, sentences: list[str], content: str, max_length: int
     ) -> str:
         """Create an executive summary with overview, findings, and recommendations."""
         # Allocate words across sections
@@ -436,32 +436,9 @@ class SimpleMCPServer:
         # NOTE: Defer initialization to avoid event loop issues
         self.unified_ticket_tool = None
         self._ticket_tool_initialized = False
-    
-    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'):
-                await self.unified_ticket_tool.initialize()
-            self._ticket_tool_initialized = True
-            self.logger.info("Unified ticket tool initialized successfully")
-        except Exception as e:
-            self.logger.warning(f"Failed to initialize unified ticket tool: {e}")
-            self.unified_ticket_tool = None
-            self._ticket_tool_initialized = True  # Mark as attempted
-
         @self.server.list_tools()
-        async def handle_list_tools() -> List[Tool]:
+        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:
@@ -469,69 +446,22 @@ class SimpleMCPServer:
             
             tools = [
                 Tool(
-                    name="echo",
-                    description="Echo back the provided message",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "message": {
-                                "type": "string",
-                                "description": "Message to echo",
-                            }
-                        },
-                        "required": ["message"],
-                    },
-                ),
-                Tool(
-                    name="calculator",
-                    description="Perform basic arithmetic calculations",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "expression": {
-                                "type": "string",
-                                "description": "Mathematical expression to evaluate",
-                            }
-                        },
-                        "required": ["expression"],
-                    },
-                ),
-                Tool(
-                    name="system_info",
-                    description="Get system information",
+                    name="status",
+                    description="Get system and service status information",
                     inputSchema={
                         "type": "object",
                         "properties": {
                             "info_type": {
                                 "type": "string",
-                                "enum": ["platform", "python_version", "cwd"],
-                                "description": "Type of system information to retrieve",
+                                "enum": ["platform", "python_version", "cwd", "all"],
+                                "description": "Type of status information to retrieve (default: all)",
+                                "default": "all",
                             }
                         },
-                        "required": ["info_type"],
-                    },
-                ),
-                Tool(
-                    name="run_command",
-                    description="Execute a shell command",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "command": {
-                                "type": "string",
-                                "description": "Shell command to execute",
-                            },
-                            "timeout": {
-                                "type": "number",
-                                "description": "Command timeout in seconds",
-                                "default": 30,
-                            },
-                        },
-                        "required": ["command"],
                     },
                 ),
                 Tool(
-                    name="summarize_document",
+                    name="document_summarizer",
                     description="Summarize documents or text content",
                     inputSchema={
                         "type": "object",
@@ -576,60 +506,17 @@ 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]
-        ) -> List[TextContent]:
+        ) -> list[TextContent]:
             """Handle tool invocation."""
             self.logger.info(f"Invoking tool: {name} with arguments: {arguments}")
 
             try:
-                if name == "echo":
-                    message = arguments.get("message", "")
-                    result = f"Echo: {message}"
-
-                elif name == "calculator":
-                    expression = arguments.get("expression", "")
-                    try:
-                        # Safe evaluation of mathematical expressions
-                        import ast
-                        import operator as op
-
-                        # Supported operators
-                        ops = {
-                            ast.Add: op.add,
-                            ast.Sub: op.sub,
-                            ast.Mult: op.mul,
-                            ast.Div: op.truediv,
-                            ast.Pow: op.pow,
-                            ast.Mod: op.mod,
-                            ast.USub: op.neg,
-                        }
-
-                        def eval_expr(expr):
-                            """Safely evaluate mathematical expression."""
-
-                            def _eval(node):
-                                if isinstance(node, ast.Constant):
-                                    return node.value
-                                elif isinstance(node, ast.BinOp):
-                                    return ops[type(node.op)](
-                                        _eval(node.left), _eval(node.right)
-                                    )
-                                elif isinstance(node, ast.UnaryOp):
-                                    return ops[type(node.op)](_eval(node.operand))
-                                else:
-                                    raise TypeError(f"Unsupported operation: {node}")
-
-                            return _eval(ast.parse(expr, mode="eval").body)
-
-                        result_value = eval_expr(expression)
-                        result = f"{expression} = {result_value}"
-                    except Exception as e:
-                        result = f"Error evaluating expression: {str(e)}"
-
-                elif name == "system_info":
-                    info_type = arguments.get("info_type", "platform")
+                if name == "status":
+                    info_type = arguments.get("info_type", "all")
 
                     if info_type == "platform":
                         import platform
@@ -643,49 +530,25 @@ class SimpleMCPServer:
                         import os
 
                         result = f"Working Directory: {os.getcwd()}"
+                    elif info_type == "all":
+                        import platform
+                        import sys
+                        import os
+                        import datetime
+                        
+                        result = (
+                            f"=== System Status ===\n"
+                            f"Platform: {platform.system()} {platform.release()}\n"
+                            f"Python: {sys.version.split()[0]}\n"
+                            f"Working Directory: {os.getcwd()}\n"
+                            f"Server: {self.name} v{self.version}\n"
+                            f"Timestamp: {datetime.datetime.now().isoformat()}\n"
+                            f"Tools Available: status, document_summarizer{', ticket' if self.unified_ticket_tool else ''}"
+                        )
                     else:
                         result = f"Unknown info type: {info_type}"
 
-                elif name == "run_command":
-                    command = arguments.get("command", "")
-                    timeout = arguments.get("timeout", 30)
-
-                    import shlex
-                    import subprocess
-
-                    try:
-                        # Split command string into a list to avoid shell injection
-                        command_parts = shlex.split(command)
-
-                        # Use create_subprocess_exec instead of create_subprocess_shell
-                        # to prevent command injection vulnerabilities
-                        proc = await asyncio.create_subprocess_exec(
-                            *command_parts,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE,
-                        )
-
-                        stdout, stderr = await asyncio.wait_for(
-                            proc.communicate(), timeout=timeout
-                        )
-
-                        if proc.returncode == 0:
-                            result = (
-                                stdout.decode()
-                                if stdout
-                                else "Command completed successfully"
-                            )
-                        else:
-                            result = f"Command failed with code {proc.returncode}: {stderr.decode()}"
-                    except asyncio.TimeoutError:
-                        result = f"Command timed out after {timeout} seconds"
-                    except ValueError as e:
-                        # Handle shlex parsing errors (e.g., unmatched quotes)
-                        result = f"Invalid command syntax: {str(e)}"
-                    except Exception as e:
-                        result = f"Error running command: {str(e)}"
-
-                elif name == "summarize_document":
+                elif name == "document_summarizer":
                     content = arguments.get("content", "")
                     style = arguments.get("style", "brief")
                     max_length = arguments.get("max_length", 150)
@@ -734,6 +597,29 @@ class SimpleMCPServer:
                 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'):
+                await self.unified_ticket_tool.initialize()
+            self._ticket_tool_initialized = True
+            self.logger.info("Unified ticket tool initialized successfully")
+        except Exception as e:
+            self.logger.warning(f"Failed to initialize unified ticket tool: {e}")
+            self.unified_ticket_tool = None
+            self._ticket_tool_initialized = True  # Mark as attempted
+
     async def run(self):
         """
         Run the MCP server using stdio communication with backward compatibility.
@@ -799,9 +685,15 @@ 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')
     asyncio.run(main())
 
 
 if __name__ == "__main__":
+    import os
+    # Disable telemetry by default
+    os.environ.setdefault('DISABLE_TELEMETRY', '1')
     # Run the async main function
     main_sync()

claude_mpm/services/memory_hook_service.py

@@ -143,11 +143,69 @@ class MemoryHookService(BaseService, MemoryHookInterface):
             HookResult with success status and any modifications
         """
         try:
-            # This would integrate with a memory service to save new memories
-            # For now, this is a placeholder for future memory integration
-            self.logger.debug("Saving new memories from interaction")
-
             from claude_mpm.hooks.base_hook import HookResult
+            
+            # Extract agent_id and response from context
+            agent_id = None
+            response_text = None
+            
+            # Try to get agent_id from various possible locations in context
+            if hasattr(context, 'data') and context.data:
+                data = context.data
+                
+                # Check for agent_id in various locations
+                if isinstance(data, dict):
+                    # Try direct agent_id field
+                    agent_id = data.get('agent_id')
+                    
+                    # Try agent_type field
+                    if not agent_id:
+                        agent_id = data.get('agent_type')
+                    
+                    # Try subagent_type (for Task delegations)
+                    if not agent_id:
+                        agent_id = data.get('subagent_type')
+                    
+                    # Try tool_parameters for Task delegations
+                    if not agent_id and 'tool_parameters' in data:
+                        params = data.get('tool_parameters', {})
+                        if isinstance(params, dict):
+                            agent_id = params.get('subagent_type')
+                    
+                    # Extract response text
+                    response_text = data.get('response') or data.get('result') or data.get('output')
+                    
+                    # If response_text is a dict, try to get text from it
+                    if isinstance(response_text, dict):
+                        response_text = response_text.get('text') or response_text.get('content') or str(response_text)
+            
+            # Default to PM if no agent_id found
+            if not agent_id:
+                agent_id = "PM"
+                self.logger.debug("No agent_id found in context, defaulting to PM")
+            
+            # Only process if we have response text
+            if response_text and isinstance(response_text, str):
+                self.logger.debug(f"Processing memory extraction for agent: {agent_id}")
+                
+                # Import and use the memory manager
+                from claude_mpm.services.agents.memory.agent_memory_manager import get_memory_manager
+                
+                try:
+                    memory_manager = get_memory_manager()
+                    
+                    # Extract and update memory
+                    success = memory_manager.extract_and_update_memory(agent_id, response_text)
+                    
+                    if success:
+                        self.logger.info(f"Successfully extracted and saved memories for {agent_id}")
+                    else:
+                        self.logger.debug(f"No memories found to extract for {agent_id}")
+                        
+                except Exception as mem_error:
+                    self.logger.warning(f"Failed to extract/save memories for {agent_id}: {mem_error}")
+            else:
+                self.logger.debug("No response text found in context for memory extraction")
 
             return HookResult(success=True, data=context.data, modified=False)
 

claude_mpm/services/runner_configuration_service.py

@@ -72,11 +72,12 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
             Loaded configuration dictionary
         """
         try:
+            # Use singleton Config instance to prevent duplicate loading
             if config_path:
-                # Load from specific path if provided
-                config = Config(config_path)
+                # Only pass config_path if it's different from what might already be loaded
+                config = Config({}, config_path)
             else:
-                # Load from default location
+                # Use existing singleton instance
                 config = Config()
 
             return {
@@ -162,14 +163,9 @@ class RunnerConfigurationService(BaseService, RunnerConfigurationInterface):
             "websocket_port": kwargs.get("websocket_port", 8765),
         }
 
-        # Initialize main configuration
+        # Initialize main configuration (singleton will prevent duplicate loading)
         try:
             config = Config()
-        except FileNotFoundError as e:
-            self.logger.warning(
-                "Configuration file not found, using defaults", extra={"error": str(e)}
-            )
-            config = Config()  # Will use defaults
         except Exception as e:
             self.logger.error("Failed to load configuration", exc_info=True)
             raise RuntimeError(f"Configuration initialization failed: {e}") from e

claude_mpm/services/socketio/server/broadcaster.py

@@ -184,10 +184,41 @@ class SocketIOEventBroadcaster:
         
         WHY: Failed broadcasts need to be retried automatically
         to ensure reliable event delivery.
+        
+        IMPORTANT: This method must handle being called from a different thread
+        than the one running the event loop.
         """
         if self.loop and not self.retry_task:
+            try:
+                # Check if the loop is running in the current thread
+                try:
+                    running_loop = asyncio.get_running_loop()
+                    if running_loop == self.loop:
+                        # Same thread, can use create_task directly
+                        self.retry_task = asyncio.create_task(self._process_retry_queue())
+                        self.logger.info("🔄 Started retry queue processor (same thread)")
+                    else:
+                        # Different thread, need to schedule in the target loop
+                        self._start_retry_in_loop()
+                except RuntimeError:
+                    # No running loop in current thread, schedule in target loop
+                    self._start_retry_in_loop()
+            except Exception as e:
+                self.logger.error(f"Failed to start retry processor: {e}")
+    
+    def _start_retry_in_loop(self):
+        """Helper to start retry processor from a different thread."""
+        async def _create_retry_task():
             self.retry_task = asyncio.create_task(self._process_retry_queue())
-            self.logger.info("🔄 Started retry queue processor")
+            self.logger.info("🔄 Started retry queue processor (cross-thread)")
+        
+        # Schedule the task creation in the target loop
+        future = asyncio.run_coroutine_threadsafe(_create_retry_task(), self.loop)
+        try:
+            # Wait briefly to ensure it's scheduled
+            future.result(timeout=1.0)
+        except Exception as e:
+            self.logger.error(f"Failed to schedule retry processor: {e}")
     
     def stop_retry_processor(self):
         """Stop the background retry processor."""

claude_mpm/services/socketio/server/core.py

@@ -138,8 +138,12 @@ class SocketIOServerCore:
         """Run the server event loop."""
         try:
             # Create new event loop for this thread
+            # WHY: We create and assign the loop immediately to minimize the race
+            # condition window where other threads might try to access it.
             self.loop = asyncio.new_event_loop()
             asyncio.set_event_loop(self.loop)
+            
+            self.logger.debug("Event loop created and set for background thread")
 
             # Run the server
             self.loop.run_until_complete(self._start_server())

claude_mpm/services/socketio/server/main.py

@@ -117,11 +117,30 @@ class SocketIOServer(SocketIOServiceInterface):
             server=self,  # Pass server reference for event history access
         )
 
-        # Set the loop reference for broadcaster
-        self.broadcaster.loop = self.core.loop
+        # Wait for the event loop to be initialized in the background thread
+        # WHY: The core server starts in a background thread and creates the event
+        # loop asynchronously. We must wait for it to be ready before using it.
+        max_wait = 5.0  # Maximum wait time in seconds
+        wait_interval = 0.1  # Check interval
+        waited = 0.0
         
-        # Start the retry processor for resilient event delivery
-        self.broadcaster.start_retry_processor()
+        while self.core.loop is None and waited < max_wait:
+            time.sleep(wait_interval)
+            waited += wait_interval
+        
+        if self.core.loop is None:
+            self.logger.warning(
+                f"Event loop not initialized after {max_wait}s wait. "
+                "Retry processor may not function correctly."
+            )
+        else:
+            self.logger.debug(f"Event loop ready after {waited:.1f}s")
+            
+            # Set the loop reference for broadcaster
+            self.broadcaster.loop = self.core.loop
+            
+            # Start the retry processor for resilient event delivery
+            self.broadcaster.start_retry_processor()
 
         # Register events
         self._register_events()

claude_mpm/services/subprocess_launcher_service.py

@@ -313,4 +313,9 @@ class SubprocessLauncherService(BaseService, SubprocessLauncherInterface):
         env = os.environ.copy()
         if base_env:
             env.update(base_env)
+        
+        # Disable telemetry for Claude Code subprocesses
+        # This ensures Claude Code doesn't send telemetry data during runtime
+        env["DISABLE_TELEMETRY"] = "1"
+        
         return env

{claude_mpm-4.0.19.dist-info → claude_mpm-4.0.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.0.19
+Version: 4.0.22
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team