claude-mpm 4.7.9__tar.gz → 4.7.11__tar.gz

claude_mpm-4.7.11/BUILD_NUMBER

@@ -0,0 +1 @@
+438

{claude_mpm-4.7.9 → claude_mpm-4.7.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.7.9
+Version: 4.7.11
 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

claude_mpm-4.7.11/VERSION

@@ -0,0 +1 @@
+4.7.11

{claude_mpm-4.7.9 → claude_mpm-4.7.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.7.9"
+version = "4.7.11"
 description = "Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -84,7 +84,7 @@ ignore-imports = false
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "4.7.9"
+version = "4.7.11"
 version_files = [ "VERSION", "src/claude_mpm/VERSION", "package.json:version",]
 tag_format = "v$version"
 update_changelog_on_bump = true

claude_mpm-4.7.11/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.7.11

{claude_mpm-4.7.9 → claude_mpm-4.7.11}/src/claude_mpm/cli/__init__.py

@@ -36,6 +36,7 @@ from .commands import (  # run_guarded_session is imported lazily to avoid loadi
 )
 from .commands.analyze_code import manage_analyze_code
 from .commands.dashboard import manage_dashboard
+from .commands.upgrade import upgrade
 from .parser import create_parser, preprocess_args
 from .utils import ensure_directories, setup_logging
 
@@ -232,6 +233,9 @@ def main(argv: Optional[list] = None):
         # Re-enabled: MCP pre-warming is safe with subprocess daemon (v4.2.40)
         # The subprocess approach avoids fork() issues entirely
         _verify_mcp_gateway_startup()
+
+        # Check for updates (non-blocking, async)
+        _check_for_updates_async()
     else:
         # Still need directories for configure command to work
         ensure_directories()
@@ -544,6 +548,83 @@ def _verify_mcp_gateway_startup():
         # Continue execution - MCP gateway issues shouldn't block startup
 
 
+def _check_for_updates_async():
+    """
+    Check for updates in background thread (non-blocking).
+
+    WHY: Users should be notified of new versions and have an easy way to upgrade
+    without manually checking PyPI/npm. This runs asynchronously on startup to avoid
+    blocking the CLI.
+
+    DESIGN DECISION: This is non-blocking and non-critical - failures are logged
+    but don't prevent startup. Only runs for pip/pipx/npm installations, skips
+    editable/development installations.
+    """
+
+    def run_update_check():
+        """Inner function to run in background thread."""
+        loop = None
+        try:
+            import asyncio
+
+            from ..core.logger import get_logger
+            from ..services.self_upgrade_service import SelfUpgradeService
+
+            logger = get_logger("upgrade_check")
+
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            # Create upgrade service and check for updates
+            upgrade_service = SelfUpgradeService()
+
+            # Skip for editable installs (development mode)
+            from ..services.self_upgrade_service import InstallationMethod
+
+            if upgrade_service.installation_method == InstallationMethod.EDITABLE:
+                logger.debug("Skipping version check for editable installation")
+                return
+
+            # Check and prompt for upgrade if available (non-blocking)
+            loop.run_until_complete(upgrade_service.check_and_prompt_on_startup())
+
+        except Exception as e:
+            # Non-critical - log but don't fail startup
+            try:
+                from ..core.logger import get_logger
+
+                logger = get_logger("upgrade_check")
+                logger.debug(f"Update check failed (non-critical): {e}")
+            except Exception:
+                pass  # Avoid any errors in error handling
+        finally:
+            # Properly clean up event loop
+            if loop is not None:
+                try:
+                    # Cancel all running tasks
+                    pending = asyncio.all_tasks(loop)
+                    for task in pending:
+                        task.cancel()
+                    # Wait for tasks to complete cancellation
+                    if pending:
+                        loop.run_until_complete(
+                            asyncio.gather(*pending, return_exceptions=True)
+                        )
+                except Exception:
+                    pass  # Ignore cleanup errors
+                finally:
+                    loop.close()
+                    # Clear the event loop reference to help with cleanup
+                    asyncio.set_event_loop(None)
+
+    # Run update check in background thread to avoid blocking startup
+    import threading
+
+    update_check_thread = threading.Thread(target=run_update_check, daemon=True)
+    update_check_thread.start()
+
+
 def _ensure_run_attributes(args):
     """
     Ensure run command attributes exist when defaulting to run.
@@ -657,6 +738,7 @@ def _execute_command(command: str, args) -> int:
         CLICommands.CLEANUP.value: cleanup_memory,
         CLICommands.MCP.value: manage_mcp,
         CLICommands.DOCTOR.value: run_doctor,
+        CLICommands.UPGRADE.value: upgrade,
         "debug": manage_debug,  # Add debug command
         "mpm-init": None,  # Will be handled separately with lazy import
     }

claude_mpm-4.7.11/src/claude_mpm/cli/commands/upgrade.py

@@ -0,0 +1,152 @@
+"""
+Upgrade command implementation for claude-mpm.
+
+WHY: This module provides a manual upgrade command that allows users to check
+for and install the latest version of claude-mpm without waiting for the
+automatic startup check.
+
+DESIGN DECISIONS:
+- Use BaseCommand for consistent CLI patterns
+- Leverage SelfUpgradeService for upgrade functionality
+- Support multiple installation methods (pip, pipx, npm)
+- Skip editable/development installations (must upgrade manually)
+- Provide clear feedback on available updates and upgrade progress
+"""
+
+import asyncio
+
+from ..shared import BaseCommand, CommandResult
+
+
+class UpgradeCommand(BaseCommand):
+    """Upgrade command using shared utilities."""
+
+    def __init__(self):
+        super().__init__("upgrade")
+
+    def validate_args(self, args) -> str:
+        """Validate command arguments."""
+        # Upgrade command doesn't require specific validation
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the upgrade command."""
+        try:
+            from ...services.self_upgrade_service import (
+                InstallationMethod,
+                SelfUpgradeService,
+            )
+
+            # Create upgrade service
+            upgrade_service = SelfUpgradeService()
+
+            # Check installation method
+            if upgrade_service.installation_method == InstallationMethod.EDITABLE:
+                self.logger.info(
+                    "Editable installation detected - upgrade must be done manually"
+                )
+                print("\n⚠️  Editable Installation Detected")
+                print(
+                    "\nYou are running claude-mpm from an editable installation (development mode)."
+                )
+                print("To upgrade, run:")
+                print("  cd /path/to/claude-mpm")
+                print("  git pull")
+                print("  pip install -e .")
+                return CommandResult.success_result(
+                    "Upgrade information provided for editable installation"
+                )
+
+            # Check for updates
+            print("\n🔍 Checking for updates...")
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                update_info = loop.run_until_complete(
+                    upgrade_service.check_for_update()
+                )
+            finally:
+                loop.close()
+
+            if not update_info or not update_info.get("update_available"):
+                print(
+                    f"\n✅ You are already on the latest version (v{upgrade_service.current_version})"
+                )
+                return CommandResult.success_result("Already on latest version")
+
+            # Display update information
+            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}")
+
+            # Check if --yes flag is set for non-interactive upgrade
+            force_upgrade = getattr(args, "yes", False) or getattr(args, "force", False)
+
+            if not force_upgrade:
+                # Prompt user for confirmation
+                if not upgrade_service.prompt_for_upgrade(update_info):
+                    print("\n⏸️  Upgrade cancelled by user")
+                    return CommandResult.success_result("Upgrade cancelled by user")
+
+            # Perform upgrade
+            success, message = upgrade_service.perform_upgrade(update_info)
+            print(f"\n{message}")
+
+            if success:
+                # Restart after successful upgrade
+                upgrade_service.restart_after_upgrade()
+                # Note: This line won't be reached as restart replaces process
+                return CommandResult.success_result(f"Upgraded to v{latest}")
+            return CommandResult.error_result("Upgrade failed")
+
+        except Exception as e:
+            self.logger.error(f"Error during upgrade: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error during upgrade: {e}")
+
+
+def add_upgrade_parser(subparsers):
+    """
+    Add upgrade command parser.
+
+    WHY: This command helps users check for and install the latest version of
+    claude-mpm without waiting for the automatic startup check.
+
+    Args:
+        subparsers: The subparser action object to add the upgrade command to
+    """
+    parser = subparsers.add_parser(
+        "upgrade",
+        help="Check for and install latest claude-mpm version",
+        description="Check for updates and upgrade claude-mpm to the latest version from PyPI/npm",
+    )
+
+    parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt and upgrade immediately if available",
+    )
+
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force upgrade even if already on latest version (alias for --yes)",
+    )
+
+    return parser
+
+
+def upgrade(args):
+    """
+    Main entry point for upgrade command.
+
+    This function maintains backward compatibility while using the new BaseCommand pattern.
+    """
+    command = UpgradeCommand()
+    result = command.execute(args)
+    return result.exit_code

