claude-mpm 4.15.2__py3-none-any.whl → 4.20.3__py3-none-any.whl

claude_mpm/services/local_ops/crash_detector.py

@@ -26,10 +26,10 @@ import threading
 from collections import defaultdict
 from typing import Callable, Dict, List, Set
 
+from claude_mpm.core.enums import HealthStatus
 from claude_mpm.services.core.base import SyncBaseService
 from claude_mpm.services.core.interfaces.health import IHealthCheckManager
 from claude_mpm.services.core.interfaces.restart import ICrashDetector
-from claude_mpm.services.core.models.health import HealthStatus
 
 
 class CrashDetector(SyncBaseService, ICrashDetector):

claude_mpm/services/local_ops/health_checks/http_check.py

@@ -29,10 +29,11 @@ import time
 import requests
 from requests.exceptions import ConnectionError, RequestException, Timeout
 
+from claude_mpm.core.enums import HealthStatus
 from claude_mpm.services.core.base import SyncBaseService
 from claude_mpm.services.core.interfaces.health import IHealthCheck
 from claude_mpm.services.core.interfaces.process import ILocalProcessManager
-from claude_mpm.services.core.models.health import HealthCheckResult, HealthStatus
+from claude_mpm.services.core.models.health import HealthCheckResult
 
 
 class HttpHealthCheck(SyncBaseService, IHealthCheck):

claude_mpm/services/local_ops/health_checks/process_check.py

@@ -22,10 +22,11 @@ USAGE:
 
 import psutil
 
+from claude_mpm.core.enums import HealthStatus
 from claude_mpm.services.core.base import SyncBaseService
 from claude_mpm.services.core.interfaces.health import IHealthCheck
 from claude_mpm.services.core.interfaces.process import ILocalProcessManager
-from claude_mpm.services.core.models.health import HealthCheckResult, HealthStatus
+from claude_mpm.services.core.models.health import HealthCheckResult
 
 
 class ProcessHealthCheck(SyncBaseService, IHealthCheck):

claude_mpm/services/local_ops/health_checks/resource_check.py

@@ -28,10 +28,11 @@ import platform
 
 import psutil
 
+from claude_mpm.core.enums import HealthStatus
 from claude_mpm.services.core.base import SyncBaseService
 from claude_mpm.services.core.interfaces.health import IHealthCheck
 from claude_mpm.services.core.interfaces.process import ILocalProcessManager
-from claude_mpm.services.core.models.health import HealthCheckResult, HealthStatus
+from claude_mpm.services.core.models.health import HealthCheckResult
 
 
 class ResourceHealthCheck(SyncBaseService, IHealthCheck):

claude_mpm/services/local_ops/health_manager.py

@@ -39,13 +39,13 @@ import threading
 from collections import defaultdict
 from typing import Callable, Dict, List, Optional
 
