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

claude_mpm/cli/commands/agent_manager.py

@@ -57,6 +57,7 @@ class AgentManagerCommand(AgentCommand):
             "show": self._show_agent,
             "test": self._test_agent,
             "templates": self._list_templates,
+            "reset": self._reset_agents,
         }
 
         command = args.agent_manager_command
@@ -330,6 +331,218 @@ class AgentManagerCommand(AgentCommand):
                 output += f"    {template['description']}\n"
         return CommandResult.success_result(output)
 
+    def _reset_agents(self, args) -> CommandResult:
+        """Reset by removing claude-mpm authored agents from project and user directories.
+
+        This command removes any agents with "author: claude-mpm" in their frontmatter,
+        preserving user-created agents. This is useful for clean reinstalls or when
+        wanting to get fresh versions of system agents.
+        """
+        try:
+            # Determine which directories to clean
+            clean_project = not getattr(args, "user_only", False)
+            clean_user = not getattr(args, "project_only", False)
+            dry_run = getattr(args, "dry_run", False)
+            force = getattr(args, "force", False)
+            output_format = getattr(args, "format", "text")
+
+            # Track results
+            results = {
+                "project": {"checked": False, "removed": [], "preserved": []},
+                "user": {"checked": False, "removed": [], "preserved": []},
+                "dry_run": dry_run,
+                "total_removed": 0,
+                "total_preserved": 0,
+            }
+
+            # Check project directory - always scan first to see what's there
+            if clean_project:
+                project_dir = Path.cwd() / ".claude" / "agents"
+                if project_dir.exists():
+                    results["project"]["checked"] = True
+                    # Always scan with dry_run=True first to see what's there
+                    self._scan_and_clean_directory(
+                        project_dir, results["project"], dry_run=True
+                    )
+
+            # Check user directory - always scan first to see what's there
+            if clean_user:
+                user_dir = Path.home() / ".claude" / "agents"
+                if user_dir.exists():
+                    results["user"]["checked"] = True
+                    # Always scan with dry_run=True first to see what's there
+                    self._scan_and_clean_directory(
+                        user_dir, results["user"], dry_run=True
+                    )
+
+            # Calculate totals
+            results["total_removed"] = len(results["project"]["removed"]) + len(
+                results["user"]["removed"]
+            )
+            results["total_preserved"] = len(results["project"]["preserved"]) + len(
+                results["user"]["preserved"]
+            )
+
+            # Handle output based on format
+            if output_format == "json":
+                return CommandResult.success_result("Reset completed", data=results)
+
+            # Generate text output
+            output = self._format_reset_results(results, dry_run, force)
+
+            # If not dry-run, perform actual removal
+            if not dry_run and results["total_removed"] > 0:
+                # If force mode, remove immediately; otherwise get confirmation
+                if not force:
+                    # Get confirmation first
+                    print(output)
+                    print("\n⚠️  This will permanently remove the agents listed above.")
+
+                    # Ensure stdout is flushed before reading input
+                    sys.stdout.flush()
+
+                    # Get confirmation
+                    try:
+                        response = input("Continue? [y/N]: ").strip().lower()
+                        if response not in ["y", "yes"]:
+                            return CommandResult.success_result(
+                                "Reset cancelled by user"
+                            )
+                    except (KeyboardInterrupt, EOFError):
+                        return CommandResult.success_result("\nReset cancelled")
+
+                # Perform actual removal using the list we already have
+                if clean_project and results["project"]["removed"]:
+                    project_dir = Path.cwd() / ".claude" / "agents"
+                    for agent in results["project"]["removed"]:
+                        agent_file = project_dir / agent
+                        try:
+                            if agent_file.exists():
+                                agent_file.unlink()
+                                self.logger.info(
+                                    f"Removed claude-mpm agent: {agent_file}"
+                                )
+                        except Exception as e:
+                            self.logger.warning(f"Could not remove {agent_file}: {e}")
+
+                if clean_user and results["user"]["removed"]:
+                    user_dir = Path.home() / ".claude" / "agents"
+                    for agent in results["user"]["removed"]:
+                        agent_file = user_dir / agent
+                        try:
+                            if agent_file.exists():
+                                agent_file.unlink()
+                                self.logger.info(
+                                    f"Removed claude-mpm agent: {agent_file}"
+                                )
+                        except Exception as e:
+                            self.logger.warning(f"Could not remove {agent_file}: {e}")
+
+                # Update output to show actual removal
+                output = self._format_reset_results(results, dry_run=False, force=force)
+
+            return CommandResult.success_result(output)
+
+        except Exception as e:
+            self.logger.error(f"Failed to reset agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Failed to reset agents: {e}")
+
+    def _scan_and_clean_directory(
+        self, directory: Path, results: Dict[str, Any], dry_run: bool
+    ) -> None:
+        """Scan a directory for claude-mpm authored agents and optionally remove them.
+
+        Args:
+            directory: Directory to scan
+            results: Results dictionary to update
+            dry_run: If True, only scan without removing
+        """
+        for agent_file in directory.glob("*.md"):
+            try:
+                content = agent_file.read_text()
+                # Check if this is a claude-mpm authored agent
+                if "author: claude-mpm" in content.lower():
+                    results["removed"].append(agent_file.name)
+                    if not dry_run:
+                        agent_file.unlink()
+                        self.logger.info(f"Removed claude-mpm agent: {agent_file}")
+                else:
+                    results["preserved"].append(agent_file.name)
+                    self.logger.debug(f"Preserved user agent: {agent_file}")
+            except Exception as e:
+                self.logger.warning(f"Could not process {agent_file}: {e}")
+
+    def _format_reset_results(
+        self, results: Dict[str, Any], dry_run: bool, force: bool
+    ) -> str:
+        """Format reset results for display.
+
+        Args:
+            results: Results dictionary
+            dry_run: Whether this was a dry run
+            force: Whether force mode was used
+
+        Returns:
+            Formatted output string
+        """
+        if dry_run:
+            output = "🔍 DRY RUN - No changes will be made\n"
+            output += "=" * 50 + "\n\n"
+        else:
+            output = "🧹 Agent Reset Complete\n"
+            output += "=" * 50 + "\n\n"
+
+        # Show project results
+        if results["project"]["checked"]:
+            output += "📁 Project Level (.claude/agents):\n"
+            if results["project"]["removed"]:
+                action = "Would remove" if dry_run else "Removed"
+                output += f"   {action} {len(results['project']['removed'])} claude-mpm agent(s):\n"
+                for agent in results["project"]["removed"][:5]:
+                    output += f"      • {agent}\n"
+                if len(results["project"]["removed"]) > 5:
+                    output += (
+                        f"      ... and {len(results['project']['removed']) - 5} more\n"
+                    )
+            else:
+                output += "   No claude-mpm agents found\n"
+
+            if results["project"]["preserved"]:
+                output += f"   Preserved {len(results['project']['preserved'])} user-created agent(s)\n"
+            output += "\n"
+
+        # Show user results
+        if results["user"]["checked"]:
+            output += "📁 User Level (~/.claude/agents):\n"
+            if results["user"]["removed"]:
+                action = "Would remove" if dry_run else "Removed"
+                output += f"   {action} {len(results['user']['removed'])} claude-mpm agent(s):\n"
+                for agent in results["user"]["removed"][:5]:
+                    output += f"      • {agent}\n"
+                if len(results["user"]["removed"]) > 5:
+                    output += (
+                        f"      ... and {len(results['user']['removed']) - 5} more\n"
+                    )
+            else:
+                output += "   No claude-mpm agents found\n"
+
+            if results["user"]["preserved"]:
+                output += f"   Preserved {len(results['user']['preserved'])} user-created agent(s)\n"
+            output += "\n"
+
+        # Show summary
+        output += "📊 Summary:\n"
+        if dry_run:
+            output += f"   • Would remove: {results['total_removed']} agent(s)\n"
+        else:
+            output += f"   • Removed: {results['total_removed']} agent(s)\n"
+        output += f"   • Preserved: {results['total_preserved']} user agent(s)\n"
+
+        if dry_run and results["total_removed"] > 0:
+            output += "\n💡 Run with --force to execute this cleanup immediately"
+
+        return output
+
     def _interactive_create(self) -> CommandResult:
         """Interactive agent creation wizard."""
         print("\n=== Agent Creation Wizard ===\n")
