claude-mpm 4.1.8__py3-none-any.whl → 4.1.10__py3-none-any.whl

claude_mpm/core/framework_loader.py

@@ -1,6 +1,10 @@
 """Framework loader for Claude MPM."""
 
+import getpass
+import locale
 import logging
+import os
+import platform
 import time
 from datetime import datetime
 from pathlib import Path
@@ -995,11 +999,8 @@ class FrameworkLoader:
             # Add dynamic agent capabilities section
             instructions += self._generate_agent_capabilities_section()
 
-            # Add current date for temporal awareness
-            instructions += f"\n\n## Temporal Context\n**Today's Date**: {datetime.now().strftime('%Y-%m-%d')}\n"
-            instructions += (
-                "Apply date awareness to all time-sensitive tasks and decisions.\n"
-            )
+            # Add enhanced temporal and user context for better awareness
+            instructions += self._generate_temporal_user_context()
 
             # Add BASE_PM.md framework requirements AFTER INSTRUCTIONS.md
             if self.framework_content.get("base_pm_instructions"):
@@ -1322,6 +1323,147 @@ Extract tickets from these patterns:
             self._agent_capabilities_cache_time = current_time
             return result
 
+    def _generate_temporal_user_context(self) -> str:
+        """Generate enhanced temporal and user context for better PM awareness.
+
+        Returns:
+            str: Formatted context string with datetime, user, and system information
+        """
+        context_lines = ["\n\n## Temporal & User Context\n"]
+
+        try:
+            # Get current datetime with timezone awareness
+            now = datetime.now()
+
+            # Try to get timezone info - fallback to UTC offset if timezone name not available
+            try:
+                import time as time_module
+
+                if hasattr(time_module, "tzname"):
+                    tz_name = time_module.tzname[time_module.daylight]
+                    tz_offset = time_module.strftime("%z")
+                    if tz_offset:
+                        # Format UTC offset properly (e.g., -0800 to -08:00)
+                        tz_offset = (
+                            f"{tz_offset[:3]}:{tz_offset[3:]}"
+                            if len(tz_offset) >= 4
+                            else tz_offset
+                        )
+                        tz_info = f"{tz_name} (UTC{tz_offset})"
+                    else:
+                        tz_info = tz_name
+                else:
+                    tz_info = "Local Time"
+            except Exception:
+                tz_info = "Local Time"
+
+            # Format datetime components
+            date_str = now.strftime("%Y-%m-%d")
+            time_str = now.strftime("%H:%M:%S")
+            day_name = now.strftime("%A")
+
+            context_lines.append(
+                f"**Current DateTime**: {date_str} {time_str} {tz_info}\n"
+            )
+            context_lines.append(f"**Day**: {day_name}\n")
+
+        except Exception as e:
+            # Fallback to basic date if enhanced datetime fails
+            self.logger.debug(f"Error generating enhanced datetime context: {e}")
+            context_lines.append(
+                f"**Today's Date**: {datetime.now().strftime('%Y-%m-%d')}\n"
+            )
+
+        try:
+            # Get user information with safe fallbacks
+            username = None
+
+            # Try multiple methods to get username
+            methods = [
+                lambda: os.environ.get("USER"),
+                lambda: os.environ.get("USERNAME"),  # Windows fallback
+                lambda: getpass.getuser(),
+            ]
+
+            for method in methods:
+                try:
+                    username = method()
+                    if username:
+                        break
+                except Exception:
+                    continue
+
+            if username:
+                context_lines.append(f"**User**: {username}\n")
+
+                # Add home directory if available
+                try:
+                    home_dir = os.path.expanduser("~")
+                    if home_dir and home_dir != "~":
+                        context_lines.append(f"**Home Directory**: {home_dir}\n")
+                except Exception:
+                    pass
+
+        except Exception as e:
+            # User detection is optional, don't fail
+            self.logger.debug(f"Could not detect user information: {e}")
+
+        try:
+            # Get system information
+            system_info = platform.system()
+            if system_info:
+                # Enhance system name for common platforms
+                system_names = {
+                    "Darwin": "Darwin (macOS)",
+                    "Linux": "Linux",
+                    "Windows": "Windows",
+                }
+                system_display = system_names.get(system_info, system_info)
+                context_lines.append(f"**System**: {system_display}\n")
+
+                # Add platform version if available
+                try:
+                    platform_version = platform.release()
+                    if platform_version:
+                        context_lines.append(
+                            f"**System Version**: {platform_version}\n"
+                        )
+                except Exception:
+                    pass
+
+        except Exception as e:
+            # System info is optional
+            self.logger.debug(f"Could not detect system information: {e}")
+
+        try:
+            # Add current working directory
+            cwd = os.getcwd()
+            if cwd:
+                context_lines.append(f"**Working Directory**: {cwd}\n")
+        except Exception:
+            pass
+
+        try:
+            # Add locale information if available
+            current_locale = locale.getlocale()
+            if current_locale and current_locale[0]:
+                context_lines.append(f"**Locale**: {current_locale[0]}\n")
+        except Exception:
+            # Locale is optional
+            pass
+
+        # Add instruction for applying context
+        context_lines.append(
+            "\nApply temporal and user awareness to all tasks, "
+            "decisions, and interactions.\n"
+        )
+        context_lines.append(
+            "Use this context for personalized responses and "
+            "time-sensitive operations.\n"
+        )
+
+        return "".join(context_lines)
+
     def _parse_agent_metadata(self, agent_file: Path) -> Optional[Dict[str, Any]]:
         """Parse agent metadata from deployed agent file.
         Uses caching based on file path and modification time.
@@ -1333,7 +1475,7 @@ Extract tickets from these patterns:
             # Check cache based on file path and modification time
             cache_key = str(agent_file)
             file_mtime = agent_file.stat().st_mtime
-            current_time = time.time()
+            time.time()
 
             # Try to get from cache first
             cached_result = self._cache_manager.get_agent_metadata(cache_key)

claude_mpm/core/log_manager.py

@@ -101,9 +101,7 @@ class LogManager:
         }
 
         # Base directories
-        self.base_log_dir = Path(
-            logging_config.get("base_directory", ".claude-mpm/logs")
-        )
+        self.base_log_dir = Path(logging_config.get("base_directory", "logs"))
         if not self.base_log_dir.is_absolute():
             self.base_log_dir = Path.cwd() / self.base_log_dir
 
@@ -352,27 +350,32 @@ class LogManager:
         """
         One-time migration to move existing MPM logs to new subdirectory.
 
