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

claude_mpm/services/agent_persistence_service.py

@@ -13,42 +13,22 @@ DESIGN DECISION: Creating a minimal stub because:
 - Allows for future extension if needed
 """
 
-from dataclasses import dataclass
-from enum import Enum
-from typing import Optional, Any, Dict
+from typing import Optional, Any
 import time
 
+from claude_mpm.models.persistence import (
+    PersistenceStrategy,
+    PersistenceOperation,
+    PersistenceRecord
+)
 
-class PersistenceStrategy(Enum):
-    """Agent persistence strategies."""
-    USER_OVERRIDE = "user_override"
-    PROJECT_SPECIFIC = "project_specific"
-    SYSTEM_DEFAULT = "system_default"
-
-
-class PersistenceOperation(Enum):
-    """Persistence operation types."""
-    CREATE = "create"
-    UPDATE = "update"
-    DELETE = "delete"
-    BACKUP = "backup"
-    RESTORE = "restore"
-
-
-@dataclass
-class PersistenceRecord:
-    """Record of a persistence operation."""
-    operation_id: str
-    operation_type: PersistenceOperation
-    agent_name: str
-    source_tier: Any
-    target_tier: Optional[Any] = None
-    strategy: Optional[PersistenceStrategy] = None
-    success: bool = True
-    timestamp: float = 0.0
-    file_path: Optional[str] = None
-    error_message: Optional[str] = None
-    metadata: Dict[str, Any] = None
+# Backward compatibility exports
+__all__ = [
+    'PersistenceStrategy',
+    'PersistenceOperation',
+    'PersistenceRecord',
+    'AgentPersistenceService'
+]
 
 
 class AgentPersistenceService:

claude_mpm/services/agent_registry.py

@@ -25,36 +25,35 @@ import hashlib
 import logging
 from pathlib import Path
 from typing import Dict, List, Optional, Set, Tuple, Any, Union
-from dataclasses import dataclass, field, asdict
+from dataclasses import asdict
 from datetime import datetime
 from enum import Enum
 
-logger = logging.getLogger(__name__)
-
-
-# ============================================================================
-# Constants and Types
-# ============================================================================
-
-CORE_AGENT_TYPES = {
-    'engineer', 'architect', 'qa', 'security', 'documentation',
-    'ops', 'data', 'research', 'version_control'
-}
-
-SPECIALIZED_AGENT_TYPES = {
-    'pm_orchestrator', 'frontend', 'backend', 'devops', 'ml',
-    'database', 'api', 'mobile', 'cloud', 'testing'
-}
+from claude_mpm.models.registry import AgentTier, AgentRegistryMetadata
+from claude_mpm.models.common import (
+    CORE_AGENT_TYPES,
+    SPECIALIZED_AGENT_TYPES,
+    ALL_AGENT_TYPES,
+    AGENT_FILE_EXTENSIONS,
+    AGENT_IGNORE_PATTERNS
+)
 
-ALL_AGENT_TYPES = CORE_AGENT_TYPES | SPECIALIZED_AGENT_TYPES
+logger = logging.getLogger(__name__)
 
+# Backward compatibility exports
+# Export AgentRegistryMetadata as AgentMetadata for existing code
+AgentMetadata = AgentRegistryMetadata
 
-class AgentTier(Enum):
-    """Agent hierarchy tiers."""
-    USER = "user"
-    SYSTEM = "system"
+__all__ = [
+    'AgentTier',
+    'AgentType',
+    'AgentMetadata',  # Alias for AgentRegistryMetadata
+    'AgentRegistryMetadata',
+    'AgentRegistry'
+]
 
 
+# Keep local AgentType enum for internal classification logic
 class AgentType(Enum):
     """Agent classification types."""
     CORE = "core"
@@ -63,44 +62,6 @@ class AgentType(Enum):
     UNKNOWN = "unknown"
 
 
-# ============================================================================
-# Data Models
-# ============================================================================
-
-@dataclass
-class AgentMetadata:
-    """Complete metadata for discovered agent."""
-    name: str
-    path: str
-    tier: AgentTier
-    agent_type: AgentType
-    description: str = ""
-    version: str = "0.0.0"
-    dependencies: List[str] = field(default_factory=list)
-    capabilities: List[str] = field(default_factory=list)
-    created_at: float = field(default_factory=time.time)
-    last_modified: float = field(default_factory=time.time)
-    file_size: int = 0
-    checksum: str = ""
-    is_valid: bool = True
-    validation_errors: List[str] = field(default_factory=list)
-    metadata: Dict[str, Any] = field(default_factory=dict)
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for serialization."""
-        data = asdict(self)
-        data['tier'] = self.tier.value
-        data['agent_type'] = self.agent_type.value
-        return data
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'AgentMetadata':
-        """Create from dictionary."""
-        data['tier'] = AgentTier(data['tier'])
-        data['agent_type'] = AgentType(data['agent_type'])
-        return cls(**data)
-
-
 # ============================================================================
 # Main Registry Class
 # ============================================================================
