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

moai_adk/statusline/main.py

@@ -0,0 +1,228 @@
+# type: ignore
+#!/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:
+        input_data = sys.stdin.read()
+        if input_data:
+            return json.loads(input_data)
+        return {}
+    except (json.JSONDecodeError, EOFError, ValueError):
+        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 Exception:
+        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 Exception:
+        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 Exception:
+        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 Exception:
+        return "unknown"
+
+
+# safe_collect_output_style function removed - no longer needed
+
+
+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 Exception:
+        return False, None
+
+
+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
+    - Git repository
+    - Session metrics
+    - Alfred workflow state
+    - MoAI-ADK version
+    - Update checker
+
+    Args:
+        session_context: Context passed from Claude Code
+        mode: Display mode (compact, extended, minimal)
+
+    Returns:
+        Rendered statusline string
+    """
+    try:
+        # Extract model from session context
+        model_info = session_context.get("model", {})
+        model = model_info.get("display_name", "Unknown")
+        if not model:
+            model = model_info.get("name", "Unknown")
+
+        # Extract directory
+        cwd = session_context.get("cwd", "")
+        if cwd:
+            directory = Path(cwd).name or Path(cwd).parent.name or "project"
+        else:
+            directory = "project"
+
+        # Collect all information
+        branch, git_status = safe_collect_git_info()
+        duration = safe_collect_duration()
+        active_task = safe_collect_alfred_task()
+        version = safe_collect_version()
+        update_available, latest_version = safe_check_update(version)
+
+        # Build StatuslineData with dynamic fields
+        data = StatuslineData(
+            model=model,
+            version=version,
+            memory_usage="256MB",  # TODO: Get actual memory usage
+            branch=branch,
+            git_status=git_status,
+            duration=duration,
+            directory=directory,
+            active_task=active_task,
+            update_available=update_available,
+            latest_version=latest_version,
+        )
+
+        # 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.
+    """
+    # Read session context from Claude Code
+    session_context = read_session_context()
+
+    # 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 statusline:
+        print(statusline, end="")
+
+
+if __name__ == "__main__":
+    main()

moai_adk/statusline/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()

moai_adk/statusline/renderer.py

