claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/services/version_control/semantic_versioning.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Semantic Versioning Manager - Version management logic for Version Control Agent.
 
@@ -37,14 +39,12 @@ Change Analysis:
 - Confidence scoring for version bump suggestions
 """
 
+import logging
 import re
-import json
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Optional, Any, Tuple, Union
 from dataclasses import dataclass, field
+from datetime import datetime, timezone
 from enum import Enum
-import logging
+from typing import Dict, List, Optional, Tuple
 
 from ...utils.config_manager import ConfigurationManager
 
@@ -61,20 +61,20 @@ class VersionBumpType(Enum):
 @dataclass
 class SemanticVersion:
     """Represents a semantic version following semver.org specification.
-    
+
     This class encapsulates a semantic version with support for:
     - Major, minor, and patch version numbers
     - Pre-release identifiers (alpha, beta, rc, etc.)
     - Build metadata
     - Version comparison and sorting
     - Version bumping operations
-    
+
     The comparison logic follows semver precedence rules:
     1. Compare major, minor, patch numerically
     2. Pre-release versions have lower precedence than normal versions
     3. Pre-release identifiers are compared alphanumerically
     4. Build metadata is ignored in comparisons
-    
+
     This is used for both project versioning and agent version management.
     """
 
@@ -86,7 +86,7 @@ class SemanticVersion:
 
     def __str__(self) -> str:
         """String representation of version in semver format.
-        
+
         Examples:
         - 1.2.3
         - 1.2.3-alpha.1
@@ -102,13 +102,13 @@ class SemanticVersion:
 
     def __lt__(self, other: "SemanticVersion") -> bool:
         """Compare versions for sorting according to semver precedence.
-        
+
         Comparison Rules:
         1. Version core (major.minor.patch) compared numerically
         2. Version with pre-release < same version without pre-release
         3. Pre-release versions compared alphanumerically
         4. Build metadata ignored (1.0.0+build1 == 1.0.0+build2)
-        
+
         This enables proper version sorting for:
         - Determining latest version
         - Agent deployment decisions
@@ -136,43 +136,43 @@ class SemanticVersion:
 
     def bump(self, bump_type: VersionBumpType) -> "SemanticVersion":
         """Create a new version with the specified bump applied.
-        
+
         Version Bump Rules:
         - MAJOR: Increment major, reset minor and patch to 0
         - MINOR: Increment minor, reset patch to 0
         - PATCH: Increment patch only
         - PRERELEASE: Handle pre-release progression
-        
+
         Pre-release Progression:
         - No prerelease -> alpha.1
         - alpha.1 -> alpha.2
         - beta.1 -> beta.2
         - rc.1 -> rc.2
         - custom -> custom.1
-        
+
         Examples:
         - 1.2.3 + MAJOR -> 2.0.0
         - 1.2.3 + MINOR -> 1.3.0
         - 1.2.3 + PATCH -> 1.2.4
         - 1.2.3 + PRERELEASE -> 1.2.3-alpha.1
         - 1.2.3-alpha.1 + PRERELEASE -> 1.2.3-alpha.2
-        
+
         Args:
             bump_type: Type of version bump to apply
