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

claude_mpm/core/claude_runner.py

@@ -9,15 +9,16 @@ from datetime import datetime
 from pathlib import Path
 from typing import Optional
 import uuid
+from claude_mpm.config.paths import paths
 
 try:
-    from claude_mpm.services.agent_deployment import AgentDeploymentService
+    from claude_mpm.services.agents.deployment import AgentDeploymentService
     from claude_mpm.services.ticket_manager import TicketManager
     from claude_mpm.services.hook_service import HookService
     from claude_mpm.core.config import Config
     from claude_mpm.core.logger import get_logger, get_project_logger, ProjectLogger
 except ImportError:
-    from claude_mpm.services.agent_deployment import AgentDeploymentService
+    from claude_mpm.services.agents.deployment import AgentDeploymentService
     from claude_mpm.services.ticket_manager import TicketManager
     from claude_mpm.services.hook_service import HookService
     from claude_mpm.core.config import Config
@@ -67,23 +68,58 @@ class ClaudeRunner:
                     level="INFO",
                     component="runner"
                 )
+            except ImportError as e:
+                self.logger.warning(f"Project logger module not available: {e}")
             except Exception as e:
                 self.logger.warning(f"Failed to initialize project logger: {e}")
         
-        # Initialize services
-        self.deployment_service = AgentDeploymentService()
+        # Initialize services with proper error handling
+        try:
+            self.deployment_service = AgentDeploymentService()
+        except ImportError as e:
+            self.logger.error(f"Failed to import AgentDeploymentService: {e}")
+            raise RuntimeError("Required module AgentDeploymentService not available. Please reinstall claude-mpm.") from e
+        except Exception as e:
+            self.logger.error(f"Failed to initialize AgentDeploymentService: {e}")
+            raise RuntimeError(f"Agent deployment service initialization failed: {e}") from e
+        
+        # Initialize ticket manager if enabled
         if enable_tickets:
             try:
                 self.ticket_manager = TicketManager()
-            except (ImportError, TypeError, Exception) as e:
-                self.logger.warning(f"Ticket manager not available: {e}")
+            except ImportError as e:
+                self.logger.warning(f"Ticket manager module not available: {e}")
+                self.ticket_manager = None
+                self.enable_tickets = False
+            except TypeError as e:
+                self.logger.warning(f"Ticket manager initialization error: {e}")
+                self.ticket_manager = None
+                self.enable_tickets = False
+            except Exception as e:
+                self.logger.warning(f"Unexpected error initializing ticket manager: {e}")
                 self.ticket_manager = None
                 self.enable_tickets = False
         
-        # Initialize hook service and register memory hooks
-        self.config = Config()
-        self.hook_service = HookService(self.config)
-        self._register_memory_hooks()
+        # Initialize configuration
+        try:
+            self.config = Config()
+        except FileNotFoundError as e:
+            self.logger.warning(f"Configuration file not found, using defaults: {e}")
+            self.config = Config()  # Will use defaults
+        except Exception as e:
+            self.logger.error(f"Failed to load configuration: {e}")
+            raise RuntimeError(f"Configuration initialization failed: {e}") from e
+        
+        # Initialize hook service
+        try:
+            self.hook_service = HookService(self.config)
+            self._register_memory_hooks()
+        except ImportError as e:
+            self.logger.warning(f"Hook service module not available: {e}")
+            self.hook_service = None
+        except Exception as e:
+            self.logger.warning(f"Failed to initialize hook service: {e}")
+            self.hook_service = None
         
         # Load system instructions
         self.system_instructions = self._load_system_instructions()
@@ -101,6 +137,10 @@ class ClaudeRunner:
                     "log_level": log_level,
                     "launch_method": launch_method
                 })
+            except PermissionError as e:
+                self.logger.debug(f"Permission denied creating session log file: {e}")
+            except OSError as e:
+                self.logger.debug(f"OS error creating session log file: {e}")
             except Exception as e:
                 self.logger.debug(f"Failed to create session log file: {e}")
         
@@ -148,12 +188,99 @@ class ClaudeRunner:
                     )
                 return True
                 
