claude-mpm 5.6.10__py3-none-any.whl → 5.6.33__py3-none-any.whl

claude_mpm/commander/adapters/registry.py

@@ -0,0 +1,204 @@
+"""Adapter registry for runtime detection and selection.
+
+This module provides a registry for managing runtime adapters, with
+automatic detection of available runtimes on the system.
+"""
+
+import logging
+import shutil
+from typing import Dict, List, Optional, Type
+
+from .base import RuntimeAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class AdapterRegistry:
+    """Registry for managing runtime adapters.
+
+    Provides centralized registration, retrieval, and auto-detection
+    of available runtime adapters.
+
+    Example:
+        >>> # Register adapter
+        >>> AdapterRegistry.register('claude-code', ClaudeCodeAdapter)
+        >>> # Get adapter instance
+        >>> adapter = AdapterRegistry.get('claude-code')
+        >>> # Detect available runtimes
+        >>> available = AdapterRegistry.detect_available()
+        >>> print(available)
+        ['claude-code', 'mpm']
+    """
+
+    _adapters: Dict[str, Type[RuntimeAdapter]] = {}
+    _runtime_commands: Dict[str, str] = {
+        "claude-code": "claude",
+        "auggie": "auggie",
+        "codex": "codex",
+        "mpm": "claude",  # MPM uses claude with extra config
+    }
+
+    @classmethod
+    def register(cls, name: str, adapter_class: Type[RuntimeAdapter]) -> None:
+        """Register a runtime adapter.
+
+        Args:
+            name: Unique identifier for the adapter
+            adapter_class: RuntimeAdapter subclass to register
+
+        Example:
+            >>> AdapterRegistry.register('my-runtime', MyAdapter)
+        """
+        cls._adapters[name] = adapter_class
+        logger.debug(f"Registered adapter: {name}")
+
+    @classmethod
+    def unregister(cls, name: str) -> None:
+        """Unregister a runtime adapter.
+
+        Args:
+            name: Identifier of adapter to unregister
+
+        Example:
+            >>> AdapterRegistry.unregister('my-runtime')
+        """
+        if name in cls._adapters:
+            del cls._adapters[name]
+            logger.debug(f"Unregistered adapter: {name}")
+
+    @classmethod
+    def get(cls, name: str) -> Optional[RuntimeAdapter]:
+        """Get adapter instance by name.
+
+        Args:
+            name: Identifier of adapter to retrieve
+
+        Returns:
+            RuntimeAdapter instance if found, None otherwise
+
+        Example:
+            >>> adapter = AdapterRegistry.get('claude-code')
+            >>> if adapter:
+            ...     print(adapter.name)
+            'claude-code'
+        """
+        if name in cls._adapters:
+            adapter = cls._adapters[name]()
+            logger.debug(f"Retrieved adapter: {name}")
+            return adapter
+        logger.warning(f"Adapter not found: {name}")
+        return None
+
+    @classmethod
+    def list_registered(cls) -> List[str]:
+        """List all registered adapter names.
+
+        Returns:
+            List of registered adapter identifiers
+
+        Example:
+            >>> registered = AdapterRegistry.list_registered()
+            >>> print(registered)
+            ['claude-code', 'auggie', 'codex', 'mpm']
+        """
+        return list(cls._adapters.keys())
+
+    @classmethod
+    def detect_available(cls) -> List[str]:
+        """Detect which runtimes are available on this system.
+
+        Checks for CLI commands in PATH to determine which runtimes
+        are installed and accessible.
+
+        Returns:
+            List of available runtime identifiers
+
+        Example:
+            >>> available = AdapterRegistry.detect_available()
+            >>> if 'claude-code' in available:
+            ...     print("Claude Code is available")
+        """
+        available = []
+
+        for name, command in cls._runtime_commands.items():
+            if name in cls._adapters and shutil.which(command):
+                available.append(name)
+                logger.debug(f"Detected available runtime: {name} (command: {command})")
+
+        logger.info(f"Available runtimes: {available}")
+        return available
+
+    @classmethod
+    def get_default(cls) -> Optional[RuntimeAdapter]:
+        """Get the best available adapter.
+
+        Selection priority: mpm > claude-code > auggie > codex
+
+        Returns:
+            RuntimeAdapter instance for best available runtime, or None
+
+        Example:
+            >>> adapter = AdapterRegistry.get_default()
+            >>> if adapter:
+            ...     print(f"Using {adapter.name}")
+        """
+        # Priority order: MPM has most features, then Claude Code, etc.
+        priority = ["mpm", "claude-code", "auggie", "codex"]
+
+        available = cls.detect_available()
+
+        for name in priority:
+            if name in available:
+                adapter = cls.get(name)
+                logger.info(f"Selected default adapter: {name}")
+                return adapter
+
+        logger.warning("No adapters available")
+        return None
+
+    @classmethod
+    def is_available(cls, name: str) -> bool:
+        """Check if a specific runtime is available.
+
+        Args:
+            name: Runtime identifier to check
+
+        Returns:
+            True if runtime is registered and command is in PATH
+
+        Example:
+            >>> if AdapterRegistry.is_available('claude-code'):
+            ...     adapter = AdapterRegistry.get('claude-code')
+        """
+        return name in cls.detect_available()
+
+    @classmethod
+    def get_command(cls, name: str) -> Optional[str]:
+        """Get CLI command for a runtime.
+
+        Args:
+            name: Runtime identifier
+
+        Returns:
+            CLI command string if found, None otherwise
+
+        Example:
+            >>> cmd = AdapterRegistry.get_command('claude-code')
+            >>> print(cmd)
+            'claude'
+        """
+        return cls._runtime_commands.get(name)
+
+    @classmethod
+    def register_command(cls, name: str, command: str) -> None:
+        """Register CLI command for a runtime.
+
+        Args:
+            name: Runtime identifier
+            command: CLI command to invoke runtime
+
+        Example:
+            >>> AdapterRegistry.register_command('my-runtime', 'my-cli')
+        """
+        cls._runtime_commands[name] = command
+        logger.debug(f"Registered command for {name}: {command}")

