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

claude_mpm/core/interactive_session.py

@@ -2,16 +2,31 @@
 
 This module provides the InteractiveSession class that manages Claude's interactive mode
 with proper separation of concerns and reduced complexity.
+
+DEPENDENCY INJECTION:
+This module uses protocol-based dependency injection to break circular imports.
+Instead of importing ClaudeRunner directly, it uses ClaudeRunnerProtocol which
+defines the interface it needs. This allows ClaudeRunner to create instances
+of InteractiveSession without circular dependency issues.
 """
 
 import contextlib
 import os
 import subprocess
 import uuid
-from typing import Any, Dict, Optional, Tuple
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
 
+from claude_mpm.core.enums import ServiceState
 from claude_mpm.core.logger import get_logger
 
+# Protocol imports for type checking without circular dependencies
+if TYPE_CHECKING:
+    from claude_mpm.core.protocols import ClaudeRunnerProtocol
+else:
+    # At runtime, accept any object with matching interface
+    ClaudeRunnerProtocol = Any
+
 
 class InteractiveSession:
     """
@@ -26,16 +41,17 @@ class InteractiveSession:
     and makes testing easier while preserving all original functionality.
     """
 
-    def __init__(self, runner):
+    def __init__(self, runner: "ClaudeRunnerProtocol"):
         """Initialize interactive session handler.
 
         Args:
-            runner: ClaudeRunner instance with all necessary services
+            runner: ClaudeRunner instance (or any object matching ClaudeRunnerProtocol)
+                    with all necessary services
         """
-        self.runner = runner
+        self.runner: ClaudeRunnerProtocol = 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.
@@ -83,8 +99,8 @@ class InteractiveSession:
                     self.logger.warning(f"WebSocket initialization failed: {error}")
                     # Continue without WebSocket - not a fatal error
 
-            # Display welcome message
-            self._display_welcome_message()
+            # Banner now displayed in CLI startup - see startup_display.py
+            # Removed duplicate _display_welcome_message() to consolidate with main banner
 
             # Log session start
             if self.runner.project_logger:
@@ -178,7 +194,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 +242,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 +295,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
 
@@ -290,7 +307,12 @@ class InteractiveSession:
             return False, f"Unexpected error with Socket.IO: {e}"
 
     def _display_welcome_message(self) -> None:
-        """Display the interactive session welcome message."""
+        """Display the interactive session welcome message.
+
+        DEPRECATED: This method is kept for backward compatibility with tests.
+        The main banner is now displayed in startup_display.py during CLI startup.
+        This consolidated approach prevents duplicate banners.
+        """
         version_str = self.runner._get_version()
 
         # Get output style status
@@ -310,6 +332,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 +394,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,12 +402,82 @@ class InteractiveSession:
             self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
             cmd.extend(self.runner.claude_args)
 
-        # Add system instructions
-        from claude_mpm.core.claude_runner import create_simple_context
+        # 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 with file-based caching
+        from claude_mpm.core.system_context import create_simple_context
+        from claude_mpm.services.instructions.instruction_cache_service import (
+            InstructionCacheService,
+        )
 
         system_prompt = self.runner._create_system_prompt()
         if system_prompt and system_prompt != create_simple_context():
-            cmd.extend(["--append-system-prompt", system_prompt])
+            # Try to use cached instruction file for better performance
+            try:
+                # Initialize cache service with project root
+                if "CLAUDE_MPM_USER_PWD" in os.environ:
+                    project_root = Path(os.environ["CLAUDE_MPM_USER_PWD"])
+                else:
+                    project_root = Path.cwd()
+
+                # Instruction Caching (1M-446)
+                # Cache assembled instructions to file to avoid ARG_MAX limits on Linux/Windows.
+                # - Linux: 128 KB limit, instructions are ~152 KB (exceeds by 19.1%)
+                # - Windows: 32 KB limit (exceeds by 476%)
+                # Cache updates only when content hash changes (hash-based invalidation).
+                # Fallback to inline instruction if cache fails (graceful degradation).
+                cache_service = InstructionCacheService(project_root=project_root)
+
+                # Update cache with assembled instruction content
+                cache_result = cache_service.update_cache(
+                    instruction_content=system_prompt
+                )
+
+                # Use cache file if available
+                if (
+                    cache_result.get("updated")
+                    or cache_service.get_cache_path().exists()
+                ):
+                    cache_file = cache_service.get_cache_path()
+
+                    # Log cache operation
+                    if cache_result.get("updated"):
+                        self.logger.info(
+                            f"Instruction cache updated: {cache_result.get('reason', 'unknown')}"
+                        )
+                        self.logger.debug(
+                            f"Cache hash: {cache_result.get('content_hash', 'N/A')[:8]}..."
+                        )
+                        self.logger.debug(
+                            f"Cache size: {cache_result.get('content_size_kb', 'N/A')} KB"
+                        )
+                    else:
+                        self.logger.debug(
+                            f"Using cached instructions: {cache_result.get('reason', 'unknown')}"
+                        )
+
+                    # Use file-based loading for better performance
+                    cmd.extend(["--system-prompt-file", str(cache_file)])
+                    self.logger.info(
+                        f"✓ Using file-based instruction loading: {cache_file}"
+                    )
+                else:
+                    # Fallback to inline if cache file doesn't exist
+                    self.logger.warning(
+                        "Cache file not available, falling back to inline instruction"
+                    )
+                    cmd.extend(["--append-system-prompt", system_prompt])
+
+            except Exception as e:
+                # Graceful fallback - cache failures don't break deployment
+                self.logger.warning(f"Failed to cache instructions, using inline: {e}")
+                cmd.extend(["--append-system-prompt", system_prompt])
 
         # Final command verification
         # self.logger.info(f"Final Claude command built: {' '.join(cmd)}")
@@ -392,10 +487,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 +577,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 +618,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