claude-mpm 4.2.44__py3-none-any.whl → 4.3.0__py3-none-any.whl

claude_mpm/constants.py

@@ -229,7 +229,7 @@ class Paths(str, Enum):
 
     CLAUDE_AGENTS_DIR = ".claude/agents"
     CLAUDE_CONFIG_DIR = ".claude"
-    MPM_LOG_DIR = "logs/mpm"
+    MPM_LOG_DIR = ".claude-mpm/logs/mpm"
     MPM_SESSION_DIR = ".claude-mpm/session"
     MPM_PROMPTS_DIR = ".claude-mpm/prompts"
 

claude_mpm/core/error_handler.py

@@ -145,6 +145,7 @@ class ErrorHandler:
         if strategy == ErrorStrategy.TERMINATE:
             self.logger.critical(f"Terminating due to critical error: {error}")
             sys.exit(1)
+        return None
 
     def _log_error(
         self,
@@ -307,10 +308,7 @@ def handle_error(
     Returns:
         Result based on strategy
     """
-    if logger:
-        handler = ErrorHandler(logger=logger)
-    else:
-        handler = _global_handler
+    handler = ErrorHandler(logger=logger) if logger else _global_handler
 
     return handler.handle(
         error=error,

claude_mpm/core/file_utils.py

@@ -11,7 +11,7 @@ import json
 import os
 import shutil
 import tempfile
-from contextlib import contextmanager
+from contextlib import contextmanager, suppress
 from pathlib import Path
 from typing import Any, List, Optional, Union
 
@@ -374,10 +374,8 @@ def atomic_write(
     except OSError as e:
         logger.error(f"Error in atomic write to {filepath}: {e}")
         # Clean up temporary file
-        try:
+        with suppress(Exception):
             os.unlink(temp_path)
-        except:
-            pass
         return False
 
 
@@ -703,10 +701,7 @@ def validate_file(
         return False
 
     # Check extension
-    if extensions and filepath.suffix not in extensions:
-        return False
-
-    return True
+    return not (extensions and filepath.suffix not in extensions)
 
 
 def get_file_hash(
@@ -760,10 +755,7 @@ def find_files(
     if not directory.exists():
         return []
 
-    if recursive:
-        paths = directory.rglob(pattern)
-    else:
-        paths = directory.glob(pattern)
+    paths = directory.rglob(pattern) if recursive else directory.glob(pattern)
 
     if file_only:
         return [p for p in paths if p.is_file()]

claude_mpm/core/framework_loader.py

@@ -639,7 +639,14 @@ class FrameworkLoader:
             self._load_packaged_framework_content(content)
         else:
             # Load from filesystem for development mode
-            # Load framework's INSTRUCTIONS.md
+            # Try new consolidated PM_INSTRUCTIONS.md first, fall back to INSTRUCTIONS.md
+            pm_instructions_path = (
+                self.framework_path
+                / "src"
+                / "claude_mpm"
+                / "agents"
+                / "PM_INSTRUCTIONS.md"
+            )
             framework_instructions_path = (
                 self.framework_path
                 / "src"
@@ -647,12 +654,25 @@ class FrameworkLoader:
                 / "agents"
                 / "INSTRUCTIONS.md"
             )
-            if framework_instructions_path.exists():
+
+            # Try loading new consolidated file first
+            if pm_instructions_path.exists():
                 loaded_content = self._try_load_file(
-                    framework_instructions_path, "framework INSTRUCTIONS.md"
+                    pm_instructions_path, "consolidated PM_INSTRUCTIONS.md"
                 )
                 if loaded_content:
                     content["framework_instructions"] = loaded_content
+                    self.logger.info("Loaded consolidated PM_INSTRUCTIONS.md")
+            # Fall back to legacy file for backward compatibility
+            elif framework_instructions_path.exists():
+                loaded_content = self._try_load_file(
+                    framework_instructions_path, "framework INSTRUCTIONS.md (legacy)"
+                )
+                if loaded_content:
+                    content["framework_instructions"] = loaded_content
+                    self.logger.warning(
+                        "Using legacy INSTRUCTIONS.md - consider migrating to PM_INSTRUCTIONS.md"
+                    )
                     content["loaded"] = True
                     # Add framework version to content
                     if self.framework_version:
@@ -717,20 +737,33 @@ class FrameworkLoader:
                 return
 
         try:
-            # Load INSTRUCTIONS.md
-            instructions_content = self._load_packaged_file("INSTRUCTIONS.md")
-            if instructions_content:
-                content["framework_instructions"] = instructions_content
+            # Try new consolidated PM_INSTRUCTIONS.md first
+            pm_instructions_content = self._load_packaged_file("PM_INSTRUCTIONS.md")
+            if pm_instructions_content:
+                content["framework_instructions"] = pm_instructions_content
                 content["loaded"] = True
+                self.logger.info("Loaded consolidated PM_INSTRUCTIONS.md from package")
                 # Extract and store version/timestamp metadata
                 self._extract_metadata_from_content(
-                    instructions_content, "INSTRUCTIONS.md"
+                    pm_instructions_content, "PM_INSTRUCTIONS.md"
                 )
-                if self.framework_version:
-                    content["instructions_version"] = self.framework_version
-                    content["version"] = self.framework_version
-                if self.framework_last_modified:
-                    content["instructions_last_modified"] = self.framework_last_modified
+            else:
+                # Fall back to legacy INSTRUCTIONS.md
+                instructions_content = self._load_packaged_file("INSTRUCTIONS.md")
+                if instructions_content:
+                    content["framework_instructions"] = instructions_content
+                    content["loaded"] = True
+                    self.logger.warning("Using legacy INSTRUCTIONS.md from package")
+                    # Extract and store version/timestamp metadata
+                    self._extract_metadata_from_content(
+                        instructions_content, "INSTRUCTIONS.md"
+                    )
+
+            if self.framework_version:
+                content["instructions_version"] = self.framework_version
+                content["version"] = self.framework_version
+            if self.framework_last_modified:
+                content["instructions_last_modified"] = self.framework_last_modified
 
             # Load BASE_PM.md
             base_pm_content = self._load_packaged_file("BASE_PM.md")
@@ -757,22 +790,37 @@ class FrameworkLoader:
     ) -> None:
         """Load framework content using importlib.resources fallback."""
         try:
-            # Load INSTRUCTIONS.md
-            instructions_content = self._load_packaged_file_fallback(
-                "INSTRUCTIONS.md", resources
+            # Try new consolidated PM_INSTRUCTIONS.md first
+            pm_instructions_content = self._load_packaged_file_fallback(
+                "PM_INSTRUCTIONS.md", resources
             )
-            if instructions_content:
-                content["framework_instructions"] = instructions_content
+            if pm_instructions_content:
+                content["framework_instructions"] = pm_instructions_content
                 content["loaded"] = True
+                self.logger.info("Loaded consolidated PM_INSTRUCTIONS.md via fallback")
                 # Extract and store version/timestamp metadata
                 self._extract_metadata_from_content(
-                    instructions_content, "INSTRUCTIONS.md"
+                    pm_instructions_content, "PM_INSTRUCTIONS.md"
                 )
-                if self.framework_version:
-                    content["instructions_version"] = self.framework_version
-                    content["version"] = self.framework_version
-                if self.framework_last_modified:
-                    content["instructions_last_modified"] = self.framework_last_modified
+            else:
+                # Fall back to legacy INSTRUCTIONS.md
+                instructions_content = self._load_packaged_file_fallback(
+                    "INSTRUCTIONS.md", resources
+                )
+                if instructions_content:
+                    content["framework_instructions"] = instructions_content
+                    content["loaded"] = True
+                    self.logger.warning("Using legacy INSTRUCTIONS.md via fallback")
+                    # Extract and store version/timestamp metadata
+                    self._extract_metadata_from_content(
+                        instructions_content, "INSTRUCTIONS.md"
+                    )
+
+            if self.framework_version:
+                content["instructions_version"] = self.framework_version
+                content["version"] = self.framework_version
+            if self.framework_last_modified:
+                content["instructions_last_modified"] = self.framework_last_modified
 
             # Load BASE_PM.md
             base_pm_content = self._load_packaged_file_fallback("BASE_PM.md", resources)

claude_mpm/core/log_manager.py

@@ -29,6 +29,12 @@ from ..core.constants import SystemLimits
 
 logger = logging.getLogger(__name__)
 
+# Import cleanup utility for automatic cleanup
+try:
+    from ..utils.log_cleanup import run_cleanup_on_startup
+except ImportError:
+    run_cleanup_on_startup = None
+
 
 class LogManager:
     """
@@ -76,6 +82,9 @@ class LogManager:
         # Start background threads
         self._start_background_threads()
 
+        # Run automatic cleanup on startup if enabled
+        self._run_startup_cleanup()
+
     def _setup_logging_config(self):
         """Load and setup logging configuration from config."""
         logging_config = self.config.get("logging", {})
@@ -101,10 +110,55 @@ class LogManager:
         }
 
         # Base directories
-        self.base_log_dir = Path(logging_config.get("base_directory", "logs"))
+        self.base_log_dir = Path(
+            logging_config.get("base_directory", ".claude-mpm/logs")
+        )
         if not self.base_log_dir.is_absolute():
             self.base_log_dir = Path.cwd() / self.base_log_dir
 
+    def _run_startup_cleanup(self):
+        """Run automatic log cleanup on startup if enabled."""
+        if run_cleanup_on_startup is None:
+            return  # Cleanup utility not available
+
+        try:
+            # Get cleanup configuration
+            cleanup_config = self.config.get("log_cleanup", {})
+
+            # Check if automatic cleanup is enabled (default: True)
+            if not cleanup_config.get("auto_cleanup_enabled", True):
+                logger.debug("Automatic log cleanup is disabled")
+                return
+
+            # Convert hours to days for cleanup utility
+            cleanup_params = {
+                "auto_cleanup_enabled": True,
+                "session_retention_days": self.retention_hours.get("sessions", 168)
+                // 24,
+                "archive_retention_days": cleanup_config.get(
+                    "archive_retention_days", 30
+                ),
+                "log_retention_days": cleanup_config.get("log_retention_days", 14),
+            }
+
+            # Run cleanup in background thread to avoid blocking startup
+            def cleanup_task():
+                try:
+                    result = run_cleanup_on_startup(self.base_log_dir, cleanup_params)
+                    if result:
+                        logger.debug(
+                            f"Startup cleanup completed: "
+                            f"Removed {result.get('total_removed', 0)} items"
+                        )
+                except Exception as e:
+                    logger.debug(f"Startup cleanup failed: {e}")
+
+            cleanup_thread = Thread(target=cleanup_task, daemon=True)
+            cleanup_thread.start()
+
+        except Exception as e:
+            logger.debug(f"Could not run startup cleanup: {e}")
+
     def _start_background_threads(self):
         """Start background threads for async operations."""
         with self._lock:
@@ -350,13 +404,14 @@ class LogManager:
         """
         One-time migration to move existing MPM logs to new subdirectory.
 
-        Moves mpm_*.log files from .claude-mpm/logs/ to logs/mpm/
+        Moves mpm_*.log files from old locations to .claude-mpm/logs/mpm/
         """
         try:
-            # Check both old possible locations
+            # Check old possible locations (including incorrectly created ones)
             old_locations = [
-                Path.cwd() / ".claude-mpm" / "logs",  # Old default location
-                self.base_log_dir,  # Current base location (logs/)
+                Path.cwd() / "logs",  # Incorrectly created in project root
+                Path.cwd() / ".claude-mpm" / "logs",  # Correct base location
+                self.base_log_dir,  # Current base location (.claude-mpm/logs/)
             ]
             new_location = self.base_log_dir / "mpm"
 

claude_mpm/core/logger.py

@@ -232,7 +232,7 @@ def setup_logging(
             if log_dir is None:
                 # Use deployment root for logs to keep everything centralized
                 deployment_root = get_project_root()
-                log_dir = deployment_root / "logs" / "mpm"
+                log_dir = deployment_root / ".claude-mpm" / "logs" / "mpm"
 
             log_dir.mkdir(parents=True, exist_ok=True)
 

claude_mpm/core/logging_utils.py

@@ -42,8 +42,10 @@ class LoggingConfig:
     ISO_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
 
     # File settings
-    MAX_BYTES = 10 * 1024 * 1024  # 10MB
+    MAX_BYTES = 5 * 1024 * 1024  # 5MB - lowered for better rotation testing
     BACKUP_COUNT = 5
+    ROTATION_INTERVAL = "midnight"  # Daily rotation at midnight
+    ROTATION_BACKUP_COUNT = 7  # Keep 7 days of daily logs
 
     # Component-specific log names
     COMPONENT_NAMES = {
@@ -76,11 +78,11 @@ class LoggerFactory:
     @classmethod
     def initialize(
         cls,
-        log_level: str = None,
+        log_level: Optional[str] = None,
         log_dir: Optional[Path] = None,
         log_to_file: bool = False,
-        log_format: str = None,
-        date_format: str = None,
+        log_format: Optional[str] = None,
+        date_format: Optional[str] = None,
     ) -> None:
         """Initialize the logging system globally.
 
@@ -129,30 +131,46 @@ class LoggerFactory:
         log_format: Optional[str] = None,
         date_format: Optional[str] = None,
     ) -> None:
-        """Set up file logging handler."""
+        """Set up file logging handlers with both size and time-based rotation."""
         if not cls._log_dir:
             return
 
         # Ensure log directory exists
         cls._log_dir.mkdir(parents=True, exist_ok=True)
 
-        # Create rotating file handler
+        formatter = logging.Formatter(
+            log_format or LoggingConfig.DETAILED_FORMAT,
+            date_format or LoggingConfig.DATE_FORMAT,
+        )
+
+        # 1. Size-based rotating file handler (for current active log)
         log_file = cls._log_dir / "claude_mpm.log"
-        file_handler = logging.handlers.RotatingFileHandler(
+        size_handler = logging.handlers.RotatingFileHandler(
             log_file,
             maxBytes=LoggingConfig.MAX_BYTES,
             backupCount=LoggingConfig.BACKUP_COUNT,
         )
-        file_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
-
-        file_formatter = logging.Formatter(
-            log_format or LoggingConfig.DETAILED_FORMAT,
-            date_format or LoggingConfig.DATE_FORMAT,
+        size_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
+        size_handler.setFormatter(formatter)
+        logging.getLogger().addHandler(size_handler)
+        cls._handlers["file"] = size_handler
+
+        # 2. Time-based rotating file handler (daily rotation)
+        daily_log_file = cls._log_dir / "claude_mpm_daily.log"
+        time_handler = logging.handlers.TimedRotatingFileHandler(
+            daily_log_file,
+            when=LoggingConfig.ROTATION_INTERVAL,
+            interval=1,
+            backupCount=LoggingConfig.ROTATION_BACKUP_COUNT,
         )
-        file_handler.setFormatter(file_formatter)
+        time_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
+        time_handler.setFormatter(formatter)
+
+        # Add suffix to rotated files (e.g., claude_mpm_daily.log.2024-09-18)
+        time_handler.suffix = "%Y-%m-%d"
 
-        logging.getLogger().addHandler(file_handler)
-        cls._handlers["file"] = file_handler
+        logging.getLogger().addHandler(time_handler)
+        cls._handlers["file_daily"] = time_handler
 
     @classmethod
     def get_logger(
@@ -268,10 +286,10 @@ def get_logger(
 
 
 def initialize_logging(
-    log_level: str = None,
+    log_level: Optional[str] = None,
     log_dir: Optional[Path] = None,
     log_to_file: bool = False,
-    log_format: str = None,
+    log_format: Optional[str] = None,
 ) -> None:
     """Initialize the logging system with standard configuration.
 
@@ -300,7 +318,7 @@ def set_log_level(level: str) -> None:
     LoggerFactory.set_level(level)
 
 
-def get_component_logger(component: str, name: str = None) -> logging.Logger:
+def get_component_logger(component: str, name: Optional[str] = None) -> logging.Logger:
     """Get a logger for a specific component.
 
     Args:

claude_mpm/core/unified_agent_registry.py

@@ -367,9 +367,17 @@ class UnifiedAgentRegistry:
                                 break
                             project_root = project_root.parent
 
-                    # Extract tags
+                    # Extract tags (handle both list and comma-separated string formats)
                     if "metadata" in data:
-                        tags = data["metadata"].get("tags", [])
+                        tags_raw = data["metadata"].get("tags", [])
+                        if isinstance(tags_raw, str):
+                            tags = [
+                                tag.strip()
+                                for tag in tags_raw.split(",")
+                                if tag.strip()
+                            ]
+                        else:
+                            tags = tags_raw if isinstance(tags_raw, list) else []
 
                 except Exception as e:
                     logger.debug(
@@ -462,8 +470,14 @@ class UnifiedAgentRegistry:
                         "specializations", data.get("specializations", [])
                     )
 
-                    # Extract tags as specializations if present
-                    tags = metadata.get("tags", [])
+                    # Extract tags as specializations if present (handle both formats)
+                    tags_raw = metadata.get("tags", [])
+                    if isinstance(tags_raw, str):
+                        tags = [
+                            tag.strip() for tag in tags_raw.split(",") if tag.strip()
+                        ]
+                    else:
+                        tags = tags_raw if isinstance(tags_raw, list) else []
                     if tags and not specializations:
                         specializations = tags
                 else:

claude_mpm/dashboard/react/components/DataInspector/DataInspector.module.css

@@ -0,0 +1,188 @@
+.dataInspector {
+  background: rgba(0, 0, 0, 0.3);
+  border-radius: 6px;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  overflow: hidden;
+}
+
+.inspectorHeader {
+  display: flex;
+  gap: 10px;
+  padding: 10px;
+  background: rgba(255, 255, 255, 0.05);
+  border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+  align-items: center;
+}
+
+.searchInput {
+  flex: 1;
+  padding: 8px 12px;
+  background: rgba(255, 255, 255, 0.05);
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  border-radius: 4px;
+  color: white;
+  font-size: 12px;
+}
+
+.searchInput::placeholder {
+  color: rgba(255, 255, 255, 0.5);
+}
+
+.actions {
+  display: flex;
+  gap: 8px;
+}
+
+.actionButton {
+  padding: 6px 12px;
+  background: rgba(255, 255, 255, 0.1);
+  border: none;
+  border-radius: 4px;
+  color: white;
+  font-size: 11px;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.actionButton:hover {
+  background: rgba(255, 255, 255, 0.2);
+}
+
+.treeContainer {
+  overflow-y: auto;
+  padding: 10px;
+  font-family: 'Courier New', monospace;
+  font-size: 13px;
+  line-height: 1.4;
+}
+
+.treeNode {
+  margin-bottom: 2px;
+}
+
+.nodeHeader {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 2px 4px;
+  cursor: pointer;
+  border-radius: 3px;
+  transition: background 0.2s;
+}
+
+.nodeHeader:hover {
+  background: rgba(255, 255, 255, 0.05);
+}
+
+.expandIcon {
+  color: #94a3b8;
+  font-size: 10px;
+  transition: transform 0.2s;
+  cursor: pointer;
+  user-select: none;
+  width: 12px;
+  display: inline-block;
+}
+
+.expandIcon.expanded {
+  transform: rotate(90deg);
+}
+
+.leafIcon {
+  color: #94a3b8;
+  font-size: 8px;
+  width: 12px;
+  display: inline-block;
+  text-align: center;
+}
+
+.nodeKey {
+  color: #60a5fa;
+  font-weight: 500;
+}
+
+.nodeValue {
+  margin-left: 6px;
+  word-break: break-all;
+}
+
+.nodeValue.string {
+  color: #86efac;
+}
+
+.nodeValue.number {
+  color: #fbbf24;
+}
+
+.nodeValue.boolean {
+  color: #a78bfa;
+}
+
+.nodeValue.null,
+.nodeValue.undefined {
+  color: #f87171;
+  font-style: italic;
+}
+
+.nodeValue.object,
+.nodeValue.array {
+  color: #94a3b8;
+  font-style: italic;
+}
+
+.copyButton {
+  margin-left: auto;
+  background: none;
+  border: none;
+  color: rgba(255, 255, 255, 0.5);
+  cursor: pointer;
+  padding: 2px;
+  font-size: 10px;
+  opacity: 0;
+  transition: opacity 0.2s;
+}
+
+.nodeHeader:hover .copyButton {
+  opacity: 1;
+}
+
+.copyButton:hover {
+  color: rgba(255, 255, 255, 0.8);
+}
+
+.nodeChildren {
+  border-left: 1px solid rgba(255, 255, 255, 0.1);
+  margin-left: 6px;
+}
+
+.highlight {
+  background: rgba(251, 191, 36, 0.3);
+  color: #fbbf24;
+  padding: 1px 2px;
+  border-radius: 2px;
+}
+
+.noData {
+  text-align: center;
+  color: rgba(255, 255, 255, 0.5);
+  padding: 20px;
+  font-style: italic;
+}
+
+/* Scrollbar styling */
+.treeContainer::-webkit-scrollbar {
+  width: 6px;
+}
+
+.treeContainer::-webkit-scrollbar-track {
+  background: rgba(255, 255, 255, 0.05);
+}
+
+.treeContainer::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.2);
+  border-radius: 3px;
+}
+
+.treeContainer::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 255, 255, 0.3);
+}