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

claude_mpm/core/config_paths.py

@@ -0,0 +1,151 @@
+"""
+Centralized configuration paths for claude-mpm.
+
+This module provides a single source of truth for all configuration-related paths
+throughout the codebase. All modules should import and use these constants
+instead of hardcoding directory names.
+"""
+
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+
+class ConfigDirName(Enum):
+    """Enum for configuration directory names to ensure type safety."""
+    CLAUDE_MPM = ".claude-mpm"
+
+
+# Core configuration directory name - MUST be consistent everywhere
+CONFIG_DIR_NAME = ConfigDirName.CLAUDE_MPM.value
+
+# Legacy name that should NOT be used (kept for reference during migration)
+_LEGACY_CONFIG_DIR_NAME = ".claude-pm"  # DO NOT USE THIS
+
+
+class ConfigPaths:
+    """Centralized configuration path constants."""
+    
+    # Base directory names
+    CONFIG_DIR = ConfigDirName.CLAUDE_MPM.value
+    AGENTS_DIR = "agents"
+    BACKUPS_DIR = "backups"
+    TRACKING_DIR = "agent_tracking"
+    MEMORIES_DIR = "memories"
+    RESPONSES_DIR = "responses"
+    
+    # Agent subdirectories
+    AGENT_PROJECT_SPECIFIC = "project-specific"
+    AGENT_USER_AGENTS = "user-agents"
+    AGENT_USER_DEFINED = "user-defined"
+    AGENT_SYSTEM = "templates"
+    
+    # Configuration files
+    CONFIG_FILE = "config.json"
+    CONFIGURATION_YAML = "configuration.yaml"
+    LIFECYCLE_RECORDS = "lifecycle_records.json"
+    VERSION_FILE = "VERSION"
+    INSTRUCTIONS_FILE = "INSTRUCTIONS.md"
+    
+    @classmethod
+    def get_user_config_dir(cls) -> Path:
+        """Get the user-level configuration directory."""
+        return Path.home() / cls.CONFIG_DIR
+    
+    @classmethod
+    def get_project_config_dir(cls, project_root: Optional[Path] = None) -> Path:
+        """Get the project-level configuration directory."""
+        root = project_root or Path.cwd()
+        return root / cls.CONFIG_DIR
+    
+    @classmethod
+    def get_framework_config_dir(cls, framework_root: Path) -> Path:
+        """Get the framework-level configuration directory."""
+        return framework_root / cls.CONFIG_DIR
+    
+    @classmethod
+    def get_user_agents_dir(cls) -> Path:
+        """Get the user-level agents directory."""
+        return cls.get_user_config_dir() / cls.AGENTS_DIR
+    
+    @classmethod
+    def get_project_agents_dir(cls, project_root: Optional[Path] = None) -> Path:
+        """Get the project-level agents directory."""
+        return cls.get_project_config_dir(project_root) / cls.AGENTS_DIR
+    
+    @classmethod
+    def get_tracking_dir(cls) -> Path:
+        """Get the agent tracking directory."""
+        return cls.get_user_config_dir() / cls.TRACKING_DIR
+    
+    @classmethod
+    def get_backups_dir(cls, base_dir: Optional[Path] = None) -> Path:
+        """Get the backups directory."""
+        if base_dir:
+            return base_dir / cls.CONFIG_DIR / cls.BACKUPS_DIR
+        return cls.get_user_config_dir() / cls.BACKUPS_DIR
+    
+    @classmethod
+    def get_memories_dir(cls, base_dir: Optional[Path] = None) -> Path:
+        """Get the memories directory."""
+        if base_dir:
+            return base_dir / cls.CONFIG_DIR / cls.MEMORIES_DIR
+        return cls.get_project_config_dir() / cls.MEMORIES_DIR
+    
+    @classmethod
+    def get_responses_dir(cls, base_dir: Optional[Path] = None) -> Path:
+        """Get the responses directory."""
+        if base_dir:
+            return base_dir / cls.CONFIG_DIR / cls.RESPONSES_DIR
+        return cls.get_project_config_dir() / cls.RESPONSES_DIR
+    
+    @classmethod
+    def find_config_dir(cls, start_path: Optional[Path] = None) -> Optional[Path]:
+        """
+        Find the nearest configuration directory by walking up the directory tree.
+        
+        Args:
+            start_path: Starting directory (defaults to current working directory)
+            
+        Returns:
+            Path to the configuration directory if found, None otherwise
+        """
+        current = start_path or Path.cwd()
+        
+        # Check current directory and parents
+        for path in [current] + list(current.parents):
+            config_dir = path / cls.CONFIG_DIR
+            if config_dir.exists():
+                return config_dir
+        
+        return None
+    
+    @classmethod
+    def validate_not_legacy(cls, path: Path) -> bool:
+        """
+        Check if a path contains the legacy configuration directory name.
+        
+        Args:
+            path: Path to check
+            
+        Returns:
+            True if path is valid (not legacy), False if it contains legacy name
+        """
+        path_str = str(path)
+        return _LEGACY_CONFIG_DIR_NAME not in path_str
+
+
+# Export commonly used paths as module-level constants for convenience
+USER_CONFIG_DIR = ConfigPaths.get_user_config_dir()
+USER_AGENTS_DIR = ConfigPaths.get_user_agents_dir()
+USER_TRACKING_DIR = ConfigPaths.get_tracking_dir()
+
+# Export all public symbols
+__all__ = [
+    "ConfigDirName",
+    "ConfigPaths",
+    "CONFIG_DIR_NAME",
+    "USER_CONFIG_DIR",
+    "USER_AGENTS_DIR",
+    "USER_TRACKING_DIR",
+]

