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

claude_mpm/init.py

@@ -71,18 +71,23 @@ class ProjectInitializer:
           - agents/
             - project-specific/
           - config/
+          - responses/
           - logs/
         """
         try:
-            # Find project root
+            # Find project root - always define project_root for consistent messaging
             if project_path:
+                project_root = project_path
                 self.project_dir = project_path / ".claude-mpm"
             else:
-                project_root = self._find_project_root()
-                if not project_root:
-                    project_root = Path.cwd()
+                # Always use current working directory for project directories
+                # This ensures .claude-mpm is created where the user launches the tool
+                project_root = Path.cwd()
                 self.project_dir = project_root / ".claude-mpm"
             
+            # Check if directory already exists
+            directory_existed = self.project_dir.exists()
+            
             # Create project directory
             self.project_dir.mkdir(exist_ok=True)
             
@@ -90,6 +95,7 @@ class ProjectInitializer:
             directories = [
                 self.project_dir / "agents" / "project-specific",
                 self.project_dir / "config",
+                self.project_dir / "responses",
                 self.project_dir / "logs",
             ]
             
@@ -106,11 +112,21 @@ class ProjectInitializer:
             if not gitignore.exists():
                 gitignore.write_text("logs/\n*.log\n*.pyc\n__pycache__/\n")
             
+            # Log successful creation with details
             self.logger.info(f"Initialized project directory at {self.project_dir}")
+            self.logger.debug(f"Created directories: agents, config, responses, logs")
+            
+            # Print appropriate message to console for visibility during startup
+            if directory_existed:
+                print(f"✓ Found existing .claude-mpm/ directory in {project_root}")
+            else:
+                print(f"✓ Initialized .claude-mpm/ in {project_root}")
+            
             return True
             
         except Exception as e:
             self.logger.error(f"Failed to initialize project directory: {e}")
+            print(f"✗ Failed to create .claude-mpm/ directory: {e}")
             return False
     
     def _find_project_root(self) -> Optional[Path]:
@@ -198,7 +214,6 @@ class ProjectInitializer:
             'ai_trackdown_pytools',
             'yaml',
             'dotenv',
-            'rich',
             'click',
             'pexpect',
             'psutil',
@@ -218,9 +233,25 @@ class ProjectInitializer:
         return dependencies
     
     def ensure_initialized(self) -> bool:
-        """Ensure both user and project directories are initialized."""
+        """Ensure both user and project directories are initialized.
+        
+        Shows clear information about where directories are being created.
+        """
+        # Show working directory info at startup
+        cwd = Path.cwd()
+        framework_path = Path(__file__).parent.parent.parent
+        
+        # Log startup context
+        self.logger.info(f"Working directory: {cwd}")
+        self.logger.info(f"Framework path: {framework_path}")
+        
+        # Initialize user directory (in home)
         user_ok = self.initialize_user_directory()
+        
+        # Initialize project directory (in current working directory)
+        self.logger.info(f"Checking for .claude-mpm/ in {cwd}")
         project_ok = self.initialize_project_directory()
+        
         return user_ok and project_ok
 
 

claude_mpm/scripts/socketio_daemon.py

@@ -71,8 +71,12 @@ except ImportError:
         print("   3. Check that PYTHONPATH includes the package location")
         sys.exit(1)
 
-PID_FILE = Path.home() / ".claude-mpm" / "socketio-server.pid"
-LOG_FILE = Path.home() / ".claude-mpm" / "socketio-server.log"
+# Use deployment root for daemon files to keep everything centralized
+from claude_mpm.deployment_paths import get_project_root
+
+deployment_root = get_project_root()
+PID_FILE = deployment_root / ".claude-mpm" / "socketio-server.pid"
+LOG_FILE = deployment_root / ".claude-mpm" / "socketio-server.log"
 
 def ensure_dirs():
     """Ensure required directories exist."""

claude_mpm/services/__init__.py

@@ -7,14 +7,48 @@ def __getattr__(name):
         from .ticket_manager import TicketManager
         return TicketManager
     elif name == "AgentDeploymentService":
-        from .agent_deployment import AgentDeploymentService
+        from .agents.deployment import AgentDeploymentService
         return AgentDeploymentService
     elif name == "AgentMemoryManager":
-        from .agent_memory_manager import AgentMemoryManager
+        from .agents.memory import AgentMemoryManager
         return AgentMemoryManager
     elif name == "get_memory_manager":
-        from .agent_memory_manager import get_memory_manager
+        from .agents.memory import get_memory_manager
         return get_memory_manager
+    # Add backward compatibility for other agent services
+    elif name == "AgentRegistry":
+        from .agents.registry import AgentRegistry
+        return AgentRegistry
+    elif name == "AgentLifecycleManager":
+        from .agents.deployment import AgentLifecycleManager
+        return AgentLifecycleManager
+    elif name == "AgentManager":
+        from .agents.management import AgentManager
+        return AgentManager
+    elif name == "AgentCapabilitiesGenerator":
+        from .agents.management import AgentCapabilitiesGenerator
+        return AgentCapabilitiesGenerator
+    elif name == "AgentModificationTracker":
+        from .agents.registry import AgentModificationTracker
+        return AgentModificationTracker
+    elif name == "AgentPersistenceService":
+        from .agents.memory import AgentPersistenceService
+        return AgentPersistenceService
+    elif name == "AgentProfileLoader":
+        from .agents.loading import AgentProfileLoader
+        return AgentProfileLoader
+    elif name == "AgentVersionManager":
+        from .agents.deployment import AgentVersionManager
+        return AgentVersionManager
+    elif name == "BaseAgentManager":
+        from .agents.loading import BaseAgentManager
+        return BaseAgentManager
+    elif name == "DeployedAgentDiscovery":
+        from .agents.registry import DeployedAgentDiscovery
+        return DeployedAgentDiscovery
+    elif name == "FrameworkAgentLoader":
+        from .agents.loading import FrameworkAgentLoader
+        return FrameworkAgentLoader
     elif name == "HookService":
         from .hook_service import HookService
         return HookService
@@ -36,6 +70,22 @@ def __getattr__(name):
     elif name == "StandaloneSocketIOServer":
         from .standalone_socketio_server import StandaloneSocketIOServer
         return StandaloneSocketIOServer
+    # Backward compatibility for memory services
+    elif name == "MemoryBuilder":
+        from .memory.builder import MemoryBuilder
+        return MemoryBuilder
+    elif name == "MemoryRouter":
+        from .memory.router import MemoryRouter
+        return MemoryRouter
+    elif name == "MemoryOptimizer":
+        from .memory.optimizer import MemoryOptimizer
+        return MemoryOptimizer
+    elif name == "SimpleCacheService":
+        from .memory.cache.simple_cache import SimpleCacheService
+        return SimpleCacheService
+    elif name == "SharedPromptCache":
+        from .memory.cache.shared_prompt_cache import SharedPromptCache
+        return SharedPromptCache
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
 __all__ = [
@@ -48,4 +98,22 @@ __all__ = [
     "AdvancedHealthMonitor",
     "RecoveryManager", 
     "StandaloneSocketIOServer",
+    # Additional agent services for backward compatibility
+    "AgentRegistry",
+    "AgentLifecycleManager",
+    "AgentManager",
+    "AgentCapabilitiesGenerator",
+    "AgentModificationTracker",
+    "AgentPersistenceService",
+    "AgentProfileLoader",
+    "AgentVersionManager",
+    "BaseAgentManager",
+    "DeployedAgentDiscovery",
+    "FrameworkAgentLoader",
+    # Memory services (backward compatibility)
+    "MemoryBuilder",
+    "MemoryRouter",
+    "MemoryOptimizer",
+    "SimpleCacheService",
+    "SharedPromptCache",
 ]

claude_mpm/services/agents/__init__.py

@@ -0,0 +1,85 @@
+"""Agent services module - hierarchical organization of agent-related services."""
+
+# Registry exports
+from .registry.agent_registry import (
+    AgentRegistry,
+    AgentMetadata,
+    AgentTier,
+    AgentType,
+)
+from .registry.deployed_agent_discovery import DeployedAgentDiscovery
+from .registry.modification_tracker import (
+    AgentModificationTracker,
+    ModificationType,
+    ModificationTier,
+    AgentModification,
+    ModificationHistory,
+)
+
+# Loading exports
+from .loading.framework_agent_loader import FrameworkAgentLoader
+from .loading.agent_profile_loader import AgentProfileLoader
+from .loading.base_agent_manager import BaseAgentManager
+
+# Deployment exports
+from .deployment.agent_deployment import AgentDeploymentService
+from .deployment.agent_lifecycle_manager import (
+    AgentLifecycleManager,
+    LifecycleState,
+    LifecycleOperation,
+    AgentLifecycleRecord,
+    LifecycleOperationResult,
+)
+from .deployment.agent_versioning import AgentVersionManager
+
+# Memory exports
+from .memory.agent_memory_manager import (
+    AgentMemoryManager,
+    get_memory_manager,
+)
+from .memory.agent_persistence_service import (
+    AgentPersistenceService,
+    PersistenceStrategy,
+    PersistenceOperation,
+    PersistenceRecord,
+)
+
+# Management exports
+from .management.agent_management_service import AgentManager
+from .management.agent_capabilities_generator import AgentCapabilitiesGenerator
+
+__all__ = [
+    # Registry
+    "AgentRegistry",
+    "AgentMetadata",
+    "AgentTier",
+    "AgentType",
+    "DeployedAgentDiscovery",
+    "AgentModificationTracker",
+    "ModificationType",
+    "ModificationTier",
+    "AgentModification",
+    "ModificationHistory",
+    # Loading
+    "FrameworkAgentLoader",
+    "AgentProfileLoader",
+    "BaseAgentManager",
+    # Deployment
+    "AgentDeploymentService",
+    "AgentLifecycleManager",
+    "LifecycleState",
+    "LifecycleOperation",
+    "AgentLifecycleRecord",
+    "LifecycleOperationResult",
+    "AgentVersionManager",
+    # Memory
+    "AgentMemoryManager",
+    "get_memory_manager",
+    "AgentPersistenceService",
+    "PersistenceStrategy",
+    "PersistenceOperation",
+    "PersistenceRecord",
+    # Management
+    "AgentManager",
+    "AgentCapabilitiesGenerator",
+]

claude_mpm/services/agents/deployment/__init__.py

@@ -0,0 +1,21 @@
+"""Agent deployment and lifecycle management services."""
+
+from .agent_deployment import AgentDeploymentService
+from .agent_lifecycle_manager import (
+    AgentLifecycleManager,
+    LifecycleState,
+    LifecycleOperation,
+    AgentLifecycleRecord,
+    LifecycleOperationResult,
+)
+from .agent_versioning import AgentVersionManager
+
+__all__ = [
+    "AgentDeploymentService",
+    "AgentLifecycleManager",
+    "LifecycleState",
+    "LifecycleOperation",
+    "AgentLifecycleRecord",
+    "LifecycleOperationResult",
+    "AgentVersionManager",
+]

claude_mpm/services/{agent_deployment.py → agents/deployment/agent_deployment.py}

@@ -36,6 +36,7 @@ from typing import Optional, List, Dict, Any
 
 from claude_mpm.core.logger import get_logger
 from claude_mpm.constants import EnvironmentVars, Paths, AgentMetadata
+from claude_mpm.config.paths import paths
 
 
 class AgentDeploymentService:
@@ -99,29 +100,32 @@ class AgentDeploymentService:
             'deployment_errors': {}  # Track error types and frequencies
         }
         
-        # Find templates directory
-        module_path = Path(__file__).parent.parent
+        # Find templates directory using centralized path management
         if templates_dir:
             self.templates_dir = Path(templates_dir)
         else:
-            # Default to src/claude_mpm/agents/templates/
-            self.templates_dir = module_path / "agents" / "templates"
+            # Use centralized paths instead of fragile parent calculations
+            self.templates_dir = paths.agents_dir / "templates"
         
         # Find base agent file
         if base_agent_path:
             self.base_agent_path = Path(base_agent_path)
         else:
-            # Default to src/claude_mpm/agents/base_agent.json
-            self.base_agent_path = module_path / "agents" / "base_agent.json"
+            # Use centralized paths for consistency
+            self.base_agent_path = paths.agents_dir / "base_agent.json"
         
         self.logger.info(f"Templates directory: {self.templates_dir}")
         self.logger.info(f"Base agent path: {self.base_agent_path}")
         
-    def deploy_agents(self, target_dir: Optional[Path] = None, force_rebuild: bool = False) -> Dict[str, Any]:
+    def deploy_agents(self, target_dir: Optional[Path] = None, force_rebuild: bool = False, deployment_mode: str = "update") -> Dict[str, Any]:
         """
         Build and deploy agents by combining base_agent.md with templates.
         Also deploys system instructions for PM framework.
         
