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

claude_mpm/services/claude_session_logger.py

@@ -10,33 +10,38 @@ Now with optional async logging support for improved performance.
 Configuration via .claude-mpm/configuration.yaml.
 """
 
+# Try to import async logger for performance optimization
+import importlib.util
 import json
-import logging
 import os
-from datetime import datetime
+from datetime import datetime, timezone
+from threading import Lock
 from typing import Any, Dict, Optional
 
 # Import configuration manager
 from claude_mpm.core.config import Config
 
-# Try to import async logger for performance optimization
-try:
-    from claude_mpm.services.async_session_logger import (
-        AsyncSessionLogger,
-        get_async_logger,
-        log_response_async,
-    )
+# Import centralized session manager
+from claude_mpm.services.session_manager import get_session_manager
+
+if importlib.util.find_spec("claude_mpm.services.async_session_logger"):
+    from claude_mpm.services.async_session_logger import get_async_logger
 
     ASYNC_AVAILABLE = True
-except ImportError:
+else:
     ASYNC_AVAILABLE = False
 
-logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
 
 
 class ClaudeSessionLogger:
     """Simplified response logger for Claude Code sessions."""
 
+    _initialization_lock = Lock()
+    _initialized = False
+
     def __init__(
         self,
         base_dir: Optional[Path] = None,
@@ -51,29 +56,41 @@ class ClaudeSessionLogger:
             use_async: Use async logging if available. Overrides config.
             config: Configuration instance to use (creates new if not provided)
         """
-        # Load configuration
-        if config is None:
-            config = Config()
-        self.config = config
-
-        # Get response logging configuration
-        response_config = self.config.get("response_logging", {})
-
-        # Determine base directory
-        if base_dir is None:
-            # Check configuration first
-            base_dir = response_config.get("session_directory")
-            if not base_dir:
-                # Fall back to default response directory
-                base_dir = ".claude-mpm/responses"
-            base_dir = Path(base_dir)
-
-        self.base_dir = Path(base_dir)
-        self.base_dir.mkdir(parents=True, exist_ok=True)
+        # Use initialization flag to prevent duplicate setup
+        with self._initialization_lock:
+            if self._initialized and hasattr(self, "config"):
+                logger.debug("ClaudeSessionLogger already initialized, skipping setup")
+                return
+
+            # Load configuration
+            if config is None:
+                config = Config()
+            self.config = config
+
+            # Get response logging configuration
+            response_config = self.config.get("response_logging", {})
+
+            # Determine base directory
+            if base_dir is None:
+                # Check configuration first
+                base_dir = response_config.get("session_directory")
+                if not base_dir:
+                    # Fall back to default response directory
+                    base_dir = ".claude-mpm/responses"
+                base_dir = Path(base_dir)
+
+            self.base_dir = Path(base_dir)
+            self.base_dir.mkdir(parents=True, exist_ok=True)
+
+            # Use centralized SessionManager for session ID
+            session_manager = get_session_manager()
+            self.session_id = session_manager.get_session_id()
+            logger.debug(
+                f"ClaudeSessionLogger using session ID from SessionManager: {self.session_id}"
+            )
 
-        # Try to get session ID from environment
-        self.session_id = self._get_claude_session_id()
-        self.response_counter = {}  # Track response count per session
+            self.response_counter = {}  # Track response count per session
+            self._initialized = True
 
         # Determine if we should use async logging
         if use_async is None:
@@ -100,46 +117,22 @@ class ClaudeSessionLogger:
 
         if self.use_async:
             try:
+                # Pass our session_id to async logger to avoid duplicate generation
                 self._async_logger = get_async_logger(config=config)
-                logger.info("Using async logger for improved performance")
+                # Synchronize session IDs - use the one we already generated
+                if self.session_id and hasattr(self._async_logger, "set_session_id"):
+                    self._async_logger.set_session_id(self.session_id)
+                    logger.debug(
+                        f"Using async logger with session ID: {self.session_id}"
+                    )
+                else:
+                    logger.debug("Using async logger for improved performance")
             except Exception as e:
                 logger.warning(
                     f"Failed to initialize async logger, falling back to sync: {e}"
                 )
                 self.use_async = False
 
