claude-mpm 5.4.22__py3-none-any.whl → 5.6.34__py3-none-any.whl

claude_mpm/services/event_log.py

@@ -0,0 +1,325 @@
+"""Event Log Service for persistent event storage.
+
+WHY this is needed:
+- Decouple event producers from consumers
+- Persist events for later processing (e.g., autotodos CLI)
+- Enable event-driven architecture patterns
+- Provide audit trail of system events
+
+DESIGN DECISION: Simple JSON file storage because:
+- Human-readable and inspectable
+- No additional database dependencies
+- Fast for small event volumes
+- Easy to clear and manage
+- Follows existing pattern (hook_error_memory)
+"""
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+
+from ..core.logger import get_logger
+
+# Event status types
+EventStatus = Literal["pending", "resolved", "archived"]
+
+# Max message length to prevent file bloat
+MAX_MESSAGE_LENGTH = 2000
+
+
+class EventLog:
+    """Persistent event log with simple JSON storage.
+
+    WHY this design:
+    - Store events with timestamp, type, payload, status
+    - Support filtering by status and event type
+    - Prevent file bloat with message truncation
+    - Enable mark-as-resolved workflow
+    - Keep it simple - no complex queries needed
+    """
+
+    def __init__(self, log_file: Optional[Path] = None):
+        """Initialize event log.
+
+        Args:
+            log_file: Path to event log file (default: .claude-mpm/event_log.json)
+        """
+        self.logger = get_logger("event_log")
+
+        # Use default location if not specified
+        if log_file is None:
+            log_file = Path.cwd() / ".claude-mpm" / "event_log.json"
+
+        self.log_file = log_file
+        self.events: List[Dict[str, Any]] = self._load_events()
+
+    def _load_events(self) -> List[Dict[str, Any]]:
+        """Load events from disk.
+
+        Returns:
+            List of event records
+        """
+        if not self.log_file.exists():
+            return []
+
+        try:
+            content = self.log_file.read_text()
+            if not content.strip():
+                return []
+            data = json.loads(content)
+
+            # Validate structure
+            if not isinstance(data, list):
+                self.logger.warning("Event log is not a list, resetting")
+                return []
+
+            return data
+        except json.JSONDecodeError as e:
+            self.logger.warning(f"Failed to parse event log: {e}, resetting")
+            return []
+        except Exception as e:
+            self.logger.error(f"Error loading event log: {e}")
+            return []
+
+    def _save_events(self):
+        """Persist events to disk."""
+        try:
+            # Ensure directory exists
+            self.log_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write with pretty formatting for human readability
+            self.log_file.write_text(json.dumps(self.events, indent=2))
+        except Exception as e:
+            self.logger.error(f"Failed to save event log: {e}")
+
+    def _truncate_message(self, message: str) -> str:
+        """Truncate message to prevent file bloat.
+
+        Args:
+            message: Message to truncate
+
+        Returns:
+            Truncated message with ellipsis if needed
+        """
+        if len(message) <= MAX_MESSAGE_LENGTH:
+            return message
+
+        return message[:MAX_MESSAGE_LENGTH] + "... (truncated)"
+
+    def append_event(
+        self,
+        event_type: str,
+        payload: Dict[str, Any],
+        status: EventStatus = "pending",
+    ) -> str:
+        """Append a new event to the log.
+
+        Args:
+            event_type: Type of event (e.g., "autotodo.error", "hook.error")
+            payload: Event data (will be truncated if too large)
+            status: Event status (default: "pending")
+
+        Returns:
+            Event ID (timestamp-based for simplicity)
+        """
+        # Truncate any message fields in payload
+        truncated_payload = payload.copy()
+        if "message" in truncated_payload:
+            truncated_payload["message"] = self._truncate_message(
+                str(truncated_payload["message"])
+            )
+        if "full_message" in truncated_payload:
+            truncated_payload["full_message"] = self._truncate_message(
+                str(truncated_payload["full_message"])
+            )
+
+        # Create event record
+        timestamp = datetime.now(timezone.utc).isoformat()
+        event = {
+            "id": timestamp,  # Use timestamp as ID for simplicity
+            "timestamp": timestamp,
+            "event_type": event_type,
+            "payload": truncated_payload,
+            "status": status,
+        }
+
+        # Append and save
+        self.events.append(event)
+        self._save_events()
+
+        self.logger.debug(f"Appended event: {event_type} (status: {status})")
+        return timestamp
+
+    def list_events(
+        self,
+        event_type: Optional[str] = None,
+        status: Optional[EventStatus] = None,
+        limit: Optional[int] = None,
+    ) -> List[Dict[str, Any]]:
+        """List events with optional filtering.
+
+        Args:
+            event_type: Filter by event type (e.g., "autotodo.error")
+            status: Filter by status (e.g., "pending")
+            limit: Maximum number of events to return (most recent first)
+
+        Returns:
+            List of matching events
+        """
+        # Filter events
+        filtered = self.events
+
+        if event_type:
+            filtered = [e for e in filtered if e["event_type"] == event_type]
+
+        if status:
+            filtered = [e for e in filtered if e["status"] == status]
+
+        # Sort by timestamp (most recent first)
+        filtered = sorted(filtered, key=lambda e: e["timestamp"], reverse=True)
+
+        # Apply limit
+        if limit:
+            filtered = filtered[:limit]
+
+        return filtered
+
+    def mark_resolved(self, event_id: str) -> bool:
+        """Mark an event as resolved.
+
+        Args:
+            event_id: Event ID (timestamp)
+
+        Returns:
+            True if event was found and updated
+        """
+        for event in self.events:
+            if event["id"] == event_id:
+                event["status"] = "resolved"
+                event["resolved_at"] = datetime.now(timezone.utc).isoformat()
+                self._save_events()
+                self.logger.debug(f"Marked event resolved: {event_id}")
+                return True
+
+        return False
+
+    def mark_all_resolved(
+        self, event_type: Optional[str] = None, status: EventStatus = "pending"
+    ) -> int:
+        """Mark multiple events as resolved.
+
+        Args:
+            event_type: Optional filter by event type
+            status: Filter by current status (default: "pending")
+
+        Returns:
+            Number of events marked as resolved
+        """
+        count = 0
+        now = datetime.now(timezone.utc).isoformat()
+
+        for event in self.events:
+            # Check filters
+            if event["status"] != status:
+                continue
+            if event_type and event["event_type"] != event_type:
+                continue
+
+            # Mark resolved
+            event["status"] = "resolved"
+            event["resolved_at"] = now
+            count += 1
+
+        if count > 0:
+            self._save_events()
+            self.logger.debug(f"Marked {count} events as resolved")
+
+        return count
+
+    def clear_resolved(self, older_than_days: Optional[int] = None) -> int:
+        """Remove resolved events from the log.
+
+        Args:
+            older_than_days: Only clear events older than N days
+
+        Returns:
+            Number of events removed
+        """
+        if older_than_days:
+            # Calculate cutoff timestamp
+            from datetime import timedelta
+
+            cutoff = datetime.now(timezone.utc) - timedelta(days=older_than_days)
+            cutoff_iso = cutoff.isoformat()
+
+            # Keep events that are NOT resolved OR are newer than cutoff
+            before_count = len(self.events)
+            self.events = [
+                e
+                for e in self.events
+                if e["status"] != "resolved" or e.get("resolved_at", "") > cutoff_iso
+            ]
+            removed = before_count - len(self.events)
+        else:
+            # Remove all resolved events
+            before_count = len(self.events)
+            self.events = [e for e in self.events if e["status"] != "resolved"]
+            removed = before_count - len(self.events)
+
+        if removed > 0:
+            self._save_events()
+            self.logger.debug(f"Cleared {removed} resolved events")
+
+        return removed
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get event log statistics.
+
+        Returns:
+            Dictionary with event counts by status and type
+        """
+        stats = {
+            "total_events": len(self.events),
+            "by_status": {"pending": 0, "resolved": 0, "archived": 0},
+            "by_type": {},
+            "log_file": str(self.log_file),
+        }
+
+        for event in self.events:
+            # Count by status
+            status = event["status"]
+            stats["by_status"][status] = stats["by_status"].get(status, 0) + 1
+
+            # Count by type
+            event_type = event["event_type"]
+            stats["by_type"][event_type] = stats["by_type"].get(event_type, 0) + 1
+
+        return stats
+
+
+# Global instance
+_event_log: Optional[EventLog] = None
+
+
+def get_event_log(log_file: Optional[Path] = None) -> EventLog:
+    """Get the global event log instance.
+
+    Args:
+        log_file: Optional custom log file path
+
+    Returns:
+        EventLog instance
+
+    Note:
+        If log_file is provided and differs from the current instance,
+        a new EventLog is created and replaces the global instance.
+        This allows hooks to use project-specific event logs.
+    """
+    global _event_log
+    if _event_log is None:
+        _event_log = EventLog(log_file)
+    elif log_file is not None and _event_log.log_file != log_file:
+        # Create new instance if log file differs from current
+        _event_log = EventLog(log_file)
+    return _event_log

claude_mpm/services/git/git_operations_service.py

@@ -12,10 +12,10 @@ Design Decisions:
 
 Example:
     >>> service = GitOperationsService()
-    >>> success = service.create_branch(Path("~/.claude-mpm/cache/remote-agents"), "improve/research-memory")
+    >>> success = service.create_branch(Path("~/.claude-mpm/cache/agents"), "improve/research-memory")
     >>> if success:
-    ...     service.stage_files(Path("~/.claude-mpm/cache/remote-agents"), ["agents/research.md"])
-    ...     service.commit(Path("~/.claude-mpm/cache/remote-agents"), "feat: improve research agent memory handling")
+    ...     service.stage_files(Path("~/.claude-mpm/cache/agents"), ["agents/research.md"])
+    ...     service.commit(Path("~/.claude-mpm/cache/agents"), "feat: improve research agent memory handling")
 """
 
 import logging
