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

overcode/__init__.py

@@ -2,4 +2,4 @@
 Overcode - A supervisor for managing multiple Claude Code instances.
 """
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

overcode/cli.py

@@ -264,7 +264,7 @@ def instruct(
     ] = None,
     instructions: Annotated[
         Optional[List[str]],
-        typer.Argument(help="Instructions or preset name (e.g., DEFAULT, CODING)"),
+        typer.Argument(help="Instructions or preset name (e.g., DO_NOTHING, STANDARD, CODING)"),
     ] = None,
     clear: Annotated[
         bool, typer.Option("--clear", "-c", help="Clear standing instructions")
@@ -276,7 +276,7 @@ def instruct(
 ):
     """Set standing instructions for an agent.
 
-    Use a preset name (DEFAULT, CODING, TESTING, etc.) or provide custom instructions.
+    Use a preset name (DO_NOTHING, STANDARD, CODING, etc.) or provide custom instructions.
     Use --list to see all available presets.
     """
     from .session_manager import SessionManager
@@ -285,7 +285,7 @@ def instruct(
     if list_presets:
         presets_dict = load_presets()
         rprint("\n[bold]Standing Instruction Presets:[/bold]\n")
-        for preset_name in sorted(presets_dict.keys(), key=lambda x: (x != "DEFAULT", x)):
+        for preset_name in sorted(presets_dict.keys(), key=lambda x: (x != "DO_NOTHING", x)):
             preset = presets_dict[preset_name]
             rprint(f"  [cyan]{preset_name:12}[/cyan] {preset.description}")
         rprint("\n[dim]Usage: overcode instruct <agent> <PRESET>[/dim]")
@@ -405,6 +405,45 @@ def serve(
     run_server(host=host, port=port, tmux_session=session)
 
 
+@app.command()
+def web(
+    host: Annotated[
+        str, typer.Option("--host", "-h", help="Host to bind to")
+    ] = "127.0.0.1",
+    port: Annotated[
+        int, typer.Option("--port", "-p", help="Port to listen on")
+    ] = 8080,
+):
+    """Launch analytics web dashboard for browsing historical data.
+
+    A lightweight web app for exploring session history, timeline
+    visualization, and efficiency metrics. Uses Chart.js for
+    interactive charts with dark theme matching the TUI.
+
+    Features:
+        - Dashboard with summary stats and daily activity charts
+        - Session browser with sortable table
+        - Timeline view with agent status and user presence
+        - Efficiency metrics with cost analysis
+
+    Time range presets can be configured in ~/.overcode/config.yaml:
+
+        web:
+          time_presets:
+            - name: "Morning"
+              start: "09:00"
+              end: "12:00"
+
+    Examples:
+        overcode web                    # Start on localhost:8080
+        overcode web --port 3000        # Custom port
+        overcode web --host 0.0.0.0     # Listen on all interfaces
+    """
+    from .web_server import run_analytics_server
+
+    run_analytics_server(host=host, port=port)
+
+
 
 
 @app.command()

overcode/config.py

@@ -70,3 +70,52 @@ def get_relay_config() -> Optional[dict]:
         "api_key": api_key,
         "interval": relay.get("interval", 30),
     }
+
+
+def get_web_time_presets() -> list:
+    """Get time presets for the web analytics dashboard.
+
+    Returns list of preset dictionaries with name, start, end times.
+    Falls back to defaults if not configured.
+
+    Config format in ~/.overcode/config.yaml:
+        web:
+          time_presets:
+            - name: "Morning"
+              start: "09:00"
+              end: "12:00"
+            - name: "Full Day"
+              start: "09:00"
+              end: "17:00"
+            - name: "Night Owl"
+              start: "22:00"
+              end: "02:00"
+    """
+    config = load_config()
+    web_config = config.get("web", {})
+    presets = web_config.get("time_presets", None)
+
+    if presets and isinstance(presets, list):
+        # Validate and normalize presets
+        valid_presets = []
+        for p in presets:
+            if isinstance(p, dict) and "name" in p:
+                valid_presets.append({
+                    "name": p.get("name", ""),
+                    "start": p.get("start"),
+                    "end": p.get("end"),
+                })
+        if valid_presets:
+            # Always add "All Time" at the end
+            if not any(p["name"] == "All Time" for p in valid_presets):
+                valid_presets.append({"name": "All Time", "start": None, "end": None})
+            return valid_presets
+
+    # Default presets
+    return [
+        {"name": "Morning", "start": "09:00", "end": "12:00"},
+        {"name": "Afternoon", "start": "13:00", "end": "17:00"},
+        {"name": "Full Day", "start": "09:00", "end": "17:00"},
+        {"name": "Evening", "start": "18:00", "end": "22:00"},
+        {"name": "All Time", "start": None, "end": None},
+    ]

overcode/daemon_logging.py

@@ -0,0 +1,144 @@
+"""
+Shared logging utilities for Overcode daemons.
+
+Provides base logger class with common functionality for both
+monitor_daemon and supervisor_daemon.
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from rich.console import Console
+from rich.text import Text
+from rich.theme import Theme
+
+
+# Shared theme for daemon logs
+DAEMON_THEME = Theme({
+    "info": "cyan",
+    "warn": "yellow",
+    "error": "bold red",
+    "success": "bold green",
+    "daemon_claude": "magenta",
+    "dim": "dim white",
+    "highlight": "bold white",
+})
+
+
+class BaseDaemonLogger:
+    """Base logger for daemons with common logging methods."""
+
+    def __init__(self, log_file: Path, theme: Theme = None):
+        """Initialize the logger.
+
+        Args:
+            log_file: Path to the log file
+            theme: Optional Rich theme (defaults to DAEMON_THEME)
+        """
+        self.log_file = log_file
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+        self.console = Console(theme=theme or DAEMON_THEME, force_terminal=True)
+
+    def _write_to_file(self, message: str, level: str = "INFO"):
+        """Write plain text to log file."""
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        line = f"[{timestamp}] [{level}] {message}"
+        try:
+            with open(self.log_file, 'a') as f:
+                f.write(line + '\n')
+        except OSError:
+            pass
+
+    def _log(self, style: str, prefix: str, message: str, level: str = "INFO"):
+        """Log a message with style to both console and file."""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        text = Text()
+        text.append(f"[{timestamp}] ", style="dim")
+        text.append(f"{prefix} ", style=style)
+        text.append(message)
+        self.console.print(text)
+        self._write_to_file(message, level)
+
+    def info(self, message: str):
+        """Log info message."""
+        self._log("info", "●", message, "INFO")
+
+    def warn(self, message: str):
+        """Log warning message."""
+        self._log("warn", "⚠", message, "WARN")
+
+    def error(self, message: str):
+        """Log error message."""
+        self._log("error", "✗", message, "ERROR")
+
+    def success(self, message: str):
+        """Log success message."""
+        self._log("success", "✓", message, "INFO")
+
+    def debug(self, message: str):
+        """Log a debug message (only to file, not console)."""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        try:
+            with open(self.log_file, 'a') as f:
+                f.write(f"[{timestamp}] DEBUG {message}\n")
+        except OSError:
+            pass
+
+    def section(self, title: str):
+        """Print a section header."""
+        self._write_to_file(f"=== {title} ===", "INFO")
+        self.console.print()
+        self.console.rule(f"[bold cyan]{title}[/]")
+
+
+class SupervisorDaemonLogger(BaseDaemonLogger):
+    """Logger for supervisor daemon with additional methods."""
+
+    def __init__(self, log_file: Path):
+        super().__init__(log_file)
+        self._seen_daemon_claude_lines: set = set()
+
+    def daemon_claude_output(self, lines: List[str]):
+        """Log daemon claude output, showing only new lines."""
+        new_lines = []
+
+        for line in lines:
+            stripped = line.strip()
+            if not stripped:
+                continue
+            if stripped not in self._seen_daemon_claude_lines:
+                new_lines.append(stripped)
+                self._seen_daemon_claude_lines.add(stripped)
+
+        # Limit set size
+        if len(self._seen_daemon_claude_lines) > 500:
+            current_lines = {line.strip() for line in lines if line.strip()}
+            self._seen_daemon_claude_lines = current_lines
+
+        if new_lines:
+            for line in new_lines:
+                self._write_to_file(f"[DAEMON_CLAUDE] {line}", "INFO")
+                if line.startswith('✓') or 'success' in line.lower():
+                    self.console.print(f"  [success]│[/success] {line}")
+                elif line.startswith('✗') or 'error' in line.lower() or 'fail' in line.lower():
+                    self.console.print(f"  [error]│[/error] {line}")
+                elif line.startswith('>') or line.startswith('$'):
+                    self.console.print(f"  [highlight]│[/highlight] {line}")
+                else:
+                    self.console.print(f"  [daemon_claude]│[/daemon_claude] {line}")
+
+    def status_summary(self, total: int, green: int, non_green: int, loop: int):
+        """Print a status summary line."""
+        status_text = Text()
+        status_text.append(f"Loop #{loop}: ", style="dim")
+        status_text.append(f"{total} agents ", style="highlight")
+        status_text.append("(", style="dim")
+        status_text.append(f"{green} green", style="success")
+        status_text.append(", ", style="dim")
+        status_text.append(f"{non_green} non-green", style="warn" if non_green else "dim")
+        status_text.append(")", style="dim")
+
+        self._write_to_file(f"Loop #{loop}: {total} agents ({green} green, {non_green} non-green)", "INFO")
+        self.console.print(f"[dim]{datetime.now().strftime('%H:%M:%S')}[/dim] ", end="")
+        self.console.print(status_text)

