claude-mpm 4.0.17__py3-none-any.whl → 4.0.20__py3-none-any.whl

claude_mpm/core/unified_paths.py

@@ -64,42 +64,179 @@ class DeploymentContext(Enum):
 class PathContext:
     """Handles deployment context detection and path resolution."""
 
+    @staticmethod
+    def _is_editable_install() -> bool:
+        """Check if the current installation is editable (development mode).
+        
+        This checks for various indicators of an editable/development installation:
+        - Presence of pyproject.toml in parent directories
+        - .pth files pointing to the source directory
+        - Direct source installation (src/ directory structure)
+        - Current working directory is within a development project
+        """
+        try:
+            import claude_mpm
+            module_path = Path(claude_mpm.__file__).parent
+            
+            # Check if we're in a src/ directory structure with pyproject.toml
+            current = module_path
+            for _ in range(5):  # Check up to 5 levels up
+                if (current / "pyproject.toml").exists():
+                    # Found pyproject.toml, check if this looks like a development setup
+                    if (current / "src" / "claude_mpm").exists():
+                        logger.debug(f"Found development installation at {current}")
+                        return True
+                if current == current.parent:
+                    break
+                current = current.parent
+            
+            # Additional check: If we're running from within a claude-mpm development directory
+            # This handles the case where pipx claude-mpm is invoked from within the dev directory
+            cwd = Path.cwd()
+            current = cwd
+            for _ in range(5):  # Check up to 5 levels up from current directory
+                if (current / "pyproject.toml").exists() and (current / "src" / "claude_mpm").exists():
+                    # Check if this is the claude-mpm project
+                    try:
+                        pyproject_content = (current / "pyproject.toml").read_text()
+                        if "claude-mpm" in pyproject_content and "claude_mpm" in pyproject_content:
+                            logger.debug(f"Running from within claude-mpm development directory: {current}")
+                            # Verify this is a development setup by checking for key files
+                            if (current / "scripts" / "claude-mpm").exists():
+                                return True
+                    except Exception:
+                        pass
+                if current == current.parent:
+                    break
+                current = current.parent
+            
+            # Check for .pth files indicating editable install
+            try:
+                import site
+                for site_dir in site.getsitepackages():
+                    site_path = Path(site_dir)
+                    if site_path.exists():
+                        # Check for .pth files
+                        for pth_file in site_path.glob("*.pth"):
+                            try:
+                                content = pth_file.read_text()
+                                # Check if the .pth file points to our module's parent
+                                if str(module_path.parent) in content or str(module_path) in content:
+                                    logger.debug(f"Found editable install via .pth file: {pth_file}")
+                                    return True
+                            except Exception:
+                                continue
+                        
+                        # Check for egg-link files
+                        for egg_link in site_path.glob("*egg-link"):
+                            if "claude" in egg_link.name.lower():
+                                try:
+                                    content = egg_link.read_text()
+                                    if str(module_path.parent) in content or str(module_path) in content:
+                                        logger.debug(f"Found editable install via egg-link: {egg_link}")
+                                        return True
+                                except Exception:
+                                    continue
+            except ImportError:
+                pass
+            
+        except Exception as e:
+            logger.debug(f"Error checking for editable install: {e}")
+        
+        return False
+
     @staticmethod
     @lru_cache(maxsize=1)
     def detect_deployment_context() -> DeploymentContext:
-        """Detect the current deployment context."""
+        """Detect the current deployment context.
+        
+        Priority order:
+        1. Environment variable override (CLAUDE_MPM_DEV_MODE)
+        2. Current working directory is a claude-mpm development project
+        3. Editable installation detection
+        4. Path-based detection (development, pipx, system, pip)
+        """
+        # Check for environment variable override
+        if os.environ.get("CLAUDE_MPM_DEV_MODE", "").lower() in ("1", "true", "yes"):
+            logger.info("Development mode forced via CLAUDE_MPM_DEV_MODE environment variable")
+            return DeploymentContext.DEVELOPMENT
+        
+        # Check if current working directory is a claude-mpm development project
+        # This handles the case where pipx claude-mpm is run from within the dev directory
+        cwd = Path.cwd()
+        current = cwd
+        for _ in range(5):  # Check up to 5 levels up from current directory
+            if (current / "pyproject.toml").exists() and (current / "src" / "claude_mpm").exists():
+                # Check if this is the claude-mpm project
+                try:
+                    pyproject_content = (current / "pyproject.toml").read_text()
+                    if 'name = "claude-mpm"' in pyproject_content or '"claude-mpm"' in pyproject_content:
+                        logger.info(f"Detected claude-mpm development directory at {current}")
+                        logger.info("Using development mode for local source preference")
+                        return DeploymentContext.DEVELOPMENT
+                except Exception:
+                    pass
+            if current == current.parent:
+                break
+            current = current.parent
+        
         try:
             import claude_mpm
-
             module_path = Path(claude_mpm.__file__).parent
-
-            # Check for development mode
+            
+            # First check if this is an editable install, regardless of path
+            # This is important for cases where pipx points to a development installation
+            if PathContext._is_editable_install():
+                logger.info(f"Detected editable/development installation")
+                # Check if we should use development paths
+                # This could be because we're in a src/ directory or running from dev directory
+                if module_path.parent.name == "src":
+                    return DeploymentContext.DEVELOPMENT
+                elif "pipx" in str(module_path):
+                    # Running via pipx but from within a development directory
+                    # Use development mode to prefer local source over pipx installation
+                    cwd = Path.cwd()
+                    current = cwd
+                    for _ in range(5):
+                        if (current / "src" / "claude_mpm").exists() and (current / "pyproject.toml").exists():
+                            logger.info(f"Running pipx from development directory, using development mode")
+                            return DeploymentContext.DEVELOPMENT
+                        if current == current.parent:
+                            break
+                        current = current.parent
+                    return DeploymentContext.EDITABLE_INSTALL
+                else:
+                    return DeploymentContext.EDITABLE_INSTALL
+            
+            # Check for development mode based on directory structure
             # module_path is typically /path/to/project/src/claude_mpm
-            # So we need to check if /path/to/project/src exists (module_path.parent)
-            # and if /path/to/project/src/claude_mpm exists (module_path itself)
             if (module_path.parent.name == "src" and
                 (module_path.parent.parent / "src" / "claude_mpm").exists()):
+                logger.info(f"Detected development mode via directory structure at {module_path}")
                 return DeploymentContext.DEVELOPMENT
 
-            # Check for editable install
-            if (
-                "site-packages" in str(module_path)
-                and (module_path.parent.parent / "src").exists()
-            ):
-                return DeploymentContext.EDITABLE_INSTALL
-
             # Check for pipx install
             if "pipx" in str(module_path):
+                logger.info(f"Detected pipx installation at {module_path}")
                 return DeploymentContext.PIPX_INSTALL
 
             # Check for system package
             if "dist-packages" in str(module_path):
+                logger.info(f"Detected system package installation at {module_path}")
                 return DeploymentContext.SYSTEM_PACKAGE
+            
+            # Check for site-packages (could be pip or editable)
+            if "site-packages" in str(module_path):
+                # Already checked for editable above, so this is a regular pip install
+                logger.info(f"Detected pip installation at {module_path}")
+                return DeploymentContext.PIP_INSTALL
 
             # Default to pip install
+            logger.info(f"Defaulting to pip installation for {module_path}")
             return DeploymentContext.PIP_INSTALL
 
         except ImportError:
+            logger.info("ImportError during context detection, defaulting to development")
             return DeploymentContext.DEVELOPMENT
 
 
@@ -143,8 +280,8 @@ class UnifiedPathManager:
         ]
         self._initialized = True
 
