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

overcode/implementations.py

@@ -1,142 +1,233 @@
 """
 Real implementations of protocol interfaces.
 
-These are production implementations that make actual subprocess calls
-to tmux, perform real file I/O, etc.
+These are production implementations that use libtmux for tmux operations
+and perform real file I/O.
 """
 
 import json
-import subprocess
 import os
 import time
 from pathlib import Path
 from typing import Optional, List, Dict, Any
 
+import libtmux
+from libtmux.exc import LibTmuxException
+from libtmux._internal.query_list import ObjectDoesNotExist
+
 
 class RealTmux:
-    """Production implementation of TmuxInterface using subprocess"""
+    """Production implementation of TmuxInterface using libtmux.
+
+    Includes caching to reduce subprocess overhead. libtmux spawns a new
+    subprocess for every tmux command, which is expensive at high frequencies.
+    """
+
+    # Cache TTL in seconds - pane objects rarely change
+    _CACHE_TTL = 30.0
+
+    def __init__(self, socket_name: Optional[str] = None):
+        """Initialize with optional socket name for test isolation.
+
+        If no socket_name is provided, checks OVERCODE_TMUX_SOCKET env var.
+        """
+        # Support OVERCODE_TMUX_SOCKET env var for testing
+        self._socket_name = socket_name or os.environ.get("OVERCODE_TMUX_SOCKET")
+        self._server: Optional[libtmux.Server] = None
+        # Cache: (session_name, window_index) -> (pane, timestamp)
+        self._pane_cache: Dict[tuple, tuple] = {}
+        # Cache: session_name -> (session_obj, timestamp)
+        self._session_cache: Dict[str, tuple] = {}
+
+    @property
+    def server(self) -> libtmux.Server:
+        """Lazy-load the tmux server connection."""
+        if self._server is None:
+            if self._socket_name:
+                self._server = libtmux.Server(socket_name=self._socket_name)
+            else:
+                self._server = libtmux.Server()
+        return self._server
+
+    def _get_session(self, session: str) -> Optional[libtmux.Session]:
+        """Get a session by name, with caching."""
+        now = time.time()
+        if session in self._session_cache:
+            cached_session, cached_time = self._session_cache[session]
+            if now - cached_time < self._CACHE_TTL:
+                return cached_session
 
-    def capture_pane(self, session: str, window: int, lines: int = 100) -> Optional[str]:
         try:
-            result = subprocess.run(
-                ["tmux", "capture-pane", "-t", f"{session}:{window}",
-                 "-p", "-S", f"-{lines}"],
-                capture_output=True, text=True, timeout=5
-            )
-            if result.returncode == 0:
-                return result.stdout
+            sess = self.server.sessions.get(session_name=session)
+            self._session_cache[session] = (sess, now)
+            return sess
+        except (LibTmuxException, ObjectDoesNotExist):
             return None
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+
+    def _get_window(self, session: str, window: int) -> Optional[libtmux.Window]:
+        """Get a window by session name and window index."""
+        sess = self._get_session(session)
+        if sess is None:
+            return None
+        try:
+            return sess.windows.get(window_index=str(window))
+        except (LibTmuxException, ObjectDoesNotExist):
+            return None
+
+    def _get_pane(self, session: str, window: int) -> Optional[libtmux.Pane]:
+        """Get the first pane of a window, with caching."""
+        cache_key = (session, window)
+        now = time.time()
+
+        # Check cache first
+        if cache_key in self._pane_cache:
+            cached_pane, cached_time = self._pane_cache[cache_key]
+            if now - cached_time < self._CACHE_TTL:
+                return cached_pane
+
+        # Cache miss - fetch from tmux
+        win = self._get_window(session, window)
+        if win is None or not win.panes:
+            return None
+        pane = win.panes[0]
+        self._pane_cache[cache_key] = (pane, now)
+        return pane
+
+    def invalidate_cache(self, session: str = None, window: int = None) -> None:
+        """Invalidate cached objects.
+
+        Args:
+            session: If provided, invalidate only this session's cache
+            window: If provided with session, invalidate only this window's pane
+        """
+        if session is None:
+            self._pane_cache.clear()
+            self._session_cache.clear()
+        elif window is not None:
+            self._pane_cache.pop((session, window), None)
+        else:
+            self._session_cache.pop(session, None)
+            # Remove all panes for this session
+            keys_to_remove = [k for k in self._pane_cache if k[0] == session]
+            for k in keys_to_remove:
+                del self._pane_cache[k]
+
+    def capture_pane(self, session: str, window: int, lines: int = 100) -> Optional[str]:
+        try:
+            pane = self._get_pane(session, window)
+            if pane is None:
+                return None
+            # capture_pane returns list of lines
+            # escape_sequences=True preserves ANSI color codes for TUI rendering
+            captured = pane.capture_pane(start=-lines, escape_sequences=True)
+            if isinstance(captured, list):
+                return '\n'.join(captured)
+            return captured
+        except LibTmuxException:
+            # Pane may have been killed - invalidate cache and retry once
+            self.invalidate_cache(session, window)
             return None
 
     def send_keys(self, session: str, window: int, keys: str, enter: bool = True) -> bool:
         try:
