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

overcode/settings.py

@@ -216,6 +216,12 @@ class UserConfig:
     default_standing_instructions: str = ""
     tmux_session: str = "agents"
 
+    # Token pricing (per million tokens) - defaults to Opus 4.5
+    price_input: float = 5.0        # $/MTok for input tokens
+    price_output: float = 25.0      # $/MTok for output tokens
+    price_cache_write: float = 6.25  # $/MTok for cache creation
+    price_cache_read: float = 0.50   # $/MTok for cache reads
+
     @classmethod
     def load(cls) -> "UserConfig":
         """Load configuration from config file."""
@@ -230,11 +236,18 @@ class UserConfig:
                 if not isinstance(data, dict):
                     return cls()
 
+                # Load pricing config (nested under 'pricing' key)
+                pricing = data.get("pricing", {})
+
                 return cls(
                     default_standing_instructions=data.get(
                         "default_standing_instructions", ""
                     ),
                     tmux_session=data.get("tmux_session", "agents"),
+                    price_input=pricing.get("input", 5.0),
+                    price_output=pricing.get("output", 25.0),
+                    price_cache_write=pricing.get("cache_write", 6.25),
+                    price_cache_read=pricing.get("cache_read", 0.50),
                 )
         except (yaml.YAMLError, IOError):
             return cls()
@@ -384,6 +397,9 @@ class TUIPreferences:
     hide_asleep: bool = False  # hide sleeping agents from display
     sort_mode: str = "alphabetical"  # alphabetical, by_status, by_value (#61)
     summary_content_mode: str = "ai_short"  # ai_short, ai_long, orders, annotation (#98)
+    baseline_minutes: int = 60  # 0=now (instantaneous), 15/30/.../180 = minutes back for mean spin
+    monochrome: bool = False  # B&W mode for terminals with ANSI issues (#138)
+    show_cost: bool = False  # Show $ cost instead of token counts
     # Session IDs of stalled agents that have been visited by the user
     visited_stalled_agents: Set[str] = field(default_factory=set)
 
@@ -413,6 +429,9 @@ class TUIPreferences:
                     hide_asleep=data.get("hide_asleep", False),
                     sort_mode=data.get("sort_mode", "alphabetical"),
                     summary_content_mode=data.get("summary_content_mode", "ai_short"),
+                    baseline_minutes=data.get("baseline_minutes", 0),
+                    monochrome=data.get("monochrome", False),
+                    show_cost=data.get("show_cost", False),
                     visited_stalled_agents=set(data.get("visited_stalled_agents", [])),
                 )
         except (json.JSONDecodeError, IOError):
@@ -437,6 +456,9 @@ class TUIPreferences:
                     "hide_asleep": self.hide_asleep,
                     "sort_mode": self.sort_mode,
                     "summary_content_mode": self.summary_content_mode,
+                    "baseline_minutes": self.baseline_minutes,
+                    "monochrome": self.monochrome,
+                    "show_cost": self.show_cost,
                     "visited_stalled_agents": list(self.visited_stalled_agents),
                 }, f, indent=2)
         except (IOError, OSError):

overcode/supervisor_daemon.py

@@ -16,7 +16,7 @@ Prerequisites:
 Architecture:
     Monitor Daemon (metrics) → monitor_daemon_state.json → Supervisor Daemon (claude)
 
