claude-mpm 5.1.9__py3-none-any.whl → 5.4.14__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)

claude_mpm-5.1.9.dist-info/entry_points.txt

@@ -1,10 +0,0 @@
-[console_scripts]
-claude-mpm = claude_mpm.cli:main
-claude-mpm-doctor = claude_mpm.scripts.mpm_doctor:main
-claude-mpm-mcp = claude_mpm.services.mcp_gateway.server.stdio_server:main_sync
-claude-mpm-mcp-wrapper = claude_mpm.scripts.mcp_wrapper:entry_point
-claude-mpm-monitor = claude_mpm.scripts.launch_monitor:main
-claude-mpm-socketio = claude_mpm.scripts.socketio_daemon:main
-claude-mpm-ticket = claude_mpm.cli.ticket_cli:main
-claude-mpm-version = claude_mpm.scripts.manage_version:main
-ticket = claude_mpm.cli.ticket_cli:main

claude_mpm-5.1.9.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Claude MPM Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.