-    def _get_claude_session_id(self) -> Optional[str]:
-        """
-        Get the Claude Code session ID from environment.
-
-        Returns:
-            Session ID if available, None otherwise
-        """
-        # Claude Code may set various environment variables
-        # Check common patterns
-        session_id = None
-
-        # Check for CLAUDE_SESSION_ID
-        session_id = os.environ.get("CLAUDE_SESSION_ID")
-
-        # Check for ANTHROPIC_SESSION_ID
-        if not session_id:
-            session_id = os.environ.get("ANTHROPIC_SESSION_ID")
-
-        # Check for generic SESSION_ID
-        if not session_id:
-            session_id = os.environ.get("SESSION_ID")
-
-        # Generate a default based on timestamp if nothing found
-        if not session_id:
-            # Use a timestamp-based session ID as fallback
-            session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
-            logger.info(f"No Claude session ID found, using generated: {session_id}")
-        else:
-            logger.info(f"Using Claude session ID: {session_id}")
-
-        return session_id
-
     def _generate_filename(self, agent: Optional[str] = None) -> str:
         """
         Generate a flat filename with session ID, agent, and timestamp.
@@ -156,7 +149,7 @@ class ClaudeSessionLogger:
         agent_name = agent_name.replace(" ", "_").lower()
 
         # Generate timestamp with microseconds for uniqueness
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S_%f")
 
         # Create filename: session_id-agent-timestamp.json
         return f"{self.session_id}-{agent_name}-{timestamp}.json"
@@ -216,7 +209,7 @@ class ClaudeSessionLogger:
 
         # Prepare response data with standardized field names
         response_data = {
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "session_id": self.session_id,
             "request": request_summary,  # Standardized field name
             "response": response_content,  # Already correct
@@ -228,7 +221,7 @@ class ClaudeSessionLogger:
 
         # Save response
         try:
-            with open(file_path, "w", encoding="utf-8") as f:
+            with file_path.open("w", encoding="utf-8") as f:
                 json.dump(response_data, f, indent=2, ensure_ascii=False)
 
             logger.debug(f"Logged response to {filename} for session {self.session_id}")
@@ -242,10 +235,15 @@ class ClaudeSessionLogger:
         """
         Manually set the session ID.
 
+        Note: This updates both the local session ID and the SessionManager.
+
         Args:
             session_id: The session ID to use
         """
         self.session_id = session_id
+        # Also update SessionManager to keep consistency
+        session_manager = get_session_manager()
+        session_manager.set_session_id(session_id)
         logger.info(f"Session ID set to: {session_id}")
 
     def get_session_path(self) -> Optional[Path]:
@@ -271,13 +269,16 @@ class ClaudeSessionLogger:
         return self.session_id is not None
 
 
-# Singleton instance for easy access
+# Singleton instance with thread-safe initialization
 _logger_instance = None
+_logger_lock = Lock()
 
 
 def get_session_logger(config: Optional[Config] = None) -> ClaudeSessionLogger:
     """
-    Get the singleton session logger instance.
+    Get the singleton session logger instance with thread-safe initialization.
+
+    Uses double-checked locking pattern to ensure thread safety.
 
     Args:
         config: Optional configuration instance to use
@@ -286,9 +287,16 @@ def get_session_logger(config: Optional[Config] = None) -> ClaudeSessionLogger:
         The shared ClaudeSessionLogger instance
     """
     global _logger_instance
-    if _logger_instance is None:
-        _logger_instance = ClaudeSessionLogger(config=config)
-    return _logger_instance
+
+    # Fast path - check without lock
+    if _logger_instance is not None:
+        return _logger_instance
+
+    # Slow path - acquire lock and double-check
+    with _logger_lock:
+        if _logger_instance is None:
+            _logger_instance = ClaudeSessionLogger(config=config)
+        return _logger_instance
 
 
 def log_response(

claude_mpm/services/cli/agent_cleanup_service.py

@@ -138,6 +138,11 @@ class AgentCleanupService(IAgentCleanupService):
                 if not isinstance(result, dict):
                     result = {"success": bool(result)}
 
+                # Add success flag based on whether there were errors
+                if "success" not in result:
+                    # Consider it successful if no errors occurred
+                    result["success"] = not bool(result.get("errors"))
+
                 # Add cleaned_count for backward compatibility
                 if "cleaned_count" not in result:
                     removed_count = len(result.get("removed", []))

claude_mpm/services/cli/agent_listing_service.py

@@ -169,8 +169,8 @@ class AgentListingService(IAgentListingService):
 
                 base_service = AgentDeploymentService()
                 self._deployment_service = DeploymentServiceWrapper(base_service)
-            except ImportError:
-                raise ImportError("Agent deployment service not available")
+            except ImportError as e:
+                raise ImportError("Agent deployment service not available") from e
         return self._deployment_service
 
     @property
@@ -250,11 +250,11 @@ class AgentListingService(IAgentListingService):
                     type=agent_data.get("type", "agent"),
                     tier=agent_data.get("tier", "system"),
                     path=agent_data.get("path", ""),
-                    description=agent_data.get("description") if verbose else None,
+                    description=agent_data.get("description"),
                     specializations=(
                         agent_data.get("specializations") if verbose else None
                     ),
-                    version=agent_data.get("version") if verbose else None,
+                    version=agent_data.get("version"),
                     deployed=True,
                 )
                 agents.append(agent)
@@ -364,7 +364,7 @@ class AgentListingService(IAgentListingService):
             if not agent_path.exists():
                 return None
 
-            with open(agent_path) as f:
+            with agent_path.open() as f:
                 content = f.read()
 
             details = {

claude_mpm/services/cli/agent_validation_service.py

@@ -1,3 +1,5 @@
+import re
+
 """
 Agent Validation Service
 ========================