-        logger.debug(
-            f"UnifiedPathManager initialized with context: {self._deployment_context}"
+        logger.info(
+            f"UnifiedPathManager initialized with context: {self._deployment_context.value}"
         )
 
     # ========================================================================
@@ -160,11 +297,38 @@ class UnifiedPathManager:
 
             module_path = Path(claude_mpm.__file__).parent
 
-            if self._deployment_context == DeploymentContext.DEVELOPMENT:
-                # Development: go up to project root
+            if self._deployment_context in (DeploymentContext.DEVELOPMENT, DeploymentContext.EDITABLE_INSTALL):
+                # For development mode, first check if we're running from within a dev directory
+                # This handles the case where pipx is invoked from a development directory
+                cwd = Path.cwd()
+                current = cwd
+                for _ in range(5):
+                    if (current / "src" / "claude_mpm").exists() and (current / "pyproject.toml").exists():
+                        # Verify this is the claude-mpm project
+                        try:
+                            pyproject_content = (current / "pyproject.toml").read_text()
+                            if "claude-mpm" in pyproject_content:
+                                logger.debug(f"Found framework root via cwd at {current}")
+                                return current
+                        except Exception:
+                            pass
+                    if current == current.parent:
+                        break
+                    current = current.parent
+                
+                # Development or editable install: go up to project root from module
                 current = module_path
                 while current != current.parent:
-                    if (current / "src" / "claude_mpm").exists():
+                    if (current / "src" / "claude_mpm").exists() and (current / "pyproject.toml").exists():
+                        logger.debug(f"Found framework root at {current}")
+                        return current
+                    current = current.parent
+                
+                # Secondary check: Look for pyproject.toml without src structure
+                current = module_path
+                while current != current.parent:
+                    if (current / "pyproject.toml").exists():
+                        logger.debug(f"Found framework root (no src) at {current}")
                         return current
                     current = current.parent
 
@@ -202,9 +366,14 @@ class UnifiedPathManager:
     @property
     def package_root(self) -> Path:
         """Get the claude_mpm package root directory."""
+        if self._deployment_context in (DeploymentContext.DEVELOPMENT, DeploymentContext.EDITABLE_INSTALL):
+            # In development mode, always use the source directory
+            package_path = self.framework_root / "src" / "claude_mpm"
+            if package_path.exists():
+                return package_path
+        
         try:
             import claude_mpm
-
             return Path(claude_mpm.__file__).parent
         except ImportError:
             return self.framework_root / "src" / "claude_mpm"
@@ -246,7 +415,7 @@ class UnifiedPathManager:
         elif scope == "project":
             return self.get_project_config_dir() / "agents"
         elif scope == "framework":
-            if self._deployment_context == DeploymentContext.DEVELOPMENT:
+            if self._deployment_context in (DeploymentContext.DEVELOPMENT, DeploymentContext.EDITABLE_INSTALL):
                 return self.framework_root / "src" / "claude_mpm" / "agents"
             else:
                 return self.package_root / "agents"
@@ -277,7 +446,7 @@ class UnifiedPathManager:
 
     def get_scripts_dir(self) -> Path:
         """Get the scripts directory."""
-        if self._deployment_context == DeploymentContext.DEVELOPMENT:
+        if self._deployment_context in (DeploymentContext.DEVELOPMENT, DeploymentContext.EDITABLE_INSTALL):
             return self.framework_root / "scripts"
         else:
             return self.package_root / "scripts"

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -65,6 +65,10 @@ except ImportError:
 _global_handler = None
 _handler_lock = threading.Lock()
 
+# Track recent events to detect duplicates
+_recent_events = deque(maxlen=10)
+_events_lock = threading.Lock()
+
 
 class ClaudeHookHandler:
     """Optimized hook handler with direct Socket.IO client.
@@ -288,12 +292,16 @@ class ClaudeHookHandler:
         - Always continues regardless of event status
         - Process exits after handling to prevent accumulation
         """
+        _continue_sent = False  # Track if continue has been sent
 
         def timeout_handler(signum, frame):
             """Handle timeout by forcing exit."""
+            nonlocal _continue_sent
             if DEBUG:
                 print(f"Hook handler timeout (pid: {os.getpid()})", file=sys.stderr)
-            self._continue_execution()
+            if not _continue_sent:
+                self._continue_execution()
+                _continue_sent = True
             sys.exit(0)
 
         try:
@@ -304,8 +312,35 @@ class ClaudeHookHandler:
             # Read and parse event
             event = self._read_hook_event()
             if not event:
-                self._continue_execution()
+                if not _continue_sent:
+                    self._continue_execution()
+                    _continue_sent = True
                 return
+            
+            # Check for duplicate events (same event within 100ms)
+            global _recent_events, _events_lock
+            event_key = self._get_event_key(event)
+            current_time = time.time()
+            
+            with _events_lock:
+                # Check if we've seen this event recently
+                for recent_key, recent_time in _recent_events:
+                    if recent_key == event_key and (current_time - recent_time) < 0.1:
+                        if DEBUG:
+                            print(f"[{datetime.now().isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})", file=sys.stderr)
+                        # Still need to output continue for this invocation
+                        if not _continue_sent:
+                            self._continue_execution()
+                            _continue_sent = True
+                        return
+                
+                # Not a duplicate, record it
+                _recent_events.append((event_key, current_time))
+            
+            # Debug: Log that we're processing an event
+            if DEBUG:
+                hook_type = event.get("hook_event_name", "unknown")
+                print(f"\n[{datetime.now().isoformat()}] Processing hook event: {hook_type} (PID: {os.getpid()})", file=sys.stderr)
 
             # Increment event counter and perform periodic cleanup
             self.events_processed += 1
@@ -320,12 +355,16 @@ class ClaudeHookHandler:
             # Route event to appropriate handler
             self._route_event(event)
 
-            # Always continue execution
-            self._continue_execution()
+            # Always continue execution (only if not already sent)
+            if not _continue_sent:
+                self._continue_execution()
+                _continue_sent = True
 
-        except:
-            # Fail fast and silent
-            self._continue_execution()
+        except Exception:
+            # Fail fast and silent (only send continue if not already sent)
+            if not _continue_sent:
+                self._continue_execution()
+                _continue_sent = True
         finally:
             # Cancel the alarm
             signal.alarm(0)
@@ -402,6 +441,35 @@ class ClaudeHookHandler:
                 if DEBUG:
                     print(f"Error handling {hook_type}: {e}", file=sys.stderr)
 
+    def _get_event_key(self, event: dict) -> str:
+        """Generate a unique key for an event to detect duplicates.
+        
+        WHY: Claude Code may call the hook multiple times for the same event
+        because the hook is registered for multiple event types. We need to
+        detect and skip duplicate processing while still returning continue.
+        """
+        # Create a key from event type, session_id, and key data
+        hook_type = event.get("hook_event_name", "unknown")
+        session_id = event.get("session_id", "")
+        
+        # Add type-specific data to make the key unique
+        if hook_type == "PreToolUse":
+            tool_name = event.get("tool_name", "")
+            # For some tools, include parameters to distinguish calls
+            if tool_name == "Task":
+                tool_input = event.get("tool_input", {})
+                agent = tool_input.get("subagent_type", "")
+                prompt_preview = (tool_input.get("prompt", "") or tool_input.get("description", ""))[:50]
+                return f"{hook_type}:{session_id}:{tool_name}:{agent}:{prompt_preview}"
+            else:
+                return f"{hook_type}:{session_id}:{tool_name}"
+        elif hook_type == "UserPromptSubmit":
+            prompt_preview = event.get("prompt", "")[:50]
+            return f"{hook_type}:{session_id}:{prompt_preview}"
+        else:
+            # For other events, just use type and session
+            return f"{hook_type}:{session_id}"
+    
     def _continue_execution(self) -> None:
         """
         Send continue action to Claude.
@@ -893,24 +961,26 @@ class ClaudeHookHandler:
 def main():
     """Entry point with singleton pattern and proper cleanup."""
     global _global_handler
+    _continue_printed = False  # Track if we've already printed continue
 
     def cleanup_handler(signum=None, frame=None):
         """Cleanup handler for signals and exit."""
+        nonlocal _continue_printed
         if DEBUG:
             print(
                 f"Hook handler cleanup (pid: {os.getpid()}, signal: {signum})",
                 file=sys.stderr,
             )
-        # Always output continue action to not block Claude
-        print(json.dumps({"action": "continue"}))
-        # Only exit if this is a signal handler call, not atexit
-        if signum is not None:
+        # Only output continue if we haven't already (i.e., if interrupted by signal)
+        if signum is not None and not _continue_printed:
+            print(json.dumps({"action": "continue"}))
+            _continue_printed = True
             sys.exit(0)
 
     # Register cleanup handlers
     signal.signal(signal.SIGTERM, cleanup_handler)
     signal.signal(signal.SIGINT, cleanup_handler)
-    atexit.register(cleanup_handler)
+    # Don't register atexit handler since we're handling exit properly in main
 
     try:
         # Use singleton pattern to prevent creating multiple instances
@@ -931,14 +1001,19 @@ def main():
 
             handler = _global_handler
 
+        # Mark that handle() will print continue
         handler.handle()
+        _continue_printed = True  # Mark as printed since handle() always prints it
 
-        # Ensure we exit after handling
-        cleanup_handler()
+        # handler.handle() already calls _continue_execution(), so we don't need to do it again
+        # Just exit cleanly
+        sys.exit(0)
 
     except Exception as e:
-        # Always output continue action to not block Claude
-        print(json.dumps({"action": "continue"}))
+        # Only output continue if not already printed
+        if not _continue_printed:
+            print(json.dumps({"action": "continue"}))
+            _continue_printed = True
         # Log error for debugging
         if DEBUG:
             print(f"Hook handler error: {e}", file=sys.stderr)

claude_mpm/hooks/claude_hooks/hook_wrapper.sh

@@ -57,3 +57,6 @@ if ! "$PYTHON_CMD" -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/hoo
     echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Hook handler failed, see /tmp/hook-error.log" >> /tmp/hook-wrapper.log
     exit 0
 fi
+
+# Success - Python handler already printed continue, just exit
+exit 0

claude_mpm/init.py

@@ -47,6 +47,7 @@ class ProjectInitializer:
                 self.user_dir / "logs",
                 self.user_dir / "templates",
                 self.user_dir / "registry",
+                self.user_dir / "memories",  # Add user-level memories directory
             ]
 
             for directory in directories:

claude_mpm/scripts/mcp_server.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""MCP Server launcher script for Claude Desktop.
+
+This script launches the MCP gateway server for Claude Desktop integration.
+It handles proper Python path setup and error reporting to stderr.
+"""
+
+import sys
+import os
+import logging
+
+# Since we're now in src/claude_mpm/scripts/, we need to go up 3 levels to reach the project root
+# Then down into src to add it to the path
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+sys.path.insert(0, os.path.join(project_root, 'src'))
+
+def setup_logging():
+    """Configure logging to stderr to avoid interfering with stdio protocol."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        stream=sys.stderr,
+    )
+
+def main():
+    """Main entry point for the MCP server launcher."""
+    try:
+        # Setup logging first
+        setup_logging()
+        logger = logging.getLogger("MCPLauncher")
+        
+        # Import modules after path setup
+        try:
+            from claude_mpm.services.mcp_gateway.server.stdio_server import SimpleMCPServer
+            import asyncio
+        except ImportError as e:
+            logger.error(f"Failed to import required modules: {e}")
+            logger.error("Make sure claude-mpm is properly installed")
+            sys.exit(1)
+        
+        # Create and run server
+        logger.info("Starting MCP Gateway Server...")
+        
+        async def run_server():
+            """Async function to run the server."""
+            try:
+                server = SimpleMCPServer(name="claude-mpm-gateway", version="1.0.0")
+                await server.run()
+            except Exception as e:
+                logger.error(f"Server runtime error: {e}")
+                raise
+        
+        # Run the async server
+        asyncio.run(run_server())
+        
+    except KeyboardInterrupt:
+        # Clean shutdown on Ctrl+C
+        logger.info("Server shutdown requested")
+        sys.exit(0)
+    except Exception as e:
+        # Log any unexpected errors
+        logger.error(f"Unexpected error: {e}")
+        import traceback
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

claude_mpm/scripts/mcp_wrapper.py

@@ -0,0 +1,39 @@
+"""
+MCP Wrapper Module
+==================
+
+This module provides an importable entry point for the MCP wrapper script.
+It delegates to the actual wrapper script in the scripts directory.
+
+WHY: We need this to make the wrapper accessible as a Python module entry point
+for the pyproject.toml scripts configuration.
+"""
+
+import sys
+import os
+from pathlib import Path
+
+
+def entry_point():
+    """Entry point that delegates to the actual wrapper script."""
+    # Find the actual wrapper script
+    current_file = Path(__file__).resolve()
+    project_root = current_file.parent.parent.parent.parent
+    wrapper_script = project_root / "scripts" / "mcp_wrapper.py"
+    
+    if not wrapper_script.exists():
+        print(f"Error: Wrapper script not found at {wrapper_script}", file=sys.stderr)
+        sys.exit(1)
+    
+    # Add the scripts directory to path and import the wrapper
+    scripts_dir = str(wrapper_script.parent)
+    if scripts_dir not in sys.path:
+        sys.path.insert(0, scripts_dir)
+    
+    # Import and run the wrapper
+    import mcp_wrapper
+    mcp_wrapper.main()
+
+
+if __name__ == "__main__":
+    entry_point()