claude-mpm 4.13.2__py3-none-any.whl → 4.18.2__py3-none-any.whl

claude_mpm/skills/skill_manager.py

@@ -0,0 +1,310 @@
+"""Skills manager - integrates skills with agents."""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from claude_mpm.core.logging_utils import get_logger
+
+from .registry import Skill, get_registry
+
+logger = get_logger(__name__)
+
+
+class SkillManager:
+    """Manages skills and their integration with agents."""
+
+    def __init__(self):
+        """Initialize the skill manager."""
+        self.registry = get_registry()
+        self.agent_skill_mapping: Dict[str, List[str]] = {}
+        self._load_agent_mappings()
+
+    def _load_agent_mappings(self):
+        """Load skill mappings from agent templates."""
+        # Load mappings from agent JSON templates that have 'skills' field
+        agent_templates_dir = Path(__file__).parent.parent / "agents" / "templates"
+
+        if not agent_templates_dir.exists():
+            logger.warning(
+                f"Agent templates directory not found: {agent_templates_dir}"
+            )
+            return
+
+        mapping_count = 0
+        for template_file in agent_templates_dir.glob("*.json"):
+            try:
+                with open(template_file, encoding="utf-8") as f:
+                    agent_data = json.load(f)
+
+                agent_id = agent_data.get("agent_id") or agent_data.get("agent_type")
+                if not agent_id:
+                    continue
+
+                # Extract skills list if present
+                skills = agent_data.get("skills", [])
+                if skills:
+                    self.agent_skill_mapping[agent_id] = skills
+                    mapping_count += 1
+                    logger.debug(
+                        f"Agent '{agent_id}' mapped to {len(skills)} skills: {', '.join(skills)}"
+                    )
+
+            except Exception as e:
+                logger.error(f"Error loading agent mapping from {template_file}: {e}")
+
+        if mapping_count > 0:
+            logger.info(f"Loaded skill mappings for {mapping_count} agents")
+
+    def get_agent_skills(self, agent_type: str) -> List[Skill]:
+        """
+        Get all skills for an agent (bundled + discovered).
+
+        Args:
+            agent_type: Agent type/ID (e.g., 'engineer', 'python_engineer')
+
+        Returns:
+            List of Skill objects for this agent
+        """
+        skill_names = self.agent_skill_mapping.get(agent_type, [])
+
+        # Get skills from registry
+        skills = []
+        for name in skill_names:
+            skill = self.registry.get_skill(name)
+            if skill:
+                skills.append(skill)
+            else:
+                logger.warning(
+                    f"Skill '{name}' referenced by agent '{agent_type}' not found"
+                )
+
+        # Also include skills that have no agent restriction
+        # or explicitly list this agent type
+        additional_skills = self.registry.get_skills_for_agent(agent_type)
+        for skill in additional_skills:
+            if skill not in skills:
+                skills.append(skill)
+
+        return skills
+
+    def enhance_agent_prompt(
+        self, agent_type: str, base_prompt: str, include_all: bool = False
+    ) -> str:
+        """
+        Enhance agent prompt with available skills.
+
+        Args:
+            agent_type: Agent type/ID
+            base_prompt: Original agent prompt
+            include_all: If True, include all available skills regardless of mapping
+
+        Returns:
+            Enhanced prompt with skills section appended
+        """
+        if include_all:
+            skills = self.registry.list_skills()
+        else:
+            skills = self.get_agent_skills(agent_type)
+
+        if not skills:
+            return base_prompt
+
+        # Build skills section
+        skills_section = "\n\n" + "=" * 80 + "\n"
+        skills_section += "## 🎯 Available Skills\n\n"
+        skills_section += f"You have access to {len(skills)} specialized skills:\n\n"
+
+        for skill in skills:
+            skills_section += f"### 📚 {skill.name.replace('-', ' ').title()}\n\n"
+            skills_section += f"**Source:** {skill.source}\n"
+            if skill.description:
+                skills_section += f"**Description:** {skill.description}\n"
+            skills_section += "\n```\n"
+            skills_section += skill.content
+            skills_section += "\n```\n\n"
+
+        skills_section += "=" * 80 + "\n"
+
+        return base_prompt + skills_section
+
+    def list_agent_skill_mappings(self) -> Dict[str, List[str]]:
+        """
+        Get all agent-to-skill mappings.
+
+        Returns:
+            Dictionary mapping agent IDs to lists of skill names
+        """
+        return self.agent_skill_mapping.copy()
+
+    def add_skill_to_agent(self, agent_type: str, skill_name: str) -> bool:
+        """
+        Add a skill to an agent's mapping.
+
+        Args:
+            agent_type: Agent type/ID
+            skill_name: Name of the skill to add
+
+        Returns:
+            True if successful, False if skill not found
+        """
+        skill = self.registry.get_skill(skill_name)
+        if not skill:
+            logger.error(f"Cannot add skill '{skill_name}': skill not found")
+            return False
+
+        if agent_type not in self.agent_skill_mapping:
+            self.agent_skill_mapping[agent_type] = []
+
+        if skill_name not in self.agent_skill_mapping[agent_type]:
+            self.agent_skill_mapping[agent_type].append(skill_name)
+            logger.info(f"Added skill '{skill_name}' to agent '{agent_type}'")
+
+        return True
+
+    def remove_skill_from_agent(self, agent_type: str, skill_name: str) -> bool:
+        """
+        Remove a skill from an agent's mapping.
+
+        Args:
+            agent_type: Agent type/ID
+            skill_name: Name of the skill to remove
+
+        Returns:
+            True if successful, False if not found
+        """
+        if agent_type not in self.agent_skill_mapping:
+            return False
+
+        if skill_name in self.agent_skill_mapping[agent_type]:
+            self.agent_skill_mapping[agent_type].remove(skill_name)
+            logger.info(f"Removed skill '{skill_name}' from agent '{agent_type}'")
+            return True
+
+        return False
+
+    def reload(self):
+        """Reload skills and agent mappings."""
+        logger.info("Reloading skill manager...")
+        self.registry.reload()
+        self.agent_skill_mapping.clear()
+        self._load_agent_mappings()
+        logger.info("Skill manager reloaded")
+
+    def infer_agents_for_skill(self, skill) -> List[str]:
+        """Infer which agents should have this skill based on tags/name.
+
+        Args:
+            skill: Skill object to analyze
+
+        Returns:
+            List of agent IDs that should have this skill
+        """
+        agents = []
+        content_lower = skill.content.lower()
+        name_lower = skill.name.lower()
+
+        # Python-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["python", "django", "flask", "fastapi"]
+        ):
+            agents.append("python-engineer")
+
+        # TypeScript/JavaScript-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["typescript", "javascript", "react", "next", "vue", "node"]
+        ):
+            agents.extend(["typescript-engineer", "react-engineer", "nextjs-engineer"])
+
+        # Go-related
+        if any(tag in content_lower or tag in name_lower for tag in ["golang", "go "]):
+            agents.append("golang-engineer")
+
+        # Ops-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["docker", "kubernetes", "deploy", "devops", "ops"]
+        ):
+            agents.extend(["ops", "devops", "local-ops"])
+
+        # Testing/QA-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["test", "qa", "quality", "assert"]
+        ):
+            agents.extend(["qa", "web-qa", "api-qa"])
+
+        # Documentation-related
+        if any(
+            tag in content_lower or tag in name_lower
+            for tag in ["documentation", "docs", "api doc", "openapi"]
+        ):
+            agents.extend(["docs", "documentation", "technical-writer"])
+
+        # Remove duplicates
+        return list(set(agents))
+
+    def save_mappings_to_config(self, config_path: Optional[Path] = None):
+        """Save current agent-skill mappings to configuration file.
+
+        Args:
+            config_path: Path to configuration file. If None, uses default.
+        """
+        import json
+
+        if config_path is None:
+            config_path = Path.cwd() / ".claude-mpm" / "skills_config.json"
+
+        # Ensure directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Save mappings
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(self.agent_skill_mapping, f, indent=2)
+
+        logger.info(f"Saved skill mappings to {config_path}")
+
+    def load_mappings_from_config(self, config_path: Optional[Path] = None):
+        """Load agent-skill mappings from configuration file.
+
+        Args:
+            config_path: Path to configuration file. If None, uses default.
+        """
+        import json
+
+        if config_path is None:
+            config_path = Path.cwd() / ".claude-mpm" / "skills_config.json"
+
+        if not config_path.exists():
+            logger.debug(f"No skill mappings config found at {config_path}")
+            return
+
+        try:
+            with open(config_path, encoding="utf-8") as f:
+                loaded_mappings = json.load(f)
+
+            # Merge with existing mappings
+            for agent_id, skills in loaded_mappings.items():
+                if agent_id not in self.agent_skill_mapping:
+                    self.agent_skill_mapping[agent_id] = []
+                for skill in skills:
+                    if skill not in self.agent_skill_mapping[agent_id]:
+                        self.agent_skill_mapping[agent_id].append(skill)
+
+            logger.info(f"Loaded skill mappings from {config_path}")
+        except Exception as e:
+            logger.error(f"Error loading skill mappings from {config_path}: {e}")
+
+
+# Global manager instance (singleton pattern)
+_manager: Optional[SkillManager] = None
+
+
+def get_manager() -> SkillManager:
+    """Get the global skill manager (singleton)."""
+    global _manager
+    if _manager is None:
+        _manager = SkillManager()
+    return _manager