@@ -493,6 +706,7 @@ Commands:
   show          Display detailed agent information
   test          Validate agent configuration
   templates     List available agent templates
+  reset         Remove claude-mpm authored agents for clean install
 
 Examples:
   claude-mpm agent-manager list
@@ -500,6 +714,8 @@ Examples:
   claude-mpm agent-manager variant --base research --id research-v2
   claude-mpm agent-manager deploy --agent-id my-agent --tier user
   claude-mpm agent-manager customize-pm --level project
+  claude-mpm agent-manager reset --dry-run
+  claude-mpm agent-manager reset --force --project-only
 
 Note: PM customization writes to .claude-mpm/INSTRUCTIONS.md, not CLAUDE.md
 """
@@ -520,7 +736,11 @@ def manage_agent_manager(args) -> int:
     result = command.run(args)
 
     if result.success:
-        if result.message:
+        # Handle JSON output format
+        output_format = getattr(args, "format", "text")
+        if output_format == "json" and result.data is not None:
+            print(json.dumps(result.data, indent=2))
+        elif result.message:
             print(result.message)
         return 0
     if result.message:

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/services/memory/router.py

@@ -25,6 +25,7 @@ from datetime import datetime
 from typing import Any, Dict, List, Optional, Tuple
 
 from claude_mpm.core.config import Config
+from claude_mpm.core.framework_loader import FrameworkLoader
 from claude_mpm.core.mixins import LoggerMixin
 
 
@@ -467,6 +468,84 @@ class MemoryRouter(LoggerMixin):
         """
         super().__init__()
         self.config = config or Config()
