claude-mpm 5.4.71__py3-none-any.whl → 5.4.73__py3-none-any.whl

claude_mpm/services/agents/deployment/deployment_reconciler.py

@@ -0,0 +1,539 @@
+"""
+Deployment Reconciliation Service - Simplified Deployment Model
+
+This service implements the simplified deployment model where:
+1. Configuration has explicit lists: agents.enabled and skills.enabled
+2. On startup/sync, reconcile deployed state with configured state
+3. Deploy agents from cache to project .claude/ directories
+4. Remove agents/skills NOT in enabled lists
+
+Key Principles:
+- Explicit configuration over auto-discovery
+- Clear reconciliation view (configured vs deployed)
+- Simple cleanup of unneeded agents/skills
+- Backward compatibility with empty enabled lists
+"""
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+from claude_mpm.core.logging_utils import get_logger
+from claude_mpm.core.unified_config import UnifiedConfig
+from claude_mpm.core.unified_paths import get_path_manager
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class DeploymentResult:
+    """Result of deployment reconciliation."""
+
+    deployed: List[str]  # Newly deployed
+    removed: List[str]  # Removed (not in config)
+    unchanged: List[str]  # Already deployed and still needed
+    errors: List[str]  # Errors during reconciliation
+
+    @property
+    def success(self) -> bool:
+        """Whether reconciliation succeeded (no errors)."""
+        return len(self.errors) == 0
+
+
+@dataclass
+class ReconciliationState:
+    """Current state of agent/skill deployment."""
+
+    configured: Set[str]  # IDs in config enabled list
+    deployed: Set[str]  # IDs currently deployed
+    cached: Set[str]  # IDs available in cache
+
+    @property
+    def to_deploy(self) -> Set[str]:
+        """Agents/skills that need deployment (in config but not deployed)."""
+        return self.configured - self.deployed
+
+    @property
+    def to_remove(self) -> Set[str]:
+        """Agents/skills that should be removed (deployed but not in config)."""
+        return self.deployed - self.configured
+
+    @property
+    def unchanged(self) -> Set[str]:
+        """Agents/skills already deployed and still needed."""
+        return self.configured & self.deployed
+
+
+class DeploymentReconciler:
+    """
+    Reconciles configured agents/skills with deployed state.
+
+    This service implements the simplified deployment model:
+    1. Read agents.enabled and skills.enabled from config
+    2. Discover what's currently deployed in .claude/agents and .claude/skills
+    3. Deploy missing agents/skills from cache
+    4. Remove agents/skills not in enabled lists
+    """
+
+    def __init__(self, config: Optional[UnifiedConfig] = None):
+        """
+        Initialize reconciler.
+
+        Args:
+            config: UnifiedConfig instance (auto-loads if None)
+        """
+        self.config = config or self._load_config()
+        self.path_manager = get_path_manager()
+
+    def _load_config(self) -> UnifiedConfig:
+        """Load configuration from standard location."""
+        # For now, return default config
+        # TODO: Load from .claude-mpm/configuration.yaml
+        return UnifiedConfig()
+
+    def reconcile_agents(self, project_path: Optional[Path] = None) -> DeploymentResult:
+        """
+        Reconcile agent deployment with configuration.
+
+        Args:
+            project_path: Project directory (default: current directory)
+
+        Returns:
+            DeploymentResult with reconciliation summary
+        """
+        project_path = project_path or Path.cwd()
+        cache_dir = self.path_manager.get_cache_dir() / "agents"
+        deploy_dir = project_path / ".claude" / "agents"
+
+        # Get current state
+        state = self._get_agent_state(cache_dir, deploy_dir)
+
+        # Check backward compatibility
+        if not self.config.agents.enabled and self.config.agents.auto_discover:
+            logger.warning(
+                "agents.enabled is empty and auto_discover is True. "
+                "Consider migrating to explicit agent list. "
+                "Falling back to auto-discovery mode."
+            )
+            # In auto-discovery mode, don't remove anything
+            return DeploymentResult(
+                deployed=[], removed=[], unchanged=list(state.deployed), errors=[]
+            )
+
+        result = DeploymentResult(deployed=[], removed=[], unchanged=[], errors=[])
+
+        # Deploy missing agents
+        for agent_id in state.to_deploy:
+            if agent_id not in state.cached:
+                error_msg = f"Agent '{agent_id}' not found in cache. Run 'claude-mpm agents sync' first."
+                logger.warning(error_msg)
+                result.errors.append(error_msg)
+                continue
+
+            try:
+                self._deploy_agent(agent_id, cache_dir, deploy_dir)
+                result.deployed.append(agent_id)
+                logger.info(f"Deployed agent: {agent_id}")
+            except Exception as e:
+                error_msg = f"Failed to deploy agent '{agent_id}': {e}"
+                logger.error(error_msg)
+                result.errors.append(error_msg)
+
+        # Remove unneeded agents (only MPM agents, not user-created)
+        for agent_id in state.to_remove:
+            try:
+                if self._is_mpm_agent(deploy_dir, agent_id):
+                    self._remove_agent(agent_id, deploy_dir)
+                    result.removed.append(agent_id)
+                    logger.info(f"Removed agent: {agent_id}")
+                else:
+                    logger.debug(f"Skipping removal of user agent: {agent_id}")
+                    result.unchanged.append(agent_id)
+            except Exception as e:
+                error_msg = f"Failed to remove agent '{agent_id}': {e}"
+                logger.error(error_msg)
+                result.errors.append(error_msg)
+
+        # Track unchanged agents
+        result.unchanged.extend(list(state.unchanged))
+
+        return result
+
+    def reconcile_skills(self, project_path: Optional[Path] = None) -> DeploymentResult:
+        """
+        Reconcile skill deployment with configuration.
+
+        This includes:
+        1. Skills in skills.enabled list
+        2. Skills required by enabled agents (if auto_detect_dependencies=True)
+
+        Args:
+            project_path: Project directory (default: current directory)
+
+        Returns:
+            DeploymentResult with reconciliation summary
+        """
+        project_path = project_path or Path.cwd()
+        cache_dir = self.path_manager.get_cache_dir() / "skills"
+        deploy_dir = project_path / ".claude" / "skills"
+
+        # Get configured skills (explicit + agent dependencies)
+        configured_skills = set(self.config.skills.enabled)
+
+        if self.config.skills.auto_detect_dependencies:
+            # Add skills required by enabled agents
+            agent_skill_deps = self._get_agent_skill_dependencies(
+                self.config.agents.enabled
+            )
+            configured_skills.update(agent_skill_deps)
+
+        # Get current state
+        state = ReconciliationState(
+            configured=configured_skills,
+            deployed=self._list_deployed_skills(deploy_dir),
+            cached=self._list_cached_skills(cache_dir),
+        )
+
+        result = DeploymentResult(deployed=[], removed=[], unchanged=[], errors=[])
+
+        # Deploy missing skills
+        for skill_id in state.to_deploy:
+            if skill_id not in state.cached:
+                error_msg = (
+                    f"Skill '{skill_id}' not found in cache. Check skill sources."
+                )
+                logger.warning(error_msg)
+                result.errors.append(error_msg)
+                continue
+
+            try:
+                self._deploy_skill(skill_id, cache_dir, deploy_dir)
+                result.deployed.append(skill_id)
+                logger.info(f"Deployed skill: {skill_id}")
+            except Exception as e:
+                error_msg = f"Failed to deploy skill '{skill_id}': {e}"
+                logger.error(error_msg)
+                result.errors.append(error_msg)
+
+        # Remove unneeded skills (only MPM skills)
+        for skill_id in state.to_remove:
+            try:
+                if self._is_mpm_skill(deploy_dir, skill_id):
+                    self._remove_skill(skill_id, deploy_dir)
+                    result.removed.append(skill_id)
+                    logger.info(f"Removed skill: {skill_id}")
+                else:
+                    logger.debug(f"Skipping removal of user skill: {skill_id}")
+                    result.unchanged.append(skill_id)
+            except Exception as e:
+                error_msg = f"Failed to remove skill '{skill_id}': {e}"
+                logger.error(error_msg)
+                result.errors.append(error_msg)
+
+        # Track unchanged skills
+        result.unchanged.extend(list(state.unchanged))
+
+        return result
+
+    def _get_agent_state(
+        self, cache_dir: Path, deploy_dir: Path
+    ) -> ReconciliationState:
+        """Get current agent deployment state."""
+        return ReconciliationState(
+            configured=set(self.config.agents.enabled),
+            deployed=self._list_deployed_agents(deploy_dir),
+            cached=self._list_cached_agents(cache_dir),
+        )
+
+    def _list_deployed_agents(self, deploy_dir: Path) -> Set[str]:
+        """List agent IDs currently deployed."""
+        if not deploy_dir.exists():
+            return set()
+
+        agent_ids = set()
+        for agent_file in deploy_dir.glob("*.md"):
+            # Extract agent ID from filename (remove .md extension)
+            agent_id = agent_file.stem
+            agent_ids.add(agent_id)
+
+        return agent_ids
+
+    def _list_cached_agents(self, cache_dir: Path) -> Set[str]:
+        """List agent IDs available in cache."""
+        if not cache_dir.exists():
+            return set()
+
+        agent_ids = set()
+        for agent_file in cache_dir.glob("**/*.md"):
+            # Extract agent ID from filename
+            agent_id = agent_file.stem
+            agent_ids.add(agent_id)
+
+        return agent_ids
+
+    def _list_deployed_skills(self, deploy_dir: Path) -> Set[str]:
+        """List skill IDs currently deployed."""
+        if not deploy_dir.exists():
+            return set()
+
+        skill_ids = set()
+        for skill_file in deploy_dir.glob("*.md"):
+            skill_id = skill_file.stem
+            skill_ids.add(skill_id)
+
+        return skill_ids
+
+    def _list_cached_skills(self, cache_dir: Path) -> Set[str]:
+        """List skill IDs available in cache."""
+        if not cache_dir.exists():
+            return set()
+
+        skill_ids = set()
+        for skill_file in cache_dir.glob("**/*.md"):
+            skill_id = skill_file.stem
+            skill_ids.add(skill_id)
+
+        return skill_ids
+
+    def _deploy_agent(self, agent_id: str, cache_dir: Path, deploy_dir: Path) -> None:
+        """Deploy agent from cache to project directory."""
+        # Find agent file in cache
+        agent_file = self._find_file_in_cache(agent_id, cache_dir, "*.md")
+        if not agent_file:
+            raise FileNotFoundError(f"Agent file for '{agent_id}' not found in cache")
+
+        # Ensure deploy directory exists
+        deploy_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy agent file to deployment directory
+        dest_file = deploy_dir / agent_file.name
+        shutil.copy2(agent_file, dest_file)
+
+    def _deploy_skill(self, skill_id: str, cache_dir: Path, deploy_dir: Path) -> None:
+        """Deploy skill from cache to project directory."""
+        # Find skill file in cache
+        skill_file = self._find_file_in_cache(skill_id, cache_dir, "*.md")
+        if not skill_file:
+            raise FileNotFoundError(f"Skill file for '{skill_id}' not found in cache")
+
+        # Ensure deploy directory exists
+        deploy_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy skill file to deployment directory
+        dest_file = deploy_dir / skill_file.name
+        shutil.copy2(skill_file, dest_file)
+
+    def _remove_agent(self, agent_id: str, deploy_dir: Path) -> None:
+        """Remove deployed agent."""
+        agent_file = deploy_dir / f"{agent_id}.md"
+        if agent_file.exists():
+            agent_file.unlink()
+
+    def _remove_skill(self, skill_id: str, deploy_dir: Path) -> None:
+        """Remove deployed skill."""
+        skill_file = deploy_dir / f"{skill_id}.md"
+        if skill_file.exists():
+            skill_file.unlink()
+
+    def _is_mpm_agent(self, deploy_dir: Path, agent_id: str) -> bool:
+        """Check if agent is managed by MPM (not user-created)."""
+        agent_file = deploy_dir / f"{agent_id}.md"
+        if not agent_file.exists():
+            return False
+
+        try:
+            content = agent_file.read_text(encoding="utf-8")
+            # Check for MPM author markers
+            mpm_markers = [
+                "author: claude-mpm",
+                "author: 'claude-mpm'",
+                "author: anthropic",
+            ]
+            return any(marker in content.lower() for marker in mpm_markers)
+        except Exception as e:
+            logger.warning(f"Failed to check MPM marker for {agent_id}: {e}")
+            return False
+
+    def _is_mpm_skill(self, deploy_dir: Path, skill_id: str) -> bool:
+        """Check if skill is managed by MPM (not user-created)."""
+        skill_file = deploy_dir / f"{skill_id}.md"
+        if not skill_file.exists():
+            return False
+
+        try:
+            content = skill_file.read_text(encoding="utf-8")
+            # Check for MPM author markers
+            mpm_markers = [
+                "author: claude-mpm",
+                "author: 'claude-mpm'",
+                "author: anthropic",
+            ]
+            return any(marker in content.lower() for marker in mpm_markers)
+        except Exception as e:
+            logger.warning(f"Failed to check MPM marker for {skill_id}: {e}")
+            return False
+
+    def _find_file_in_cache(
+        self, item_id: str, cache_dir: Path, pattern: str
+    ) -> Optional[Path]:
+        """Find file in cache directory by ID pattern."""
+        # Try exact match first
+        exact_match = cache_dir / f"{item_id}.md"
+        if exact_match.exists():
+            return exact_match
+
+        # Search recursively
+        for file_path in cache_dir.glob(f"**/{item_id}.md"):
+            return file_path
+
+        return None
+
+    def _get_agent_skill_dependencies(self, agent_ids: List[str]) -> Set[str]:
+        """
+        Get skill dependencies for enabled agents.
+
+        This reads agent frontmatter to find required skills.
+
+        Args:
+            agent_ids: List of enabled agent IDs
+
+        Returns:
+            Set of skill IDs required by these agents
+        """
+        skill_deps = set()
+
+        # Get deployed agents directory
+        project_path = Path.cwd()
+        agents_dir = project_path / ".claude" / "agents"
+
+        if not agents_dir.exists():
+            logger.debug("No agents directory found, cannot extract skill dependencies")
+            return skill_deps
+
+        for agent_id in agent_ids:
+            agent_file = agents_dir / f"{agent_id}.md"
+            if not agent_file.exists():
+                logger.debug(
+                    f"Agent file not found for {agent_id}, skipping skill dependency extraction"
+                )
+                continue
+
+            try:
+                # Parse frontmatter to get skills list
+                skills = self._parse_agent_skills_from_frontmatter(agent_file)
+                if skills:
+                    logger.debug(f"Agent {agent_id} requires skills: {skills}")
+                    skill_deps.update(skills)
+            except Exception as e:
+                logger.warning(f"Failed to parse skills from {agent_id}: {e}")
+
+        return skill_deps
+
+    def _parse_agent_skills_from_frontmatter(self, agent_file: Path) -> List[str]:
+        """
+        Parse skills list from agent frontmatter.
+
+        Expected frontmatter format:
+        ---
+        name: Python Engineer
+        skills:
+          - pytest
+          - git-workflow
+        ---
+
+        Args:
+            agent_file: Path to agent .md file
+
+        Returns:
+            List of skill IDs from frontmatter (empty if none found)
+        """
+        try:
+            import yaml
+        except ImportError:
+            logger.warning("PyYAML not installed, cannot parse agent frontmatter")
+            return []
+
+        try:
+            content = agent_file.read_text(encoding="utf-8")
+
+            # Check for frontmatter delimiters
+            if not content.startswith("---"):
+                return []
+
+            # Find end of frontmatter
+            end_marker = content.find("\n---\n", 4)
+            if end_marker == -1:
+                end_marker = content.find("\n---\r\n", 4)
+
+            if end_marker == -1:
+                logger.debug(
+                    f"No valid frontmatter end marker found in {agent_file.name}"
+                )
+                return []
+
+            # Extract frontmatter YAML
+            frontmatter_yaml = content[4:end_marker]
+
+            # Parse YAML
+            frontmatter = yaml.safe_load(frontmatter_yaml)
+
+            if not frontmatter or not isinstance(frontmatter, dict):
+                return []
+
+            # Get skills list
+            skills = frontmatter.get("skills", [])
+            if isinstance(skills, list):
+                return [str(skill) for skill in skills]
+            logger.debug(
+                f"Skills field in {agent_file.name} is not a list: {type(skills)}"
+            )
+            return []
+
+        except yaml.YAMLError as e:
+            logger.warning(
+                f"Failed to parse YAML frontmatter in {agent_file.name}: {e}"
+            )
+            return []
+        except Exception as e:
+            logger.warning(
+                f"Unexpected error parsing frontmatter in {agent_file.name}: {e}"
+            )
+            return []
+
+    def get_reconciliation_view(
+        self, project_path: Optional[Path] = None
+    ) -> Dict[str, ReconciliationState]:
+        """
+        Get reconciliation view for agents and skills.
+
+        Args:
+            project_path: Project directory
+
+        Returns:
+            Dictionary with 'agents' and 'skills' reconciliation states
+        """
+        project_path = project_path or Path.cwd()
+
+        # Get agent state
+        agent_cache = self.path_manager.get_cache_dir() / "agents"
+        agent_deploy = project_path / ".claude" / "agents"
+        agent_state = self._get_agent_state(agent_cache, agent_deploy)
+
+        # Get skill state
+        skill_cache = self.path_manager.get_cache_dir() / "skills"
+        skill_deploy = project_path / ".claude" / "skills"
+
+        configured_skills = set(self.config.skills.enabled)
+        if self.config.skills.auto_detect_dependencies:
+            configured_skills.update(
+                self._get_agent_skill_dependencies(self.config.agents.enabled)
+            )
+
+        skill_state = ReconciliationState(
+            configured=configured_skills,
+            deployed=self._list_deployed_skills(skill_deploy),
+            cached=self._list_cached_skills(skill_cache),
+        )
+
+        return {"agents": agent_state, "skills": skill_state}