+        DEPLOYMENT MODES:
+        - "update": Normal update mode - skip agents with matching versions (default)
+        - "project": Project deployment mode - always deploy all agents regardless of version
+        
         METRICS COLLECTED:
         - Deployment start/end timestamps
         - Individual agent deployment durations
@@ -161,6 +165,7 @@ class AgentDeploymentService:
         Args:
             target_dir: Target directory for agents (default: .claude/agents/)
             force_rebuild: Force rebuild even if agents exist (useful for troubleshooting)
+            deployment_mode: "update" for version-aware updates, "project" for always deploy
             
         Returns:
             Dictionary with deployment results:
@@ -176,11 +181,28 @@ class AgentDeploymentService:
         deployment_start_time = time.time()
         
         if not target_dir:
-            target_dir = Path(Paths.CLAUDE_AGENTS_DIR.value).expanduser()
+            # Default to user's home .claude/agents directory
+            agents_dir = Path(Paths.CLAUDE_AGENTS_DIR.value).expanduser()
+        else:
+            # If target_dir provided, use it directly (caller decides structure)
+            # This allows for both passing a project dir or the full agents path
+            target_dir = Path(target_dir)
+            # Check if this is already an agents directory
+            if target_dir.name == "agents":
+                # Already an agents directory, use as-is
+                agents_dir = target_dir
+            elif target_dir.name == ".claude-mpm":
+                # .claude-mpm directory, add agents subdirectory
+                agents_dir = target_dir / "agents"
+            elif target_dir.name == ".claude":
+                # .claude directory, add agents subdirectory
+                agents_dir = target_dir / "agents"
+            else:
+                # Assume it's a project directory, add .claude/agents
+                agents_dir = target_dir / ".claude" / "agents"
         