@@ -70,7 +72,7 @@ class AgentValidationService(IAgentValidationService):
                 self._registry = adapter.registry
             except Exception as e:
                 self.logger.error(f"Failed to initialize agent registry: {e}")
-                raise RuntimeError(f"Could not initialize agent registry: {e}")
+                raise RuntimeError(f"Could not initialize agent registry: {e}") from e
         return self._registry
 
     def validate_agent(self, agent_name: str) -> Dict[str, Any]:

claude_mpm/services/cli/memory_crud_service.py

@@ -17,7 +17,7 @@ DESIGN DECISIONS:
 
 import os
 from abc import ABC, abstractmethod
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -142,7 +142,7 @@ class MemoryCRUDService(IMemoryCRUDService):
             config_loader = ConfigLoader()
             config = config_loader.load_main_config()
             # Use CLAUDE_MPM_USER_PWD if available
-            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", os.getcwd())
+            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", Path.cwd())
             current_dir = Path(user_pwd)
             self._memory_manager = AgentMemoryManager(config, current_dir)
         return self._memory_manager
@@ -223,7 +223,9 @@ class MemoryCRUDService(IMemoryCRUDService):
                     stat = memory_file.stat()
                     file_stats = {
                         "size_kb": stat.st_size / 1024,
-                        "modified": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                        "modified": datetime.fromtimestamp(
+                            stat.st_mtime, tz=timezone.utc
+                        ).isoformat(),
                         "path": str(memory_file),
                     }
 
@@ -256,7 +258,7 @@ class MemoryCRUDService(IMemoryCRUDService):
                             "file_stats": {
                                 "size_kb": stat.st_size / 1024,
                                 "modified": datetime.fromtimestamp(
-                                    stat.st_mtime
+                                    stat.st_mtime, tz=timezone.utc
                                 ).isoformat(),
                                 "path": str(memory_file),
                             },
@@ -431,10 +433,10 @@ class MemoryCRUDService(IMemoryCRUDService):
                         {
                             "size_kb": stat.st_size / 1024,
                             "modified": datetime.fromtimestamp(
-                                stat.st_mtime
+                                stat.st_mtime, tz=timezone.utc
                             ).isoformat(),
                             "created": datetime.fromtimestamp(
-                                stat.st_ctime
+                                stat.st_ctime, tz=timezone.utc
                             ).isoformat(),
                         }
                     )
@@ -499,7 +501,10 @@ class MemoryCRUDService(IMemoryCRUDService):
                     continue
 
                 stat = memory_file.stat()
-                age_days = (datetime.now() - datetime.fromtimestamp(stat.st_mtime)).days
+                age_days = (
+                    datetime.now(timezone.utc)
+                    - datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)
+                ).days
 
                 # Identify files older than 30 days as candidates
                 if age_days > 30:

claude_mpm/services/cli/memory_output_formatter.py

@@ -90,7 +90,7 @@ class MemoryOutputFormatter(IMemoryOutputFormatter):
             "success": "✅" if not quiet else "[OK]",
             "error": "❌" if not quiet else "[ERROR]",
             "warning": "⚠️" if not quiet else "[WARN]",
-            "info": "ℹ️" if not quiet else "[INFO]",
+            "info": "[INFO]️" if not quiet else "[INFO]",
             "memory": "🧠" if not quiet else "[MEMORY]",
             "file": "📁" if not quiet else "[FILE]",
             "agent": "🤖" if not quiet else "[AGENT]",
@@ -200,7 +200,7 @@ class MemoryOutputFormatter(IMemoryOutputFormatter):
                 try:
                     dt = datetime.fromisoformat(last_modified.replace("Z", "+00:00"))
                     last_modified_str = dt.strftime("%Y-%m-%d %H:%M:%S")
-                except:
+                except Exception:
                     last_modified_str = last_modified
 
                 # Status indicator based on usage