-            
+
         Returns:
             New SemanticVersion instance with bump applied
         """
         if bump_type == VersionBumpType.MAJOR:
             # Breaking changes - reset minor and patch
             return SemanticVersion(self.major + 1, 0, 0)
-        elif bump_type == VersionBumpType.MINOR:
+        if bump_type == VersionBumpType.MINOR:
             # New features - reset patch only
             return SemanticVersion(self.major, self.minor + 1, 0)
-        elif bump_type == VersionBumpType.PATCH:
+        if bump_type == VersionBumpType.PATCH:
             # Bug fixes - increment patch only
             return SemanticVersion(self.major, self.minor, self.patch + 1)
-        elif bump_type == VersionBumpType.PRERELEASE:
+        if bump_type == VersionBumpType.PRERELEASE:
             if self.prerelease:
                 # Increment existing prerelease number
                 match = re.match(r"(.+?)(\d+)$", self.prerelease)
@@ -186,7 +186,9 @@ class SemanticVersion:
                 # Start new prerelease series
                 new_prerelease = "alpha.1"
 
-            return SemanticVersion(self.major, self.minor, self.patch, prerelease=new_prerelease)
+            return SemanticVersion(
+                self.major, self.minor, self.patch, prerelease=new_prerelease
+            )
 
         return self
 
@@ -287,13 +289,13 @@ class SemanticVersionManager:
         - 1.2.3-alpha.1 (with prerelease and number)
         - 1.2.3-beta.2+build.123 (full format)
         - 1.2.3+20230615 (with build metadata only)
-        
+
         The parser is flexible and handles:
         - Optional 'v' prefix (stripped automatically)
         - Whitespace trimming
         - Full semver specification compliance
         - Graceful failure for invalid formats
-        
+
         This is used for:
         - Parsing versions from files (package.json, etc.)
         - Converting git tags to versions
@@ -334,11 +336,48 @@ 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
 
@@ -377,14 +416,16 @@ class SemanticVersionManager:
                 return self._parse_toml_version_regex(file_path)
 
         try:
-            with open(file_path, "rb") as f:
+            with file_path.open("rb") as f:
                 data = tomllib.load(f)
 
             # Try different locations for version
             if "project" in data and "version" in data["project"]:
                 return data["project"]["version"]
-            elif (
-                "tool" in data and "poetry" in data["tool"] and "version" in data["tool"]["poetry"]
+            if (
+                "tool" in data
+                and "poetry" in data["tool"]
+                and "version" in data["tool"]["poetry"]
             ):
                 return data["tool"]["poetry"]["version"]
 
@@ -396,11 +437,14 @@ class SemanticVersionManager:
     def _parse_toml_version_regex(self, file_path: Path) -> Optional[str]:
         """Parse version from TOML file using regex."""
         try:
-            with open(file_path, "r") as f:
+            with file_path.open() as f:
                 content = f.read()
 
             # Look for version = "x.y.z" pattern
-            patterns = [r'version\s*=\s*["\']([^"\']+)["\']', r'version:\s*["\']([^"\']+)["\']']
+            patterns = [
+                r'version\s*=\s*["\']([^"\']+)["\']',
+                r'version:\s*["\']([^"\']+)["\']',
+            ]
 
             for pattern in patterns:
                 match = re.search(pattern, content)
@@ -419,7 +463,7 @@ class SemanticVersionManager:
     def _parse_version_file(self, file_path: Path) -> Optional[str]:
         """Parse version from simple version file."""
         try:
-            with open(file_path, "r") as f:
+            with file_path.open() as f:
                 return f.read().strip()
         except Exception:
             return None
@@ -427,7 +471,7 @@ class SemanticVersionManager:
     def _parse_pom_xml_version(self, file_path: Path) -> Optional[str]:
         """Parse version from Maven pom.xml."""
         try:
-            with open(file_path, "r") as f:
+            with file_path.open() as f:
                 content = f.read()
 
             # Simple regex to find version in pom.xml
@@ -452,24 +496,24 @@ class SemanticVersionManager:
         3. Determine highest priority change type
         4. Suggest appropriate version bump
         5. Calculate confidence score
-        
+
         Pattern Matching:
         - Breaking: "breaking", "breaking change", "remove api", etc.
         - Features: "add", "new feature", "implement", "enhance"
         - Fixes: "fix", "bug fix", "resolve", "correct"
-        
+
         Version Bump Priority:
         1. Breaking changes -> MAJOR (highest priority)
         2. New features -> MINOR
         3. Bug fixes -> PATCH
         4. Other changes -> PATCH (default)
-        
+
         Confidence Scoring:
         - 0.9: Clear breaking changes detected
         - 0.8: Clear new features detected
         - 0.7: Clear bug fixes detected
         - 0.5: No clear patterns (default to patch)
-        
+
         This analysis is used for:
         - Conventional commit integration
         - Automated version bumping
@@ -490,15 +534,22 @@ class SemanticVersionManager:
             change_lower = change.lower()
 
             # Check for breaking changes (highest priority)
-            if any(re.search(pattern, change_lower) for pattern in self.breaking_change_patterns):
+            if any(
+                re.search(pattern, change_lower)
+                for pattern in self.breaking_change_patterns
+            ):
                 analysis.has_breaking_changes = True
 
             # Check for new features
-            elif any(re.search(pattern, change_lower) for pattern in self.feature_patterns):
+            elif any(
+                re.search(pattern, change_lower) for pattern in self.feature_patterns
+            ):
                 analysis.has_new_features = True
 
             # Check for bug fixes
-            elif any(re.search(pattern, change_lower) for pattern in self.bug_fix_patterns):
+            elif any(
+                re.search(pattern, change_lower) for pattern in self.bug_fix_patterns
+            ):
                 analysis.has_bug_fixes = True
 
         # Determine suggested bump based on priority
@@ -532,7 +583,9 @@ class SemanticVersionManager:
         """
         return current_version.bump(bump_type)
 