+            pane = self._get_pane(session, window)
+            if pane is None:
+                return False
+
             # For Claude Code: text and Enter must be sent as SEPARATE commands
             # with a small delay, otherwise Claude Code doesn't process the Enter.
-            target = f"{session}:{window}"
-
-            # Send text first (if any)
             if keys:
-                result = subprocess.run(
-                    ["tmux", "send-keys", "-t", target, keys],
-                    timeout=5, capture_output=True
-                )
-                if result.returncode != 0:
-                    return False
-                # Small delay for Claude Code to process text
-                time.sleep(0.1)
-
-            # Send Enter separately
+                # Special handling for ! commands (#139)
+                # Claude Code requires ! to be sent separately to trigger mode switch
+                # to bash mode before receiving the rest of the command
+                if keys.startswith('!') and len(keys) > 1:
+                    # Send ! first
+                    pane.send_keys('!', enter=False)
+                    # Wait for mode switch to process
+                    time.sleep(0.15)
+                    # Send the rest (without the !)
+                    rest = keys[1:]
+                    if rest:
+                        pane.send_keys(rest, enter=False)
+                        time.sleep(0.1)
+                else:
+                    pane.send_keys(keys, enter=False)
+                    # Small delay for Claude Code to process text
+                    time.sleep(0.1)
+
             if enter:
-                result = subprocess.run(
-                    ["tmux", "send-keys", "-t", target, "Enter"],
-                    timeout=5, capture_output=True
-                )
-                if result.returncode != 0:
-                    return False
+                pane.send_keys('', enter=True)
 
             return True
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+        except LibTmuxException:
             return False
 
     def has_session(self, session: str) -> bool:
         try:
-            result = subprocess.run(
-                ["tmux", "has-session", "-t", session],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            return self.server.has_session(session)
+        except LibTmuxException:
             return False
 
     def new_session(self, session: str) -> bool:
         try:
-            result = subprocess.run(
-                ["tmux", "new-session", "-d", "-s", session],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            self.server.new_session(session_name=session, attach=False)
+            return True
+        except LibTmuxException:
             return False
 
     def new_window(self, session: str, name: str, command: Optional[List[str]] = None,
                    cwd: Optional[str] = None) -> Optional[int]:
         try:
-            cmd = ["tmux", "new-window", "-t", session, "-n", name, "-P", "-F", "#{window_index}"]
+            sess = self._get_session(session)
+            if sess is None:
+                return None
+
+            kwargs: Dict[str, Any] = {'window_name': name, 'attach': False}
             if cwd:
-                cmd.extend(["-c", cwd])
+                kwargs['start_directory'] = cwd
             if command:
-                cmd.append(" ".join(command))
+                kwargs['window_shell'] = ' '.join(command)
 
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
-            if result.returncode == 0:
-                return int(result.stdout.strip())
-            return None
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError, ValueError):
+            window = sess.new_window(**kwargs)
+            return int(window.window_index)
+        except (LibTmuxException, ValueError):
             return None
 
     def kill_window(self, session: str, window: int) -> bool:
         try:
-            result = subprocess.run(
-                ["tmux", "kill-window", "-t", f"{session}:{window}"],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            win = self._get_window(session, window)
+            if win is None:
+                return False
+            win.kill()
+            return True
+        except LibTmuxException:
             return False
 
     def kill_session(self, session: str) -> bool:
         try:
-            result = subprocess.run(
-                ["tmux", "kill-session", "-t", session],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            sess = self._get_session(session)
+            if sess is None:
+                return False
+            sess.kill()
+            return True
+        except LibTmuxException:
             return False
 
     def list_windows(self, session: str) -> List[Dict[str, Any]]:
         try:
-            result = subprocess.run(
-                ["tmux", "list-windows", "-t", session, "-F",
-                 "#{window_index}:#{window_name}:#{window_active}"],
-                capture_output=True, text=True, timeout=5
-            )
-            if result.returncode != 0:
+            sess = self._get_session(session)
+            if sess is None:
                 return []
 
             windows = []
-            for line in result.stdout.strip().split('\n'):
-                if line:
-                    parts = line.split(':')
-                    if len(parts) >= 3:
-                        windows.append({
-                            'index': int(parts[0]),
-                            'name': parts[1],
-                            'active': parts[2] == '1'
-                        })
+            for win in sess.windows:
+                windows.append({
+                    'index': int(win.window_index),
+                    'name': win.window_name,
+                    'active': win.window_active == '1'
+                })
             return windows
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+        except LibTmuxException:
             return []
 
     def attach(self, session: str) -> None:
@@ -145,12 +236,12 @@ class RealTmux:
     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):
+            win = self._get_window(session, window)
+            if win is None:
+                return False
+            win.select()
+            return True
+        except LibTmuxException:
             return False
 
 

overcode/monitor_daemon.py

@@ -17,7 +17,7 @@ This separation ensures:
 - Clean interface contract via MonitorDaemonState
 - Platform-agnostic core (presence is optional)
 
-TODO: Add unit tests (currently 0% coverage)
+Pure business logic is extracted to monitor_daemon_core.py for testability.
 """
 
 import os
@@ -30,7 +30,7 @@ from typing import Dict, List, Optional
 
 from .daemon_logging import BaseDaemonLogger
 from .daemon_utils import create_daemon_helpers
-from .history_reader import get_session_stats
+from .history_reader import get_session_stats, get_current_session_id_for_directory
 from .monitor_daemon_state import (
     MonitorDaemonState,
     SessionDaemonState,
@@ -53,10 +53,17 @@ from .settings import (
     get_supervisor_stats_path,
 )
 from .config import get_relay_config
-from .status_constants import STATUS_RUNNING, STATUS_TERMINATED
+from .status_constants import STATUS_ASLEEP, STATUS_RUNNING, STATUS_TERMINATED
 from .status_detector import StatusDetector
 from .status_history import log_agent_status
-from .summarizer_component import SummarizerComponent, SummarizerConfig
+from .monitor_daemon_core import (
+    calculate_time_accumulation,
+    calculate_cost_estimate,
+    calculate_total_tokens,
+    calculate_median,
+    should_sync_stats,
+    parse_datetime_safe,
+)
 
 
 # Check for macOS presence APIs (optional)
@@ -187,12 +194,6 @@ class MonitorDaemon:
         # Presence tracking (graceful degradation)
         self.presence = PresenceComponent()
 
-        # Summarizer component (graceful degradation if no API key)
-        self.summarizer = SummarizerComponent(
-            tmux_session=tmux_session,
-            config=SummarizerConfig(enabled=False),  # Off by default, enable via CLI
-        )
-
         # Logging - session-specific log file
         self.log = _create_monitor_logger(session=tmux_session)
 
@@ -209,8 +210,8 @@ class MonitorDaemon:
         self.last_state_times: Dict[str, datetime] = {}
         self.operation_start_times: Dict[str, datetime] = {}
 
-        # Stats sync throttling
-        self._last_stats_sync = datetime.now()
+        # Stats sync throttling - None forces immediate sync on first loop
+        self._last_stats_sync: Optional[datetime] = None
         self._stats_sync_interval = 60  # seconds
 
         # Relay configuration (for pushing state to cloud)
@@ -278,6 +279,7 @@ class MonitorDaemon:
             status_since=stats.state_since,
             green_time_seconds=stats.green_time_seconds,
             non_green_time_seconds=stats.non_green_time_seconds,
+            sleep_time_seconds=stats.sleep_time_seconds,
             interaction_count=stats.interaction_count,
             input_tokens=stats.input_tokens,
             output_tokens=stats.output_tokens,
@@ -293,6 +295,8 @@ class MonitorDaemon:
             start_time=session.start_time,
             permissiveness_mode=session.permissiveness_mode,
             start_directory=session.start_directory,
+            is_asleep=session.is_asleep,
+            agent_value=session.agent_value,
         )
 
     def _update_state_time(self, session, status: str, now: datetime) -> None:
@@ -305,18 +309,11 @@ class MonitorDaemon:
         if last_time is None:
             # First observation after daemon (re)start - use last_time_accumulation
             # to avoid re-adding time that was already accumulated before restart
-            if current_stats.last_time_accumulation:
-                try:
-                    last_time = datetime.fromisoformat(current_stats.last_time_accumulation)
-                except ValueError:
-                    last_time = now
-            elif current_stats.state_since:
+            last_time = parse_datetime_safe(current_stats.last_time_accumulation)
+            if last_time is None:
                 # Fallback for sessions without last_time_accumulation
-                try:
-                    last_time = datetime.fromisoformat(current_stats.state_since)
-                except ValueError:
-                    last_time = now
-            else:
+                last_time = parse_datetime_safe(current_stats.state_since)
+            if last_time is None:
                 last_time = now
             self.last_state_times[session_id] = last_time
             return  # Don't accumulate on first observation
@@ -326,41 +323,33 @@ class MonitorDaemon:
         if elapsed <= 0:
             return
 
-        # Accumulate time based on state
-        green_time = current_stats.green_time_seconds
-        non_green_time = current_stats.non_green_time_seconds
+        # Get session start time for capping
+        session_start = parse_datetime_safe(session.start_time)
 
-        if status == STATUS_RUNNING:
-            green_time += elapsed
-        elif status != STATUS_TERMINATED:
-            # Only count non-green time for non-terminated states
-            non_green_time += elapsed
-        # else: terminated - don't accumulate time
+        # Use pure function for time accumulation (with sleep time tracking #141)
+        prev_status = self.previous_states.get(session_id, status)
+        result = calculate_time_accumulation(
+            current_status=status,
+            previous_status=prev_status,
+            elapsed_seconds=elapsed,
+            current_green=current_stats.green_time_seconds,
+            current_non_green=current_stats.non_green_time_seconds,
+            current_sleep=current_stats.sleep_time_seconds,
+            session_start=session_start,
+            now=now,
+        )
 
-        # INVARIANT CHECK: accumulated time should never exceed uptime
-        # This catches bugs like multiple daemons running simultaneously
-        if session.start_time:
-            try:
-                session_start = datetime.fromisoformat(session.start_time)
-                max_allowed = (now - session_start).total_seconds()
-                total_accumulated = green_time + non_green_time
-
-                if total_accumulated > max_allowed * 1.1:  # 10% tolerance for timing jitter
-                    # Reset to sane values based on ratio
-                    ratio = max_allowed / total_accumulated if total_accumulated > 0 else 1.0
-                    green_time = green_time * ratio
-                    non_green_time = non_green_time * ratio
-                    self.log.warn(
-                        f"[{session.name}] Time tracking reset: "
-                        f"accumulated {total_accumulated/3600:.1f}h > uptime {max_allowed/3600:.1f}h"
-                    )
-            except (ValueError, TypeError):
-                pass
+        if result.was_capped:
+            total = current_stats.green_time_seconds + current_stats.non_green_time_seconds + current_stats.sleep_time_seconds
+            max_allowed = (now - session_start).total_seconds() if session_start else 0
+            self.log.warn(
+                f"[{session.name}] Time tracking reset: "
+                f"accumulated {total/3600:.1f}h > uptime {max_allowed/3600:.1f}h"
+            )
 
         # Update state tracking
-        prev_status = self.previous_states.get(session_id, status)
         state_since = current_stats.state_since
-        if prev_status != status:
+        if result.state_changed:
             state_since = now.isoformat()
         elif not state_since:
             # Initialize state_since if never set (e.g., new session)
@@ -371,8 +360,9 @@ class MonitorDaemon:
             session_id,
             current_state=status,
             state_since=state_since,
-            green_time_seconds=green_time,
-            non_green_time_seconds=non_green_time,
+            green_time_seconds=result.green_seconds,
+            non_green_time_seconds=result.non_green_seconds,
+            sleep_time_seconds=result.sleep_seconds,
             last_time_accumulation=now.isoformat(),
         )
 
@@ -381,24 +371,43 @@ class MonitorDaemon:
     def sync_claude_code_stats(self, session) -> None:
         """Sync token/interaction stats from Claude Code history files."""
         try:
+            # Capture current Claude sessionId if not already tracked (#119)
+            # This ensures accurate context window calculation for this agent
+            if session.start_directory:
+                try:
+                    session_start = datetime.fromisoformat(session.start_time)
+                    current_id = get_current_session_id_for_directory(
+                        session.start_directory, session_start
+                    )
+                    if current_id:
+                        self.session_manager.add_claude_session_id(session.id, current_id)
+                except (ValueError, TypeError):
+                    pass
+
             stats = get_session_stats(session)
             if stats is None:
                 return
 
             now = datetime.now()
-            total_tokens = (
-                stats.input_tokens +
-                stats.output_tokens +
-                stats.cache_creation_tokens +
-                stats.cache_read_tokens
+            total_tokens = calculate_total_tokens(
+                stats.input_tokens,
+                stats.output_tokens,
+                stats.cache_creation_tokens,
+                stats.cache_read_tokens,
             )
 
-            # Estimate cost
-            cost_estimate = (
-                (stats.input_tokens / 1_000_000) * 3.0 +
-                (stats.output_tokens / 1_000_000) * 15.0 +
-                (stats.cache_creation_tokens / 1_000_000) * 3.75 +
-                (stats.cache_read_tokens / 1_000_000) * 0.30
+            # Estimate cost using configured pricing (defaults to Opus 4.5)
+            from .settings import get_user_config
+            pricing = get_user_config()
+            cost_estimate = calculate_cost_estimate(
+                stats.input_tokens,
+                stats.output_tokens,
+                stats.cache_creation_tokens,
+                stats.cache_read_tokens,
+                price_input=pricing.price_input,
+                price_output=pricing.price_output,
+                price_cache_write=pricing.price_cache_write,
+                price_cache_read=pricing.price_cache_read,
             )
 
             self.session_manager.update_stats(
@@ -417,13 +426,7 @@ class MonitorDaemon:
 
     def _calculate_median_work_time(self, operation_times: List[float]) -> float:
         """Calculate median operation time."""
-        if not operation_times:
-            return 0.0
-        sorted_times = sorted(operation_times)
-        n = len(sorted_times)
-        if n % 2 == 0:
-            return (sorted_times[n // 2 - 1] + sorted_times[n // 2]) / 2
-        return sorted_times[n // 2]
+        return calculate_median(operation_times)
 
     def calculate_interval(self, sessions: list, all_waiting_user: bool) -> int:
         """Calculate appropriate loop interval.
@@ -481,13 +484,6 @@ class MonitorDaemon:
             except (json.JSONDecodeError, OSError):
                 pass
 
-        # Update summarizer stats
-        self.state.summarizer_available = self.summarizer.available
-        self.state.summarizer_enabled = self.summarizer.enabled
-        self.state.summarizer_calls = self.summarizer.total_calls
-        # Estimate cost: ~$0.0007 per call (4K input tokens + 150 output tokens)
-        self.state.summarizer_cost_usd = round(self.summarizer.total_calls * 0.0007, 4)
-
         self.state.save(self.state_path)
 
         # Push to relay if configured and interval elapsed
@@ -587,6 +583,13 @@ class MonitorDaemon:
                 # Get all sessions
                 sessions = self.session_manager.list_sessions()
 
+                # Sync Claude Code stats BEFORE building session_states so token counts are fresh
+                # This ensures the first loop has accurate data (fixes #103)
+                if should_sync_stats(self._last_stats_sync, now, self._stats_sync_interval):
+                    for session in sessions:
+                        self.sync_claude_code_stats(session)
+                    self._last_stats_sync = now
+
                 # Detect status and track stats for each session
                 session_states = []
                 all_waiting_user = True
@@ -610,12 +613,14 @@ class MonitorDaemon:
                         continue
 
                     # Track stats and build state
-                    session_state = self.track_session_stats(session, status)
+                    # Use "asleep" status if session is marked as sleeping (#68)
+                    effective_status = STATUS_ASLEEP if session.is_asleep else status
+                    session_state = self.track_session_stats(session, effective_status)
                     session_state.current_activity = activity
                     session_states.append(session_state)
 
                     # Log status history to session-specific file
-                    log_agent_status(session.name, status, activity, history_file=self.history_path)
+                    log_agent_status(session.name, effective_status, activity, history_file=self.history_path)
 
                     # Track if any session is not waiting for user
                     if status != "waiting_user":
@@ -630,20 +635,6 @@ class MonitorDaemon:
                 for stale_id in stale_ids:
                     del self.previous_states[stale_id]
 
-                # Sync Claude Code stats periodically (git context is refreshed every loop above)
-                if (now - self._last_stats_sync).total_seconds() >= self._stats_sync_interval:
-                    for session in sessions:
-                        self.sync_claude_code_stats(session)
-                    self._last_stats_sync = now
-
-                # Update summaries (if enabled)
-                summaries = self.summarizer.update(sessions)
-                for session_state in session_states:
-                    summary = summaries.get(session_state.session_id)
-                    if summary:
-                        session_state.activity_summary = summary.text
-                        session_state.activity_summary_updated = summary.updated_at
-
                 # Calculate interval
                 interval = self.calculate_interval(sessions, all_waiting_user)
                 self.state.current_interval = interval
@@ -673,7 +664,6 @@ class MonitorDaemon:
         finally:
             self.log.info("Monitor daemon shutting down")
             self.presence.stop()
-            self.summarizer.stop()
             self.state.status = "stopped"
             self.state.save(self.state_path)
             remove_pid_file(self.pid_path)