claude-mpm 4.5.5__py3-none-any.whl → 4.5.8__py3-none-any.whl

claude_mpm/services/mcp_config_manager.py

@@ -41,6 +41,14 @@ class MCPConfigManager:
         "kuzu-memory",
     }
 
+    # Known missing dependencies for MCP services that pipx doesn't handle automatically
+    # Maps service names to list of missing dependencies that need injection
+    SERVICE_MISSING_DEPENDENCIES = {
+        "mcp-ticketer": ["gql"],  # mcp-ticketer v0.1.8+ needs gql but doesn't declare it
+        # Add more services here as needed, e.g.:
+        # "another-service": ["dep1", "dep2"],
+    }
+
     # Static known-good MCP service configurations
     # These are the correct, tested configurations that work reliably
     # Note: Commands will be resolved to full paths dynamically in get_static_service_config()
@@ -943,6 +951,11 @@ class MCPConfigManager:
                 )
 
                 if result.returncode == 0:
+                    # Inject any missing dependencies if needed
+                    if service_name in self.SERVICE_MISSING_DEPENDENCIES:
+                        self.logger.debug(f"Injecting missing dependencies for newly installed {service_name}...")
+                        self._inject_missing_dependencies(service_name)
+
                     # Verify installation worked
                     if self._verify_service_installed(service_name, "pipx"):
                         return True, "pipx"
@@ -1092,18 +1105,39 @@ class MCPConfigManager:
                     failed_services.append(f"{service_name} (reinstall failed)")
 
             elif issue_type == "missing_dependency":
-                # Fix missing dependencies by automatically reinstalling
+                # Fix missing dependencies - try injection first, then reinstall if needed
                 self.logger.info(
-                    f"  {service_name} has missing dependencies - auto-reinstalling..."
+                    f"  {service_name} has missing dependencies - attempting fix..."
                 )
+
+                # First try to inject dependencies without reinstalling
+                injection_success = self._inject_missing_dependencies(service_name)
+
+                if injection_success:
+                    # Verify the fix worked
+                    issue_after_injection = self._detect_service_issue(service_name)
+                    if issue_after_injection is None:
+                        fixed_services.append(f"{service_name} (dependencies injected)")
+                        self.logger.info(f"  ✅ Fixed {service_name} with dependency injection")
+                        continue  # Move to next service
+
+                # If injection alone didn't work, try full reinstall
+                self.logger.info("  Dependency injection insufficient, trying full reinstall...")
                 success = self._auto_reinstall_mcp_service(service_name)
                 if success:
-                    fixed_services.append(f"{service_name} (auto-reinstalled)")
+                    fixed_services.append(f"{service_name} (auto-reinstalled with dependencies)")
                 else:
-                    self.logger.warning(
-                        f"  Auto-reinstall failed for {service_name}. Manual fix: "
-                        f"pipx uninstall {service_name} && pipx install {service_name}"
-                    )
+                    # Provide specific manual fix for known services
+                    if service_name == "mcp-ticketer":
+                        self.logger.warning(
+                            f"  Auto-fix failed for {service_name}. Manual fix: "
+                            f"pipx uninstall {service_name} && pipx install {service_name} && pipx inject {service_name} gql"
+                        )
+                    else:
+                        self.logger.warning(
+                            f"  Auto-reinstall failed for {service_name}. Manual fix: "
+                            f"pipx uninstall {service_name} && pipx install {service_name}"
+                        )
                     failed_services.append(f"{service_name} (auto-reinstall failed)")
 
             elif issue_type == "path_issue":
@@ -1129,7 +1163,11 @@ class MCPConfigManager:
             message += "\n\n💡 Manual fix instructions:"
             for failed in failed_services:
                 service = failed.split(" ")[0]
-                message += f"\n  • {service}: pipx uninstall {service} && pipx install {service}"
+                if service in self.SERVICE_MISSING_DEPENDENCIES:
+                    deps = " ".join([f"&& pipx inject {service} {dep}" for dep in self.SERVICE_MISSING_DEPENDENCIES[service]])
+                    message += f"\n  • {service}: pipx uninstall {service} && pipx install {service} {deps}"
+                else:
+                    message += f"\n  • {service}: pipx uninstall {service} && pipx install {service}"
 
         return success, message
 
