overcode 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

overcode/supervisor_daemon_core.py

@@ -0,0 +1,210 @@
+"""
+Pure business logic for Supervisor Daemon.
+
+These functions contain no I/O and are fully unit-testable.
+They are used by SupervisorDaemon but can be tested independently.
+"""
+
+from typing import List, Optional
+
+from .status_constants import STATUS_RUNNING, get_status_emoji
+
+
+def build_daemon_claude_context(
+    tmux_session: str,
+    non_green_sessions: List[dict],
+) -> str:
+    """Build initial context prompt for daemon claude.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        tmux_session: Name of the tmux session
+        non_green_sessions: List of session dicts with 'name', 'tmux_window',
+                           'standing_instructions', 'current_status', 'repo_name'
+
+    Returns:
+        Multi-line context string for daemon claude
+    """
+    context_parts = []
+
+    context_parts.append("You are the Overcode daemon claude agent.")
+    context_parts.append("Your mission: Make all RED/YELLOW/ORANGE sessions GREEN.")
+    context_parts.append("")
+    context_parts.append(f"TMUX SESSION: {tmux_session}")
+    context_parts.append(f"Sessions needing attention: {len(non_green_sessions)}")
+    context_parts.append("")
+
+    for session in non_green_sessions:
+        status = session.get("current_status", "unknown")
+        emoji = get_status_emoji(status)
+        name = session.get("name", "unknown")
+        window = session.get("tmux_window", "?")
+        context_parts.append(f"{emoji} {name} (window {window})")
+
+        instructions = session.get("standing_instructions")
+        if instructions:
+            context_parts.append(f"   Autopilot: {instructions}")
+        else:
+            context_parts.append("   No autopilot instructions set")
+
+        repo_name = session.get("repo_name")
+        if repo_name:
+            context_parts.append(f"   Repo: {repo_name}")
+        context_parts.append("")
+
+    context_parts.append("Read the daemon claude skill for how to control sessions via tmux.")
+    context_parts.append("Start by reading ~/.overcode/sessions/sessions.json to see full state.")
+    context_parts.append("Then check each non-green session and help them make progress.")
+
+    return "\n".join(context_parts)
+
+
+def filter_non_green_sessions(
+    sessions: List[dict],
+    exclude_names: Optional[List[str]] = None,
+) -> List[dict]:
+    """Filter sessions to only those needing attention.
+
+    Pure function - no side effects, fully testable.
+
+    Filters out:
+    - Running (green) sessions
+    - Sessions with names in exclude_names (e.g., 'daemon_claude')
+    - Asleep sessions
+    - Sessions with DO_NOTHING standing orders
+
+    Args:
+        sessions: List of session dicts with 'current_status', 'name',
+                 'is_asleep', 'standing_instructions'
+        exclude_names: Optional list of session names to always exclude
+
+    Returns:
+        Filtered list of sessions needing attention
+    """
+    exclude_names = exclude_names or []
+    result = []
+
+    for s in sessions:
+        # Skip green sessions
+        if s.get("current_status") == STATUS_RUNNING:
+            continue
+
+        # Skip excluded names (e.g., daemon_claude)
+        if s.get("name") in exclude_names:
+            continue
+
+        # Skip asleep sessions
+        if s.get("is_asleep", False):
+            continue
+
+        # Skip sessions with DO_NOTHING standing orders
+        instructions = s.get("standing_instructions", "")
+        if instructions and "DO_NOTHING" in instructions.upper():
+            continue
+
+        result.append(s)
+
+    return result
+
+
+def calculate_daemon_claude_run_seconds(
+    started_at_iso: Optional[str],
+    now_iso: str,
+    previous_total: float,
+) -> float:
+    """Calculate total daemon claude run time including current run.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        started_at_iso: ISO timestamp when current run started (None if not running)
+        now_iso: Current time as ISO timestamp
+        previous_total: Previously accumulated run seconds
+
+    Returns:
+        Total run seconds including any current run
+    """
+    if started_at_iso is None:
+        return previous_total
+
+    try:
+        from datetime import datetime
+        started_at = datetime.fromisoformat(started_at_iso)
+        now = datetime.fromisoformat(now_iso)
+        current_run = (now - started_at).total_seconds()
+        return previous_total + max(0, current_run)
+    except (ValueError, TypeError):
+        return previous_total
+
+
+def should_launch_daemon_claude(
+    non_green_sessions: List[dict],
+    daemon_claude_running: bool,
+) -> tuple:
+    """Determine if daemon claude should be launched.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        non_green_sessions: List of non-green session dicts
+        daemon_claude_running: Whether daemon claude is already running
+
+    Returns:
+        Tuple of (should_launch: bool, reason: str)
+    """
+    if not non_green_sessions:
+        return False, "no_sessions"
+
+    if daemon_claude_running:
+        return False, "already_running"
+
+    # Check if all are waiting for user with no instructions
+    all_waiting_user = all(
+        s.get("current_status") == "waiting_user"
+        for s in non_green_sessions
+    )
+    any_has_instructions = any(
+        s.get("standing_instructions")
+        for s in non_green_sessions
+    )
+
+    if all_waiting_user and not any_has_instructions:
+        return False, "waiting_user_no_instructions"
+
+    reason = "with_instructions" if any_has_instructions else "non_user_blocked"
+    return True, reason
+
+
+def parse_intervention_log_line(
+    line: str,
+    session_names: List[str],
+    action_phrases: List[str],
+    no_action_phrases: List[str],
+) -> Optional[str]:
+    """Parse a log line to extract intervention session name if applicable.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        line: Single log line to parse
+        session_names: Session names to look for
+        action_phrases: Phrases indicating an action was taken
+        no_action_phrases: Phrases indicating no action was taken
+
+    Returns:
+        Session name if an intervention was detected, None otherwise
+    """
+    line_lower = line.lower()
+
+    for name in session_names:
+        if f"{name} - " in line:
+            # Check for no-action phrases first
+            if any(phrase in line_lower for phrase in no_action_phrases):
+                return None
+
+            # Check for action phrases
+            if any(phrase in line_lower for phrase in action_phrases):
+                return name
+
+    return None