+from claude_mpm.core.enums import HealthStatus
 from claude_mpm.services.core.base import SyncBaseService
 from claude_mpm.services.core.interfaces.health import IHealthCheckManager
 from claude_mpm.services.core.interfaces.process import ILocalProcessManager
 from claude_mpm.services.core.models.health import (
     DeploymentHealth,
     HealthCheckResult,
-    HealthStatus,
 )
 from claude_mpm.services.local_ops.health_checks import (
     HttpHealthCheck,

claude_mpm/services/local_ops/restart_manager.py

@@ -43,6 +43,7 @@ import time
 from pathlib import Path
 from typing import Optional, Set
 
+from claude_mpm.core.enums import HealthStatus
 from claude_mpm.services.core.base import SyncBaseService
 from claude_mpm.services.core.interfaces.health import IHealthCheckManager
 from claude_mpm.services.core.interfaces.process import ILocalProcessManager
@@ -51,7 +52,6 @@ from claude_mpm.services.core.interfaces.restart import (
     IRestartManager,
     IRestartPolicy,
 )
-from claude_mpm.services.core.models.health import HealthStatus
 from claude_mpm.services.core.models.restart import RestartHistory
 
 

claude_mpm/services/mcp_config_manager.py

@@ -1130,139 +1130,15 @@ class MCPConfigManager:
         """
         Detect and fix corrupted MCP service installations.
 
-        This method:
-        1. Tests each MCP service for import/execution errors
-        2. Automatically reinstalls corrupted services
-        3. Fixes missing dependencies (like mcp-ticketer's gql)
-        4. Validates fixes worked
+        NOTE: Proactive health checking has been disabled.
+        Each MCP service should stand on its own and handle its own issues.
+        This function now only returns success without checking services.
 
         Returns:
             Tuple of (success, message)
         """
-        services_to_fix = []
-        fixed_services = []
-        failed_services = []
-
-        # Check each service for issues
-        for service_name in self.PIPX_SERVICES:
-            # Check if service is enabled in config
-            if not self.should_enable_service(service_name):
-                self.logger.debug(f"Skipping {service_name} (disabled in config)")
-                continue
-
-            self.logger.debug(f"🔍 Checking {service_name} for issues...")
-            issue_type = self._detect_service_issue(service_name)
-            if issue_type:
-                services_to_fix.append((service_name, issue_type))
-                self.logger.debug(f"  ⚠️  Found issue with {service_name}: {issue_type}")
-            else:
-                self.logger.debug(f"  ✅ {service_name} is functioning correctly")
-
-        if not services_to_fix:
-            return True, "All MCP services are functioning correctly"
-
-        # Fix each problematic service
-        for service_name, issue_type in services_to_fix:
-            self.logger.info(f"🔧 Fixing {service_name}: {issue_type}")
-
-            if issue_type == "not_installed":
-                # Install the service
-                success, method = self._install_service_with_fallback(service_name)
-                if success:
-                    fixed_services.append(f"{service_name} (installed via {method})")
-                else:
-                    failed_services.append(f"{service_name} (installation failed)")
-
-            elif issue_type == "import_error":
-                # Reinstall to fix corrupted installation
-                self.logger.info(
-                    f"  Reinstalling {service_name} to fix import errors..."
-                )
-                success = self._reinstall_service(service_name)
-                if success:
-                    # NOTE: Removed automatic dependency injection workaround
-                    # Package maintainers should fix dependency declarations
-                    fixed_services.append(f"{service_name} (reinstalled)")
-                else:
-                    failed_services.append(f"{service_name} (reinstall failed)")
-
-            elif issue_type == "missing_dependency":
-                # Fix missing dependencies - try injection first, then reinstall if needed
-                self.logger.info(
-                    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 with dependencies)"
-                    )
-                else:
-                    # 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":
-                # Path issues are handled by config updates
-                self.logger.info(
-                    f"  Path issue for {service_name} will be fixed by config update"
-                )
-                fixed_services.append(f"{service_name} (config updated)")
-
-        # Build result message
-        messages = []
-        if fixed_services:
-            messages.append(f"✅ Fixed: {', '.join(fixed_services)}")
-        if failed_services:
-            messages.append(f"❌ Failed: {', '.join(failed_services)}")
-
-        # Return success if at least some services were fixed
-        success = len(fixed_services) > 0 or len(failed_services) == 0
-        message = " | ".join(messages) if messages else "No services needed fixing"
-
-        # Provide manual fix instructions if auto-fix failed
-        if failed_services:
-            message += "\n\n💡 Manual fix instructions:"
-            for failed in failed_services:
-                service = failed.split(" ")[0]
-                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
+        # Services should stand on their own - no proactive health checking
+        return True, "MCP services managing their own health"
 
     def _detect_service_issue(self, service_name: str) -> Optional[str]:
         """
@@ -1497,7 +1373,7 @@ class MCPConfigManager:
                 )
 
                 if result.returncode == 0:
-                    self.logger.info(f"    ✅ Successfully injected {dep}")
+                    self.logger.debug(f"    ✅ Successfully injected {dep}")
                 # Check if already injected (pipx will complain if package already exists)
                 elif (
                     "already satisfied" in result.stderr.lower()
@@ -1582,7 +1458,7 @@ class MCPConfigManager:
                     )
 
             # Verify the reinstall worked
-            self.logger.info(f"  → Verifying {service_name} installation...")
+            self.logger.debug(f"  → Verifying {service_name} installation...")
             issue = self._detect_service_issue(service_name)
 
             if issue is None:

claude_mpm/services/session_manager.py

@@ -6,12 +6,19 @@ 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.
+
+Extended with:
+- Token usage tracking and monitoring
+- Resume log generation on session end
+- Context metrics persistence
+- Automatic resume log injection on session startup
 """
 
 import os
 from datetime import datetime, timezone
+from pathlib import Path
 from threading import Lock
-from typing import Optional
+from typing import Any, Dict, Optional
 
 from claude_mpm.core.logging_utils import get_logger
 
@@ -64,6 +71,24 @@ class SessionManager:
             self._session_id = self._generate_session_id()
             self._session_start_time = datetime.now(timezone.utc)
 
+            # Token usage tracking
+            self._cumulative_tokens = 0
+            self._total_budget = 200000  # Default Claude Code budget
+            self._last_stop_reason: Optional[str] = None
+
+            # Context metrics storage
+            self._context_metrics: Dict[str, Any] = {
+                "total_budget": self._total_budget,
+                "used_tokens": 0,
+                "remaining_tokens": self._total_budget,
+                "percentage_used": 0.0,
+                "stop_reason": None,
+                "model": "claude-sonnet-4.5",
+            }
+
+            # Resume log reference (loaded on startup if exists)
+            self._resume_log_content: Optional[str] = None
+
             # Mark as initialized
             self.__class__._initialized = True
 
@@ -71,6 +96,9 @@ class SessionManager:
                 f"SessionManager initialized with session ID: {self._session_id}"
             )
 
+            # Check for resume log from previous session
+            self._load_resume_log()
+
     def _generate_session_id(self) -> str:
         """
         Generate or retrieve a session ID.
@@ -134,6 +162,182 @@ class SessionManager:
                     f"Session ID already set to {session_id}, no change needed"
                 )
 
+    def update_token_usage(
+        self,
+        input_tokens: int = 0,
+        output_tokens: int = 0,
+        stop_reason: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update cumulative token usage for the session.
+
+        Args:
+            input_tokens: Input tokens from latest API call
+            output_tokens: Output tokens from latest API call
+            stop_reason: Stop reason from Claude API
+
+        Returns:
+            Updated context metrics
+        """
+        with self.__class__._lock:
+            # Update cumulative usage
+            tokens_used = input_tokens + output_tokens
+            self._cumulative_tokens += tokens_used
+
+            # Update stop reason if provided
+            if stop_reason:
+                self._last_stop_reason = stop_reason
+
+            # Calculate metrics
+            remaining = max(0, self._total_budget - self._cumulative_tokens)
+            percentage = (self._cumulative_tokens / self._total_budget) * 100
+
+            # Update context metrics
+            self._context_metrics = {
+                "total_budget": self._total_budget,
+                "used_tokens": self._cumulative_tokens,
+                "remaining_tokens": remaining,
+                "percentage_used": percentage,
+                "stop_reason": self._last_stop_reason,
+                "model": "claude-sonnet-4.5",
+            }
+
+            logger.debug(
+                f"Token usage updated: {self._cumulative_tokens}/{self._total_budget} "
+                f"({percentage:.1f}%) - Stop reason: {stop_reason}"
+            )
+
+            return self._context_metrics.copy()
+
+    def get_context_metrics(self) -> Dict[str, Any]:
+        """
+        Get current context metrics.
+
+        Returns:
+            Dictionary containing token usage and context metrics
+        """
+        with self.__class__._lock:
+            return self._context_metrics.copy()
+
+    def get_token_usage_percentage(self) -> float:
+        """
+        Get current token usage as a percentage (0.0 to 1.0).
+
+        Returns:
+            Token usage percentage
+        """
+        with self.__class__._lock:
+            return self._context_metrics["percentage_used"] / 100.0
+
+    def should_warn_context_limit(self, threshold: float = 0.70) -> bool:
+        """
+        Check if context usage has reached warning threshold.
+
+        Args:
+            threshold: Warning threshold (0.0 to 1.0)
+
+        Returns:
+            True if threshold reached
+        """
+        return self.get_token_usage_percentage() >= threshold
+
+    def _load_resume_log(self) -> None:
+        """
+        Load resume log from previous session if it exists.
+
+        This is called during initialization to check for session continuity.
+        """
+        try:
+            # Lazy import to avoid circular dependencies
+            from claude_mpm.services.infrastructure.resume_log_generator import (
+                ResumeLogGenerator,
+            )
+
+            generator = ResumeLogGenerator()
+
+            # Check if there's a resume log for this session
+            # (Could be from a previous interrupted session with same ID)
+            resume_content = generator.load_resume_log(self._session_id)
+
+            if resume_content:
+                self._resume_log_content = resume_content
+                logger.info(f"Loaded resume log for session {self._session_id}")
+            else:
+                logger.debug("No resume log found for current session")
+
+        except Exception as e:
+            logger.warning(f"Failed to load resume log: {e}")
+            # Non-critical error, continue without resume log
+
+    def get_resume_log_content(self) -> Optional[str]:
+        """
+        Get resume log content if loaded.
+
+        Returns:
+            Resume log markdown content or None
+        """
+        with self.__class__._lock:
+            return self._resume_log_content
+
+    def generate_resume_log(
+        self,
+        session_state: Optional[Dict[str, Any]] = None,
+    ) -> Optional[Path]:
+        """
+        Generate and save resume log for current session.
+
+        Args:
+            session_state: Optional session state data to include
+
+        Returns:
+            Path to saved resume log or None if generation failed
+        """
+        try:
+            # Lazy import to avoid circular dependencies
+            from claude_mpm.models.resume_log import ContextMetrics, ResumeLog
+            from claude_mpm.services.infrastructure.resume_log_generator import (
+                ResumeLogGenerator,
+            )
+
+            generator = ResumeLogGenerator()
+
+            # Create context metrics from current state
+            context_metrics = ContextMetrics(
+                total_budget=self._total_budget,
+                used_tokens=self._cumulative_tokens,
+                remaining_tokens=self._context_metrics["remaining_tokens"],
+                percentage_used=self._context_metrics["percentage_used"],
+                stop_reason=self._last_stop_reason,
+                model=self._context_metrics["model"],
+                session_id=self._session_id,
+            )
+
+            if session_state:
+                # Generate from provided session state
+                resume_log = generator.generate_from_session_state(
+                    session_id=self._session_id,
+                    session_state=session_state,
+                    stop_reason=self._last_stop_reason,
+                )
+            else:
+                # Create minimal resume log
+                resume_log = ResumeLog(
+                    session_id=self._session_id,
+                    context_metrics=context_metrics,
+                    mission_summary="Session ended - resume log auto-generated.",
+                )
+
+            if resume_log:
+                file_path = generator.save_resume_log(resume_log)
+                logger.info(f"Resume log generated and saved: {file_path}")
+                return file_path
+            logger.warning("Resume log generation returned None")
+            return None
+
+        except Exception as e:
+            logger.error(f"Failed to generate resume log: {e}", exc_info=True)
+            return None
+
     @classmethod
     def reset(cls) -> None:
         """

claude_mpm/services/shared/async_service_base.py

@@ -4,23 +4,12 @@ Base class for asynchronous services to reduce duplication.
 
 import asyncio
 from abc import ABC, abstractmethod
-from enum import Enum
 from typing import Any, Dict, Optional
 
+from ...core.enums import ServiceState
 from ...core.mixins import LoggerMixin
 
 
-class AsyncServiceState(Enum):
-    """Standard states for async services."""
-
-    UNINITIALIZED = "uninitialized"
-    INITIALIZING = "initializing"
-    RUNNING = "running"
-    STOPPING = "stopping"
-    STOPPED = "stopped"
-    ERROR = "error"
-
-
 class AsyncServiceBase(LoggerMixin, ABC):
     """
     Base class for asynchronous services.
