claude-mpm 5.0.9__py3-none-any.whl → 5.4.41__py3-none-any.whl

claude_mpm/services/skills/git_skill_source_manager.py

@@ -20,7 +20,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
 from pathlib import Path
 from threading import Lock
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from claude_mpm.config.skill_sources import SkillSource, SkillSourceConfiguration
 from claude_mpm.core.logging_config import get_logger
@@ -989,6 +989,7 @@ class GitSkillSourceManager:
         target_dir: Optional[Path] = None,
         force: bool = False,
         progress_callback=None,
+        skill_filter: Optional[Set[str]] = None,
     ) -> Dict[str, Any]:
         """Deploy skills from cache to target directory with flat structure.
 
@@ -1004,6 +1005,9 @@ class GitSkillSourceManager:
             target_dir: Target deployment directory (default: ~/.claude/skills/)
             force: Overwrite existing skills
             progress_callback: Optional callback(increment: int) called for each skill deployed
+            skill_filter: Optional set of skill names to deploy (selective deployment).
+                         If None, deploys all skills. If provided, only deploys skills
+                         whose name matches an entry in the filter set.
 
         Returns:
             Dict with deployment results:
@@ -1013,13 +1017,19 @@ class GitSkillSourceManager:
                 "failed_count": int,
                 "deployed_skills": List[str],
                 "skipped_skills": List[str],
-                "errors": List[str]
+                "errors": List[str],
+                "filtered_count": int  # Number of skills filtered out
             }
 
         Example:
             >>> manager = GitSkillSourceManager(config)
             >>> result = manager.deploy_skills()
             >>> print(f"Deployed {result['deployed_count']} skills")
+
+            # Selective deployment based on agent requirements:
+            >>> required = {"typescript-core", "react-patterns"}
+            >>> result = manager.deploy_skills(skill_filter=required)
+            >>> print(f"Deployed {result['deployed_count']} of {len(required)} required skills")
         """
         if target_dir is None:
             target_dir = Path.home() / ".claude" / "skills"
@@ -1029,10 +1039,60 @@ class GitSkillSourceManager:
         deployed = []
         skipped = []
         errors = []
+        filtered_count = 0
 
         # Get all skills from all sources
         all_skills = self.get_all_skills()
 
+        # Apply skill filter if provided (selective deployment)
+        if skill_filter is not None:
+            original_count = len(all_skills)
+            # Normalize filter to lowercase for case-insensitive matching
+            normalized_filter = {s.lower() for s in skill_filter}
+
+            def matches_filter(deployment_name: str) -> bool:
+                """Match using same fuzzy logic as ProfileManager.is_skill_enabled()"""
+                deployment_lower = deployment_name.lower()
+
+                # Exact match
+                if deployment_lower in normalized_filter:
+                    return True
+
+                # Fuzzy match: check if deployment name ends with or contains short name
+                # Example: "toolchains-python-frameworks-flask" matches "flask"
+                for short_name in normalized_filter:
+                    if deployment_lower.endswith(f"-{short_name}"):
+                        return True
+                    # Check if short name is contained as a segment
+                    if f"-{short_name}-" in deployment_lower:
+                        return True
+                    if deployment_lower.startswith(f"{short_name}-"):
+                        return True
+
+                return False
+
+            # Match against deployment_name using fuzzy matching
+            all_skills = [
+                s
+                for s in all_skills
+                if matches_filter(s.get("deployment_name", ""))
+            ]
+            filtered_count = original_count - len(all_skills)
+            self.logger.info(
+                f"Selective deployment: {len(all_skills)} of {original_count} skills "
+                f"match agent requirements ({filtered_count} filtered out)"
+            )
+
+            # Cleanup: Remove skills from target directory that aren't in the filtered set
+            # This ensures only the skills in the profile are deployed
+            removed_skills = self._cleanup_unfiltered_skills(
+                target_dir, all_skills
+            )
+            if removed_skills:
+                self.logger.info(
+                    f"Removed {len(removed_skills)} skills not in profile filter: {removed_skills}"
+                )
+
         self.logger.info(
             f"Deploying {len(all_skills)} skills to {target_dir} (force={force})"
         )
@@ -1083,8 +1143,76 @@ class GitSkillSourceManager:
             "deployed_skills": deployed,
             "skipped_skills": skipped,
             "errors": errors,
+            "filtered_count": filtered_count,
+        }
+
+    def _cleanup_unfiltered_skills(
+        self, target_dir: Path, filtered_skills: List[Dict[str, Any]]
+    ) -> List[str]:
+        """Remove skills from target directory that aren't in the filtered skill list.
+
+        Args:
+            target_dir: Target deployment directory
+            filtered_skills: List of skills that should remain deployed
+
+        Returns:
+            List of skill names that were removed
+        """
+        import shutil
+
+        removed_skills = []
+
+        # Build set of deployment names that should exist
+        expected_deployments = {
+            skill.get("deployment_name") for skill in filtered_skills
+            if skill.get("deployment_name")
         }
 
+        # Check each directory in target_dir
+        if not target_dir.exists():
+            return removed_skills
+
+        try:
+            for item in target_dir.iterdir():
+                # Skip files, only process directories
+                if not item.is_dir():
+                    continue
+
+                # Skip hidden directories
+                if item.name.startswith("."):
+                    continue
+
+                # Check if this skill directory should be kept
+                if item.name not in expected_deployments:
+                    try:
+                        # Security: Validate path is within target_dir
+                        if not self._validate_safe_path(target_dir, item):
+                            self.logger.error(
+                                f"Refusing to remove path outside target directory: {item}"
+                            )
+                            continue
+
+                        # Remove the skill directory
+                        if item.is_symlink():
+                            item.unlink()
+                        else:
+                            shutil.rmtree(item)
+
+                        removed_skills.append(item.name)
+                        self.logger.debug(
+                            f"Removed unfiltered skill: {item.name}"
+                        )
+
+                    except Exception as e:
+                        self.logger.warning(
+                            f"Failed to remove skill directory {item.name}: {e}"
+                        )
+
+        except Exception as e:
+            self.logger.error(f"Error during skill cleanup: {e}")
+
+        return removed_skills
+
     def _deploy_single_skill(
         self, skill: Dict[str, Any], target_dir: Path, deployment_name: str, force: bool
     ) -> Dict[str, Any]: