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

claude_mpm/core/hook_manager.py

@@ -19,7 +19,7 @@ import queue
 import subprocess
 import threading
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from ..core.logger import get_logger
@@ -106,7 +106,9 @@ class HookManager:
             hook_event = {
                 "hook_event_name": hook_type,
                 "session_id": self.session_id,
-                "timestamp": hook_data.get("timestamp", datetime.utcnow().isoformat()),
+                "timestamp": hook_data.get(
+                    "timestamp", datetime.now(timezone.utc).isoformat()
+                ),
                 **event_data,
             }
 
@@ -182,7 +184,7 @@ class HookManager:
             {
                 "tool_name": tool_name,
                 "tool_args": tool_args or {},
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             },
         )
 
@@ -205,7 +207,7 @@ class HookManager:
                 "tool_name": tool_name,
                 "exit_code": exit_code,
                 "result": str(result) if result is not None else None,
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             },
         )
 
@@ -220,7 +222,7 @@ class HookManager:
         """
         return self._trigger_hook_event(
             "UserPromptSubmit",
-            {"prompt": prompt, "timestamp": datetime.utcnow().isoformat()},
+            {"prompt": prompt, "timestamp": datetime.now(timezone.utc).isoformat()},
         )
 
     def _trigger_hook_event(self, hook_type: str, event_data: Dict[str, Any]) -> bool:
@@ -250,7 +252,7 @@ class HookManager:
             hook_data = {
                 "hook_type": hook_type,
                 "event_data": event_data,
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             }
 
             # Try to queue without blocking

claude_mpm/core/injectable_service.py

@@ -182,14 +182,17 @@ class InjectableService(BaseService, ABC):
                 continue
 
             attr = getattr(self, attr_name, None)
-            if attr and hasattr(attr, "start") and hasattr(attr, "running"):
-                # It's a service that needs to be started
-                if not attr.running:
-                    try:
-                        await attr.start()
-                        logger.debug(f"Started dependency {attr_name}")
-                    except Exception as e:
-                        logger.warning(f"Failed to start dependency {attr_name}: {e}")
+            if (
+                attr
+                and hasattr(attr, "start")
+                and hasattr(attr, "running")
+                and not attr.running
+            ):
+                try:
+                    await attr.start()
+                    logger.debug(f"Started dependency {attr_name}")
+                except Exception as e:
+                    logger.warning(f"Failed to start dependency {attr_name}: {e}")
 
     def __repr__(self) -> str:
         """Enhanced string representation showing dependencies."""

claude_mpm/core/instruction_reinforcement_hook.py

@@ -18,9 +18,10 @@ The hook works by:
 """
 
 import threading
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
+from ..core.enums import OperationResult
 from ..core.logger import get_logger
 
 
@@ -158,7 +159,7 @@ class InstructionReinforcementHook:
         # Create reminder todo
         reminder_todo = {
             "content": message,
-            "status": "pending",
+            "status": OperationResult.PENDING,
             "activeForm": "Processing instruction reminder",
         }
 
@@ -197,7 +198,7 @@ class InstructionReinforcementHook:
                 "enabled": self.enabled,
                 "test_mode": self.test_mode,
                 "injection_interval": self.injection_interval,
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             }
 
     def reset_counters(self):

claude_mpm/core/interactive_session.py

@@ -8,8 +8,10 @@ import contextlib
 import os
 import subprocess
 import uuid
+from pathlib import Path
 from typing import Any, Dict, Optional, Tuple
 
+from claude_mpm.core.enums import ServiceState
 from claude_mpm.core.logger import get_logger
 
 
@@ -35,7 +37,7 @@ class InteractiveSession:
         self.runner = runner
         self.logger = get_logger("interactive_session")
         self.session_id = None
-        self.original_cwd = os.getcwd()
+        self.original_cwd = Path.cwd()
 
         # Initialize response tracking for interactive sessions
         # WHY: Interactive sessions need response logging just like oneshot sessions.
@@ -178,7 +180,8 @@ class InteractiveSession:
             # Notify WebSocket if connected
             if self.runner.websocket_server:
                 self.runner.websocket_server.claude_status_changed(
-                    status="starting", message="Launching Claude interactive session"
+                    status=ServiceState.STARTING,
+                    message="Launching Claude interactive session",
                 )
 
             # Launch using selected method
