claude-mpm 4.1.1__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/agents/memory/agent_persistence_service.py

@@ -65,12 +65,10 @@ class AgentPersistenceService:
     async def start(self) -> None:
         """Start the persistence service."""
         # No-op for stub
-        pass
 
     async def stop(self) -> None:
         """Stop the persistence service."""
         # No-op for stub
-        pass
 
     async def persist_agent(
         self,

claude_mpm/services/agents/memory/content_manager.py

@@ -67,7 +67,7 @@ class MemoryContentManager:
                 item_indices.append(i)
                 existing_item = line.strip()[2:]  # Remove "- " prefix
                 similarity = self._calculate_similarity(existing_item, new_item)
-                
+
                 # If highly similar (>80%), mark for removal
                 if similarity > 0.8:
                     items_to_remove.append(i)
@@ -99,7 +99,7 @@ class MemoryContentManager:
             if lines[i].strip():
                 insert_point = i + 1
                 break
-        
+
         lines.insert(insert_point, f"- {new_item}")
 
         # Update timestamp
@@ -108,12 +108,12 @@ class MemoryContentManager:
 
     def add_item_to_section(self, content: str, section: str, new_item: str) -> str:
         """Legacy method for backward compatibility - delegates to add_item_to_list.
-        
+
         Args:
             content: Current memory file content
             section: Section name (ignored in simple list format)
             new_item: Item to add
-            
+
         Returns:
             str: Updated content with new item added
         """
@@ -172,12 +172,12 @@ class MemoryContentManager:
         # Also check max_items limit
         max_items = limits.get("max_items", 100)
         item_count = sum(1 for line in lines if line.strip().startswith("- "))
-        
+
         if item_count > max_items:
             # Remove oldest items to fit within max_items
             items_removed = 0
             target_removals = item_count - max_items
-            
+
             i = 0
             while i < len(lines) and items_removed < target_removals:
                 if lines[i].strip().startswith("- "):
@@ -187,7 +187,7 @@ class MemoryContentManager:
                     i += 1
 
         return "\n".join(lines)
-    
+
     def truncate_to_limits(
         self, content: str, agent_limits: Optional[Dict[str, Any]] = None
     ) -> str:
@@ -211,12 +211,11 @@ class MemoryContentManager:
             content,
         )
         # Also handle legacy format