claude_mpm/core/factories.py

@@ -12,9 +12,8 @@ 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 ..orchestration.factory import OrchestratorFactory
-from ..orchestration.base import BaseOrchestrator
+from ..services import AgentDeploymentService
+# Note: Orchestration functionality has been replaced by claude_runner
 
 logger = get_logger(__name__)
 
@@ -32,52 +31,7 @@ class ServiceFactory(ABC):
 
 
 
-class OrchestratorFactoryWrapper(ServiceFactory):
-    """Factory wrapper for creating orchestrator instances."""
-    
-    def __init__(self):
-        """Initialize the factory wrapper."""
-        self._factory = OrchestratorFactory()
-        
-    def create(
-        self,
-        container: DIContainer,
-        orchestrator_type: Optional[str] = None,
-        **kwargs
-    ) -> BaseOrchestrator:
-        """
-        Create an orchestrator instance.
-        
-        Args:
-            container: DI container
-            orchestrator_type: Type of orchestrator to create
-            **kwargs: Additional arguments for orchestrator
-            
-        Returns:
-            Orchestrator instance
-        """
-        config = container.resolve(Config)
-        
-        # Get orchestrator type from config if not provided
-        if orchestrator_type is None:
-            orchestrator_type = config.get('orchestrator.type', 'subprocess')
-            
-        # Get orchestrator config
-        orch_config = config.get(f'orchestrator.{orchestrator_type}', {})
-        
-        # Merge with provided kwargs
-        orch_config.update(kwargs)
-        
-        # No hook manager injection needed - Claude Code hooks are external
-            
-        # Create orchestrator
-        orchestrator = self._factory.create_orchestrator(
-            orchestrator_type,
-            **orch_config
-        )
-        
-        logger.info(f"Created {orchestrator_type} orchestrator")
-        return orchestrator
+# OrchestratorFactoryWrapper has been removed - orchestration replaced by claude_runner
 
 
 class AgentServiceFactory(ServiceFactory):