-        target_dir = Path(target_dir)
         results = {
-            "target_dir": str(target_dir),
+            "target_dir": str(agents_dir),
             "deployed": [],
             "errors": [],
             "skipped": [],
@@ -200,9 +222,9 @@ class AgentDeploymentService:
         }
         
         try:
-            # Create target directory if needed
-            target_dir.mkdir(parents=True, exist_ok=True)
-            self.logger.info(f"Building and deploying agents to: {target_dir}")
+            # Create agents directory if needed
+            agents_dir.mkdir(parents=True, exist_ok=True)
+            self.logger.info(f"Building and deploying agents to: {agents_dir}")
             
             # Note: System instructions are now loaded directly by SimpleClaudeRunner
             
@@ -214,7 +236,7 @@ class AgentDeploymentService:
                 return results
             
             # Convert any existing YAML files to MD format
-            conversion_results = self._convert_yaml_to_md(target_dir)
+            conversion_results = self._convert_yaml_to_md(agents_dir)
             results["converted"] = conversion_results.get("converted", [])
             
             # Load base agent content
@@ -237,8 +259,14 @@ class AgentDeploymentService:
             
             # Get all template files
             template_files = list(self.templates_dir.glob("*.json"))
-            # Filter out non-agent files
-            template_files = [f for f in template_files if f.stem != "__init__" and not f.stem.startswith(".")]
+            # Filter out non-agent files - exclude system files and uppercase special files
+            excluded_names = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README"}
+            template_files = [
+                f for f in template_files 
+                if f.stem not in excluded_names 
+                and not f.stem.startswith(".")
+                and not f.stem.endswith(".backup")
+            ]
             results["total"] = len(template_files)
             
             for template_file in template_files:
@@ -247,12 +275,22 @@ class AgentDeploymentService:
                     agent_start_time = time.time()
                     
                     agent_name = template_file.stem
-                    target_file = target_dir / f"{agent_name}.md"
+                    target_file = agents_dir / f"{agent_name}.md"
                     
                     # Check if agent needs update
                     needs_update = force_rebuild
                     is_migration = False
-                    if not needs_update and target_file.exists():
+                    
+                    # In project deployment mode, always deploy regardless of version
+                    if deployment_mode == "project":
+                        if target_file.exists():
+                            # Check if it's a system agent that we should update
+                            needs_update = True
+                            self.logger.debug(f"Project deployment mode: will deploy {agent_name}")
+                        else:
+                            needs_update = True
+                    elif not needs_update and target_file.exists():
+                        # In update mode, check version compatibility
                         needs_update, reason = self._check_agent_needs_update(
                             target_file, template_file, base_agent_version
                         )
@@ -264,8 +302,8 @@ class AgentDeploymentService:
                             else:
                                 self.logger.info(f"Agent {agent_name} needs update: {reason}")
                     
-                    # Skip if exists and doesn't need update
-                    if target_file.exists() and not needs_update:
+                    # Skip if exists and doesn't need update (only in update mode)
+                    if target_file.exists() and not needs_update and deployment_mode != "project":
                         results["skipped"].append(agent_name)
                         self.logger.debug(f"Skipped up-to-date agent: {agent_name}")
                         continue
