claude-mpm 5.0.2__py3-none-any.whl → 5.4.3__py3-none-any.whl

claude_mpm/services/mcp_gateway/utils/package_version_checker.py

@@ -1,160 +0,0 @@
-"""
-Package Version Checker
-=======================
-
-Checks PyPI packages for updates with caching and timeout support.
-Provides non-blocking version checking for MCP tools like kuzu-memory.
-"""
-
-import asyncio
-import json
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-import aiohttp
-from packaging import version
-
-from ....core.logger import get_logger
-
-
-class PackageVersionChecker:
-    """
-    Check PyPI packages for updates with caching and timeout.
-
-    WHY: Automatically detect when newer versions of critical packages
-    (like kuzu-memory) are available to help users stay up-to-date.
-
-    DESIGN DECISIONS:
-    - Cache results to avoid excessive PyPI API calls
-    - Non-blocking with timeout to prevent startup delays
-    - Graceful failure handling (never block system operation)
-    """
-
-    CACHE_DIR = Path.home() / ".cache" / "claude-mpm" / "version-checks"
-    DEFAULT_CACHE_TTL = 86400  # 24 hours
-    PYPI_TIMEOUT = 5  # seconds
-
-    def __init__(self):
-        """Initialize the version checker with cache directory."""
-        self.logger = get_logger("PackageVersionChecker")
-        self.cache_dir = self.CACHE_DIR
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-    async def check_for_update(
-        self, package_name: str, current_version: str, cache_ttl: Optional[int] = None
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Check if a package has updates available.
-
-        Args:
-            package_name: Name of the package on PyPI
-            current_version: Currently installed version
-            cache_ttl: Cache time-to-live in seconds (optional)
-
-        Returns:
-            Dict with update information or None if check fails:
-            {
-                "current": "1.0.0",
-                "latest": "1.1.0",
-                "update_available": True,
-                "checked_at": "2025-01-29T12:00:00"
-            }
-        """
-        cache_ttl = cache_ttl or self.DEFAULT_CACHE_TTL
-
-        # Check cache first
-        cache_file = self.cache_dir / f"{package_name}.json"
-        cached = self._read_cache(cache_file, cache_ttl)
-        if cached:
-            # Update current version in cached data
-            cached["current"] = current_version
-            cached["update_available"] = version.parse(
-                cached["latest"]
-            ) > version.parse(current_version)
-            return cached
-
-        # Fetch from PyPI with timeout
-        try:
-            latest = await self._fetch_pypi_version(package_name)
-            if latest:
-                result = {
-                    "current": current_version,
-                    "latest": latest,
-                    "update_available": version.parse(latest)
-                    > version.parse(current_version),
-                    "checked_at": datetime.now(timezone.utc).isoformat(),
-                }
-                self._write_cache(cache_file, result)
-                return result
-        except Exception as e:
-            self.logger.debug(f"Version check failed for {package_name}: {e}")
-
-        return None
-
-    async def _fetch_pypi_version(self, package_name: str) -> Optional[str]:
-        """
-        Fetch the latest version from PyPI.
-
-        Args:
-            package_name: Package name to query
-
-        Returns:
-            Latest version string or None if fetch fails
-        """
-        url = f"https://pypi.org/pypi/{package_name}/json"
-
-        try:
-            timeout = aiohttp.ClientTimeout(total=self.PYPI_TIMEOUT)
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.get(url) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        return data["info"]["version"]
-        except asyncio.TimeoutError:
-            self.logger.debug(f"PyPI request timed out for {package_name}")
-        except Exception as e:
-            self.logger.debug(f"PyPI request failed: {e}")
-
-        return None
-
-    def _read_cache(self, cache_file: Path, ttl: int) -> Optional[Dict[str, Any]]:
-        """
-        Read from cache if valid.
-
-        Args:
-            cache_file: Path to cache file
-            ttl: Time-to-live in seconds
-
-        Returns:
-            Cached data if valid, None otherwise
-        """
-        if not cache_file.exists():
-            return None
-
-        try:
-            with cache_file.open() as f:
-                data = json.load(f)
-
-            # Check TTL
-            checked_at = datetime.fromisoformat(data["checked_at"])
-            if datetime.now(timezone.utc) - checked_at < timedelta(seconds=ttl):
-                return data
-        except Exception as e:
-            self.logger.debug(f"Cache read error: {e}")
-
-        return None
-
-    def _write_cache(self, cache_file: Path, data: Dict[str, Any]) -> None:
-        """
-        Write data to cache file.
-
-        Args:
-            cache_file: Path to cache file
-            data: Data to cache
-        """
-        try:
-            with cache_file.open("w") as f:
-                json.dump(data, f, indent=2)
-        except Exception as e:
-            self.logger.debug(f"Cache write failed: {e}")

claude_mpm/services/mcp_gateway/utils/update_preferences.py

@@ -1,170 +0,0 @@
-"""
-Update Preferences Manager
-===========================
-
-Manages user preferences for package update checking.
-Allows users to skip specific versions or disable update checks entirely.
-"""
-
-import json
-from pathlib import Path
-from typing import Any, Dict
-
-
-class UpdatePreferences:
-    """
-    Manage update checking preferences.
-
-    WHY: Respect user preferences about update notifications to avoid
-    annoying users who want to stay on specific versions or disable checks.
-
-    DESIGN DECISIONS:
-    - Store preferences in user's home directory
-    - Simple JSON format for easy manual editing
-    - Per-package preferences for granular control
-    """
-
-    PREFS_FILE = Path.home() / ".claude-mpm" / "mcp_updates.json"
-
-    @classmethod
-    def load(cls) -> Dict[str, Any]:
-        """
-        Load preferences from disk.
-
-        Returns:
-            Dictionary of preferences, empty dict if file doesn't exist
-        """
-        if cls.PREFS_FILE.exists():
-            try:
-                with cls.PREFS_FILE.open() as f:
-                    return json.load(f)
-            except (OSError, json.JSONDecodeError):
-                # Return empty dict if file is corrupted or unreadable
-                pass
-        return {}
-
-    @classmethod
-    def save(cls, prefs: Dict[str, Any]) -> None:
-        """
-        Save preferences to disk.
-
-        Args:
-            prefs: Preferences dictionary to save
-        """
-        cls.PREFS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        try:
-            with cls.PREFS_FILE.open("w") as f:
-                json.dump(prefs, f, indent=2)
-        except OSError:
-            # Silently fail if we can't write preferences
-            pass
-
-    @classmethod
-    def should_check_package(cls, package: str) -> bool:
-        """
-        Check if updates should be checked for a specific package.
-
-        Args:
-            package: Package name to check
-
-        Returns:
-            True if updates should be checked, False otherwise
-        """
-        prefs = cls.load()
-
-        # Global preference takes precedence
-        if not prefs.get("global_check_enabled", True):
-            return False
-
-        # Package-specific preference
-        pkg_prefs = prefs.get("packages", {}).get(package, {})
-        return pkg_prefs.get("check_enabled", True)
-
-    @classmethod
-    def should_skip_version(cls, package: str, version: str) -> bool:
-        """
-        Check if a specific version should be skipped for a package.
-
-        Args:
-            package: Package name
-            version: Version to check
-
-        Returns:
-            True if this version should be skipped, False otherwise
-        """
-        prefs = cls.load()
-        pkg_prefs = prefs.get("packages", {}).get(package, {})
-        skip_version = pkg_prefs.get("skip_version")
-        return skip_version == version
-
-    @classmethod
-    def set_skip_version(cls, package: str, version: str) -> None:
-        """
-        Remember to skip a specific version for a package.
-
-        Args:
-            package: Package name
-            version: Version to skip
-        """
-        prefs = cls.load()
-
-        # Ensure packages dict exists
-        if "packages" not in prefs:
-            prefs["packages"] = {}
-        if package not in prefs["packages"]:
-            prefs["packages"][package] = {}
-
-        prefs["packages"][package]["skip_version"] = version
-        cls.save(prefs)
-
-    @classmethod
-    def disable_package_checks(cls, package: str) -> None:
-        """
-        Disable update checks for a specific package.
-
-        Args:
-            package: Package name to disable checks for
-        """
-        prefs = cls.load()
-
-        # Ensure packages dict exists
-        if "packages" not in prefs:
-            prefs["packages"] = {}
-        if package not in prefs["packages"]:
-            prefs["packages"][package] = {}
-
-        prefs["packages"][package]["check_enabled"] = False
-        cls.save(prefs)
-
-    @classmethod
-    def enable_package_checks(cls, package: str) -> None:
-        """
-        Enable update checks for a specific package.
-
-        Args:
-            package: Package name to enable checks for
-        """
-        prefs = cls.load()
-
-        # Ensure packages dict exists
-        if "packages" not in prefs:
-            prefs["packages"] = {}
-        if package not in prefs["packages"]:
-            prefs["packages"][package] = {}
-
-        prefs["packages"][package]["check_enabled"] = True
-        cls.save(prefs)
-
-    @classmethod
-    def disable_all_checks(cls) -> None:
-        """Disable all update checks globally."""
-        prefs = cls.load()
-        prefs["global_check_enabled"] = False
-        cls.save(prefs)
-
-    @classmethod
-    def enable_all_checks(cls) -> None:
-        """Enable all update checks globally."""
-        prefs = cls.load()
-        prefs["global_check_enabled"] = True
-        cls.save(prefs)