claude-mpm 5.6.23__py3-none-any.whl → 5.6.73__py3-none-any.whl

claude_mpm/commander/events/manager.py

@@ -3,11 +3,13 @@
 Manages event lifecycle, inbox queries, and project event tracking.
 """
 
+import asyncio
 import logging
 import threading
 import uuid
+from asyncio import Queue
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from ..models.events import (
     DEFAULT_PRIORITIES,
@@ -48,6 +50,8 @@ class EventManager:
         self._events: Dict[str, Event] = {}
         self._project_index: Dict[str, List[str]] = {}  # project_id -> event_ids
         self._lock = threading.RLock()
+        self._subscribers: Dict[EventType, List[Callable]] = {}
+        self._event_queue: Queue = Queue()
 
     def create(
         self,
@@ -330,3 +334,59 @@ class EventManager:
             for eid in event_ids:
                 self._events.pop(eid, None)
             return len(event_ids)
+
+    def subscribe(self, event_type: EventType, callback: Callable) -> None:
+        """Subscribe callback to event type.
+
+        Args:
+            event_type: Type of event to subscribe to
+            callback: Function to call when event occurs (sync or async)
+
+        Example:
+            def on_error(event):
+                print(f"Error: {event.title}")
+
+            manager.subscribe(EventType.ERROR, on_error)
+        """
+        if event_type not in self._subscribers:
+            self._subscribers[event_type] = []
+        self._subscribers[event_type].append(callback)
+
+    def unsubscribe(self, event_type: EventType, callback: Callable) -> None:
+        """Unsubscribe callback from event type.
+
+        Args:
+            event_type: Type of event to unsubscribe from
+            callback: Function to remove from subscribers
+
+        Example:
+            manager.unsubscribe(EventType.ERROR, on_error)
+        """
+        if (
+            event_type in self._subscribers
+            and callback in self._subscribers[event_type]
+        ):
+            self._subscribers[event_type].remove(callback)
+
+    async def emit(self, event: Event) -> None:
+        """Emit event to all subscribers.
+
+        Queues the event and notifies all subscribed callbacks.
+        Supports both sync and async callbacks.
+
+        Args:
+            event: Event to emit
+
+        Example:
+            await manager.emit(event)
+        """
+        await self._event_queue.put(event)
+        if event.type in self._subscribers:
+            for callback in self._subscribers[event.type]:
+                try:
+                    if asyncio.iscoroutinefunction(callback):
+                        await callback(event)
+                    else:
+                        callback(event)
+                except Exception as e:
+                    logger.error(f"Subscriber callback error: {e}")

claude_mpm/commander/frameworks/base.py

@@ -42,6 +42,93 @@ class InstanceInfo:
     git_branch: Optional[str] = None
     git_status: Optional[str] = None
     connected: bool = False
+    ready: bool = False
+
+
+@dataclass
+class RegisteredInstance:
+    """Persistent instance configuration (survives daemon restart).
+
+    Attributes:
+        name: Instance identifier
+        path: Original project directory path (stored as string for JSON)
+        framework: Framework identifier ("cc" or "mpm")
+        registered_at: ISO timestamp when instance was registered
+        worktree_path: Path to git worktree (if using worktree isolation)
+        worktree_branch: Branch name in the worktree
+        use_worktree: Whether worktree isolation is enabled
+
+    Example:
+        >>> instance = RegisteredInstance(
+        ...     name="myapp",
+        ...     path="/Users/user/myapp",
+        ...     framework="cc",
+        ...     registered_at="2024-01-15T10:30:00"
+        ... )
+        >>> instance.to_dict()
+        {'name': 'myapp', 'path': '/Users/user/myapp', 'framework': 'cc', ...}
+        >>> instance.working_path
+        '/Users/user/myapp'
+
+        >>> # With worktree enabled
+        >>> instance = RegisteredInstance(
+        ...     name="myapp",
+        ...     path="/Users/user/myapp",
+        ...     framework="cc",
+        ...     registered_at="2024-01-15T10:30:00",
+        ...     worktree_path="/Users/user/.mpm/worktrees/myapp",
+        ...     worktree_branch="feature/new-feature",
+        ...     use_worktree=True
+        ... )
+        >>> instance.working_path
+        '/Users/user/.mpm/worktrees/myapp'
+    """
+
+    name: str
+    path: str  # Original project path
+    framework: str
+    registered_at: str
+    # Worktree fields
+    worktree_path: Optional[str] = None  # Path to worktree (if using)
+    worktree_branch: Optional[str] = None  # Branch in worktree
+    use_worktree: bool = False  # Whether worktree is enabled
+
+    def to_dict(self) -> dict:
+        """Serialize for JSON storage."""
+        return {
+            "name": self.name,
+            "path": self.path,
+            "framework": self.framework,
+            "registered_at": self.registered_at,
+            "worktree_path": self.worktree_path,
+            "worktree_branch": self.worktree_branch,
+            "use_worktree": self.use_worktree,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "RegisteredInstance":
+        """Deserialize from JSON."""
+        return cls(
+            name=data["name"],
+            path=data["path"],
+            framework=data["framework"],
+            registered_at=data.get("registered_at", ""),
+            worktree_path=data.get("worktree_path"),
+            worktree_branch=data.get("worktree_branch"),
+            use_worktree=data.get("use_worktree", False),
+        )
+
+    @property
+    def working_path(self) -> str:
+        """Get the actual working path (worktree or original).
+
+        Returns:
+            The worktree path if worktree is enabled and configured,
+            otherwise the original project path.
+        """
+        if self.use_worktree and self.worktree_path:
+            return self.worktree_path
+        return self.path
 
 
 class BaseFramework(ABC):

claude_mpm/commander/frameworks/mpm.py

@@ -10,9 +10,7 @@ from .base import BaseFramework
 class MPMFramework(BaseFramework):
     """Claude MPM framework.
 