@@ -524,26 +562,48 @@ class AgentDeploymentService:
         model = (
             template_data.get('capabilities', {}).get('model') or
             template_data.get('configuration_fields', {}).get('model') or
-            "claude-sonnet-4-20250514"  # Default fallback
+            "sonnet"  # Default fallback
         )
         
-        frontmatter = f"""---
-name: {agent_name}
-description: "{description}"
-version: "{version_string}"
-author: "{template_data.get('author', 'claude-mpm@anthropic.com')}"
-created: "{datetime.now().isoformat()}Z"
-updated: "{datetime.now().isoformat()}Z"
-tags: {tags}
-tools: {tools}
-model: "{model}"
-metadata:
-  base_version: "{self._format_version_display(base_version)}"
-  agent_version: "{self._format_version_display(agent_version)}"
-  deployment_type: "system"
----
-
-"""
+        # Simplify model name for Claude Code
+        model_map = {
+            'claude-4-sonnet-20250514': 'sonnet',
+            'claude-sonnet-4-20250514': 'sonnet', 
+            'claude-3-opus-20240229': 'opus',
+            'claude-3-haiku-20240307': 'haiku',
+            'claude-3.5-sonnet': 'sonnet',
+            'claude-3-sonnet': 'sonnet'
+        }
+        model = model_map.get(model, model.split('-')[-1] if '-' in model else model)
+        
+        # Get response format from template or use base agent default
+        response_format = template_data.get('response', {}).get('format', 'structured')
+        
+        # Convert lists to space-separated strings for Claude Code compatibility
+        tags_str = ' '.join(tags) if isinstance(tags, list) else tags
+        tools_str = ', '.join(tools) if isinstance(tools, list) else tools
+        
+        # Build frontmatter with only the fields Claude Code uses
+        frontmatter_lines = [
+            "---",
+            f"name: {agent_name}",
+            f"description: {description}",
+            f"version: {version_string}",
+            f"base_version: {self._format_version_display(base_version)}",
+            f"author: claude-mpm",  # Identify as system agent for deployment
+            f"tools: {tools_str}",
+            f"model: {model}"
+        ]
+        
+        # Add optional fields if present
+        if template_data.get('color'):
+            frontmatter_lines.append(f"color: {template_data['color']}")
+        
+        frontmatter_lines.append("---")
+        frontmatter_lines.append("")
+        frontmatter_lines.append("")
+        
+        frontmatter = '\n'.join(frontmatter_lines)
         
         # Get the main content (instructions)
         # Check multiple possible locations for instructions