overcode/daemon_utils.py

@@ -0,0 +1,84 @@
+"""
+Shared utilities for Overcode daemons.
+
+Provides factory functions for creating daemon PID management helpers,
+avoiding code duplication between monitor_daemon and supervisor_daemon.
+"""
+
+import os
+import signal
+from pathlib import Path
+from typing import Callable, Optional, Tuple
+
+from .pid_utils import (
+    get_process_pid,
+    is_process_running,
+    remove_pid_file,
+)
+from .settings import DAEMON
+
+
+def create_daemon_helpers(
+    get_pid_path: Callable[[str], Path],
+    daemon_name: str,
+) -> Tuple[
+    Callable[[Optional[str]], bool],
+    Callable[[Optional[str]], Optional[int]],
+    Callable[[Optional[str]], bool],
+]:
+    """Factory to create is_*_running, get_*_pid, stop_* functions for a daemon.
+
+    Args:
+        get_pid_path: Function that takes session name and returns PID file path
+        daemon_name: Human-readable name for error messages
+
+    Returns:
+        Tuple of (is_running_fn, get_pid_fn, stop_fn)
+    """
+
+    def is_running(session: str = None) -> bool:
+        """Check if the daemon process is currently running for a session.
+
+        Args:
+            session: tmux session name (default: from config)
+        """
+        if session is None:
+            session = DAEMON.default_tmux_session
+        return is_process_running(get_pid_path(session))
+
+    def get_pid(session: str = None) -> Optional[int]:
+        """Get the daemon PID if running, None otherwise.
+
+        Args:
+            session: tmux session name (default: from config)
+        """
+        if session is None:
+            session = DAEMON.default_tmux_session
+        return get_process_pid(get_pid_path(session))
+
+    def stop(session: str = None) -> bool:
+        """Stop the daemon process if running.
+
+        Args:
+            session: tmux session name (default: from config)
+
+        Returns:
+            True if daemon was stopped, False if it wasn't running.
+        """
+        if session is None:
+            session = DAEMON.default_tmux_session
+        pid_path = get_pid_path(session)
+        pid = get_process_pid(pid_path)
+        if pid is None:
+            remove_pid_file(pid_path)
+            return False
+
+        try:
+            os.kill(pid, signal.SIGTERM)
+            remove_pid_file(pid_path)
+            return True
+        except (OSError, ProcessLookupError):
+            remove_pid_file(pid_path)
+            return False
+
+    return is_running, get_pid, stop