+        
+        except PermissionError as e:
+            error_msg = f"Permission denied deploying agents to .claude/agents/: {e}"
+            self.logger.error(error_msg)
+            print(f"❌ {error_msg}")
+            print("💡 Try running with appropriate permissions or check directory ownership")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="deployment")
+            return False
+        
+        except FileNotFoundError as e:
+            error_msg = f"Agent templates not found: {e}"
+            self.logger.error(error_msg)
+            print(f"❌ {error_msg}")
+            print("💡 Ensure claude-mpm is properly installed")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="deployment")
+            return False
+        
+        except ImportError as e:
+            error_msg = f"Missing required module for agent deployment: {e}"
+            self.logger.error(error_msg)
+            print(f"⚠️  {error_msg}")
+            print("💡 Some agent features may be limited")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="WARNING", component="deployment")
+            return False
+        
+        except Exception as e:
+            error_msg = f"Unexpected error during agent deployment: {e}"
+            self.logger.error(error_msg)
+            print(f"⚠️  {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="deployment")
+            # Continue without agents rather than failing completely
+            return False
+    
+    def ensure_project_agents(self) -> bool:
+        """Ensure system agents are available in the project directory.
+        
+        Deploys system agents to project's .claude-mpm/agents/ directory
+        if they don't exist or are outdated. This enables project-level
+        agent customization and ensures all agents are available locally.
+        
+        Returns:
+            bool: True if agents are available, False on error
+        """
+        try:
+            # Check if we're in a project directory
+            project_dir = Path.cwd()
+            project_agents_dir = project_dir / ".claude-mpm" / "agents"
+            
+            # Create directory if it doesn't exist
+            project_agents_dir.mkdir(parents=True, exist_ok=True)
+            
+            if self.project_logger:
+                self.project_logger.log_system(
+                    f"Ensuring agents are available in project: {project_agents_dir}",
+                    level="INFO",
+                    component="deployment"
+                )
+            
+            # Deploy agents to project directory with project deployment mode
+            # This ensures all system agents are deployed regardless of version
+            results = self.deployment_service.deploy_agents(
+                target_dir=project_dir / ".claude-mpm",
+                force_rebuild=False,
+                deployment_mode="project"
+            )
+            
+            if results["deployed"] or results.get("updated", []):
+                deployed_count = len(results['deployed'])
+                updated_count = len(results.get('updated', []))
+                
+                if deployed_count > 0:
+                    self.logger.info(f"Deployed {deployed_count} agents to project")
+                if updated_count > 0:
+                    self.logger.info(f"Updated {updated_count} agents in project")
+                    
+                return True
+            elif results.get("skipped", []):
+                # Agents already exist and are current
+                self.logger.debug(f"Project agents up to date: {len(results['skipped'])} agents")
+                return True
+            else:
+                self.logger.warning("No agents deployed to project")
+                return False
+                
         except Exception as e:
-            self.logger.error(f"Agent deployment failed: {e}")
-            print(f"⚠️  Agent deployment failed: {e}")
+            self.logger.error(f"Failed to ensure project agents: {e}")
             if self.project_logger:
                 self.project_logger.log_system(
-                    f"Agent deployment failed: {e}",
+                    f"Failed to ensure project agents: {e}",
                     level="ERROR",
                     component="deployment"
                 )
@@ -180,8 +307,14 @@ class ClaudeRunner:
                     launch_method=self.launch_method,
                     working_dir=working_dir
                 )
+            except ImportError as e:
+                self.logger.warning(f"Socket.IO module not available: {e}")
+                self.websocket_server = None
+            except ConnectionError as e:
+                self.logger.warning(f"Cannot connect to Socket.IO server on port {self.websocket_port}: {e}")
+                self.websocket_server = None
             except Exception as e:
-                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
+                self.logger.warning(f"Unexpected error with Socket.IO server: {e}")
                 self.websocket_server = None
         
         # Get version with robust fallback mechanisms
@@ -246,8 +379,12 @@ class ClaudeRunner:
                 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}")
+                except PermissionError as e:
+                    self.logger.warning(f"Permission denied accessing directory {user_pwd}: {e}")
+                except FileNotFoundError as e:
+                    self.logger.warning(f"Directory not found {user_pwd}: {e}")
+                except OSError as e:
+                    self.logger.warning(f"OS error changing to directory {user_pwd}: {e}")
             
             print("Launching Claude...")
             
@@ -283,18 +420,62 @@ class ClaudeRunner:
                     )
                 os.execvpe(cmd[0], cmd, clean_env)
             