@@ -0,0 +1,327 @@
+"""
+Statusline renderer for Claude Code status display
+
+"""
+
+# type: ignore
+
+from dataclasses import dataclass
+from typing import List
+
+from .config import StatuslineConfig  # type: ignore[attr-defined]
+
+
+@dataclass
+class StatuslineData:
+    """Status line data structure containing all necessary information"""
+
+    model: str
+    version: str
+    memory_usage: str
+    branch: str
+    git_status: str
+    duration: str
+    directory: str
+    active_task: str
+    update_available: bool = False
+    latest_version: str = ""
+
+
+class StatuslineRenderer:
+    """Renders status information in various modes (compact, extended, minimal)"""
+
+    # Constraints for each mode
+    _MODE_CONSTRAINTS = {
+        "compact": 80,
+        "extended": 120,
+        "minimal": 40,
+    }
+
+    def __init__(self):
+        """Initialize renderer with configuration"""
+        self._config = StatuslineConfig()
+        self._format_config = self._config.get_format_config()
+        self._display_config = self._config.get_display_config()
+
+    def render(self, data: StatuslineData, mode: str = "compact") -> str:
+        """
+        Render statusline with given data in specified mode
+
+        Args:
+            data: StatuslineData instance with all required fields
+            mode: Display mode - "compact" (80 chars), "extended" (120 chars), "minimal" (40 chars)
+
+        Returns:
+            Formatted statusline string
+        """
+        render_method = {
+            "compact": self._render_compact,
+            "extended": self._render_extended,
+            "minimal": self._render_minimal,
+        }.get(mode, self._render_compact)
+
+        return render_method(data)
+
+    def _render_compact(self, data: StatuslineData) -> str:
+        """
+        Render compact mode: [MODEL] [DURATION] | [DIR] | [VERSION] | [BRANCH] | [GIT] | [TASK]
+        Constraint: <= 80 characters
+
+        Args:
+            data: StatuslineData instance
+
+        Returns:
+            Formatted statusline string (max 80 chars)
+        """
+        max_length = self._MODE_CONSTRAINTS["compact"]
+        parts = self._build_compact_parts(data)
+        result = self._format_config.separator.join(parts)
+
+        # Adjust if too long
+        if len(result) > max_length:
+            result = self._fit_to_constraint(data, max_length)
+
+        return result
+
+    def _build_compact_parts(self, data: StatuslineData) -> List[str]:
+        """
+        Build parts list for compact mode with labeled sections
+        Format: 🤖 Model | 🗿 Version | Output Style | 📋 TODO | 🔀 Git: Branch | Changes
+
+        Args:
+            data: StatuslineData instance
+
+        Returns:
+            List of parts to be joined
+        """
+        parts = []
+
+        # Add model if display enabled (most important - cloud service context)
+        if self._display_config.model:
+            parts.append(f"🤖 {data.model}")
+
+        # Add version if display enabled (system status)
+        if self._display_config.version:
+            parts.append(f"🗿 Ver {data.version}")
+
+        # Add git status if display enabled and status not empty
+        if self._display_config.git_status and data.git_status:
+            parts.append(f"📊 {data.git_status}")
+
+        # Add Git info (development context)
+        if self._display_config.branch:
+            parts.append(f"🔀 {data.branch}")
+
+        # Add active_task if display enabled and not empty
+        if self._display_config.active_task and data.active_task.strip():
+            parts.append(data.active_task)
+
+        return parts
+
+    def _fit_to_constraint(self, data: StatuslineData, max_length: int) -> str:
+        """
+        Fit statusline to character constraint by truncating
+        Format: 🤖 Model | 🗿 Version | Output Style | 📋 TODO | 🔀 Git: Branch | Changes
+
+        Args:
+            data: StatuslineData instance
+            max_length: Maximum allowed length
+
+        Returns:
+            Truncated statusline string
+        """
+        # Try with truncated branch first
+        truncated_branch = self._truncate_branch(data.branch, max_length=20)
+        parts = [
+            f"🤖 {data.model}",
+            f"🗿 Ver {data.version}",
+        ]
+
+        # Add git status if display enabled and status not empty
+        if self._display_config.git_status and data.git_status:
+            parts.append(f"📊 {data.git_status}")
+
+        # Add Git info
+        parts.append(f"🔀 {truncated_branch}")
+
+        # Only add active_task if it's not empty
+        if data.active_task.strip():
+            parts.append(data.active_task)
+
+        result = self._format_config.separator.join(parts)
+
+        # If still too long, try more aggressive branch truncation
+        if len(result) > max_length:
+            truncated_branch = self._truncate_branch(data.branch, max_length=12)
+            parts = [
+                f"🤖 {data.model}",
+                f"🗿 Ver {data.version}",
+            ]
+            if data.git_status:
+                parts.append(f"📊 {data.git_status}")
+            parts.append(f"🔀 {truncated_branch}")
+            if data.active_task.strip():
+                parts.append(data.active_task)
+            result = self._format_config.separator.join(parts)
+
+        # If still too long, remove active_task
+        if len(result) > max_length and data.active_task.strip():
+            parts = [
+                f"🤖 {data.model}",
+                f"🗿 Ver {data.version}",
+            ]
+            if data.git_status:
+                parts.append(f"📊 {data.git_status}")
+            parts.append(f"🔀 {truncated_branch}")
+            result = self._format_config.separator.join(parts)
+
+        # Final fallback to minimal if still too long
+        if len(result) > max_length:
+            result = self._render_minimal(data)
+
+        return result
+
+    def _render_extended(self, data: StatuslineData) -> str:
+        """
+        Render extended mode: Full path and detailed info with labels
+        Constraint: <= 120 characters
+        Format: 🤖 Model | 🗿 Version | Output Style | 📋 TODO | 🔀 Git: Branch | Changes
+
+        Args:
+            data: StatuslineData instance
+
+        Returns:
+            Formatted statusline string (max 120 chars)
+        """
+        branch = self._truncate_branch(data.branch, max_length=30)
+
+        parts = []
+
+        # Add model if display enabled
+        if self._display_config.model:
+            parts.append(f"🤖 {data.model}")
+
+        # Add version if display enabled
+        if self._display_config.version:
+            parts.append(f"🗿 Ver {data.version}")
+
+        # Add git status if display enabled and status not empty
+        if self._display_config.git_status and data.git_status:
+            parts.append(f"📊 {data.git_status}")
+
+        # Add Git info (development context)
+        if self._display_config.branch:
+            parts.append(f"🔀 {branch}")
+
+        # Add active_task if display enabled and not empty
+        if self._display_config.active_task and data.active_task.strip():
+            parts.append(data.active_task)
+
+        result = self._format_config.separator.join(parts)
+
+        # If exceeds limit, try truncating branch
+        if len(result) > 120:
+            branch = self._truncate_branch(data.branch, max_length=20)
+            parts = [
+                f"🤖 {data.model}",
+                f"🗿 Ver {data.version}",
+            ]
+
+            # Add optional parts only if they have content
+            if self._display_config.output_style and data.output_style.strip():
+                # Use Yoda-specific emoji for Yoda styles only
+                if "yoda" in data.output_style.lower() or "Yoda Master" in data.output_style:
+                    parts.append(f"🧙 {data.output_style}")
+                else:
+                    parts.append(f"{data.output_style}")
+            if self._display_config.todo_count and data.todo_count.strip():
+                parts.append(f"📋 {data.todo_count}")
+
+            parts.append(f"🔀 {branch}")
+
+            if data.git_status:
+                parts.append(f"Changes: {data.git_status}")
+            if data.active_task.strip():
+                parts.append(data.active_task)
+            result = self._format_config.separator.join(parts)
+
+        return result
+
+    def _render_minimal(self, data: StatuslineData) -> str:
+        """
+        Render minimal mode: Extreme space constraint with minimal labels
+        Constraint: <= 40 characters
+        Format: 🤖 Model | 🗿 Ver Version | Changes: +staged M modified ? untracked
+
+        Args:
+            data: StatuslineData instance
+
+        Returns:
+            Formatted statusline string (max 40 chars)
+        """
+        parts = []
+
+        # Add model if display enabled
+        if self._display_config.model:
+            parts.append(f"🤖 {data.model}")
+
+        # Add version if display enabled
+        if self._display_config.version:
+            parts.append(f"🗿 Ver {self._truncate_version(data.version)}")
+
+        result = self._format_config.separator.join(parts)
+
+        # Add git_status if it fits (use abbreviated format for minimal)
+        # and if display is enabled and status not empty
+        if self._display_config.git_status and data.git_status:
+            status_label = f"Chg: {data.git_status}"
+            if (
+                len(result) + len(status_label) + len(self._format_config.separator)
+                <= 40
+            ):
+                result += f"{self._format_config.separator}{status_label}"
+
+        return result
+
+    @staticmethod
+    def _truncate_branch(branch: str, max_length: int = 20) -> str:
+        """
+        Truncate branch name intelligently, preserving SPEC ID if present
+
+        Args:
+            branch: Branch name to truncate
+            max_length: Maximum allowed length
+
+        Returns:
+            Truncated branch name
+        """
+        if len(branch) <= max_length:
+            return branch
+
+        # Try to preserve SPEC ID in feature branches
+        if "SPEC" in branch:
+            parts = branch.split("-")
+            for i, part in enumerate(parts):
+                if "SPEC" in part and i + 1 < len(parts):
+                    # Found SPEC ID, include it
+                    spec_truncated = "-".join(parts[: i + 2])
+                    if len(spec_truncated) <= max_length:
+                        return spec_truncated
+
+        # Simple truncation with ellipsis for very long names
+        return f"{branch[:max_length-1]}…" if len(branch) > max_length else branch
+
+    @staticmethod
+    def _truncate_version(version: str) -> str:
+        """
+        Truncate version string for minimal display by removing 'v' prefix
+
+        Args:
+            version: Version string (e.g., "v0.20.1" or "0.20.1")
+
+        Returns:
+            Truncated version string
+        """
+        if version.startswith("v"):
+            return version[1:]
+        return version