-    def suggest_version_bump(self, commit_messages: List[str]) -> Tuple[VersionBumpType, float]:
+    def suggest_version_bump(
+        self, commit_messages: List[str]
+    ) -> Tuple[VersionBumpType, float]:
         """
         Suggest version bump based on commit messages.
 
@@ -572,7 +625,9 @@ class SemanticVersionManager:
                     results[filename] = success
 
                     if success:
-                        self.logger.info(f"Updated version to {version_string} in {filename}")
+                        self.logger.info(
+                            f"Updated version to {version_string} in {filename}"
+                        )
                     else:
                         self.logger.error(f"Failed to update version in {filename}")
 
@@ -589,11 +644,11 @@ class SemanticVersionManager:
         try:
             if filename == "package.json":
                 return self._update_package_json_version(file_path, new_version)
-            elif filename in ["pyproject.toml", "Cargo.toml"]:
+            if filename in ["pyproject.toml", "Cargo.toml"]:
                 return self._update_toml_version(file_path, new_version)
-            elif filename in ["VERSION", "version.txt"]:
+            if filename in ["VERSION", "version.txt"]:
                 return self._update_simple_version_file(file_path, new_version)
-            elif filename == "pom.xml":
+            if filename == "pom.xml":
                 return self._update_pom_xml_version(file_path, new_version)
 
             return False
@@ -618,7 +673,7 @@ class SemanticVersionManager:
     def _update_toml_version(self, file_path: Path, new_version: str) -> bool:
         """Update version in TOML file."""
         try:
-            with open(file_path, "r") as f:
+            with file_path.open() as f:
                 content = f.read()
 
             # Replace version field
@@ -636,7 +691,7 @@ class SemanticVersionManager:
                     break
 
             if updated:
-                with open(file_path, "w") as f:
+                with file_path.open("w") as f:
                     f.write(content)
                 return True
 
@@ -648,7 +703,7 @@ class SemanticVersionManager:
     def _update_simple_version_file(self, file_path: Path, new_version: str) -> bool:
         """Update version in simple version file."""
         try:
-            with open(file_path, "w") as f:
+            with file_path.open("w") as f:
                 f.write(new_version + "\n")
             return True
         except Exception:
@@ -657,7 +712,7 @@ class SemanticVersionManager:
     def _update_pom_xml_version(self, file_path: Path, new_version: str) -> bool:
         """Update version in Maven pom.xml."""
         try:
-            with open(file_path, "r") as f:
+            with file_path.open() as f:
                 content = f.read()
 
             # Replace first version tag (project version)
@@ -667,7 +722,7 @@ class SemanticVersionManager:
             new_content = re.sub(pattern, replacement, content, count=1)
 
             if new_content != content:
-                with open(file_path, "w") as f:
+                with file_path.open("w") as f:
                     f.write(new_content)
                 return True
 
@@ -693,7 +748,7 @@ class SemanticVersionManager:
         Returns:
             Formatted changelog entry
         """
-        date_str = datetime.now().strftime("%Y-%m-%d")
+        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
         if metadata and metadata.release_date:
             date_str = metadata.release_date.strftime("%Y-%m-%d")
 
@@ -709,11 +764,18 @@ class SemanticVersionManager:
         for change in changes:
             change_lower = change.lower()
 
-            if any(re.search(pattern, change_lower) for pattern in self.breaking_change_patterns):
+            if any(
+                re.search(pattern, change_lower)
+                for pattern in self.breaking_change_patterns
+            ):
                 breaking_changes.append(change)
-            elif any(re.search(pattern, change_lower) for pattern in self.feature_patterns):
+            elif any(
+                re.search(pattern, change_lower) for pattern in self.feature_patterns
+            ):
                 features.append(change)
-            elif any(re.search(pattern, change_lower) for pattern in self.bug_fix_patterns):
+            elif any(
+                re.search(pattern, change_lower) for pattern in self.bug_fix_patterns
+            ):
                 fixes.append(change)
             else:
                 other_changes.append(change)
@@ -755,7 +817,10 @@ class SemanticVersionManager:
         return "\n".join(lines)
 
     def update_changelog(
-        self, version: SemanticVersion, changes: List[str], changelog_file: str = "docs/CHANGELOG.md"
+        self,
+        version: SemanticVersion,
+        changes: List[str],
+        changelog_file: str = "docs/CHANGELOG.md",
     ) -> bool:
         """
         Update CHANGELOG.md with new version entry.
@@ -776,7 +841,7 @@ class SemanticVersionManager:
 
             # Read existing changelog or create new one
             if changelog_path.exists():
-                with open(changelog_path, "r") as f:
+                with changelog_path.open() as f:
                     existing_content = f.read()
 
                 # Insert new entry after title
@@ -785,7 +850,7 @@ class SemanticVersionManager:
 
                 # Find insertion point (after # Changelog title)
                 for i, line in enumerate(lines):
-                    if line.startswith("# ") or line.startswith("## [Unreleased]"):
+                    if line.startswith(("# ", "## [Unreleased]")):
                         insert_index = i + 1
                         break
 
@@ -799,7 +864,7 @@ class SemanticVersionManager:
                 content = f"# Changelog\n\n{new_entry}\n"
 
             # Write updated changelog
-            with open(changelog_path, "w") as f:
+            with changelog_path.open("w") as f:
                 f.write(content)
 
             self.logger.info(f"Updated {changelog_file} with version {version}")
@@ -811,19 +876,65 @@ 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))
+        changelog_paths = [
+            self.project_root / "CHANGELOG.md",
+            self.project_root / "docs" / "CHANGELOG.md",
+        ]
 
-        # TODO: Add Git tag parsing if needed
+        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)
@@ -834,7 +945,7 @@ class SemanticVersionManager:
         versions = []
 
         try:
-            with open(changelog_path, "r") as f:
+            with changelog_path.open() as f:
                 content = f.read()
 
             # Find version entries