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

claude_mpm/cli/parsers/agent_manager_parser.py

@@ -32,6 +32,9 @@ Examples:
   claude-mpm agent-manager show --id engineer            # Show agent details
   claude-mpm agent-manager test --id my-agent            # Test agent configuration
   claude-mpm agent-manager templates                     # List available templates
+  claude-mpm agent-manager reset --dry-run               # Preview agent cleanup
+  claude-mpm agent-manager reset --force                 # Remove all claude-mpm agents
+  claude-mpm agent-manager reset --project-only          # Clean only project agents
 """,
     )
 
@@ -197,3 +200,34 @@ Examples:
         default="text",
         help="Output format (default: text)",
     )
+
+    # Reset command
+    reset_parser = agent_subparsers.add_parser(
+        "reset", help="Remove claude-mpm authored agents for clean install"
+    )
+    reset_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Execute cleanup immediately without confirmation",
+    )
+    reset_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview what would be removed without making changes",
+    )
+    reset_parser.add_argument(
+        "--project-only",
+        action="store_true",
+        help="Only clean project-level agents (.claude/agents)",
+    )
+    reset_parser.add_argument(
+        "--user-only",
+        action="store_true",
+        help="Only clean user-level agents (~/.claude/agents)",
+    )
+    reset_parser.add_argument(
+        "--format",
+        choices=["text", "json"],
+        default="text",
+        help="Output format (default: text)",
+    )

claude_mpm/core/framework_loader.py

@@ -1283,6 +1283,14 @@ Extract tickets from these patterns:
                 if agent.get("model") and agent["model"] != "opus":
                     section += f"- **Model**: {agent['model']}\n"
 
+                # Add memory routing information if available
+                if agent.get("memory_routing"):
+                    memory_routing = agent["memory_routing"]
+                    if memory_routing.get("description"):
+                        section += (
+                            f"- **Memory Routing**: {memory_routing['description']}\n"
+                        )
+
             # Add simple Context-Aware Agent Selection
             section += "\n## Context-Aware Agent Selection\n\n"
             section += (
@@ -1384,6 +1392,14 @@ Extract tickets from these patterns:
                 if routing_data:
                     agent_data["routing"] = routing_data
 
+            # Try to load memory routing metadata from JSON template if not in YAML frontmatter
+            if "memory_routing" not in agent_data:
+                memory_routing_data = self._load_memory_routing_from_template(
+                    agent_file.stem
+                )
+                if memory_routing_data:
+                    agent_data["memory_routing"] = memory_routing_data
+
             # Cache the parsed metadata
             self._cache_manager.set_agent_metadata(cache_key, agent_data, file_mtime)
 
@@ -1393,6 +1409,81 @@ Extract tickets from these patterns:
             self.logger.debug(f"Could not parse metadata from {agent_file}: {e}")
             return None
 
+    def _load_memory_routing_from_template(
+        self, agent_name: str
+    ) -> Optional[Dict[str, Any]]:
+        """Load memory routing metadata from agent JSON template.
+
+        Args:
+            agent_name: Name of the agent (stem of the file)
+
+        Returns:
+            Dictionary with memory routing metadata or None if not found
+        """
+        try:
+            import json
+
+            # Check if we have a framework path
+            if not self.framework_path or self.framework_path == Path("__PACKAGED__"):
+                # For packaged installations, try to load from package resources
+                if files:
+                    try:
+                        templates_package = files("claude_mpm.agents.templates")
+                        template_file = templates_package / f"{agent_name}.json"
+
+                        if template_file.is_file():
+                            template_content = template_file.read_text()
+                            template_data = json.loads(template_content)
+                            return template_data.get("memory_routing")
+                    except Exception as e:
+                        self.logger.debug(
+                            f"Could not load memory routing from packaged template for {agent_name}: {e}"
+                        )
+                return None
+
+            # For development mode, load from filesystem
+            templates_dir = (
+                self.framework_path / "src" / "claude_mpm" / "agents" / "templates"
+            )
+            template_file = templates_dir / f"{agent_name}.json"
+
+            if template_file.exists():
+                with open(template_file) as f:
+                    template_data = json.load(f)
+                    return template_data.get("memory_routing")
+
+            # Also check for variations in naming (underscore vs dash)
+            # Handle common naming variations between deployed .md files and .json templates
+            # Remove duplicates by using a set
+            alternative_names = list(
+                {
+                    agent_name.replace("-", "_"),  # api-qa -> api_qa
+                    agent_name.replace("_", "-"),  # api_qa -> api-qa
+                    agent_name.replace("-", ""),  # api-qa -> apiqa
+                    agent_name.replace("_", ""),  # api_qa -> apiqa
+                    agent_name.replace("-agent", ""),  # research-agent -> research
+                    agent_name.replace("_agent", ""),  # research_agent -> research
+                    agent_name + "_agent",  # research -> research_agent
+                    agent_name + "-agent",  # research -> research-agent
+                }
+            )
+
+            for alt_name in alternative_names:
+                if alt_name != agent_name:  # Skip the original name we already tried
+                    alt_file = templates_dir / f"{alt_name}.json"
+                    if alt_file.exists():
+                        with open(alt_file) as f:
+                            template_data = json.load(f)
+                            return template_data.get("memory_routing")
+
+            return None
+
+        except Exception as e:
+            self.logger.debug(
+                f"Could not load memory routing from template for {agent_name}: {e}"
+            )
+            return None
+
     def _load_routing_from_template(self, agent_name: str) -> Optional[Dict[str, Any]]:
         """Load routing metadata from agent JSON template.
 