@@ -204,7 +158,7 @@ class FactoryRegistry:
     def __init__(self):
         """Initialize factory registry."""
         self._factories: Dict[str, ServiceFactory] = {
-            'orchestrator': OrchestratorFactoryWrapper(),
+            # 'orchestrator' removed - replaced by claude_runner
             'agent_service': AgentServiceFactory(),
             'session_manager': SessionManagerFactory(),
             'configuration': ConfigurationFactory(),

claude_mpm/core/logger.py

@@ -18,13 +18,8 @@ from enum import Enum
 from collections import defaultdict
 import functools
 
-# Optional Rich support
-try:
-    from rich.logging import RichHandler
-    from rich.console import Console
-    HAS_RICH = True
-except ImportError:
-    HAS_RICH = False
+# Rich support has been removed
+HAS_RICH = False
 
 
 class LogLevel(Enum):
@@ -150,7 +145,7 @@ def setup_logging(
         log_file: Specific log file path (overrides log_dir)
         console_output: Enable console output
         file_output: Enable file output
-        use_rich: Use Rich handler for colored console output
+        use_rich: (Deprecated) Rich support has been removed
         json_format: Use JSON format for structured logging
         use_streaming: Use streaming handler for single-line INFO messages
         
@@ -187,10 +182,10 @@ def setup_logging(
             # Use streaming handler for single-line INFO messages
             console_handler = StreamingHandler(sys.stdout)
             console_handler.setFormatter(simple_formatter)
-        elif use_rich and HAS_RICH and not json_format:
-            console = Console(stderr=True)
-            console_handler = RichHandler(console=console, show_time=True, show_path=True, markup=True)
-            console_handler.setFormatter(logging.Formatter(fmt="%(message)s", datefmt="[%X]"))
+        elif use_rich and not json_format:
+            # Rich support has been removed, use standard handler
+            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler.setFormatter(simple_formatter)
         else:
             console_handler = logging.StreamHandler(sys.stdout)
             console_handler.setFormatter(formatter if json_format else simple_formatter)
@@ -212,7 +207,10 @@ def setup_logging(
         else:
             # Use default log directory
             if log_dir is None:
-                log_dir = Path.home() / ".claude-mpm" / "logs"
+                # Use deployment root for logs to keep everything centralized
+                from claude_mpm.deployment_paths import get_project_root
+                deployment_root = get_project_root()
+                log_dir = deployment_root / ".claude-mpm" / "logs"
             
             log_dir.mkdir(parents=True, exist_ok=True)
             

claude_mpm/core/service_registry.py

@@ -36,9 +36,9 @@ class ServiceRegistry:
         
     def register_core_services(self) -> None:
         """Register all core framework services."""
-        from ..services.shared_prompt_cache import SharedPromptCache
+        from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
         from ..services.ticket_manager import TicketManager
-        from ..services.agent_deployment import AgentDeploymentService
+        from ..services import AgentDeploymentService
         from .session_manager import SessionManager
         from .agent_session_manager import AgentSessionManager
         from .config import Config

claude_mpm/dashboard/static/js/components/agent-inference.js

@@ -77,6 +77,14 @@ class AgentInference {
         // Direct event detection (highest confidence) - from design doc
         if (eventType === 'SubagentStop' || subtype === 'subagent_stop') {
             const agentName = this.extractAgentNameFromEvent(event);
+            // Log SubagentStop events for debugging
+            console.log('SubagentStop event detected:', {
+                agentName: agentName,
+                sessionId: sessionId,
+                eventType: eventType,
+                subtype: subtype,
+                rawAgentType: event.agent_type || data.agent_type
+            });
             return {
                 type: 'subagent',
                 confidence: 'definitive',
@@ -98,6 +106,12 @@ class AgentInference {
         if (toolName === 'Task') {
             const agentName = this.extractSubagentTypeFromTask(event);
             if (agentName) {
+                // Log Task delegations for debugging
+                console.log('Task delegation detected:', {
+                    agentName: agentName,
+                    sessionId: sessionId,
+                    eventType: eventType
+                });
                 return {
                     type: 'subagent',
                     confidence: 'high',
@@ -141,7 +155,7 @@ class AgentInference {
             return {
                 type: 'subagent',
                 confidence: 'high',
-                agentName: subagentType,
+                agentName: this.normalizeAgentName(subagentType),
                 reason: 'subagent_type field'
             };
         }
@@ -150,7 +164,7 @@ class AgentInference {
             return {
                 type: 'subagent',
                 confidence: 'medium',
-                agentName: agentType,
+                agentName: this.normalizeAgentName(agentType),
                 reason: 'agent_type field'
             };
         }
@@ -160,7 +174,7 @@ class AgentInference {
             return {
                 type: 'subagent',
                 confidence: 'high',
-                agentName: data.delegation_details.agent_type,
+                agentName: this.normalizeAgentName(data.delegation_details.agent_type),
                 reason: 'delegation_details'
             };
         }
@@ -169,12 +183,30 @@ class AgentInference {
         if (event.type && event.type.startsWith('hook.')) {
             // Extract the hook type
             const hookType = event.type.replace('hook.', '');
+            
+            // Handle SubagentStart events
+            if (hookType === 'subagent_start' || (data.hook_event_name === 'SubagentStart')) {
+                const rawAgentName = data.agent_type || data.agent_id || 'Subagent';
+                console.log('SubagentStart event from Socket.IO:', {
+                    agentName: rawAgentName,
+                    sessionId: sessionId,
+                    hookType: hookType
+                });
+                return {
+                    type: 'subagent',
+                    confidence: 'definitive',
+                    agentName: this.normalizeAgentName(rawAgentName),
+                    reason: 'Socket.IO hook SubagentStart'
+                };
+            }
+            
+            // Handle SubagentStop events
             if (hookType === 'subagent_stop' || (data.hook_event_name === 'SubagentStop')) {
-                const agentName = data.agent_type || data.agent_id || 'Subagent';
+                const rawAgentName = data.agent_type || data.agent_id || 'Subagent';
                 return {
                     type: 'subagent',
                     confidence: 'high',
-                    agentName: agentName,
+                    agentName: this.normalizeAgentName(rawAgentName),
                     reason: 'Socket.IO hook SubagentStop'
                 };
             }
@@ -189,33 +221,77 @@ class AgentInference {
         };
     }
 
+    /**
+     * Normalize agent name from lowercase/underscore format to display format
+     * @param {string} agentName - Raw agent name (e.g., 'engineer', 'test_integration')
+     * @returns {string} - Normalized display name (e.g., 'Engineer Agent', 'Test Integration Agent')
+     */
+    normalizeAgentName(agentName) {
+        if (!agentName) return 'Unknown';
+        
+        // Agent name mapping from raw format to display format
+        const agentNameMap = {
+            'engineer': 'Engineer Agent',
+            'research': 'Research Agent',
+            'qa': 'QA Agent',
+            'documentation': 'Documentation Agent',
+            'security': 'Security Agent',
+            'ops': 'Ops Agent',
+            'version_control': 'Version Control Agent',
+            'data_engineer': 'Data Engineer Agent',
+            'test_integration': 'Test Integration Agent',
+            'pm': 'PM Agent'
+        };
+        
+        // Check if we have a direct mapping
+        const normalized = agentNameMap[agentName.toLowerCase()];
+        if (normalized) {
+            return normalized;
+        }
+        
+        // If no direct mapping, apply basic formatting:
+        // Convert underscore to space, capitalize words, and add "Agent" if not present
+        let formatted = agentName
+            .replace(/_/g, ' ')
+            .split(' ')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join(' ');
+        
+        // Add "Agent" suffix if not already present
+        if (!formatted.toLowerCase().includes('agent')) {
+            formatted += ' Agent';
+        }
+        
+        return formatted;
+    }
+
     /**
      * Extract subagent type from Task tool parameters
      * @param {Object} event - Event with Task tool
      * @returns {string|null} - Subagent type or null
      */
     extractSubagentTypeFromTask(event) {
+        let rawAgentName = null;
+        
         // Check tool_parameters directly
         if (event.tool_parameters?.subagent_type) {
-            return event.tool_parameters.subagent_type;
+            rawAgentName = event.tool_parameters.subagent_type;
         }
-        
         // Check nested in data.tool_parameters (hook events)
-        if (event.data?.tool_parameters?.subagent_type) {
-            return event.data.tool_parameters.subagent_type;
+        else if (event.data?.tool_parameters?.subagent_type) {
+            rawAgentName = event.data.tool_parameters.subagent_type;
         }
-        
         // Check delegation_details (new structure)
-        if (event.data?.delegation_details?.agent_type) {
-            return event.data.delegation_details.agent_type;
+        else if (event.data?.delegation_details?.agent_type) {
+            rawAgentName = event.data.delegation_details.agent_type;
         }
-        
         // Check tool_input fallback
-        if (event.tool_input?.subagent_type) {
-            return event.tool_input.subagent_type;
+        else if (event.tool_input?.subagent_type) {
+            rawAgentName = event.tool_input.subagent_type;
         }
         
-        return null;
+        // Normalize the agent name before returning
+        return rawAgentName ? this.normalizeAgentName(rawAgentName) : null;
     }
 
     /**
@@ -235,40 +311,40 @@ class AgentInference {
         
         // 2. Direct subagent_type field
         if (event.subagent_type && event.subagent_type !== 'unknown') {
-            return event.subagent_type;
+            return this.normalizeAgentName(event.subagent_type);
         }
         if (data.subagent_type && data.subagent_type !== 'unknown') {
-            return data.subagent_type;
+            return this.normalizeAgentName(data.subagent_type);
         }
         
         // 2.5. Check delegation_details
         if (data.delegation_details?.agent_type && data.delegation_details.agent_type !== 'unknown') {
-            return data.delegation_details.agent_type;
+            return this.normalizeAgentName(data.delegation_details.agent_type);
         }
         
         // 3. Agent type fields (but not 'main' or 'unknown')
         if (event.agent_type && !['main', 'unknown'].includes(event.agent_type)) {
-            return event.agent_type;
+            return this.normalizeAgentName(event.agent_type);
         }
         if (data.agent_type && !['main', 'unknown'].includes(data.agent_type)) {
-            return data.agent_type;
+            return this.normalizeAgentName(data.agent_type);
         }
         
         // 4. Agent ID field as fallback
         if (event.agent_id && !['main', 'unknown'].includes(event.agent_id)) {
-            return event.agent_id;
+            return this.normalizeAgentName(event.agent_id);
         }
         if (data.agent_id && !['main', 'unknown'].includes(data.agent_id)) {
-            return data.agent_id;
+            return this.normalizeAgentName(data.agent_id);
         }
         
         // 5. Other fallbacks
         if (event.agent && event.agent !== 'unknown') {
-            return event.agent;
+            return this.normalizeAgentName(event.agent);
         }
         
         if (event.name && event.name !== 'unknown') {
-            return event.name;
+            return this.normalizeAgentName(event.name);
         }
         
         // Default fallback

claude_mpm/dashboard/static/js/components/event-processor.js

@@ -324,9 +324,10 @@ class EventProcessor {
         
         return filteredInstances.map((instance, index) => {
             const agentName = instance.agentName;
-            const timestamp = this.formatTimestamp(instance.timestamp);
+            const timestamp = this.formatTimestamp(instance.firstTimestamp || instance.timestamp);
             const delegationType = instance.isImplied ? 'implied' : 'explicit';
-            const eventCount = instance.eventCount || 0;
+            // Fix: Use totalEventCount which is the actual property name from getUniqueAgentInstances()
+            const eventCount = instance.totalEventCount || instance.eventCount || 0;
             
             const onclickString = `dashboard.selectCard('agents', ${index}, 'agent_instance', '${instance.id}'); dashboard.showAgentInstanceDetails('${instance.id}');`;