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

claude_mpm-4.7.11/BUILD_NUMBER

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.7.8
+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.8 → claude_mpm-4.7.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-mpm"
-version = "4.7.8"
+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.8"
+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.8 → 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.8 → claude_mpm-4.7.11}/src/claude_mpm/cli/commands/mpm_init.py

@@ -12,7 +12,7 @@ import contextlib
 import subprocess
 import sys
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 import click
 from rich.console import Console
@@ -63,6 +63,7 @@ class MPMInitCommand:
         skip_archive: bool = False,
         dry_run: bool = False,
         quick_update: bool = False,
+        catchup: bool = False,
         non_interactive: bool = False,
         days: int = 30,
         export: Optional[str] = None,
@@ -84,6 +85,7 @@ class MPMInitCommand:
             skip_archive: Skip archiving existing files
             dry_run: Show what would be done without making changes
             quick_update: Perform lightweight update based on recent git activity
+            catchup: Show recent commit history from all branches for PM context
             non_interactive: Non-interactive mode - display report only without prompting
             days: Number of days for git history analysis (7, 14, 30, 60, or 90)
             export: Export report to file (path or "auto" for default location)
@@ -99,6 +101,11 @@ class MPMInitCommand:
             if review_only:
                 return self._run_review_mode()
 
+            if catchup:
+                data = self._catchup()
+                self._display_catchup(data)
+                return {"status": "success", "mode": "catchup", "catchup_data": data}
+
             if quick_update:
                 return self._run_quick_update_mode(
                     days=days,
@@ -679,6 +686,142 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
         console.print("\n[yellow]Quick update cancelled[/yellow]")
         return {"status": "cancelled", "message": "Quick update cancelled"}
 
+    def _catchup(self) -> Dict[str, Any]:
+        """Get recent commit history for PM context.
+
+        Returns:
+            Dict containing commit history and contributor stats
+        """
+        from collections import Counter
+        from datetime import datetime
+        from subprocess import run
+
+        try:
+            # Get last 25 commits from all branches with author info
+            result = run(
+                ["git", "log", "--all", "--format=%h|%an|%ai|%s", "-25"],
+                capture_output=True,
+                text=True,
+                check=True,
+                cwd=str(self.project_path),
+            )
+
+            commits = []
+            authors = []
+
+            for line in result.stdout.strip().split("\n"):
+                if not line:
+                    continue
+
+                parts = line.split("|", 3)
+                if len(parts) == 4:
+                    hash_val, author, date_str, message = parts
+
+                    # Parse date
+                    try:
+                        dt = datetime.fromisoformat(date_str.replace(" ", "T", 1))
+                        date_display = dt.strftime("%Y-%m-%d %H:%M")
+                    except Exception:
+                        date_display = date_str[:16]
+
+                    commits.append(
+                        {
+                            "hash": hash_val,
+                            "author": author,
+                            "date": date_display,
+                            "message": message,
+                        }
+                    )
+                    authors.append(author)
+
+            # Calculate contributor stats
+            author_counts = Counter(authors)
+
+            return {
+                "commits": commits,
+                "total_commits": len(commits),
+                "contributors": dict(author_counts),
+                "contributor_count": len(author_counts),
+            }
+
+        except Exception as e:
+            console.print(f"[yellow]Could not retrieve commit history: {e}[/yellow]")
+            return {
+                "commits": [],
+                "total_commits": 0,
+                "contributors": {},
+                "contributor_count": 0,
+                "error": str(e),
+            }
+
+    def _display_catchup(self, data: Dict[str, Any]) -> None:
+        """Display catchup information to console.
+
+        Args:
+            data: Commit history data from _catchup()
+        """
+        from rich.panel import Panel
+        from rich.table import Table
+
+        if data.get("error"):
+            console.print(
+                Panel(
+                    "[yellow]Not a git repository or no commits found[/yellow]",
+                    title="⚠️ Catchup Status",
+                    border_style="yellow",
+                )
+            )
+            return
+
+        # Display contributor summary
+        if data["contributors"]:
+            console.print("\n[bold cyan]👥 Active Contributors[/bold cyan]")
+            for author, count in sorted(
+                data["contributors"].items(), key=lambda x: x[1], reverse=True
+            ):
+                console.print(
+                    f"  • [green]{author}[/green]: {count} commit{'s' if count != 1 else ''}"
+                )
+
+        # Display commit history table
+        if data["commits"]:
+            console.print(
+                f"\n[bold cyan]📝 Last {data['total_commits']} Commits[/bold cyan]"
+            )
+
+            table = Table(
+                show_header=True, header_style="bold magenta", border_style="dim"
+            )
+            table.add_column("#", style="dim", width=3)
+            table.add_column("Hash", style="yellow", width=8)
+            table.add_column("Author", style="green", width=20)
+            table.add_column("Date", style="cyan", width=16)
+            table.add_column("Message", style="white")
+
+            for idx, commit in enumerate(data["commits"], 1):
+                # Truncate message if too long
+                msg = commit["message"]
+                if len(msg) > 80:
+                    msg = msg[:77] + "..."
+
+                # Truncate author if too long
+                author = commit["author"]
+                if len(author) > 18:
+                    author = author[:18] + "..."
+
+                table.add_row(str(idx), commit["hash"], author, commit["date"], msg)
+
+            console.print(table)
+
+        # Display PM recommendations
+        console.print("\n[bold cyan]💡 PM Recommendations[/bold cyan]")
+        console.print(
+            f"  • Total activity: {data['total_commits']} commits from {data['contributor_count']} contributor{'s' if data['contributor_count'] != 1 else ''}"
+        )
+        console.print("  • Review commit messages for recent project context")
+        console.print("  • Identify development patterns and focus areas")
+        console.print("  • Use this context to inform current work priorities\n")
+
     def _generate_activity_report(
         self, git_analysis: Dict, doc_analysis: Dict, days: int = 30
     ) -> Dict:
@@ -1463,6 +1606,11 @@ preserving valuable project-specific information while refreshing standard secti
     is_flag=True,
     help="Perform lightweight update based on recent git activity (default: 30 days)",
 )