-        content = re.sub(
+        return re.sub(
             r"<!-- Last Updated: .+ \| Auto-updated by: .+ -->",
             f"<!-- Last Updated: {timestamp} -->",
             content,
         )
-        return content
 
     def validate_and_repair(self, content: str, agent_id: str) -> str:
         """Validate memory file and repair if needed.
@@ -232,22 +231,23 @@ class MemoryContentManager:
             str: Validated and repaired content
         """
         lines = content.split("\n")
-        
+
         # Ensure proper header format
         has_header = False
         has_timestamp = False
-        
-        for i, line in enumerate(lines[:5]):  # Check first 5 lines
+
+        for _i, line in enumerate(lines[:5]):  # Check first 5 lines
             if line.startswith("# Agent Memory:"):
                 has_header = True
             elif line.startswith("<!-- Last Updated:"):
                 has_timestamp = True
-        
+
         # Add missing header or timestamp
         if not has_header or not has_timestamp:
             from datetime import datetime
+
             new_lines = []
-            
+
             if not has_header:
                 new_lines.append(f"# Agent Memory: {agent_id}")
             else:
@@ -257,9 +257,11 @@ class MemoryContentManager:
                         new_lines.append(line)
                         lines.remove(line)
                         break
-            
+
             if not has_timestamp:
-                new_lines.append(f"<!-- Last Updated: {datetime.now().isoformat()}Z -->")
+                new_lines.append(
+                    f"<!-- Last Updated: {datetime.now().isoformat()}Z -->"
+                )
                 new_lines.append("")
             else:
                 # Keep existing timestamp
@@ -268,14 +270,16 @@ class MemoryContentManager:
                         new_lines.append(line)
                         lines.remove(line)
                         break
-            
+
             # Add remaining content
             for line in lines:
-                if not line.startswith("# ") and not line.startswith("<!-- Last Updated:"):
+                if not line.startswith("# ") and not line.startswith(
+                    "<!-- Last Updated:"
+                ):
                     new_lines.append(line)
-            
+
             return "\n".join(new_lines)
-        
+
         return "\n".join(lines)
 
     def parse_memory_content_to_list(self, content: str) -> List[str]:
@@ -296,7 +300,7 @@ class MemoryContentManager:
             line = line.strip()
 
             # Skip empty lines, headers, and metadata
-            if not line or line.startswith("#") or line.startswith("<!--"):
+            if not line or line.startswith(("#", "<!--")):
                 continue
 
             if line.startswith("- "):
@@ -306,15 +310,15 @@ class MemoryContentManager:
                     items.append(item)
 
         return items
-    
+
     def parse_memory_content_to_dict(self, content: str) -> Dict[str, List[str]]:
         """Legacy method for backward compatibility.
-        
+
         Returns a dict with single key 'memories' containing all items.
-        
+
         Args:
             content: Raw memory file content
-            
+
         Returns:
             Dict with 'memories' key mapping to list of items
         """
@@ -344,23 +348,23 @@ class MemoryContentManager:
         # Normalize strings for comparison
         str1_normalized = str1.lower().strip()
         str2_normalized = str2.lower().strip()
-        
+
         # Handle exact matches quickly
         if str1_normalized == str2_normalized:
             return 1.0
-        
+
         # Use SequenceMatcher for fuzzy matching
         # None as first param tells it to use automatic junk heuristic
         matcher = SequenceMatcher(None, str1_normalized, str2_normalized)
         similarity = matcher.ratio()
-        
+
         # Additional check: if one string contains the other (substring match)
         # This catches cases where one item is a more detailed version of another
         if len(str1_normalized) > 20 and len(str2_normalized) > 20:
             if str1_normalized in str2_normalized or str2_normalized in str1_normalized:
                 # Boost similarity for substring matches
                 similarity = max(similarity, 0.85)
-        
+
         return similarity
 
     def deduplicate_list(self, content: str) -> Tuple[str, int]:
@@ -377,7 +381,7 @@ class MemoryContentManager:
             Tuple of (updated content, number of items removed)
         """
         lines = content.split("\n")
-        
+
         # Collect all items in the list
         items = []
         item_indices = []
@@ -385,7 +389,7 @@ class MemoryContentManager:
             if line.strip().startswith("- "):
                 items.append(line.strip()[2:])  # Remove "- " prefix
                 item_indices.append(i)
-        
+
         # Find duplicates using pairwise comparison
         duplicates_to_remove = set()
         for i in range(len(items)):
@@ -403,21 +407,21 @@ class MemoryContentManager:
                         f"(keeping newer: '{items[j][:50]}...')"
                     )
                     break  # Move to next item
-        
+
         # Remove duplicates (in reverse order to maintain indices)
         removed_count = len(duplicates_to_remove)
         for idx in sorted(duplicates_to_remove, reverse=True):
             lines.pop(item_indices[idx])
-        
+
         return "\n".join(lines), removed_count
-    
+
     def deduplicate_section(self, content: str, section: str) -> Tuple[str, int]:
         """Legacy method for backward compatibility - delegates to deduplicate_list.
-        
+
         Args:
             content: Current memory file content
             section: Section name (ignored in simple list format)
-            
+
         Returns:
             Tuple of (updated content, number of items removed)
         """
@@ -444,7 +448,9 @@ class MemoryContentManager:
                 )
 
             # Check item count
-            items = sum(1 for line in content.split("\n") if line.strip().startswith("- "))
+            items = sum(
+                1 for line in content.split("\n") if line.strip().startswith("- ")
+            )
             max_items = self.memory_limits.get("max_items", 100)
 
             if items > max_items:
@@ -453,4 +459,4 @@ class MemoryContentManager:
             return True, None
 
         except Exception as e:
-            return False, f"Validation error: {str(e)}"
+            return False, f"Validation error: {e!s}"

claude_mpm/services/agents/memory/template_generator.py

@@ -15,7 +15,7 @@ This module provides:
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 from claude_mpm.core.config import Config
 
@@ -35,9 +35,7 @@ class MemoryTemplateGenerator:
         "Current Technical Context",
     ]
 
-    def __init__(
-        self, config: Config, working_directory: Path
-    ):
+    def __init__(self, config: Config, working_directory: Path):
         """Initialize the template generator.
 
         Args:
@@ -59,8 +57,8 @@ class MemoryTemplateGenerator:
             str: The basic memory template content
         """
         # Convert agent_id to proper name, handling cases like "test_agent" -> "Test"
-        agent_name = agent_id.replace("_agent", "").replace("_", " ").title()
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        agent_id.replace("_agent", "").replace("_", " ").title()
+        datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
         # Create a simple template that agents will populate through learning
         return self._create_basic_memory_template(agent_id, limits)

claude_mpm/services/agents/registry/__init__.py

@@ -1,6 +1,10 @@
 """Agent registry services for discovery and tracking."""
 
-from claude_mpm.core.unified_agent_registry import AgentMetadata, AgentTier, AgentType
+from claude_mpm.core.unified_agent_registry import (
+    AgentMetadata,
+    AgentTier,
+    AgentType,
+)
 from claude_mpm.core.unified_agent_registry import UnifiedAgentRegistry as AgentRegistry
 
 from .deployed_agent_discovery import DeployedAgentDiscovery
@@ -13,14 +17,14 @@ from .modification_tracker import (
 )
 
 __all__ = [
-    "AgentRegistry",
     "AgentMetadata",
+    "AgentModification",
+    "AgentModificationTracker",
+    "AgentRegistry",
     "AgentTier",
     "AgentType",
     "DeployedAgentDiscovery",
-    "AgentModificationTracker",
-    "ModificationType",
-    "ModificationTier",
-    "AgentModification",
     "ModificationHistory",
+    "ModificationTier",
+    "ModificationType",
 ]

claude_mpm/services/agents/registry/deployed_agent_discovery.py

@@ -19,7 +19,11 @@ logger = logging.getLogger(__name__)
 class DeployedAgentDiscovery(ConfigServiceBase):
     """Discovers and analyzes deployed agents in the project."""
 
-    def __init__(self, project_root: Path = None, config: Optional[Dict[str, Any]] = None):
+    def __init__(
+        self,
+        project_root: Optional[Path] = None,
+        config: Optional[Dict[str, Any]] = None,
+    ):
         """Initialize the discovery service.
 
         Args:
@@ -32,7 +36,7 @@ class DeployedAgentDiscovery(ConfigServiceBase):
         self.project_root = self.get_config_value(
             "project_root",
             default=project_root or get_path_manager().project_root,
-            config_type=Path
+            config_type=Path,
         )
         self.agent_registry = AgentRegistryAdapter()
         self.logger.debug(
@@ -111,7 +115,7 @@ class DeployedAgentDiscovery(ConfigServiceBase):
                     "tools": agent.get("tools", []),
                 }
             # Handle object format with metadata (new standardized schema)
-            elif hasattr(agent, "metadata"):
+            if hasattr(agent, "metadata"):
                 return {
                     "id": agent.agent_id,
                     "name": agent.metadata.name,
@@ -125,28 +129,27 @@ class DeployedAgentDiscovery(ConfigServiceBase):
                         else []
                     ),
                 }
