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

claude_mpm/services/memory_hook_service.py

@@ -29,11 +29,9 @@ class MemoryHookService(BaseService, MemoryHookInterface):
 
     async def _initialize(self) -> None:
         """Initialize the service. No special initialization needed."""
-        pass
 
     async def _cleanup(self) -> None:
         """Cleanup service resources. No cleanup needed."""
-        pass
 
     def register_memory_hooks(self):
         """Register memory-related hooks with the hook service.
@@ -144,68 +142,86 @@ class MemoryHookService(BaseService, MemoryHookInterface):
         """
         try:
             from claude_mpm.hooks.base_hook import HookResult
-            
+
             # Extract agent_id and response from context
             agent_id = None
             response_text = None
-            
+
             # Try to get agent_id from various possible locations in context
-            if hasattr(context, 'data') and context.data:
+            if hasattr(context, "data") and context.data:
                 data = context.data
-                
+
                 # Check for agent_id in various locations
                 if isinstance(data, dict):
                     # Try direct agent_id field
-                    agent_id = data.get('agent_id')
-                    
+                    agent_id = data.get("agent_id")
+
                     # Try agent_type field
                     if not agent_id:
-                        agent_id = data.get('agent_type')
-                    
+                        agent_id = data.get("agent_type")
+
                     # Try subagent_type (for Task delegations)
                     if not agent_id:
-                        agent_id = data.get('subagent_type')
-                    
+                        agent_id = data.get("subagent_type")
+
                     # Try tool_parameters for Task delegations
-                    if not agent_id and 'tool_parameters' in data:
-                        params = data.get('tool_parameters', {})
+                    if not agent_id and "tool_parameters" in data:
+                        params = data.get("tool_parameters", {})
                         if isinstance(params, dict):
-                            agent_id = params.get('subagent_type')
-                    
+                            agent_id = params.get("subagent_type")
+
                     # Extract response text
-                    response_text = data.get('response') or data.get('result') or data.get('output')
-                    
+                    response_text = (
+                        data.get("response") or data.get("result") or data.get("output")
+                    )
+
                     # If response_text is a dict, try to get text from it
                     if isinstance(response_text, dict):
-                        response_text = response_text.get('text') or response_text.get('content') or str(response_text)
-            
+                        response_text = (
+                            response_text.get("text")
+                            or response_text.get("content")
+                            or str(response_text)
+                        )
+
             # Default to PM if no agent_id found
             if not agent_id:
                 agent_id = "PM"
                 self.logger.debug("No agent_id found in context, defaulting to PM")
-            
+
             # Only process if we have response text
             if response_text and isinstance(response_text, str):
                 self.logger.debug(f"Processing memory extraction for agent: {agent_id}")
-                
+
                 # Import and use the memory manager
-                from claude_mpm.services.agents.memory.agent_memory_manager import get_memory_manager
-                
+                from claude_mpm.services.agents.memory.agent_memory_manager import (
+                    get_memory_manager,
+                )
+
                 try:
                     memory_manager = get_memory_manager()
-                    
+
                     # Extract and update memory
-                    success = memory_manager.extract_and_update_memory(agent_id, response_text)
-                    
+                    success = memory_manager.extract_and_update_memory(
+                        agent_id, response_text
+                    )
+
                     if success:
-                        self.logger.info(f"Successfully extracted and saved memories for {agent_id}")
+                        self.logger.info(
+                            f"Successfully extracted and saved memories for {agent_id}"
+                        )
                     else:
-                        self.logger.debug(f"No memories found to extract for {agent_id}")
-                        
+                        self.logger.debug(
+                            f"No memories found to extract for {agent_id}"
+                        )
+
                 except Exception as mem_error:
-                    self.logger.warning(f"Failed to extract/save memories for {agent_id}: {mem_error}")
+                    self.logger.warning(
+                        f"Failed to extract/save memories for {agent_id}: {mem_error}"
+                    )
             else:
-                self.logger.debug("No response text found in context for memory extraction")
+                self.logger.debug(
+                    "No response text found in context for memory extraction"
+                )
 
             return HookResult(success=True, data=context.data, modified=False)
 
@@ -291,5 +307,3 @@ class MemoryHookService(BaseService, MemoryHookInterface):
             "total_hooks": len(self.registered_hooks),
             "status": "active" if self.registered_hooks else "inactive",
         }
-
-

claude_mpm/services/monitor_build_service.py

@@ -3,7 +3,7 @@
 WHY: The Monitor UI needs its own build tracking separate from the main MPM build
 number to track UI-specific changes and deployments independently.
 
-DESIGN DECISION: 
+DESIGN DECISION:
 - Uses atomic file operations for thread-safe build number management
 - Stores build number in MONITOR_BUILD file at project root
 - Formats as 4-digit zero-padded strings (0001, 0002, etc.)
@@ -11,7 +11,6 @@ DESIGN DECISION:
 """
 
 import asyncio
-import fcntl
 import json
 import os
 import tempfile
@@ -24,67 +23,68 @@ from claude_mpm.core.logger import get_logger
 
 class MonitorBuildService(BaseService):
     """Service for managing Monitor UI build numbers.
-    
+
     WHY: Separate build tracking allows the Monitor UI to evolve independently
     of the main MPM framework, enabling rapid UI iterations without affecting
     core framework versioning.
     """
-    
+
     # Default values
     DEFAULT_BUILD_NUMBER = 1
     DEFAULT_VERSION = "1.0.0"
     BUILD_FILE_NAME = "MONITOR_BUILD"
-    
+
     def __init__(self):
         """Initialize the monitor build service."""
         super().__init__(name="monitor_build_service")
         self.logger = get_logger(self.__class__.__name__)
-        
+
         # Determine build file location
         self._build_file_path = self._get_build_file_path()
-        
+
         # Cache for build info to reduce file I/O
         self._cached_build_info: Optional[Dict[str, Any]] = None
         self._cache_lock = asyncio.Lock()
-    
+
     def _get_build_file_path(self) -> Path:
         """Get the path to the MONITOR_BUILD file.
-        
+
         WHY: Centralizes build file location logic, checking multiple
         possible locations to support different installation scenarios.
-        
+
         Returns:
             Path to the MONITOR_BUILD file
         """
         # Try project root first (development)
         try:
             from claude_mpm.config.paths import paths
+
             build_file = paths.project_root / self.BUILD_FILE_NAME
             if build_file.parent.exists():
                 return build_file
         except ImportError:
             pass
-        
+
         # Fallback to package root
         package_root = Path(__file__).parent.parent.parent
         return package_root / self.BUILD_FILE_NAME
-    
+
     async def _initialize(self) -> None:
         """Initialize the service and ensure build file exists.
-        
+
         WHY: Ensures the build file exists with default values on first run,
         preventing errors and providing a clean starting point.
         """
         await self._ensure_build_file_exists()
         await self._load_build_info()
-    
+
     async def _cleanup(self) -> None:
         """Cleanup service resources."""
         self._cached_build_info = None
-    
+
     async def _ensure_build_file_exists(self) -> None:
         """Ensure the MONITOR_BUILD file exists with default values.
-        
+
         WHY: Atomic file creation prevents race conditions when multiple
         processes might try to create the file simultaneously.
         """
@@ -92,17 +92,17 @@ class MonitorBuildService(BaseService):
             default_info = {
                 "build_number": self.DEFAULT_BUILD_NUMBER,
                 "version": self.DEFAULT_VERSION,
-                "last_updated": None
+                "last_updated": None,
             }
             await self._write_build_info(default_info)
             self.logger.info(f"Created MONITOR_BUILD file at {self._build_file_path}")
-    
+
     async def _load_build_info(self) -> Dict[str, Any]:
         """Load build information from file.
-        
+
         WHY: Centralizes file reading with error handling and caching
         to improve performance and reliability.
