moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/hooks/moai/lib/unified_timeout_manager.py

@@ -12,6 +12,8 @@ Architecture:
 - Graceful degradation with retry mechanisms
 """
 
+from __future__ import annotations
+
 import contextlib
 import logging
 import platform
@@ -22,10 +24,17 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Callable, Dict, Optional, Set
+from typing import Any, Callable, Dict, Set
 
 import yaml
 
+# Import base TimeoutError from timeout module for exception hierarchy
+try:
+    from .timeout import TimeoutError as BaseTimeoutError
+except ImportError:
+    # Fallback if timeout module not available
+    BaseTimeoutError = Exception  # type: ignore
+
 
 class TimeoutPolicy(Enum):
     """Timeout policy types for different hook categories"""
@@ -41,12 +50,12 @@ class HookTimeoutConfig:
     """Configuration for hook timeout behavior"""
 
     policy: TimeoutPolicy = TimeoutPolicy.NORMAL
-    custom_timeout_ms: Optional[int] = None
+    custom_timeout_ms: int | None = None
     retry_count: int = 0
     retry_delay_ms: int = 100
     graceful_degradation: bool = True
-    memory_limit_mb: Optional[int] = None
-    on_timeout_callback: Optional[Callable] = None
+    memory_limit_mb: int | None = None
+    on_timeout_callback: Callable | None = None
 
 
 @dataclass
@@ -57,13 +66,18 @@ class TimeoutSession:
     start_time: datetime
     timeout_seconds: float
     thread_id: int
-    callback: Optional[Callable] = None
+    callback: Callable | None = None
     completed: bool = False
     cleanup_actions: list = field(default_factory=list)
 
 
-class HookTimeoutError(Exception):
-    """Enhanced timeout error with context"""
+class HookTimeoutError(BaseTimeoutError):
+    """Enhanced timeout error with context.
+
+    Inherits from timeout.TimeoutError for consistent exception handling
+    across the hooks system. Adds hook-specific context like hook_id,
+    execution time, and retry information.
+    """
 
     def __init__(
         self,
@@ -92,7 +106,7 @@ class UnifiedTimeoutManager:
     """
 
     # Global singleton instance
-    _instance: Optional["UnifiedTimeoutManager"] = None
+    _instance: "UnifiedTimeoutManager | None" = None
     _lock = threading.Lock()
 
     def __new__(cls) -> "UnifiedTimeoutManager":
@@ -111,18 +125,18 @@ class UnifiedTimeoutManager:
         self._logger = logging.getLogger(__name__)
 
         # Active timeout tracking
-        self._active_sessions: Dict[str, TimeoutSession] = {}
+        self._active_sessions: dict[str, TimeoutSession] = {}
         self._session_lock = threading.RLock()
 
         # Platform detection
         self._is_windows = platform.system() == "Windows"
 
         # Signal management for Unix
-        self._original_signal_handler: Optional[Callable] = None
+        self._original_signal_handler: Callable | None = None
         self._signal_lock = threading.Lock()
 
         # Resource monitoring
-        self._memory_tracker: Dict[str, Any] = {}
+        self._memory_tracker: dict[str, Any] = {}
         self._cleanup_registry: Set[str] = set()
 
         # Default timeout configurations
@@ -161,9 +175,7 @@ class UnifiedTimeoutManager:
             self._logger.warning(f"Failed to load timeout config: {e}")
         return {}
 
-    def get_timeout_config(
-        self, hook_name: str, custom_config: Optional[HookTimeoutConfig] = None
-    ) -> HookTimeoutConfig:
+    def get_timeout_config(self, hook_name: str, custom_config: HookTimeoutConfig | None = None) -> HookTimeoutConfig:
         """Get timeout configuration for a specific hook"""
         if custom_config:
             return custom_config
@@ -194,7 +206,7 @@ class UnifiedTimeoutManager:
         else:
             return self._default_configs[TimeoutPolicy.NORMAL]
 
-    def create_timeout_session(self, hook_name: str, config: Optional[HookTimeoutConfig] = None) -> TimeoutSession:
+    def create_timeout_session(self, hook_name: str, config: HookTimeoutConfig | None = None) -> TimeoutSession:
         """Create a new timeout session for a hook"""
         if not config:
             config = self.get_timeout_config(hook_name)
@@ -338,14 +350,14 @@ class UnifiedTimeoutManager:
         hook_name: str,
         func: Callable,
         *args,
-        config: Optional[HookTimeoutConfig] = None,
+        config: HookTimeoutConfig | None = None,
         **kwargs,
     ) -> Any:
         """Execute a function with timeout management and retry logic"""
         if not config:
             config = self.get_timeout_config(hook_name)
 