-    This framework launches Claude with MPM agent loading via CLAUDE.md.
-    It uses the same 'claude' command as Claude Code, but relies on CLAUDE.md
-    in the project to load the MPM agent system.
+    This framework launches Claude MPM with full agent orchestration.
 
     Example:
         >>> framework = MPMFramework()
@@ -21,42 +19,39 @@ class MPMFramework(BaseFramework):
         >>> framework.is_available()
         True
         >>> framework.get_startup_command(Path("/Users/user/myapp"))
-        "cd '/Users/user/myapp' && claude --dangerously-skip-permissions"
+        "cd '/Users/user/myapp' && claude-mpm"
     """
 
     name = "mpm"
     display_name = "Claude MPM"
-    command = "claude"  # Uses claude with MPM agent loading
+    command = "claude-mpm"
 
     def get_startup_command(self, project_path: Path) -> str:
         """Get the command to start Claude MPM in a project.
 
-        The MPM framework uses the standard 'claude' command, but expects
-        a CLAUDE.md file in the project to load the MPM agent system.
-
         Args:
             project_path: Path to the project directory
 
         Returns:
-            Shell command string to start Claude with MPM
+            Shell command string to start Claude MPM
 
         Example:
             >>> framework = MPMFramework()
             >>> framework.get_startup_command(Path("/Users/user/myapp"))
-            "cd '/Users/user/myapp' && claude --dangerously-skip-permissions"
+            "cd '/Users/user/myapp' && claude-mpm"
         """
         quoted_path = shlex.quote(str(project_path))
-        return f"cd {quoted_path} && claude --dangerously-skip-permissions"
+        return f"cd {quoted_path} && claude-mpm"
 
     def is_available(self) -> bool:
-        """Check if 'claude' command is available.
+        """Check if 'claude-mpm' command is available.
 
         Returns:
-            True if 'claude' command exists in PATH
+            True if 'claude-mpm' command exists in PATH
 
         Example:
             >>> framework = MPMFramework()
             >>> framework.is_available()
             True
         """
-        return shutil.which("claude") is not None
+        return shutil.which("claude-mpm") is not None

claude_mpm/commander/git/__init__.py

@@ -0,0 +1,5 @@
+"""Git operations for Commander."""
+
+from .worktree_manager import WorktreeInfo, WorktreeManager
+
+__all__ = ["WorktreeInfo", "WorktreeManager"]

claude_mpm/commander/git/worktree_manager.py

