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

moai_adk/statusline/enhanced_output_style_detector.py

@@ -0,0 +1,372 @@
+# type: ignore
+#!/usr/bin/env python3
+"""
+Enhanced Output Style Detector for Claude Code Statusline
+
+This module provides real-time detection of Claude Code's current output style
+by analyzing session context, environment variables, and behavioral indicators.
+
+Key improvements:
+1. Real-time session context analysis
+2. Multiple detection methods with priority ordering
+3. Behavioral pattern recognition
+4. Robust error handling and graceful degradation
+"""
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class OutputStyleDetector:
+    """
+    Enhanced output style detector with multiple detection strategies.
+
+    Detection Priority:
+    1. Session context (most reliable)
+    2. Environment variables
+    3. Behavioral analysis
+    4. Settings file (fallback)
+    5. Heuristics (last resort)
+    """
+
+    # Style mapping for consistent display format
+    STYLE_MAPPING = {
+        # Internal style names
+        "streaming": "R2-D2",
+        "explanatory": "Explanatory",
+        "concise": "Concise",
+        "detailed": "Detailed",
+        "yoda": "🧙 Yoda Master",
+        "yoda-master": "🧙 Yoda Master",
+        "tutorial": "🧙 Yoda Master",
+        # Display values with emojis
+        "🤖 R2-D2": "R2-D2",
+        "R2-D2": "R2-D2",
+        "🧙 Explanatory": "Explanatory",
+        "Explanatory": "Explanatory",
+        "🧙 Concise": "Concise",
+        "Concise": "Concise",
+        "🧙 Detailed": "Detailed",
+        "Detailed": "Detailed",
+        "🧙 Yoda Master": "🧙 Yoda Master",
+        "Yoda Master": "🧙 Yoda Master",
+    }
+
+    def __init__(self):
+        self.cache = {}
+        self.cache_ttl: float = 5.0  # Cache for 5 seconds to balance performance and accuracy
+
+    def detect_from_session_context(self, session_data: Dict[str, Any]) -> Optional[str]:
+        """
+        Detect output style from Claude Code session context.
+
+        This is the most reliable method as it uses real-time session data.
+        """
+        try:
+            # Method 1: Check explicit outputStyle in session
+            if "outputStyle" in session_data:
+                style = session_data["outputStyle"]
+                if style:
+                    return self._normalize_style(style)
+
+            # Method 2: Check model configuration for style indicators
+            model_info = session_data.get("model", {})
+            if isinstance(model_info, dict):
+                model_name = model_info.get("name", "").lower()
+                display_name = model_info.get("display_name", "").lower()
+
+                # Check for style indicators in model names
+                for text in [model_name, display_name]:
+                    if "explanatory" in text:
+                        return "Explanatory"
+                    elif "yoda" in text or "tutorial" in text:
+                        return "🧙 Yoda Master"
+                    elif "concise" in text:
+                        return "Concise"
+                    elif "detailed" in text:
+                        return "Detailed"
+                    elif "streaming" in text or "r2d2" in text:
+                        return "R2-D2"
+
+            # Method 3: Check conversation patterns
+            messages = session_data.get("messages", [])
+            if messages:
+                # Analyze recent message patterns for style indicators
+                recent_messages = messages[-3:]  # Last 3 messages
+                return self._analyze_message_patterns(recent_messages)
+
+        except Exception as e:
+            # Log error but don't fail - continue to next detection method
+            print(f"Session context detection error: {e}", file=sys.stderr)
+
+        return None
+
+    def detect_from_environment(self) -> Optional[str]:
+        """
+        Detect output style from environment variables.
+        """
+        try:
+            # Check for explicit environment variable
+            if "CLAUDE_OUTPUT_STYLE" in os.environ:
+                env_style = os.environ["CLAUDE_OUTPUT_STYLE"]
+                if env_style:
+                    return self._normalize_style(env_style)
+
+            # Check for Claude Code session indicators
+            if "CLAUDE_SESSION_ID" in os.environ:
+                # Could integrate with Claude Code session management
+                pass
+
+            # Check for process name or command line indicators
+            try:
+                # This could be enhanced with process inspection if needed
+                pass
+            except Exception:
+                pass
+
+        except Exception as e:
+            print(f"Environment detection error: {e}", file=sys.stderr)
+
+        return None
+
+    def detect_from_behavioral_analysis(self) -> Optional[str]:
+        """
+        Analyze behavioral patterns to infer current output style.
+
+        This method uses heuristics based on file system state and recent activity.
+        """
+        try:
+            cwd = Path.cwd()
+
+            # Check for active Yoda session indicators
+            moai_dir = cwd / ".moai"
+            if moai_dir.exists():
+                # Look for recent Yoda-related activity
+                yoda_files = list(moai_dir.rglob("*yoda*"))
+                if yoda_files:
+                    # Check if any Yoda files are recently modified
+                    recent_yoda = any(f.stat().st_mtime > (time.time() - 300) for f in yoda_files)  # Last 5 minutes
+                    if recent_yoda:
+                        return "🧙 Yoda Master"
+
+            # Check for extensive documentation (might indicate Explanatory mode)
+            docs_dir = cwd / "docs"
+            if docs_dir.exists():
+                md_files = list(docs_dir.rglob("*.md"))
+                if len(md_files) > 10:  # Heuristic threshold
+                    return "Explanatory"
+
+            # Check for TODO/task tracking patterns
+            todo_file = cwd / ".moai" / "current_session_todo.txt"
+            if todo_file.exists():
+                content = todo_file.read_text()
+                if "plan" in content.lower() or "phase" in content.lower():
+                    return "Explanatory"
+
+        except Exception as e:
+            print(f"Behavioral analysis error: {e}", file=sys.stderr)
+
+        return None
+
+    def detect_from_settings(self) -> Optional[str]:
+        """
+        Detect output style from settings.json file.
+
+        This is the least reliable method as it may not reflect current session.
+        """
+        try:
+            settings_path = Path.cwd() / ".claude" / "settings.json"
+            if settings_path.exists():
+                with open(settings_path, "r", encoding="utf-8") as f:
+                    settings = json.load(f)
+                    output_style = settings.get("outputStyle", "")
+
+                    if output_style:
+                        return self._normalize_style(output_style)
+
+        except Exception as e:
+            print(f"Settings file detection error: {e}", file=sys.stderr)
+
+        return None
+
+    def _normalize_style(self, style: str) -> str:
+        """
+        Normalize style name to consistent display format.
+        """
+        if not style:
+            return "Unknown"
+
+        # Direct mapping lookup
+        if style in self.STYLE_MAPPING:
+            return self.STYLE_MAPPING[style]
+
+        # Case-insensitive lookup
+        style_lower = style.lower()
+        for key, value in self.STYLE_MAPPING.items():
+            if key.lower() == style_lower:
+                return value
+
+        # Pattern-based normalization
+        if "r2d2" in style_lower or "streaming" in style_lower:
+            return "R2-D2"
+        elif "yoda" in style_lower or "master" in style_lower:
+            return "🧙 Yoda Master"
+        elif "explanatory" in style_lower:
+            return "Explanatory"
+        elif "concise" in style_lower:
+            return "Concise"
+        elif "detailed" in style_lower:
+            return "Detailed"
+
+        # Extract from emoji-prefixed values
+        if "🤖" in style:
+            return "R2-D2"
+        elif "🧙" in style:
+            # Extract the part after emoji
+            parts = style.split("🧙", 1)
+            if len(parts) > 1:
+                extracted = parts[1].strip()
+                return self._normalize_style(extracted)
+
+        # Fallback: capitalize first letter
+        return style.title() if style else "Unknown"
+
+    def _analyze_message_patterns(self, messages: list) -> Optional[str]:
+        """
+        Analyze recent message patterns for style indicators.
+        """
+        try:
+            if not messages:
+                return None
+
+            # Look for style indicators in recent responses
+            full_text = " ".join(msg.get("content", "") for msg in messages[-3:] if msg.get("role") == "assistant")
+
+            if not full_text:
+                return None
+
+            # Style heuristics based on response patterns
+            text_lower = full_text.lower()
+
+            # Yoda Master indicators
+            yoda_indicators = [
+                "young padawan",
+                "the force",
+                "master",
+                "wisdom",
+                "patience",
+            ]
+            yoda_count = sum(1 for indicator in yoda_indicators if indicator in text_lower)
+
+            if yoda_count >= 2:
+                return "🧙 Yoda Master"
+
+            # Explanatory indicators
+            if len(full_text) > 2000:  # Long responses
+                explanatory_count = sum(
+                    1
+                    for phrase in [
+                        "let me explain",
+                        "here's how",
+                        "the reason is",
+                        "to understand",
+                    ]
+                    if phrase in text_lower
+                )
+                if explanatory_count >= 2:
+                    return "Explanatory"
+
+            # Concise indicators
+            if len(full_text) < 500:
+                return "Concise"
+
+            # Default fallback
+            return "R2-D2"
+
+        except Exception as e:
+            print(f"Message pattern analysis error: {e}", file=sys.stderr)
+            return None
+
+    def get_output_style(self, session_context: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Get the current output style using all available detection methods.
+
+        Args:
+            session_context: Optional session context from Claude Code
+
+        Returns:
+            Normalized output style string
+        """
+        # Use cache if available and fresh
+        cache_key = f"{id(session_context)}_{hash(str(session_context))}"
+        current_time = time.time()
+
+        if cache_key in self.cache:
+            cached_style, cached_time = self.cache[cache_key]
+            if current_time - cached_time < self.cache_ttl:
+                return cached_style
+
+        # Detection methods in priority order
+        detection_methods = [
+            (
+                "Session Context",
+                lambda: self.detect_from_session_context(session_context or {}),
+            ),
+            ("Environment", self.detect_from_environment),
+            ("Behavioral Analysis", self.detect_from_behavioral_analysis),
+            ("Settings File", self.detect_from_settings),
+        ]
+
+        for method_name, method_func in detection_methods:
+            try:
+                style = method_func()
+                if style and style != "Unknown":
+                    # Cache the result
+                    self.cache[cache_key] = (style, current_time)
+                    return style
+            except Exception as e:
+                print(f"{method_name} detection failed: {e}", file=sys.stderr)
+                continue
+
+        # Default fallback - Mr. Alfred is the default output style
+        return "Mr. Alfred"
+
+
+def safe_collect_output_style() -> str:
+    """
+    Legacy compatibility function that maintains the original interface.
+
+    This function provides backward compatibility with the existing statusline
+    system while using the enhanced detection capabilities.
+
+    Returns:
+        Detected output style string
+    """
+    try:
+        # Read session context from stdin if available
+        session_context = {}
+        try:
+            # Handle Docker/non-interactive environments by checking TTY
+            input_data = sys.stdin.read() if not sys.stdin.isatty() else "{}"
+            if input_data.strip():
+                session_context = json.loads(input_data)
+        except (json.JSONDecodeError, EOFError):
+            pass
+
+        # Use the enhanced detector
+        detector = OutputStyleDetector()
+        return detector.get_output_style(session_context)
+
+    except Exception as e:
+        print(f"Output style detection failed: {e}", file=sys.stderr)
+        return "Mr. Alfred"
+
+
+# For backward compatibility
+if __name__ == "__main__":
+    # If run as a script, output the detected style
+    print(safe_collect_output_style())

moai_adk/statusline/git_collector.py

@@ -0,0 +1,190 @@
+# type: ignore
+"""
+Git information collector for statusline
+
+"""
+
+import logging
+import re
+import subprocess
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class GitInfo:
+    """Git repository information"""
+
+    branch: str
+    staged: int
+    modified: int
+    untracked: int
+
+
+class GitCollector:
+    """Collects git information from repository with 5-second caching"""
+
+    # Configuration constants
+    _CACHE_TTL_SECONDS = 5
+    _GIT_COMMAND_TIMEOUT = 2
+
+    # File status prefixes from git status --porcelain
+    _STATUS_ADDED = "A"
+    _STATUS_MODIFIED = "M"
+    _STATUS_UNTRACKED = "??"
+
+    def __init__(self):
+        """Initialize git collector with cache"""
+        self._cache: Optional[GitInfo] = None
+        self._cache_time: Optional[datetime] = None
+        self._cache_ttl = timedelta(seconds=self._CACHE_TTL_SECONDS)
+
+    def collect_git_info(self) -> GitInfo:
+        """
+        Collect git information from the repository
+
+        Returns:
+            GitInfo containing branch name and change counts
+        """
+        # Check cache validity first
+        if self._is_cache_valid():
+            return self._cache
+
+        # Run git command and parse output
+        git_info = self._fetch_git_info()
+        self._update_cache(git_info)
+        return git_info
+
+    def _fetch_git_info(self) -> GitInfo:
+        """
+        Fetch git information from command
+
+        Returns:
+            GitInfo from command or error defaults
+        """
+        try:
+            result = subprocess.run(
+                ["git", "status", "-b", "--porcelain"],
+                capture_output=True,
+                text=True,
+                timeout=self._GIT_COMMAND_TIMEOUT,
+            )
+
+            if result.returncode != 0:
+                logger.debug(f"Git command failed: {result.stderr}")
+                return self._create_error_info()
+
+            return self._parse_git_output(result.stdout)
+
+        except subprocess.TimeoutExpired:
+            logger.warning("Git command timed out")
+            return self._create_error_info()
+        except Exception as e:
+            logger.debug(f"Error collecting git info: {e}")
+            return self._create_error_info()
+
+    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
+        return datetime.now() - self._cache_time < self._cache_ttl
+
+    def _update_cache(self, git_info: GitInfo) -> None:
+        """Update cache with new git info"""
+        self._cache = git_info
+        self._cache_time = datetime.now()
+
+    def _parse_git_output(self, output: str) -> GitInfo:
+        """
+        Parse git status output into GitInfo
+
+        Args:
+            output: Output from 'git status -b --porcelain'
+
+        Returns:
+            GitInfo with parsed data
+        """
+        lines = output.strip().split("\n")
+
+        # Extract branch name from first line (## branch_name...)
+        branch = self._extract_branch(lines[0] if lines else "")
+
+        # Count file changes from remaining lines
+        staged, modified, untracked = self._count_changes(lines[1:])
+
+        return GitInfo(
+            branch=branch,
+            staged=staged,
+            modified=modified,
+            untracked=untracked,
+        )
+
+    def _count_changes(self, lines: list) -> tuple[int, int, int]:
+        """
+        Count staged, modified, and untracked files
+
+        Args:
+            lines: Lines from git status output (excluding header)
+
+        Returns:
+            Tuple of (staged_count, modified_count, untracked_count)
+        """
+        staged = 0
+        modified = 0
+        untracked = 0
+
+        for line in lines:
+            if not line or len(line) < 2:
+                continue
+
+            status = line[:2]
+
+            # Check staged changes (first character)
+            if status[0] == self._STATUS_ADDED:
+                staged += 1
+            elif status[0] == self._STATUS_MODIFIED:
+                staged += 1
+
+            # Check unstaged/working directory changes (second character)
+            # Detects: M(modified), D(deleted), A(added), R(renamed), C(copied), T(type changed)
+            if len(status) > 1 and status[1] not in (" ", "."):
+                modified += 1
+
+            # Check untracked files
+            if status == self._STATUS_UNTRACKED:
+                untracked += 1
+
+        return staged, modified, untracked
+
+    @staticmethod
+    def _extract_branch(branch_line: str) -> str:
+        """
+        Extract branch name from git status -b output
+
+        Format: ## branch_name...origin/branch_name
+
+        Args:
+            branch_line: First line from git status -b
+
+        Returns:
+            Branch name or "unknown" if parsing fails
+        """
+        if not branch_line.startswith("##"):
+            return "unknown"
+
+        # Use regex to extract branch name before first dot
+        match = re.match(r"##\s+([^\s\.]+)", branch_line)
+        return match.group(1) if match else "unknown"
+
+    @staticmethod
+    def _create_error_info() -> GitInfo:
+        """Create error info with default values for graceful degradation"""
+        return GitInfo(
+            branch="unknown",
+            staged=0,
+            modified=0,
+            untracked=0,
+        )