claude_mpm/tools/code_tree_analyzer.py

@@ -1528,10 +1528,31 @@ class CodeTreeAnalyzer:
         if not path.exists() or not path.is_file():
             return {"error": f"Invalid file: {file_path}"}
 
-        # Get language first (needed for return statement)
         language = self._get_language(path)
+        self._emit_analysis_start(path, language)
 
-        # Emit analysis start event
+        # Check cache
+        file_hash = self._get_file_hash(path)
+        cache_key = f"{file_path}:{file_hash}"
+
+        if cache_key in self.cache:
+            nodes = self.cache[cache_key]
+            self._emit_cache_hit(path)
+            filtered_nodes = self._filter_nodes(nodes)
+        else:
+            nodes, filtered_nodes, duration = self._analyze_and_cache_file(
+                path, language, cache_key
+            )
+            self._emit_analysis_complete(path, filtered_nodes, duration)
+
+        # Prepare final data structures
+        final_nodes = self._prepare_final_nodes(nodes, filtered_nodes)
+        elements = self._convert_nodes_to_elements(final_nodes)
+
+        return self._build_result(file_path, language, final_nodes, elements)
+
+    def _emit_analysis_start(self, path: Path, language: str) -> None:
+        """Emit analysis start event."""
         if self.emitter:
             from datetime import datetime
 