@@ -45,7 +34,7 @@ class AsyncServiceBase(LoggerMixin, ABC):
         self.config = config or {}
 
         # State management
-        self._state = AsyncServiceState.UNINITIALIZED
+        self._state = ServiceState.UNINITIALIZED
         self._state_lock = asyncio.Lock()
 
         # Background tasks
@@ -57,19 +46,19 @@ class AsyncServiceBase(LoggerMixin, ABC):
         self._error_count = 0
 
     @property
-    def state(self) -> AsyncServiceState:
+    def state(self) -> ServiceState:
         """Get current service state."""
         return self._state
 
     @property
     def is_running(self) -> bool:
         """Check if service is running."""
-        return self._state == AsyncServiceState.RUNNING
+        return self._state == ServiceState.RUNNING
 
     @property
     def is_healthy(self) -> bool:
         """Check if service is healthy."""
-        return self._state == AsyncServiceState.RUNNING and self._last_error is None
+        return self._state == ServiceState.RUNNING and self._last_error is None
 
     async def initialize(self) -> bool:
         """
@@ -79,22 +68,22 @@ class AsyncServiceBase(LoggerMixin, ABC):
             True if initialization successful
         """
         async with self._state_lock:
-            if self._state != AsyncServiceState.UNINITIALIZED:
+            if self._state != ServiceState.UNINITIALIZED:
                 self.logger.warning(f"Service {self.service_name} already initialized")
