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

claude_mpm/core/logger.py

@@ -11,16 +11,22 @@ import json
 import logging
 import logging.handlers
 import sys
+import threading
 import time
 from collections import defaultdict
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
+
+from claude_mpm.core.unified_paths import get_project_root
 
 # Rich support has been removed
 HAS_RICH = False
 
+# Thread lock for symlink creation to prevent race conditions
+_symlink_lock = threading.Lock()
+
 
 class LogLevel(Enum):
     """Log levels for different verbosity."""
@@ -225,8 +231,6 @@ def setup_logging(
             # Use default log directory
             if log_dir is None:
                 # Use deployment root for logs to keep everything centralized
-                from claude_mpm.core.unified_paths import get_project_root
-
                 deployment_root = get_project_root()
                 log_dir = deployment_root / ".claude-mpm" / "logs"
 
@@ -238,12 +242,59 @@ def setup_logging(
 
             file_handler = logging.FileHandler(log_file)
 
-            # Also create a symlink to latest log
+            # Clean up old MPM logs (using configured retention count)
+            try:
+                deleted_count = cleanup_old_mpm_logs(log_dir)
+                if deleted_count > 0:
+                    # Log to the new file handler that we're about to add
+                    pass  # Deletion count will be logged when logger is ready
+            except Exception:
+                pass  # Ignore cleanup errors
+
+            # Also create a symlink to latest log (with thread safety)
             latest_link = log_dir / "latest.log"
-            if latest_link.exists() and latest_link.is_symlink():
-                latest_link.unlink()
-            if not latest_link.exists():
-                latest_link.symlink_to(log_file.name)
+
+            # Use a lock to prevent race conditions in concurrent environments
+            with _symlink_lock:
+                # Remove existing symlink/file if it exists
+                # Note: We need to handle both regular files and symlinks (including broken ones)
+                try:
+                    # unlink() works for both files and symlinks, even broken ones
+                    # This is more robust than checking exists() which returns False for broken symlinks
+                    if latest_link.is_symlink() or latest_link.exists():
+                        latest_link.unlink()
+                except (OSError, PermissionError) as e:
+                    # Log warning but continue - symlink is nice-to-have, not critical
+                    logger.debug(f"Could not remove existing latest.log: {e}")
+                except Exception as e:
+                    # Catch any other unexpected errors
+                    logger.debug(f"Unexpected error removing latest.log: {e}")
+
+                # Create new symlink with proper error handling
+                try:
+                    # Use relative path for better portability
+                    latest_link.symlink_to(log_file.name)
+                except FileExistsError:
+                    # This can happen in race conditions - try to remove and recreate
+                    try:
+                        latest_link.unlink()
+                        latest_link.symlink_to(log_file.name)
+                    except Exception as e:
+                        logger.debug(
+                            f"Could not recreate latest.log symlink after FileExistsError: {e}"
+                        )
+                except (OSError, NotImplementedError) as e:
+                    # Handle platforms where symlinks aren't supported (e.g., Windows without admin)
+                    # or filesystem doesn't support symlinks
+                    logger.debug(f"Could not create latest.log symlink: {e}")
+                    # Fallback: try to create a regular file with reference to actual log
+                    try:
+                        latest_link.write_text(f"Latest log: {log_file.name}\n")
+                    except Exception:
+                        pass  # Silently fail - logging should not break the application
+                except Exception as e:
+                    # Catch any other unexpected errors to ensure logging doesn't break
+                    logger.debug(f"Unexpected error creating latest.log symlink: {e}")
 
         file_handler.setLevel(logging.DEBUG)
         file_handler.setFormatter(formatter if json_format else detailed_formatter)
@@ -255,6 +306,72 @@ def setup_logging(
     return logger
 
 
+def cleanup_old_mpm_logs(
+    log_dir: Optional[Path] = None, keep_count: Optional[int] = None
+) -> int:
+    """
+    Clean up old MPM log files using time-based retention.
+
+    WHY: This function now delegates to LogManager for unified log management
+    with time-based retention instead of count-based.
+
+    DESIGN DECISIONS:
+    - Delegates to LogManager for consistency
+    - Uses time-based retention (48 hours default)
+    - Maintains backward compatibility
+
+    Args:
+        log_dir: Directory containing log files (defaults to .claude-mpm/logs)
+        keep_count: Ignored (kept for backward compatibility)
+
+    Returns:
+        Number of log files deleted
+    """
+    try:
+        from .log_manager import get_log_manager
+
+        log_manager = get_log_manager()
+
+        # Use LogManager's time-based cleanup (48 hours default)
+        return log_manager.cleanup_old_mpm_logs(log_dir)
+    except ImportError:
+        # Fallback to old implementation if LogManager not available
+        # Get retention count from configuration if not specified
+        if keep_count is None:
+            from claude_mpm.core.config_constants import ConfigConstants
+
+            keep_count = (
+                ConfigConstants.get_logging_setting("mpm_logs_retention_count") or 10
+            )
+        if log_dir is None:
+            deployment_root = get_project_root()
+            log_dir = deployment_root / ".claude-mpm" / "logs"
+
+        if not log_dir.exists():
+            return 0
+
+        # Get all MPM log files
+        log_files = sorted(
+            log_dir.glob("mpm_*.log"), key=lambda p: p.stat().st_mtime, reverse=True
+        )  # Newest first
+
+        if len(log_files) <= keep_count:
+            return 0  # Already within limit
+
+        # Delete older files beyond keep_count
+        deleted_count = 0
+        for log_file in log_files[
+            keep_count:
+        ]:  # Keep only the most recent keep_count files
+            try:
+                log_file.unlink()
+                deleted_count += 1
+            except Exception:
+                pass  # Ignore deletion errors
+
+        return deleted_count
+
+
 def get_logger(name: str) -> logging.Logger:
     """Get a logger instance."""
     return logging.getLogger(f"claude_mpm.{name}")

claude_mpm/core/logging_config.py

@@ -18,21 +18,21 @@ while maintaining backwards compatibility.
 """
 
 import functools
-import json
 import logging
 import time
 from contextlib import contextmanager
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Optional, Union
 
 from claude_mpm.core.logger import (
     JsonFormatter,
-    StreamingHandler,
     finalize_streaming_logs,
 )
 from claude_mpm.core.logger import get_logger as _get_logger
-from claude_mpm.core.logger import log_async_performance, log_performance
+from claude_mpm.core.logger import (
+    log_async_performance,
+    log_performance,
+)
 from claude_mpm.core.logger import setup_logging as _setup_logging
 
 # Standard log format for consistency
@@ -454,19 +454,19 @@ def log_with_level(
 
 # Export main functions and decorators
 __all__ = [
-    "get_logger",
-    "configure_logging",
-    "log_operation",
-    "log_performance_context",
-    "log_function_call",
-    "log_async_function_call",
-    "log_with_level",
-    "LogContext",
-    "ContextualLogger",
     "LOGGING_STANDARDS",
     "LOG_LEVELS",
+    "ContextualLogger",
+    "LogContext",
+    "configure_logging",
+    "finalize_streaming_logs",
+    "get_logger",
+    "log_async_function_call",
+    "log_async_performance",
+    "log_function_call",
+    "log_operation",
     # Re-export from core.logger for backwards compatibility
     "log_performance",
-    "log_async_performance",
-    "finalize_streaming_logs",
+    "log_performance_context",
+    "log_with_level",
 ]

claude_mpm/core/minimal_framework_loader.py

@@ -1,7 +1,8 @@
 """Minimal framework loader for better performance."""
 
+import contextlib
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Optional
 
 try:
     from ..core.logger import get_logger
@@ -45,18 +46,14 @@ class MinimalFrameworkLoader:
         working_claude_path = Path.cwd() / "CLAUDE.md"  # Legacy support
 
         if working_instructions_path.exists():
-            try:
+            with contextlib.suppress(Exception):
                 working_claude = working_instructions_path.read_text()
-            except:
-                pass
         elif working_claude_path.exists():
-            try:
+            with contextlib.suppress(Exception):
                 working_claude = working_claude_path.read_text()
-            except:
-                pass
 
         # Build minimal framework
-        framework = f"""# Claude MPM Framework
+        framework = """# Claude MPM Framework
 
 You are a multi-agent orchestrator in the Claude MPM framework.
 

claude_mpm/core/oneshot_session.py

@@ -4,30 +4,14 @@ This module encapsulates the logic for running one-time Claude commands,
 breaking down the monolithic run_oneshot method into focused, testable components.
 """
 
+import contextlib
 import os
 import subprocess
 import time
 import uuid
-from logging import Logger
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple
 
 from claude_mpm.core.logger import get_logger
-from claude_mpm.core.typing_utils import (
-    ErrorResult,
-    SessionConfig,
-    SessionEvent,
-    SessionId,
-    SessionResult,
-    SessionStatus,
-    SuccessResult,
-)
-
-if TYPE_CHECKING:
-    from claude_mpm.agents.memory.ticket_manager import TicketManager
-    from claude_mpm.core.claude_runner import ClaudeRunner
-    from claude_mpm.core.logger import ProjectLogger
-    from claude_mpm.services.response_logger import ResponseLogger
-    from claude_mpm.services.socketio_server import SocketIOClientProxy
 
 
 class OneshotSession:
@@ -154,13 +138,13 @@ class OneshotSession:
 
         # Add system instructions if available
         system_prompt = self.runner._create_system_prompt()
-        
+
         # Debug: log the system prompt to check for issues
         if system_prompt:
             self.logger.debug(f"System prompt length: {len(system_prompt)}")
             if "Path.cwd()" in system_prompt or "Path(" in system_prompt:
                 self.logger.warning("System prompt contains Python code references!")
-        
+
         if system_prompt and system_prompt != self._get_simple_context():
             # The problem might be with insert positioning
             # Let's add system prompt differently
@@ -189,17 +173,18 @@ class OneshotSession:
             self.logger.debug(f"Running command: {' '.join(cmd[:5])}...")
             if len(cmd) > 5:
                 self.logger.debug(f"Command has {len(cmd)} arguments total")
-            
-            result = subprocess.run(cmd, capture_output=True, text=True, env=env)
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, env=env, check=False
+            )
 
             if result.returncode == 0:
                 response = result.stdout.strip()
                 self._handle_successful_response(response, prompt)
                 return (True, response)
-            else:
-                error_msg = result.stderr or "Unknown error"
-                self._handle_error_response(error_msg, result.returncode)
-                return (False, error_msg)
+            error_msg = result.stderr or "Unknown error"
+            self._handle_error_response(error_msg, result.returncode)
+            return (False, error_msg)
 
         except subprocess.TimeoutExpired as e:
             return self._handle_timeout(e)
@@ -218,10 +203,8 @@ class OneshotSession:
         """Clean up the session and restore state."""
         # Restore original working directory
         if self.original_cwd:
-            try:
+            with contextlib.suppress(Exception):
                 os.chdir(self.original_cwd)
-            except Exception:
-                pass
 
         # Log session summary
         if self.runner.project_logger:
@@ -268,11 +251,11 @@ class OneshotSession:
     def _prepare_environment(self) -> Dict[str, str]:
         """Prepare the execution environment."""
         env = os.environ.copy()
-        
+
         # Disable telemetry for Claude Code
         # This ensures Claude Code doesn't send telemetry data during runtime
         env["DISABLE_TELEMETRY"] = "1"
-        
+
         return env
 
     def _build_command(self) -> list:
@@ -342,9 +325,8 @@ class OneshotSession:
     def _handle_error_response(self, error_msg: str, return_code: int) -> None:
         """Handle an error response from Claude."""
         print(f"Error: {error_msg}")
-        
+
         # Debug: print full traceback if available
-        import traceback
         if "Traceback" in error_msg or "Error:" in error_msg:
             self.logger.debug(f"Full error output:\n{error_msg}")
 

claude_mpm/core/optimized_agent_loader.py

@@ -17,14 +17,13 @@ WHY optimized agent loading:
 """
 
 import asyncio
-import hashlib
 import json
 import threading
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional
 
 try:
     import aiofiles
@@ -34,8 +33,7 @@ except ImportError:
     AIOFILES_AVAILABLE = False
 
 from ..core.logger import get_logger
-from .cache import FileSystemCache, get_file_cache
-from .lazy import LazyService
+from .cache import get_file_cache
 
 
 @dataclass
@@ -308,7 +306,7 @@ class OptimizedAgentLoader:
             self.metrics.cache_misses += 1
 
             # Read file asynchronously
-            async with aiofiles.open(file_path, "r", encoding="utf-8") as f:
+            async with aiofiles.open(file_path, encoding="utf-8") as f:
                 content = await f.read()
 
             # Parse in executor to avoid blocking

claude_mpm/core/optimized_startup.py

@@ -20,7 +20,8 @@ import sys
 import time
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
 
 from ..core.logger import get_logger
 from .cache import get_file_cache