@@ -68,7 +68,7 @@ class GitOperationsService:
 
         Example:
             >>> service = GitOperationsService()
-            >>> service.is_git_repo(Path("~/.claude-mpm/cache/remote-agents"))
+            >>> service.is_git_repo(Path("~/.claude-mpm/cache/agents"))
             True
         """
         try:
@@ -150,7 +150,7 @@ class GitOperationsService:
         Example:
             >>> service = GitOperationsService()
             >>> service.create_and_checkout_branch(
-            ...     Path("~/.claude-mpm/cache/remote-agents"),
+            ...     Path("~/.claude-mpm/cache/agents"),
             ...     "improve/research-memory",
             ...     "main"
             ... )
@@ -245,7 +245,7 @@ class GitOperationsService:
         Example:
             >>> service = GitOperationsService()
             >>> service.commit(
-            ...     Path("~/.claude-mpm/cache/remote-agents"),
+            ...     Path("~/.claude-mpm/cache/agents"),
             ...     "feat(agent): improve research agent memory handling\\n\\n- Add hard limit of 5 files"
             ... )
             True
@@ -289,7 +289,7 @@ class GitOperationsService:
 
         Example:
             >>> service = GitOperationsService()
-            >>> service.push(Path("~/.claude-mpm/cache/remote-agents"), "improve/research-memory")
+            >>> service.push(Path("~/.claude-mpm/cache/agents"), "improve/research-memory")
             True
         """
         self._validate_repo(repo_path)