+@click.option(
+    "--catchup",
+    is_flag=True,
+    help="Show recent commit history from all branches for PM context",
+)
 @click.option(
     "--non-interactive",
     is_flag=True,
@@ -1499,6 +1647,7 @@ def mpm_init(
     verbose,
     ast_analysis,
     quick_update,
+    catchup,
     non_interactive,
     days,
     export,
@@ -1544,6 +1693,7 @@ def mpm_init(
             preserve_custom=preserve_custom,
             skip_archive=skip_archive,
             quick_update=quick_update,
+            catchup=catchup,
             non_interactive=non_interactive,
             days=days,
             export=export,

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.8 → 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.8 → claude_mpm-4.7.11}/src/claude_mpm/cli/parsers/mpm_init_parser.py

@@ -91,6 +91,11 @@ def add_mpm_init_subparser(subparsers: Any) -> None:
         action="store_true",
         help="Perform lightweight update based on recent git activity (default: 30 days)",
     )
+    init_group.add_argument(
+        "--catchup",
+        action="store_true",
+        help="Show recent commit history from all branches for PM context",
+    )
     init_group.add_argument(
         "--non-interactive",
         action="store_true",

{claude_mpm-4.7.8 → claude_mpm-4.7.11}/src/claude_mpm/commands/mpm-init.md

@@ -146,6 +146,23 @@ Fast update based on recent 30-day git activity. Generates activity report and u
 
 **Note**: Typing `/mpm-init update` executes `claude-mpm mpm-init --quick-update` automatically.
 
+### Catchup Mode
+
+Show recent commit history to provide PM with project context:
+
+```bash
+/mpm-init catchup
+```
+
+This displays:
+- Last 25 commits from all branches
+- Author attribution (WHO did WHAT)
+- Temporal context (WHEN)
+- Contributor activity summary
+- PM recommendations based on commit patterns
+
+Useful for understanding recent development activity and getting PM up to speed on project changes.
+
 ### Review Project State
 ```bash
 /mpm-init --review

{claude_mpm-4.7.8 → 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.8 → 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}"