-            else:
-                # Legacy object format fallback
-                agent_type = getattr(agent, "type", None)
-                agent_name = getattr(agent, "name", None)
-
-                # Generate name from type if name not present
-                if not agent_name and agent_type:
-                    agent_name = agent_type.replace("_", " ").title()
-                elif not agent_name:
-                    agent_name = "Unknown Agent"
-
-                return {
-                    "id": getattr(agent, "agent_id", agent_type or "unknown"),
-                    "name": agent_name,
-                    "description": getattr(
-                        agent, "description", "No description available"
-                    ),
-                    "specializations": getattr(agent, "specializations", []),
-                    "capabilities": {},
-                    "source_tier": self._determine_source_tier(agent),
-                    "tools": getattr(agent, "tools", []),
-                }
+            # Legacy object format fallback
+            agent_type = getattr(agent, "type", None)
+            agent_name = getattr(agent, "name", None)
+
+            # Generate name from type if name not present
+            if not agent_name and agent_type:
+                agent_name = agent_type.replace("_", " ").title()
+            elif not agent_name:
+                agent_name = "Unknown Agent"
+
+            return {
+                "id": getattr(agent, "agent_id", agent_type or "unknown"),
+                "name": agent_name,
+                "description": getattr(
+                    agent, "description", "No description available"
+                ),
+                "specializations": getattr(agent, "specializations", []),
+                "capabilities": {},
+                "source_tier": self._determine_source_tier(agent),
+                "tools": getattr(agent, "tools", []),
+            }
         except Exception as e:
             logger.error(f"Error extracting agent info: {e}")
             return None