@@ -225,7 +228,7 @@ class InteractiveSession:
         """
         try:
             # Restore original directory
-            if self.original_cwd and os.path.exists(self.original_cwd):
+            if self.original_cwd and Path(self.original_cwd).exists():
                 with contextlib.suppress(OSError):
                     os.chdir(self.original_cwd)
 
@@ -278,7 +281,7 @@ class InteractiveSession:
             self.runner.websocket_server.session_started(
                 session_id=self.session_id,
                 launch_method=self.runner.launch_method,
-                working_dir=os.getcwd(),
+                working_dir=Path.cwd(),
             )
             return True, None
 
@@ -310,6 +313,9 @@ class InteractiveSession:
         print(
             "\033[32m│\033[0m     /mpm        - MPM overview and help           \033[32m│\033[0m"
         )
+        print(
+            "\033[32m│\033[0m     /mpm-init   - Initialize or update project    \033[32m│\033[0m"
+        )
         print(
             "\033[32m│\033[0m     /mpm-agents - Show available agents           \033[32m│\033[0m"
         )
@@ -369,7 +375,7 @@ class InteractiveSession:
 
             return cmd
         # Normal mode - full command with all claude-mpm enhancements
-        cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
+        cmd = ["claude", "--dangerously-skip-permissions"]
 
         # Add custom arguments
         if self.runner.claude_args:
@@ -377,6 +383,14 @@ class InteractiveSession:
             self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
             cmd.extend(self.runner.claude_args)
 
+        # Add --agents flag if native agents mode is enabled
+        if getattr(self.runner, "use_native_agents", False):
+            agents_flag = self._build_agents_flag()
+            if agents_flag:
+                # Add --agents JSON directly (already properly formatted)
+                cmd.extend(agents_flag)
+                self.logger.info("✓ Native agents mode: Using --agents CLI flag")
+
         # Add system instructions
         from claude_mpm.core.claude_runner import create_simple_context
 
@@ -392,10 +406,42 @@ class InteractiveSession:
             self.logger.info("✅ VERIFIED: --resume flag IS included in final command")
             self.logger.debug(f"--resume position in command: {cmd.index('--resume')}")
         else:
-            self.logger.debug("ℹ️ --resume flag NOT included in final command")
+            self.logger.debug("[INFO]️ --resume flag NOT included in final command")
 
         return cmd
 
+    def _build_agents_flag(self) -> Optional[list]:
+        """Build --agents flag with all MPM agents.
+
+        Returns:
+            List with ["--agents", "<json>"] or None if conversion fails
+        """
+        try:
+            from claude_mpm.services.native_agent_converter import NativeAgentConverter
+
+            converter = NativeAgentConverter()
+            agents = converter.load_agents_from_templates()
+
+            if not agents:
+                self.logger.warning("No agents loaded for native mode")
+                return None
+
+            # Generate JSON for --agents flag
+            agents_json = converter.generate_agents_json(agents)
+            summary = converter.get_conversion_summary(agents)
+
+            self.logger.info(
+                f"Native agents: {summary['total_agents']} agents, "
+                f"{summary['json_size_kb']} KB JSON"
+            )
+
+            # Return as list: ["--agents", "<json>"]
+            return ["--agents", agents_json]
+
+        except Exception as e:
+            self.logger.error(f"Failed to build --agents flag: {e}", exc_info=True)
+            return None
+
     def _prepare_environment(self) -> dict:
         """Prepare clean environment variables for Claude."""
         clean_env = os.environ.copy()
@@ -450,7 +496,8 @@ class InteractiveSession:
         # Notify WebSocket before exec
         if self.runner.websocket_server:
             self.runner.websocket_server.claude_status_changed(
-                status="running", message="Claude process started (exec mode)"
+                status=ServiceState.RUNNING,
+                message="Claude process started (exec mode)",
             )
 
         # This will not return if successful
@@ -490,7 +537,7 @@ class InteractiveSession:
         # Notify WebSocket of error
         if self.runner.websocket_server:
             self.runner.websocket_server.claude_status_changed(
-                status="error", message=f"Failed to launch Claude: {error}"
+                status=ServiceState.ERROR, message=f"Failed to launch Claude: {error}"
             )
 
     def _handle_keyboard_interrupt(self) -> None:

claude_mpm/core/interfaces.py

@@ -33,7 +33,62 @@ from pathlib import Path
 from typing import Any, Dict, Generic, List, Optional, Tuple, TypeVar
 
 # Re-export everything from the new location for backward compatibility
-from claude_mpm.services.core.interfaces import *
+from claude_mpm.services.core.interfaces import (  # noqa: F401
+    AgentCapabilitiesInterface,
+    AgentDeploymentInterface,
+    AgentMetadata,
+    CacheEntry,
+    CommandHandlerInterface,
+    HealthStatus,
+    HookServiceInterface,
+    IAgentRecommender,
+    IAgentRegistry,
+    IAutoConfigManager,
+    ICacheService,
+    IConfigurationManager,
+    IConfigurationService,
+    ICrashDetector,
+    IDeploymentStateManager,
+    IErrorHandler,
+    IEventBus,
+    IHealthCheck,
+    IHealthCheckManager,
+    IHealthMonitor,
+    ILocalProcessManager,
+    ILogMonitor,
+    IMemoryLeakDetector,
+    IModelProvider,
+    IModelRouter,
+    InterfaceRegistry,
+    IPerformanceMonitor,
+    IPromptCache,
+    IResourceMonitor,
+    IRestartManager,
+    IRestartPolicy,
+    IServiceContainer,
+    IServiceFactory,
+    IServiceLifecycle,
+    IStructuredLogger,
+    ITemplateManager,
+    IToolchainAnalyzer,
+    MemoryHookInterface,
+    MemoryServiceInterface,
+    ModelCapability,
+    ModelProvider,
+    ModelResponse,
+    ProjectAnalyzerInterface,
+    RunnerConfigurationInterface,
+    ServiceType,
+    SessionManagementInterface,
+    SocketIOServiceInterface,
+    SubprocessLauncherInterface,
+    SystemInstructionsInterface,
+    T,
+    TemplateRenderContext,
+    TicketManagerInterface,
+    UtilityServiceInterface,
+    VersionServiceInterface,
+)
 
 # Type variables for generic interfaces
 T = TypeVar("T")

claude_mpm/core/lazy.py

@@ -16,7 +16,7 @@ import functools
 import threading
 import time
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Dict, Generic, Optional, Type, TypeVar
 
 from ..core.logger import get_logger
@@ -121,7 +121,7 @@ class LazyService(Generic[T]):
             # Track initialization
             start_time = time.time()
             if self._metrics.first_access is None:
-                self._metrics.first_access = datetime.now()
+                self._metrics.first_access = datetime.now(timezone.utc)
 
             try:
                 self._logger.debug(f"Initializing lazy service: {self._name}")
@@ -417,7 +417,7 @@ class AsyncLazyService(Generic[T]):
 
             start_time = time.time()
             if self._metrics.first_access is None:
-                self._metrics.first_access = datetime.now()
+                self._metrics.first_access = datetime.now(timezone.utc)
 
             try:
                 self._logger.debug(f"Async initializing: {self._name}")

claude_mpm/core/log_manager.py

@@ -16,18 +16,25 @@ DESIGN DECISIONS:
 
 import asyncio
 import json
-import logging
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from queue import Full, Queue
 from threading import Lock, Thread
 from typing import Any, Dict, Optional
 
+from claude_mpm.core.logging_utils import get_logger
+
 from ..core.config import Config
 from ..core.constants import SystemLimits
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__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 +83,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 +111,62 @@ 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
+
+        # Check environment variable to skip cleanup (for configure command)
+        import os
+
+        if os.environ.get("CLAUDE_MPM_SKIP_CLEANUP", "0") == "1":
+            logger.debug("Startup cleanup skipped (CLAUDE_MPM_SKIP_CLEANUP=1)")
+            return
+
+        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:
@@ -137,7 +199,7 @@ class LogManager:
                 finally:
                     self.write_queue.task_done()
 
-            except:
+            except Exception:
                 continue  # Timeout or other error, continue loop
 
     def _process_cleanup_queue(self):
@@ -157,7 +219,7 @@ class LogManager:
                 finally:
                     self.cleanup_queue.task_done()
 
-            except:
+            except Exception:
                 continue  # Timeout or other error, continue loop
 
     async def setup_logging(self, log_type: str) -> Path:
@@ -242,7 +304,7 @@ class LogManager:
             return 0
 
         # Calculate cutoff time
-        cutoff_time = datetime.now() - timedelta(hours=retention_hours)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
 
         # Schedule async cleanup
         deleted_count = await self._async_cleanup(directory, pattern, cutoff_time)
@@ -283,7 +345,9 @@ class LogManager:
 
                     try:
                         # Check file modification time
-                        mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
+                        mtime = datetime.fromtimestamp(
+                            file_path.stat().st_mtime, tz=timezone.utc
+                        )
                         if mtime < cutoff_time:
                             file_path.unlink()
                             deleted_count += 1
@@ -316,7 +380,7 @@ class LogManager:
             return 0
 
         # Calculate cutoff time
-        cutoff_time = datetime.now() - timedelta(hours=retention_hours)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(hours=retention_hours)
         deleted_count = 0
 
         try:
@@ -332,7 +396,9 @@ class LogManager:
 
                 try:
                     # Check file modification time
-                    mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
+                    mtime = datetime.fromtimestamp(
+                        file_path.stat().st_mtime, tz=timezone.utc
+                    )
                     if mtime < cutoff_time:
                         file_path.unlink()
                         deleted_count += 1
@@ -350,13 +416,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"
 
@@ -413,7 +480,7 @@ class LogManager:
             prompts_dir = await self.setup_logging("prompts")
 
             # Generate filename with timestamp
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S_%f")[
                 :-3
             ]  # Microseconds to milliseconds
 
@@ -439,7 +506,7 @@ class LogManager:
 
             # Prepare prompt data
             prompt_data = {
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "type": prompt_type,
                 "content": content,
                 "metadata": metadata or {},
@@ -475,12 +542,12 @@ class LogManager:
 
                 if extension == ".json":
                     # JSON files also get structured metadata for consistency
-                    with open(file_path, "w", encoding="utf-8") as f:
+                    with file_path.open("w", encoding="utf-8") as f:
                         json.dump(data, f, indent=2, ensure_ascii=False)
                 # For markdown or text files
                 elif isinstance(data, dict):
                     # Write as formatted markdown with metadata
-                    with open(file_path, "w", encoding="utf-8") as f:
+                    with file_path.open("w", encoding="utf-8") as f:
                         f.write("---\n")
                         f.write(f"timestamp: {data.get('timestamp', 'unknown')}\n")
                         f.write(f"type: {data.get('type', 'unknown')}\n")
@@ -492,7 +559,7 @@ class LogManager:
                         f.write(data.get("content", ""))
                 else:
                     # Write content directly
-                    with open(file_path, "w", encoding="utf-8") as f:
+                    with file_path.open("w", encoding="utf-8") as f:
                         f.write(str(data))
             except Exception as e:
                 logger.error(f"Failed to write {file_path}: {e}")
@@ -512,16 +579,18 @@ class LogManager:
             message: Log message to write
             level: Log level (INFO, WARNING, ERROR, DEBUG)
         """
-        timestamp = datetime.now().isoformat()
+        timestamp = datetime.now(timezone.utc).isoformat()
         log_entry = f"[{timestamp}] [{level}] {message}\n"
 
         # Get appropriate log file based on context
         log_dir = self._get_log_directory("mpm")
-        log_file = log_dir / f"mpm_{datetime.now().strftime('%Y%m%d')}.log"
+        log_file = log_dir / f"mpm_{datetime.now(timezone.utc).strftime('%Y%m%d')}.log"
 
         def write_task():
             try:
-                with open(log_file, "a", encoding="utf-8") as f:
+                # Ensure directory exists before writing (race condition with cleanup)
+                log_dir.mkdir(parents=True, exist_ok=True)
+                with log_file.open("a", encoding="utf-8") as f:
                     f.write(log_entry)
             except Exception as e:
                 logger.error(f"Failed to write log: {e}")
@@ -597,7 +666,7 @@ class LogManager:
         try:
             self.write_queue.put_nowait(None)
             self.cleanup_queue.put_nowait(None)
-        except:
+        except Exception:
             pass
 
         # Wait for threads to finish