@@ -1546,179 +1567,194 @@ class CodeTreeAnalyzer:
                 },
             )
 
-        # Check cache
-        file_hash = self._get_file_hash(path)
-        cache_key = f"{file_path}:{file_hash}"
+    def _emit_cache_hit(self, path: Path) -> None:
+        """Emit cache hit event."""
+        if self.emitter:
+            from datetime import datetime
 
-        if cache_key in self.cache:
-            nodes = self.cache[cache_key]
-            if self.emitter:
-                from datetime import datetime
+            self.emitter.emit(
+                "info",
+                {
+                    "type": "cache.hit",
+                    "file": str(path),
+                    "message": f"Using cached analysis for {path.name}",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
 
-                self.emitter.emit(
-                    "info",
-                    {
-                        "type": "cache.hit",
-                        "file": str(path),
-                        "message": f"Using cached analysis for {path.name}",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                )
-        else:
-            # Analyze file
-            if self.emitter:
-                from datetime import datetime
+    def _emit_cache_miss(self, path: Path) -> None:
+        """Emit cache miss event."""
+        if self.emitter:
+            from datetime import datetime
 
-                self.emitter.emit(
-                    "info",
-                    {
-                        "type": "cache.miss",
-                        "file": str(path),
-                        "message": f"Cache miss, analyzing fresh: {path.name}",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                )
+            self.emitter.emit(
+                "info",
+                {
+                    "type": "cache.miss",
+                    "file": str(path),
+                    "message": f"Cache miss, analyzing fresh: {path.name}",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
 
-            if language == "python":
-                analyzer = self.python_analyzer
-            elif language in {"javascript", "typescript"}:
-                analyzer = self.javascript_analyzer
-            else:
-                analyzer = self.generic_analyzer
+    def _emit_parsing_start(self, path: Path) -> None:
+        """Emit parsing start event."""
+        if self.emitter:
+            from datetime import datetime
+
+            self.emitter.emit(
+                "info",
+                {
+                    "type": "analysis.parse",
+                    "file": str(path),
+                    "message": f"Parsing file content: {path.name}",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
 
-            start_time = time.time()
+    def _emit_node_found(self, node: CodeNode, path: Path) -> None:
+        """Emit node found event."""
+        if self.emitter:
+            from datetime import datetime
 
-            # Emit parsing event
-            if self.emitter:
-                from datetime import datetime
+            self.emitter.emit(
+                "info",
+                {
+                    "type": f"analysis.{node.node_type}",
+                    "name": node.name,
+                    "file": str(path),
+                    "line_start": node.line_start,
+                    "complexity": node.complexity,
+                    "message": f"Found {node.node_type}: {node.name}",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
 
-                self.emitter.emit(
-                    "info",
-                    {
-                        "type": "analysis.parse",
-                        "file": str(path),
-                        "message": f"Parsing file content: {path.name}",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                )
+    def _emit_analysis_complete(
+        self, path: Path, filtered_nodes: list, duration: float
+    ) -> None:
+        """Emit analysis complete event."""
+        if not self.emitter:
+            return
 
-            nodes = analyzer.analyze_file(path) if analyzer else []
-            duration = time.time() - start_time
+        from datetime import datetime
+
+        stats = self._calculate_node_stats(filtered_nodes)
+        self.emitter.emit(
+            "info",
+            {
+                "type": "analysis.complete",
+                "file": str(path),
+                "stats": stats,
+                "duration": duration,
+                "message": f"Analysis complete: {stats['classes']} classes, {stats['functions']} functions, {stats['methods']} methods",
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            },
+        )
+        self.emitter.emit_file_analyzed(str(path), filtered_nodes, duration)
 
-            # Cache results
-            self.cache[cache_key] = nodes
+    def _analyze_and_cache_file(
+        self, path: Path, language: str, cache_key: str
+    ) -> tuple:
+        """Analyze file content and cache results."""
+        self._emit_cache_miss(path)
+        self._emit_parsing_start(path)
 
-            # Filter internal functions before emitting
-            filtered_nodes = []
-            classes_count = 0
-            functions_count = 0
-            methods_count = 0
+        # Select analyzer based on language
+        analyzer = self._select_analyzer(language)
 
-            for node in nodes:
-                # Only include main structural elements
-                if not self._is_internal_node(node):
-                    # Emit found element event
-                    if self.emitter:
-                        from datetime import datetime
+        # Perform analysis
+        start_time = time.time()
+        nodes = analyzer.analyze_file(path) if analyzer else []
+        duration = time.time() - start_time
 
-                        self.emitter.emit(
-                            "info",
-                            {
-                                "type": f"analysis.{node.node_type}",
-                                "name": node.name,
-                                "file": str(path),
-                                "line_start": node.line_start,
-                                "complexity": node.complexity,
-                                "message": f"Found {node.node_type}: {node.name}",
-                                "timestamp": datetime.now(timezone.utc).isoformat(),
-                            },
-                        )
+        # Cache results
+        self.cache[cache_key] = nodes
 
-                        # Count node types
-                        if node.node_type == "class":
-                            classes_count += 1
-                        elif node.node_type == "function":
-                            functions_count += 1
-                        elif node.node_type == "method":
-                            methods_count += 1
-
-                    filtered_nodes.append(
-                        {
-                            "name": node.name,
-                            "type": node.node_type,
-                            "line_start": node.line_start,
-                            "line_end": node.line_end,
-                            "complexity": node.complexity,
-                            "has_docstring": node.has_docstring,
-                            "signature": node.signature,
-                        }
-                    )
+        # Filter and process nodes
+        filtered_nodes = self._filter_and_emit_nodes(nodes, path)
 
-            # Emit analysis complete event with stats
-            if self.emitter:
-                from datetime import datetime
+        return nodes, filtered_nodes, duration
 
-                self.emitter.emit(
-                    "info",
-                    {
-                        "type": "analysis.complete",
-                        "file": str(path),
-                        "stats": {
-                            "classes": classes_count,
-                            "functions": functions_count,
-                            "methods": methods_count,
-                            "total_nodes": len(filtered_nodes),
-                        },
-                        "duration": duration,
-                        "message": f"Analysis complete: {classes_count} classes, {functions_count} functions, {methods_count} methods",
-                        "timestamp": datetime.now(timezone.utc).isoformat(),
-                    },
-                )
+    def _select_analyzer(self, language: str):
+        """Select appropriate analyzer for language."""
+        if language == "python":
+            return self.python_analyzer
+        if language in {"javascript", "typescript"}:
+            return self.javascript_analyzer
+        return self.generic_analyzer
 
-                self.emitter.emit_file_analyzed(file_path, filtered_nodes, duration)
+    def _filter_nodes(self, nodes: list) -> list:
+        """Filter nodes without emitting events."""
+        return [self._node_to_dict(n) for n in nodes if not self._is_internal_node(n)]
 
-        # Prepare the nodes data
-        final_nodes = (
-            filtered_nodes
-            if "filtered_nodes" in locals()
-            else [
-                {
-                    "name": n.name,
-                    "type": n.node_type,
-                    "line_start": n.line_start,
-                    "line_end": n.line_end,
-                    "complexity": n.complexity,
-                    "has_docstring": n.has_docstring,
-                    "signature": n.signature,
-                }
-                for n in nodes
-                if not self._is_internal_node(n)
-            ]
-        )
+    def _filter_and_emit_nodes(self, nodes: list, path: Path) -> list:
+        """Filter nodes and emit events for each."""
+        filtered_nodes = []
+        for node in nodes:
+            if not self._is_internal_node(node):
+                self._emit_node_found(node, path)
+                filtered_nodes.append(self._node_to_dict(node))
+        return filtered_nodes
+
+    def _node_to_dict(self, node: CodeNode) -> dict:
+        """Convert CodeNode to dictionary."""
+        return {
+            "name": node.name,
+            "type": node.node_type,
+            "line_start": node.line_start,
+            "line_end": node.line_end,
+            "complexity": node.complexity,
+            "has_docstring": node.has_docstring,
+            "signature": node.signature,
+        }
+
+    def _calculate_node_stats(self, filtered_nodes: list) -> dict:
+        """Calculate statistics from filtered nodes."""
+        classes_count = sum(1 for n in filtered_nodes if n["type"] == "class")
+        functions_count = sum(1 for n in filtered_nodes if n["type"] == "function")
+        methods_count = sum(1 for n in filtered_nodes if n["type"] == "method")
+        return {
+            "classes": classes_count,
+            "functions": functions_count,
+            "methods": methods_count,
+            "total_nodes": len(filtered_nodes),
+        }
+
+    def _prepare_final_nodes(self, nodes: list, filtered_nodes: list) -> list:
+        """Prepare final nodes data structure."""
+        if filtered_nodes:
+            return filtered_nodes
+        return [self._node_to_dict(n) for n in nodes if not self._is_internal_node(n)]
 
-        # Convert nodes to elements format for dashboard compatibility
+    def _convert_nodes_to_elements(self, final_nodes: list) -> list:
+        """Convert nodes to elements format for dashboard."""
         elements = []
         for node in final_nodes:
             element = {
                 "name": node["name"],
                 "type": node["type"],
-                "line": node["line_start"],  # Dashboard expects 'line' not 'line_start'
+                "line": node["line_start"],
                 "complexity": node["complexity"],
                 "signature": node.get("signature", ""),
                 "has_docstring": node.get("has_docstring", False),
             }
-            # Add methods if it's a class (for expandable tree)
             if node["type"] == "class":
-                element["methods"] = []  # Could be populated with class methods
+                element["methods"] = []
             elements.append(element)
+        return elements
 
+    def _build_result(
+        self, file_path: str, language: str, final_nodes: list, elements: list
+    ) -> dict:
+        """Build final result dictionary."""
         return {
             "path": file_path,
             "language": language,
-            "nodes": final_nodes,  # Keep for backward compatibility
-            "elements": elements,  # Add for dashboard compatibility
+            "nodes": final_nodes,
+            "elements": elements,
             "complexity": sum(e["complexity"] for e in elements),
-            "lines": len(elements),  # Simple line count approximation
+            "lines": len(elements),
             "stats": {
                 "classes": len([e for e in elements if e["type"] == "class"]),
                 "functions": len([e for e in elements if e["type"] == "function"]),