claude-mpm 3.1.1__py3-none-any.whl → 3.1.3__py3-none-any.whl

claude_mpm/cli/utils.py

@@ -0,0 +1,190 @@
+"""
+Utility functions for the CLI.
+
+WHY: This module contains shared utility functions used across different CLI commands.
+Centralizing these functions reduces code duplication and provides a single place
+for common CLI operations.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+from claude_mpm.utils.imports import safe_import
+
+# Import logger using safe_import pattern
+get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
+
+
+def get_user_input(input_arg: Optional[str], logger) -> str:
+    """
+    Get user input based on command line arguments.
+    
+    WHY: This function handles the three ways users can provide input:
+    1. Direct text via -i/--input
+    2. File path via -i/--input
+    3. stdin (for piping)
+    
+    DESIGN DECISION: We check if the input is a file path first, then fall back
+    to treating it as direct text. This allows maximum flexibility.
+    
+    Args:
+        input_arg: The value of the -i/--input argument
+        logger: Logger instance for output
+        
+    Returns:
+        The user input as a string
+    """
+    if input_arg:
+        # Check if it's a file path
+        input_path = Path(input_arg)
+        if input_path.exists():
+            logger.info(f"Reading input from file: {input_path}")
+            return input_path.read_text()
+        else:
+            logger.info("Using command line input")
+            return input_arg
+    else:
+        # Read from stdin
+        logger.info("Reading input from stdin")
+        return sys.stdin.read()
+
+
+def get_agent_versions_display() -> Optional[str]:
+    """
+    Get formatted agent versions display as a string.
+    
+    WHY: This function provides a single source of truth for agent version
+    information that can be displayed both at startup and on-demand via the
+    /mpm agents command. This ensures consistency in how agent versions are
+    presented to users.
+    
+    Returns:
+        Formatted string containing agent version information, or None if failed
+    """
+    # Import AgentDeploymentService using safe_import pattern
+    AgentDeploymentService = safe_import(
+        'claude_mpm.services.agent_deployment',
+        None,
+        ['AgentDeploymentService']
+    )
+    
+    if not AgentDeploymentService:
+        return None
+        
+    try:
+        deployment_service = AgentDeploymentService()
+        
+        # Get deployed agents
+        verification = deployment_service.verify_deployment()
+        if not verification.get("agents_found"):
+            return None
+            
+        output_lines = []
+        output_lines.append("\nDeployed Agent Versions:")
+        output_lines.append("-" * 40)
+        
+        # Sort agents by name for consistent display
+        agents = sorted(verification["agents_found"], key=lambda x: x.get('name', x.get('file', '')))
+        
+        for agent in agents:
+            name = agent.get('name', 'unknown')
+            version = agent.get('version', 'unknown')
+            # Format: name (version)
+            output_lines.append(f"  {name:<20} {version}")
+        
+        # Add base agent version info
+        try:
+            import json
+            base_agent_path = deployment_service.base_agent_path
+            if base_agent_path.exists():
+                base_data = json.loads(base_agent_path.read_text())
+                # Parse version the same way as AgentDeploymentService
+                raw_version = base_data.get('base_version') or base_data.get('version', 0)
+                base_version_tuple = deployment_service._parse_version(raw_version)
+                base_version_str = deployment_service._format_version_display(base_version_tuple)
+                output_lines.append(f"\n  Base Agent Version:  {base_version_str}")
+        except:
+            pass
+        
+        # Check for agents needing migration
+        if verification.get("agents_needing_migration"):
+            output_lines.append(f"\n  ⚠️  {len(verification['agents_needing_migration'])} agent(s) need migration to semantic versioning")
+            output_lines.append(f"     Run 'claude-mpm agents deploy' to update")
+            
+        output_lines.append("-" * 40)
+        return "\n".join(output_lines)
+    except Exception as e:
+        # Log error but don't fail
+        logger = get_logger("cli")
+        logger.debug(f"Failed to get agent versions: {e}")
+        return None
+
+
+def list_agent_versions_at_startup() -> None:
+    """
+    List deployed agent versions at startup.
+    
+    WHY: Users want to see what agents are available when they start a session.
+    This provides immediate feedback about the deployed agent environment.
+    """
+    agent_versions = get_agent_versions_display()
+    if agent_versions:
+        print(agent_versions)
+        print()  # Extra newline after the display
+
+
+def setup_logging(args) -> object:
+    """
+    Set up logging based on parsed arguments.
+    
+    WHY: This centralizes logging setup logic, handling the deprecated --debug flag
+    and the new --logging argument consistently across all commands.
+    
+    Args:
+        args: Parsed command line arguments
+        
+    Returns:
+        Logger instance
+    """
+    from ..core.logger import setup_logging as core_setup_logging, get_logger
+    from ..constants import LogLevel
+    
+    # Handle deprecated --debug flag
+    if hasattr(args, 'debug') and args.debug and args.logging == LogLevel.INFO.value:
+        args.logging = LogLevel.DEBUG.value
+    
+    # Only setup logging if not OFF
+    if args.logging != LogLevel.OFF.value:
+        logger = core_setup_logging(level=args.logging, log_dir=args.log_dir)
+    else:
+        # Minimal logger for CLI feedback
+        import logging
+        logger = logging.getLogger("cli")
+        logger.setLevel(logging.WARNING)
+    
+    return logger
+
+
+def ensure_directories() -> None:
+    """
+    Ensure required directories exist on first run.
+    
+    WHY: Claude-mpm needs certain directories to function properly. Rather than
+    failing when they don't exist, we create them automatically for a better
+    user experience.
+    """
+    # Import ensure_directories using safe_import pattern
+    init_ensure_directories = safe_import(
+        'claude_mpm.init',
+        None,
+        ['ensure_directories']
+    )
+    
+    if init_ensure_directories:
+        try:
+            init_ensure_directories()
+        except Exception:
+            # Continue even if initialization fails
+            # The individual commands will handle missing directories as needed
+            pass

claude_mpm/cli_enhancements.py

@@ -1,6 +1,25 @@
 """
 Enhanced CLI operations for claude-mpm.
 
+WHY THIS FILE EXISTS:
+This module provides an alternative CLI implementation with enhanced error handling
+and validation features. It was created to explore advanced CLI patterns including:
+- Comprehensive prerequisite validation
+- User-friendly error messages with suggestions
+- Dry-run mode for testing
+- Profile validation and generation
+- Rich terminal output with status indicators
+
+CURRENT STATUS: This is an experimental/alternative CLI implementation that uses
+Click instead of argparse. It's kept separate from the main CLI to:
+1. Preserve the existing CLI behavior
+2. Allow testing of new features without breaking the main interface
+3. Provide a reference implementation for future CLI enhancements
+
+NOTE: This CLI is not currently used in production. The main CLI is in cli/__init__.py.
+To use this enhanced CLI, you would need to create a separate entry point or
+integrate selected features into the main CLI.
+
 Implements error handling and user guidance patterns from awesome-claude-code.
 """
 

claude_mpm/core/agent_registry.py

@@ -20,10 +20,10 @@ import importlib.util
 from datetime import datetime
 from dataclasses import dataclass
 
-try:
-    from ..core.logger import get_logger
-except ImportError:
-    from core.logger import get_logger
+from claude_mpm.utils.imports import safe_import
+
+# Import logger using safe_import pattern
+get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
 
 
 @dataclass

claude_mpm/core/factories.py

@@ -12,7 +12,7 @@ from typing import Any, Dict, Optional, Type, TypeVar
 from .container import DIContainer
 from .logger import get_logger
 from .config import Config
-from ..services.agent_deployment import AgentDeploymentService
+from claude_mpm.services.agent_deployment import AgentDeploymentService
 from ..orchestration.factory import OrchestratorFactory
 from ..orchestration.base import BaseOrchestrator
 

claude_mpm/core/service_registry.py

@@ -38,7 +38,7 @@ class ServiceRegistry:
         """Register all core framework services."""
         from ..services.shared_prompt_cache import SharedPromptCache
         from ..services.ticket_manager import TicketManager
-        from ..services.agent_deployment import AgentDeploymentService
+        from claude_mpm.services.agent_deployment import AgentDeploymentService
         from .session_manager import SessionManager
         from .agent_session_manager import AgentSessionManager
         from .config import Config

claude_mpm/core/simple_runner.py

@@ -195,16 +195,15 @@ class SimpleClaudeRunner:
                 clean_env.pop(var, None)
             
             # Set the correct working directory for Claude Code
-            # If CLAUDE_MPM_USER_PWD is set, use that as the working directory
+            # WHY: We're already in the user's directory thanks to __main__.py restoration
+            # We just need to ensure CLAUDE_WORKSPACE is set correctly
+            current_dir = os.getcwd()
+            clean_env['CLAUDE_WORKSPACE'] = current_dir
+            self.logger.info(f"Working directory: {current_dir}")
+            
+            # Log directory context for debugging
             if 'CLAUDE_MPM_USER_PWD' in clean_env:
-                user_pwd = clean_env['CLAUDE_MPM_USER_PWD']
-                clean_env['CLAUDE_WORKSPACE'] = user_pwd
-                # Also change to that directory before launching Claude
-                try:
-                    os.chdir(user_pwd)
-                    self.logger.info(f"Changed working directory to: {user_pwd}")
-                except Exception as e:
-                    self.logger.warning(f"Could not change to user directory {user_pwd}: {e}")
+                self.logger.debug(f"User PWD from env: {clean_env['CLAUDE_MPM_USER_PWD']}")
             
             print("Launching Claude...")
             
@@ -313,19 +312,15 @@ class SimpleClaudeRunner:
             env = os.environ.copy()
             
             # Set the correct working directory for Claude Code
+            # WHY: We're already in the user's directory thanks to __main__.py restoration
+            # We just need to ensure CLAUDE_WORKSPACE is set correctly
+            current_dir = os.getcwd()
+            env['CLAUDE_WORKSPACE'] = current_dir
+            self.logger.info(f"Working directory for subprocess: {current_dir}")
+            
+            # Log directory context for debugging
             if 'CLAUDE_MPM_USER_PWD' in env:
-                user_pwd = env['CLAUDE_MPM_USER_PWD']
-                env['CLAUDE_WORKSPACE'] = user_pwd
-                # Change to that directory before running Claude
-                try:
-                    original_cwd = os.getcwd()
-                    os.chdir(user_pwd)
-                    self.logger.info(f"Changed working directory to: {user_pwd}")
-                except Exception as e:
-                    self.logger.warning(f"Could not change to user directory {user_pwd}: {e}")
-                    original_cwd = None
-            else:
-                original_cwd = None
+                self.logger.debug(f"User PWD from env: {env['CLAUDE_MPM_USER_PWD']}")
             
             # Run Claude
             if self.project_logger:
@@ -337,12 +332,7 @@ class SimpleClaudeRunner:
             
             result = subprocess.run(cmd, capture_output=True, text=True, env=env)
             
-            # Restore original directory if we changed it
-            if original_cwd:
-                try:
-                    os.chdir(original_cwd)
-                except Exception:
-                    pass
+            # No need to restore directory since we didn't change it
             execution_time = time.time() - start_time
             
             if result.returncode == 0:

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -44,6 +44,7 @@ project_root = Path(__file__).parent.parent.parent.parent
 sys.path.insert(0, str(project_root / 'src'))
 
 from claude_mpm.core.logger import get_logger, setup_logging, LogLevel
+from claude_mpm.security import BashSecurityValidator
 
 # Don't initialize global logging here - we'll do it per-project
 logger = None
@@ -329,6 +330,7 @@ class ClaudeHookHandler:
         - Checking for path traversal attempts
         - Ensuring file operations stay within the working directory
         - Blocking dangerous operations
+        - Validating bash commands for security violations
         
         Security Design:
         - Fail-secure: Block suspicious operations
@@ -342,6 +344,29 @@ class ClaudeHookHandler:
         tool_name = self.event.get('tool_name', '')
         tool_input = self.event.get('tool_input', {})
         
+        # Get the working directory from the event
+        working_dir = Path(self.event.get('cwd', os.getcwd())).resolve()
+        
+        # Special handling for Bash tool - validate commands for security
+        if tool_name == 'Bash':
+            command = tool_input.get('command', '')
+            if command:
+                # Create bash validator for this working directory
+                bash_validator = BashSecurityValidator(working_dir)
+                is_valid, error_msg = bash_validator.validate_command(command)
+                
+                if not is_valid:
+                    if logger:
+                        logger.warning(f"Security: Blocked Bash command: {command[:100]}...")
+                    
+                    response = {
+                        "action": "block",
+                        "error": error_msg
+                    }
+                    print(json.dumps(response))
+                    sys.exit(0)
+                    return
+        
         # List of tools that perform write operations
         # These tools need special security checks to prevent
         # writing outside the project directory
@@ -349,9 +374,6 @@ class ClaudeHookHandler:
         
         # Check if this is a write operation
         if tool_name in write_tools:
-            # Get the working directory from the event
-            working_dir = Path(self.event.get('cwd', os.getcwd())).resolve()
-            
             # Extract file path based on tool type
             file_path = None
             if tool_name in ['Write', 'Edit', 'NotebookEdit']:
@@ -414,7 +436,34 @@ class ClaudeHookHandler:
                     sys.exit(0)
                     return
         
-        # For read operations and other tools, continue normally
+        # Additional security checks for other tools that might access files
+        read_tools = ['Read', 'LS', 'Glob', 'Grep', 'NotebookRead']
+        
+        if tool_name in read_tools:
+            # For read operations, we allow them but log for auditing
+            file_path = None
+            if tool_name == 'Read':
+                file_path = tool_input.get('file_path')
+            elif tool_name == 'NotebookRead':
+                file_path = tool_input.get('notebook_path')
+            elif tool_name == 'LS':
+                file_path = tool_input.get('path')
+            elif tool_name in ['Glob', 'Grep']:
+                file_path = tool_input.get('path', '.')
+            
+            if file_path and logger:
+                # Log read operations for security auditing
+                logger.info(f"Security audit: {tool_name} accessing path: {file_path}")
+        
+        # Check for other potentially dangerous tools
+        if tool_name in ['WebFetch', 'WebSearch']:
+            # Log web access for security auditing
+            if logger:
+                url = tool_input.get('url', '') if tool_name == 'WebFetch' else 'N/A'
+                query = tool_input.get('query', '') if tool_name == 'WebSearch' else 'N/A'
+                logger.info(f"Security audit: {tool_name} - URL: {url}, Query: {query}")
+        
+        # For all other operations, continue normally
         return self._continue()
     
     def _handle_post_tool_use(self):

claude_mpm/models/__init__.py

@@ -0,0 +1,106 @@
+"""
+Claude MPM Models Package
+=========================
+
+Centralized data models for the Claude MPM system.
+
+WHY: This package centralizes all data models to:
+- Prevent circular imports
+- Reduce code duplication
+- Ensure consistent data structures
+- Make models easily discoverable
+
+DESIGN DECISION: Models are organized by domain:
+- agent_definition: Core agent behavior models
+- lifecycle: Agent lifecycle management models
+- modification: Change tracking models
+- persistence: Storage operation models
+- registry: Discovery and management models
+- common: Shared constants and enums
+"""
+
+# Agent definition models
+from .agent_definition import (
+    AgentType,
+    AgentSection,
+    AgentPermissions,
+    AgentWorkflow,
+    AgentMetadata,
+    AgentDefinition
+)
+
+# Lifecycle models
+from .lifecycle import (
+    LifecycleOperation,
+    LifecycleState,
+    AgentLifecycleRecord,
+    LifecycleOperationResult
+)
+
+# Modification models
+from .modification import (
+    ModificationType,
+    ModificationTier,
+    AgentModification,
+    ModificationHistory
+)
+
+# Persistence models
+from .persistence import (
+    PersistenceStrategy,
+    PersistenceOperation,
+    PersistenceRecord
+)
+
+# Registry models
+from .registry import (
+    AgentTier,
+    AgentRegistryMetadata
+)
+
+# Common constants
+from .common import (
+    AGENT_FILE_EXTENSIONS,
+    AGENT_IGNORE_PATTERNS,
+    CORE_AGENT_TYPES,
+    SPECIALIZED_AGENT_TYPES,
+    ALL_AGENT_TYPES
+)
+
+__all__ = [
+    # Agent definition
+    'AgentType',
+    'AgentSection',
+    'AgentPermissions',
+    'AgentWorkflow',
+    'AgentMetadata',
+    'AgentDefinition',
+    
+    # Lifecycle
+    'LifecycleOperation',
+    'LifecycleState',
+    'AgentLifecycleRecord',
+    'LifecycleOperationResult',
+    
+    # Modification
+    'ModificationType',
+    'ModificationTier',
+    'AgentModification',
+    'ModificationHistory',
+    
+    # Persistence
+    'PersistenceStrategy',
+    'PersistenceOperation',
+    'PersistenceRecord',
+    
+    # Registry
+    'AgentTier',
+    'AgentRegistryMetadata',
+    
+    # Common
+    'AGENT_FILE_EXTENSIONS',
+    'AGENT_IGNORE_PATTERNS',
+    'CORE_AGENT_TYPES',
+    'SPECIALIZED_AGENT_TYPES',
+    'ALL_AGENT_TYPES'
+]