@@ -874,14 +934,18 @@ temperature: {temperature}"""
                     "path": str(agent_file)
                 }
                 
-                # Extract name and version from YAML frontmatter
+                # Extract name, version, and base_version from YAML frontmatter
                 version_str = None
+                base_version_str = None
                 for line in lines:
                     if line.startswith("name:"):
                         agent_info["name"] = line.split(":", 1)[1].strip().strip('"\'')
                     elif line.startswith("version:"):
                         version_str = line.split(":", 1)[1].strip().strip('"\'')
                         agent_info["version"] = version_str
+                    elif line.startswith("base_version:"):
+                        base_version_str = line.split(":", 1)[1].strip().strip('"\'')
+                        agent_info["base_version"] = base_version_str
                 
                 # Check if agent needs migration
                 if version_str and self._is_old_version_format(version_str):
@@ -904,6 +968,87 @@ temperature: {temperature}"""
         
         return results
     
+    def deploy_agent(self, agent_name: str, target_dir: Path, force_rebuild: bool = False) -> bool:
+        """
+        Deploy a single agent to the specified directory.
+        
+        Args:
+            agent_name: Name of the agent to deploy
+            target_dir: Target directory for deployment (Path object)
+            force_rebuild: Whether to force rebuild even if version is current
+            
+        Returns:
+            True if deployment was successful, False otherwise
+            
+        WHY: Single agent deployment because:
+        - Users may want to deploy specific agents only
+        - Reduces deployment time for targeted updates
+        - Enables selective agent management in projects
+        
+        FIXED: Method now correctly handles all internal calls to:
+        - _check_agent_needs_update (with 3 arguments)
+        - _build_agent_markdown (with 3 arguments including base_agent_data)
+        - Properly loads base_agent_data before building agent content
+        """
+        try:
+            # Find the template file
+            template_file = self.templates_dir / f"{agent_name}.json"
+            if not template_file.exists():
+                self.logger.error(f"Agent template not found: {agent_name}")
+                return False
+            
+            # Ensure target directory exists
+            agents_dir = target_dir / '.claude' / 'agents'
+            agents_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Build and deploy the agent
+            target_file = agents_dir / f"{agent_name}.md"
+            
+            # Check if update is needed
+            if not force_rebuild and target_file.exists():
+                # Load base agent data for version checking
+                base_agent_data = {}
+                base_agent_version = (0, 0, 0)
+                if self.base_agent_path.exists():
+                    try:
+                        import json
+                        base_agent_data = json.loads(self.base_agent_path.read_text())
+                        base_agent_version = self._parse_version(base_agent_data.get('base_version') or base_agent_data.get('version', 0))
+                    except Exception as e:
+                        self.logger.warning(f"Could not load base agent for version check: {e}")
+                
+                needs_update, reason = self._check_agent_needs_update(target_file, template_file, base_agent_version)
+                if not needs_update:
+                    self.logger.info(f"Agent {agent_name} is up to date")
+                    return True
+                else:
+                    self.logger.info(f"Updating agent {agent_name}: {reason}")
+            
+            # Load base agent data for building
+            base_agent_data = {}
+            if self.base_agent_path.exists():
+                try:
+                    import json
+                    base_agent_data = json.loads(self.base_agent_path.read_text())
+                except Exception as e:
+                    self.logger.warning(f"Could not load base agent: {e}")
+            
+            # Build the agent markdown
+            agent_content = self._build_agent_markdown(agent_name, template_file, base_agent_data)
+            if not agent_content:
+                self.logger.error(f"Failed to build agent content for {agent_name}")
+                return False
+            
+            # Write to target file
+            target_file.write_text(agent_content)
+            self.logger.info(f"Successfully deployed agent: {agent_name} to {target_file}")
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to deploy agent {agent_name}: {e}")
+            return False
+    
     def list_available_agents(self) -> List[Dict[str, Any]]:
         """
         List available agent templates.
@@ -918,8 +1063,14 @@ temperature: {temperature}"""
             return agents
         
         template_files = sorted(self.templates_dir.glob("*.json"))
-        # Filter out non-agent files
-        template_files = [f for f in template_files if f.stem != "__init__" and not f.stem.startswith(".")]
+        # Filter out non-agent files - exclude system files and uppercase special files
+        excluded_names = {"__init__", "MEMORIES", "TODOWRITE", "INSTRUCTIONS", "README"}
+        template_files = [
+            f for f in template_files 
+            if f.stem not in excluded_names 
+            and not f.stem.startswith(".")
+            and not f.stem.endswith(".backup")
+        ]
         
         for template_file in template_files:
             try: