claude-mpm 3.4.27__py3-none-any.whl → 3.5.1__py3-none-any.whl

claude_mpm/hooks/builtin/__init__.py

@@ -1 +0,0 @@
-"""Built-in hooks for claude-mpm."""

claude_mpm/hooks/builtin/logging_hook_example.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-"""
-Example logging hook for Claude MPM.
-
-This hook demonstrates how to capture and log all prompts and responses
-through the hook system, providing an alternative to built-in logging.
-"""
-
-import json
-import os
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, Any, Optional
-
-# Configure your logging directory
-LOG_DIR = Path.home() / ".claude-mpm-hook-logs"
-LOG_DIR.mkdir(exist_ok=True)
-
-
-def execute_pre_delegation_hook(agent: str, context: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Log task details before delegation.
-    
-    Args:
-        agent: The agent being invoked
-        context: Contains 'task' and other context data
-    
-    Returns:
-        Empty dict (no modifications)
-    """
-    timestamp = datetime.now().isoformat()
-    log_entry = {
-        "timestamp": timestamp,
-        "event": "pre_delegation",
-        "agent": agent,
-        "task": context.get("task", ""),
-        "context": context
-    }
-    
-    # Write to daily log file
-    log_file = LOG_DIR / f"delegations_{datetime.now().strftime('%Y%m%d')}.jsonl"
-    with open(log_file, 'a') as f:
-        f.write(json.dumps(log_entry) + '\n')
-    
-    return {}
-
-
-def execute_post_delegation_hook(agent: str, result: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Log complete prompt and response after delegation.
-    
-    Args:
-        agent: The agent that was invoked
-        result: Contains task, response, execution_time, tokens
-    
-    Returns:
-        Empty dict (no modifications)
-    """
-    timestamp = datetime.now().isoformat()
-    
-    # Extract data
-    task = result.get("task", "")
-    response = result.get("response", "")
-    execution_time = result.get("execution_time", 0)
-    tokens = result.get("tokens", 0)
-    
-    # Create detailed log entry
-    log_entry = {
-        "timestamp": timestamp,
-        "event": "post_delegation",
-        "agent": agent,
-        "task": task,
-        "response_length": len(response),
-        "execution_time": execution_time,
-        "tokens": tokens,
-        "success": not response.startswith("Error:"),
-        "response_preview": response[:500] + "..." if len(response) > 500 else response
-    }
-    
-    # Write to agent-specific log
-    agent_log_dir = LOG_DIR / "agents" / agent.lower()
-    agent_log_dir.mkdir(parents=True, exist_ok=True)
-    
-    log_file = agent_log_dir / f"{datetime.now().strftime('%Y%m%d')}.jsonl"
-    with open(log_file, 'a') as f:
-        f.write(json.dumps(log_entry) + '\n')
-    
-    # Save full prompt/response if needed
-    if os.environ.get("CLAUDE_MPM_HOOK_LOG_FULL", "").lower() == "true":
-        # Create unique filename
-        task_hash = str(hash(task))[-8:]
-        prompt_file = agent_log_dir / f"prompt_{timestamp}_{task_hash}.txt"
-        response_file = agent_log_dir / f"response_{timestamp}_{task_hash}.txt"
-        
-        # Note: We don't have access to the original prompt in post-delegation
-        # To capture prompts, you'd need to store them in pre-delegation
-        # and match them up using task hash or similar
-        
-        response_file.write_text(response)
-        
-        log_entry["response_file"] = str(response_file)
-    
-    return {}
-
-
-def execute_submit_hook(prompt: str, session_type: str) -> Dict[str, Any]:
-    """
-    Log user prompts at session start.
-    
-    Args:
-        prompt: The user's input prompt
-        session_type: Type of session (e.g., "subprocess")
-    
-    Returns:
-        Empty dict (no modifications)
-    """
-    timestamp = datetime.now().isoformat()
-    log_entry = {
-        "timestamp": timestamp,
-        "event": "user_submit",
-        "session_type": session_type,
-        "prompt": prompt,
-        "prompt_length": len(prompt)
-    }
-    
-    # Write to session log
-    log_file = LOG_DIR / f"sessions_{datetime.now().strftime('%Y%m%d')}.jsonl"
-    with open(log_file, 'a') as f:
-        f.write(json.dumps(log_entry) + '\n')
-    
-    print(f"[Logging Hook] Logged user prompt to {log_file}")
-    
-    return {}
-
-
-# Optional: Hook metadata for registration
-HOOK_METADATA = {
-    "name": "logging_hook",
-    "description": "Comprehensive logging of all prompts and responses",
-    "version": "1.0.0",
-    "author": "claude-mpm",
-    "events": ["pre_delegation", "post_delegation", "submit"],
-    "config": {
-        "log_dir": str(LOG_DIR),
-        "full_logging": os.environ.get("CLAUDE_MPM_HOOK_LOG_FULL", "false")
-    }
-}
-
-
-if __name__ == "__main__":
-    # Test the hook
-    print(f"Logging hook configured to write to: {LOG_DIR}")
-    print("Set CLAUDE_MPM_HOOK_LOG_FULL=true to save complete responses")
-    
-    # Example usage
-    execute_submit_hook("Test prompt", "test")
-    execute_pre_delegation_hook("Engineer", {"task": "Test task"})
-    execute_post_delegation_hook("Engineer", {
-        "task": "Test task",
-        "response": "Test response",
-        "execution_time": 1.5,
-        "tokens": 100
-    })
-    
-    print(f"\nCheck logs in: {LOG_DIR}")

claude_mpm/hooks/builtin/memory_hooks_example.py

@@ -1,67 +0,0 @@
-"""Example of how to register memory integration hooks.
-
-WHY: This demonstrates how to register the memory hooks with the HookService
-for automatic memory injection and learning extraction.
-"""
-
-from claude_mpm.hooks.memory_integration_hook import (
-    MemoryPreDelegationHook,
-    MemoryPostDelegationHook
-)
-from claude_mpm.services.hook_service import HookService
-from claude_mpm.core.config import Config
-
-
-def register_memory_hooks(hook_service: HookService, config: Config = None):
-    """Register memory integration hooks with the hook service.
-    
-    WHY: To enable automatic memory management, both hooks need to be
-    registered with appropriate priorities:
-    - Pre-hook runs early (priority 20) to inject memory into context
-    - Post-hook runs late (priority 80) to extract learnings after processing
-    
-    Args:
-        hook_service: The HookService instance to register with
-        config: Optional configuration (will create default if not provided)
-    """
-    config = config or Config()
-    
-    # Only register if memory system is enabled
-    if not config.get('memory.enabled', True):
-        return
-    
-    # Register pre-delegation hook for memory injection
-    pre_hook = MemoryPreDelegationHook(config)
-    hook_service.register_hook(pre_hook)
-    
-    # Register post-delegation hook for learning extraction
-    # Only if auto-learning is enabled
-    if config.get('memory.auto_learning', False):
-        post_hook = MemoryPostDelegationHook(config)
-        hook_service.register_hook(post_hook)
-
-
-# Example usage:
-if __name__ == "__main__":
-    # This would typically be done during application initialization
-    config = Config(config={
-        'memory': {
-            'enabled': True,
-            'auto_learning': True,
-            'limits': {
-                'default_size_kb': 8,
-                'max_items_per_section': 20
-            }
-        }
-    })
-    
-    # Create hook service (normally this would be passed from main app)
-    from claude_mpm.services.hook_service import HookService
-    hook_service = HookService(config)
-    
-    # Register memory hooks
-    register_memory_hooks(hook_service, config)
-    
-    print("Memory hooks registered successfully!")
-    print(f"Pre-delegation hook: {hook_service.get_hooks('pre_delegation')}")
-    print(f"Post-delegation hook: {hook_service.get_hooks('post_delegation')}")

claude_mpm/hooks/builtin/mpm_command_hook.py

@@ -1,125 +0,0 @@
-"""Hook to intercept and handle /mpm: commands."""
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-from claude_mpm.hooks.base_hook import SubmitHook, HookContext, HookResult
-from claude_mpm.core.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class MpmCommandHook(SubmitHook):
-    """Hook that intercepts /mpm commands and routes them to the command router."""
-    
-    def __init__(self):
-        super().__init__(name="mpm_command", priority=1)  # High priority to intercept early
-        self.command_prefix = "/mpm "
-        self.command_router_path = self._find_command_router()
-    
-    def _find_command_router(self) -> Path:
-        """Find the command router script."""
-        # Look for command router relative to project root
-        possible_paths = [
-            Path(".claude/scripts/command_router.py"),
-            Path(__file__).parent.parent.parent.parent.parent / ".claude/scripts/command_router.py"
-        ]
-        
-        for path in possible_paths:
-            if path.exists():
-                return path.resolve()
-        
-        # Default path
-        return Path(".claude/scripts/command_router.py").resolve()
-    
-    def execute(self, context: HookContext) -> HookResult:
-        """Check for /mpm commands and execute them directly."""
-        try:
-            prompt = context.data.get('prompt', '').strip()
-            
-            # Check if this is an /mpm command
-            if not prompt.startswith(self.command_prefix):
-                # Not our command, pass through
-                return HookResult(
-                    success=True,
-                    data=context.data,
-                    modified=False
-                )
-            
-            # Extract command and arguments
-            command_line = prompt[len(self.command_prefix):].strip()
-            parts = command_line.split()
-            
-            if not parts:
-                return HookResult(
-                    success=True,
-                    data={
-                        'prompt': '',
-                        'response': "No command specified. Available commands: test",
-                        'skip_llm': True
-                    },
-                    modified=True,
-                    metadata={'command_handled': True}
-                )
-            
-            command = parts[0]
-            args = parts[1:]
-            
-            logger.info(f"Executing /mpm {command} with args: {args}")
-            
-            # Execute command using command router
-            try:
-                # Run the command router script
-                cmd = [sys.executable, str(self.command_router_path), command] + args
-                result = subprocess.run(
-                    cmd,
-                    capture_output=True,
-                    text=True,
-                    check=False
-                )
-                
-                if result.returncode == 0:
-                    response = result.stdout.strip()
-                else:
-                    response = f"Command failed: {result.stderr.strip() or 'Unknown error'}"
-                
-                logger.info(f"Command result: {response}")
-                
-                # Return result without going to LLM
-                return HookResult(
-                    success=True,
-                    data={
-                        'prompt': '',  # Clear prompt to prevent LLM processing
-                        'response': response,
-                        'skip_llm': True  # Flag to skip LLM
-                    },
-                    modified=True,
-                    metadata={
-                        'command_handled': True,
-                        'command': command,
-                        'args': args
-                    }
-                )
-                
-            except Exception as e:
-                logger.error(f"Failed to execute command: {e}")
-                return HookResult(
-                    success=True,
-                    data={
-                        'prompt': '',
-                        'response': f"Error executing command: {str(e)}",
-                        'skip_llm': True
-                    },
-                    modified=True,
-                    metadata={'command_error': str(e)}
-                )
-                
-        except Exception as e:
-            logger.error(f"MPM command hook failed: {e}")
-            # On error, pass through to normal processing
-            return HookResult(
-                success=False,
-                error=str(e)
-            )

claude_mpm/hooks/builtin/post_delegation_hook_example.py

@@ -1,124 +0,0 @@
-"""Example post-delegation hook implementation."""
-
-import json
-import re
-from typing import Dict, Any, List
-
-from claude_mpm.hooks.base_hook import PostDelegationHook, HookContext, HookResult
-from claude_mpm.core.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class ResultValidatorHook(PostDelegationHook):
-    """Hook that validates agent results for quality and completeness."""
-    
-    def __init__(self):
-        super().__init__(name="result_validator", priority=10)
-        
-    def execute(self, context: HookContext) -> HookResult:
-        """Validate agent results."""
-        try:
-            result = context.data.get('result', {})
-            agent = context.data.get('agent', 'unknown')
-            
-            # Validation checks
-            issues = []
-            
-            # Check for empty results
-            if not result:
-                issues.append("Empty result returned")
-                
-            # Check for error indicators
-            error_patterns = ['error', 'failed', 'exception', 'traceback']
-            result_str = json.dumps(result).lower()
-            for pattern in error_patterns:
-                if pattern in result_str and 'success' not in result:
-                    issues.append(f"Result contains '{pattern}' indicator")
-                    
-            # Agent-specific validation
-            if agent.lower() == 'engineer' and 'code' in str(result):
-                # Check for code quality indicators
-                if 'todo' in result_str or 'fixme' in result_str:
-                    issues.append("Code contains TODO/FIXME comments")
-                    
-            if issues:
-                logger.warning(f"Validation issues found: {issues}")
-                return HookResult(
-                    success=True,
-                    data={
-                        'result': result,
-                        'validation_issues': issues
-                    },
-                    modified=True,
-                    metadata={'issues_count': len(issues)}
-                )
-            else:
-                return HookResult(
-                    success=True,
-                    data=context.data,
-                    modified=False,
-                    metadata={'validated': True}
-                )
-                
-        except Exception as e:
-            logger.error(f"Result validation failed: {e}")
-            return HookResult(
-                success=False,
-                error=str(e)
-            )
-
-
-class ResultMetricsHook(PostDelegationHook):
-    """Hook that collects metrics from agent results."""
-    
-    def __init__(self):
-        super().__init__(name="result_metrics", priority=50)
-        
-    def execute(self, context: HookContext) -> HookResult:
-        """Collect metrics from agent results."""
-        try:
-            result = context.data.get('result', {})
-            agent = context.data.get('agent', 'unknown')
-            execution_time = context.metadata.get('execution_time_ms', 0)
-            
-            # Collect metrics
-            metrics = {
-                'agent': agent,
-                'execution_time_ms': execution_time,
-                'result_size_bytes': len(json.dumps(result).encode()),
-                'timestamp': context.timestamp.isoformat()
-            }
-            
-            # Agent-specific metrics
-            if agent.lower() == 'engineer':
-                # Count code-related metrics
-                code_content = str(result)
-                metrics['lines_of_code'] = code_content.count('\n')
-                metrics['functions_created'] = len(re.findall(r'def\s+\w+', code_content))
-                metrics['classes_created'] = len(re.findall(r'class\s+\w+', code_content))
-                
-            elif agent.lower() == 'qa':
-                # Count test-related metrics
-                test_content = str(result)
-                metrics['tests_count'] = len(re.findall(r'test_\w+', test_content))
-                metrics['assertions_count'] = len(re.findall(r'assert\s+', test_content))
-                
-            logger.info(f"Collected metrics: {metrics}")
-            
-            return HookResult(
-                success=True,
-                data={
-                    'result': result,
-                    'metrics': metrics
-                },
-                modified=True,
-                metadata=metrics
-            )
-            
-        except Exception as e:
-            logger.error(f"Metrics collection failed: {e}")
-            return HookResult(
-                success=False,
-                error=str(e)
-            )

claude_mpm/hooks/builtin/pre_delegation_hook_example.py

@@ -1,125 +0,0 @@
-"""Example pre-delegation hook implementation."""
-
-import json
-from typing import Dict, Any, List
-
-from claude_mpm.hooks.base_hook import PreDelegationHook, HookContext, HookResult
-from claude_mpm.core.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-class ContextFilterHook(PreDelegationHook):
-    """Hook that filters sensitive information from context before delegation."""
-    
-    def __init__(self):
-        super().__init__(name="context_filter", priority=10)
-        self.sensitive_keys = {
-            'api_key', 'secret', 'password', 'token',
-            'private_key', 'credentials', 'auth'
-        }
-        
-    def execute(self, context: HookContext) -> HookResult:
-        """Filter sensitive information from delegation context."""
-        try:
-            agent_context = context.data.get('context', {})
-            filtered_context = self._filter_sensitive(agent_context)
-            
-            if filtered_context != agent_context:
-                logger.info("Filtered sensitive information from context")
-                return HookResult(
-                    success=True,
-                    data={
-                        'agent': context.data.get('agent'),
-                        'context': filtered_context
-                    },
-                    modified=True,
-                    metadata={'filtered_keys': True}
-                )
-            else:
-                return HookResult(
-                    success=True,
-                    data=context.data,
-                    modified=False
-                )
-                
-        except Exception as e:
-            logger.error(f"Context filtering failed: {e}")
-            return HookResult(
-                success=False,
-                error=str(e)
-            )
-            
-    def _filter_sensitive(self, data: Any) -> Any:
-        """Recursively filter sensitive keys from data."""
-        if isinstance(data, dict):
-            filtered = {}
-            for key, value in data.items():
-                if any(sensitive in key.lower() for sensitive in self.sensitive_keys):
-                    filtered[key] = "[REDACTED]"
-                else:
-                    filtered[key] = self._filter_sensitive(value)
-            return filtered
-        elif isinstance(data, list):
-            return [self._filter_sensitive(item) for item in data]
-        else:
-            return data
-
-
-class AgentCapabilityEnhancerHook(PreDelegationHook):
-    """Hook that enhances agent context with additional capabilities."""
-    
-    def __init__(self):
-        super().__init__(name="capability_enhancer", priority=30)
-        self.agent_enhancements = {
-            'engineer': {
-                'tools': ['code_analysis', 'refactoring', 'testing'],
-                'context': 'You have access to advanced code analysis tools.'
-            },
-            'researcher': {
-                'tools': ['web_search', 'document_analysis'],
-                'context': 'You can search the web and analyze documents.'
-            },
-            'qa': {
-                'tools': ['test_runner', 'coverage_analyzer'],
-                'context': 'You have access to comprehensive testing tools.'
-            }
-        }
-        
-    def execute(self, context: HookContext) -> HookResult:
-        """Enhance agent capabilities based on agent type."""
-        try:
-            agent_type = context.data.get('agent', '').lower()
-            
-            if agent_type in self.agent_enhancements:
-                enhancement = self.agent_enhancements[agent_type]
-                
-                # Add enhancements to context
-                enhanced_context = context.data.get('context', {}).copy()
-                enhanced_context['additional_tools'] = enhancement['tools']
-                enhanced_context['enhanced_context'] = enhancement['context']
-                
-                logger.info(f"Enhanced {agent_type} agent with additional capabilities")
-                
-                return HookResult(
-                    success=True,
-                    data={
-                        'agent': context.data.get('agent'),
-                        'context': enhanced_context
-                    },
-                    modified=True,
-                    metadata={'enhancements_applied': True}
-                )
-            else:
-                return HookResult(
-                    success=True,
-                    data=context.data,
-                    modified=False
-                )
-                
-        except Exception as e:
-            logger.error(f"Capability enhancement failed: {e}")
-            return HookResult(
-                success=False,
-                error=str(e)
-            )