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

claude_mpm/services/agents/memory/memory_format_service.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Memory Format Service - Handles memory content formatting and parsing."""
+
+import logging
+import re
+from datetime import datetime
+from typing import Dict, List
+
+
+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.
+
+        Args:
+            agent_id: Agent identifier for the header
+            items: List of memory items
+
+        Returns:
+            Formatted memory content string
+        """
+        # 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 += "## Learnings\n\n"
+
+        # Build item list
+        item_lines = []
+        for item in items:
+            # Clean and format each item
+            item = item.strip()
+            if item and not item.startswith("- "):
+                item = f"- {item}"
+            if item:
+                item_lines.append(item)
+
+        # Combine
+        content = header + "\n".join(item_lines)
+        if item_lines:
+            content += "\n"
+
+        return content
+
+    def parse_memory_list(self, memory_content: str) -> List[str]:
+        """Parse memory content into a simple list.
+
+        Args:
+            memory_content: Raw memory content
+
+        Returns:
+            List of memory items (without "- " prefix)
+        """
+        items = []
+        lines = memory_content.split("\n")
+
+        for line in lines:
+            line = line.strip()
+            # Skip headers, empty lines, and metadata
+            if (
+                not line
+                or line.startswith("#")
+                or line.startswith("Last Updated:")
+                or line.startswith("**")
+                or line == "---"
+            ):
+                continue
+
+            # Extract list items
+            if line.startswith("- "):
+                item = line[2:].strip()
+                if item:
+                    items.append(item)
+            elif line and not any(
+                line.startswith(p) for p in ["#", "**", "Last Updated:", "---"]
+            ):
+                # Include non-list items that aren't headers
+                items.append(line)
+
+        return items
+
+    def parse_memory_sections(self, memory_content: str) -> Dict[str, List[str]]:
+        """Parse memory content into sections and items.
+
+        Args:
+            memory_content: Raw memory file content
+
+        Returns:
+            Dict mapping section names to lists of items
+        """
+        sections = {}
+        current_section = None
+        current_items = []
+
+        for line in memory_content.split("\n"):
+            # Check for section header (## Section Name)
+            if line.startswith("## "):
+                # Save previous section if exists
+                if current_section and current_items:
+                    sections[current_section] = current_items
+                # Start new section
+                current_section = line[3:].strip()
+                current_items = []
+            # Check for list item
+            elif line.startswith("- ") and current_section:
+                item = line[2:].strip()
+                if item:
+                    current_items.append(item)
+
+        # Save last section
+        if current_section and current_items:
+            sections[current_section] = current_items
+
+        return sections
+
+    def clean_template_placeholders(
+        self,
+        content: str,
+        preserve_structure: bool = False,
+        agent_id: str = "agent",
+    ) -> str:
+        """Clean template placeholders from memory content.
+
+        WHY: Default templates contain placeholder text that should be removed
+        when adding real memories. This method cleans those placeholders while
+        preserving any actual content.
+
+        Args:
+            content: Memory content to clean
+            preserve_structure: If True, preserve empty sections
+            agent_id: Agent ID for context
+
+        Returns:
+            Cleaned content string
+        """
+        if not content:
+            return content
+
+        # Patterns to remove
+        placeholder_patterns = [
+            r"\[Agent will add.*?\]",
+            r"\[No .* yet\]",
+            r"<!-- .* -->",
+            r"No items yet.*",
+            r"Memory items will be added.*",
+            r"\*\*Note:.*?\*\*",
+        ]
+
+        cleaned = content
+        for pattern in placeholder_patterns:
+            cleaned = re.sub(pattern, "", cleaned, flags=re.IGNORECASE | re.MULTILINE)
+
+        if not preserve_structure:
+            # Remove empty sections
+            lines = []
+            skip_empty = False
+            for line in cleaned.split("\n"):
+                if line.startswith("## "):
+                    skip_empty = True
+                    lines.append(line)
+                elif line.strip() and skip_empty:
+                    skip_empty = False
+                    lines.append(line)
+                elif not skip_empty:
+                    lines.append(line)
+
+            cleaned = "\n".join(lines)
+
+        # Clean up multiple blank lines
+        cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
+
+        return cleaned.strip()
+
+    def clean_template_placeholders_list(self, items: List[str]) -> List[str]:
+        """Clean template placeholders from a list of items.
+
+        Args:
+            items: List of items to clean
+
+        Returns:
+            Cleaned list of items
+        """
+        cleaned = []
+        for item in items:
+            # Skip placeholder items
+            if any(
+                pattern in item.lower()
+                for pattern in [
+                    "[agent will add",
+                    "[no ",
+                    "no items yet",
+                    "memory items will be added",
+                ]
+            ):
+                continue
+            cleaned.append(item)
+        return cleaned