claude_mpm/core/log_manager.py

@@ -179,6 +179,11 @@ class LogManager:
         # Add to cache
         self._dir_cache[log_type] = log_dir
 
+        # One-time migration for MPM logs from old location to new subdirectory
+        if log_type == "mpm" and not hasattr(self, "_mpm_logs_migrated"):
+            await self._migrate_mpm_logs()
+            self._mpm_logs_migrated = True
+
         # Schedule cleanup for old logs
         await self.cleanup_old_logs(
             log_dir,
@@ -206,7 +211,7 @@ class LogManager:
         # Map log types to directory names
         dir_mapping = {
             "startup": "startup",
-            "mpm": "",  # Root of logs directory
+            "mpm": "mpm",  # MPM logs in dedicated subdirectory
             "prompts": "prompts",
             "sessions": "sessions",
             "agents": "agents",
@@ -343,6 +348,49 @@ class LogManager:
 
         return deleted_count
 
+    async def _migrate_mpm_logs(self):
+        """
+        One-time migration to move existing MPM logs to new subdirectory.
+
+        Moves mpm_*.log files from .claude-mpm/logs/ to .claude-mpm/logs/mpm/
+        """
+        try:
+            old_location = self.base_log_dir
+            new_location = self.base_log_dir / "mpm"
+
+            # Only proceed if old location exists and has MPM logs
+            if not old_location.exists():
+                return
+
+            # Find all MPM log files in the old location
+            mpm_logs = list(old_location.glob("mpm_*.log"))
+
+            if not mpm_logs:
+                return  # No logs to migrate
+
+            # Ensure new directory exists
+            new_location.mkdir(parents=True, exist_ok=True)
+
+            migrated_count = 0
+            for log_file in mpm_logs:
+                try:
+                    # Move file to new location
+                    new_path = new_location / log_file.name
+                    if not new_path.exists():  # Don't overwrite existing files
+                        log_file.rename(new_path)
+                        migrated_count += 1
+                except Exception as e:
+                    logger.debug(f"Could not migrate {log_file}: {e}")
+
+            if migrated_count > 0:
+                logger.info(
+                    f"Migrated {migrated_count} MPM log files to {new_location}"
+                )
+
+        except Exception as e:
+            # Migration is best-effort, don't fail if something goes wrong
+            logger.debug(f"MPM log migration skipped: {e}")
+
     async def log_prompt(
         self, prompt_type: str, content: str, metadata: Optional[Dict[str, Any]] = None
     ) -> Optional[Path]:

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")