overcode/testing/__init__.py

@@ -0,0 +1,6 @@
+"""TUI visual testing tools for Claude Code integration."""
+
+from .renderer import render_terminal_to_png
+from .tmux_driver import TUIDriver
+
+__all__ = ["render_terminal_to_png", "TUIDriver"]

overcode/testing/renderer.py

@@ -0,0 +1,268 @@
+"""Render terminal output with ANSI codes to PNG images."""
+
+from pathlib import Path
+from typing import Optional
+import pyte
+from PIL import Image, ImageDraw, ImageFont
+
+
+# Default terminal color palette (based on common terminal themes)
+ANSI_COLORS = {
+    "black": "#1e1e1e",
+    "red": "#f44747",
+    "green": "#6a9955",
+    "yellow": "#dcdcaa",
+    "blue": "#569cd6",
+    "magenta": "#c586c0",
+    "cyan": "#4ec9b0",
+    "white": "#d4d4d4",
+    # Bright variants
+    "brightblack": "#808080",
+    "brightred": "#f44747",
+    "brightgreen": "#6a9955",
+    "brightyellow": "#dcdcaa",
+    "brightblue": "#569cd6",
+    "brightmagenta": "#c586c0",
+    "brightcyan": "#4ec9b0",
+    "brightwhite": "#ffffff",
+}
+
+# Background color
+BG_COLOR = "#1e1e1e"
+DEFAULT_FG = "#d4d4d4"
+
+# Font configuration
+DEFAULT_FONT_SIZE = 14
+FONT_PATHS = [
+    # macOS
+    "/System/Library/Fonts/Monaco.ttf",
+    "/System/Library/Fonts/SFMono-Regular.otf",
+    "/Library/Fonts/JetBrainsMono-Regular.ttf",
+    # Linux
+    "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
+    "/usr/share/fonts/TTF/JetBrainsMono-Regular.ttf",
+]
+
+
+def _find_monospace_font(size: int = DEFAULT_FONT_SIZE) -> ImageFont.FreeTypeFont:
+    """Find a suitable monospace font."""
+    for path in FONT_PATHS:
+        if Path(path).exists():
+            try:
+                return ImageFont.truetype(path, size)
+            except Exception:
+                continue
+    # Fallback to default
+    return ImageFont.load_default()
+
+
+def _color_256_to_hex(n: int) -> str:
+    """Convert 256-color palette index to hex color."""
+    # Colors 0-15: Standard colors (handled by name usually)
+    standard_colors = [
+        "#000000", "#800000", "#008000", "#808000", "#000080", "#800080", "#008080", "#c0c0c0",
+        "#808080", "#ff0000", "#00ff00", "#ffff00", "#0000ff", "#ff00ff", "#00ffff", "#ffffff",
+    ]
+    if n < 16:
+        return standard_colors[n]
+
+    # Colors 16-231: 6x6x6 color cube
+    if n < 232:
+        n -= 16
+        r = (n // 36) * 51
+        g = ((n // 6) % 6) * 51
+        b = (n % 6) * 51
+        return f"#{r:02x}{g:02x}{b:02x}"
+
+    # Colors 232-255: Grayscale
+    gray = (n - 232) * 10 + 8
+    return f"#{gray:02x}{gray:02x}{gray:02x}"
+
+
+def _pyte_color_to_hex(color, default: str, bright: bool = False) -> str:
+    """Convert pyte color to hex color."""
+    if color is None or color == "default":
+        return default
+
+    # Handle 256-color codes (pyte returns as int or string number)
+    if isinstance(color, int):
+        return _color_256_to_hex(color)
+
+    if isinstance(color, str):
+        # Handle 6-digit hex without # (pyte format for 24-bit color)
+        # Must check this FIRST before trying int conversion
+        if len(color) == 6 and all(c in "0123456789abcdefABCDEF" for c in color):
+            return f"#{color}"
+
+        # Try parsing as integer (256-color)
+        if color.isdigit():
+            return _color_256_to_hex(int(color))
+
+        # Handle named colors
+        if bright and color in ANSI_COLORS:
+            bright_key = f"bright{color}"
+            if bright_key in ANSI_COLORS:
+                return ANSI_COLORS[bright_key]
+
+        if color in ANSI_COLORS:
+            return ANSI_COLORS[color]
+
+        # Handle hex colors with #
+        if color.startswith("#") and len(color) == 7:
+            return color
+
+    return default
+
+
+def render_terminal_to_png(
+    ansi_text: str,
+    output_path: str,
+    width: int = 120,
+    height: int = 40,
+    font_size: int = DEFAULT_FONT_SIZE,
+    padding: int = 10,
+) -> Path:
+    """Render ANSI terminal text to a PNG image.
+
+    Args:
+        ansi_text: Terminal output with ANSI escape codes
+        output_path: Path to save the PNG image
+        width: Terminal width in characters
+        height: Terminal height in characters
+        font_size: Font size in pixels
+        padding: Padding around the terminal content
+
+    Returns:
+        Path to the saved image
+    """
+    # Use a large internal buffer to prevent scrolling, then crop to actual content
+    internal_height = max(height, 200)
+    screen = pyte.Screen(width, internal_height)
+    stream = pyte.Stream(screen)
+
+    # Normalize line endings: \n -> \r\n for proper terminal emulation
+    # (terminal needs carriage return + line feed to move to start of next line)
+    normalized_text = ansi_text.replace('\r\n', '\n').replace('\n', '\r\n')
+
+    # Feed the ANSI text through the terminal emulator
+    stream.feed(normalized_text)
+
+    # Find actual content bounds (non-empty rows)
+    first_row = 0
+    last_row = internal_height - 1
+    for y in range(internal_height):
+        row_has_content = any(
+            screen.buffer[y][x].data.strip()
+            for x in range(width)
+            if hasattr(screen.buffer[y][x], 'data')
+        )
+        if row_has_content:
+            if first_row == 0:
+                first_row = y
+            last_row = y
+
+    # Use the requested height - the large internal buffer prevents scrolling,
+    # and we render from first_row for `height` rows
+    render_height = height
+
+    # Load font and calculate dimensions
+    font = _find_monospace_font(font_size)
+
+    # Get character dimensions using a test character
+    bbox = font.getbbox("M")
+    char_width = bbox[2] - bbox[0]
+    char_height = int(font_size * 1.4)  # Line height
+
+    # Calculate image dimensions based on actual content
+    img_width = width * char_width + 2 * padding
+    img_height = render_height * char_height + 2 * padding
+
+    # Create image with dark background
+    img = Image.new("RGB", (img_width, img_height), color=BG_COLOR)
+    draw = ImageDraw.Draw(img)
+
+    # Render each character from content area
+    for y in range(render_height):
+        buffer_y = first_row + y
+        if buffer_y >= internal_height:
+            break
+        for x in range(width):
+            char = screen.buffer[buffer_y][x]
+
+            # Get character and style
+            char_data = char.data if hasattr(char, "data") else str(char)
+            if not char_data or char_data == " ":
+                continue
+
+            # Get colors from character attributes
+            fg_color = DEFAULT_FG
+            bg_color = None
+
+            if hasattr(char, "fg"):
+                fg_color = _pyte_color_to_hex(
+                    char.fg, DEFAULT_FG, bright=getattr(char, "bold", False)
+                )
+            if hasattr(char, "bg") and char.bg != "default":
+                bg_color = _pyte_color_to_hex(char.bg, BG_COLOR)
+
+            # Calculate position
+            pos_x = padding + x * char_width
+            pos_y = padding + y * char_height
+
+            # Draw background if different from default
+            if bg_color and bg_color != BG_COLOR:
+                draw.rectangle(
+                    [pos_x, pos_y, pos_x + char_width, pos_y + char_height],
+                    fill=bg_color,
+                )
+
+            # Draw character
+            draw.text((pos_x, pos_y), char_data, fill=fg_color, font=font)
+
+    # Save image
+    output = Path(output_path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    img.save(output)
+
+    return output
+
+
+def render_lines_to_png(
+    lines: list[str],
+    output_path: str,
+    font_size: int = DEFAULT_FONT_SIZE,
+    padding: int = 10,
+    fg_color: str = DEFAULT_FG,
+    bg_color: str = BG_COLOR,
+) -> Path:
+    """Render plain text lines to a PNG image (no ANSI parsing).
+
+    This is a simpler alternative when you have plain text without ANSI codes.
+    """
+    font = _find_monospace_font(font_size)
+
+    # Get character dimensions
+    bbox = font.getbbox("M")
+    char_width = bbox[2] - bbox[0]
+    char_height = int(font_size * 1.4)
+
+    # Calculate dimensions
+    max_line_length = max(len(line) for line in lines) if lines else 1
+    img_width = max_line_length * char_width + 2 * padding
+    img_height = len(lines) * char_height + 2 * padding
+
+    # Create image
+    img = Image.new("RGB", (img_width, img_height), color=bg_color)
+    draw = ImageDraw.Draw(img)
+
+    # Render lines
+    for y, line in enumerate(lines):
+        pos_y = padding + y * char_height
+        draw.text((padding, pos_y), line, fill=fg_color, font=font)
+
+    # Save
+    output = Path(output_path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    img.save(output)
+
+    return output

overcode/testing/tmux_driver.py

@@ -0,0 +1,223 @@
+"""tmux session management for TUI testing."""
+
+import time
+from typing import Optional
+import libtmux
+
+
+class TUIDriver:
+    """Manages a tmux session for testing TUI applications.
+
+    This class provides a simple interface to:
+    - Start a TUI app in a tmux session with controlled dimensions
+    - Send keystrokes to the app
+    - Capture the screen content (with ANSI codes)
+    - Wait for specific content to appear
+    - Clean up the session
+    """
+
+    def __init__(
+        self,
+        session_name: str = "tui-eye",
+        socket_name: Optional[str] = None,
+    ):
+        """Initialize the TUI driver.
+
+        Args:
+            session_name: Name for the tmux session
+            socket_name: Optional tmux socket name (for isolation)
+        """
+        self.session_name = session_name
+        self.socket_name = socket_name
+        self.server: Optional[libtmux.Server] = None
+        self.session: Optional[libtmux.Session] = None
+
+    def start(
+        self,
+        command: str,
+        width: int = 120,
+        height: int = 40,
+        env: Optional[dict[str, str]] = None,
+    ) -> None:
+        """Start a TUI application in a new tmux session.
+
+        Args:
+            command: The command to run (e.g., "overcode supervisor")
+            width: Terminal width in characters
+            height: Terminal height in characters
+            env: Optional environment variables to set
+        """
+        # Kill any existing session with this name
+        self.stop()
+
+        # Create server connection
+        if self.socket_name:
+            self.server = libtmux.Server(socket_name=self.socket_name)
+        else:
+            self.server = libtmux.Server()
+
+        # Create new session
+        self.session = self.server.new_session(
+            session_name=self.session_name,
+            window_command=command,
+            x=width,
+            y=height,
+            environment=env,
+        )
+
+    def send_keys(self, *keys: str, enter: bool = False) -> None:
+        """Send keystrokes to the TUI.
+
+        Args:
+            keys: Key names to send (e.g., "j", "k", "Enter", "escape")
+            enter: Whether to send Enter after all keys
+        """
+        if not self.session:
+            self.connect()
+        if not self.session:
+            raise RuntimeError("No active session. Call start() first.")
+
+        pane = self.session.active_window.active_pane
+
+        for key in keys:
+            # Map common key names
+            key_map = {
+                "enter": "Enter",
+                "escape": "Escape",
+                "esc": "Escape",
+                "tab": "Tab",
+                "space": "Space",
+                "up": "Up",
+                "down": "Down",
+                "left": "Left",
+                "right": "Right",
+                "backspace": "BSpace",
+            }
+            mapped_key = key_map.get(key.lower(), key)
+            pane.send_keys(mapped_key, enter=False)
+
+        if enter:
+            pane.send_keys("Enter", enter=False)
+
+    def capture(self, with_ansi: bool = True) -> str:
+        """Capture the current screen content.
+
+        Args:
+            with_ansi: Whether to include ANSI escape codes
+
+        Returns:
+            The screen content as a string
+        """
+        if not self.session:
+            self.connect()
+        if not self.session:
+            raise RuntimeError("No active session. Call start() first.")
+
+        pane = self.session.active_window.active_pane
+
+        # Use capture_pane with escape sequences if requested
+        if with_ansi:
+            # -e preserves ANSI escape sequences
+            # -p prints to stdout
+            content = pane.cmd("capture-pane", "-e", "-p").stdout
+        else:
+            content = pane.cmd("capture-pane", "-p").stdout
+
+        return "\n".join(content) if isinstance(content, list) else content
+
+    def wait_for(
+        self,
+        text: str,
+        timeout: float = 10.0,
+        poll_interval: float = 0.2,
+    ) -> bool:
+        """Wait for specific text to appear on screen.
+
+        Args:
+            text: The text to wait for
+            timeout: Maximum time to wait in seconds
+            poll_interval: Time between checks in seconds
+
+        Returns:
+            True if text was found, False if timeout occurred
+        """
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            content = self.capture(with_ansi=False)
+            if text in content:
+                return True
+            time.sleep(poll_interval)
+
+        return False
+
+    def stop(self) -> None:
+        """Stop and clean up the tmux session."""
+        if self.session:
+            try:
+                self.session.kill()
+            except Exception:
+                pass
+            self.session = None
+
+        # Always try to kill by name, connecting first if needed
+        try:
+            if not self.server:
+                if self.socket_name:
+                    self.server = libtmux.Server(socket_name=self.socket_name)
+                else:
+                    self.server = libtmux.Server()
+
+            for session in self.server.sessions:
+                if session.name == self.session_name:
+                    session.kill()
+                    break
+        except Exception:
+            pass
+
+    def __enter__(self) -> "TUIDriver":
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit - ensures cleanup."""
+        self.stop()
+
+    def connect(self) -> bool:
+        """Connect to an existing tmux session.
+
+        Returns:
+            True if successfully connected, False if session doesn't exist
+        """
+        if self.socket_name:
+            self.server = libtmux.Server(socket_name=self.socket_name)
+        else:
+            self.server = libtmux.Server()
+
+        try:
+            for session in self.server.sessions:
+                if session.name == self.session_name:
+                    self.session = session
+                    return True
+        except Exception:
+            pass
+
+        return False
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the session is still running."""
+        # First try to connect if we don't have a session reference
+        if not self.session:
+            self.connect()
+
+        if not self.session:
+            return False
+
+        try:
+            # Try to access the session to verify it exists
+            _ = self.session.name
+            return True
+        except Exception:
+            self.session = None
+            return False