claude-mpm 3.4.26__py3-none-any.whl → 3.5.0__py3-none-any.whl

claude_mpm/config/paths.py

@@ -0,0 +1,322 @@
+"""
+Centralized path management for claude-mpm.
+
+This module provides a consistent, reliable way to access project paths
+without fragile parent.parent.parent patterns.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional, Union
+from functools import cached_property
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeMPMPaths:
+    """
+    Centralized path management for the claude-mpm project.
+    
+    This class provides a singleton instance with properties for all common paths
+    in the project, eliminating the need for fragile Path(__file__).parent.parent patterns.
+    
+    Usage:
+        from claude_mpm.config.paths import paths
+        
+        # Access common paths
+        project_root = paths.project_root
+        agents_dir = paths.agents_dir
+        config_file = paths.config_dir / "some_config.yaml"
+    """
+    
+    _instance: Optional['ClaudeMPMPaths'] = None
+    _project_root: Optional[Path] = None
+    
+    def __new__(cls) -> 'ClaudeMPMPaths':
+        """Singleton pattern to ensure single instance."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        """Initialize paths if not already done."""
+        if self._project_root is None:
+            self._detect_project_root()
+    
+    def _detect_project_root(self) -> None:
+        """
+        Detect the project root directory.
+        
+        Strategy:
+        1. Look for definitive project markers (pyproject.toml, setup.py)
+        2. Look for combination of markers to ensure we're at the right level
+        3. Walk up from current file location
+        """
+        # Start from this file's location
+        current = Path(__file__).resolve()
+        
+        # Walk up the directory tree
+        for parent in current.parents:
+            # Check for definitive project root indicators
+            # Prioritize pyproject.toml and setup.py as they're only at root
+            if (parent / 'pyproject.toml').exists() or (parent / 'setup.py').exists():
+                self._project_root = parent
+                logger.debug(f"Project root detected at: {parent} (found pyproject.toml or setup.py)")
+                return
+            
+            # Secondary check: .git directory + VERSION file together
+            # This combination is more likely to be the real project root
+            if (parent / '.git').exists() and (parent / 'VERSION').exists():
+                self._project_root = parent
+                logger.debug(f"Project root detected at: {parent} (found .git and VERSION)")
+                return
+        
+        # Fallback: walk up to find claude-mpm directory name
+        for parent in current.parents:
+            if parent.name == 'claude-mpm':
+                self._project_root = parent
+                logger.debug(f"Project root detected at: {parent} (by directory name)")
+                return
+        
+        # Last resort fallback: 3 levels up from this file
+        # paths.py is in src/claude_mpm/config/
+        self._project_root = current.parent.parent.parent
+        logger.warning(f"Project root fallback to: {self._project_root}")
+    
+    @property
+    def project_root(self) -> Path:
+        """Get the project root directory."""
+        if self._project_root is None:
+            self._detect_project_root()
+        return self._project_root
+    
+    @property
+    def src_dir(self) -> Path:
+        """Get the src directory."""
+        return self.project_root / "src"
+    
+    @property
+    def claude_mpm_dir(self) -> Path:
+        """Get the main claude_mpm package directory."""
+        return self.src_dir / "claude_mpm"
+    
+    @property
+    def agents_dir(self) -> Path:
+        """Get the agents directory."""
+        return self.claude_mpm_dir / "agents"
+    
+    @property
+    def services_dir(self) -> Path:
+        """Get the services directory."""
+        return self.claude_mpm_dir / "services"
+    
+    @property
+    def hooks_dir(self) -> Path:
+        """Get the hooks directory."""
+        return self.claude_mpm_dir / "hooks"
+    
+    @property
+    def config_dir(self) -> Path:
+        """Get the config directory."""
+        return self.claude_mpm_dir / "config"
+    
+    @property
+    def cli_dir(self) -> Path:
+        """Get the CLI directory."""
+        return self.claude_mpm_dir / "cli"
+    
+    @property
+    def core_dir(self) -> Path:
+        """Get the core directory."""
+        return self.claude_mpm_dir / "core"
+    
+    @property
+    def schemas_dir(self) -> Path:
+        """Get the schemas directory."""
+        return self.claude_mpm_dir / "schemas"
+    
+    @property
+    def scripts_dir(self) -> Path:
+        """Get the scripts directory."""
+        return self.project_root / "scripts"
+    
+    @property
+    def tests_dir(self) -> Path:
+        """Get the tests directory."""
+        return self.project_root / "tests"
+    
+    @property
+    def docs_dir(self) -> Path:
+        """Get the documentation directory."""
+        return self.project_root / "docs"
+    
+    @property
+    def logs_dir(self) -> Path:
+        """Get the logs directory (creates if doesn't exist)."""
+        logs = self.project_root / "logs"
+        logs.mkdir(exist_ok=True)
+        return logs
+    
+    @property
+    def temp_dir(self) -> Path:
+        """Get the temporary files directory (creates if doesn't exist)."""
+        temp = self.project_root / ".tmp"
+        temp.mkdir(exist_ok=True)
+        return temp
+    
+    @property
+    def claude_mpm_dir_hidden(self) -> Path:
+        """Get the hidden .claude-mpm directory (creates if doesn't exist)."""
+        hidden = self.project_root / ".claude-mpm"
+        hidden.mkdir(exist_ok=True)
+        return hidden
+    
+    @cached_property
+    def version_file(self) -> Path:
+        """Get the VERSION file path."""
+        return self.project_root / "VERSION"
+    
+    @cached_property
+    def pyproject_file(self) -> Path:
+        """Get the pyproject.toml file path."""
+        return self.project_root / "pyproject.toml"
+    
+    @cached_property
+    def package_json_file(self) -> Path:
+        """Get the package.json file path."""
+        return self.project_root / "package.json"
+    
+    @cached_property
+    def claude_md_file(self) -> Path:
+        """Get the CLAUDE.md file path."""
+        return self.project_root / "CLAUDE.md"
+    
+    def get_version(self) -> str:
+        """
+        Get the project version from various sources.
+        
+        Returns:
+            Version string or 'unknown' if not found.
+        """
+        # Try VERSION file first
+        if self.version_file.exists():
+            return self.version_file.read_text().strip()
+        
+        # Try package metadata
+        try:
+            from importlib.metadata import version
+            return version('claude-mpm')
+        except Exception:
+            pass
+        
+        return 'unknown'
+    
+    def ensure_in_path(self) -> None:
+        """Ensure src directory is in Python path."""
+        src_str = str(self.src_dir)
+        if src_str not in sys.path:
+            sys.path.insert(0, src_str)
+    
+    def relative_to_project(self, path: Union[str, Path]) -> Path:
+        """
+        Get a path relative to the project root.
+        
+        Args:
+            path: Path to make relative
+            
+        Returns:
+            Path relative to project root
+        """
+        abs_path = Path(path).resolve()
+        try:
+            return abs_path.relative_to(self.project_root)
+        except ValueError:
+            return abs_path
+    
+    def resolve_config_path(self, config_name: str) -> Path:
+        """
+        Resolve a configuration file path.
+        
+        Args:
+            config_name: Name of the config file
+            
+        Returns:
+            Full path to the config file
+        """
+        # Check in config directory first
+        config_path = self.config_dir / config_name
+        if config_path.exists():
+            return config_path
+        
+        # Check in project root
+        root_path = self.project_root / config_name
+        if root_path.exists():
+            return root_path
+        
+        # Return config dir path as default
+        return config_path
+    
+    def __str__(self) -> str:
+        """String representation."""
+        return f"ClaudeMPMPaths(root={self.project_root})"
+    
+    def __repr__(self) -> str:
+        """Developer representation."""
+        return (
+            f"ClaudeMPMPaths(\n"
+            f"  project_root={self.project_root},\n"
+            f"  src_dir={self.src_dir},\n"
+            f"  claude_mpm_dir={self.claude_mpm_dir}\n"
+            f")"
+        )
+
+
+# Singleton instance for import
+paths = ClaudeMPMPaths()
+
+
+# Convenience functions
+def get_project_root() -> Path:
+    """Get the project root directory."""
+    return paths.project_root
+
+
+def get_src_dir() -> Path:
+    """Get the src directory."""
+    return paths.src_dir
+
+
+def get_claude_mpm_dir() -> Path:
+    """Get the main claude_mpm package directory."""
+    return paths.claude_mpm_dir
+
+
+def get_agents_dir() -> Path:
+    """Get the agents directory."""
+    return paths.agents_dir
+
+
+def get_services_dir() -> Path:
+    """Get the services directory."""
+    return paths.services_dir
+
+
+def get_config_dir() -> Path:
+    """Get the config directory."""
+    return paths.config_dir
+
+
+def get_version() -> str:
+    """Get the project version."""
+    return paths.get_version()
+
+
+def ensure_src_in_path() -> None:
+    """Ensure src directory is in Python path."""
+    paths.ensure_in_path()
+
+
+# Auto-ensure src is in path when module is imported
+ensure_src_in_path()

claude_mpm/constants.py

@@ -26,7 +26,6 @@ class CLICommands(str, Enum):
     TICKETS = "tickets"
     INFO = "info"
     AGENTS = "agents"
-    UI = "ui"
     MEMORY = "memory"
     MONITOR = "monitor"
     

claude_mpm/core/__init__.py

@@ -16,9 +16,8 @@ try:
     from .service_registry import ServiceRegistry, get_service_registry, initialize_services
     from .injectable_service import InjectableService
     from .factories import (
-        ServiceFactory, HookManagerFactory, OrchestratorFactoryWrapper,
-        AgentServiceFactory, SessionManagerFactory, ConfigurationFactory,
-        get_factory_registry
+        ServiceFactory, AgentServiceFactory, SessionManagerFactory, 
+        ConfigurationFactory, get_factory_registry
     )
 except ImportError:
     pass
@@ -36,8 +35,6 @@ __all__ = [
     "initialize_services",
     "InjectableService",
     "ServiceFactory",
-    "HookManagerFactory",
-    "OrchestratorFactoryWrapper",
     "AgentServiceFactory",
     "SessionManagerFactory",
     "ConfigurationFactory",

claude_mpm/core/agent_registry.py

@@ -51,29 +51,49 @@ class SimpleAgentRegistry:
         self._discover_agents()
     
     def _discover_agents(self):
-        """Discover agents from the framework."""
-        # Check multiple possible locations
+        """Discover agents from the framework and project."""
+        # Check multiple possible locations, including project-level
         agent_locations = [
+            # Project-level agents (highest priority)
+            Path.cwd() / ".claude-mpm" / "agents",
+            # Framework/system agents
             self.framework_path / "src" / "claude_mpm" / "agents" / "templates",
             self.framework_path / "src" / "claude_mpm" / "agents",
             self.framework_path / "agents",
         ]
         
+        # Track discovered agents to handle precedence
+        discovered_agents = {}
+        
         for agents_dir in agent_locations:
             if agents_dir.exists():
                 # Look for both .md and .json files
                 for pattern in ["*.md", "*.json"]:
                     for agent_file in agents_dir.glob(pattern):
                         agent_id = agent_file.stem
-                        self.agents[agent_id] = {
+                        tier = self._determine_tier(agent_file)
+                        
+                        # Check if we already have this agent
+                        if agent_id in discovered_agents:
+                            existing_tier = discovered_agents[agent_id]['tier']
+                            # Skip if existing has higher precedence
+                            # Precedence: project > user > system
+                            tier_precedence = {'project': 3, 'user': 2, 'system': 1}
+                            if tier_precedence.get(existing_tier, 0) >= tier_precedence.get(tier, 0):
+                                continue
+                        
+                        discovered_agents[agent_id] = {
                             'name': agent_id,
                             'type': agent_id,
                             'path': str(agent_file),
                             'last_modified': agent_file.stat().st_mtime,
-                            'tier': self._determine_tier(agent_file),
+                            'tier': tier,
                             'specializations': self._extract_specializations(agent_id),
                             'description': self._extract_description(agent_id)
                         }
+        
+        # Store the final agents
+        self.agents = discovered_agents
     
     def _determine_tier(self, agent_path: Path) -> str:
         """Determine agent tier based on path."""
@@ -113,11 +133,21 @@ class SimpleAgentRegistry:
         }
         return descriptions.get(agent_id, f'{agent_id.title()} agent')
     
-    def listAgents(self, **kwargs) -> Dict[str, Any]:
-        """List all agents (camelCase for compatibility)."""
+    def list_agents(self, **kwargs) -> Dict[str, Any]:
+        """List all agents."""
         return self.agents
     
-    def list_agents(self, agent_type: Optional[str] = None, tier: Optional[str] = None) -> List[AgentMetadata]:
+    def listAgents(self, **kwargs) -> Dict[str, Any]:
+        """DEPRECATED: Use list_agents() instead. Kept for backward compatibility."""
+        import warnings
+        warnings.warn(
+            "listAgents() is deprecated, use list_agents() instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return self.list_agents(**kwargs)
+    
+    def list_agents_filtered(self, agent_type: Optional[str] = None, tier: Optional[str] = None) -> List[AgentMetadata]:
         """List agents with optional filtering."""
         results = []
         for agent_id, metadata in self.agents.items():
@@ -294,7 +324,7 @@ class AgentRegistryAdapter:
             return {}
         
         try:
-            return self.registry.listAgents(**kwargs)
+            return self.registry.list_agents(**kwargs)
         except Exception as e:
             self.logger.error(f"Error listing agents: {e}")
             return {}
@@ -314,7 +344,7 @@ class AgentRegistryAdapter:
         
         try:
             # Try to load agent definition
-            agents = self.registry.listAgents()
+            agents = self.registry.list_agents()
             for agent_id, metadata in agents.items():
                 if agent_name in agent_id or agent_name == metadata.get('type'):
                     # Load the agent file
@@ -344,7 +374,7 @@ class AgentRegistryAdapter:
         
         try:
             # Get agents with required specializations
-            agents = self.registry.listAgents()
+            agents = self.registry.list_agents()
             
             if required_specializations:
                 # Filter by specializations
@@ -386,7 +416,7 @@ class AgentRegistryAdapter:
         
         try:
             # Get all agents
-            all_agents = self.registry.listAgents()
+            all_agents = self.registry.list_agents()
             
             hierarchy = {
                 'project': [],
@@ -526,18 +556,33 @@ def get_specialized_agent_types() -> Set[str]:
         return adapter.registry.specialized_agent_types
     return set()
 
-def listAgents() -> Dict[str, Dict[str, Any]]:
+def list_agents_all() -> Dict[str, Dict[str, Any]]:
     """
-    Synchronous function for listing all agents (camelCase compatibility)
+    Synchronous function for listing all agents
     
     Returns:
         Dictionary of agent name -> agent metadata
     """
     adapter = AgentRegistryAdapter()
     if adapter.registry:
-        return adapter.registry.listAgents()
+        return adapter.registry.list_agents()
     return {}
 
+def listAgents() -> Dict[str, Dict[str, Any]]:
+    """
+    DEPRECATED: Use list_agents_all() instead. Kept for backward compatibility.
+    
+    Returns:
+        Dictionary of agent name -> agent metadata
+    """
+    import warnings
+    warnings.warn(
+        "listAgents() is deprecated, use list_agents_all() instead",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return list_agents_all()
+
 def list_agents(agent_type: Optional[str] = None, tier: Optional[str] = None) -> List[AgentMetadata]:
     """
     Synchronous function to list agents with optional filtering
@@ -551,7 +596,7 @@ def list_agents(agent_type: Optional[str] = None, tier: Optional[str] = None) ->
     """
     adapter = AgentRegistryAdapter()
     if adapter.registry:
-        return adapter.registry.list_agents(agent_type=agent_type, tier=tier)
+        return adapter.registry.list_agents_filtered(agent_type=agent_type, tier=tier)
     return []
 
 def discover_agents_sync(force_refresh: bool = False) -> Dict[str, AgentMetadata]:
@@ -600,7 +645,7 @@ def get_registry_stats() -> Dict[str, Any]:
     """
     adapter = AgentRegistryAdapter()
     if adapter.registry:
-        agents = adapter.registry.list_agents()
+        agents = adapter.registry.list_agents_filtered()
         return {
             'total_agents': len(agents),
             'agent_types': len(set(a.type for a in agents)),
@@ -619,8 +664,9 @@ __all__ = [
     'discover_agents',
     'get_core_agent_types',
     'get_specialized_agent_types',
-    'listAgents',
+    'list_agents_all',
     'list_agents',
+    'listAgents',  # Deprecated
     'discover_agents_sync',
     'get_agent',
     'get_registry_stats'