+        self._dynamic_patterns_loaded = False
+        self._dynamic_patterns = {}
+
+    def _load_dynamic_patterns(self) -> None:
+        """Load memory routing patterns dynamically from agent templates.
+
+        WHY: Allows agents to define their own memory routing patterns
+        in their template files, making the system more flexible and
+        maintainable.
+        """
+        if self._dynamic_patterns_loaded:
+            return
+
+        try:
+            # Initialize framework loader to access agent templates
+            framework_loader = FrameworkLoader()
+
+            # Try to load patterns from deployed agents
+            from pathlib import Path
+
+            # Check both project and user agent directories
+            agent_dirs = [
+                Path(".claude/agents"),  # Project agents
+                Path.home() / ".claude-mpm/agents",  # User agents
+            ]
+
+            for agent_dir in agent_dirs:
+                if not agent_dir.exists():
+                    continue
+
+                # Look for deployed agent files
+                for agent_file in agent_dir.glob("*.md"):
+                    agent_name = agent_file.stem
+
+                    # Try to load memory routing from template
+                    memory_routing = (
+                        framework_loader._load_memory_routing_from_template(agent_name)
+                    )
+
+                    if memory_routing:
+                        # Convert agent name to pattern key format
+                        # e.g., "research-agent" -> "research"
+                        pattern_key = (
+                            agent_name.replace("-agent", "")
+                            .replace("_agent", "")
+                            .replace("-", "_")
+                        )
+
+                        # Build pattern structure from memory routing
+                        pattern_data = {
+                            "keywords": memory_routing.get("keywords", []),
+                            "sections": memory_routing.get("categories", []),
+                        }
+
+                        # Merge with existing patterns or add new
+                        if pattern_key in self.AGENT_PATTERNS:
+                            # Merge keywords, keeping unique values
+                            existing_keywords = set(
+                                self.AGENT_PATTERNS[pattern_key]["keywords"]
+                            )
+                            new_keywords = set(memory_routing.get("keywords", []))
+                            pattern_data["keywords"] = list(
+                                existing_keywords | new_keywords
+                            )
+
+                        self._dynamic_patterns[pattern_key] = pattern_data
+                        self.logger.debug(
+                            f"Loaded dynamic memory routing for {pattern_key}"
+                        )
+
+            self._dynamic_patterns_loaded = True
+            self.logger.info(
+                f"Loaded memory routing patterns for {len(self._dynamic_patterns)} agents"
+            )
+
+        except Exception as e:
+            self.logger.warning(f"Could not load dynamic memory routing patterns: {e}")
+            self._dynamic_patterns_loaded = True  # Don't retry
 
     def get_supported_agents(self) -> List[str]:
         """Get list of supported agent types.
@@ -477,7 +556,12 @@ class MemoryRouter(LoggerMixin):
         Returns:
             List of supported agent type names
         """
-        return list(self.AGENT_PATTERNS.keys())
+        self._load_dynamic_patterns()
+
+        # Combine static and dynamic patterns
+        all_agents = set(self.AGENT_PATTERNS.keys())
+        all_agents.update(self._dynamic_patterns.keys())
+        return list(all_agents)
 
     def is_agent_supported(self, agent_type: str) -> bool:
         """Check if an agent type is supported by the memory router.
@@ -491,7 +575,8 @@ class MemoryRouter(LoggerMixin):
         Returns:
             True if agent type is supported, False otherwise
         """
-        return agent_type in self.AGENT_PATTERNS
+        self._load_dynamic_patterns()
+        return agent_type in self.AGENT_PATTERNS or agent_type in self._dynamic_patterns
 
     def analyze_and_route(
         self, content: str, context: Optional[Dict] = None
@@ -605,21 +690,30 @@ class MemoryRouter(LoggerMixin):
         Returns:
             Dict containing routing patterns and statistics
         """
+        self._load_dynamic_patterns()
+
+        # Combine static and dynamic patterns
+        all_patterns = dict(self.AGENT_PATTERNS)
+        all_patterns.update(self._dynamic_patterns)
+
         return {
-            "agents": list(self.AGENT_PATTERNS.keys()),
+            "agents": list(all_patterns.keys()),
             "default_agent": self.DEFAULT_AGENT,
+            "static_agents": list(self.AGENT_PATTERNS.keys()),
+            "dynamic_agents": list(self._dynamic_patterns.keys()),
             "patterns": {
                 agent: {
                     "keyword_count": len(patterns["keywords"]),
                     "section_count": len(patterns["sections"]),
                     "keywords": patterns["keywords"][:10],  # Show first 10
                     "sections": patterns["sections"],
+                    "source": (
+                        "dynamic" if agent in self._dynamic_patterns else "static"
+                    ),
                 }
-                for agent, patterns in self.AGENT_PATTERNS.items()
+                for agent, patterns in all_patterns.items()
             },
-            "total_keywords": sum(
-                len(p["keywords"]) for p in self.AGENT_PATTERNS.values()
-            ),
+            "total_keywords": sum(len(p["keywords"]) for p in all_patterns.values()),
         }
 
     def _normalize_content(self, content: str) -> str:
@@ -663,9 +757,14 @@ class MemoryRouter(LoggerMixin):
         Returns:
             Dict mapping agent names to relevance scores
         """
+        self._load_dynamic_patterns()
         scores = {}
 
-        for agent, patterns in self.AGENT_PATTERNS.items():
+        # Combine static and dynamic patterns
+        all_patterns = dict(self.AGENT_PATTERNS)
+        all_patterns.update(self._dynamic_patterns)
+
+        for agent, patterns in all_patterns.items():
             score = 0.0
             matched_keywords = []
 
@@ -773,10 +872,17 @@ class MemoryRouter(LoggerMixin):
         Returns:
             Section name for memory storage
         """
-        if agent not in self.AGENT_PATTERNS:
+        self._load_dynamic_patterns()
+
+        # Check both static and dynamic patterns
+        if agent in self.AGENT_PATTERNS:
+            sections = self.AGENT_PATTERNS[agent]["sections"]
+        elif agent in self._dynamic_patterns:
+            sections = self._dynamic_patterns[agent]["sections"]
+        else:
             return "Recent Learnings"
 
-        sections = self.AGENT_PATTERNS[agent]["sections"]
+        sections = sections if sections else []
 
         # Simple heuristics for section selection
         if "mistake" in content or "error" in content or "avoid" in content:

{claude_mpm-4.1.3.dist-info → claude_mpm-4.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.1.3
+Version: 4.1.4
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team