claude_mpm/commander/api/app.py

@@ -6,7 +6,7 @@ lifecycle management, and route registration.
 
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import AsyncGenerator, Optional
+from typing import AsyncGenerator
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -20,14 +20,6 @@ from ..tmux_orchestrator import TmuxOrchestrator
 from ..workflow import EventHandler
 from .routes import events, inbox as inbox_routes, messages, projects, sessions, work
 
-# Global instances (injected at startup via lifespan)
-registry: Optional[ProjectRegistry] = None
-tmux: Optional[TmuxOrchestrator] = None
-event_manager: Optional[EventManager] = None
-inbox: Optional[Inbox] = None
-event_handler: Optional[EventHandler] = None
-session_manager: dict = {}  # project_id -> ProjectSession
-
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
@@ -42,13 +34,37 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
         None during application runtime
     """
     # Startup
-    global registry, tmux, event_manager, inbox, event_handler, session_manager
-    registry = ProjectRegistry()
-    tmux = TmuxOrchestrator()
-    event_manager = EventManager()
-    inbox = Inbox(event_manager, registry)
-    session_manager = {}  # Populated by daemon when sessions are created
-    event_handler = EventHandler(inbox, session_manager)
+    import logging
+
+    logger = logging.getLogger(__name__)
+    logger.info("Lifespan starting. Initializing app.state resources...")
+
+    # Initialize app.state resources (daemon will inject its instances later)
+    if not hasattr(app.state, "registry"):
+        app.state.registry = ProjectRegistry()
+    if not hasattr(app.state, "tmux"):
+        app.state.tmux = TmuxOrchestrator()
+    if not hasattr(app.state, "event_manager"):
+        app.state.event_manager = EventManager()
+    if not hasattr(app.state, "inbox"):
+        app.state.inbox = Inbox(app.state.event_manager, app.state.registry)
+    if not hasattr(app.state, "session_manager"):
+        app.state.session_manager = {}
+    if not hasattr(app.state, "work_queues"):
+        logger.info("work_queues not set, creating new dict")
+        app.state.work_queues = {}
+    else:
+        logger.info(
+            f"work_queues already set, preserving id: {id(app.state.work_queues)}"
+        )
+    if not hasattr(app.state, "daemon_instance"):
+        app.state.daemon_instance = None
+    if not hasattr(app.state, "event_handler"):
+        app.state.event_handler = EventHandler(
+            app.state.inbox, app.state.session_manager
+        )
+
+    logger.info(f"Lifespan complete. work_queues id: {id(app.state.work_queues)}")
 
     yield
 

claude_mpm/commander/api/routes/messages.py

@@ -7,7 +7,7 @@ conversation threads for projects.
 import uuid
 from typing import List
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Request
 
 from ...models import ThreadMessage
 from ..errors import ProjectNotFoundError
@@ -16,13 +16,11 @@ from ..schemas import MessageResponse, SendMessageRequest
 router = APIRouter()
 
 
-def _get_registry():
-    """Get registry instance from app global."""
-    from ..app import registry
-
-    if registry is None:
+def _get_registry(request: Request):
+    """Get registry instance from app.state."""
+    if not hasattr(request.app.state, "registry") or request.app.state.registry is None:
         raise RuntimeError("Registry not initialized")
-    return registry
+    return request.app.state.registry
 
 
 def _message_to_response(message: ThreadMessage) -> MessageResponse:
@@ -44,7 +42,7 @@ def _message_to_response(message: ThreadMessage) -> MessageResponse:
 
 
 @router.get("/projects/{project_id}/thread", response_model=List[MessageResponse])
-async def get_thread(project_id: str) -> List[MessageResponse]:
+async def get_thread(request: Request, project_id: str) -> List[MessageResponse]:
     """Get conversation thread for a project.
 
     Returns all messages in chronological order.
