claude-mpm 4.1.4__py3-none-any.whl → 4.1.5__py3-none-any.whl

claude_mpm/core/output_style_manager.py

@@ -21,6 +21,10 @@ from ..utils.imports import safe_import
 # Import with fallback support
 get_logger = safe_import("claude_mpm.core.logger", "core.logger", ["get_logger"])
 
+# Global cache for Claude version to avoid duplicate detection/logging
+_CACHED_CLAUDE_VERSION: Optional[str] = None
+_VERSION_DETECTED: bool = False
+
 
 class OutputStyleManager:
     """Manages output style deployment and version-based handling."""
@@ -41,10 +45,17 @@ class OutputStyleManager:
     def _detect_claude_version(self) -> Optional[str]:
         """
         Detect Claude Code version by running 'claude --version'.
+        Uses global cache to avoid duplicate detection and logging.
 
         Returns:
             Version string (e.g., "1.0.82") or None if Claude not found
         """
+        global _CACHED_CLAUDE_VERSION, _VERSION_DETECTED
+
+        # Return cached version if already detected
+        if _VERSION_DETECTED:
+            return _CACHED_CLAUDE_VERSION
+
         try:
             # Run claude --version command
             result = subprocess.run(
@@ -57,6 +68,8 @@ class OutputStyleManager:
 
             if result.returncode != 0:
                 self.logger.warning(f"Claude command failed: {result.stderr}")
+                _VERSION_DETECTED = True
+                _CACHED_CLAUDE_VERSION = None
                 return None
 
             # Parse version from output
@@ -66,19 +79,30 @@ class OutputStyleManager:
 
             if version_match:
                 version = version_match.group(1)
+                # Only log on first detection
                 self.logger.info(f"Detected Claude version: {version}")
+                _CACHED_CLAUDE_VERSION = version
+                _VERSION_DETECTED = True
                 return version
             self.logger.warning(f"Could not parse version from: {version_output}")
+            _VERSION_DETECTED = True
+            _CACHED_CLAUDE_VERSION = None
             return None
 
         except FileNotFoundError:
             self.logger.info("Claude Code not found in PATH")
+            _VERSION_DETECTED = True
+            _CACHED_CLAUDE_VERSION = None
             return None
         except subprocess.TimeoutExpired:
             self.logger.warning("Claude version check timed out")
+            _VERSION_DETECTED = True
+            _CACHED_CLAUDE_VERSION = None
             return None
         except Exception as e:
             self.logger.warning(f"Error detecting Claude version: {e}")
+            _VERSION_DETECTED = True
+            _CACHED_CLAUDE_VERSION = None
             return None
 
     def _compare_versions(self, version1: str, version2: str) -> int:

claude_mpm/core/unified_agent_registry.py

@@ -136,7 +136,13 @@ class UnifiedAgentRegistry:
 
         # Discovery configuration
         self.file_extensions = {".md", ".json", ".yaml", ".yml"}
-        self.ignore_patterns = {"__pycache__", ".git", "node_modules", ".pytest_cache"}
+        self.ignore_patterns = {
+            "__pycache__",
+            ".git",
+            "node_modules",
+            ".pytest_cache",
+            "backup",
+        }
 
         # Statistics
         self.discovery_stats = {
@@ -166,15 +172,15 @@ class UnifiedAgentRegistry:
         if user_path.exists():
             self.discovery_paths.append(user_path)
 
-        # System-level agents
+        # System-level agents (includes templates as a subdirectory)
         system_path = self.path_manager.get_system_agents_dir()
         if system_path.exists():
             self.discovery_paths.append(system_path)
 
-        # Templates directory
-        templates_path = self.path_manager.get_templates_dir()
-        if templates_path.exists():
-            self.discovery_paths.append(templates_path)
+        # NOTE: Templates directory is NOT added separately because:
+        # - templates_path = system_path / "templates"
+        # - The rglob("*") in _discover_path will already find templates
+        # - Adding it separately causes duplicate discovery
 
         logger.debug(
             f"Discovery paths configured: {[str(p) for p in self.discovery_paths]}"
@@ -256,7 +262,10 @@ class UnifiedAgentRegistry:
             try:
                 metadata = self._create_agent_metadata(file_path, agent_name, tier)
                 if metadata:
-                    self.registry[agent_name] = metadata
+                    # Store all discovered agents temporarily for tier precedence
+                    # Use a unique key that includes tier to prevent overwrites
+                    registry_key = f"{agent_name}_{tier.value}"
+                    self.registry[registry_key] = metadata
                     self.discovered_files.add(file_path)
                     logger.debug(
                         f"Discovered agent: {agent_name} ({tier.value}) at {file_path}"
@@ -269,9 +278,29 @@ class UnifiedAgentRegistry:
         # Remove extension and use filename as agent name
         name = file_path.stem
 
-        # Skip certain files
-        skip_files = {"README", "INSTRUCTIONS", "template", "example"}
-        if name.upper() in skip_files:
+        # Skip certain files and non-agent templates
+        skip_files = {
+            "README",
+            "INSTRUCTIONS",
+            "template",
+            "example",
+            "base_agent",
+            "base_agent_template",
+            "agent_template",
+            "agent_schema",
+            "base_pm",
+            "workflow",
+            "output_style",
+            "memory",
+            "optimization_report",
+            "vercel_ops_instructions",
+            "agent-template",
+            "agent-schema",  # Also handle hyphenated versions
+        }
+        # Case-insensitive comparison
+        if name.replace("-", "_").upper() in {
+            s.replace("-", "_").upper() for s in skip_files
+        }:
             return None
 
         # Normalize name
@@ -424,12 +453,14 @@ class UnifiedAgentRegistry:
 
     def _apply_tier_precedence(self) -> None:
         """Apply tier precedence rules to resolve conflicts."""
-        # Group agents by name
+        # Group agents by their actual name (without tier suffix)
         agent_groups = {}
-        for name, metadata in self.registry.items():
-            if name not in agent_groups:
-                agent_groups[name] = []
-            agent_groups[name].append(metadata)
+        for registry_key, metadata in self.registry.items():
+            # Extract the actual agent name (registry_key is "name_tier")
+            agent_name = metadata.name  # Use the actual name from metadata
+            if agent_name not in agent_groups:
+                agent_groups[agent_name] = []
+            agent_groups[agent_name].append(metadata)
 
         # Resolve conflicts using tier precedence
         resolved_registry = {}

claude_mpm/services/agents/deployment/agent_discovery_service.py

@@ -34,10 +34,14 @@ class AgentDiscoveryService:
         self.logger = get_logger(__name__)
         self.templates_dir = templates_dir
 
-    def list_available_agents(self) -> List[Dict[str, Any]]:
+    def list_available_agents(self, log_discovery: bool = True) -> List[Dict[str, Any]]:
         """
         List all available agent templates with their metadata.
 
+        Args:
+            log_discovery: Whether to log discovery results (default: True).
+                          Set to False when called from multi-source discovery to avoid duplicate logs.
+
         Returns:
             List of agent information dictionaries containing:
             - name: Agent name
@@ -73,7 +77,11 @@ class AgentDiscoveryService:
         # Sort by agent name for consistent ordering
         agents.sort(key=lambda x: x.get("name", ""))
 
-        self.logger.info(f"Discovered {len(agents)} available agent templates")
+        # Only log if requested (to avoid duplicate logging from multi-source discovery)
+        if log_discovery:
+            self.logger.info(
+                f"Discovered {len(agents)} available agent templates from {self.templates_dir.name}"
+            )
         return agents
 
     def get_filtered_templates(
@@ -153,7 +161,8 @@ class AgentDiscoveryService:
             Dictionary mapping categories to lists of agent names
         """
         categories = {}
-        agents = self.list_available_agents()
+        # Don't log discovery when called internally
+        agents = self.list_available_agents(log_discovery=False)
 
         for agent in agents:
             agent_name = agent.get("name", "unknown")