claude-mpm 3.7.8__py3-none-any.whl → 3.9.0__py3-none-any.whl

claude_mpm/services/ticket_manager.py

@@ -4,13 +4,12 @@ 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.core.logging_config import get_logger
 
+from ..core.interfaces import TicketManagerInterface
 
-class TicketManager:
+
+class TicketManager(TicketManagerInterface):
     """
     Manage ticket creation using ai-trackdown-pytools.
     
@@ -25,7 +24,7 @@ class TicketManager:
         Args:
             project_path: Project root (defaults to current directory)
         """
-        self.logger = get_logger("ticket_manager")
+        self.logger = get_logger(__name__)
         self.project_path = project_path or Path.cwd()
         self.task_manager = self._init_task_manager()
         
@@ -50,7 +49,7 @@ class TicketManager:
             # Check if config exists, create if needed
             if not config_file.exists():
                 try:
-                    config = Config.create_default(str(config_file))
+                    config = Config.create_default(config_file)  # Pass Path object directly
                     config.set("paths.tickets_dir", "tickets")
                     config.set("paths.epics_dir", "tickets/epics")
                     config.set("paths.issues_dir", "tickets/issues")
@@ -65,7 +64,7 @@ class TicketManager:
             
             # Initialize TaskManager directly with the project path
             # TaskManager will handle project initialization internally
-            task_manager = TaskManager(str(self.project_path))
+            task_manager = TaskManager(self.project_path)  # Pass Path object directly
             
             # Verify it's using the right directory
             if hasattr(task_manager, 'tasks_dir'):
@@ -373,4 +372,168 @@ class TicketManager:
             self.logger.error(f"Failed to get ticket {ticket_id}: {e.__class__.__name__}: {e}")
             self.logger.info(f"Try using the CLI: aitrackdown show {ticket_id}")
             self.logger.debug("Full error details:", exc_info=True)
-            return None
+            return None
+    
+    # ================================================================================
+    # Interface Adapter Methods
+    # ================================================================================
+    # These methods adapt the existing implementation to comply with TicketManagerInterface
+    
+    def create_task(self, title: str, description: str, **kwargs) -> Optional[str]:
+        """Create a new task ticket.
+        
+        WHY: This adapter method provides interface compliance by wrapping
+        the underlying task manager's create functionality.
+        
+        Args:
+            title: Task title
+            description: Task description
+            **kwargs: Additional task properties
+            
+        Returns:
+            Task ID if created successfully, None otherwise
+        """
+        if not self.task_manager:
+            self.logger.error("Task manager not initialized")
+            return None
+        
+        try:
+            # Create task using ai-trackdown-pytools
+            from ai_trackdown_pytools.core.task import Task
+            
+            task = Task(
+                title=title,
+                description=description,
+                status=kwargs.get('status', 'open'),
+                priority=kwargs.get('priority', 'medium'),
+                tags=kwargs.get('tags', []),
+                assignees=kwargs.get('assignees', [])
+            )
+            
+            # Save the task
+            task_id = self.task_manager.create_task(task)
+            self.logger.info(f"Created task {task_id}: {title}")
+            return task_id
+            
+        except ImportError:
+            self.logger.error("ai-trackdown-pytools not available")
+            return None
+        except Exception as e:
+            self.logger.error(f"Failed to create task: {e}")
+            return None
+    
+    def update_task(self, task_id: str, **updates) -> bool:
+        """Update an existing task.
+        
+        WHY: This adapter method provides interface compliance by wrapping
+        task update operations.
+        
+        Args:
+            task_id: ID of task to update
+            **updates: Fields to update
+            
+        Returns:
+            True if update successful
+        """
+        if not self.task_manager:
+            self.logger.error("Task manager not initialized")
+            return False
+        
+        try:
+            # Get the existing task
+            task = self.task_manager.get_task(task_id)
+            if not task:
+                self.logger.error(f"Task {task_id} not found")
+                return False
+            
+            # Apply updates
+            for key, value in updates.items():
+                if hasattr(task, key):
+                    setattr(task, key, value)
+            
+            # Save the updated task
+            self.task_manager.update_task(task)
+            self.logger.info(f"Updated task {task_id}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to update task {task_id}: {e}")
+            return False
+    
+    def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:
+        """Get task details.
+        
+        WHY: This adapter method provides interface compliance by wrapping
+        the existing get_ticket method.
+        
+        Args:
+            task_id: ID of task to retrieve
+            
+        Returns:
+            Task data dictionary or None if not found
+        """
+        # Use existing get_ticket method which already returns dict format
+        return self.get_ticket(task_id)
+    
+    def list_tasks(self, status: Optional[str] = None, **filters) -> List[Dict[str, Any]]:
+        """List tasks with optional filtering.
+        
+        WHY: This adapter method provides interface compliance by wrapping
+        task listing operations.
+        
+        Args:
+            status: Optional status filter
+            **filters: Additional filter criteria
+            
+        Returns:
+            List of task dictionaries
+        """
+        if not self.task_manager:
+            self.logger.error("Task manager not initialized")
+            return []
+        
+        try:
+            # Get all tasks
+            tasks = self.task_manager.list_tasks()
+            
+            # Apply filters
+            filtered_tasks = []
+            for task in tasks:
+                # Check status filter
+                if status and task.get('status') != status:
+                    continue
+                
+                # Check additional filters
+                match = True
+                for key, value in filters.items():
+                    if task.get(key) != value:
+                        match = False
+                        break
+                
+                if match:
+                    filtered_tasks.append(task)
+            
+            return filtered_tasks
+            
+        except Exception as e:
+            self.logger.error(f"Failed to list tasks: {e}")
+            return []
+    
+    def close_task(self, task_id: str, resolution: Optional[str] = None) -> bool:
+        """Close a task.
+        
+        WHY: This adapter method provides interface compliance by updating
+        task status to closed.
+        
+        Args:
+            task_id: ID of task to close
+            resolution: Optional resolution description
+            
+        Returns:
+            True if close successful
+        """
+        updates = {'status': 'closed'}
+        if resolution:
+            updates['resolution'] = resolution
+        
+        return self.update_task(task_id, **updates)