overcode/history_reader.py

@@ -39,6 +39,7 @@ class ClaudeSessionStats:
     cache_creation_tokens: int
     cache_read_tokens: int
     work_times: List[float]  # seconds per work cycle (prompt to next prompt)
+    current_context_tokens: int = 0  # Most recent input_tokens (current context size)
 
     @property
     def total_tokens(self) -> int:
@@ -249,13 +250,15 @@ def read_token_usage_from_session_file(
         since: Only count tokens from messages after this time
 
     Returns:
-        Dict with input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens
+        Dict with input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+        and current_context_tokens (most recent input_tokens value)
     """
     totals = {
         "input_tokens": 0,
         "output_tokens": 0,
         "cache_creation_tokens": 0,
         "cache_read_tokens": 0,
+        "current_context_tokens": 0,  # Most recent input_tokens
     }
 
     if not session_file.exists():
@@ -288,14 +291,18 @@ def read_token_usage_from_session_file(
                         message = data.get("message", {})
                         usage = message.get("usage", {})
                         if usage:
-                            totals["input_tokens"] += usage.get("input_tokens", 0)
+                            input_tokens = usage.get("input_tokens", 0)
+                            cache_read = usage.get("cache_read_input_tokens", 0)
+                            totals["input_tokens"] += input_tokens
                             totals["output_tokens"] += usage.get("output_tokens", 0)
                             totals["cache_creation_tokens"] += usage.get(
                                 "cache_creation_input_tokens", 0
                             )
-                            totals["cache_read_tokens"] += usage.get(
-                                "cache_read_input_tokens", 0
-                            )
+                            totals["cache_read_tokens"] += cache_read
+                            # Track most recent context size (input + cached context)
+                            context_size = input_tokens + cache_read
+                            if context_size > 0:
+                                totals["current_context_tokens"] = context_size
                 except (json.JSONDecodeError, KeyError, TypeError):
                     continue
     except IOError:
@@ -422,6 +429,7 @@ def get_session_stats(
     total_output = 0
     total_cache_creation = 0
     total_cache_read = 0
+    current_context = 0  # Track most recent context size
     all_work_times: List[float] = []
 
     for sid in session_ids:
@@ -433,6 +441,9 @@ def get_session_stats(
         total_output += usage["output_tokens"]
         total_cache_creation += usage["cache_creation_tokens"]
         total_cache_read += usage["cache_read_tokens"]
+        # Keep the largest current context (most recent across all session files)
+        if usage["current_context_tokens"] > current_context:
+            current_context = usage["current_context_tokens"]
 
         # Collect work times from this session file
         work_times = read_work_times_from_session_file(session_file, since=session_start)
@@ -445,4 +456,5 @@ def get_session_stats(
         cache_creation_tokens=total_cache_creation,
         cache_read_tokens=total_cache_read,
         work_times=all_work_times,
+        current_context_tokens=current_context,
     )

overcode/implementations.py

@@ -142,6 +142,17 @@ class RealTmux:
     def attach(self, session: str) -> None:
         os.execlp("tmux", "tmux", "attach-session", "-t", session)
 
+    def select_window(self, session: str, window: int) -> bool:
+        """Select a window in a tmux session (for external pane sync)."""
+        try:
+            result = subprocess.run(
+                ["tmux", "select-window", "-t", f"{session}:{window}"],
+                capture_output=True, timeout=5
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            return False
+
 
 class RealFileSystem:
     """Production implementation of FileSystemInterface"""

overcode/launcher.py

@@ -4,6 +4,9 @@ Launcher for interactive Claude Code sessions in tmux windows.
 All Claude sessions launched by overcode are interactive - users can
 take over at any time. Initial prompts are sent as keystrokes after
 Claude starts, not as CLI arguments.
+
+TODO: Extract _send_prompt_to_window to a shared tmux utilities module
+(duplicated in supervisor_daemon.py)
 """
 
 import time

overcode/mocks.py

@@ -77,6 +77,10 @@ class MockTmux:
     def attach(self, session: str) -> None:
         pass  # No-op in tests
 
+    def select_window(self, session: str, window: int) -> bool:
+        """Select a window - no-op in tests, just return True."""
+        return session in self.sessions
+
 
 class MockFileSystem:
     """Mock implementation of FileSystemInterface for testing"""

overcode/monitor_daemon.py

@@ -16,6 +16,8 @@ This separation ensures:
 - No duplicate time tracking between TUI and daemon
 - Clean interface contract via MonitorDaemonState
 - Platform-agnostic core (presence is optional)
+
+TODO: Add unit tests (currently 0% coverage)
 """
 
 import os
@@ -26,10 +28,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from rich.console import Console
-from rich.text import Text
-from rich.theme import Theme
-
+from .daemon_logging import BaseDaemonLogger
+from .daemon_utils import create_daemon_helpers
 from .history_reader import get_session_stats
 from .monitor_daemon_state import (
     MonitorDaemonState,
@@ -38,10 +38,7 @@ from .monitor_daemon_state import (
 )
 from .pid_utils import (
     acquire_daemon_lock,
-    get_process_pid,
-    is_process_running,
     remove_pid_file,
-    write_pid_file,
 )
 from .session_manager import SessionManager
 from .settings import (
@@ -83,51 +80,12 @@ INTERVAL_SLOW = DAEMON.interval_slow    # When all agents need user input
 INTERVAL_IDLE = DAEMON.interval_idle    # When no agents at all
 
 
-def is_monitor_daemon_running(session: str = None) -> bool:
-    """Check if the monitor daemon process is currently running for a session.
-
-    Args:
-        session: tmux session name (default: from config)
-    """
-    if session is None:
-        session = DAEMON.default_tmux_session
-    return is_process_running(get_monitor_daemon_pid_path(session))
-
-
-def get_monitor_daemon_pid(session: str = None) -> Optional[int]:
-    """Get the monitor daemon PID if running, None otherwise.
-
-    Args:
-        session: tmux session name (default: from config)
-    """
-    if session is None:
-        session = DAEMON.default_tmux_session
-    return get_process_pid(get_monitor_daemon_pid_path(session))
-
-
-def stop_monitor_daemon(session: str = None) -> bool:
-    """Stop the monitor daemon process if running.
-
-    Args:
-        session: tmux session name (default: from config)
-
-    Returns True if daemon was stopped, False if it wasn't running.
-    """
-    if session is None:
-        session = DAEMON.default_tmux_session
-    pid_path = get_monitor_daemon_pid_path(session)
-    pid = get_process_pid(pid_path)
-    if pid is None:
-        remove_pid_file(pid_path)
-        return False
-
-    try:
-        os.kill(pid, signal.SIGTERM)
-        remove_pid_file(pid_path)
-        return True
-    except (OSError, ProcessLookupError):
-        remove_pid_file(pid_path)
-        return False
+# Create PID helper functions using factory
+(
+    is_monitor_daemon_running,
+    get_monitor_daemon_pid,
+    stop_monitor_daemon,
+) = create_daemon_helpers(get_monitor_daemon_pid_path, "monitor")
 
 
 def check_activity_signal(session: str = None) -> bool:
@@ -151,71 +109,12 @@ def check_activity_signal(session: str = None) -> bool:
         return False
 
 
-# Rich theme for daemon logs
-MONITOR_THEME = Theme({
-    "info": "cyan",
-    "warn": "yellow",
-    "error": "bold red",
-    "success": "bold green",
-    "dim": "dim white",
-    "highlight": "bold white",
-})
-
-
-class MonitorDaemonLogger:
-    """Simple logger for monitor daemon."""
-
-    def __init__(self, session: str = "agents", log_file: Optional[Path] = None):
-        self.console = Console(theme=MONITOR_THEME, force_terminal=True)
-        # Use session-specific log file
-        if log_file:
-            self.log_file = log_file
-        else:
-            session_dir = ensure_session_dir(session)
-            self.log_file = session_dir / "monitor_daemon.log"
-        self._logged_messages: set = set()
-
-    def _log(self, style: str, prefix: str, message: str):
-        """Log a message with style."""
-        timestamp = datetime.now().strftime("%H:%M:%S")
-        text = Text()
-        text.append(f"[{timestamp}] ", style="dim")
-        text.append(f"{prefix} ", style=style)
-        text.append(message)
-        self.console.print(text)
-
-        # Also log to file
-        try:
-            with open(self.log_file, 'a') as f:
-                f.write(f"[{timestamp}] {prefix} {message}\n")
-        except OSError:
-            pass
-
-    def info(self, message: str):
-        self._log("info", "●", message)
-
-    def warn(self, message: str):
-        self._log("warn", "⚠", message)
-
-    def error(self, message: str):
-        self._log("error", "✗", message)
-
-    def success(self, message: str):
-        self._log("success", "✓", message)
-
-    def debug(self, message: str):
-        """Log a debug message (only to file, not console)."""
-        timestamp = datetime.now().strftime("%H:%M:%S")
-        try:
-            with open(self.log_file, 'a') as f:
-                f.write(f"[{timestamp}] DEBUG {message}\n")
-        except OSError:
-            pass
-
-    def section(self, title: str):
-        """Print a section header."""
-        self.console.print()
-        self.console.rule(f"[bold cyan]{title}[/]")
+def _create_monitor_logger(session: str = "agents", log_file: Optional[Path] = None) -> BaseDaemonLogger:
+    """Create a logger for the monitor daemon."""
+    if log_file is None:
+        session_dir = ensure_session_dir(session)
+        log_file = session_dir / "monitor_daemon.log"
+    return BaseDaemonLogger(log_file)
 
 
 class PresenceComponent:
@@ -295,7 +194,7 @@ class MonitorDaemon:
         )
 
         # Logging - session-specific log file
-        self.log = MonitorDaemonLogger(session=tmux_session)
+        self.log = _create_monitor_logger(session=tmux_session)
 
         # State tracking
         self.state = MonitorDaemonState(
@@ -527,13 +426,13 @@ class MonitorDaemon:
         return sorted_times[n // 2]
 
     def calculate_interval(self, sessions: list, all_waiting_user: bool) -> int:
-        """Calculate appropriate loop interval."""
-        if not sessions:
-            return INTERVAL_IDLE
-
-        if all_waiting_user:
-            return INTERVAL_SLOW
+        """Calculate appropriate loop interval.
 
+        The monitor daemon always uses a fixed 10s interval to maintain
+        high-resolution monitoring data. Variable frequency logic is only
+        used by the supervisor daemon.
+        """
+        # Always use fast interval for consistent monitoring resolution
         return INTERVAL_FAST
 
     def _interruptible_sleep(self, total_seconds: int) -> None:
@@ -715,8 +614,8 @@ class MonitorDaemon:
                     session_state.current_activity = activity
                     session_states.append(session_state)
 
-                    # Log status history
-                    log_agent_status(session.name, status, activity)
+                    # Log status history to session-specific file
+                    log_agent_status(session.name, status, activity, history_file=self.history_path)
 
                     # Track if any session is not waiting for user
                     if status != "waiting_user":