claude-mpm 4.1.26__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/agents/management/agent_capabilities_generator.py

@@ -4,12 +4,13 @@ This service generates markdown content for agent capabilities section
 from discovered deployed agents.
 """
 
-import logging
 from typing import Any, Dict, List
 
 from jinja2 import Template
 
-logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
 
 
 class AgentCapabilitiesGenerator:

claude_mpm/services/agents/management/agent_management_service.py

@@ -11,15 +11,15 @@ section extraction/updates, and version management.
 Uses python-frontmatter and mistune for markdown parsing as recommended.
 """
 
-import logging
 import re
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 import frontmatter
 import mistune
 import yaml
 
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.models.agent_definition import (
     AgentDefinition,
@@ -33,7 +33,7 @@ from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCac
 
 from ..deployment.agent_versioning import AgentVersionManager
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class AgentManager:
@@ -156,7 +156,7 @@ class AgentManager:
         # Increment version if requested
         if increment_version:
             agent_def.metadata.increment_serial_version()
-            agent_def.metadata.last_updated = datetime.now()
+            agent_def.metadata.last_updated = datetime.now(timezone.utc)
 
         # Write back
         agent_path = self._find_agent_file(name)
@@ -234,7 +234,7 @@ class AgentManager:
         # Increment version
         if increment_version:
             agent_def.metadata.increment_serial_version()
-            agent_def.metadata.last_updated = datetime.now()
+            agent_def.metadata.last_updated = datetime.now(timezone.utc)
 
         # Write back
         return self.update_agent(name, {}, increment_version=False)

claude_mpm/services/agents/memory/agent_memory_manager.py

@@ -22,10 +22,10 @@ following the naming convention: {agent_id}_memories.md
 """
 
 import logging
-import os
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, ClassVar, Dict, List, Optional, Tuple
 
 from claude_mpm.core.config import Config
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.interfaces import MemoryServiceInterface
 from claude_mpm.core.unified_paths import get_path_manager
 
@@ -54,7 +54,7 @@ class AgentMemoryManager(MemoryServiceInterface):
 
     # Default limits - will be overridden by configuration
     # Updated to support 20k tokens (~80KB) for enhanced memory capacity
-    DEFAULT_MEMORY_LIMITS = {
+    DEFAULT_MEMORY_LIMITS: ClassVar[dict[str, int]] = {
         "max_file_size_kb": 80,  # Increased from 8KB to 80KB (20k tokens)
         "max_items": 100,  # Maximum total memory items
         "max_line_length": 120,
@@ -78,7 +78,7 @@ class AgentMemoryManager(MemoryServiceInterface):
         self.config = config or Config()
         self.project_root = get_path_manager().project_root
         # Use current working directory by default, not project root
-        self.working_directory = working_directory or Path(os.getcwd())
+        self.working_directory = working_directory or Path(Path.cwd())
 
         # Use only project memory directory
         self.project_memories_dir = self.working_directory / ".claude-mpm" / "memories"
@@ -387,31 +387,32 @@ class AgentMemoryManager(MemoryServiceInterface):
                         memory_items = data["Remember"]
 
                     # Process memory items if found and not null
-                    if memory_items is not None and memory_items != "null":
-                        # Skip if explicitly null or empty list
-                        if isinstance(memory_items, list) and len(memory_items) > 0:
-                            # Filter out empty strings and None values
-                            valid_items = []
-                            for item in memory_items:
-                                if item and isinstance(item, str) and item.strip():
-                                    valid_items.append(item.strip())
-
-                            # Only proceed if we have valid items
-                            if valid_items:
+                    if (
+                        memory_items is not None
+                        and memory_items != "null"
+                        and isinstance(memory_items, list)
+                        and len(memory_items) > 0
+                    ):
+                        # Filter out empty strings and None values
+                        valid_items = []
+                        for item in memory_items:
+                            if item and isinstance(item, str) and item.strip():
+                                valid_items.append(item.strip())
+
+                        # Only proceed if we have valid items
+                        if valid_items:
+                            self.logger.info(
+                                f"Found {len(valid_items)} memory items for {agent_id}: {valid_items[:2]}..."
+                            )
+                            success = self._add_learnings_to_memory(
+                                agent_id, valid_items
+                            )
+                            if success:
                                 self.logger.info(
-                                    f"Found {len(valid_items)} memory items for {agent_id}: {valid_items[:2]}..."
-                                )
-                                success = self._add_learnings_to_memory(
-                                    agent_id, valid_items
-                                )
-                                if success:
-                                    self.logger.info(
-                                        f"Successfully saved {len(valid_items)} memories for {agent_id} to project directory"
-                                    )
-                                    return True
-                                self.logger.error(
-                                    f"Failed to save memories for {agent_id}"
+                                    f"Successfully saved {len(valid_items)} memories for {agent_id} to project directory"
                                 )
+                                return True
+                            self.logger.error(f"Failed to save memories for {agent_id}")
 
                 except json.JSONDecodeError as je:
                     # Not valid JSON, continue to next match
@@ -596,9 +597,10 @@ class AgentMemoryManager(MemoryServiceInterface):
         """
         # Deprecated - return informative message
         return {
-            "status": "deprecated",
+            "status": OperationResult.ERROR,  # Deprecated function - calling it is an error
             "message": "Cross-reference analysis has been deprecated in favor of simplified memory management",
             "suggestion": "Use get_memory_status() for memory overview",
+            "deprecated": True,
         }
 
     def get_all_memories_raw(self) -> Dict[str, Any]:
@@ -613,9 +615,10 @@ class AgentMemoryManager(MemoryServiceInterface):
         """
         # Deprecated - return informative message
         return {
-            "status": "deprecated",
+            "status": OperationResult.ERROR,  # Deprecated function - calling it is an error
             "message": "Raw memory access has been deprecated in favor of simplified memory management",
             "suggestion": "Use load_agent_memory() for specific agent memories",
+            "deprecated": True,
         }
 
     def _save_memory_file_wrapper(self, agent_id: str, content: str) -> bool:

claude_mpm/services/agents/memory/content_manager.py

@@ -12,12 +12,15 @@ This module provides:
 - Content repair and structure validation
 """
 
-import logging
 import re
-from datetime import datetime
+from datetime import datetime, timezone
 from difflib import SequenceMatcher
 from typing import Any, Dict, List, Optional, Tuple
 
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
 
 class MemoryContentManager:
     """Manages memory content manipulation and validation.
@@ -34,7 +37,7 @@ class MemoryContentManager:
             memory_limits: Dictionary containing memory limits configuration
         """
         self.memory_limits = memory_limits
-        self.logger = logging.getLogger(f"{__name__}.{self.__class__.__name__}")
+        self.logger = logger  # Use the module-level logger
 
     def add_item_to_list(self, content: str, new_item: str) -> str:
         """Add item to memory list with deduplication.
@@ -203,7 +206,7 @@ class MemoryContentManager:
         Returns:
             str: Content with updated timestamp
         """
-        timestamp = datetime.now().isoformat() + "Z"
+        timestamp = datetime.now(timezone.utc).isoformat() + "Z"
         # Handle both old and new timestamp formats
         content = re.sub(
             r"<!-- Last Updated: .+? -->",
@@ -260,7 +263,7 @@ class MemoryContentManager:
 
             if not has_timestamp:
                 new_lines.append(
-                    f"<!-- Last Updated: {datetime.now().isoformat()}Z -->"
+                    f"<!-- Last Updated: {datetime.now(timezone.utc).isoformat()}Z -->"
                 )
                 new_lines.append("")
             else:
@@ -360,10 +363,15 @@ class MemoryContentManager:
 
         # 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)
+        if (
+            len(str1_normalized) > 20
+            and len(str2_normalized) > 20
+            and (
+                str1_normalized in str2_normalized or str2_normalized in str1_normalized
+            )
+        ):
+            # Boost similarity for substring matches
+            similarity = max(similarity, 0.85)
 
         return similarity
 

claude_mpm/services/agents/memory/memory_categorization_service.py

@@ -1,9 +1,12 @@
 #!/usr/bin/env python3
 """Memory Categorization Service - Categorizes learnings into appropriate sections."""
 
-import logging
 from typing import List
 
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
 
 class MemoryCategorizationService:
     """Service for categorizing memory learnings."""
@@ -82,7 +85,6 @@ class MemoryCategorizationService:
 
     def __init__(self):
         """Initialize the categorization service."""
-        self.logger = logging.getLogger(__name__)
 
     def categorize_learning(self, learning: str) -> str:
         """Categorize a learning item based on its content.

claude_mpm/services/agents/memory/memory_file_service.py

@@ -1,9 +1,12 @@
 #!/usr/bin/env python3
 """Memory File Service - Handles file operations for agent memories."""
 
-import logging
 from pathlib import Path
 
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
 
 class MemoryFileService:
     """Service for handling memory file operations."""
@@ -15,24 +18,47 @@ class MemoryFileService:
             memories_dir: Directory where memory files are stored
         """
         self.memories_dir = memories_dir
-        self.logger = logging.getLogger(__name__)
+        self.logger = logger  # Use the module-level logger
 
     def get_memory_file_with_migration(self, directory: Path, agent_id: str) -> Path:
         """Get memory file path with migration support.
 
         Migrates from old naming convention if needed.
+        Also handles hyphen to underscore conversion for agent IDs.
 
         Args:
             directory: Directory to check for memory file
-            agent_id: Agent identifier
+            agent_id: Agent identifier (may contain hyphens or underscores)
 
         Returns:
             Path to the memory file
         """
-        new_file = directory / f"{agent_id}_memories.md"
-        old_file = directory / f"{agent_id}_memory.md"
+        # Normalize agent_id to use underscores (matching deployed agent names)
+        normalized_id = agent_id.replace("-", "_")
+
+        # Define possible file paths
+        new_file = directory / f"{normalized_id}_memories.md"
+        old_file = directory / f"{normalized_id}_memory.md"
+
+        # Also check for legacy hyphenated versions
+        hyphenated_file = (
+            directory / f"{agent_id}_memories.md" if "-" in agent_id else None
+        )
+
+        # Migration priority:
+        # 1. If hyphenated version exists and normalized doesn't, migrate it
+        if hyphenated_file and hyphenated_file.exists() and not new_file.exists():
+            try:
+                hyphenated_file.rename(new_file)
+                self.logger.info(
+                    f"Migrated hyphenated memory file: {hyphenated_file} -> {new_file}"
+                )
+            except Exception as e:
+                self.logger.warning(f"Could not migrate hyphenated memory file: {e}")
+                # Fall back to using the hyphenated version
+                return hyphenated_file
 
-        # Migrate from old naming convention if needed
+        # 2. Migrate from old naming convention (_memory.md to _memories.md)
         if old_file.exists() and not new_file.exists():
             try:
                 old_file.rename(new_file)

claude_mpm/services/agents/memory/memory_format_service.py

@@ -1,18 +1,20 @@
 #!/usr/bin/env python3
 """Memory Format Service - Handles memory content formatting and parsing."""
 
-import logging
 import re
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Dict, List
 
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
 
 class MemoryFormatService:
     """Service for memory content formatting and parsing."""
 
     def __init__(self):
         """Initialize the memory format service."""
-        self.logger = logging.getLogger(__name__)
 
     def build_simple_memory_content(self, agent_id: str, items: List[str]) -> str:
         """Build memory content as a simple list with header and timestamp.
@@ -26,7 +28,7 @@ class MemoryFormatService:
         """
         # Build header
         header = f"# {agent_id.title()} Agent Memory\n\n"
-        header += f"Last Updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+        header += f"Last Updated: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')}\n\n"
         header += "## Learnings\n\n"
 
         # Build item list

claude_mpm/services/agents/memory/memory_limits_service.py

@@ -1,10 +1,12 @@
 #!/usr/bin/env python3
 """Memory Limits Service - Manages memory size limits and configuration."""
 
-import logging
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.config import Config
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
 
 
 class MemoryLimitsService:
@@ -24,7 +26,7 @@ class MemoryLimitsService:
             config: Optional Config object for reading configuration
         """
         self.config = config or Config()
-        self.logger = logging.getLogger(__name__)
+        self.logger = logger  # Use the module-level logger
         self.memory_limits = self._init_memory_limits()
 
     def _init_memory_limits(self) -> Dict[str, Any]:

claude_mpm/services/agents/memory/template_generator.py

@@ -13,7 +13,7 @@ This module provides:
 """
 
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict
 
@@ -58,7 +58,7 @@ class MemoryTemplateGenerator:
         """
         # Convert agent_id to proper name, handling cases like "test_agent" -> "Test"
         agent_id.replace("_agent", "").replace("_", " ").title()
-        datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        datetime.now(timezone.utc).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)
@@ -75,7 +75,7 @@ class MemoryTemplateGenerator:
         Returns:
             str: Basic memory template
         """
-        timestamp = datetime.now().isoformat() + "Z"
+        timestamp = datetime.now(timezone.utc).isoformat() + "Z"
 
         return f"""# Agent Memory: {agent_id}
 <!-- Last Updated: {timestamp} -->