@@ -77,7 +75,7 @@ async def get_thread(project_id: str) -> List[MessageResponse]:
             }
         ]
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:
@@ -90,7 +88,9 @@ async def get_thread(project_id: str) -> List[MessageResponse]:
 @router.post(
     "/projects/{project_id}/messages", response_model=MessageResponse, status_code=201
 )
-async def send_message(project_id: str, req: SendMessageRequest) -> MessageResponse:
+async def send_message(
+    request: Request, project_id: str, req: SendMessageRequest
+) -> MessageResponse:
     """Send a message to a project's active session.
 
     Adds message to conversation thread and sends to specified or active session.
@@ -119,7 +119,7 @@ async def send_message(project_id: str, req: SendMessageRequest) -> MessageRespo
             "timestamp": "2025-01-12T10:00:00Z"
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:

claude_mpm/commander/api/routes/projects.py

@@ -7,7 +7,7 @@ projects in the MPM Commander.
 from pathlib import Path
 from typing import List
 
-from fastapi import APIRouter, Response
+from fastapi import APIRouter, Request, Response
 
 from ...models import ProjectState
 from ..errors import InvalidPathError, ProjectAlreadyExistsError, ProjectNotFoundError
@@ -16,13 +16,11 @@ from ..schemas import ProjectResponse, RegisterProjectRequest, SessionResponse
 router = APIRouter()
 
 
-def _get_registry():
-    """Get registry instance from app global."""
-    from ..app import registry
-
-    if registry is None:
+def _get_registry(request: Request):
+    """Get registry instance from app.state."""
+    if not hasattr(request.app.state, "registry") or request.app.state.registry is None:
         raise RuntimeError("Registry not initialized")
-    return registry
+    return request.app.state.registry
 
 
 def _project_to_response(project) -> ProjectResponse:
@@ -61,7 +59,7 @@ def _project_to_response(project) -> ProjectResponse:
 
 
 @router.get("/projects", response_model=List[ProjectResponse])
-async def list_projects() -> List[ProjectResponse]:
+async def list_projects(request: Request) -> List[ProjectResponse]:
     """List all registered projects.
 
     Returns:
@@ -83,13 +81,13 @@ async def list_projects() -> List[ProjectResponse]:
             }
         ]
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     projects = registry.list_all()
     return [_project_to_response(p) for p in projects]
 
 
 @router.get("/projects/{project_id}", response_model=ProjectResponse)
-async def get_project(project_id: str) -> ProjectResponse:
+async def get_project(request: Request, project_id: str) -> ProjectResponse:
     """Get project details by ID.
 
     Args:
@@ -111,7 +109,7 @@ async def get_project(project_id: str) -> ProjectResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:
@@ -121,7 +119,9 @@ async def get_project(project_id: str) -> ProjectResponse:
 
 
 @router.post("/projects", response_model=ProjectResponse, status_code=201)
-async def register_project(req: RegisterProjectRequest) -> ProjectResponse:
+async def register_project(
+    request: Request, req: RegisterProjectRequest
+) -> ProjectResponse:
     """Register a new project.
 
     Args:
@@ -148,7 +148,7 @@ async def register_project(req: RegisterProjectRequest) -> ProjectResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
 
     # Validate path exists and is directory
     path_obj = Path(req.path)
@@ -156,7 +156,7 @@ async def register_project(req: RegisterProjectRequest) -> ProjectResponse:
         raise InvalidPathError(req.path)
 
     try:
-        project = registry.register(req.path, req.name)
+        project = registry.register(req.path, req.name, req.project_id)
         return _project_to_response(project)
     except ValueError as e:
         # Registry raises ValueError for duplicate registration
@@ -168,7 +168,7 @@ async def register_project(req: RegisterProjectRequest) -> ProjectResponse:
 
 
 @router.delete("/projects/{project_id}", status_code=204)
-async def unregister_project(project_id: str) -> Response:
+async def unregister_project(request: Request, project_id: str) -> Response:
     """Unregister a project.
 
     Args:
@@ -184,7 +184,7 @@ async def unregister_project(project_id: str) -> Response:
         DELETE /api/projects/abc-123
         Response: 204 No Content
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
 
     try:
         registry.unregister(project_id)
@@ -194,7 +194,7 @@ async def unregister_project(project_id: str) -> Response:
 
 
 @router.post("/projects/{project_id}/pause", response_model=ProjectResponse)
-async def pause_project(project_id: str) -> ProjectResponse:
+async def pause_project(request: Request, project_id: str) -> ProjectResponse:
     """Pause a project.
 
     Sets project state to PAUSED to prevent automatic work processing.
