claude-mpm 4.1.1__py3-none-any.whl → 4.1.3__py3-none-any.whl

claude_mpm/services/version_control/conflict_resolution.py

@@ -11,13 +11,11 @@ This module provides conflict resolution management including:
 5. Resolution validation
 """
 
-import difflib
 import logging
 import re
 from dataclasses import dataclass, field
-from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional
 
 
 class ConflictType(Enum):
@@ -248,11 +246,7 @@ class ConflictResolutionManager:
 
             conflicted_files = []
             for line in result.stdout.strip().split("\n"):
-                if line.strip() and (
-                    line.startswith("UU")
-                    or line.startswith("AA")
-                    or line.startswith("DD")
-                ):
+                if line.strip() and (line.startswith(("UU", "AA", "DD"))):
                     # Extract filename
                     filename = line[3:].strip()
                     conflicted_files.append(filename)
@@ -280,7 +274,7 @@ class ConflictResolutionManager:
             )
 
         try:
-            with open(full_path, "r", encoding="utf-8") as f:
+            with open(full_path, encoding="utf-8") as f:
                 content = f.read()
 
             # Parse conflict markers
@@ -404,11 +398,7 @@ class ConflictResolutionManager:
             return False
 
         # Check if all conflicts are simple
-        for marker in markers:
-            if not self._is_simple_conflict(marker):
-                return False
-
-        return True
+        return all(self._is_simple_conflict(marker) for marker in markers)
 
     def _is_simple_conflict(self, marker: ConflictMarker) -> bool:
         """Check if a conflict marker represents a simple conflict."""
@@ -428,10 +418,7 @@ class ConflictResolutionManager:
             return True
 
         # Check if differences are only imports
-        if self._only_import_differences(ours_lines, theirs_lines):
-            return True
-
-        return False
+        return bool(self._only_import_differences(ours_lines, theirs_lines))
 
     def _only_whitespace_differences(self, ours: List[str], theirs: List[str]) -> bool:
         """Check if differences are only whitespace."""
@@ -444,7 +431,7 @@ class ConflictResolutionManager:
         # This is a simplified check
         for line in ours + theirs:
             stripped = line.strip()
-            if stripped and not (stripped.startswith("#") or stripped.startswith("//")):
+            if stripped and not (stripped.startswith(("#", "//"))):
                 return False
         return True
 
@@ -516,10 +503,9 @@ class ConflictResolutionManager:
 
         if auto_ratio > 0.8:
             return "simple"
-        elif auto_ratio > 0.5:
+        if auto_ratio > 0.5:
             return "moderate"
-        else:
-            return "complex"
+        return "complex"
 
     def _estimate_resolution_time(self, file_conflicts: List[FileConflict]) -> int:
         """Estimate resolution time in minutes."""
@@ -601,7 +587,7 @@ class ConflictResolutionManager:
 
         try:
             # Read current content
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(file_path, encoding="utf-8") as f:
                 content = f.read()
 
             # Apply resolution strategy

claude_mpm/services/version_control/git_operations.py

@@ -13,11 +13,10 @@ This module provides comprehensive Git operation management including:
 
 import logging
 import os
-import re
 import subprocess
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 
 @dataclass
@@ -128,7 +127,7 @@ class GitOperationsManager:
         Raises:
             GitOperationError: If command fails and check=True
         """
-        cmd = ["git"] + args
+        cmd = ["git", *args]
         cwd = cwd or str(self.project_root)
 
         try:
@@ -444,7 +443,7 @@ class GitOperationsManager:
                 return GitOperationResult(
                     success=False,
                     operation="switch_branch",
-                    message=f"Cannot switch branch: uncommitted changes exist",
+                    message="Cannot switch branch: uncommitted changes exist",
                     error=f"Modified files: {', '.join(modified_files)}",
                     branch_before=current_branch,
                     branch_after=current_branch,
@@ -599,10 +598,9 @@ class GitOperationsManager:
             conflicted_files = []
             if has_conflicts:
                 lines = result.stdout.split("\n")
-                current_file = None
 
                 for line in lines:
-                    if line.startswith("+++") or line.startswith("---"):
+                    if line.startswith(("+++", "---")):
                         # Extract filename
                         parts = line.split("\t")
                         if len(parts) > 1:
@@ -775,7 +773,7 @@ class GitOperationsManager:
             for line in result.stdout.strip().split("\n"):
                 branch = line.strip().lstrip("* ").strip()
                 # Skip target branch and current branch
-                if branch and branch != target_branch and branch != current_branch:
+                if branch and branch not in (target_branch, current_branch):
                     merged_branches.append(branch)
 
             # Delete merged branches

claude_mpm/services/version_control/semantic_versioning.py

@@ -39,13 +39,12 @@ Change Analysis:
 - Confidence scoring for version bump suggestions
 """
 
-import json
 import logging
 import re
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple
 
 from ...utils.config_manager import ConfigurationManager
 
@@ -167,13 +166,13 @@ class SemanticVersion:
         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)
@@ -423,7 +422,7 @@ class SemanticVersionManager:
             # Try different locations for version
             if "project" in data and "version" in data["project"]:
                 return data["project"]["version"]
-            elif (
+            if (
                 "tool" in data
                 and "poetry" in data["tool"]
                 and "version" in data["tool"]["poetry"]
@@ -438,7 +437,7 @@ 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 open(file_path) as f:
                 content = f.read()
 
             # Look for version = "x.y.z" pattern
@@ -464,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 open(file_path) as f:
                 return f.read().strip()
         except Exception:
             return None
@@ -472,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 open(file_path) as f:
                 content = f.read()
 
             # Simple regex to find version in pom.xml
@@ -645,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
@@ -674,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 open(file_path) as f:
                 content = f.read()
 
             # Replace version field
@@ -713,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 open(file_path) as f:
                 content = f.read()
 
             # Replace first version tag (project version)
@@ -842,7 +841,7 @@ class SemanticVersionManager:
 
             # Read existing changelog or create new one
             if changelog_path.exists():
-                with open(changelog_path, "r") as f:
+                with open(changelog_path) as f:
                     existing_content = f.read()
 
                 # Insert new entry after title
@@ -851,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
 
@@ -946,7 +945,7 @@ class SemanticVersionManager:
         versions = []
 
         try:
-            with open(changelog_path, "r") as f:
+            with open(changelog_path) as f:
                 content = f.read()
 
             # Find version entries

claude_mpm/services/version_control/version_parser.py

@@ -15,15 +15,14 @@ from multiple sources with intelligent fallback logic:
 The system includes caching for performance and validation for data integrity.
 """
 
+import contextlib
 import json
 import logging
 import re
 import subprocess
 from datetime import datetime, timedelta
 from functools import lru_cache
-from typing import Dict, List, Optional, Tuple, Union
-
-from claude_mpm.services.version_control.semantic_versioning import SemanticVersion
+from typing import Dict, List, Optional, Tuple
 
 
 class VersionSource:
@@ -73,9 +72,9 @@ class VersionMetadata:
         return {
             "version": self.version,
             "source": self.source,
-            "release_date": self.release_date.isoformat()
-            if self.release_date
-            else None,
+            "release_date": (
+                self.release_date.isoformat() if self.release_date else None
+            ),
             "commit_hash": self.commit_hash,
             "author": self.author,
             "message": self.message,
@@ -213,13 +212,13 @@ class EnhancedVersionParser:
         """Get version(s) from a specific source."""
         if source == VersionSource.GIT_TAGS:
             return self._get_version_from_git(latest_only)
-        elif source == VersionSource.VERSION_FILE:
+        if source == VersionSource.VERSION_FILE:
             return self._get_version_from_file()
-        elif source == VersionSource.PACKAGE_JSON:
+        if source == VersionSource.PACKAGE_JSON:
             return self._get_version_from_package_json()
-        elif source == VersionSource.PYPROJECT_TOML:
+        if source == VersionSource.PYPROJECT_TOML:
             return self._get_version_from_pyproject()
-        elif source == VersionSource.CHANGELOG:
+        if source == VersionSource.CHANGELOG:
             versions = self._get_versions_from_changelog()
             return versions[0] if versions else None
         return None
@@ -228,9 +227,9 @@ class EnhancedVersionParser:
         """Get all versions from a specific source."""
         if source == VersionSource.GIT_TAGS:
             return self._get_all_versions_from_git()
-        elif source == VersionSource.CHANGELOG:
+        if source == VersionSource.CHANGELOG:
             return self._get_versions_from_changelog()
-        elif source in [
+        if source in [
             VersionSource.VERSION_FILE,
             VersionSource.PACKAGE_JSON,
             VersionSource.PYPROJECT_TOML,
@@ -318,10 +317,8 @@ class EnhancedVersionParser:
         # Parse date if provided
         release_date = None
         if date_str:
-            try:
+            with contextlib.suppress(Exception):
                 release_date = datetime.fromisoformat(date_str.replace(" ", "T"))
-            except:
-                pass
 
         # Get commit hash for this tag
         commit_hash = None
@@ -422,10 +419,8 @@ class EnhancedVersionParser:
                         # Parse release date
                         release_date = None
                         if date_str:
-                            try:
+                            with contextlib.suppress(Exception):
                                 release_date = datetime.strptime(date_str, "%Y-%m-%d")
-                            except:
-                                pass
 
                         # Extract changes for this version
                         changes = self._extract_changelog_changes(

claude_mpm/services/version_service.py

@@ -25,11 +25,9 @@ class VersionService(BaseService, VersionServiceInterface):
 
     async def _initialize(self) -> None:
         """Initialize the service. No special initialization needed."""
-        pass
 
     async def _cleanup(self) -> None:
         """Cleanup service resources. No cleanup needed."""
-        pass
 
     def get_version(self) -> str:
         """
@@ -134,12 +132,16 @@ class VersionService(BaseService, VersionServiceInterface):
                 if build_file.exists():
                     build_content = build_file.read_text().strip()
                     build_number = int(build_content)
-                    self.logger.debug(f"Build number obtained from {build_file}: {build_number}")
+                    self.logger.debug(
+                        f"Build number obtained from {build_file}: {build_number}"
+                    )
                     return build_number
-            except (ValueError, IOError) as e:
+            except (OSError, ValueError) as e:
                 self.logger.debug(f"Could not read BUILD_NUMBER from {build_file}: {e}")
             except Exception as e:
-                self.logger.debug(f"Unexpected error reading BUILD_NUMBER from {build_file}: {e}")
+                self.logger.debug(
+                    f"Unexpected error reading BUILD_NUMBER from {build_file}: {e}"
+                )
 
         return None
 
@@ -162,8 +164,7 @@ class VersionService(BaseService, VersionServiceInterface):
         if build_number is not None:
             # UI/logging format with 'v' prefix and dash separator
             return f"v{version}-build.{build_number}"
-        else:
-            return f"v{version}"
+        return f"v{version}"
 
     def get_base_version(self) -> str:
         """Get base version without build number.
@@ -222,8 +223,7 @@ class VersionService(BaseService, VersionServiceInterface):
 
         if build_number is not None:
             return f"{base_version}+build.{build_number}"
-        else:
-            return base_version
+        return base_version
 
     # Implementation of abstract methods from VersionServiceInterface
 
@@ -256,8 +256,7 @@ class VersionService(BaseService, VersionServiceInterface):
         """
         if include_build:
             return self.get_version()  # Already includes build number
-        else:
-            return self.get_base_version()
+        return self.get_base_version()
 
     def check_for_updates(self) -> Dict[str, Any]:
         """Check for available updates.

claude_mpm/storage/__init__.py

@@ -6,4 +6,4 @@ with atomic operations and various serialization formats.
 
 from .state_storage import StateCache, StateStorage
 
-__all__ = ["StateStorage", "StateCache"]
+__all__ = ["StateCache", "StateStorage"]

claude_mpm/storage/state_storage.py

@@ -20,12 +20,10 @@ import logging
 import os
 import pickle
 import platform
-import shutil
 import tempfile
 import time
-from contextlib import contextmanager
-from datetime import datetime
-from typing import Any, BinaryIO, Dict, Optional, TextIO, Union
+from contextlib import contextmanager, suppress
+from typing import Any, Dict, Optional, Tuple, Union
 
 
 class StateStorage:
@@ -76,17 +74,16 @@ class StateStorage:
                 return self._atomic_write(
                     file_path, data, serializer="json", compress=compress
                 )
+            # Direct write (not atomic)
+            if compress:
+                with gzip.open(file_path, "wt", encoding="utf-8") as f:
+                    json.dump(data, f, indent=2, default=str)
             else:
-                # Direct write (not atomic)
-                if compress:
-                    with gzip.open(file_path, "wt", encoding="utf-8") as f:
-                        json.dump(data, f, indent=2, default=str)
-                else:
-                    with open(file_path, "w") as f:
-                        json.dump(data, f, indent=2, default=str)
+                with open(file_path, "w") as f:
+                    json.dump(data, f, indent=2, default=str)
 
-                self.write_count += 1
-                return True
+            self.write_count += 1
+            return True
 
         except Exception as e:
             self.logger.error(f"Failed to write JSON to {file_path}: {e}")
@@ -121,7 +118,7 @@ class StateStorage:
                     with gzip.open(file_path, "rt", encoding="utf-8") as f:
                         data = json.load(f)
                 else:
-                    with open(file_path, "r") as f:
+                    with open(file_path) as f:
                         data = json.load(f)
 
             self.read_count += 1
@@ -157,17 +154,16 @@ class StateStorage:
                 return self._atomic_write(
                     file_path, data, serializer="pickle", compress=compress
                 )
+            # Direct write (not atomic)
+            if compress:
+                with gzip.open(file_path, "wb") as f:
+                    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
             else:
-                # Direct write (not atomic)
-                if compress:
-                    with gzip.open(file_path, "wb") as f:
-                        pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
-                else:
-                    with open(file_path, "wb") as f:
-                        pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
+                with open(file_path, "wb") as f:
+                    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
 
-                self.write_count += 1
-                return True
+            self.write_count += 1
+            return True
 
         except Exception as e:
             self.logger.error(f"Failed to write pickle to {file_path}: {e}")
@@ -307,7 +303,7 @@ class StateStorage:
                 try:
                     fcntl.flock(f.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
                     break
-                except IOError:
+                except OSError:
                     if attempt == max_attempts - 1:
                         raise
                     time.sleep(0.1)
@@ -316,10 +312,8 @@ class StateStorage:
 
         finally:
             if f:
-                try:
+                with suppress(Exception):
                     fcntl.flock(f.fileno(), fcntl.LOCK_UN)
-                except:
-                    pass
                 f.close()
 
     def _add_checksum(self, file_path: Union[str, Path]) -> None:
@@ -364,7 +358,7 @@ class StateStorage:
                 return True  # No checksum to verify
 
             # Read expected checksum
-            with open(checksum_path, "r") as f:
+            with open(checksum_path) as f:
                 expected = f.read().strip()
 
             # Calculate actual checksum

claude_mpm/utils/__init__.py

@@ -2,15 +2,15 @@
 
 # Delay imports to avoid circular dependencies
 __all__ = [
+    "ConfigurationManager",
+    "find_file_upwards",
+    "get_framework_root",
     "get_logger",
-    "setup_logging",
-    "safe_import",
-    "safe_import_multiple",
     "get_path_manager()",
-    "get_framework_root",
     "get_project_root",
-    "find_file_upwards",
-    "ConfigurationManager",
     "load_config",
+    "safe_import",
+    "safe_import_multiple",
     "save_config",
+    "setup_logging",
 ]