-        except Exception as e:
-            print(f"Failed to launch Claude: {e}")
+        except FileNotFoundError as e:
+            error_msg = f"Claude CLI not found. Please ensure 'claude' is installed and in your PATH: {e}"
+            print(f"❌ {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="session")
+                self._log_session_event({
+                    "event": "interactive_launch_failed",
+                    "error": str(e),
+                    "exception_type": "FileNotFoundError",
+                    "recovery_action": "fallback_to_subprocess"
+                })
+        except PermissionError as e:
+            error_msg = f"Permission denied executing Claude CLI: {e}"
+            print(f"❌ {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="session")
+                self._log_session_event({
+                    "event": "interactive_launch_failed",
+                    "error": str(e),
+                    "exception_type": "PermissionError",
+                    "recovery_action": "check_file_permissions"
+                })
+        except OSError as e:
+            error_msg = f"OS error launching Claude: {e}"
+            print(f"❌ {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="session")
+                self._log_session_event({
+                    "event": "interactive_launch_failed",
+                    "error": str(e),
+                    "exception_type": "OSError",
+                    "recovery_action": "fallback_to_subprocess"
+                })
+        except KeyboardInterrupt:
+            print("\n⚠️  Session interrupted by user")
             if self.project_logger:
                 self.project_logger.log_system(
-                    f"Failed to launch Claude: {e}",
-                    level="ERROR",
+                    "Session interrupted by user",
+                    level="INFO",
                     component="session"
                 )
+                self._log_session_event({
+                    "event": "session_interrupted",
+                    "reason": "user_interrupt"
+                })
+            return  # Clean exit on user interrupt
+        except Exception as e:
+            error_msg = f"Unexpected error launching Claude: {e}"
+            print(f"❌ {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="session")
                 self._log_session_event({
                     "event": "interactive_launch_failed",
                     "error": str(e),
-                    "exception_type": type(e).__name__
+                    "exception_type": type(e).__name__,
+                    "recovery_action": "fallback_to_subprocess"
                 })
             
             # Notify WebSocket clients of error
@@ -304,21 +485,52 @@ class ClaudeRunner:
                     message=f"Failed to launch Claude: {e}"
                 )
             # Fallback to subprocess
+            print("\n🔄 Attempting fallback launch method...")
             try:
                 # Use the same clean_env we prepared earlier
-                subprocess.run(cmd, stdin=None, stdout=None, stderr=None, env=clean_env)
+                result = subprocess.run(cmd, stdin=None, stdout=None, stderr=None, env=clean_env)
+                if result.returncode == 0:
+                    if self.project_logger:
+                        self.project_logger.log_system(
+                            "Interactive session completed (subprocess fallback)",
+                            level="INFO",
+                            component="session"
+                        )
+                        self._log_session_event({
+                            "event": "interactive_session_complete",
+                            "fallback": True,
+                            "return_code": result.returncode
+                        })
+                else:
+                    print(f"⚠️  Claude exited with code {result.returncode}")
+                    if self.project_logger:
+                        self.project_logger.log_system(
+                            f"Claude exited with non-zero code: {result.returncode}",
+                            level="WARNING",
+                            component="session"
+                        )
+            except FileNotFoundError as e:
+                print(f"❌ Fallback failed: Claude CLI not found in PATH")
+                print("\n💡 To fix this issue:")
+                print("   1. Install Claude CLI: npm install -g @anthropic-ai/claude-ai")
+                print("   2. Or specify the full path to the claude binary")
+                if self.project_logger:
+                    self.project_logger.log_system(
+                        f"Fallback failed - Claude CLI not found: {e}",
+                        level="ERROR",
+                        component="session"
+                    )
+            except KeyboardInterrupt:
+                print("\n⚠️  Fallback interrupted by user")
                 if self.project_logger:
                     self.project_logger.log_system(
-                        "Interactive session completed (subprocess fallback)",
+                        "Fallback interrupted by user",
                         level="INFO",
                         component="session"
                     )
-                    self._log_session_event({
-                        "event": "interactive_session_complete",
-                        "fallback": True
-                    })
             except Exception as fallback_error:
-                print(f"Fallback also failed: {fallback_error}")
+                print(f"❌ Fallback failed with unexpected error: {fallback_error}")
+                print(f"   Error type: {type(fallback_error).__name__}")
                 if self.project_logger:
                     self.project_logger.log_system(
                         f"Fallback launch failed: {fallback_error}",
@@ -354,8 +566,14 @@ class ClaudeRunner:
                     launch_method="oneshot",
                     working_dir=working_dir
                 )
+            except ImportError as e:
+                self.logger.warning(f"Socket.IO module not available: {e}")
+                self.websocket_server = None
+            except ConnectionError as e:
+                self.logger.warning(f"Cannot connect to Socket.IO server on port {self.websocket_port}: {e}")
+                self.websocket_server = None
             except Exception as e:
-                self.logger.warning(f"Failed to connect to Socket.IO server: {e}")
+                self.logger.warning(f"Unexpected error with Socket.IO server: {e}")
                 self.websocket_server = None
         
         # Check for /mpm: commands
@@ -412,8 +630,14 @@ class ClaudeRunner:
                     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}")
+                except PermissionError as e:
+                    self.logger.warning(f"Permission denied accessing directory {user_pwd}: {e}")
+                    original_cwd = None
+                except FileNotFoundError as e:
+                    self.logger.warning(f"Directory not found {user_pwd}: {e}")
+                    original_cwd = None
+                except OSError as e:
+                    self.logger.warning(f"OS error changing to directory {user_pwd}: {e}")
                     original_cwd = None
             else:
                 original_cwd = None
@@ -523,9 +747,79 @@ class ClaudeRunner:
                     })
                 
                 return False