@@ -217,7 +217,7 @@ async def pause_project(project_id: str) -> ProjectResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:
@@ -233,7 +233,7 @@ async def pause_project(project_id: str) -> ProjectResponse:
 
 
 @router.post("/projects/{project_id}/resume", response_model=ProjectResponse)
-async def resume_project(project_id: str) -> ProjectResponse:
+async def resume_project(request: Request, project_id: str) -> ProjectResponse:
     """Resume a paused project.
 
     Sets project state back to IDLE to allow work processing.
@@ -256,7 +256,7 @@ async def resume_project(project_id: str) -> ProjectResponse:
             ...
         }
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:

claude_mpm/commander/api/routes/sessions.py

@@ -9,7 +9,7 @@ import subprocess  # nosec B404 - needed for tmux error handling
 import uuid
 from typing import List
 
-from fastapi import APIRouter, Response
+from fastapi import APIRouter, Request, Response
 
 from ...models import ToolSession
 from ..errors import (
@@ -27,22 +27,18 @@ logger = logging.getLogger(__name__)
 VALID_RUNTIMES = {"claude-code"}
 
 
-def _get_registry():
-    """Get registry instance from app global."""
-    from ..app import registry
-
-    if registry is None:
+def _get_registry(request: Request):
+    """Get registry instance from app.state."""
+    if not hasattr(request.app.state, "registry") or request.app.state.registry is None:
         raise RuntimeError("Registry not initialized")
-    return registry
-
+    return request.app.state.registry
 
-def _get_tmux():
-    """Get tmux orchestrator instance from app global."""
-    from ..app import tmux
 
-    if tmux is None:
+def _get_tmux(request: Request):
+    """Get tmux orchestrator instance from app.state."""
+    if not hasattr(request.app.state, "tmux") or request.app.state.tmux is None:
         raise RuntimeError("Tmux orchestrator not initialized")
-    return tmux
+    return request.app.state.tmux
 
 
 def _session_to_response(session: ToolSession) -> SessionResponse:
@@ -65,7 +61,7 @@ def _session_to_response(session: ToolSession) -> SessionResponse:
 
 
 @router.get("/projects/{project_id}/sessions", response_model=List[SessionResponse])
-async def list_sessions(project_id: str) -> List[SessionResponse]:
+async def list_sessions(request: Request, project_id: str) -> List[SessionResponse]:
     """List all sessions for a project.
 
     Args:
@@ -90,7 +86,7 @@ async def list_sessions(project_id: str) -> List[SessionResponse]:
             }
         ]
     """
-    registry = _get_registry()
+    registry = _get_registry(request)
     project = registry.get(project_id)
 
     if project is None:
@@ -103,7 +99,9 @@ async def list_sessions(project_id: str) -> List[SessionResponse]:
 @router.post(
     "/projects/{project_id}/sessions", response_model=SessionResponse, status_code=201
 )
-async def create_session(project_id: str, req: CreateSessionRequest) -> SessionResponse:
+async def create_session(
+    request: Request, project_id: str, req: CreateSessionRequest
+) -> SessionResponse:
     """Create a new session for a project.
 
     Creates a new tmux pane and initializes the specified runtime adapter.
@@ -135,8 +133,8 @@ async def create_session(project_id: str, req: CreateSessionRequest) -> SessionR
             "created_at": "2025-01-12T10:00:00Z"
         }
     """
-    registry = _get_registry()
-    tmux_orch = _get_tmux()
+    registry = _get_registry(request)
+    tmux_orch = _get_tmux(request)
 
     # Validate project exists
     project = registry.get(project_id)
@@ -181,7 +179,7 @@ async def create_session(project_id: str, req: CreateSessionRequest) -> SessionR
 
 
 @router.delete("/sessions/{session_id}", status_code=204)
-async def stop_session(session_id: str) -> Response:
+async def stop_session(request: Request, session_id: str) -> Response:
     """Stop and remove a session.
 
     Kills the tmux pane and removes the session from its project.
@@ -199,8 +197,8 @@ async def stop_session(session_id: str) -> Response:
         DELETE /api/sessions/sess-456
         Response: 204 No Content
     """
-    registry = _get_registry()
-    tmux_orch = _get_tmux()
+    registry = _get_registry(request)
+    tmux_orch = _get_tmux(request)
 
     # Find session across all projects
     session = None