@@ -489,7 +489,7 @@ class GitOperationsService:
 
         Example:
             >>> service = GitOperationsService()
-            >>> valid, msg = service.validate_repo(Path("~/.claude-mpm/cache/remote-agents"))
+            >>> valid, msg = service.validate_repo(Path("~/.claude-mpm/cache/agents"))
             >>> if not valid:
             ...     print(f"Repository invalid: {msg}")
         """

claude_mpm/services/hook_installer_service.py

@@ -20,8 +20,13 @@ class HookInstallerService:
     def __init__(self):
         """Initialize the hook installer service."""
         self.logger = get_logger(__name__)
-        self.claude_dir = Path.home() / ".claude"
-        self.settings_file = self.claude_dir / "settings.json"
+        # Use project-level paths, NEVER global ~/.claude/settings.json
+        # This ensures hooks are scoped to the current project only
+        self.project_root = Path.cwd()
+        self.claude_dir = self.project_root / ".claude"
+        # Use settings.local.json for project-level hook settings
+        # Claude Code reads project-level settings from .claude/settings.local.json
+        self.settings_file = self.claude_dir / "settings.local.json"
 
     def is_hooks_configured(self) -> bool:
         """Check if hooks are configured in Claude settings.
@@ -299,16 +304,77 @@ class HookInstallerService:
                 self.logger.debug("Creating new Claude settings")
 
             # Configure hooks
-            hook_config = {
-                "matcher": "*",
-                "hooks": [{"type": "command", "command": hook_script_path}],
-            }
+            new_hook_command = {"type": "command", "command": hook_script_path}
 
             # Update settings
             if "hooks" not in settings:
                 settings["hooks"] = {}
 
-            # Add hooks for all event types
+            def is_our_hook(cmd: Dict[str, Any]) -> bool:
+                """Check if a hook command belongs to claude-mpm."""
+                if cmd.get("type") != "command":
+                    return False
+                command = cmd.get("command", "")
+                return (
+                    "hook_wrapper.sh" in command
+                    or "claude-hook-handler.sh" in command
+                    or "claude-mpm" in command
+                )
+
+            def merge_hooks_for_event(
+                existing_hooks: list, hook_command: Dict[str, Any]
+            ) -> list:
+                """Merge new hook command into existing hooks without duplication.
+
+                Args:
+                    existing_hooks: Current hooks configuration for an event type
+                    hook_command: The claude-mpm hook command to add
+
+                Returns:
+                    Updated hooks list with our hook merged in
+                """
+                # Check if our hook already exists in any existing hook config
+                our_hook_exists = False
+
+                for hook_config in existing_hooks:
+                    if "hooks" in hook_config and isinstance(
+                        hook_config["hooks"], list
+                    ):
+                        for hook in hook_config["hooks"]:
+                            if is_our_hook(hook):
+                                # Update existing hook command path (in case it changed)
+                                hook["command"] = hook_command["command"]
+                                our_hook_exists = True
+                                break
+                    if our_hook_exists:
+                        break
+
+                if our_hook_exists:
+                    # Our hook already exists, just return the updated list
+                    return existing_hooks
+
+                # Our hook doesn't exist - need to add it
+                # Strategy: Add our hook to the first "*" matcher config, or create new
+                added = False
+
+                for hook_config in existing_hooks:
+                    # Check if this config has matcher: "*"
+                    if hook_config.get("matcher") == "*":
+                        # Add our hook to this config's hooks array
+                        if "hooks" not in hook_config:
+                            hook_config["hooks"] = []
+                        hook_config["hooks"].append(hook_command)
+                        added = True
+                        break
+
+                if not added:
+                    # No suitable config found, create a new one
+                    new_config = {"matcher": "*", "hooks": [hook_command]}
+                    existing_hooks.append(new_config)
+
+                return existing_hooks
+
+            # Add hooks for all event types - MERGE instead of overwrite
             for event_type in [
                 "UserPromptSubmit",
                 "PreToolUse",
@@ -316,7 +382,10 @@ class HookInstallerService:
                 "Stop",
                 "SubagentStop",
             ]:
-                settings["hooks"][event_type] = [hook_config]
+                existing = settings["hooks"].get(event_type, [])
+                settings["hooks"][event_type] = merge_hooks_for_event(
+                    existing, new_hook_command
+                )
 
             # Write settings
             with self.settings_file.open("w") as f:

claude_mpm/services/infrastructure/__init__.py

@@ -11,8 +11,10 @@ Services:
 - LoggingService: Centralized logging with structured output
 - HealthMonitor: System health monitoring and alerting
 - MemoryGuardian: Memory monitoring and process restart management
+- ContextUsageTracker: Token usage tracking across hook invocations
 """
 
+from .context_usage_tracker import ContextUsageState, ContextUsageTracker
 from .logging import LoggingService
 from .monitoring import (
     AdvancedHealthMonitor,
@@ -36,6 +38,8 @@ except ImportError:
 
 __all__ = [
     "AdvancedHealthMonitor",  # For SocketIO server monitoring
+    "ContextUsageState",
+    "ContextUsageTracker",
     "LoggingService",
     # New service-based monitoring API
     "MonitoringAggregatorService",