-                return self._state == AsyncServiceState.RUNNING
+                return self._state == ServiceState.RUNNING
 
-            self._state = AsyncServiceState.INITIALIZING
+            self._state = ServiceState.INITIALIZING
             self.logger.info(f"Initializing service: {self.service_name}")
 
             try:
                 success = await self._do_initialize()
                 if success:
-                    self._state = AsyncServiceState.RUNNING
+                    self._state = ServiceState.RUNNING
                     self.logger.info(
                         f"Service {self.service_name} initialized successfully"
                     )
                 else:
-                    self._state = AsyncServiceState.ERROR
+                    self._state = ServiceState.ERROR
                     self.logger.error(
                         f"Service {self.service_name} initialization failed"
                     )
@@ -102,7 +91,7 @@ class AsyncServiceBase(LoggerMixin, ABC):
                 return success
 
             except Exception as e:
-                self._state = AsyncServiceState.ERROR
+                self._state = ServiceState.ERROR
                 self._last_error = e
                 self._error_count += 1
                 self.logger.error(
@@ -114,10 +103,10 @@ class AsyncServiceBase(LoggerMixin, ABC):
     async def shutdown(self) -> None:
         """Shutdown the service gracefully."""
         async with self._state_lock:
-            if self._state in (AsyncServiceState.STOPPED, AsyncServiceState.STOPPING):
+            if self._state in (ServiceState.STOPPED, ServiceState.STOPPING):
                 return
 
-            self._state = AsyncServiceState.STOPPING
+            self._state = ServiceState.STOPPING
             self.logger.info(f"Shutting down service: {self.service_name}")
 
             try:
@@ -130,11 +119,11 @@ class AsyncServiceBase(LoggerMixin, ABC):
                 # Service-specific shutdown
                 await self._do_shutdown()
 
-                self._state = AsyncServiceState.STOPPED
+                self._state = ServiceState.STOPPED
                 self.logger.info(f"Service {self.service_name} shut down successfully")
 
             except Exception as e:
-                self._state = AsyncServiceState.ERROR
+                self._state = ServiceState.ERROR
                 self._last_error = e
                 self.logger.error(
                     f"Service {self.service_name} shutdown error: {e}", exc_info=True
@@ -146,7 +135,7 @@ class AsyncServiceBase(LoggerMixin, ABC):
         await self.shutdown()
 
         # Reset state for restart
-        self._state = AsyncServiceState.UNINITIALIZED
+        self._state = ServiceState.UNINITIALIZED
         self._shutdown_event.clear()
         self._last_error = None
 

claude_mpm/services/shared/lifecycle_service_base.py

@@ -4,25 +4,12 @@ Base class for services with complex lifecycle management.
 
 import time
 from abc import ABC, abstractmethod
-from enum import Enum
 from typing import Any, Dict, List, Optional
 
+from ...core.enums import ServiceState
 from ...core.mixins import LoggerMixin
 
 
-class ServiceState(Enum):
-    """Standard service states."""
-
-    UNINITIALIZED = "uninitialized"
-    INITIALIZING = "initializing"
-    INITIALIZED = "initialized"
-    STARTING = "starting"
-    RUNNING = "running"
-    STOPPING = "stopping"
-    STOPPED = "stopped"
-    ERROR = "error"
-
-
 class LifecycleServiceBase(LoggerMixin, ABC):
     """
     Base class for services with complex lifecycle management.

claude_mpm/services/socketio/handlers/__init__.py

@@ -7,7 +7,9 @@ and maintainability.
 """
 
 from .base import BaseEventHandler
-from .code_analysis import CodeAnalysisEventHandler
+
+# DISABLED: File Tree interface removed from dashboard
+# from .code_analysis import CodeAnalysisEventHandler
 from .connection import ConnectionEventHandler
 from .file import FileEventHandler
 from .git import GitEventHandler
@@ -17,7 +19,8 @@ from .registry import EventHandlerRegistry
 
 __all__ = [
     "BaseEventHandler",
-    "CodeAnalysisEventHandler",
+    # DISABLED: File Tree interface removed from dashboard
+    # "CodeAnalysisEventHandler",
     "ConnectionEventHandler",
     "EventHandlerRegistry",
     "FileEventHandler",