claude-mpm 4.7.4__py3-none-any.whl → 4.18.2__py3-none-any.whl

claude_mpm/services/self_upgrade_service.py

@@ -0,0 +1,342 @@
+"""
+Self-Upgrade Service
+====================
+
+Handles version checking and self-upgrade functionality for claude-mpm.
+Supports pip, pipx, and npm installations with automatic detection.
+
+WHY: Users should be notified of updates and have an easy way to upgrade
+without manually running installation commands.
+
+DESIGN DECISIONS:
+- Detects installation method (pip/pipx/npm/editable)
+- Non-blocking version checks with caching
+- Interactive upgrade prompts with confirmation
+- Automatic restart after upgrade
+- Graceful failure handling (never breaks existing installation)
+"""
+
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+from packaging import version
+
+from ..core.logger import get_logger
+from ..core.unified_paths import PathContext
+from .mcp_gateway.utils.package_version_checker import PackageVersionChecker
+
+
+class InstallationMethod:
+    """Installation method enumeration."""
+
+    PIP = "pip"
+    PIPX = "pipx"
+    NPM = "npm"
+    EDITABLE = "editable"
+    UNKNOWN = "unknown"
+
+
+class SelfUpgradeService:
+    """
+    Service for checking and performing self-upgrades.
+
+    Capabilities:
+    - Detect current installation method
+    - Check PyPI/npm for latest version
+    - Prompt user for upgrade confirmation
+    - Execute upgrade command
+    - Restart after upgrade
+    """
+
+    def __init__(self):
+        """Initialize the self-upgrade service."""
+        self.logger = get_logger("SelfUpgradeService")
+        self.version_checker = PackageVersionChecker()
+        self.current_version = self._get_current_version()
+        self.installation_method = self._detect_installation_method()
+
+    def _get_current_version(self) -> str:
+        """
+        Get the current installed version.
+
+        Returns:
+            Version string (e.g., "4.7.10")
+        """
+        try:
+            from .. import __version__
+
+            return __version__
+        except ImportError:
+            # Fallback to VERSION file
+            try:
+                version_file = Path(__file__).parent.parent / "VERSION"
+                if version_file.exists():
+                    return version_file.read_text().strip()
+            except Exception:
+                pass
+
+        return "unknown"
+
+    def _detect_installation_method(self) -> str:
+        """
+        Detect how claude-mpm was installed.
+
+        Returns:
+            Installation method constant
+        """
+        # Check for editable install
+        if PathContext.detect_deployment_context().name in [
+            "DEVELOPMENT",
+            "EDITABLE_INSTALL",
+        ]:
+            return InstallationMethod.EDITABLE
+
+        # Check for pipx by looking at executable path
+        executable = sys.executable
+        if "pipx" in executable:
+            return InstallationMethod.PIPX
+
+        # Check if npm wrapper is present
+        try:
+            result = subprocess.run(
+                ["npm", "list", "-g", "claude-mpm"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and "claude-mpm" in result.stdout:
+                return InstallationMethod.NPM
+        except Exception:
+            pass
+
+        # Default to pip
+        return InstallationMethod.PIP
+
+    async def check_for_update(
+        self, cache_ttl: Optional[int] = None
+    ) -> Optional[Dict[str, any]]:
+        """
+        Check if an update is available.
+
+        Args:
+            cache_ttl: Cache time-to-live in seconds (default: 24 hours)
+
+        Returns:
+            Dict with update info or None:
+            {
+                "current": "4.7.10",
+                "latest": "4.7.11",
+                "update_available": True,
+                "installation_method": "pipx",
+                "upgrade_command": "pipx upgrade claude-mpm"
+            }
+        """
+        if self.current_version == "unknown":
+            self.logger.warning("Cannot check for updates: version unknown")
+            return None
+
+        # Check PyPI for Python installations
+        if self.installation_method in [
+            InstallationMethod.PIP,
+            InstallationMethod.PIPX,
+        ]:
+            result = await self.version_checker.check_for_update(
+                "claude-mpm", self.current_version, cache_ttl
+            )
+            if result and result.get("update_available"):
+                result["installation_method"] = self.installation_method
+                result["upgrade_command"] = self._get_upgrade_command()
+                return result
+
+        # Check npm for npm installations
+        elif self.installation_method == InstallationMethod.NPM:
+            npm_version = await self._check_npm_version()
+            if npm_version:
+                current_ver = version.parse(self.current_version)
+                latest_ver = version.parse(npm_version)
+                if latest_ver > current_ver:
+                    return {
+                        "current": self.current_version,
+                        "latest": npm_version,
+                        "update_available": True,
+                        "installation_method": InstallationMethod.NPM,
+                        "upgrade_command": self._get_upgrade_command(),
+                        "checked_at": datetime.now(timezone.utc).isoformat(),
+                    }
+
+        return None
+
+    async def _check_npm_version(self) -> Optional[str]:
+        """
+        Check npm registry for latest version.
+
+        Returns:
+            Latest version string or None
+        """
+        try:
+            result = subprocess.run(
+                ["npm", "view", "claude-mpm", "version"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except Exception as e:
+            self.logger.debug(f"npm version check failed: {e}")
+
+        return None
+
+    def _get_upgrade_command(self) -> str:
+        """
+        Get the appropriate upgrade command for current installation method.
+
+        Returns:
+            Shell command string to upgrade claude-mpm
+        """
+        if self.installation_method == InstallationMethod.PIPX:
+            return "pipx upgrade claude-mpm"
+        if self.installation_method == InstallationMethod.NPM:
+            return "npm update -g claude-mpm"
+        if self.installation_method == InstallationMethod.PIP:
+            return f"{sys.executable} -m pip install --upgrade claude-mpm"
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return "git pull && pip install -e ."
+        return "pip install --upgrade claude-mpm"
+
+    def prompt_for_upgrade(self, update_info: Dict[str, any]) -> bool:
+        """
+        Prompt user to upgrade.
+
+        Args:
+            update_info: Update information dict
+
+        Returns:
+            True if user confirms upgrade, False otherwise
+        """
+        current = update_info["current"]
+        latest = update_info["latest"]
+        method = update_info.get("installation_method", "unknown")
+
+        print("\n🎉 New version available!")
+        print(f"   Current: v{current}")
+        print(f"   Latest:  v{latest}")
+        print(f"   Installation method: {method}")
+        print(f"\nTo upgrade, run: {update_info['upgrade_command']}")
+
+        try:
+            response = input("\nWould you like to upgrade now? [y/N]: ").strip().lower()
+            return response in ["y", "yes"]
+        except (KeyboardInterrupt, EOFError):
+            print("\n")
+            return False
+
+    def perform_upgrade(self, update_info: Dict[str, any]) -> Tuple[bool, str]:
+        """
+        Perform the upgrade.
+
+        Args:
+            update_info: Update information dict
+
+        Returns:
+            Tuple of (success: bool, message: str)
+        """
+        command = update_info["upgrade_command"]
+
+        # Don't upgrade editable installs automatically
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return (
+                False,
+                "Editable installation detected. Please update manually with: git pull && pip install -e .",
+            )
+
+        print("\n⏳ Upgrading claude-mpm...")
+        print(f"   Running: {command}")
+
+        try:
+            # Execute upgrade command
+            result = subprocess.run(
+                command,
+                check=False,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=300,  # 5 minutes
+            )
+
+            if result.returncode == 0:
+                return (True, f"✅ Successfully upgraded to v{update_info['latest']}")
+            error_msg = result.stderr or result.stdout or "Unknown error"
+            return (False, f"❌ Upgrade failed: {error_msg}")
+
+        except subprocess.TimeoutExpired:
+            return (False, "❌ Upgrade timed out")
+        except Exception as e:
+            return (False, f"❌ Upgrade failed: {e!s}")
+
+    def restart_after_upgrade(self) -> None:
+        """
+        Restart claude-mpm after a successful upgrade.
+
+        Preserves original command line arguments.
+        """
+        print("\n🔄 Restarting claude-mpm...")
+
+        try:
+            # Get current command line arguments
+            args = sys.argv[:]
+
+            # Replace current process with new one
+            if self.installation_method == InstallationMethod.PIPX:
+                # Use pipx run
+                os.execvp("pipx", ["pipx", "run", "claude-mpm", *args[1:]])
+            elif self.installation_method == InstallationMethod.NPM:
+                # Use npm executable
+                os.execvp("claude-mpm", args)
+            else:
+                # Use Python executable
+                os.execvp(sys.executable, [sys.executable, *args])
+
+        except Exception as e:
+            self.logger.error(f"Failed to restart: {e}")
+            print(f"\n⚠️  Restart failed: {e}")
+            print("Please restart claude-mpm manually.")
+
+    async def check_and_prompt_on_startup(
+        self, auto_upgrade: bool = False
+    ) -> Optional[Dict[str, any]]:
+        """
+        Check for updates on startup and optionally prompt user.
+
+        Args:
+            auto_upgrade: If True, upgrade without prompting (use with caution)
+
+        Returns:
+            Update info if available, None otherwise
+        """
+        # Skip for editable installs
+        if self.installation_method == InstallationMethod.EDITABLE:
+            return None
+
+        try:
+            update_info = await self.check_for_update()
+
+            if update_info and update_info.get("update_available"):
+                if auto_upgrade or self.prompt_for_upgrade(update_info):
+                    success, message = self.perform_upgrade(update_info)
+                    print(message)
+                    if success:
+                        self.restart_after_upgrade()
+
+                return update_info
+
+        except Exception as e:
+            self.logger.debug(f"Startup version check failed: {e}")
+
+        return None

claude_mpm/services/session_management_service.py

@@ -17,6 +17,7 @@ from datetime import timezone
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.base_service import BaseService
+from claude_mpm.core.enums import OperationResult, ServiceState
 from claude_mpm.services.core.interfaces import SessionManagementInterface
 
 
@@ -223,7 +224,7 @@ class SessionManagementService(BaseService, SessionManagementInterface):
             "id": session_id,
             "config": session_config,
             "start_time": time.time(),
-            "status": "active",
+            "status": ServiceState.RUNNING,
             "type": session_config.get("type", "interactive"),
         }
 
@@ -267,7 +268,7 @@ class SessionManagementService(BaseService, SessionManagementInterface):
             return self.active_sessions[session_id].copy()
         return {
             "id": session_id,
-            "status": "not_found",
+            "status": OperationResult.ERROR,
             "error": "Session not found",
         }
 

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:
         """