-        Moves mpm_*.log files from .claude-mpm/logs/ to .claude-mpm/logs/mpm/
+        Moves mpm_*.log files from .claude-mpm/logs/ to logs/mpm/
         """
         try:
-            old_location = self.base_log_dir
+            # Check both old possible locations
+            old_locations = [
+                Path.cwd() / ".claude-mpm" / "logs",  # Old default location
+                self.base_log_dir,  # Current base location (logs/)
+            ]
             new_location = self.base_log_dir / "mpm"
 
-            # Only proceed if old location exists and has MPM logs
-            if not old_location.exists():
-                return
-
-            # Find all MPM log files in the old location
-            mpm_logs = list(old_location.glob("mpm_*.log"))
+            # Collect all MPM logs from all old locations
+            all_mpm_logs = []
+            for old_location in old_locations:
+                if old_location.exists() and old_location != new_location:
+                    # Find all MPM log files in this location
+                    mpm_logs = list(old_location.glob("mpm_*.log"))
+                    all_mpm_logs.extend(mpm_logs)
 
-            if not mpm_logs:
+            if not all_mpm_logs:
                 return  # No logs to migrate
 
             # Ensure new directory exists
             new_location.mkdir(parents=True, exist_ok=True)
 
             migrated_count = 0
-            for log_file in mpm_logs:
+            for log_file in all_mpm_logs:
                 try:
                     # Move file to new location
                     new_path = new_location / log_file.name

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 / ".claude-mpm" / "logs"
+                log_dir = deployment_root / "logs" / "mpm"
 
             log_dir.mkdir(parents=True, exist_ok=True)
 

claude_mpm/core/unified_agent_registry.py

@@ -455,7 +455,7 @@ class UnifiedAgentRegistry:
         """Apply tier precedence rules to resolve conflicts."""
         # Group agents by their actual name (without tier suffix)
         agent_groups = {}
-        for registry_key, metadata in self.registry.items():
+        for _registry_key, metadata in self.registry.items():
             # Extract the actual agent name (registry_key is "name_tier")
             agent_name = metadata.name  # Use the actual name from metadata
             if agent_name not in agent_groups:

claude_mpm/dashboard/.claude-mpm/socketio-instances.json

@@ -0,0 +1 @@
+{}

claude_mpm/dashboard/analysis_runner.py

@@ -0,0 +1,428 @@
+#!/usr/bin/env python3
+"""
+Code Analysis Runner for Dashboard
+===================================
+
+WHY: Manages subprocess execution of code analysis, streaming results to
+Socket.IO clients in real-time while handling cancellation and error recovery.
+
+DESIGN DECISIONS:
+- Use subprocess for isolation and cancellation support
+- Stream output line-by-line for real-time updates
+- Queue multiple analysis requests
+- Handle process lifecycle management
+- Convert analyzer events to Socket.IO events
+"""
+
+import json
+import os
+import subprocess
+import sys
+import threading
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from queue import Queue
+from typing import Any, Dict, List, Optional
+
+from ..core.logging_config import get_logger
+
+
+@dataclass
+class AnalysisRequest:
+    """Represents a code analysis request."""
+
+    request_id: str
+    path: str
+    languages: Optional[List[str]] = None
+    max_depth: Optional[int] = None
+    ignore_patterns: Optional[List[str]] = None
+    timestamp: datetime = None
+
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = datetime.utcnow()
+
+
+class CodeAnalysisRunner:
+    """Manages code analysis subprocess execution for the dashboard.
+
+    WHY: Provides isolation between the dashboard server and analysis process,
+    allowing for cancellation, resource limits, and crash recovery.
+    """
+
+    def __init__(self, socketio_server):
+        """Initialize the analysis runner.
+
+        Args:
+            socketio_server: SocketIOServer instance for broadcasting events
+        """
+        self.logger = get_logger(__name__)
+        self.server = socketio_server
+        self.current_process = None
+        self.current_request = None
+        self.request_queue = Queue()
+        self.running = False
+        self.worker_thread = None
+        self.cancel_event = threading.Event()
+
+        # Statistics
+        self.stats = {
+            "analyses_started": 0,
+            "analyses_completed": 0,
+            "analyses_cancelled": 0,
+            "analyses_failed": 0,
+            "total_files": 0,
+            "total_nodes": 0,
+        }
+
+    def start(self):
+        """Start the analysis runner worker thread."""
+        if self.running:
+            return
+
+        self.running = True
+        self.cancel_event.clear()
+        self.worker_thread = threading.Thread(target=self._worker_loop, daemon=True)
+        self.worker_thread.start()
+        self.logger.info("Code analysis runner started")
+
+    def stop(self):
+        """Stop the analysis runner and cleanup."""
+        self.running = False
+        self.cancel_current()
+
+        # Add sentinel to queue to wake up worker
+        self.request_queue.put(None)
+
+        if self.worker_thread:
+            self.worker_thread.join(timeout=5)
+
+        self.logger.info("Code analysis runner stopped")
+
+    def request_analysis(
+        self,
+        request_id: str,
+        path: str,
+        languages: Optional[List[str]] = None,
+        max_depth: Optional[int] = None,
+        ignore_patterns: Optional[List[str]] = None,
+    ) -> bool:
+        """Queue a new analysis request.
+
+        Args:
+            request_id: Unique request identifier
+            path: Directory path to analyze
+            languages: Optional list of languages to filter
+            max_depth: Optional maximum directory depth
+            ignore_patterns: Optional list of patterns to ignore
+
+        Returns:
+            True if request was queued successfully
+        """
+        # Validate path
+        analysis_path = Path(path).resolve()
+        if not analysis_path.exists():
+            self._emit_error(request_id, f"Path does not exist: {path}")
+            return False
+
+        if not analysis_path.is_dir():
+            self._emit_error(request_id, f"Path is not a directory: {path}")
+            return False
+
+        # Create request
+        request = AnalysisRequest(
+            request_id=request_id,
+            path=str(analysis_path),
+            languages=languages,
+            max_depth=max_depth,
+            ignore_patterns=ignore_patterns,
+        )
+
+        # Queue request
+        self.request_queue.put(request)
+        self.logger.info(f"Queued analysis request {request_id} for {path}")
+
+        # Emit queued event
+        self._emit_event(
+            "code:analysis:queued",
+            {
+                "request_id": request_id,
+                "path": str(analysis_path),
+                "queue_size": self.request_queue.qsize(),
+            },
+        )
+
+        return True
+
+    def cancel_current(self):
+        """Cancel the currently running analysis."""
+        if self.current_process and self.current_process.poll() is None:
+            self.cancel_event.set()
+
+            # Try graceful termination first
+            self.current_process.terminate()
+            try:
+                self.current_process.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                # Force kill if needed
+                self.current_process.kill()
+                self.current_process.wait()
+
+            self.stats["analyses_cancelled"] += 1
+
+            if self.current_request:
+                self._emit_event(
+                    "code:analysis:cancelled",
+                    {
+                        "request_id": self.current_request.request_id,
+                        "path": self.current_request.path,
+                    },
+                )
+
+            self.logger.info("Cancelled current analysis")
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get current runner status.
+
+        Returns:
+            Dictionary with current status and statistics
+        """
+        return {
+            "running": self.running,
+            "current_request": (
+                asdict(self.current_request) if self.current_request else None
+            ),
+            "queue_size": self.request_queue.qsize(),
+            "stats": self.stats.copy(),
+        }
+
+    def _worker_loop(self):
+        """Worker thread loop for processing analysis requests."""
+        while self.running:
+            try:
+                # Get next request (blocking with timeout)
+                request = self.request_queue.get(timeout=1)
+
+                if request is None:  # Sentinel value
+                    break
+
+                # Reset cancel event
+                self.cancel_event.clear()
+
+                # Process request
+                self._process_request(request)
+
+            except Exception as e:
+                self.logger.error(f"Error in worker loop: {e}")
+
+    def _process_request(self, request: AnalysisRequest):
+        """Process a single analysis request.
+
+        Args:
+            request: The analysis request to process
+        """
+        self.current_request = request
+        self.stats["analyses_started"] += 1
+
+        try:
+            # Emit start event
+            self._emit_event(
+                "code:analysis:start",
+                {
+                    "request_id": request.request_id,
+                    "path": request.path,
+                    "languages": request.languages,
+                    "timestamp": request.timestamp.isoformat(),
+                },
+            )
+
+            # Build command
+            cmd = self._build_command(request)
+
+            # Start subprocess
+            self.current_process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+                env=self._get_subprocess_env(),
+            )
+
+            # Process output
+            self._process_output(request)
+
+            # Wait for completion
+            return_code = self.current_process.wait()
+
+            if self.cancel_event.is_set():
+                # Analysis was cancelled
+                pass  # Event already emitted in cancel_current
+            elif return_code == 0:
+                # Success
+                self.stats["analyses_completed"] += 1
+                self._emit_event(
+                    "code:analysis:complete",
+                    {
+                        "request_id": request.request_id,
+                        "path": request.path,
+                        "stats": {
+                            "total_files": self.stats["total_files"],
+                            "total_nodes": self.stats["total_nodes"],
+                        },
+                    },
+                )
+            else:
+                # Failure
+                self.stats["analyses_failed"] += 1
+                stderr = (
+                    self.current_process.stderr.read()
+                    if self.current_process.stderr
+                    else ""
+                )
+                self._emit_error(
+                    request.request_id,
+                    f"Analysis failed with code {return_code}: {stderr}",
+                )
+
+        except Exception as e:
+            self.logger.error(f"Error processing request {request.request_id}: {e}")
+            self.stats["analyses_failed"] += 1
+            self._emit_error(request.request_id, str(e))
+
+        finally:
+            self.current_process = None
+            self.current_request = None
+
+    def _build_command(self, request: AnalysisRequest) -> List[str]:
+        """Build the subprocess command for analysis.
+
+        Args:
+            request: The analysis request
+
+        Returns:
+            Command list for subprocess.Popen
+        """
+        # Get Python executable
+        python_exe = sys.executable
+
+        # Build command - use the tools module as a runnable module
+        cmd = [
+            python_exe,
+            "-m",
+            "claude_mpm.tools",
+            "--path",
+            request.path,
+            "--emit-events",
+            "--output-format",
+            "json-stream",
+        ]
+
+        # Add optional parameters
+        if request.languages:
+            cmd.extend(["--languages", ",".join(request.languages)])
+
+        if request.max_depth:
+            cmd.extend(["--max-depth", str(request.max_depth)])
+
+        if request.ignore_patterns:
+            for pattern in request.ignore_patterns:
+                cmd.extend(["--ignore", pattern])
+
+        return cmd
+
+    def _get_subprocess_env(self) -> Dict[str, str]:
+        """Get environment variables for subprocess.
+
+        Returns:
+            Environment dictionary for subprocess
+        """
+        env = os.environ.copy()
+
+        # Ensure Socket.IO URL is set for event emission
+        env["SOCKETIO_URL"] = f"http://localhost:{self.server.port}"
+
+        # Set Python path to include our modules
+        python_path = env.get("PYTHONPATH", "")
+        src_path = str(Path(__file__).parent.parent.parent)
+        if src_path not in python_path:
+            env["PYTHONPATH"] = f"{src_path}:{python_path}" if python_path else src_path
+
+        return env
+
+    def _process_output(self, request: AnalysisRequest):
+        """Process subprocess output and emit events.
+
+        Args:
+            request: The current analysis request
+        """
+        if not self.current_process:
+            return
+
+        # Read output line by line
+        for line in iter(self.current_process.stdout.readline, ""):
+            if self.cancel_event.is_set():
+                break
+
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                # Parse JSON event
+                event = json.loads(line)
+
+                # Route event to appropriate handler
+                event_type = event.get("type")
+                event_data = event.get("data", {})
+
+                # Add request ID to event data
+                event_data["request_id"] = request.request_id
+
+                # Update statistics based on event type
+                if event_type == "code:file:complete":
+                    self.stats["total_files"] += 1
+                elif event_type == "code:node:found":
+                    self.stats["total_nodes"] += 1
+
+                # Emit to Socket.IO clients
+                self._emit_event(event_type, event_data)
+
+            except json.JSONDecodeError:
+                # Not JSON, treat as log message
+                self.logger.debug(f"Analyzer output: {line}")
+            except Exception as e:
+                self.logger.warning(f"Error processing analyzer output: {e}")
+
+    def _emit_event(self, event_type: str, data: Dict[str, Any]):
+        """Emit an event to Socket.IO clients.
+
+        Args:
+            event_type: Type of event
+            data: Event data
+        """
+        if self.server:
+            # Add timestamp if not present
+            if "timestamp" not in data:
+                data["timestamp"] = datetime.utcnow().isoformat()
+
+            # Broadcast to all clients
+            self.server.broadcast_event(event_type, data)
+
+    def _emit_error(self, request_id: str, message: str):
+        """Emit an error event.
+
+        Args:
+            request_id: Request that caused the error
+            message: Error message
+        """
+        self._emit_event(
+            "code:analysis:error",
+            {
+                "request_id": request_id,
+                "message": message,
+                "timestamp": datetime.utcnow().isoformat(),
+            },
+        )