claude_mpm/services/agents/memory/memory_limits_service.py

@@ -0,0 +1,99 @@
+#!/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
+
+
+class MemoryLimitsService:
+    """Service for managing memory limits and configuration."""
+
+    # Default limits
+    DEFAULT_MEMORY_LIMITS = {
+        "max_file_size_kb": 80,  # 80KB (20k tokens)
+        "max_items": 100,  # Maximum total memory items
+        "max_line_length": 120,
+    }
+
+    def __init__(self, config: Optional[Config] = None):
+        """Initialize the memory limits service.
+
+        Args:
+            config: Optional Config object for reading configuration
+        """
+        self.config = config or Config()
+        self.logger = logging.getLogger(__name__)
+        self.memory_limits = self._init_memory_limits()
+
+    def _init_memory_limits(self) -> Dict[str, Any]:
+        """Initialize memory limits from configuration.
+
+        Returns:
+            Dictionary of memory limits
+        """
+        try:
+            limits = self.DEFAULT_MEMORY_LIMITS.copy()
+
+            # Try to load from config
+            if hasattr(self.config, "agent_memory_limits"):
+                config_limits = self.config.agent_memory_limits
+                if isinstance(config_limits, dict):
+                    limits.update(config_limits)
+
+            self.logger.debug(f"Initialized memory limits: {limits}")
+            return limits
+
+        except Exception as e:
+            self.logger.warning(f"Failed to load memory limits from config: {e}")
+            return self.DEFAULT_MEMORY_LIMITS.copy()
+
+    def get_agent_limits(self, agent_id: str) -> Dict[str, Any]:
+        """Get memory limits for a specific agent.
+
+        Args:
+            agent_id: Agent identifier
+
+        Returns:
+            Dictionary of memory limits for the agent
+        """
+        # Start with default limits
+        limits = self.memory_limits.copy()
+
+        # Check for agent-specific overrides
+        try:
+            if hasattr(self.config, "agents") and agent_id in self.config.agents:
+                agent_config = self.config.agents[agent_id]
+                if "memory_limits" in agent_config:
+                    limits.update(agent_config["memory_limits"])
+        except Exception as e:
+            self.logger.debug(f"No agent-specific limits for {agent_id}: {e}")
+
+        return limits
+
+    def get_agent_auto_learning(self, agent_id: str) -> bool:
+        """Get auto-learning setting for a specific agent.
+
+        Args:
+            agent_id: Agent identifier
+
+        Returns:
+            True if auto-learning is enabled, False otherwise
+        """
+        try:
+            # Check agent-specific config
+            if hasattr(self.config, "agents") and agent_id in self.config.agents:
+                agent_config = self.config.agents[agent_id]
+                if "auto_learning" in agent_config:
+                    return agent_config["auto_learning"]
+
+            # Check global config
+            if hasattr(self.config, "agent_auto_learning"):
+                return self.config.agent_auto_learning
+
+        except Exception as e:
+            self.logger.debug(f"Error checking auto-learning for {agent_id}: {e}")
+
+        # Default to True (auto-learning enabled)
+        return True

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,7 +1,11 @@
 """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 UnifiedAgentRegistry as AgentRegistry
+from claude_mpm.core.unified_agent_registry import (
+    AgentMetadata,
+    AgentTier,
+    AgentType,
+    UnifiedAgentRegistry as AgentRegistry,
+)
 
 from .deployed_agent_discovery import DeployedAgentDiscovery
 from .modification_tracker import (
@@ -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/cli/__init__.py

@@ -0,0 +1,18 @@
+"""CLI services package.
+
+Services specifically for CLI command support and utilities.
+"""
+
+from .agent_dependency_service import AgentDependencyService, IAgentDependencyService
+from .agent_validation_service import AgentValidationService, IAgentValidationService
+from .startup_checker import IStartupChecker, StartupCheckerService, StartupWarning
+
+__all__ = [
+    "AgentDependencyService",
+    "AgentValidationService",
+    "IAgentDependencyService",
+    "IAgentValidationService",
+    "IStartupChecker",
+    "StartupCheckerService",
+    "StartupWarning",
+]