-        last_exception: Optional[Exception] = None
+        last_exception: Exception | None = None
 
         for attempt in range(config.retry_count + 1):
             session = self.create_timeout_session(hook_name, config)
@@ -507,7 +519,7 @@ def get_timeout_manager() -> UnifiedTimeoutManager:
 
 
 @contextlib.contextmanager
-def hook_timeout_context(hook_name: str, config: Optional[HookTimeoutConfig] = None):
+def hook_timeout_context(hook_name: str, config: HookTimeoutConfig | None = None):
     """Context manager for hook execution with timeout management
 
     Usage:

moai_adk/templates/.claude/hooks/moai/lib/update_checker.py

@@ -0,0 +1,129 @@
+# type: ignore
+"""
+Update checker for MoAI-ADK using PyPI API
+
+"""
+
+import json
+import logging
+import re
+import urllib.request
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class UpdateInfo:
+    """Update information"""
+
+    available: bool
+    latest_version: Optional[str]
+
+
+class UpdateChecker:
+    """Checks for MoAI-ADK updates from PyPI with 300-second caching"""
+
+    # Configuration
+    _CACHE_TTL_SECONDS = 300
+    _PYPI_API_URL = "https://pypi.org/pypi/moai-adk/json"
+    _TIMEOUT_SECONDS = 5
+
+    def __init__(self):
+        """Initialize update checker"""
+        self._cached_info: Optional[UpdateInfo] = None
+        self._cache_time: Optional[datetime] = None
+        self._cache_ttl = timedelta(seconds=self._CACHE_TTL_SECONDS)
+        self._cached_version: Optional[str] = None
+
+    def check_for_update(self, current_version: str) -> UpdateInfo:
+        """
+        Check for available updates
+
+        Args:
+            current_version: Current MoAI-ADK version (e.g., "0.20.1")
+
+        Returns:
+            UpdateInfo with availability and latest version
+        """
+        # Check cache validity (same version)
+        if self._is_cache_valid() and self._cached_version == current_version:
+            return self._cached_info
+
+        # Fetch latest version from PyPI
+        update_info = self._fetch_latest_version(current_version)
+        self._update_cache_with(update_info, current_version)
+        return update_info
+
+    def _fetch_latest_version(self, current_version: str) -> UpdateInfo:
+        """
+        Fetch latest version from PyPI API
+
+        Args:
+            current_version: Current version string
+
+        Returns:
+            UpdateInfo from PyPI or error default
+        """
+        try:
+            with urllib.request.urlopen(self._PYPI_API_URL, timeout=self._TIMEOUT_SECONDS) as response:
+                data = json.loads(response.read().decode("utf-8"))
+
+            latest_version = data.get("info", {}).get("version")
+
+            if not latest_version:
+                return UpdateInfo(available=False, latest_version=None)
+
+            # Compare versions
+            available = self._is_update_available(current_version, latest_version)
+
+            return UpdateInfo(
+                available=available,
+                latest_version=latest_version if available else None,
+            )
+
+        except Exception as e:
+            logger.debug(f"Error checking for updates: {e}")
+            return UpdateInfo(available=False, latest_version=None)
+
+    @staticmethod
+    def _is_update_available(current: str, latest: str) -> bool:
+        """
+        Compare versions to determine if update is available
+
+        Args:
+            current: Current version string
+            latest: Latest version string
+
+        Returns:
+            True if update is available
+        """
+        try:
+            # Parse version strings (remove 'v' prefix)
+            current_clean = current.lstrip("v")
+            latest_clean = latest.lstrip("v")
+
+            # Split by dots and convert to integers
+            current_parts = [int(x) for x in re.split(r"[^\d]+", current_clean) if x.isdigit()]
+            latest_parts = [int(x) for x in re.split(r"[^\d]+", latest_clean) if x.isdigit()]
+
+            # Compare version tuples
+            return tuple(latest_parts) > tuple(current_parts)
+
+        except Exception as e:
+            logger.debug(f"Error comparing versions: {e}")
+            return False
+
+    def _is_cache_valid(self) -> bool:
+        """Check if update cache is still valid"""
+        if self._cached_info is None or self._cache_time is None:
+            return False
+        return datetime.now() - self._cache_time < self._cache_ttl
+
+    def _update_cache_with(self, update_info: UpdateInfo, version: str) -> None:
+        """Update cache with update info"""
+        self._cached_info = update_info
+        self._cache_time = datetime.now()
+        self._cached_version = version