@@ -163,7 +166,7 @@ class DeployedAgentDiscovery(ConfigServiceBase):
         try:
             path = Path(agent_path)
             if path.exists() and path.suffix == ".json":
-                with open(path, "r") as f:
+                with open(path) as f:
                     return json.load(f)
         except Exception as e:
             logger.warning(f"Failed to load full agent data from {agent_path}: {e}")
@@ -223,7 +226,7 @@ class DeployedAgentDiscovery(ConfigServiceBase):
             source_path = str(agent.source_path)
             if ".claude/agents" in source_path:
                 return "project"
-            elif str(Path.home()) in source_path:
+            if str(Path.home()) in source_path:
                 return "user"
 
         # Default to system tier

claude_mpm/services/agents/registry/modification_tracker.py

@@ -26,7 +26,6 @@ import asyncio
 import hashlib
 import json
 import logging
-import os
 import shutil
 import time
 import uuid
@@ -42,8 +41,6 @@ from claude_mpm.core.base_service import BaseService
 from claude_mpm.core.unified_agent_registry import UnifiedAgentRegistry as AgentRegistry
 from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
-from claude_mpm.utils.config_manager import ConfigurationManager
-from claude_mpm.utils.path_operations import path_ops
 
 # ============================================================================
 # Data Models
@@ -664,7 +661,7 @@ class AgentModificationTracker(BaseService):
             # Load active modifications
             active_path = self.persistence_root / "active_modifications.json"
             if active_path.exists():