@@ -119,7 +80,7 @@ class AgentRegistry:
         self.model_selector = model_selector
         
         # Registry storage
-        self.registry: Dict[str, AgentMetadata] = {}
+        self.registry: Dict[str, AgentRegistryMetadata] = {}
         self.discovery_paths: List[Path] = []
         
         # Cache configuration
@@ -128,8 +89,8 @@ class AgentRegistry:
         self.cache_prefix = "agent_registry"
         
         # Discovery configuration
-        self.file_extensions = {'.md', '.json', '.yaml', '.yml'}
-        self.ignore_patterns = {'__pycache__', '.git', 'node_modules', '.pytest_cache'}
+        self.file_extensions = AGENT_FILE_EXTENSIONS
+        self.ignore_patterns = AGENT_IGNORE_PATTERNS
         
         # Statistics
         self.discovery_stats = {
@@ -169,7 +130,7 @@ class AgentRegistry:
     # Discovery Methods
     # ========================================================================
     
-    def discover_agents(self, force_refresh: bool = False) -> Dict[str, AgentMetadata]:
+    def discover_agents(self, force_refresh: bool = False) -> Dict[str, AgentRegistryMetadata]:
         """
         Discover all available agents across configured paths.
         
@@ -269,7 +230,7 @@ class AgentRegistry:
         
         return name
     
-    def _create_agent_metadata(self, file_path: Path, agent_name: str, tier: AgentTier) -> AgentMetadata:
+    def _create_agent_metadata(self, file_path: Path, agent_name: str, tier: AgentTier) -> AgentRegistryMetadata:
         """Create agent metadata from file."""
         # Get file stats
         stat = file_path.stat()
@@ -324,11 +285,11 @@ class AgentRegistry:
         except Exception as e:
             logger.warning(f"Failed to parse {file_path}: {e}")
         
-        return AgentMetadata(
+        return AgentRegistryMetadata(
             name=agent_name,
             path=str(file_path),
             tier=tier,
-            agent_type=agent_type,
+            agent_type=agent_type.value,  # Convert enum to string
             description=description,
             version=version,
             capabilities=capabilities,
@@ -379,7 +340,7 @@ class AgentRegistry:
     def _apply_tier_precedence(self) -> None:
         """Apply tier precedence rules to discovered agents."""
         # Group agents by name
-        agents_by_name: Dict[str, List[AgentMetadata]] = {}
+        agents_by_name: Dict[str, List[AgentRegistryMetadata]] = {}
         
         for agent in self.registry.values():
             if agent.name not in agents_by_name:
@@ -403,7 +364,7 @@ class AgentRegistry:
     # Validation Methods
     # ========================================================================
     
-    def _validate_agent(self, metadata: AgentMetadata) -> bool:
+    def _validate_agent(self, metadata: AgentRegistryMetadata) -> bool:
         """Validate agent metadata and file."""
         errors = []
         
@@ -437,7 +398,7 @@ class AgentRegistry:
     # Cache Methods
     # ========================================================================
     
-    def _get_cached_registry(self) -> Optional[Dict[str, AgentMetadata]]:
+    def _get_cached_registry(self) -> Optional[Dict[str, AgentRegistryMetadata]]:
         """Get registry from cache if available."""
         if not self.cache_service:
             return None
@@ -450,7 +411,7 @@ class AgentRegistry:
                 # Deserialize metadata
                 registry = {}
                 for name, data in cached_data.items():
-                    registry[name] = AgentMetadata.from_dict(data)
+                    registry[name] = AgentRegistryMetadata.from_dict(data)
                 return registry
         
         except Exception as e:
@@ -491,7 +452,7 @@ class AgentRegistry:
     # Query Methods
     # ========================================================================
     
-    def get_agent(self, name: str) -> Optional[AgentMetadata]:
+    def get_agent(self, name: str) -> Optional[AgentRegistryMetadata]:
         """Get metadata for a specific agent."""
         # Ensure registry is populated
         if not self.registry:
@@ -500,7 +461,7 @@ class AgentRegistry:
         return self.registry.get(name)
     
     def list_agents(self, tier: Optional[AgentTier] = None, 
-                   agent_type: Optional[AgentType] = None) -> List[AgentMetadata]:
+                   agent_type: Optional[str] = None) -> List[AgentRegistryMetadata]:
         """List agents with optional filtering."""
         # Ensure registry is populated
         if not self.registry:
@@ -524,19 +485,19 @@ class AgentRegistry:
         
         return sorted(self.registry.keys())
     
-    def get_core_agents(self) -> List[AgentMetadata]:
+    def get_core_agents(self) -> List[AgentRegistryMetadata]:
         """Get all core framework agents."""
-        return self.list_agents(agent_type=AgentType.CORE)
+        return self.list_agents(agent_type=AgentType.CORE.value)
     
-    def get_specialized_agents(self) -> List[AgentMetadata]:
+    def get_specialized_agents(self) -> List[AgentRegistryMetadata]:
         """Get all specialized agents."""
-        return self.list_agents(agent_type=AgentType.SPECIALIZED)
+        return self.list_agents(agent_type=AgentType.SPECIALIZED.value)
     
-    def get_custom_agents(self) -> List[AgentMetadata]:
+    def get_custom_agents(self) -> List[AgentRegistryMetadata]:
         """Get all custom user-defined agents."""
-        return self.list_agents(agent_type=AgentType.CUSTOM)
+        return self.list_agents(agent_type=AgentType.CUSTOM.value)
     
-    def search_agents(self, query: str) -> List[AgentMetadata]:
+    def search_agents(self, query: str) -> List[AgentRegistryMetadata]:
         """Search agents by name or description."""
         if not self.registry:
             self.discover_agents()
@@ -579,7 +540,7 @@ class AgentRegistry:
         
         # Count by type
         for agent in self.registry.values():
-            agent_type = agent.agent_type.value
+            agent_type = agent.agent_type  # Already a string
             stats['agents_by_type'][agent_type] = stats['agents_by_type'].get(agent_type, 0) + 1
         
         # Validation stats
@@ -667,7 +628,7 @@ class AgentRegistry:
         
         # Import agents
         for name, agent_data in data.get('agents', {}).items():
-            self.registry[name] = AgentMetadata.from_dict(agent_data)
+            self.registry[name] = AgentRegistryMetadata.from_dict(agent_data)
         
         # Cache imported registry
         if self.cache_enabled:

claude_mpm/services/{ticketing_service_original.py → legacy_ticketing_service.py}

@@ -1,10 +1,13 @@
 #!/usr/bin/env python3
 """
-Ticketing Service
-=================
+Legacy Ticketing Service (DEPRECATED)
+=====================================
 
-Core service that wraps ai-trackdown-pytools for simplified ticket management.
-Provides a clean interface for PM orchestration and agent ticket operations.
+DEPRECATED: This is the original ticketing service implementation.
+For new development, use TicketManager or TicketManagerDependencyInjection instead.
+
+This service is kept for backward compatibility and reference purposes.
+It wraps ai-trackdown-pytools for simplified ticket management.
 
 Key Features:
 - Singleton pattern for consistent ticket management
@@ -44,15 +47,19 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-# Import ai-trackdown-pytools
-try:
-    from ai_trackdown_pytools import Task, Project
-    from ai_trackdown_pytools.core.task import TaskManager
+from claude_mpm.utils.imports import safe_import
+
+# Import ai-trackdown-pytools using safe_import pattern
+trackdown_imports = safe_import('ai_trackdown_pytools', None, ['Task', 'Project'])
+TaskManager = safe_import('ai_trackdown_pytools.core.task', None, ['TaskManager'])
+
+if trackdown_imports and TaskManager:
+    Task, Project = trackdown_imports
     AI_TRACKDOWN_AVAILABLE = True
     # Map to expected names
     Ticket = Task
     TicketManager = TaskManager
-except ImportError:
+else:
     AI_TRACKDOWN_AVAILABLE = False
     # Define fallback classes for type hints
     class TicketStatus:

claude_mpm/services/ticket_manager.py

@@ -4,10 +4,11 @@ from pathlib import Path
 from typing import Optional, Dict, Any, List
 from datetime import datetime
 
-try:
-    from ..core.logger import get_logger
-except ImportError:
-    from core.logger import get_logger
+from claude_mpm.utils.imports import safe_import
+
+# Import logger using safe_import pattern
+# Note: safe_import cannot handle relative imports as primary, use absolute import first
+get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
 
 
 class TicketManager:

claude_mpm/services/{ticket_manager_di.py → ticket_manager_dependency_injection.py}

@@ -1,16 +1,39 @@
 """
-Enhanced Ticket Manager with Dependency Injection support.
+Ticket Manager with Dependency Injection
+========================================
 
-This version demonstrates proper constructor injection and testability.
+Modern implementation of the ticket manager service with full dependency injection support.
+This is the recommended implementation for new development requiring ticket management.
+
+Key Features:
+- Constructor-based dependency injection
+- Interface-based design for testability
+- Easy mocking for unit tests
+- Follows SOLID principles
+
+Usage:
+    # With dependency injection container
+    ticket_manager = container.get(TicketManagerDependencyInjection)
+    
+    # Manual instantiation with dependencies
+    ticket_manager = TicketManagerDependencyInjection(
+        config=config_service,
+        task_adapter=mock_adapter  # For testing
+    )
+
+This implementation supersedes the legacy_ticketing_service.py.
 """
 
 from pathlib import Path
 from typing import Optional, Dict, Any, List
 from datetime import datetime
 
-from ..core.injectable_service import InjectableService
-from ..core.config import Config
-from ..core.logger import get_logger
+from claude_mpm.utils.imports import safe_import
+
+# Import dependencies using safe_import pattern
+InjectableService = safe_import('claude_mpm.core.injectable_service', None, ['InjectableService'])
+Config = safe_import('claude_mpm.core.config', None, ['Config'])
+get_logger = safe_import('claude_mpm.core.logger', None, ['get_logger'])
 
 
 class ITaskManagerAdapter:
@@ -40,10 +63,17 @@ class AITrackdownAdapter(ITaskManagerAdapter):
         
     def _init_task_manager(self):
         """Initialize ai-trackdown-pytools TaskManager."""
-        try:
-            from ai_trackdown_pytools.core.task import TaskManager
-            from ai_trackdown_pytools import Config as TrackdownConfig, Project
+        # Import using safe_import pattern
+        TaskManager = safe_import('ai_trackdown_pytools.core.task', None, ['TaskManager'])
+        trackdown_imports = safe_import('ai_trackdown_pytools', None, ['Config', 'Project'])
+        
+        if not TaskManager or not trackdown_imports:
+            self.logger.error("ai-trackdown-pytools not installed")
+            return None
             
+        TrackdownConfig, Project = trackdown_imports
+        
+        try:
             # Ensure tickets directory exists
             tickets_dir = self.project_path / "tickets"
             if not tickets_dir.exists():
@@ -67,9 +97,6 @@ class AITrackdownAdapter(ITaskManagerAdapter):
             # Initialize task manager directly
             return TaskManager(self.project_path)
             
-        except ImportError:
-            self.logger.error("ai-trackdown-pytools not installed")
-            return None
         except Exception as e:
             self.logger.error(f"Failed to initialize TaskManager: {e}")
             return None
@@ -93,7 +120,7 @@ class AITrackdownAdapter(ITaskManagerAdapter):
         return self._task_manager.load_task(task_id)
 
 
-class TicketManagerDI(InjectableService):
+class TicketManagerDependencyInjection(InjectableService):
     """
     Enhanced Ticket Manager with Dependency Injection.
     

claude_mpm/services/version_control/semantic_versioning.py

@@ -46,7 +46,10 @@ from dataclasses import dataclass, field
 from enum import Enum
 import logging
 
-from ...utils.config_manager import ConfigurationManager
+from claude_mpm.utils.imports import safe_import
+
+# Import dependencies using safe_import pattern
+ConfigurationManager = safe_import('claude_mpm.utils.config_manager', None, ['ConfigurationManager'])
 
 
 class VersionBumpType(Enum):
@@ -367,14 +370,12 @@ class SemanticVersionManager:
 
     def _parse_pyproject_toml_version(self, file_path: Path) -> Optional[str]:
         """Parse version from pyproject.toml."""
-        try:
-            import tomllib
-        except ImportError:
-            try:
-                import tomli as tomllib
-            except ImportError:
-                # Fallback to simple regex parsing
-                return self._parse_toml_version_regex(file_path)
+        # Try to import tomllib (Python 3.11+) or tomli as fallback
+        tomllib = safe_import('tomllib', 'tomli')
+        
+        if not tomllib:
+            # Fallback to simple regex parsing
+            return self._parse_toml_version_regex(file_path)
 
         try:
             with open(file_path, "rb") as f:

claude_mpm/utils/path_operations.py

@@ -2,6 +2,26 @@
 
 This module provides a centralized PathOperations class for common path validation
 and file operations, reducing code duplication across the codebase.
+
+ARCHITECTURAL DECISION: Separation of Concerns
+---------------------------------------------
+This module (path_operations.py) and paths.py serve distinct purposes and should
+remain separate:
+
+1. path_operations.py (this file):
+   - Provides safe file I/O operations (read, write, copy, delete)
+   - Handles file validation and permissions
+   - Implements error handling and recovery mechanisms
+   - Focus: File system operations with safety guarantees
+
+2. paths.py:
+   - Provides path discovery and resolution logic
+   - Handles framework/project directory structure navigation
+   - Implements caching for performance optimization
+   - Focus: Path resolution and directory structure
+
+This separation follows the Single Responsibility Principle and makes the codebase
+more maintainable by keeping distinct concerns in separate modules.
 """
 
 import os

{claude_mpm-3.1.2.dist-info → claude_mpm-3.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 3.1.2
+Version: 3.1.3
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team
@@ -191,6 +191,14 @@ Claude MPM provides a modular framework for extending Claude's capabilities:
 
 ## Key Features
 
+### Security Features
+- **File Access Restrictions**: Agents are restricted to their working directory
+- **Bash Command Validation**: Comprehensive validation prevents writes outside project directory
+- **Path Traversal Protection**: Blocks attempts to escape the working directory
+- **Dangerous Command Blocking**: Prevents execution of sudo, rm -rf, and other risky commands
+- **Security Audit Logging**: All file operations are logged for security monitoring
+- See [Security Documentation](docs/SECURITY.md) for details
+
 ### Agent System
 - Specialized agents for different domains (Research, Engineer, etc.)
 - Dynamic agent discovery and registration