overcode 0.1.0__py3-none-any.whl

overcode/status_constants.py

@@ -0,0 +1,190 @@
+"""
+Status constants and mappings for Overcode.
+
+Centralizes all status-related constants, colors, emojis, and display
+mappings used throughout the application.
+"""
+
+from typing import Tuple
+
+
+# =============================================================================
+# Agent Status Values
+# =============================================================================
+
+STATUS_RUNNING = "running"
+STATUS_NO_INSTRUCTIONS = "no_instructions"
+STATUS_WAITING_SUPERVISOR = "waiting_supervisor"
+STATUS_WAITING_USER = "waiting_user"
+STATUS_TERMINATED = "terminated"  # Claude Code exited, shell prompt showing
+
+# All valid agent status values
+ALL_STATUSES = [
+    STATUS_RUNNING,
+    STATUS_NO_INSTRUCTIONS,
+    STATUS_WAITING_SUPERVISOR,
+    STATUS_WAITING_USER,
+    STATUS_TERMINATED,
+]
+
+
+# =============================================================================
+# Daemon Status Values
+# =============================================================================
+
+DAEMON_STATUS_ACTIVE = "active"
+DAEMON_STATUS_IDLE = "idle"
+DAEMON_STATUS_WAITING = "waiting"
+DAEMON_STATUS_SUPERVISING = "supervising"
+DAEMON_STATUS_SLEEPING = "sleeping"
+DAEMON_STATUS_STOPPED = "stopped"
+DAEMON_STATUS_NO_AGENTS = "no_agents"
+
+
+# =============================================================================
+# Presence State Values
+# =============================================================================
+
+PRESENCE_LOCKED = 1
+PRESENCE_INACTIVE = 2
+PRESENCE_ACTIVE = 3
+
+
+# =============================================================================
+# Status to Emoji Mappings
+# =============================================================================
+
+STATUS_EMOJIS = {
+    STATUS_RUNNING: "🟢",
+    STATUS_NO_INSTRUCTIONS: "🟡",
+    STATUS_WAITING_SUPERVISOR: "🟠",
+    STATUS_WAITING_USER: "🔴",
+    STATUS_TERMINATED: "⚫",  # Black circle - Claude exited
+}
+
+
+def get_status_emoji(status: str) -> str:
+    """Get emoji for an agent status."""
+    return STATUS_EMOJIS.get(status, "⚪")
+
+
+# =============================================================================
+# Status to Color Mappings (for Rich/Textual styling)
+# =============================================================================
+
+STATUS_COLORS = {
+    STATUS_RUNNING: "green",
+    STATUS_NO_INSTRUCTIONS: "yellow",
+    STATUS_WAITING_SUPERVISOR: "orange1",
+    STATUS_WAITING_USER: "red",
+    STATUS_TERMINATED: "dim",  # Grey for terminated
+}
+
+
+def get_status_color(status: str) -> str:
+    """Get color name for an agent status."""
+    return STATUS_COLORS.get(status, "dim")
+
+
+# =============================================================================
+# Status to Symbol+Color (combined for display)
+# =============================================================================
+
+STATUS_SYMBOLS = {
+    STATUS_RUNNING: ("🟢", "green"),
+    STATUS_NO_INSTRUCTIONS: ("🟡", "yellow"),
+    STATUS_WAITING_SUPERVISOR: ("🟠", "orange1"),
+    STATUS_WAITING_USER: ("🔴", "red"),
+    STATUS_TERMINATED: ("⚫", "dim"),
+}
+
+
+def get_status_symbol(status: str) -> Tuple[str, str]:
+    """Get (emoji, color) tuple for an agent status."""
+    return STATUS_SYMBOLS.get(status, ("⚪", "dim"))
+
+
+# =============================================================================
+# Timeline Character Mappings
+# =============================================================================
+
+AGENT_TIMELINE_CHARS = {
+    STATUS_RUNNING: "█",
+    STATUS_NO_INSTRUCTIONS: "▓",
+    STATUS_WAITING_SUPERVISOR: "▒",
+    STATUS_WAITING_USER: "░",
+    STATUS_TERMINATED: "×",  # Small X - terminated
+}
+
+
+def get_agent_timeline_char(status: str) -> str:
+    """Get timeline character for an agent status."""
+    return AGENT_TIMELINE_CHARS.get(status, "─")
+
+
+PRESENCE_TIMELINE_CHARS = {
+    PRESENCE_LOCKED: "░",
+    PRESENCE_INACTIVE: "▒",
+    PRESENCE_ACTIVE: "█",
+}
+
+
+def get_presence_timeline_char(state: int) -> str:
+    """Get timeline character for a presence state."""
+    return PRESENCE_TIMELINE_CHARS.get(state, "─")
+
+
+# =============================================================================
+# Presence State Colors
+# =============================================================================
+
+PRESENCE_COLORS = {
+    PRESENCE_LOCKED: "red",
+    PRESENCE_INACTIVE: "yellow",
+    PRESENCE_ACTIVE: "green",
+}
+
+
+def get_presence_color(state: int) -> str:
+    """Get color for a presence state."""
+    return PRESENCE_COLORS.get(state, "dim")
+
+
+# =============================================================================
+# Daemon Status Display
+# =============================================================================
+
+DAEMON_STATUS_STYLES = {
+    DAEMON_STATUS_ACTIVE: ("●", "green"),
+    DAEMON_STATUS_IDLE: ("○", "yellow"),
+    DAEMON_STATUS_WAITING: ("◐", "yellow"),
+    DAEMON_STATUS_SUPERVISING: ("●", "cyan"),
+    DAEMON_STATUS_SLEEPING: ("○", "dim"),
+    DAEMON_STATUS_STOPPED: ("○", "red"),
+    DAEMON_STATUS_NO_AGENTS: ("○", "dim"),
+}
+
+
+def get_daemon_status_style(status: str) -> Tuple[str, str]:
+    """Get (symbol, color) for daemon status display."""
+    return DAEMON_STATUS_STYLES.get(status, ("?", "dim"))
+
+
+# =============================================================================
+# Status Categorization
+# =============================================================================
+
+
+def is_green_status(status: str) -> bool:
+    """Check if a status is considered 'green' (actively working)."""
+    return status == STATUS_RUNNING
+
+
+def is_waiting_status(status: str) -> bool:
+    """Check if a status is a waiting state."""
+    return status in (STATUS_WAITING_SUPERVISOR, STATUS_WAITING_USER)
+
+
+def is_user_blocked(status: str) -> bool:
+    """Check if status indicates user intervention is required."""
+    return status == STATUS_WAITING_USER