-                with open(active_path, "r") as f:
+                with open(active_path) as f:
                     data = json.load(f)
                     self.active_modifications = {
                         k: AgentModification.from_dict(v) for k, v in data.items()
@@ -672,7 +669,7 @@ class AgentModificationTracker(BaseService):
 
             # Load modification history
             for history_file in self.history_root.glob("*.json"):
-                with open(history_file, "r") as f:
+                with open(history_file) as f:
                     data = json.load(f)
                     agent_name = data["agent_name"]
                     history = ModificationHistory(agent_name=agent_name)
@@ -770,7 +767,7 @@ class AgentModificationTracker(BaseService):
                 if backup_dir.is_dir():
                     metadata_path = backup_dir / "metadata.json"
                     if metadata_path.exists():
-                        with open(metadata_path, "r") as f:
+                        with open(metadata_path) as f:
                             metadata = json.load(f)
                             if metadata.get("backup_time", 0) < cutoff_time:
                                 shutil.rmtree(backup_dir)

claude_mpm/services/async_session_logger.py

@@ -15,7 +15,6 @@ Key Features:
 - Configuration via .claude-mpm/configuration.yaml
 """
 
-import asyncio
 import json
 import logging
 import logging.handlers
@@ -27,7 +26,7 @@ from datetime import datetime
 from enum import Enum
 from queue import Full, Queue
 from threading import Lock, Thread
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Dict, Optional
 
 from claude_mpm.core.constants import PerformanceConfig, SystemLimits, TimeoutConfig
 

claude_mpm/services/claude_session_logger.py

@@ -159,8 +159,7 @@ class ClaudeSessionLogger:
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
 
         # Create filename: session_id-agent-timestamp.json
-        filename = f"{self.session_id}-{agent_name}-{timestamp}.json"
-        return filename
+        return f"{self.session_id}-{agent_name}-{timestamp}.json"
 
     def log_response(
         self,

claude_mpm/services/command_deployment_service.py

@@ -0,0 +1,173 @@
+"""Service for deploying MPM slash commands to user's Claude configuration.
+
+This service handles:
+1. Copying command markdown files from source to user's ~/.claude/commands directory
+2. Creating the commands directory if it doesn't exist
+3. Overwriting existing commands to ensure they're up-to-date
+"""
+
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List
+
+from claude_mpm.core.base_service import BaseService
+from claude_mpm.core.logger import get_logger
+
+
+class CommandDeploymentService(BaseService):
+    """Service for deploying MPM slash commands."""
+
+    def __init__(self):
+        """Initialize the command deployment service."""
+        super().__init__(name="command_deployment")
+
+        # Source commands directory in the package
+        self.source_dir = Path(__file__).parent.parent / "commands"
+
+        # Target directory in user's home
+        self.target_dir = Path.home() / ".claude" / "commands"
+
+    async def _initialize(self) -> None:
+        """Initialize the service."""
+
+    async def _cleanup(self) -> None:
+        """Cleanup service resources."""
+
+    def deploy_commands(self, force: bool = False) -> Dict[str, Any]:
+        """Deploy MPM slash commands to user's Claude configuration.
+
+        Args:
+            force: Force deployment even if files exist
+
+        Returns:
+            Dictionary with deployment results
+        """
+        result = {
+            "success": False,
+            "deployed": [],
+            "errors": [],
+            "target_dir": str(self.target_dir),
+        }
+
+        try:
+            # Check if source directory exists
+            if not self.source_dir.exists():
+                self.logger.warning(
+                    f"Source commands directory not found: {self.source_dir}"
+                )
+                result["errors"].append(
+                    f"Source directory not found: {self.source_dir}"
+                )
+                return result
+
+            # Create target directory if it doesn't exist
+            self.target_dir.mkdir(parents=True, exist_ok=True)
+            self.logger.debug(f"Ensured target directory exists: {self.target_dir}")
+
+            # Get all .md files from source directory
+            command_files = list(self.source_dir.glob("*.md"))
+
+            if not command_files:
+                self.logger.info("No command files found to deploy")
+                result["success"] = True
+                return result
+
+            # Deploy each command file
+            for source_file in command_files:
+                target_file = self.target_dir / source_file.name
+
+                try:
+                    # Check if file exists and if we should overwrite
+                    if target_file.exists() and not force:
+                        # Check if source is newer
+                        if source_file.stat().st_mtime <= target_file.stat().st_mtime:
+                            self.logger.debug(
+                                f"Skipping {source_file.name} - target is up to date"
+                            )
+                            continue
+
+                    # Copy the file
+                    shutil.copy2(source_file, target_file)
+                    self.logger.info(f"Deployed command: {source_file.name}")
+                    result["deployed"].append(source_file.name)
+
+                except Exception as e:
+                    error_msg = f"Failed to deploy {source_file.name}: {e}"
+                    self.logger.error(error_msg)
+                    result["errors"].append(error_msg)
+
+            result["success"] = len(result["errors"]) == 0
+
+            if result["deployed"]:
+                self.logger.info(
+                    f"Successfully deployed {len(result['deployed'])} commands to {self.target_dir}"
+                )
+
+            return result
+
+        except Exception as e:
+            error_msg = f"Command deployment failed: {e}"
+            self.logger.error(error_msg)
+            result["errors"].append(error_msg)
+            return result
+
+    def list_available_commands(self) -> List[str]:
+        """List available commands in the source directory.
+
+        Returns:
+            List of command file names
+        """
+        if not self.source_dir.exists():
+            return []
+
+        return [f.name for f in self.source_dir.glob("*.md")]
+
+    def list_deployed_commands(self) -> List[str]:
+        """List deployed commands in the target directory.
+
+        Returns:
+            List of deployed command file names
+        """
+        if not self.target_dir.exists():
+            return []
+
+        return [f.name for f in self.target_dir.glob("mpm*.md")]
+
+    def remove_deployed_commands(self) -> int:
+        """Remove all deployed MPM commands from target directory.
+
+        Returns:
+            Number of files removed
+        """
+        if not self.target_dir.exists():
+            return 0
+
+        removed = 0
+        for file in self.target_dir.glob("mpm*.md"):
+            try:
+                file.unlink()
+                self.logger.info(f"Removed command: {file.name}")
+                removed += 1
+            except Exception as e:
+                self.logger.error(f"Failed to remove {file.name}: {e}")
+
+        return removed
+
+
+def deploy_commands_on_startup(force: bool = False) -> None:
+    """Convenience function to deploy commands during startup.
+
+    Args:
+        force: Force deployment even if files exist
+    """
+    service = CommandDeploymentService()
+    result = service.deploy_commands(force=force)
+
+    if result["deployed"]:
+        logger = get_logger("startup")
+        logger.info(f"MPM commands deployed: {', '.join(result['deployed'])}")
+
+    if result["errors"]:
+        logger = get_logger("startup")
+        for error in result["errors"]:
+            logger.warning(f"Command deployment issue: {error}")