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

moai_adk/statusline/main.py

@@ -32,11 +32,22 @@ def read_session_context() -> dict:
         Dictionary containing session information
     """
     try:
-        input_data = sys.stdin.read()
+        # Handle Docker/non-interactive environments by checking TTY
+        input_data = sys.stdin.read() if not sys.stdin.isatty() else "{}"
         if input_data:
-            return json.loads(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 (json.JSONDecodeError, EOFError, ValueError):
+    except (EOFError, ValueError) as e:
+        import logging
+
+        logging.error(f"Error reading stdin: {e}")
         return {}
 
 
@@ -55,7 +66,8 @@ def safe_collect_git_info() -> tuple[str, str]:
         git_status = f"+{git_info.staged} M{git_info.modified} ?{git_info.untracked}"
 
         return branch, git_status
-    except Exception:
+    except (OSError, AttributeError, RuntimeError):
+        # Git collector errors (file access, attribute, or runtime errors)
         return "N/A", ""
 
 
@@ -69,7 +81,8 @@ def safe_collect_duration() -> str:
     try:
         tracker = MetricsTracker()
         return tracker.get_duration()
-    except Exception:
+    except (OSError, AttributeError, ValueError):
+        # Metrics tracker errors (file access, attribute, or value errors)
         return "0m"
 
 
@@ -88,7 +101,8 @@ def safe_collect_alfred_task() -> str:
             stage_suffix = f"-{task.stage}" if task.stage else ""
             return f"[{task.command.upper()}{stage_suffix}]"
         return ""
-    except Exception:
+    except (OSError, AttributeError, RuntimeError):
+        # Alfred detector errors (file access, attribute, or runtime errors)
         return ""
 
 
@@ -103,7 +117,8 @@ def safe_collect_version() -> str:
         reader = VersionReader()
         version = reader.get_version()
         return version or "unknown"
-    except Exception:
+    except (ImportError, AttributeError, OSError):
+        # Version reader errors (import, attribute, or file access errors)
         return "unknown"
 
 
@@ -125,35 +140,93 @@ def safe_check_update(current_version: str) -> tuple[bool, Optional[str]]:
         update_info = checker.check_for_update(current_version)
 
         return update_info.available, update_info.latest_version
-    except Exception:
+    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
+    - 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
+        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
+        # Extract model from session context with Claude Code version
         model_info = session_context.get("model", {})
-        model = model_info.get("display_name", "Unknown")
-        if not model:
-            model = model_info.get("name", "Unknown")
+        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", "")
@@ -162,7 +235,13 @@ def build_statusline_data(session_context: dict, mode: str = "compact") -> str:
         else:
             directory = "project"
 
-        # Collect all information
+        # 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()
@@ -172,6 +251,7 @@ def build_statusline_data(session_context: dict, mode: str = "compact") -> str:
         # Build StatuslineData with dynamic fields
         data = StatuslineData(
             model=model,
+            claude_version=claude_version,
             version=version,
             memory_usage="256MB",  # TODO: Get actual memory usage
             branch=branch,
@@ -179,8 +259,10 @@ def build_statusline_data(session_context: dict, mode: str = "compact") -> str:
             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
@@ -204,9 +286,17 @@ def main():
     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()
 
@@ -220,6 +310,10 @@ def main():
 
     # 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="")
 

moai_adk/statusline/renderer.py

@@ -23,8 +23,11 @@ class StatuslineData:
     duration: str
     directory: str
     active_task: str
+    claude_version: str = ""  # Claude Code version (e.g., "2.0.46")
+    output_style: str = ""  # Output style name (e.g., "R2-D2", "Yoda")
     update_available: bool = False
     latest_version: str = ""
+    context_window: str = ""  # Context window usage (e.g., "15K/200K")
 
 
 class StatuslineRenderer:
@@ -64,7 +67,7 @@ class StatuslineRenderer:
 
     def _render_compact(self, data: StatuslineData) -> str:
         """
-        Render compact mode: [MODEL] [DURATION] | [DIR] | [VERSION] | [BRANCH] | [GIT] | [TASK]
+        Render compact mode: 🤖 Model | 🔅 Version | 💰 Context | 💬 Style | 📊 Changes | 🔀 Branch
         Constraint: <= 80 characters
 
         Args:
@@ -75,6 +78,8 @@ class StatuslineRenderer:
         """
         max_length = self._MODE_CONSTRAINTS["compact"]
         parts = self._build_compact_parts(data)
+
+        # Join all parts with separator (no brackets)
         result = self._format_config.separator.join(parts)
 
         # Adjust if too long
@@ -86,7 +91,7 @@ class StatuslineRenderer:
     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
+        Format: 🤖 Model | 🔅 Version | 💰 Context | 💬 Style | 📊 Changes | 🔀 Branch
 
         Args:
             data: StatuslineData instance
@@ -100,9 +105,18 @@ class StatuslineRenderer:
         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 Claude Code version if available
+        if data.claude_version:
+            claude_ver_str = data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
+            parts.append(f"🔅 {claude_ver_str}")
+
+        # Add context window usage if available (💰 icon)
+        if data.context_window:
+            parts.append(f"💰 {data.context_window}")
+
+        # Add output style if not empty
+        if data.output_style:
+            parts.append(f"💬 {data.output_style}")
 
         # Add git status if display enabled and status not empty
         if self._display_config.git_status and data.git_status:
@@ -121,7 +135,7 @@ class StatuslineRenderer:
     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
+        Format: 🤖 Model | 🔅 Version | 💰 Context | 💬 Style | 📊 Changes | 🔀 Branch
 
         Args:
             data: StatuslineData instance
@@ -130,21 +144,26 @@ class StatuslineRenderer:
         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}",
-        ]
+        truncated_branch = self._truncate_branch(data.branch, max_length=30)
+
+        # Build parts list
+        parts = [f"🤖 {data.model}"]
+
+        if data.claude_version:
+            claude_ver_str = data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
+            parts.append(f"🔅 {claude_ver_str}")
+
+        if data.context_window:
+            parts.append(f"💰 {data.context_window}")
+
+        if data.output_style:
+            parts.append(f"💬 {data.output_style}")
 
-        # 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)
 
@@ -153,23 +172,27 @@ class StatuslineRenderer:
         # 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}",
-            ]
+            parts = [f"🤖 {data.model}"]
+
+            if data.claude_version:
+                claude_ver_str = (
+                    data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
+                )
+                parts.append(f"🔅 {claude_ver_str}")
+            if data.context_window:
+                parts.append(f"💰 {data.context_window}")
+            if data.output_style:
+                parts.append(f"💬 {data.output_style}")
             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 still too long, remove output_style
+        if len(result) > max_length:
+            parts = [f"🤖 {data.model}"]
+            if data.context_window:
+                parts.append(f"💰 {data.context_window}")
             if data.git_status:
                 parts.append(f"📊 {data.git_status}")
             parts.append(f"🔀 {truncated_branch}")
@@ -185,7 +208,7 @@ class StatuslineRenderer:
         """
         Render extended mode: Full path and detailed info with labels
         Constraint: <= 120 characters
-        Format: 🤖 Model | 🗿 Version | Output Style | 📋 TODO | 🔀 Git: Branch | Changes
+        Format: 🤖 Model | 🔅 Version | 💰 Context | 💬 Style | 📊 Changes | 🔀 Branch
 
         Args:
             data: StatuslineData instance
@@ -195,54 +218,51 @@ class StatuslineRenderer:
         """
         branch = self._truncate_branch(data.branch, max_length=30)
 
+        # Build parts list
         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}")
+        if data.claude_version:
+            claude_ver_str = data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
+            parts.append(f"🔅 {claude_ver_str}")
+
+        if data.context_window:
+            parts.append(f"💰 {data.context_window}")
+
+        if data.output_style:
+            parts.append(f"💬 {data.output_style}")
 
-        # 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 exceeds limit, try truncating
         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}")
-
+            parts = []
+            if self._display_config.model:
+                parts.append(f"🤖 {data.model}")
+            if data.claude_version:
+                claude_ver_str = (
+                    data.claude_version if data.claude_version.startswith("v") else f"v{data.claude_version}"
+                )
+                parts.append(f"🔅 {claude_ver_str}")
+            if data.context_window:
+                parts.append(f"💰 {data.context_window}")
+            if data.output_style:
+                parts.append(f"💬 {data.output_style}")
             if data.git_status:
-                parts.append(f"Changes: {data.git_status}")
-            if data.active_task.strip():
-                parts.append(data.active_task)
+                parts.append(f"📊 {data.git_status}")
+            parts.append(f"🔀 {branch}")
             result = self._format_config.separator.join(parts)
 
         return result
@@ -251,7 +271,7 @@ class StatuslineRenderer:
         """
         Render minimal mode: Extreme space constraint with minimal labels
         Constraint: <= 40 characters
-        Format: 🤖 Model | 🗿 Ver Version | Changes: +staged M modified ? untracked
+        Format: 🤖 Model | 💰 Context
 
         Args:
             data: StatuslineData instance
@@ -265,26 +285,22 @@ class StatuslineRenderer:
         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)}")
+        # Add context window usage if available (💰 icon)
+        if data.context_window:
+            parts.append(f"💰 {data.context_window}")
 
         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
+        # Add git_status if it fits
         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
-            ):
+            status_label = f"📊 {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:
+    def _truncate_branch(branch: str, max_length: int = 30) -> str:
         """
         Truncate branch name intelligently, preserving SPEC ID if present
 
@@ -309,7 +325,7 @@ class StatuslineRenderer:
                         return spec_truncated
 
         # Simple truncation with ellipsis for very long names
-        return f"{branch[:max_length-1]}…" if len(branch) > max_length else branch
+        return f"{branch[: max_length - 1]}…" if len(branch) > max_length else branch
 
     @staticmethod
     def _truncate_version(version: str) -> str:

moai_adk/statusline/update_checker.py

@@ -68,9 +68,7 @@ class UpdateChecker:
             UpdateInfo from PyPI or error default
         """
         try:
-            with urllib.request.urlopen(
-                self._PYPI_API_URL, timeout=self._TIMEOUT_SECONDS
-            ) as response:
+            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")
@@ -108,12 +106,8 @@ class UpdateChecker:
             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()
-            ]
+            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)