{claude_mpm-4.7.9 → claude_mpm-4.7.11}/src/claude_mpm/cli/parsers/base_parser.py

@@ -423,6 +423,11 @@ def create_parser(
 
         add_doctor_parser(subparsers)
 
+        # Add upgrade command
+        from ..commands.upgrade import add_upgrade_parser
+
+        add_upgrade_parser(subparsers)
+
         # Add verify command for MCP service verification
         from ..commands.verify import add_parser as add_verify_parser
 

{claude_mpm-4.7.9 → claude_mpm-4.7.11}/src/claude_mpm/constants.py

@@ -44,6 +44,7 @@ class CLICommands(str, Enum):
     MCP = "mcp"
     DOCTOR = "doctor"
     DASHBOARD = "dashboard"
+    UPGRADE = "upgrade"
 
     def with_prefix(self, prefix: CLIPrefix = CLIPrefix.MPM) -> str:
         """Get command with prefix."""

{claude_mpm-4.7.9 → claude_mpm-4.7.11}/src/claude_mpm/services/core/memory_manager.py

@@ -40,9 +40,11 @@ class MemoryManager(IMemoryManager):
     4. Legacy format migration (e.g., PM.md -> PM_memories.md)
     5. Memory caching for performance
 
-    Memory Loading Order:
-    - User-level memories: ~/.claude-mpm/memories/ (global defaults)
-    - Project-level memories: ./.claude-mpm/memories/ (overrides user)
+    Memory Scope:
+    - Project-level ONLY: ./.claude-mpm/memories/ (project-scoped isolation)
+    - User-level memories are NOT loaded to prevent cross-project contamination
+
+    Note: As of v4.7.10+, memories are strictly project-scoped for complete isolation.
     """
 
     def __init__(
@@ -279,7 +281,10 @@ class MemoryManager(IMemoryManager):
 
     def _load_actual_memories(self, deployed_agents: Set[str]) -> Dict[str, Any]:
         """
-        Load actual memories from both user and project directories.
+        Load actual memories from project directory only.
+
+        Memories are project-scoped to ensure complete isolation between projects.
+        User-level memories are no longer supported to prevent cross-project contamination.
 
         Args:
             deployed_agents: Set of deployed agent names
@@ -287,32 +292,14 @@ class MemoryManager(IMemoryManager):
         Returns:
             Dictionary with actual_memories and agent_memories
         """
-        # Define memory directories in priority order
-        user_memories_dir = Path.home() / ".claude-mpm" / "memories"
+        # Define project memory directory (project-scoped only)
         project_memories_dir = Path.cwd() / ".claude-mpm" / "memories"
 
         # Dictionary to store aggregated memories
         pm_memories = []
         agent_memories_dict = {}
 
-        # Load memories from user directory first
-        if user_memories_dir.exists():
-            self.logger.info(
-                f"Loading user-level memory files from: {user_memories_dir}"
-            )
-            self._load_memories_from_directory(
-                user_memories_dir,
-                deployed_agents,
-                pm_memories,
-                agent_memories_dict,
-                "user",
-            )
-        else:
-            self.logger.debug(
-                f"No user memories directory found at: {user_memories_dir}"
-            )
-
-        # Load memories from project directory (overrides user memories)
+        # Load memories from project directory only
         if project_memories_dir.exists():
             self.logger.info(
                 f"Loading project-level memory files from: {project_memories_dir}"