@@ -1148,7 +1186,58 @@ class MCPConfigManager:
 
         # Try to run the service with --help to detect issues
         try:
-            # Test with pipx run
+            # First check if service is installed in pipx venv
+            pipx_venv_bin = self.pipx_base / service_name / "bin" / service_name
+            if pipx_venv_bin.exists():
+                # Test the installed version directly (has injected dependencies)
+                # This avoids using pipx run which downloads a fresh cache copy without dependencies
+                self.logger.debug(f"Testing {service_name} from installed pipx venv: {pipx_venv_bin}")
+                result = subprocess.run(
+                    [str(pipx_venv_bin), "--help"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                    check=False,
+                )
+
+                # Check for specific error patterns in installed version
+                stderr_lower = result.stderr.lower()
+                stdout_lower = result.stdout.lower()
+                combined_output = stderr_lower + stdout_lower
+
+                # Import errors in installed version (should be rare if dependencies injected)
+                if (
+                    "modulenotfounderror" in combined_output
+                    or "importerror" in combined_output
+                ):
+                    # Check if it's specifically the gql dependency for mcp-ticketer
+                    if service_name == "mcp-ticketer" and "gql" in combined_output:
+                        return "missing_dependency"
+                    return "import_error"
+
+                # Path issues
+                if "no such file or directory" in combined_output:
+                    return "path_issue"
+
+                # If help text appears, service is working
+                if (
+                    "usage:" in combined_output
+                    or "help" in combined_output
+                    or result.returncode in [0, 1]
+                ):
+                    self.logger.debug(f"{service_name} is working correctly")
+                    return None  # Service is working
+
+                # Unknown issue
+                if result.returncode not in [0, 1]:
+                    self.logger.debug(f"{service_name} returned unexpected exit code: {result.returncode}")
+                    return "unknown_error"
+
+                return None  # Default to working if no issues detected
+
+            # Service not installed in pipx venv - use pipx run for detection
+            # Note: pipx run uses cache which may not have injected dependencies
+            self.logger.debug(f"Testing {service_name} via pipx run (not installed in venv)")
             result = subprocess.run(
                 ["pipx", "run", service_name, "--help"],
                 capture_output=True,
@@ -1169,15 +1258,15 @@ class MCPConfigManager:
             ):
                 return "not_installed"
 
-            # Import errors (like mcp-ticketer's corrupted state)
+            # Import errors when using pipx run (cache version)
             if (
                 "modulenotfounderror" in combined_output
                 or "importerror" in combined_output
             ):
-                # Check if it's specifically the gql dependency for mcp-ticketer
-                if service_name == "mcp-ticketer" and "gql" in combined_output:
-                    return "missing_dependency"
-                return "import_error"
+                # Don't report missing_dependency for cache version - it may be missing injected deps
+                # Just report that service needs to be installed properly
+                self.logger.debug(f"{service_name} has import errors in pipx run cache - needs proper installation")
+                return "not_installed"
 
             # Path issues
             if "no such file or directory" in combined_output:
@@ -1240,6 +1329,11 @@ class MCPConfigManager:
             )
 
             if install_result.returncode == 0:
+                # Inject any missing dependencies if needed
+                if service_name in self.SERVICE_MISSING_DEPENDENCIES:
+                    self.logger.debug(f"Injecting missing dependencies for {service_name}...")
+                    self._inject_missing_dependencies(service_name)
+
                 # Verify the reinstall worked
                 issue = self._detect_service_issue(service_name)
                 if issue is None:
@@ -1258,6 +1352,65 @@ class MCPConfigManager:
             self.logger.error(f"Error reinstalling {service_name}: {e}")
             return False
 