claude_mpm/services/agents/deployment/startup_reconciliation.py

@@ -0,0 +1,138 @@
+"""
+Startup Reconciliation Hook
+
+This module provides a hook for performing agent/skill reconciliation
+during application startup, ensuring deployed state matches configuration.
+
+Usage:
+    from claude_mpm.services.agents.deployment.startup_reconciliation import (
+        perform_startup_reconciliation
+    )
+
+    # In your startup code
+    perform_startup_reconciliation()
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from claude_mpm.core.logging_utils import get_logger
+from claude_mpm.core.unified_config import UnifiedConfig
+
+from .deployment_reconciler import DeploymentReconciler, DeploymentResult
+
+logger = get_logger(__name__)
+
+
+def perform_startup_reconciliation(
+    project_path: Optional[Path] = None,
+    config: Optional[UnifiedConfig] = None,
+    silent: bool = False,
+) -> tuple[DeploymentResult, DeploymentResult]:
+    """
+    Perform agent and skill reconciliation during startup.
+
+    This ensures the deployed state (.claude/agents, .claude/skills) matches
+    the configuration (agents.enabled, skills.enabled lists).
+
+    Args:
+        project_path: Project directory (default: current directory)
+        config: Configuration instance (auto-loads if None)
+        silent: Suppress info logging (only errors)
+
+    Returns:
+        Tuple of (agent_result, skill_result)
+    """
+    project_path = project_path or Path.cwd()
+
+    # Load config if not provided
+    if config is None:
+        config = UnifiedConfig()
+
+    # Initialize reconciler
+    reconciler = DeploymentReconciler(config)
+
+    if not silent:
+        logger.info("Performing startup reconciliation...")
+
+    # Reconcile agents
+    agent_result = reconciler.reconcile_agents(project_path)
+
+    if agent_result.deployed and not silent:
+        logger.info(f"Deployed agents: {', '.join(agent_result.deployed)}")
+    if agent_result.removed and not silent:
+        logger.info(f"Removed agents: {', '.join(agent_result.removed)}")
+    if agent_result.errors:
+        for error in agent_result.errors:
+            logger.error(f"Agent reconciliation error: {error}")
+
+    # Reconcile skills
+    skill_result = reconciler.reconcile_skills(project_path)
+
+    if skill_result.deployed and not silent:
+        logger.info(f"Deployed skills: {', '.join(skill_result.deployed)}")
+    if skill_result.removed and not silent:
+        logger.info(f"Removed skills: {', '.join(skill_result.removed)}")
+    if skill_result.errors:
+        for error in skill_result.errors:
+            logger.error(f"Skill reconciliation error: {error}")
+
+    if not silent:
+        total_errors = len(agent_result.errors) + len(skill_result.errors)
+        if total_errors == 0:
+            logger.info("Startup reconciliation complete")
+        else:
+            logger.warning(
+                f"Startup reconciliation complete with {total_errors} errors"
+            )
+
+    return agent_result, skill_result
+
+
+def check_reconciliation_needed(
+    project_path: Optional[Path] = None, config: Optional[UnifiedConfig] = None
+) -> bool:
+    """
+    Check if reconciliation is needed (without performing it).
+
+    Args:
+        project_path: Project directory
+        config: Configuration instance
+
+    Returns:
+        True if reconciliation would make changes
+    """
+    project_path = project_path or Path.cwd()
+
+    if config is None:
+        config = UnifiedConfig()
+
+    reconciler = DeploymentReconciler(config)
+    view = reconciler.get_reconciliation_view(project_path)
+
+    agent_state = view["agents"]
+    skill_state = view["skills"]
+
+    # Check if any changes needed
+    return (
+        len(agent_state.to_deploy) > 0
+        or len(agent_state.to_remove) > 0
+        or len(skill_state.to_deploy) > 0
+        or len(skill_state.to_remove) > 0
+    )
+
+
+# Example integration in startup code:
+#
+# from claude_mpm.services.agents.deployment.startup_reconciliation import (
+#     perform_startup_reconciliation,
+#     check_reconciliation_needed
+# )
+#
+# def startup():
+#     # Check if reconciliation needed
+#     if check_reconciliation_needed():
+#         logger.info("Reconciliation needed, performing...")
+#         perform_startup_reconciliation()
+#     else:
+#         logger.debug("No reconciliation needed")

claude_mpm/utils/agent_dependency_loader.py

@@ -768,8 +768,10 @@ class AgentDependencyLoader:
                 )
 
                 if is_uv_tool:
-                    cmd = ["uv", "pip", "install"]
-                    logger.debug("Using 'uv pip install' for UV tool environment")
+                    cmd = ["uv", "pip", "install", "--python", sys.executable]
+                    logger.debug(
+                        f"Using 'uv pip install --python {sys.executable}' for UV tool environment"
+                    )
                 else:
                     cmd = [sys.executable, "-m", "pip", "install"]