-TODO: Add unit tests (currently 0% coverage)
+Pure business logic is extracted to supervisor_daemon_core.py for testability.
 TODO: Extract _send_prompt_to_window to a shared tmux utilities module
 (duplicated in launcher.py)
 """
@@ -60,6 +60,13 @@ from .status_constants import (
 )
 from .tmux_manager import TmuxManager
 from .history_reader import encode_project_path, read_token_usage_from_session_file
+from .supervisor_daemon_core import (
+    build_daemon_claude_context as _build_daemon_claude_context,
+    filter_non_green_sessions,
+    calculate_daemon_claude_run_seconds,
+    should_launch_daemon_claude,
+    parse_intervention_log_line,
+)
 
 
 @dataclass
@@ -473,14 +480,14 @@ class SupervisorDaemon:
     def _mark_daemon_claude_stopped(self) -> None:
         """Mark daemon claude as stopped and accumulate run time."""
         if self.supervisor_stats.supervisor_claude_running:
-            # Calculate run duration
-            if self.supervisor_stats.supervisor_claude_started_at:
-                try:
-                    started_at = datetime.fromisoformat(self.supervisor_stats.supervisor_claude_started_at)
-                    run_seconds = (datetime.now() - started_at).total_seconds()
-                    self.supervisor_stats.supervisor_claude_total_run_seconds += run_seconds
-                except (ValueError, TypeError):
-                    pass
+            # Calculate total run time using pure function
+            self.supervisor_stats.supervisor_claude_total_run_seconds = (
+                calculate_daemon_claude_run_seconds(
+                    started_at_iso=self.supervisor_stats.supervisor_claude_started_at,
+                    now_iso=datetime.now().isoformat(),
+                    previous_total=self.supervisor_stats.supervisor_claude_total_run_seconds,
+                )
+            )
 
             self.supervisor_stats.supervisor_claude_running = False
             self.supervisor_stats.supervisor_claude_started_at = None
@@ -555,31 +562,18 @@ class SupervisorDaemon:
         non_green_sessions: List[SessionDaemonState]
     ) -> str:
         """Build initial context 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: {self.tmux_session}")
-        context_parts.append(f"Sessions needing attention: {len(non_green_sessions)}")
-        context_parts.append("")
-
-        for session in non_green_sessions:
-            emoji = get_status_emoji(session.current_status)
-            context_parts.append(f"{emoji} {session.name} (window {session.tmux_window})")
-            if session.standing_instructions:
-                context_parts.append(f"   Autopilot: {session.standing_instructions}")
-            else:
-                context_parts.append(f"   No autopilot instructions set")
-            if session.repo_name:
-                context_parts.append(f"   Repo: {session.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)
+        # Convert dataclass objects to dicts for pure function
+        session_dicts = [
+            {
+                "name": s.name,
+                "tmux_window": s.tmux_window,
+                "current_status": s.current_status,
+                "standing_instructions": s.standing_instructions,
+                "repo_name": s.repo_name,
+            }
+            for s in non_green_sessions
+        ]
+        return _build_daemon_claude_context(self.tmux_session, session_dicts)
 
     def _send_prompt_to_window(self, window_index: int, prompt: str) -> bool:
         """Send a large prompt to a tmux window via load-buffer/paste-buffer."""
@@ -686,19 +680,26 @@ class SupervisorDaemon:
         - Asleep sessions (#70)
         - Sessions with DO_NOTHING standing orders (#70)
         """
-        result = []
-        for s in monitor_state.sessions:
-            # Skip green sessions and daemon_claude
-            if s.current_status == STATUS_RUNNING or s.name == 'daemon_claude':
-                continue
-            # Skip asleep sessions
-            if s.is_asleep:
-                continue
-            # Skip sessions with DO_NOTHING standing orders
-            if s.standing_instructions and 'DO_NOTHING' in s.standing_instructions.upper():
-                continue
-            result.append(s)
-        return result
+        # Convert to dicts for pure function
+        session_dicts = [
+            {
+                "name": s.name,
+                "current_status": s.current_status,
+                "is_asleep": s.is_asleep,
+                "standing_instructions": s.standing_instructions,
+                "_session": s,  # Keep reference to original
+            }
+            for s in monitor_state.sessions
+        ]
+
+        # Filter using pure function
+        filtered = filter_non_green_sessions(
+            session_dicts,
+            exclude_names=["daemon_claude"],
+        )
+
+        # Return original SessionDaemonState objects
+        return [d["_session"] for d in filtered]
 
     def wait_for_monitor_daemon(self, timeout: int = 30, poll_interval: int = 2) -> bool:
         """Wait for monitor daemon to be running.

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