+    def _inject_missing_dependencies(self, service_name: str) -> bool:
+        """
+        Inject missing dependencies into a pipx-installed MCP service.
+
+        Some MCP services don't properly declare all their dependencies in their
+        package metadata, which causes import errors when pipx creates isolated
+        virtual environments. This method injects the missing dependencies using
+        pipx inject.
+
+        Args:
+            service_name: Name of the MCP service to fix
+
+        Returns:
+            True if dependencies were injected successfully or no injection needed, False otherwise
+        """
+        # Check if this service has known missing dependencies
+        if service_name not in self.SERVICE_MISSING_DEPENDENCIES:
+            return True  # No dependencies to inject
+
+        missing_deps = self.SERVICE_MISSING_DEPENDENCIES[service_name]
+        if not missing_deps:
+            return True  # No dependencies to inject
+
+        self.logger.info(
+            f"  → Injecting missing dependencies for {service_name}: {', '.join(missing_deps)}"
+        )
+
+        all_successful = True
+        for dep in missing_deps:
+            try:
+                self.logger.debug(f"    Injecting {dep} into {service_name}...")
+                result = subprocess.run(
+                    ["pipx", "inject", service_name, dep],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                    check=False,
+                )
+
+                if result.returncode == 0:
+                    self.logger.info(f"    ✅ Successfully injected {dep}")
+                # Check if already injected (pipx will complain if package already exists)
+                elif "already satisfied" in result.stderr.lower() or "already installed" in result.stderr.lower():
+                    self.logger.debug(f"    {dep} already present in {service_name}")
+                else:
+                    self.logger.error(
+                        f"    Failed to inject {dep}: {result.stderr}"
+                    )
+                    all_successful = False
+
+            except subprocess.TimeoutExpired:
+                self.logger.error(f"    Timeout while injecting {dep}")
+                all_successful = False
+            except Exception as e:
+                self.logger.error(f"    Error injecting {dep}: {e}")
+                all_successful = False
+
+        return all_successful
+
     def _auto_reinstall_mcp_service(self, service_name: str) -> bool:
         """
         Automatically reinstall an MCP service with missing dependencies.
@@ -1312,6 +1465,14 @@ class MCPConfigManager:
                 )
                 return False
 
+            # Inject any missing dependencies that pipx doesn't handle automatically
+            if service_name in self.SERVICE_MISSING_DEPENDENCIES:
+                self.logger.info(f"  → Fixing missing dependencies for {service_name}...")
+                if not self._inject_missing_dependencies(service_name):
+                    self.logger.warning(
+                        f"Failed to inject all dependencies for {service_name}, but continuing..."
+                    )
+
             # Verify the reinstall worked
             self.logger.info(f"  → Verifying {service_name} installation...")
             issue = self._detect_service_issue(service_name)
@@ -1319,9 +1480,17 @@ class MCPConfigManager:
             if issue is None:
                 self.logger.info(f"  ✅ Successfully reinstalled {service_name}")
                 return True
-            self.logger.warning(
-                f"Reinstalled {service_name} but still has issue: {issue}"
-            )
+
+            # If still has missing dependency issue after injection, log specific instructions
+            if issue == "missing_dependency" and service_name == "mcp-ticketer":
+                self.logger.error(
+                    f"  {service_name} still has missing dependencies after injection. "
+                    f"Manual fix: pipx inject {service_name} gql"
+                )
+            else:
+                self.logger.warning(
+                    f"Reinstalled {service_name} but still has issue: {issue}"
+                )
             return False
 
         except subprocess.TimeoutExpired:

claude_mpm/services/project/archive_manager.py

@@ -961,7 +961,6 @@ Generated by Claude MPM Archive Manager
             content,
         )
 
-
     def display_review_summary(self, review: Dict) -> None:
         """Display a formatted summary of the documentation review."""
         console.print("\n[bold cyan]📚 Documentation Review Summary[/bold cyan]\n")

claude_mpm/services/project/documentation_manager.py

@@ -233,7 +233,6 @@ class DocumentationManager:
         # Add metadata
         return self._add_metadata(merged)
 
-
     def _parse_into_sections(self, content: str) -> Dict[str, str]:
         """Parse markdown content into a dictionary of sections."""
         sections = {}

claude_mpm/services/project/project_organizer.py

@@ -979,10 +979,7 @@ This directory is used for {description.lower()}.
         for file in root_files:
             if file.is_file() and (
                 ("test" in file.name.lower() and file.suffix == ".py")
-                or (
-                    file.suffix in [".sh", ".bash"]
-                    and file.name not in ["Makefile"]
-                )
+                or (file.suffix in [".sh", ".bash"] and file.name not in ["Makefile"])
                 or file.suffix in [".log", ".tmp", ".cache"]
             ):
                 misplaced_count += 1

claude_mpm/services/response_tracker.py

@@ -19,6 +19,7 @@ DESIGN DECISIONS:
 """
 
 from datetime import datetime, timezone
