overcode 0.1.0__tar.gz → 0.1.2__tar.gz

{overcode-0.1.0/src/overcode.egg-info → overcode-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.1.0
+Version: 0.1.2
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode
@@ -43,6 +43,18 @@ A TUI supervisor for managing multiple Claude Code agents in tmux.
 
 Monitor status, costs, and activity across all your agents from a single dashboard.
 
+## Screenshots
+
+**Split-screen with tmux sync** - Monitor agents in the top pane while viewing live agent output below. Press `p` to enable pane sync, then navigate with `j/k` to switch the bottom pane to the selected agent's window.
+
+![Overcode split-screen with tmux sync](docs/images/overcode-split-screen.png)
+
+> **iTerm2 setup**: Use `Cmd+Shift+D` to split horizontally. Run `overcode monitor` in the top pane and `tmux attach -t agents` in the bottom pane.
+
+**Preview mode** - Press `m` to toggle List+Preview mode. Shows collapsed agent list with detailed terminal output preview for the selected agent.
+
+![Overcode preview mode](docs/images/overcode-preview-mode.png)
+
 ## Installation
 
 ```bash

{overcode-0.1.0 → overcode-0.1.2}/README.md

@@ -4,6 +4,18 @@ A TUI supervisor for managing multiple Claude Code agents in tmux.
 
 Monitor status, costs, and activity across all your agents from a single dashboard.
 
+## Screenshots
+
+**Split-screen with tmux sync** - Monitor agents in the top pane while viewing live agent output below. Press `p` to enable pane sync, then navigate with `j/k` to switch the bottom pane to the selected agent's window.
+
+![Overcode split-screen with tmux sync](docs/images/overcode-split-screen.png)
+
+> **iTerm2 setup**: Use `Cmd+Shift+D` to split horizontally. Run `overcode monitor` in the top pane and `tmux attach -t agents` in the bottom pane.
+
+**Preview mode** - Press `m` to toggle List+Preview mode. Shows collapsed agent list with detailed terminal output preview for the selected agent.
+
+![Overcode preview mode](docs/images/overcode-preview-mode.png)
+
 ## Installation
 
 ```bash

{overcode-0.1.0 → overcode-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overcode"
-version = "0.1.0"
+version = "0.1.2"
 description = "A supervisor for managing multiple Claude Code instances in tmux"
 authors = [
     {name = "Mike Bond"}

{overcode-0.1.0 → overcode-0.1.2}/src/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-0.1.0 → overcode-0.1.2}/src/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-0.1.0 → overcode-0.1.2}/src/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-0.1.2/src/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-0.1.2/src/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-0.1.0 → overcode-0.1.2}/src/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-0.1.0 → overcode-0.1.2}/src/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-0.1.0 → overcode-0.1.2}/src/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-0.1.0 → overcode-0.1.2}/src/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"""