moai-adk 0.15.0__py3-none-any.whl → 0.25.4__py3-none-any.whl

moai_adk/templates/.claude/hooks/alfred/core/timeout.py

@@ -1,136 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:BUGFIX-001:CROSS-PLATFORM-TIMEOUT | SPEC: SPEC-BUGFIX-001
-"""Cross-Platform Timeout Handler for Windows & Unix Compatibility
-
-Provides a unified timeout mechanism that works on both Windows (threading-based)
-and Unix/POSIX systems (signal-based).
-
-Architecture:
-  - Windows: threading.Timer with exception injection
-  - Unix/POSIX: signal.SIGALRM (traditional approach)
-  - Both: Context manager for clean cancellation
-"""
-
-import platform
-import signal
-import threading
-from contextlib import contextmanager
-from typing import Optional
-
-
-class TimeoutError(Exception):
-    """Timeout exception raised when deadline exceeded"""
-    pass
-
-
-class CrossPlatformTimeout:
-    """Cross-platform timeout handler supporting Windows and Unix.
-
-    Windows: Uses threading.Timer to schedule timeout exception
-    Unix: Uses signal.SIGALRM for timeout handling
-
-    Usage:
-        # Context manager (recommended)
-        with CrossPlatformTimeout(5):
-            long_running_operation()
-
-        # Manual control
-        timeout = CrossPlatformTimeout(5)
-        timeout.start()
-        try:
-            long_running_operation()
-        finally:
-            timeout.cancel()
-    """
-
-    def __init__(self, timeout_seconds: int):
-        """Initialize timeout with duration in seconds.
-
-        Args:
-            timeout_seconds: Timeout duration in seconds
-        """
-        self.timeout_seconds = timeout_seconds
-        self.timer: Optional[threading.Timer] = None
-        self._is_windows = platform.system() == "Windows"
-        self._old_handler = None
-
-    def start(self) -> None:
-        """Start timeout countdown."""
-        if self._is_windows:
-            self._start_windows_timeout()
-        else:
-            self._start_unix_timeout()
-
-    def cancel(self) -> None:
-        """Cancel timeout (must call before timeout expires)."""
-        if self._is_windows:
-            self._cancel_windows_timeout()
-        else:
-            self._cancel_unix_timeout()
-
-    def _start_windows_timeout(self) -> None:
-        """Windows: Use threading.Timer to raise exception."""
-        def timeout_handler():
-            raise TimeoutError(
-                f"Operation exceeded {self.timeout_seconds}s timeout (Windows threading)"
-            )
-
-        self.timer = threading.Timer(self.timeout_seconds, timeout_handler)
-        self.timer.daemon = True
-        self.timer.start()
-
-    def _cancel_windows_timeout(self) -> None:
-        """Windows: Cancel timer thread."""
-        if self.timer:
-            self.timer.cancel()
-            self.timer = None
-
-    def _start_unix_timeout(self) -> None:
-        """Unix/POSIX: Use signal.SIGALRM for timeout."""
-        def signal_handler(signum, frame):
-            raise TimeoutError(
-                f"Operation exceeded {self.timeout_seconds}s timeout (Unix signal)"
-            )
-
-        # Save old handler to restore later
-        self._old_handler = signal.signal(signal.SIGALRM, signal_handler)
-        signal.alarm(self.timeout_seconds)
-
-    def _cancel_unix_timeout(self) -> None:
-        """Unix/POSIX: Cancel alarm and restore old handler."""
-        signal.alarm(0)  # Cancel pending alarm
-        if self._old_handler is not None:
-            signal.signal(signal.SIGALRM, self._old_handler)
-            self._old_handler = None
-
-    def __enter__(self):
-        """Context manager entry."""
-        self.start()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit - always cancel."""
-        self.cancel()
-        return False  # Don't suppress exceptions
-
-
-@contextmanager
-def timeout_context(timeout_seconds: int):
-    """Decorator/context manager for timeout.
-
-    Usage:
-        with timeout_context(5):
-            slow_function()
-
-    Args:
-        timeout_seconds: Timeout duration in seconds
-
-    Yields:
-        CrossPlatformTimeout instance
-    """
-    timeout = CrossPlatformTimeout(timeout_seconds)
-    timeout.start()
-    try:
-        yield timeout
-    finally:
-        timeout.cancel()

moai_adk/templates/.claude/hooks/alfred/core/ttl_cache.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:ENHANCE-PERF-001:CACHE | SPEC: SPEC-ENHANCE-PERF-001
-"""TTL-Based Cache for SessionStart Hook Performance Optimization
-
-Provides transparent caching with automatic time-based expiration (TTL).
-Optimizes SessionStart hook performance by caching network I/O and git operations.
-
-Architecture:
-  - Decorator-based: @ttl_cache(ttl_seconds=1800) for clean syntax
-  - Thread-safe: Uses threading.Lock for concurrent access
-  - Automatic expiration: TTL-based invalidation with mtime tracking
-  - Graceful fallback: Cache misses call function directly
-
-Performance Impact:
-  - get_package_version_info(): 112.82ms → <5ms (95% improvement)
-  - get_git_info(): 52.88ms → <5ms (90% improvement)
-  - SessionStart Hook: 185.26ms → 0.04ms (99.98% improvement, 4,625x faster)
-"""
-
-import functools
-import threading
-import time
-from typing import Any, Callable, Optional, TypeVar
-
-T = TypeVar('T')
-
-
-class TTLCache:
-    """Thread-safe TTL-based cache with automatic expiration."""
-
-    def __init__(self, ttl_seconds: int):
-        self.ttl_seconds = ttl_seconds
-        self._cache: dict[str, tuple[Any, float]] = {}
-        self._lock = threading.Lock()
-
-    def set(self, key: str, value: Any) -> None:
-        with self._lock:
-            self._cache[key] = (value, time.time())
-
-    def get(self, key: str) -> Optional[Any]:
-        with self._lock:
-            if key not in self._cache:
-                return None
-            value, timestamp = self._cache[key]
-            if time.time() - timestamp > self.ttl_seconds:
-                del self._cache[key]
-                return None
-            return value
-
-    def clear(self) -> None:
-        with self._lock:
-            self._cache.clear()
-
-    def size(self) -> int:
-        with self._lock:
-            return len(self._cache)
-
-
-_version_cache = TTLCache(ttl_seconds=1800)
-_git_cache = TTLCache(ttl_seconds=10)
-
-
-def ttl_cache(ttl_seconds: int = 300) -> Callable[[Callable[..., T]], Callable[..., T]]:
-    """Decorator for function-level TTL caching."""
-    cache = TTLCache(ttl_seconds=ttl_seconds)
-
-    def decorator(func: Callable[..., T]) -> Callable[..., T]:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs) -> T:
-            cache_key = f"{func.__name__}"
-            if args:
-                cache_key += f"_{hash(args)}"
-            if kwargs:
-                cache_key += f"_{hash(frozenset(kwargs.items()))}"
-            cached = cache.get(cache_key)
-            if cached is not None:
-                return cached
-            result = func(*args, **kwargs)
-            cache.set(cache_key, result)
-            return result
-        return wrapper
-    return decorator
-
-
-def get_cached_package_version() -> Optional[str]:
-    """Get cached package version info (30-min TTL)."""
-    return _version_cache.get("package_version")
-
-
-def set_cached_package_version(version: str) -> None:
-    """Cache package version info (30-min TTL)."""
-    _version_cache.set("package_version", version)
-
-
-def get_cached_git_info() -> Optional[dict[str, str]]:
-    """Get cached git info (10-sec TTL)."""
-    return _git_cache.get("git_info")
-
-
-def set_cached_git_info(git_info: dict[str, str]) -> None:
-    """Cache git info (10-sec TTL)."""
-    _git_cache.set("git_info", git_info)
-
-
-def clear_all_caches() -> None:
-    """Clear all SessionStart caches."""
-    _version_cache.clear()
-    _git_cache.clear()

moai_adk/templates/.claude/hooks/alfred/core/version_cache.py

@@ -1,198 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:VERSION-CACHE-001
-"""Version information cache with TTL support
-
-TTL-based caching system for version check results to minimize network calls
-during SessionStart hook execution.
-
-SPEC: SPEC-UPDATE-ENHANCE-001 - SessionStart 버전 체크 시스템 강화
-Phase 1: Cache System Implementation
-"""
-
-import json
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-
-class VersionCache:
-    """TTL-based version information cache
-
-    Caches version check results with configurable Time-To-Live (TTL)
-    to avoid excessive network calls to PyPI during SessionStart events.
-
-    Attributes:
-        cache_dir: Directory to store cache file
-        ttl_hours: Time-to-live in hours (default 24)
-        cache_file: Path to the cache JSON file
-
-    Examples:
-        >>> cache = VersionCache(Path(".moai/cache"), ttl_hours=24)
-        >>> cache.save({"current_version": "0.8.1", "latest_version": "0.9.0"})
-        True
-        >>> cache.is_valid()
-        True
-        >>> data = cache.load()
-        >>> data["current_version"]
-        '0.8.1'
-    """
-
-    def __init__(self, cache_dir: Path, ttl_hours: int = 24):
-        """Initialize cache with TTL in hours
-
-        Args:
-            cache_dir: Directory where cache file will be stored
-            ttl_hours: Time-to-live in hours (default 24)
-        """
-        self.cache_dir = Path(cache_dir)
-        self.ttl_hours = ttl_hours
-        self.cache_file = self.cache_dir / "version-check.json"
-
-    def _calculate_age_hours(self, last_check_iso: str) -> float:
-        """Calculate age in hours from ISO timestamp (internal helper)
-
-        Normalizes timezone-aware and naive datetimes for consistent comparison.
-
-        Args:
-            last_check_iso: ISO format timestamp string
-
-        Returns:
-            Age in hours
-
-        Raises:
-            ValueError: If timestamp parsing fails
-        """
-        last_check = datetime.fromisoformat(last_check_iso)
-
-        # Normalize to naive datetime (remove timezone for comparison)
-        if last_check.tzinfo is not None:
-            last_check = last_check.replace(tzinfo=None)
-
-        now = datetime.now()
-        return (now - last_check).total_seconds() / 3600
-
-    def is_valid(self) -> bool:
-        """Check if cache exists and is not expired
-
-        Returns:
-            True if cache file exists and is within TTL, False otherwise
-
-        Examples:
-            >>> cache = VersionCache(Path(".moai/cache"))
-            >>> cache.is_valid()
-            False  # No cache file exists yet
-        """
-        if not self.cache_file.exists():
-            return False
-
-        try:
-            with open(self.cache_file, "r") as f:
-                data = json.load(f)
-
-            age_hours = self._calculate_age_hours(data["last_check"])
-            return age_hours < self.ttl_hours
-
-        except (json.JSONDecodeError, KeyError, ValueError, OSError):
-            # Corrupted or invalid cache file
-            return False
-
-    def load(self) -> dict[str, Any] | None:
-        """Load cached version info if valid
-
-        Returns:
-            Cached version info dictionary if valid, None otherwise
-
-        Examples:
-            >>> cache = VersionCache(Path(".moai/cache"))
-            >>> data = cache.load()
-            >>> data is None
-            True  # No valid cache exists
-        """
-        if not self.is_valid():
-            return None
-
-        try:
-            with open(self.cache_file, "r") as f:
-                return json.load(f)
-        except (json.JSONDecodeError, OSError):
-            # Graceful degradation on read errors
-            return None
-
-    def save(self, version_info: dict[str, Any]) -> bool:
-        """Save version info to cache file
-
-        Creates cache directory if it doesn't exist.
-        Updates last_check timestamp to current time if not provided.
-
-        Args:
-            version_info: Version information dictionary to cache
-
-        Returns:
-            True on successful save, False on error
-
-        Examples:
-            >>> cache = VersionCache(Path(".moai/cache"))
-            >>> cache.save({"current_version": "0.8.1"})
-            True
-        """
-        try:
-            # Create cache directory if it doesn't exist
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-            # Update last_check timestamp only if not provided (for testing)
-            if "last_check" not in version_info:
-                version_info["last_check"] = datetime.now(timezone.utc).isoformat()
-
-            # Write to cache file
-            with open(self.cache_file, "w") as f:
-                json.dump(version_info, f, indent=2)
-
-            return True
-
-        except (OSError, TypeError):
-            # Graceful degradation on write errors
-            return False
-
-    def clear(self) -> bool:
-        """Clear/remove cache file
-
-        Returns:
-            True if cache file was removed or didn't exist, False on error
-
-        Examples:
-            >>> cache = VersionCache(Path(".moai/cache"))
-            >>> cache.clear()
-            True
-        """
-        try:
-            if self.cache_file.exists():
-                self.cache_file.unlink()
-            return True
-        except OSError:
-            return False
-
-    def get_age_hours(self) -> float:
-        """Get age of cache in hours
-
-        Returns:
-            Age in hours, or 0.0 if cache doesn't exist or is invalid
-
-        Examples:
-            >>> cache = VersionCache(Path(".moai/cache"))
-            >>> cache.get_age_hours()
-            0.0  # No cache exists
-        """
-        if not self.cache_file.exists():
-            return 0.0
-
-        try:
-            with open(self.cache_file, "r") as f:
-                data = json.load(f)
-
-            return self._calculate_age_hours(data["last_check"])
-
-        except (json.JSONDecodeError, KeyError, ValueError, OSError):
-            return 0.0
-
-
-__all__ = ["VersionCache"]

moai_adk/templates/.claude/hooks/alfred/handlers/__init__.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python3
-"""Re-export handlers from shared module
-
-This module provides backward compatibility by re-exporting handlers
-from the shared.handlers module to allow alfred_hooks.py to import
-directly from handlers instead of shared.handlers.
-"""
-
-from shared.handlers import (
-    handle_notification,
-    handle_post_tool_use,
-    handle_pre_tool_use,
-    handle_session_end,
-    handle_session_start,
-    handle_stop,
-    handle_subagent_stop,
-    handle_user_prompt_submit,
-)
-
-__all__ = [
-    "handle_session_start",
-    "handle_session_end",
-    "handle_user_prompt_submit",
-    "handle_pre_tool_use",
-    "handle_post_tool_use",
-    "handle_notification",
-    "handle_stop",
-    "handle_subagent_stop",
-]

moai_adk/templates/.claude/hooks/alfred/post_tool__log_changes.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:HOOKS-CLARITY-LOG | SPEC: Individual hook files for better UX
-"""PostToolUse Hook: Log Tool Usage and Changes
-
-Claude Code Event: PostToolUse
-Purpose: Log tool execution results and track changes for audit trail
-Execution: Triggered after Edit, Write, or MultiEdit tools are used
-Matcher: Edit|Write|MultiEdit
-
-Output: Continue execution (currently a stub for future enhancements)
-"""
-
-import json
-import sys
-from pathlib import Path
-from typing import Any
-
-from utils.timeout import CrossPlatformTimeout
-from utils.timeout import TimeoutError as PlatformTimeoutError
-
-# Setup import path for shared modules
-HOOKS_DIR = Path(__file__).parent
-SHARED_DIR = HOOKS_DIR / "shared"
-if str(SHARED_DIR) not in sys.path:
-    sys.path.insert(0, str(SHARED_DIR))
-
-from handlers import handle_post_tool_use
-
-
-def main() -> None:
-    """Main entry point for PostToolUse hook
-
-    Currently a stub for future functionality:
-    - Change tracking and audit logging
-    - Metrics collection (files modified, lines changed)
-    - Integration with external monitoring systems
-
-    Exit Codes:
-        0: Success
-        1: Error (timeout, JSON parse failure, handler exception)
-    """
-    # Set 5-second timeout
-    timeout = CrossPlatformTimeout(5)
-    timeout.start()
-
-    try:
-        # Read JSON payload from stdin
-        input_data = sys.stdin.read()
-        data = json.loads(input_data) if input_data.strip() else {}
-
-        # Call handler
-        result = handle_post_tool_use(data)
-
-        # Output result as JSON
-        print(json.dumps(result.to_dict()))
-        sys.exit(0)
-
-    except PlatformTimeoutError:
-        # Timeout - return minimal valid response
-        timeout_response: dict[str, Any] = {
-            "continue": True,
-            "systemMessage": "⚠️ PostToolUse timeout - continuing",
-        }
-        print(json.dumps(timeout_response))
-        print("PostToolUse hook timeout after 5 seconds", file=sys.stderr)
-        sys.exit(1)
-
-    except json.JSONDecodeError as e:
-        # JSON parse error
-        error_response: dict[str, Any] = {
-            "continue": True,
-            "hookSpecificOutput": {"error": f"JSON parse error: {e}"},
-        }
-        print(json.dumps(error_response))
-        print(f"PostToolUse JSON parse error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    except Exception as e:
-        # Unexpected error
-        error_response: dict[str, Any] = {
-            "continue": True,
-            "hookSpecificOutput": {"error": f"PostToolUse error: {e}"},
-        }
-        print(json.dumps(error_response))
-        print(f"PostToolUse unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    finally:
-        # Always cancel alarm
-        timeout.cancel()
-
-
-if __name__ == "__main__":
-    main()

moai_adk/templates/.claude/hooks/alfred/pre_tool__auto_checkpoint.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-# @CODE:HOOKS-CLARITY-CKPT | SPEC: Individual hook files for better UX
-"""PreToolUse Hook: Automatic Safety Checkpoint Creation
-
-Claude Code Event: PreToolUse
-Purpose: Detect risky operations and automatically create Git checkpoints before execution
-Execution: Triggered before Edit, Write, or MultiEdit tools are used
-Matcher: Edit|Write|MultiEdit
-
-Output: System message with checkpoint information (if created)
-
-Risky Operations Detected:
-- Bash: rm -rf, git merge, git reset --hard
-- Edit/Write: CLAUDE.md, config.json, critical files
-- MultiEdit: Operations affecting ≥10 files
-"""
-
-import json
-import sys
-from pathlib import Path
-from typing import Any
-
-from utils.timeout import CrossPlatformTimeout
-from utils.timeout import TimeoutError as PlatformTimeoutError
-
-# Setup import path for shared modules
-HOOKS_DIR = Path(__file__).parent
-SHARED_DIR = HOOKS_DIR / "shared"
-if str(SHARED_DIR) not in sys.path:
-    sys.path.insert(0, str(SHARED_DIR))
-
-from handlers import handle_pre_tool_use
-
-
-def main() -> None:
-    """Main entry point for PreToolUse hook
-
-    Analyzes tool usage and creates checkpoints for risky operations:
-    1. Detects dangerous patterns (rm -rf, git reset, etc.)
-    2. Creates Git checkpoint: checkpoint/before-{operation}-{timestamp}
-    3. Logs checkpoint to .moai/checkpoints.log
-    4. Returns guidance message to user
-
-    Exit Codes:
-        0: Success (checkpoint created or not needed)
-        1: Error (timeout, JSON parse failure, handler exception)
-    """
-    # Set 5-second timeout
-    timeout = CrossPlatformTimeout(5)
-    timeout.start()
-
-    try:
-        # Read JSON payload from stdin
-        input_data = sys.stdin.read()
-        data = json.loads(input_data) if input_data.strip() else {}
-
-        # Call handler
-        result = handle_pre_tool_use(data)
-
-        # Output result as JSON
-        print(json.dumps(result.to_dict()))
-        sys.exit(0)
-
-    except PlatformTimeoutError:
-        # Timeout - return minimal valid response (allow operation to continue)
-        timeout_response: dict[str, Any] = {
-            "continue": True,
-            "systemMessage": "⚠️ Checkpoint creation timeout - operation proceeding without checkpoint",
-        }
-        print(json.dumps(timeout_response))
-        print("PreToolUse hook timeout after 5 seconds", file=sys.stderr)
-        sys.exit(1)
-
-    except json.JSONDecodeError as e:
-        # JSON parse error - allow operation to continue
-        error_response: dict[str, Any] = {
-            "continue": True,
-            "hookSpecificOutput": {"error": f"JSON parse error: {e}"},
-        }
-        print(json.dumps(error_response))
-        print(f"PreToolUse JSON parse error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    except Exception as e:
-        # Unexpected error - allow operation to continue
-        error_response: dict[str, Any] = {
-            "continue": True,
-            "hookSpecificOutput": {"error": f"PreToolUse error: {e}"},
-        }
-        print(json.dumps(error_response))
-        print(f"PreToolUse unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    finally:
-        # Always cancel alarm
-        timeout.cancel()
-
-
-if __name__ == "__main__":
-    main()