@@ -0,0 +1,212 @@
+"""Git worktree manager for session isolation."""
+
+import logging
+import subprocess  # nosec B404 - subprocess needed for git commands
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class WorktreeInfo:
+    """Info about a git worktree."""
+
+    name: str
+    path: Path
+    branch: str
+    base_path: Path  # Original repo path
+
+
+class WorktreeManager:
+    """Manages git worktrees for session isolation."""
+
+    def __init__(self, base_path: Path):
+        """Initialize with base project path."""
+        self.base_path = Path(base_path)
+        self.worktrees_dir = self.base_path.parent / f".worktrees-{self.base_path.name}"
+
+    def create(self, name: str, branch: Optional[str] = None) -> WorktreeInfo:
+        """Create a worktree for a session.
+
+        Args:
+            name: Session/worktree name (e.g., "izzie")
+            branch: Branch name, defaults to session-{name}
+
+        Returns:
+            WorktreeInfo with path and branch details
+        """
+        branch = branch or f"session-{name}"
+        worktree_path = self.worktrees_dir / name
+
+        # Ensure worktrees directory exists
+        self.worktrees_dir.mkdir(parents=True, exist_ok=True)
+
+        # Check if worktree already exists
+        if worktree_path.exists():
+            logger.info(f"Worktree '{name}' already exists at {worktree_path}")
+            return self._get_worktree_info(name, worktree_path)
+
+        # Create new branch if it doesn't exist
+        try:
+            subprocess.run(  # nosec B603 B607 - git command with safe args
+                ["git", "branch", branch],
+                cwd=self.base_path,
+                capture_output=True,
+                check=False,  # Branch may already exist
+            )
+        except Exception as e:
+            logger.warning(f"Could not create branch {branch}: {e}")
+
+        # Create worktree
+        result = subprocess.run(  # nosec B603 B607 - git command with safe args
+            ["git", "worktree", "add", str(worktree_path), branch],
+            check=False,
+            cwd=self.base_path,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode != 0:
+            raise RuntimeError(f"Failed to create worktree: {result.stderr}")
+
+        logger.info(f"Created worktree '{name}' at {worktree_path} on branch {branch}")
+        return WorktreeInfo(
+            name=name, path=worktree_path, branch=branch, base_path=self.base_path
+        )
+
+    def _get_worktree_info(self, name: str, path: Path) -> WorktreeInfo:
+        """Get info for existing worktree."""
+        result = subprocess.run(  # nosec B603 B607 - git command with safe args
+            ["git", "branch", "--show-current"],
+            check=False,
+            cwd=path,
+            capture_output=True,
+            text=True,
+        )
+        branch = result.stdout.strip() or f"session-{name}"
+        return WorktreeInfo(
+            name=name, path=path, branch=branch, base_path=self.base_path
+        )
+
+    def list(self) -> list[WorktreeInfo]:
+        """List all worktrees for this project."""
+        result = subprocess.run(  # nosec B603 B607 - git command with safe args
+            ["git", "worktree", "list", "--porcelain"],
+            check=False,
+            cwd=self.base_path,
+            capture_output=True,
+            text=True,
+        )
+
+        worktrees = []
+        current_path = None
+        current_branch = None
+
+        for line in result.stdout.strip().split("\n"):
+            if line.startswith("worktree "):
+                current_path = Path(line.split(" ", 1)[1])
+            elif line.startswith("branch "):
+                current_branch = line.split("/")[-1]  # refs/heads/branch -> branch
+            elif line == "":
+                if current_path and str(self.worktrees_dir) in str(current_path):
+                    name = current_path.name
+                    worktrees.append(
+                        WorktreeInfo(
+                            name=name,
+                            path=current_path,
+                            branch=current_branch or f"session-{name}",
+                            base_path=self.base_path,
+                        )
+                    )
+                current_path = None
+                current_branch = None
+
+        return worktrees
+
+    def remove(self, name: str, force: bool = False) -> bool:
+        """Remove a worktree."""
+        worktree_path = self.worktrees_dir / name
+
+        if not worktree_path.exists():
+            return False
+
+        args = ["git", "worktree", "remove", str(worktree_path)]
+        if force:
+            args.insert(3, "--force")
+
+        result = subprocess.run(  # nosec B603 B607 - git command with safe args
+            args, check=False, cwd=self.base_path, capture_output=True, text=True
+        )
+        return result.returncode == 0
+
+    def get(self, name: str) -> Optional[WorktreeInfo]:
+        """Get worktree by name."""
+        worktree_path = self.worktrees_dir / name
+        if worktree_path.exists():
+            return self._get_worktree_info(name, worktree_path)
+        return None
+
+    def merge_to_main(self, name: str, delete_after: bool = True) -> tuple[bool, str]:
+        """Merge worktree branch back to main and optionally delete worktree.
+
+        Args:
+            name: Worktree name to merge
+            delete_after: Remove worktree after merge (default True)
+
+        Returns:
+            Tuple of (success, message)
+        """
+        worktree = self.get(name)
+        if not worktree:
+            return False, f"Worktree '{name}' not found"
+
+        # Get main branch name
+        result = subprocess.run(  # nosec B603 B607 - git command with safe args
+            ["git", "symbolic-ref", "refs/remotes/origin/HEAD"],
+            check=False,
+            cwd=self.base_path,
+            capture_output=True,
+            text=True,
+        )
+        main_branch = (
+            result.stdout.strip().split("/")[-1] if result.returncode == 0 else "main"
+        )
+
+        # Checkout main in base repo
+        checkout_result = subprocess.run(  # nosec B603 B607 - git command with safe args
+            ["git", "checkout", main_branch],
+            check=False,
+            cwd=self.base_path,
+            capture_output=True,
+            text=True,
+        )
+        if checkout_result.returncode != 0:
+            return False, f"Failed to checkout {main_branch}: {checkout_result.stderr}"
+
+        # Merge worktree branch
+        merge_result = subprocess.run(  # nosec B603 B607 - git command with safe args
+            ["git", "merge", worktree.branch, "--no-edit"],
+            check=False,
+            cwd=self.base_path,
+            capture_output=True,
+            text=True,
+        )
+
+        if merge_result.returncode != 0:
+            return False, f"Merge failed: {merge_result.stderr}"
+
+        # Delete worktree if requested
+        if delete_after:
+            self.remove(name, force=True)
+            # Delete branch
+            subprocess.run(  # nosec B603 B607 - git command with safe args
+                ["git", "branch", "-d", worktree.branch],
+                check=False,
+                cwd=self.base_path,
+                capture_output=True,
+            )
+
+        logger.info(f"Merged '{worktree.branch}' to {main_branch}")
+        return True, f"Merged '{worktree.branch}' to {main_branch}"