overcode/status_detector.py

@@ -0,0 +1,339 @@
+"""
+Status detection for Claude sessions in tmux.
+"""
+
+from typing import Optional, Tuple, TYPE_CHECKING
+
+from .status_constants import (
+    STATUS_RUNNING,
+    STATUS_NO_INSTRUCTIONS,
+    STATUS_WAITING_SUPERVISOR,
+    STATUS_WAITING_USER,
+    STATUS_TERMINATED,
+)
+from .status_patterns import (
+    get_patterns,
+    matches_any,
+    find_matching_line,
+    is_status_bar_line,
+    is_command_menu_line,
+    count_command_menu_lines,
+    clean_line,
+    StatusPatterns,
+)
+
+if TYPE_CHECKING:
+    from .interfaces import TmuxInterface
+
+
+class StatusDetector:
+    """Detects the current status of a Claude session"""
+
+    # Re-export status constants for backwards compatibility
+    STATUS_RUNNING = STATUS_RUNNING
+    STATUS_NO_INSTRUCTIONS = STATUS_NO_INSTRUCTIONS
+    STATUS_WAITING_SUPERVISOR = STATUS_WAITING_SUPERVISOR
+    STATUS_WAITING_USER = STATUS_WAITING_USER
+    STATUS_TERMINATED = STATUS_TERMINATED
+
+    def __init__(
+        self,
+        tmux_session: str,
+        tmux: "TmuxInterface" = None,
+        patterns: StatusPatterns = None
+    ):
+        """Initialize the status detector.
+
+        Args:
+            tmux_session: Name of the tmux session to monitor
+            tmux: TmuxInterface implementation (defaults to RealTmux for production)
+            patterns: StatusPatterns to use for detection (defaults to DEFAULT_PATTERNS)
+        """
+        self.tmux_session = tmux_session
+
+        # Dependency injection for testability
+        if tmux is None:
+            from .interfaces import RealTmux
+            tmux = RealTmux()
+        self.tmux = tmux
+
+        # Use provided patterns or default
+        self.patterns = patterns or get_patterns()
+
+        # Track previous content per session for change detection
+        self._previous_content: dict[int, str] = {}  # window -> content hash
+        self._content_changed: dict[int, bool] = {}  # window -> changed flag
+
+    def get_pane_content(self, window: int, num_lines: int = 50) -> Optional[str]:
+        """Get the last N meaningful lines from a tmux pane.
+
+        Captures more content than requested and filters out trailing blank lines
+        to find the actual content (Claude Code often has blank lines at bottom).
+        """
+        content = self.tmux.capture_pane(self.tmux_session, window, lines=150)
+        if content is None:
+            return None
+
+        # Strip trailing blank lines, then return last num_lines
+        lines = content.rstrip().split('\n')
+        meaningful_lines = lines[-num_lines:] if len(lines) > num_lines else lines
+        return '\n'.join(meaningful_lines)
+
+    def detect_status(self, session) -> Tuple[str, str, str]:
+        """
+        Detect session status and current activity.
+
+        Returns:
+            Tuple of (status, current_activity, pane_content)
+            - status: one of STATUS_* constants
+            - current_activity: single line description of what's happening
+            - pane_content: the raw pane content (to avoid duplicate tmux calls)
+        """
+        content = self.get_pane_content(session.tmux_window)
+
+        if not content:
+            return self.STATUS_WAITING_USER, "Unable to read pane", ""
+
+        # Content change detection - if content is changing, Claude is actively working
+        # Key by session.id, not window index, to avoid stale hashes when windows are recycled
+        # IMPORTANT: Filter out status bar lines before hashing to avoid false positives
+        # from dynamic status bar elements (token counts, elapsed time) that update when idle
+        session_id = session.id
+        content_for_hash = self._filter_status_bar_for_hash(content)
+        content_hash = hash(content_for_hash)
+        content_changed = False
+        if session_id in self._previous_content:
+            content_changed = self._previous_content[session_id] != content_hash
+        self._previous_content[session_id] = content_hash
+        self._content_changed[session_id] = content_changed
+
+        lines = content.strip().split('\n')
+        # Get more lines for better context (menu prompts can be 5+ lines)
+        last_lines = [l.strip() for l in lines[-10:] if l.strip()]
+
+        if not last_lines:
+            return self.STATUS_WAITING_USER, "No output", content
+
+        last_line = last_lines[-1]
+
+        # Check for shell prompt (Claude Code has terminated)
+        # Shell prompts typically end with $ or % and have username@hostname pattern
+        # Also check for absence of Claude Code UI elements
+        if self._is_shell_prompt(last_lines):
+            return self.STATUS_TERMINATED, "Claude exited - shell prompt", content
+
+        # Filter out UI chrome lines before pattern matching
+        content_lines = [l for l in last_lines if not is_status_bar_line(l, self.patterns)]
+
+        # Join more lines for pattern matching (menus have multiple lines)
+        last_few = ' '.join(content_lines[-6:]).lower() if content_lines else ''
+
+        # Check for permission/confirmation prompts (HIGHEST priority)
+        # This MUST come before active indicator checks because permission dialogs
+        # can contain tool names like "Web Search commands in" that would falsely
+        # match active indicators.
+        if matches_any(last_few, self.patterns.permission_patterns):
+            request_text = self._extract_permission_request(last_lines)
+            return self.STATUS_WAITING_USER, f"Permission: {request_text}", content
+
+        # Check for command menu display (slash command autocomplete)
+        # When user types a slash command, Claude shows a menu of available commands.
+        # This means Claude is waiting for the user to complete/select a command.
+        # We check if most of the last lines are menu entries.
+        menu_lines = count_command_menu_lines(last_lines, self.patterns)
+        if menu_lines >= 3 and menu_lines >= len(last_lines) * 0.4:
+            return self.STATUS_WAITING_USER, "Command menu - waiting for input", content
+
+        # Content change detection - if pane content is actively changing, Claude is working
+        # This is the most reliable indicator as it catches streaming output
+        if content_changed:
+            activity = self._extract_last_activity(last_lines)
+            return self.STATUS_RUNNING, f"Active: {activity}", content
+
+        # Check for ACTIVE WORK indicators BEFORE checking for prompt
+        # These indicate Claude is busy even if the prompt is visible
+        if matches_any(last_few, self.patterns.active_indicators):
+            matching_line = find_matching_line(
+                last_lines, self.patterns.active_indicators, reverse=True
+            )
+            if matching_line:
+                return self.STATUS_RUNNING, clean_line(matching_line, self.patterns), content
+            return self.STATUS_RUNNING, "Processing...", content
+
+        # Check for tool execution indicators (case-sensitive)
+        matching_line = find_matching_line(
+            last_lines, self.patterns.execution_indicators, case_sensitive=True, reverse=True
+        )
+        if matching_line:
+            return self.STATUS_RUNNING, clean_line(matching_line, self.patterns), content
+
+        # Check for thinking/planning
+        if any("thinking" in line.lower() for line in last_lines):
+            return self.STATUS_RUNNING, "Thinking...", content
+
+        # NOW check for Claude's prompt (user input prompt) - means waiting for user
+        # Only check after ruling out active work indicators above
+        # We need to distinguish:
+        #   - Empty prompt `>` or `› ` = waiting for user input
+        #   - User input `> some text` with no Claude response = stalled
+        for line in last_lines[-4:]:
+            stripped = line.strip()
+            # Empty prompt ready for input
+            if stripped in self.patterns.prompt_chars:
+                return self.STATUS_WAITING_USER, "Waiting for user input", content
+            # Autocomplete suggestion showing (prompt with suggested content + send indicator)
+            # This means Claude is idle and waiting for user input
+            if any(stripped.startswith(c) for c in self.patterns.prompt_chars):
+                if '↵' in stripped and 'send' in stripped.lower():
+                    return self.STATUS_WAITING_USER, "Waiting for user input", content
+
+        # Check if there's user input that Claude hasn't responded to (stalled)
+        # Look for `> text` followed by no Claude response (no ⏺ line after it)
+        # Note: ⏺ is Claude's output indicator, ⏵⏵ in status bar is just UI chrome
+        # Note: Claude Code uses \xa0 (non-breaking space) after prompt, not regular space
+        found_user_input = False
+        found_claude_response = False
+        for line in last_lines:
+            stripped = line.strip()
+            # Skip autocomplete suggestion lines - they end with "↵ send" indicator
+            # These are not actual user input, just UI showing suggested completions
+            if '↵' in stripped and 'send' in stripped.lower():
+                continue
+            # Check for prompt with either regular space or non-breaking space (\xa0)
+            is_user_input = (
+                stripped.startswith('> ') or stripped.startswith('>\xa0') or
+                stripped.startswith('› ') or stripped.startswith('›\xa0') or
+                stripped.startswith('❯ ') or stripped.startswith('❯\xa0')
+            )
+            if is_user_input and len(stripped) > 2:  # Has actual content after prompt
+                found_user_input = True
+                found_claude_response = False  # Reset - look for response after this
+            elif stripped.startswith('⏺'):  # Claude's response indicator (not ⏵⏵ status bar)
+                found_claude_response = True
+
+        if found_user_input and not found_claude_response:
+            return self.STATUS_WAITING_USER, "Stalled - no response to user input", content
+
+        # Check for common waiting patterns
+        if matches_any(last_few, self.patterns.waiting_patterns):
+            return self.STATUS_WAITING_USER, self._extract_question(last_lines), content
+
+        # Default: if no standing instructions, it's yellow
+        if not session.standing_instructions:
+            return self.STATUS_NO_INSTRUCTIONS, self._extract_last_activity(last_lines), content
+
+        # Otherwise, assume running
+        return self.STATUS_RUNNING, self._extract_last_activity(last_lines), content
+
+    def _extract_permission_request(self, lines: list) -> str:
+        """Extract the permission request text from lines before the prompt"""
+        # Look for lines before "Enter to confirm" that contain the request
+        relevant_lines = []
+        for line in reversed(lines):
+            line_lower = line.lower()
+            # Stop when we hit the confirmation line
+            if "enter to confirm" in line_lower or "esc to reject" in line_lower:
+                continue
+            # Stop at empty lines
+            if not line.strip():
+                break
+            # Collect meaningful lines
+            clean = self._clean_line(line)
+            if len(clean) > 5:
+                relevant_lines.insert(0, clean)
+            # Don't go too far back
+            if len(relevant_lines) >= 3:
+                break
+
+        if relevant_lines:
+            # Join and truncate
+            request = " ".join(relevant_lines)
+            if len(request) > 100:
+                request = request[:97] + "..."
+            return request
+        return "approval required"
+
+    def _extract_question(self, lines: list) -> str:
+        """Extract a question from recent output"""
+        for line in reversed(lines):
+            if '?' in line:
+                return self._clean_line(line)
+        return self._clean_line(lines[-1])
+
+    def _extract_last_activity(self, lines: list) -> str:
+        """Extract the most recent activity description"""
+        # Look for lines that look like activity descriptions
+        # Skip status bar lines (they contain UI chrome, not actual activity)
+        for line in reversed(lines):
+            # Skip status bar lines
+            if is_status_bar_line(line, self.patterns):
+                continue
+            cleaned = clean_line(line, self.patterns)
+            if len(cleaned) > 10 and not cleaned.startswith('›'):
+                return cleaned
+        return "Idle"
+
+    def _clean_line(self, line: str) -> str:
+        """Clean a line for display"""
+        return clean_line(line, self.patterns)
+
+    def _filter_status_bar_for_hash(self, content: str) -> str:
+        """Filter out status bar lines before computing content hash.
+
+        The Claude Code status bar contains dynamic elements (token counts,
+        elapsed time, etc.) that change even when Claude is idle. Including
+        these in the hash causes false "content changed" detection.
+
+        Args:
+            content: Raw pane content
+
+        Returns:
+            Content with status bar lines removed
+        """
+        lines = content.split('\n')
+        filtered = [
+            line for line in lines
+            if not is_status_bar_line(line, self.patterns)
+        ]
+        return '\n'.join(filtered)
+
+    def _is_shell_prompt(self, lines: list) -> bool:
+        """Detect if we're at a shell prompt (Claude Code has exited).
+
+        Shell prompts typically:
+        - End with $ or % (bash/zsh)
+        - Have username@hostname pattern
+        - Don't have Claude Code UI elements (>, ⏺, status bar chars)
+
+        Returns True if this looks like a shell prompt, not Claude Code.
+        """
+        import re
+
+        if not lines:
+            return False
+
+        # Get last non-empty line
+        last_line = lines[-1].strip()
+
+        # Common shell prompt patterns:
+        # - user@host path $
+        # - user@host path %
+        # - [user@host path]$
+        # - path $
+        shell_prompt_patterns = [
+            r'\w+@\w+.*[%$]\s*$',  # user@hostname ... $ or %
+            r'\[.*\][%$#]\s*$',    # [prompt]$ or [prompt]%
+            r'^[~\/].*[%$]\s*$',   # /path/to/dir $ or ~/dir %
+        ]
+
+        for pattern in shell_prompt_patterns:
+            if re.search(pattern, last_line):
+                # Verify there's no Claude Code UI in recent lines
+                claude_ui_indicators = ['⏺', '›', '? for shortcuts', '⎿', '⏵']
+                recent_text = ' '.join(lines[-5:])
+                has_claude_ui = any(indicator in recent_text for indicator in claude_ui_indicators)
+
+                if not has_claude_ui:
+                    return True
+
+        return False

