claude-mpm 4.0.19__py3-none-any.whl → 4.0.22__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/socketio_daemon.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 #!/usr/bin/env python3
 """
 Pure Python daemon management for Socket.IO server.
@@ -12,6 +10,64 @@ import signal
 import subprocess
 import sys
 import time
+from pathlib import Path
+
+# Detect and use virtual environment Python if available
+def get_python_executable():
+    """
+    Get the appropriate Python executable, preferring virtual environment.
+    
+    WHY: The daemon must use the same Python environment as the parent process
+    to ensure all dependencies are available. System Python won't have the
+    required packages installed.
+    """
+    # First, check if we're already in a virtual environment
+    if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+        # We're in a virtual environment, use its Python
+        return sys.executable
+    
+    # Check for common virtual environment indicators
+    # 1. VIRTUAL_ENV environment variable (most common)
+    venv_path = os.environ.get('VIRTUAL_ENV')
+    if venv_path:
+        venv_python = Path(venv_path) / 'bin' / 'python'
+        if venv_python.exists():
+            return str(venv_python)
+    
+    # 2. Check if current executable is in a venv directory structure
+    exe_path = Path(sys.executable).resolve()
+    for parent in exe_path.parents:
+        # Check for common venv directory names
+        if parent.name in ('venv', '.venv', 'env', '.env'):
+            # This looks like a virtual environment
+            return sys.executable
+        
+        # Check for typical venv structure (bin/python or Scripts/python.exe)
+        if parent.name == 'bin' and (parent.parent / 'pyvenv.cfg').exists():
+            return sys.executable
+        if parent.name == 'Scripts' and (parent.parent / 'pyvenv.cfg').exists():
+            return sys.executable
+    
+    # 3. Try to detect project-specific venv
+    # Look for venv in the project root (going up from script location)
+    script_path = Path(__file__).resolve()
+    for parent in script_path.parents:
+        # Stop at src or when we've gone too far up
+        if parent.name == 'src' or not (parent / 'src').exists():
+            # Check for venv directories
+            for venv_name in ('venv', '.venv', 'env', '.env'):
+                venv_dir = parent / venv_name
+                if venv_dir.exists():
+                    venv_python = venv_dir / 'bin' / 'python'
+                    if venv_python.exists():
+                        return str(venv_python)
+            break
+    
+    # Fall back to current Python executable
+    return sys.executable
+
+# Store the detected Python executable for daemon usage
+PYTHON_EXECUTABLE = get_python_executable()
 
 import psutil
 
@@ -145,11 +201,12 @@ def start_server():
 
     ensure_dirs()
 
-    # Fork to create daemon
+    # Fork to create daemon using the correct Python environment
     pid = os.fork()
     if pid > 0:
         # Parent process
         print(f"Starting Socket.IO server on port {selected_port} (PID: {pid})...")
+        print(f"Using Python: {PYTHON_EXECUTABLE}")
 
         # Register the instance
         instance_id = port_manager.register_instance(selected_port, pid)
@@ -179,10 +236,13 @@ def start_server():
         os.dup2(log.fileno(), sys.stdout.fileno())
         os.dup2(log.fileno(), sys.stderr.fileno())
 
-    # Start server
+    # Log environment information for debugging
     print(
         f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Starting Socket.IO server on port {selected_port}..."
     )
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python executable: {sys.executable}")
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python version: {sys.version}")
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python path: {sys.path[:3]}...")  # Show first 3 entries
     server = SocketIOServer(host="localhost", port=selected_port)
 
     # Handle signals
@@ -384,12 +444,12 @@ def main():
 
 
 if __name__ == "__main__":
-    # Install psutil if not available
+    # Install psutil if not available (using correct Python)
     try:
         import psutil
     except ImportError:
-        print("Installing psutil...")
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "psutil"])
+        print(f"Installing psutil using {PYTHON_EXECUTABLE}...")
+        subprocess.check_call([PYTHON_EXECUTABLE, "-m", "pip", "install", "psutil"])
         import psutil
 
     main()