claude-mpm 4.1.1__py3-none-any.whl → 4.1.3__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/memory_categorization_service.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Memory Categorization Service - Categorizes learnings into appropriate sections."""
+
+import logging
+from typing import List
+
+
+class MemoryCategorizationService:
+    """Service for categorizing memory learnings."""
+
+    # Category keywords for automatic categorization
+    CATEGORY_KEYWORDS = {
+        "Project Architecture": [
+            "architecture",
+            "structure",
+            "design",
+            "pattern",
+            "framework",
+            "component",
+            "module",
+            "service",
+            "interface",
+            "api",
+            "endpoint",
+            "schema",
+            "model",
+            "database",
+            "microservice",
+        ],
+        "Implementation Guidelines": [
+            "implement",
+            "code",
+            "function",
+            "method",
+            "class",
+            "algorithm",
+            "logic",
+            "process",
+            "workflow",
+            "feature",
+            "requirement",
+            "specification",
+            "standard",
+            "convention",
+            "practice",
+        ],
+        "Common Mistakes to Avoid": [
+            "mistake",
+            "error",
+            "bug",
+            "issue",
+            "problem",
+            "avoid",
+            "don't",
+            "never",
+            "warning",
+            "caution",
+            "gotcha",
+            "pitfall",
+            "trap",
+            "wrong",
+            "incorrect",
+        ],
+        "Current Technical Context": [
+            "current",
+            "status",
+            "context",
+            "environment",
+            "configuration",
+            "setup",
+            "version",
+            "dependency",
+            "tool",
+            "library",
+            "package",
+            "integration",
+            "deployment",
+            "infrastructure",
+            "state",
+        ],
+    }
+
+    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.
+
+        WHY: Learnings are automatically organized into categories to make them
+        easier to find and review. This uses keyword matching to determine the
+        most appropriate category.
+
+        Args:
+            learning: The learning content to categorize
+
+        Returns:
+            Category name (defaults to "Current Technical Context")
+        """
+        if not learning:
+            return "Current Technical Context"
+
+        learning_lower = learning.lower()
+        category_scores = {}
+
+        # Score each category based on keyword matches
+        for category, keywords in self.CATEGORY_KEYWORDS.items():
+            score = sum(1 for keyword in keywords if keyword in learning_lower)
+            if score > 0:
+                category_scores[category] = score
+
+        # Return category with highest score, or default
+        if category_scores:
+            return max(category_scores, key=category_scores.get)
+
+        return "Current Technical Context"
+
+    def categorize_learnings_batch(self, learnings: List[str]) -> dict:
+        """Categorize multiple learnings at once.
+
+        Args:
+            learnings: List of learning items to categorize
+
+        Returns:
+            Dictionary mapping categories to lists of learnings
+        """
+        categorized = {}
+
+        for learning in learnings:
+            category = self.categorize_learning(learning)
+            if category not in categorized:
+                categorized[category] = []
+            categorized[category].append(learning)
+
+        return categorized
+
+    def merge_categorized_learnings(
+        self, existing: dict, new: dict, max_per_category: int = 15
+    ) -> dict:
+        """Merge new categorized learnings with existing ones.
+
+        Args:
+            existing: Existing categorized learnings
+            new: New categorized learnings to add
+            max_per_category: Maximum items per category
+
+        Returns:
+            Merged categorized learnings with limits applied
+        """
+        merged = existing.copy()
+
+        for category, items in new.items():
+            if category not in merged:
+                merged[category] = []
+
+            # Add new items, avoiding duplicates
+            for item in items:
+                if item not in merged[category]:
+                    merged[category].append(item)
+
+            # Apply limit (keep most recent)
+            if len(merged[category]) > max_per_category:
+                merged[category] = merged[category][-max_per_category:]
+
+        return merged

claude_mpm/services/agents/memory/memory_file_service.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Memory File Service - Handles file operations for agent memories."""
+
+import logging
+from pathlib import Path
+
+
+class MemoryFileService:
+    """Service for handling memory file operations."""
+
+    def __init__(self, memories_dir: Path):
+        """Initialize the memory file service.
+
+        Args:
+            memories_dir: Directory where memory files are stored
+        """
+        self.memories_dir = memories_dir
+        self.logger = logging.getLogger(__name__)
+
+    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.
+
+        Args:
+            directory: Directory to check for memory file
+            agent_id: Agent identifier
+
+        Returns:
+            Path to the memory file
+        """
+        new_file = directory / f"{agent_id}_memories.md"
+        old_file = directory / f"{agent_id}_memory.md"
+
+        # Migrate from old naming convention if needed
+        if old_file.exists() and not new_file.exists():
+            try:
+                old_file.rename(new_file)
+                self.logger.info(f"Migrated memory file: {old_file} -> {new_file}")
+            except Exception as e:
+                self.logger.warning(f"Could not migrate memory file: {e}")
+                return old_file
+
+        return new_file
+
+    def save_memory_file(self, file_path: Path, content: str) -> bool:
+        """Save content to a memory file.
+
+        Args:
+            file_path: Path to the memory file
+            content: Content to save
+
+        Returns:
+            True if saved successfully, False otherwise
+        """
+        try:
+            # Ensure directory exists
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write content
+            file_path.write_text(content)
+
+            self.logger.debug(f"Saved memory file: {file_path}")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to save memory file {file_path}: {e}")
+            return False
+
+    def ensure_memories_directory(self) -> None:
+        """Ensure the memories directory exists with README."""
+        try:
+            # Create directory if it doesn't exist
+            self.memories_dir.mkdir(parents=True, exist_ok=True)
+
+            # Create README if it doesn't exist
+            readme_path = self.memories_dir / "README.md"
+            if not readme_path.exists():
+                readme_content = """# Agent Memories Directory
+
+This directory contains memory files for various agents used in the project.
+
+## File Format
+
+Memory files follow the naming convention: `{agent_id}_memories.md`
+
+Each file contains:
+- Agent metadata (name, type, version)
+- Project-specific learnings organized by category
+- Timestamps for tracking updates
+
+## Auto-generated
+
+These files are managed automatically by the agent memory system.
+Manual edits should be done carefully to preserve the format.
+"""
+                readme_path.write_text(readme_content)
+                self.logger.debug(
+                    f"Created README in memories directory: {readme_path}"
+                )
+
+        except Exception as e:
+            self.logger.error(f"Failed to ensure memories directory: {e}")