overcode/status_history.py

@@ -0,0 +1,164 @@
+"""
+Agent status history tracking.
+
+Provides functions to log and read agent status history for timeline visualization.
+"""
+
+import csv
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from .settings import PATHS
+
+
+def log_agent_status(
+    agent_name: str,
+    status: str,
+    activity: str = "",
+    history_file: Optional[Path] = None
+) -> None:
+    """Log agent status to history CSV file.
+
+    Called by daemon each loop to track agent status over time.
+    Used by TUI for timeline visualization.
+
+    Args:
+        agent_name: Name of the agent
+        status: Current status string
+        activity: Optional activity description
+        history_file: Optional path override (for testing)
+    """
+    path = history_file or PATHS.agent_history
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Check if file exists (to write header)
+    write_header = not path.exists()
+
+    with open(path, 'a', newline='') as f:
+        writer = csv.writer(f)
+        if write_header:
+            writer.writerow(['timestamp', 'agent', 'status', 'activity'])
+        writer.writerow([
+            datetime.now().isoformat(),
+            agent_name,
+            status,
+            activity[:100] if activity else ""
+        ])
+
+
+def read_agent_status_history(
+    hours: float = 3.0,
+    agent_name: Optional[str] = None,
+    history_file: Optional[Path] = None
+) -> List[Tuple[datetime, str, str, str]]:
+    """Read agent status history from CSV file.
+
+    Args:
+        hours: How many hours of history to read (default 3)
+        agent_name: Optional - filter to specific agent
+        history_file: Optional path override (for testing)
+
+    Returns:
+        List of (timestamp, agent, status, activity) tuples, oldest first
+    """
+    path = history_file or PATHS.agent_history
+
+    if not path.exists():
+        return []
+
+    cutoff = datetime.now() - timedelta(hours=hours)
+    history: List[Tuple[datetime, str, str, str]] = []
+
+    try:
+        with open(path, 'r', newline='') as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                try:
+                    ts = datetime.fromisoformat(row['timestamp'])
+                    if ts >= cutoff:
+                        agent = row['agent']
+                        if agent_name is None or agent == agent_name:
+                            history.append((
+                                ts,
+                                agent,
+                                row['status'],
+                                row.get('activity', '')
+                            ))
+                except (ValueError, KeyError):
+                    continue
+    except (OSError, IOError):
+        pass
+
+    return history
+
+
+def get_agent_timeline(
+    agent_name: str,
+    hours: float = 3.0,
+    history_file: Optional[Path] = None
+) -> List[Tuple[datetime, str]]:
+    """Get simplified timeline for a specific agent.
+
+    Args:
+        agent_name: Name of the agent
+        hours: How many hours of history (default 3)
+        history_file: Optional path override (for testing)
+
+    Returns:
+        List of (timestamp, status) tuples for the agent
+    """
+    history = read_agent_status_history(hours, agent_name, history_file)
+    return [(ts, status) for ts, _, status, _ in history]
+
+
+def clear_old_history(
+    max_age_hours: float = 24.0,
+    history_file: Optional[Path] = None
+) -> int:
+    """Remove old entries from history file.
+
+    Args:
+        max_age_hours: Remove entries older than this (default 24 hours)
+        history_file: Optional path override (for testing)
+
+    Returns:
+        Number of entries removed
+    """
+    path = history_file or PATHS.agent_history
+
+    if not path.exists():
+        return 0
+
+    cutoff = datetime.now() - timedelta(hours=max_age_hours)
+    kept_entries: List[List[str]] = []
+    removed_count = 0
+
+    try:
+        with open(path, 'r', newline='') as f:
+            reader = csv.reader(f)
+            header = next(reader, None)
+            if header:
+                kept_entries.append(header)
+
+            for row in reader:
+                try:
+                    ts = datetime.fromisoformat(row[0])
+                    if ts >= cutoff:
+                        kept_entries.append(row)
+                    else:
+                        removed_count += 1
+                except (ValueError, IndexError):
+                    # Keep malformed entries
+                    kept_entries.append(row)
+
+        # Only rewrite if we removed entries
+        if removed_count > 0:
+            with open(path, 'w', newline='') as f:
+                writer = csv.writer(f)
+                writer.writerows(kept_entries)
+
+    except (OSError, IOError):
+        pass
+
+    return removed_count