-        
+
         Returns:
             Dictionary with build information
         """
@@ -110,7 +110,7 @@ class MonitorBuildService(BaseService):
             try:
                 if self._build_file_path.exists():
                     content = self._build_file_path.read_text().strip()
-                    
+
                     # Try to parse as JSON first
                     try:
                         self._cached_build_info = json.loads(content)
@@ -121,95 +121,94 @@ class MonitorBuildService(BaseService):
                             self._cached_build_info = {
                                 "build_number": build_num,
                                 "version": self.DEFAULT_VERSION,
-                                "last_updated": None
+                                "last_updated": None,
                             }
                         except ValueError:
                             # Invalid content, use defaults
                             self._cached_build_info = {
                                 "build_number": self.DEFAULT_BUILD_NUMBER,
                                 "version": self.DEFAULT_VERSION,
-                                "last_updated": None
+                                "last_updated": None,
                             }
                 else:
                     self._cached_build_info = {
                         "build_number": self.DEFAULT_BUILD_NUMBER,
                         "version": self.DEFAULT_VERSION,
-                        "last_updated": None
+                        "last_updated": None,
                     }
             except Exception as e:
                 self.logger.error(f"Error loading build info: {e}")
                 self._cached_build_info = {
                     "build_number": self.DEFAULT_BUILD_NUMBER,
                     "version": self.DEFAULT_VERSION,
-                    "last_updated": None
+                    "last_updated": None,
                 }
-            
+
             return self._cached_build_info
-    
+
     async def _write_build_info(self, info: Dict[str, Any]) -> None:
         """Write build information to file atomically.
-        
+
         WHY: Atomic writes prevent file corruption if the process is
         interrupted during the write operation.
-        
+
         Args:
             info: Build information dictionary
         """
         # Add timestamp
         from datetime import datetime
+
         info["last_updated"] = datetime.utcnow().isoformat()
-        
+
         # Write atomically using temp file and rename
         temp_fd, temp_path = tempfile.mkstemp(
-            dir=self._build_file_path.parent,
-            prefix=".monitor_build_",
-            suffix=".tmp"
+            dir=self._build_file_path.parent, prefix=".monitor_build_", suffix=".tmp"
         )
-        
+
         try:
             # Write JSON content
-            with os.fdopen(temp_fd, 'w') as f:
+            with os.fdopen(temp_fd, "w") as f:
                 json.dump(info, f, indent=2)
-            
+
             # Atomic rename
             Path(temp_path).replace(self._build_file_path)
-            
+
             # Update cache
             async with self._cache_lock:
                 self._cached_build_info = info
-            
+
         except Exception as e:
             # Clean up temp file on error
             Path(temp_path).unlink(missing_ok=True)
             raise e
-    
+
     async def get_build_number(self) -> int:
         """Get the current monitor build number.
-        
+
         Returns:
             Current build number as integer
         """
         info = await self._load_build_info()
         return info.get("build_number", self.DEFAULT_BUILD_NUMBER)
-    
+
     async def get_formatted_build_number(self) -> str:
         """Get the current build number as a 4-digit string.
-        
+
         WHY: Consistent 4-digit formatting ensures proper sorting
         and display alignment in the UI.
-        
+
         Returns:
             Build number as 4-digit zero-padded string
         """
         build_num = await self.get_build_number()
         return f"{build_num:04d}"
-    
+
     async def increment_build_number(self) -> int:
         """Increment and return the new build number.
-        
+
         WHY: Atomic increment operation ensures no build numbers are
         skipped or duplicated even with concurrent access.
-        
+
         Returns:
             New build number after incrementing
         """
@@ -217,22 +216,22 @@ class MonitorBuildService(BaseService):
         new_build = info.get("build_number", self.DEFAULT_BUILD_NUMBER) + 1
         info["build_number"] = new_build
         await self._write_build_info(info)
-        
+
         self.logger.info(f"Monitor build number incremented to {new_build:04d}")
         return new_build
-    
+
     async def get_monitor_version(self) -> str:
         """Get the monitor UI version.