+from threading import Lock
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.config import Config
@@ -214,12 +215,15 @@ class ResponseTracker:
             logger.info(f"Response tracker session ID set to: {session_id}")
 
 
-# Singleton instance for consistency
+# Singleton instance with thread-safe initialization
 _tracker_instance = None
+_tracker_lock = Lock()
 
 
 def get_response_tracker(config: Optional[Config] = None) -> ResponseTracker:
-    """Get the singleton response tracker instance.
+    """Get the singleton response tracker instance with thread-safe initialization.
+
+    Uses double-checked locking pattern to ensure thread safety.
 
     Args:
         config: Optional configuration instance
@@ -228,9 +232,16 @@ def get_response_tracker(config: Optional[Config] = None) -> ResponseTracker:
         The shared ResponseTracker instance
     """
     global _tracker_instance
-    if _tracker_instance is None:
-        _tracker_instance = ResponseTracker(config=config)
-    return _tracker_instance
+
+    # Fast path - check without lock
+    if _tracker_instance is not None:
+        return _tracker_instance
+
+    # Slow path - acquire lock and double-check
+    with _tracker_lock:
+        if _tracker_instance is None:
+            _tracker_instance = ResponseTracker(config=config)
+        return _tracker_instance
 
 
 def track_response(

claude_mpm/services/session_manager.py

@@ -0,0 +1,174 @@
+"""
+Session Manager Service
+
+Centralized session ID management with thread-safe singleton pattern.
+Ensures a single session ID is generated and used across all components.
+
+This service addresses race conditions and duplicate session ID generation
+by providing a single source of truth for session identifiers.
+"""
+
+import os
+from datetime import datetime, timezone
+from threading import Lock
+from typing import Optional
+
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class SessionManager:
+    """
+    Thread-safe singleton session manager.
+
+    Provides centralized session ID generation and management to prevent
+    duplicate session IDs across different components.
+
+    Uses double-checked locking pattern for thread-safe singleton initialization.
+    """
+
+    _instance: Optional["SessionManager"] = None
+    _lock = Lock()
+    _initialized = False
+
+    def __new__(cls) -> "SessionManager":
+        """
+        Create or return the singleton instance using double-checked locking.
+
+        Returns:
+            The singleton SessionManager instance
+        """
+        # First check without lock (fast path)
+        if cls._instance is None:
+            # Acquire lock for thread safety
+            with cls._lock:
+                # Double-check inside lock
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        """
+        Initialize the session manager (only once).
+
+        This method uses an initialization flag to ensure it only
+        runs once, even if __init__ is called multiple times.
+        """
+        # Use class-level lock to ensure thread-safe initialization
+        with self.__class__._lock:
+            if self.__class__._initialized:
+                return
+
+            # Generate session ID once during initialization
+            self._session_id = self._generate_session_id()
+            self._session_start_time = datetime.now(timezone.utc)
+
+            # Mark as initialized
+            self.__class__._initialized = True
+
+            logger.info(
+                f"SessionManager initialized with session ID: {self._session_id}"
+            )
+
+    def _generate_session_id(self) -> str:
+        """
+        Generate or retrieve a session ID.
+
+        Checks environment variables first, then generates a timestamp-based ID.
+
+        Returns:
+            A unique session identifier
+        """
+        # Check environment variables in order of preference
+        env_vars = ["CLAUDE_SESSION_ID", "ANTHROPIC_SESSION_ID", "SESSION_ID"]
+
+        for env_var in env_vars:
+            session_id = os.environ.get(env_var)
+            if session_id:
+                logger.info(f"Using session ID from {env_var}: {session_id}")
+                return session_id
+
+        # Generate timestamp-based session ID
+        session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+        logger.info(f"Generated new session ID: {session_id}")
+        return session_id
+
+    def get_session_id(self) -> str:
+        """
+        Get the current session ID.
+
+        Thread-safe method to retrieve the session ID.
+
+        Returns:
+            The current session ID
+        """
+        return self._session_id
+
+    def get_session_start_time(self) -> datetime:
+        """
+        Get the session start time.
+
+        Returns:
+            The datetime when the session was initialized
+        """
+        return self._session_start_time
+
+    def set_session_id(self, session_id: str) -> None:
+        """
+        Override the session ID.
+
+        This should only be used in special circumstances, as it can
+        break the single session ID guarantee.
+
+        Args:
+            session_id: The new session ID to use
+        """
+        with self.__class__._lock:
+            old_id = self._session_id
+            if old_id != session_id:
+                self._session_id = session_id
+                logger.warning(f"Session ID changed from {old_id} to {session_id}")
+            else:
+                logger.debug(f"Session ID already set to {session_id}, no change needed")
+
+    @classmethod
+    def reset(cls) -> None:
+        """
+        Reset the singleton instance (mainly for testing).
+
+        This method should not be used in production code.
+        """
+        with cls._lock:
+            cls._instance = None
+            cls._initialized = False
+            logger.debug("SessionManager singleton reset")
+
+
+# Global accessor function
+_manager: Optional[SessionManager] = None
+
+
+def get_session_manager() -> SessionManager:
+    """
+    Get the global SessionManager instance.
+
+    Thread-safe accessor that ensures a single SessionManager exists.
+
+    Returns:
+        The singleton SessionManager instance
+    """
+    global _manager
+    if _manager is None:
+        _manager = SessionManager()
+    return _manager
+
+
+def get_session_id() -> str:
+    """
+    Convenience function to get the current session ID.
+
+    Returns:
+        The current session ID
+    """
+    return get_session_manager().get_session_id()

claude_mpm/services/unified/analyzer_strategies/dependency_analyzer.py

@@ -580,7 +580,6 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
         # In production, you would integrate with vulnerability databases
         # like npm audit, pip-audit, or safety
 
-
     def _calculate_statistics(self, results: Dict[str, Any]) -> Dict[str, Any]:
         """Calculate dependency statistics."""
         all_deps = self._flatten_dependencies(results.get("dependencies", {}))

claude_mpm/services/unified/analyzer_strategies/structure_analyzer.py

@@ -716,9 +716,13 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
                         }
 
         # Compare architecture
-        if "architecture" in baseline and "architecture" in current and (
-            baseline["architecture"]["pattern"]
-            != current["architecture"]["pattern"]
+        if (
+            "architecture" in baseline
+            and "architecture" in current
+            and (
+                baseline["architecture"]["pattern"]
+                != current["architecture"]["pattern"]
+            )
         ):
             comparison["architecture_change"] = {
                 "baseline": baseline["architecture"]["pattern"],

claude_mpm/services/unified/config_strategies/context_strategy.py

@@ -509,9 +509,7 @@ class CachingContextManager:
     def invalidate_context(self, context_id: str):
         """Invalidate all cached values for context"""
         with self._lock:
-            keys_to_remove = [
-                k for k in self.cache if k.startswith(f"{context_id}:")
-            ]
+            keys_to_remove = [k for k in self.cache if k.startswith(f"{context_id}:")]
 
             for key in keys_to_remove:
                 del self.cache[key]

{claude_mpm-4.5.5.dist-info → claude_mpm-4.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.5.5
+Version: 4.5.8
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team