claude-mpm 4.5.0__py3-none-any.whl → 4.5.5__py3-none-any.whl

claude_mpm/services/mcp_gateway/utils/__init__.py

@@ -0,0 +1,14 @@
+"""
+MCP Gateway Utilities
+======================
+
+Utility modules for the MCP Gateway service.
+"""
+
+from .package_version_checker import PackageVersionChecker
+from .update_preferences import UpdatePreferences
+
+__all__ = [
+    "PackageVersionChecker",
+    "UpdatePreferences",
+]

claude_mpm/services/mcp_gateway/utils/package_version_checker.py

@@ -0,0 +1,160 @@
+"""
+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
+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().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 open(cache_file) as f:
+                data = json.load(f)
+
+            # Check TTL
+            checked_at = datetime.fromisoformat(data["checked_at"])
+            if datetime.now() - 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 open(cache_file, "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

@@ -0,0 +1,170 @@
+"""
+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 open(cls.PREFS_FILE) 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 open(cls.PREFS_FILE, "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/services/mcp_service_verifier.py

@@ -311,7 +311,7 @@ class MCPServiceVerifier:
         try:
             # First try direct execution
             result = subprocess.run(
-                [path] + test_args,
+                [path, *test_args],
                 capture_output=True,
                 text=True,
                 timeout=10,
@@ -339,7 +339,7 @@ class MCPServiceVerifier:
             # Try pipx run as fallback
             if shutil.which("pipx"):
                 result = subprocess.run(
-                    ["pipx", "run", service_name] + test_args,
+                    ["pipx", "run", service_name, *test_args],
                     capture_output=True,
                     text=True,
                     timeout=10,
@@ -655,7 +655,7 @@ class MCPServiceVerifier:
         working = []
         issues = []
 
-        for name, diag in diagnostics.items():
+        for _name, diag in diagnostics.items():
             if diag.status == ServiceStatus.WORKING:
                 working.append(diag)
             else:
@@ -710,7 +710,7 @@ def verify_mcp_services_on_startup() -> Tuple[bool, str]:
         Tuple of (all_working, summary_message)
     """
     verifier = MCPServiceVerifier()
-    logger = get_logger(__name__)
+    get_logger(__name__)
 
     # Do quick checks only (don't block startup)
     issues = []

claude_mpm/services/monitor/event_emitter.py

@@ -26,7 +26,8 @@ class AsyncEventEmitter:
 
     def __init__(self):
         """Initialize the event emitter."""
-        self.logger = get_logger(__name__)
+        # Use a shorter, cleaner logger name instead of full module path
+        self.logger = get_logger("event_emitter")
 
         # Direct emission targets (in-process)
         self._socketio_servers: Set[weakref.ref] = set()
@@ -221,7 +222,10 @@ class AsyncEventEmitter:
             self.logger.warning(f"HTTP emission timeout: {event}")
             return False
         except aiohttp.ClientError as e:
-            self.logger.warning(f"HTTP emission client error: {e}")
+            # Use DEBUG since the monitor service is optional and may not be running
+            self.logger.debug(
+                f"HTTP emission client error (monitor may not be running): {e}"
+            )
             return False
         except Exception as e:
             self.logger.error(f"HTTP emission unexpected error: {e}")

claude_mpm/services/project/archive_manager.py

@@ -16,6 +16,7 @@ Author: Claude MPM Development Team
 Created: 2025-01-26
 """
 
+import contextlib
 import difflib
 import gzip
 import hashlib
@@ -173,7 +174,7 @@ Generated by Claude MPM Archive Manager
         # Compress old archives
         cutoff_compress = datetime.now() - timedelta(days=self.COMPRESS_AFTER_DAYS)
         for archive in archives:
-            if not archive.suffix == ".gz":
+            if archive.suffix != ".gz":
                 mtime = datetime.fromtimestamp(archive.stat().st_mtime)
                 if mtime < cutoff_compress:
                     self._compress_archive(archive)
@@ -247,7 +248,7 @@ Generated by Claude MPM Archive Manager
             archive_files = [
                 f
                 for f in self.archive_path.glob("*")
-                if not f.name.endswith(".meta.json") and not f.name == "README.md"
+                if not f.name.endswith(".meta.json") and f.name != "README.md"
             ]
 
         for archive_file in archive_files:
@@ -265,10 +266,8 @@ Generated by Claude MPM Archive Manager
             if include_metadata:
                 meta_path = self.archive_path / f"{archive_file.name}.meta.json"
                 if meta_path.exists():
-                    try:
+                    with contextlib.suppress(Exception):
                         info["metadata"] = json.loads(meta_path.read_text())
-                    except Exception:
-                        pass
 
             archives.append(info)
 
@@ -452,7 +451,7 @@ Generated by Claude MPM Archive Manager
 
         try:
             result = subprocess.run(
-                ["git"] + args,
+                ["git", *args],
                 cwd=self.project_path,
                 capture_output=True,
                 text=True,
@@ -528,7 +527,7 @@ Generated by Claude MPM Archive Manager
         }
 
         # Review each key documentation file
-        for doc_file, description in self.key_docs.items():
+        for doc_file, _description in self.key_docs.items():
             file_path = self.project_path / doc_file
             if file_path.exists():
                 file_report = self._review_single_doc(file_path, check_git)
@@ -956,13 +955,12 @@ Generated by Claude MPM Archive Manager
         )
 
         # Update explicit version mentions
-        content = re.sub(
+        return re.sub(
             r"(?:Version|version|v)\s*\d+\.\d+\.\d+",
             f"v{new_version}",
             content,
         )
 
-        return content
 
     def display_review_summary(self, review: Dict) -> None:
         """Display a formatted summary of the documentation review."""

claude_mpm/services/project/documentation_manager.py

@@ -231,9 +231,8 @@ class DocumentationManager:
         merged = self._reorganize_by_priority(merged)
 
         # Add metadata
-        merged = self._add_metadata(merged)
+        return self._add_metadata(merged)
 
-        return merged
 
     def _parse_into_sections(self, content: str) -> Dict[str, str]:
         """Parse markdown content into a dictionary of sections."""
@@ -337,7 +336,7 @@ class DocumentationManager:
 
             # Reconstruct section
             if all_items:
-                return "\n".join([""] + all_items + [""])
+                return "\n".join(["", *all_items, ""])
             return new
         # For other sections, use new as base and append existing
         if existing.strip() and existing.strip() != new.strip():

claude_mpm/services/project/enhanced_analyzer.py

@@ -61,7 +61,7 @@ class EnhancedProjectAnalyzer:
         """Run a git command and return output."""
         try:
             result = subprocess.run(
-                ["git"] + args,
+                ["git", *args],
                 cwd=self.project_path,
                 capture_output=True,
                 text=True,

claude_mpm/services/project/project_organizer.py

@@ -54,6 +54,10 @@ class ProjectOrganizer:
         ".claude-mpm/cache/",
         ".claude-mpm/logs/",
         ".claude/cache/",
+        # MCP service directories for local data
+        ".mcp-vector-search/",
+        ".kuzu-memory/",
+        "kuzu-memories/",  # kuzu-memory database directory
         # Python artifacts
         "__pycache__/",
         "*.py[cod]",
@@ -444,11 +448,11 @@ This directory is used for {description.lower()}.
             existing_patterns = set()
             if self.gitignore_path.exists():
                 content = self.gitignore_path.read_text()
-                existing_patterns = set(
+                existing_patterns = {
                     line.strip()
                     for line in content.splitlines()
                     if line.strip() and not line.startswith("#")
-                )
+                }
             else:
                 content = ""
 
@@ -973,16 +977,15 @@ This directory is used for {description.lower()}.
         root_files = list(self.project_path.glob("*"))
         misplaced_count = 0
         for file in root_files:
-            if file.is_file():
-                if (
-                    ("test" in file.name.lower() and file.suffix == ".py")
-                    or (
-                        file.suffix in [".sh", ".bash"]
-                        and file.name not in ["Makefile"]
-                    )
-                    or file.suffix in [".log", ".tmp", ".cache"]
-                ):
-                    misplaced_count += 1
+            if file.is_file() and (
+                ("test" in file.name.lower() and file.suffix == ".py")
+                or (
+                    file.suffix in [".sh", ".bash"]
+                    and file.name not in ["Makefile"]
+                )
+                or file.suffix in [".log", ".tmp", ".cache"]
+            ):
+                misplaced_count += 1
 
         if misplaced_count > 0:
             validation["warnings"].append(

claude_mpm/services/unified/__init__.py

@@ -42,24 +42,24 @@ from .unified_config import UnifiedConfigManager
 from .unified_deployment import UnifiedDeploymentService
 
 __all__ = [
-    # Interfaces
-    "IDeploymentService",
+    "AnalyzerStrategy",
+    "ConfigStrategy",
+    # Strategies
+    "DeploymentStrategy",
+    "FeatureFlag",
     "IAnalyzerService",
     "IConfigurationService",
-    "ServiceMetadata",
+    # Interfaces
+    "IDeploymentService",
+    "MigrationStatus",
     "ServiceCapability",
-    # Strategies
-    "DeploymentStrategy",
-    "AnalyzerStrategy",
-    "ConfigStrategy",
-    "StrategyRegistry",
     # Migration
     "ServiceMapper",
-    "MigrationStatus",
-    "FeatureFlag",
-    "create_compatibility_wrapper",
-    # Unified Services
-    "UnifiedDeploymentService",
+    "ServiceMetadata",
+    "StrategyRegistry",
     "UnifiedAnalyzer",
     "UnifiedConfigManager",
+    # Unified Services
+    "UnifiedDeploymentService",
+    "create_compatibility_wrapper",
 ]

claude_mpm/services/unified/analyzer_strategies/dependency_analyzer.py

@@ -234,10 +234,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
             # Check for pyproject.toml variants
             if manifest_path.name == "pyproject.toml":
                 content = manifest_path.read_text()
-                if "[tool.poetry]" in content:
-                    manager = "poetry"
-                else:
-                    manager = "pip"
+                manager = "poetry" if "[tool.poetry]" in content else "pip"
 
         if not manager:
             return {
@@ -537,7 +534,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
         """Detect web frameworks from dependencies."""
         detected = []
 
-        for language, frameworks in self.FRAMEWORK_PACKAGES.items():
+        for _language, frameworks in self.FRAMEWORK_PACKAGES.items():
             for framework in frameworks:
                 if framework in dependencies:
                     detected.append(framework)
@@ -561,7 +558,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
         """Detect testing tools from dependencies."""
         detected = []
 
-        for language, tools in self.TESTING_PACKAGES.items():
+        for _language, tools in self.TESTING_PACKAGES.items():
             for tool in tools:
                 if tool in dependencies:
                     detected.append(tool)
@@ -570,7 +567,7 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
 
     def _check_vulnerabilities(self, project_path: Path) -> Dict[str, Any]:
         """Check for known security vulnerabilities in dependencies."""
-        vulnerabilities = {
+        return {
             "total": 0,
             "critical": 0,
             "high": 0,
@@ -583,7 +580,6 @@ class DependencyAnalyzerStrategy(AnalyzerStrategy):
         # In production, you would integrate with vulnerability databases
         # like npm audit, pip-audit, or safety
 
-        return vulnerabilities
 
     def _calculate_statistics(self, results: Dict[str, Any]) -> Dict[str, Any]:
         """Calculate dependency statistics."""

claude_mpm/services/unified/analyzer_strategies/performance_analyzer.py

@@ -276,7 +276,6 @@ class PerformanceAnalyzerStrategy(AnalyzerStrategy):
             ".sql",
         }
 
-        files_with_issues = []
         total_score = 0
 
         # Analyze each file

claude_mpm/services/unified/analyzer_strategies/structure_analyzer.py

@@ -716,14 +716,13 @@ class StructureAnalyzerStrategy(AnalyzerStrategy):
                         }
 
         # Compare architecture
-        if "architecture" in baseline and "architecture" in current:
-            if (
-                baseline["architecture"]["pattern"]
-                != current["architecture"]["pattern"]
-            ):
-                comparison["architecture_change"] = {
-                    "baseline": baseline["architecture"]["pattern"],
-                    "current": current["architecture"]["pattern"],
-                }
+        if "architecture" in baseline and "architecture" in current and (
+            baseline["architecture"]["pattern"]
+            != current["architecture"]["pattern"]
+        ):
+            comparison["architecture_change"] = {
+                "baseline": baseline["architecture"]["pattern"],
+                "current": current["architecture"]["pattern"],
+            }
 
         return comparison