-        
+
         Returns:
             Monitor UI semantic version string
         """
         info = await self._load_build_info()
         return info.get("version", self.DEFAULT_VERSION)
-    
+
     async def set_monitor_version(self, version: str) -> None:
         """Set the monitor UI version.
-        
+
         Args:
             version: New semantic version string
         """
@@ -240,67 +239,72 @@ class MonitorBuildService(BaseService):
         info["version"] = version
         await self._write_build_info(info)
         self.logger.info(f"Monitor version updated to {version}")
-    
+
     async def get_full_version_string(self) -> str:
         """Get the full version string for display.
-        
+
         WHY: Combines semantic version with build number for complete
         version identification in the UI.
-        
+
         Returns:
             Full version string (e.g., "v1.0.0-0001")
         """
         version = await self.get_monitor_version()
         build = await self.get_formatted_build_number()
         return f"v{version}-{build}"
-    
+
     async def get_build_info(self) -> Dict[str, Any]:
         """Get complete build information.
-        
+
         WHY: Provides all build metadata in a single call for
         efficient transmission to the UI via SocketIO.
-        
+
         Returns:
             Dictionary with all build information
         """
         info = await self._load_build_info()
-        
+
         # Get MPM version info
         mpm_version = "unknown"
         mpm_build = "unknown"
-        
+
         try:
             from claude_mpm.services.version_service import VersionService
+
             version_service = VersionService()
             version_info = version_service.get_version_info()
             mpm_version = version_info.get("base_version", "unknown")
             mpm_build = version_info.get("build_number", "unknown")
         except Exception as e:
             self.logger.debug(f"Could not get MPM version info: {e}")
-        
+
         return {
             "monitor": {
                 "version": info.get("version", self.DEFAULT_VERSION),
                 "build": info.get("build_number", self.DEFAULT_BUILD_NUMBER),
                 "formatted_build": f"{info.get('build_number', self.DEFAULT_BUILD_NUMBER):04d}",
                 "full_version": await self.get_full_version_string(),
-                "last_updated": info.get("last_updated")
+                "last_updated": info.get("last_updated"),
             },
             "mpm": {
                 "version": mpm_version,
                 "build": mpm_build,
-                "full_version": f"v{mpm_version}-build.{mpm_build}" if mpm_build != "unknown" else f"v{mpm_version}"
-            }
+                "full_version": (
+                    f"v{mpm_version}-build.{mpm_build}"
+                    if mpm_build != "unknown"
+                    else f"v{mpm_version}"
+                ),
+            },
         }
-    
+
     # Synchronous convenience methods for non-async contexts
-    
+
     def get_build_number_sync(self) -> int:
         """Synchronous version of get_build_number.
-        
+
         WHY: Some contexts (like SocketIO handlers) may not support
         async operations directly.
-        
+
         Returns:
             Current build number as integer
         """
@@ -309,13 +313,13 @@ class MonitorBuildService(BaseService):
             return loop.run_until_complete(self.get_build_number())
         finally:
             loop.close()
-    
+
     def get_build_info_sync(self) -> Dict[str, Any]:
         """Synchronous version of get_build_info.
-        
+
         WHY: SocketIO connection handlers often need synchronous
         access to build information.
-        
+
         Returns:
             Dictionary with all build information
         """
@@ -332,14 +336,14 @@ _monitor_build_service: Optional[MonitorBuildService] = None
 
 def get_monitor_build_service() -> MonitorBuildService:
     """Get or create the global monitor build service instance.
-    
+
     WHY: Singleton pattern ensures consistent build number management
     across the application.
-    
+
     Returns:
         The global MonitorBuildService instance
     """
     global _monitor_build_service
     if _monitor_build_service is None:
         _monitor_build_service = MonitorBuildService()
-    return _monitor_build_service
+    return _monitor_build_service