claude_mpm/services/ticket_manager_di.py

@@ -56,7 +56,7 @@ class AITrackdownAdapter(ITaskManagerAdapter):
             # Configure ai-trackdown if needed
             config_file = self.project_path / ".trackdown.yaml"
             if not config_file.exists():
-                config = TrackdownConfig.create_default(config_file)
+                config = TrackdownConfig.create_default(config_file)  # Already correct - using Path object
                 config.set("paths.tickets_dir", "tickets")
                 config.set("paths.epics_dir", "tickets/epics")
                 config.set("paths.issues_dir", "tickets/issues")

claude_mpm/services/version_control/semantic_versioning.py

@@ -334,11 +334,42 @@ class SemanticVersionManager:
 
     def get_current_version(self) -> Optional[SemanticVersion]:
         """
-        Get the current version from project files.
+        Get the current version from multiple sources with intelligent fallback.
+        
+        Uses the enhanced version parser to check:
+        1. Git tags (most recent)
+        2. VERSION file
+        3. package.json
+        4. pyproject.toml
+        5. Other configured version files
 
         Returns:
             Current SemanticVersion or None if not found
         """
+        try:
+            # Import here to avoid circular dependency
+            from claude_mpm.services.version_control.version_parser import get_version_parser
+            
+            # Use enhanced parser for current version
+            parser = get_version_parser(self.project_root)
+            version_meta = parser.get_current_version()
+            
+            if version_meta:
+                version = self.parse_version(version_meta.version)
+                if version:
+                    self.logger.info(f"Found version {version} from {version_meta.source}")
+                    # Optionally attach metadata
+                    if hasattr(version, '__dict__'):
+                        version.source = version_meta.source
+                    return version
+                
+        except ImportError:
+            # Fallback to original implementation
+            self.logger.debug("Enhanced version parser not available, using fallback")
+        except Exception as e:
+            self.logger.error(f"Error getting current version with enhanced parser: {e}")
+        
+        # Fallback to original implementation
         for filename, parser in self.version_files.items():
             file_path = self.project_root / filename
 
@@ -811,19 +842,61 @@ class SemanticVersionManager:
 
     def get_version_history(self) -> List[SemanticVersion]:
         """
-        Get version history from changelog or Git tags.
+        Get version history from multiple sources with intelligent fallback.
+        
+        Uses the enhanced version parser to retrieve version history from:
+        1. Git tags (primary source)
+        2. CHANGELOG.md (fallback)
+        3. VERSION files (current version only)
 
         Returns:
             List of versions in descending order
         """
+        try:
+            # Import here to avoid circular dependency
+            from claude_mpm.services.version_control.version_parser import get_version_parser
+            
+            # Use enhanced parser for comprehensive version history
+            parser = get_version_parser(self.project_root)
+            version_metadata = parser.get_version_history(include_prereleases=False)
+            
+            # Convert to SemanticVersion objects
+            versions = []
+            for meta in version_metadata:
+                version = self.parse_version(meta.version)
+                if version:
+                    # Optionally attach metadata to version
+                    if hasattr(version, '__dict__'):
+                        version.source = meta.source
+                        version.release_date = meta.release_date
+                        version.commit_hash = meta.commit_hash
+                    versions.append(version)
+            
+            return versions
+            
+        except ImportError:
+            # Fallback to original implementation if enhanced parser not available
+            self.logger.warning("Enhanced version parser not available, falling back to changelog parsing")
+            return self._parse_changelog_versions_fallback()
+        except Exception as e:
+            self.logger.error(f"Error getting version history: {e}")
+            # Fallback to original implementation
+            return self._parse_changelog_versions_fallback()
+
+    def _parse_changelog_versions_fallback(self) -> List[SemanticVersion]:
+        """Fallback method: Parse versions from changelog file only."""
         versions = []
 
         # Try to get versions from changelog
-        changelog_path = self.project_root / "docs" / "CHANGELOG.md"
-        if changelog_path.exists():
-            versions.extend(self._parse_changelog_versions(changelog_path))
-
-        # TODO: Add Git tag parsing if needed
+        changelog_paths = [
+            self.project_root / "CHANGELOG.md",
+            self.project_root / "docs" / "CHANGELOG.md"
+        ]
+        
+        for changelog_path in changelog_paths:
+            if changelog_path.exists():
+                versions.extend(self._parse_changelog_versions(changelog_path))
+                break
 
         # Sort versions in descending order
         versions.sort(reverse=True)