-                
+        
+        except subprocess.TimeoutExpired as e:
+            error_msg = f"Command timed out after {e.timeout} seconds"
+            print(f"⏱️  {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="session")
+                self._log_session_event({
+                    "event": "session_timeout",
+                    "success": False,
+                    "timeout": e.timeout,
+                    "exception_type": "TimeoutExpired"
+                })
+            return False
+        
+        except FileNotFoundError as e:
+            error_msg = "Claude CLI not found. Please ensure 'claude' is installed and in your PATH"
+            print(f"❌ {error_msg}")
+            print("\n💡 To fix: Install Claude CLI with 'npm install -g @anthropic-ai/claude-ai'")
+            if self.project_logger:
+                self.project_logger.log_system(f"{error_msg}: {e}", level="ERROR", component="session")
+                self._log_session_event({
+                    "event": "session_exception",
+                    "success": False,
+                    "exception": str(e),
+                    "exception_type": "FileNotFoundError"
+                })
+            return False
+        
+        except PermissionError as e:
+            error_msg = f"Permission denied executing Claude CLI: {e}"
+            print(f"❌ {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(error_msg, level="ERROR", component="session")
+                self._log_session_event({
+                    "event": "session_exception",
+                    "success": False,
+                    "exception": str(e),
+                    "exception_type": "PermissionError"
+                })
+            return False
+        
+        except KeyboardInterrupt:
+            print("\n⚠️  Command interrupted by user")
+            if self.project_logger:
+                self.project_logger.log_system(
+                    "Session interrupted by user",
+                    level="INFO",
+                    component="session"
+                )
+                self._log_session_event({
+                    "event": "session_interrupted",
+                    "success": False,
+                    "reason": "user_interrupt"
+                })
+            return False
+        
+        except MemoryError as e:
+            error_msg = "Out of memory while processing command"
+            print(f"❌ {error_msg}")
+            if self.project_logger:
+                self.project_logger.log_system(f"{error_msg}: {e}", level="ERROR", component="session")
+                self._log_session_event({
+                    "event": "session_exception",
+                    "success": False,
+                    "exception": str(e),
+                    "exception_type": "MemoryError"
+                })
+            return False
+        
         except Exception as e:
-            print(f"Error: {e}")
+            error_msg = f"Unexpected error: {e}"
+            print(f"❌ {error_msg}")
+            print(f"   Error type: {type(e).__name__}")
             
             if self.project_logger:
                 self.project_logger.log_system(
@@ -580,8 +874,12 @@ class ClaudeRunner:
                         print(f"  ... and {len(tickets) - 3} more")
             else:
                 self.logger.debug("Ticket extraction method not available")
+        except AttributeError as e:
+            self.logger.debug(f"Ticket manager missing expected method: {e}")
+        except TypeError as e:
+            self.logger.debug(f"Invalid ticket data format: {e}")
         except Exception as e:
-            self.logger.debug(f"Ticket extraction failed: {e}")
+            self.logger.debug(f"Unexpected error during ticket extraction: {e}")
 
     def _load_system_instructions(self) -> Optional[str]:
         """Load and process system instructions from agents/INSTRUCTIONS.md.
@@ -714,6 +1012,9 @@ class ClaudeRunner:
                             component="command"
                         )
                     return True
+                except ImportError as e:
+                    print(f"Error: CLI module not available: {e}")
+                    return False
                 except Exception as e:
                     print(f"Error getting agent versions: {e}")
                     return False
@@ -722,6 +1023,9 @@ class ClaudeRunner:
                 print("Available commands: test, agents")
                 return True
                 
+        except KeyboardInterrupt:
+            print("\nCommand interrupted")
+            return False
         except Exception as e:
             print(f"Error executing command: {e}")
             if self.project_logger:
@@ -743,6 +1047,8 @@ class ClaudeRunner:
                 
                 with open(self.session_log_file, 'a') as f:
                     f.write(json.dumps(log_entry) + '\n')
+            except (OSError, IOError) as e:
+                self.logger.debug(f"IO error logging session event: {e}")
             except Exception as e:
                 self.logger.debug(f"Failed to log session event: {e}")
     
@@ -793,14 +1099,13 @@ class ClaudeRunner:
         # Method 3: Try reading VERSION file directly (development fallback)
         if version == "0.0.0":
             try:
-                # Calculate path relative to this file
-                version_file = Path(__file__).parent.parent.parent.parent / "VERSION"
-                if version_file.exists():
-                    version = version_file.read_text().strip()
+                # Use centralized path management for VERSION file
+                if paths.version_file.exists():
+                    version = paths.version_file.read_text().strip()
                     method_used = "version_file"
                     self.logger.debug(f"Version obtained via VERSION file: {version}")
                 else:
-                    self.logger.debug(f"VERSION file not found at: {version_file}")
+                    self.logger.debug(f"VERSION file not found at: {paths.version_file}")
             except Exception as e:
                 self.logger.warning(f"Failed to read VERSION file: {e}")
         
@@ -832,10 +1137,14 @@ class ClaudeRunner:
                 return
             
             # Import hook classes (lazy import to avoid circular dependencies)
-            from claude_mpm.hooks.memory_integration_hook import (
-                MemoryPreDelegationHook,
-                MemoryPostDelegationHook
-            )
+            try:
+                from claude_mpm.hooks.memory_integration_hook import (
+                    MemoryPreDelegationHook,
+                    MemoryPostDelegationHook
+                )
+            except ImportError as e:
+                self.logger.warning(f"Memory integration hooks not available: {e}")
+                return
             
             # Register pre-delegation hook for memory injection
             pre_hook = MemoryPreDelegationHook(self.config)
@@ -862,6 +1171,8 @@ class ClaudeRunner:
             post_count = len(hooks.get('post_delegation', []))
             self.logger.info(f"📋 Hook Service initialized: {pre_count} pre-delegation, {post_count} post-delegation hooks")
             
+        except AttributeError as e:
+            self.logger.warning(f"Hook service not initialized properly: {e}")
         except Exception as e:
             self.logger.error(f"❌ Failed to register memory hooks: {e}")
             # Don't fail the entire initialization - memory system is optional

claude_mpm/core/config.py

@@ -11,6 +11,7 @@ from typing import Any, Dict, Optional, Union
 import logging
 
 from ..utils.config_manager import ConfigurationManager
+from .config_paths import ConfigPaths
 
 logger = logging.getLogger(__name__)
 
@@ -51,6 +52,11 @@ class Config:
         # Load from file if provided
         if config_file:
             self.load_file(config_file)
+        else:
+            # Try to load from standard location: .claude-mpm/configuration.yaml
+            default_config = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+            if default_config.exists():
+                self.load_file(default_config)
 
         # Load from environment variables (new and legacy prefixes)
         self._load_env_vars()
@@ -220,7 +226,7 @@ class Config:
             "fallback_tracking_method": "logging",  # Options: "logging", "file", "disabled"
             # Evaluation system - Phase 2 Mirascope integration
             "enable_evaluation": True,
-            "evaluation_storage_path": str(Path.home() / ".claude-pm" / "training"),
+            "evaluation_storage_path": str(ConfigPaths.get_user_config_dir() / "training"),
             "correction_capture_enabled": True,
             "correction_storage_rotation_days": 30,
             "evaluation_logging_enabled": True,

claude_mpm/core/config_aliases.py

@@ -5,10 +5,10 @@ Manages friendly directory aliases for configuration paths, allowing users to
 reference configurations using memorable names instead of full paths.
 
 Example:
-    claude-pm --config personal  # Resolves to ~/.claude-pm/configs/personal/
+    claude-pm --config personal  # Resolves to ~/.claude-mpm/configs/personal/
     claude-pm --config work      # Resolves to ~/work/claude-configs/
 
-Aliases are stored in ~/.claude-pm/config_aliases.json
+Aliases are stored in ~/.claude-mpm/config_aliases.json
 """
 
 import json
@@ -18,6 +18,7 @@ from pathlib import Path
 from typing import Dict, Optional, List, Tuple
 
 from ..utils.config_manager import ConfigurationManager
+from .config_paths import ConfigPaths
 
 logger = logging.getLogger(__name__)
 
@@ -59,7 +60,7 @@ class ConfigAliasManager:
                          ~/.claude-pm/config_aliases.json
         """
         if aliases_file is None:
-            self.aliases_file = Path.home() / ".claude-pm" / "config_aliases.json"
+            self.aliases_file = ConfigPaths.get_user_config_dir() / "config_aliases.json"
         else:
             self.aliases_file = Path(aliases_file)