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

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

@@ -0,0 +1,341 @@
+# type: ignore
+# -*- coding: utf-8 -*-
+#!/usr/bin/env python3
+"""
+Claude Code Statusline Integration
+
+
+Main entry point for MoAI-ADK statusline rendering in Claude Code.
+Collects all necessary information from the project and renders it
+in the specified format for display in the status bar.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .alfred_detector import AlfredDetector
+from .config import StatuslineConfig
+from .git_collector import GitCollector
+from .metrics_tracker import MetricsTracker
+from .renderer import StatuslineData, StatuslineRenderer
+from .update_checker import UpdateChecker
+from .version_reader import VersionReader
+
+
+def read_session_context() -> dict:
+    """
+    Read JSON context from stdin (sent by Claude Code).
+
+    Returns:
+        Dictionary containing session information
+    """
+    try:
+        # Handle Docker/non-interactive environments by checking TTY
+        input_data = sys.stdin.read() if not sys.stdin.isatty() else "{}"
+        if input_data:
+            try:
+                return json.loads(input_data)
+            except json.JSONDecodeError as e:
+                import logging
+
+                logging.error(f"Failed to parse JSON from stdin: {e}")
+                logging.debug(f"Input data: {input_data[:200]}")
+                return {}
+        return {}
+    except (EOFError, ValueError) as e:
+        import logging
+
+        logging.error(f"Error reading stdin: {e}")
+        return {}
+
+
+def safe_collect_git_info() -> tuple[str, str]:
+    """
+    Safely collect git information with fallback.
+
+    Returns:
+        Tuple of (branch_name, git_status_str)
+    """
+    try:
+        collector = GitCollector()
+        git_info = collector.collect_git_info()
+
+        branch = git_info.branch or "unknown"
+        git_status = f"+{git_info.staged} M{git_info.modified} ?{git_info.untracked}"
+
+        return branch, git_status
+    except (OSError, AttributeError, RuntimeError):
+        # Git collector errors (file access, attribute, or runtime errors)
+        return "N/A", ""
+
+
+def safe_collect_duration() -> str:
+    """
+    Safely collect session duration with fallback.
+
+    Returns:
+        Formatted duration string
+    """
+    try:
+        tracker = MetricsTracker()
+        return tracker.get_duration()
+    except (OSError, AttributeError, ValueError):
+        # Metrics tracker errors (file access, attribute, or value errors)
+        return "0m"
+
+
+def safe_collect_alfred_task() -> str:
+    """
+    Safely collect active Alfred task with fallback.
+
+    Returns:
+        Formatted task string
+    """
+    try:
+        detector = AlfredDetector()
+        task = detector.detect_active_task()
+
+        if task.command:
+            stage_suffix = f"-{task.stage}" if task.stage else ""
+            return f"[{task.command.upper()}{stage_suffix}]"
+        return ""
+    except (OSError, AttributeError, RuntimeError):
+        # Alfred detector errors (file access, attribute, or runtime errors)
+        return ""
+
+
+def safe_collect_version() -> str:
+    """
+    Safely collect MoAI-ADK version with fallback.
+
+    Returns:
+        Version string
+    """
+    try:
+        reader = VersionReader()
+        version = reader.get_version()
+        return version or "unknown"
+    except (ImportError, AttributeError, OSError):
+        # Version reader errors (import, attribute, or file access errors)
+        return "unknown"
+
+
+# safe_collect_output_style function removed - no longer needed
+
+
+def safe_collect_memory() -> str:
+    """
+    Safely collect memory usage with fallback.
+
+    Returns:
+        Formatted memory usage string (e.g., "128MB")
+    """
+    try:
+        from .memory_collector import MemoryCollector
+
+        collector = MemoryCollector()
+        return collector.get_display_string(mode="process")
+    except (ImportError, OSError, AttributeError, RuntimeError):
+        # Memory collector errors
+        return "N/A"
+
+
+def safe_check_update(current_version: str) -> tuple[bool, Optional[str]]:
+    """
+    Safely check for updates with fallback.
+
+    Args:
+        current_version: Current version string
+
+    Returns:
+        Tuple of (update_available, latest_version)
+    """
+    try:
+        checker = UpdateChecker()
+        update_info = checker.check_for_update(current_version)
+
+        return update_info.available, update_info.latest_version
+    except (OSError, AttributeError, RuntimeError, ValueError):
+        # Update checker errors (file access, attribute, runtime, or value errors)
+        return False, None
+
+
+def format_token_count(tokens: int) -> str:
+    """
+    Format token count for display (e.g., 15234 -> "15K").
+
+    Args:
+        tokens: Number of tokens
+
+    Returns:
+        Formatted string
+    """
+    if tokens >= 1000:
+        return f"{tokens // 1000}K"
+    return str(tokens)
+
+
+def extract_context_window(session_context: dict) -> str:
+    """
+    Extract and format context window usage from session context.
+
+    Args:
+        session_context: Context passed from Claude Code via stdin
+
+    Returns:
+        Formatted context window string (e.g., "15K/200K")
+    """
+    context_info = session_context.get("context_window", {})
+
+    if not context_info:
+        return ""
+
+    # Get context window size
+    context_size = context_info.get("context_window_size", 0)
+    if not context_size:
+        return ""
+
+    # Get current usage
+    current_usage = context_info.get("current_usage", {})
+    if current_usage:
+        # Calculate total current tokens
+        input_tokens = current_usage.get("input_tokens", 0)
+        cache_creation = current_usage.get("cache_creation_input_tokens", 0)
+        cache_read = current_usage.get("cache_read_input_tokens", 0)
+        current_tokens = input_tokens + cache_creation + cache_read
+    else:
+        # Fallback to total tokens
+        current_tokens = context_info.get("total_input_tokens", 0)
+
+    if current_tokens > 0:
+        return f"{format_token_count(current_tokens)}/{format_token_count(context_size)}"
+
+    return ""
+
+
+def build_statusline_data(session_context: dict, mode: str = "compact") -> str:
+    """
+    Build complete statusline string from all data sources.
+
+    Collects information from:
+    - Claude Code session context (via stdin)
+    - Git repository
+    - Session metrics
+    - Alfred workflow state
+    - MoAI-ADK version
+    - Update checker
+    - Output style
+    - Context window usage
+
+    Args:
+        session_context: Context passed from Claude Code via stdin
+        mode: Display mode (compact, extended, minimal)
+
+    Returns:
+        Rendered statusline string
+    """
+    try:
+        # Extract model from session context with Claude Code version
+        model_info = session_context.get("model", {})
+        model_name = model_info.get("display_name") or model_info.get("name") or "Unknown"
+
+        # Extract Claude Code version separately for new layout
+        claude_version = session_context.get("version", "")
+        model = model_name
+
+        # Extract directory
+        cwd = session_context.get("cwd", "")
+        if cwd:
+            directory = Path(cwd).name or Path(cwd).parent.name or "project"
+        else:
+            directory = "project"
+
+        # Extract output style from session context
+        output_style = session_context.get("output_style", {}).get("name", "")
+
+        # Extract context window usage
+        context_window = extract_context_window(session_context)
+
+        # Collect all information from local sources
+        branch, git_status = safe_collect_git_info()
+        duration = safe_collect_duration()
+        active_task = safe_collect_alfred_task()
+        version = safe_collect_version()
+        memory_usage = safe_collect_memory()
+        update_available, latest_version = safe_check_update(version)
+
+        # Build StatuslineData with dynamic fields
+        data = StatuslineData(
+            model=model,
+            claude_version=claude_version,
+            version=version,
+            memory_usage=memory_usage,
+            branch=branch,
+            git_status=git_status,
+            duration=duration,
+            directory=directory,
+            active_task=active_task,
+            output_style=output_style,
+            update_available=update_available,
+            latest_version=latest_version,
+            context_window=context_window,
+        )
+
+        # Render statusline with labeled sections
+        renderer = StatuslineRenderer()
+        statusline = renderer.render(data, mode=mode)
+
+        return statusline
+
+    except Exception as e:
+        # Graceful degradation on any error
+        import logging
+
+        logging.warning(f"Statusline rendering error: {e}")
+        return ""
+
+
+def main():
+    """
+    Main entry point for Claude Code statusline.
+
+    Reads JSON from stdin, processes all information,
+    and outputs the formatted statusline string.
+    """
+    # Debug mode check
+    debug_mode = os.environ.get("MOAI_STATUSLINE_DEBUG") == "1"
+
+    # Read session context from Claude Code
+    session_context = read_session_context()
+
+    if debug_mode:
+        # Write debug info to stderr for troubleshooting
+        sys.stderr.write(f"[DEBUG] Received session_context: {json.dumps(session_context, indent=2)}\n")
+        sys.stderr.flush()
+
+    # Load configuration
+    config = StatuslineConfig()
+
+    # Determine display mode (priority: session context > environment > config > default)
+    mode = (
+        session_context.get("statusline", {}).get("mode")
+        or os.environ.get("MOAI_STATUSLINE_MODE")
+        or config.get("statusline.mode")
+        or "extended"
+    )
+
+    # Build and output statusline
+    statusline = build_statusline_data(session_context, mode=mode)
+    if debug_mode:
+        sys.stderr.write(f"[DEBUG] Generated statusline: {statusline}\n")
+        sys.stderr.flush()
+
+    if statusline:
+        print(statusline, end="")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,268 @@
+"""
+Memory collector for MoAI-ADK statusline
+
+Collects memory usage information for display in the status bar.
+Uses psutil for cross-platform memory monitoring.
+"""
+
+import logging
+import os
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MemoryInfo:
+    """Memory usage information"""
+
+    # Process memory (current Python process)
+    process_rss_mb: float  # Resident Set Size
+    process_vms_mb: float  # Virtual Memory Size
+
+    # System memory
+    system_total_mb: float
+    system_available_mb: float
+    system_percent: float
+
+    # Formatted strings for display
+    display_process: str  # e.g., "128MB"
+    display_system: str  # e.g., "8.2GB/16GB"
+    display_percent: str  # e.g., "51%"
+
+    timestamp: datetime
+
+
+class MemoryCollector:
+    """
+    Memory collector for statusline display.
+
+    Features:
+    - Process memory monitoring (current Python process)
+    - System memory monitoring
+    - Caching with configurable TTL
+    - Graceful degradation on errors
+    - Multiple display format options
+    """
+
+    # Cache configuration
+    DEFAULT_CACHE_TTL_SECONDS = 10  # Memory doesn't change rapidly
+
+    def __init__(self, cache_ttl_seconds: Optional[int] = None):
+        """
+        Initialize memory collector.
+
+        Args:
+            cache_ttl_seconds: Cache TTL in seconds. If None, uses default.
+        """
+        self._cache_ttl = timedelta(seconds=cache_ttl_seconds or self.DEFAULT_CACHE_TTL_SECONDS)
+        self._cache: Optional[MemoryInfo] = None
+        self._cache_time: Optional[datetime] = None
+        self._logger = logging.getLogger(__name__)
+
+        # Check if psutil is available
+        self._psutil_available = self._check_psutil()
+
+    def _check_psutil(self) -> bool:
+        """Check if psutil is available."""
+        try:
+            import psutil  # noqa: F401
+
+            return True
+        except ImportError:
+            self._logger.warning("psutil not available, memory monitoring disabled")
+            return False
+
+    def get_memory_info(self, force_refresh: bool = False) -> Optional[MemoryInfo]:
+        """
+        Get memory usage information.
+
+        Args:
+            force_refresh: If True, bypass cache and force fresh collection
+
+        Returns:
+            MemoryInfo object or None if collection fails
+        """
+        if not self._psutil_available:
+            return None
+
+        # Check cache
+        if not force_refresh and self._is_cache_valid():
+            return self._cache
+
+        try:
+            memory_info = self._collect_memory_info()
+            self._update_cache(memory_info)
+            return memory_info
+        except Exception as e:
+            self._logger.error(f"Error collecting memory info: {e}")
+            return self._cache  # Return stale cache on error
+
+    def get_display_string(self, mode: str = "process", force_refresh: bool = False) -> str:
+        """
+        Get formatted memory string for statusline display.
+
+        Args:
+            mode: Display mode
+                - "process": Process memory (e.g., "128MB")
+                - "system": System memory usage (e.g., "8.2GB/16GB")
+                - "percent": System memory percentage (e.g., "51%")
+                - "compact": Process memory compact (e.g., "128M")
+            force_refresh: If True, bypass cache
+
+        Returns:
+            Formatted memory string, or "N/A" on error
+        """
+        memory_info = self.get_memory_info(force_refresh)
+
+        if memory_info is None:
+            return "N/A"
+
+        if mode == "process":
+            return memory_info.display_process
+        elif mode == "system":
+            return memory_info.display_system
+        elif mode == "percent":
+            return memory_info.display_percent
+        elif mode == "compact":
+            # Compact format without "MB" suffix
+            return self._format_compact(memory_info.process_rss_mb)
+        else:
+            return memory_info.display_process
+
+    def _collect_memory_info(self) -> MemoryInfo:
+        """
+        Collect memory information using psutil.
+
+        Returns:
+            MemoryInfo object with current memory usage
+        """
+        import psutil
+
+        # Get current process info
+        process = psutil.Process(os.getpid())
+        process_memory = process.memory_info()
+
+        # Convert to MB
+        process_rss_mb = process_memory.rss / (1024 * 1024)
+        process_vms_mb = process_memory.vms / (1024 * 1024)
+
+        # Get system memory info
+        system_memory = psutil.virtual_memory()
+        system_total_mb = system_memory.total / (1024 * 1024)
+        system_available_mb = system_memory.available / (1024 * 1024)
+        system_percent = system_memory.percent
+
+        # Format display strings
+        display_process = self._format_size(process_rss_mb)
+        display_system = (
+            f"{self._format_size(system_total_mb - system_available_mb)}/{self._format_size(system_total_mb)}"
+        )
+        display_percent = f"{system_percent:.0f}%"
+
+        return MemoryInfo(
+            process_rss_mb=process_rss_mb,
+            process_vms_mb=process_vms_mb,
+            system_total_mb=system_total_mb,
+            system_available_mb=system_available_mb,
+            system_percent=system_percent,
+            display_process=display_process,
+            display_system=display_system,
+            display_percent=display_percent,
+            timestamp=datetime.now(),
+        )
+
+    def _format_size(self, size_mb: float) -> str:
+        """
+        Format size in MB to human-readable string.
+
+        Args:
+            size_mb: Size in megabytes
+
+        Returns:
+            Formatted string (e.g., "128MB", "1.2GB")
+        """
+        if size_mb >= 1024:
+            return f"{size_mb / 1024:.1f}GB"
+        elif size_mb >= 100:
+            return f"{size_mb:.0f}MB"
+        elif size_mb >= 10:
+            return f"{size_mb:.1f}MB"
+        else:
+            return f"{size_mb:.2f}MB"
+
+    def _format_compact(self, size_mb: float) -> str:
+        """
+        Format size in compact format for tight spaces.
+
+        Args:
+            size_mb: Size in megabytes
+
+        Returns:
+            Compact formatted string (e.g., "128M", "1.2G")
+        """
+        if size_mb >= 1024:
+            return f"{size_mb / 1024:.1f}G"
+        else:
+            return f"{size_mb:.0f}M"
+
+    def _is_cache_valid(self) -> bool:
+        """Check if cache is still valid."""
+        if self._cache is None or self._cache_time is None:
+            return False
+
+        age = datetime.now() - self._cache_time
+        return age < self._cache_ttl
+
+    def _update_cache(self, memory_info: MemoryInfo) -> None:
+        """Update cache with new memory info."""
+        self._cache = memory_info
+        self._cache_time = datetime.now()
+
+    def clear_cache(self) -> None:
+        """Clear the memory cache."""
+        self._cache = None
+        self._cache_time = None
+
+    def get_cache_age_seconds(self) -> Optional[float]:
+        """
+        Get cache age in seconds.
+
+        Returns:
+            Cache age in seconds, or None if no cache
+        """
+        if self._cache_time is None:
+            return None
+        return (datetime.now() - self._cache_time).total_seconds()
+
+
+# Singleton instance for convenience
+_default_collector: Optional[MemoryCollector] = None
+
+
+def get_memory_collector() -> MemoryCollector:
+    """
+    Get the default memory collector instance.
+
+    Returns:
+        MemoryCollector singleton instance
+    """
+    global _default_collector
+    if _default_collector is None:
+        _default_collector = MemoryCollector()
+    return _default_collector
+
+
+def get_memory_display(mode: str = "process") -> str:
+    """
+    Convenience function to get memory display string.
+
+    Args:
+        mode: Display mode ("process", "system", "percent", "compact")
+
+    Returns:
+        Formatted memory string
+    """
+    return get_memory_collector().get_display_string(mode)

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

@@ -0,0 +1,78 @@
+# type: ignore
+"""
+Session metrics tracker for statusline
+
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class MetricsTracker:
+    """Tracks session duration with 10-second caching"""
+
+    # Configuration
+    _CACHE_TTL_SECONDS = 10
+
+    def __init__(self):
+        """Initialize metrics tracker"""
+        self._session_start: datetime = datetime.now()
+        self._duration_cache: Optional[str] = None
+        self._cache_time: Optional[datetime] = None
+        self._cache_ttl = timedelta(seconds=self._CACHE_TTL_SECONDS)
+
+    def get_duration(self) -> str:
+        """
+        Get formatted session duration
+
+        Returns:
+            Formatted duration string (e.g., "5m", "1h 30m")
+        """
+        # Check cache validity
+        if self._is_cache_valid():
+            return self._duration_cache
+
+        # Calculate and format duration
+        duration = self._calculate_and_format_duration()
+        self._update_cache(duration)
+        return duration
+
+    def _calculate_and_format_duration(self) -> str:
+        """
+        Calculate session duration and format it
+
+        Returns:
+            Formatted duration string
+        """
+        elapsed = datetime.now() - self._session_start
+        total_seconds = int(elapsed.total_seconds())
+
+        # Format based on duration range
+        if total_seconds < 60:
+            return f"{total_seconds}s"
+        elif total_seconds < 3600:
+            minutes = total_seconds // 60
+            seconds = total_seconds % 60
+            if seconds > 0:
+                return f"{minutes}m {seconds}s"
+            return f"{minutes}m"
+        else:
+            hours = total_seconds // 3600
+            minutes = (total_seconds % 3600) // 60
+            if minutes > 0:
+                return f"{hours}h {minutes}m"
+            return f"{hours}h"
+
+    def _is_cache_valid(self) -> bool:
+        """Check if duration cache is still valid"""
+        if self._duration_cache is None or self._cache_time is None:
+            return False
+        return datetime.now() - self._cache_time < self._cache_ttl
+
+    def _update_cache(self, duration: str) -> None:
+        """Update duration cache"""
+        self._duration_cache = duration
+        self._cache_time = datetime.now()