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

overcode/tui_actions/__init__.py

@@ -0,0 +1,20 @@
+"""
+TUI Action Mixins for Overcode.
+
+This package contains action method mixins organized by domain.
+These are mixed into SupervisorTUI via multiple inheritance.
+"""
+
+from .navigation import NavigationActionsMixin
+from .view import ViewActionsMixin
+from .daemon import DaemonActionsMixin
+from .session import SessionActionsMixin
+from .input import InputActionsMixin
+
+__all__ = [
+    "NavigationActionsMixin",
+    "ViewActionsMixin",
+    "DaemonActionsMixin",
+    "SessionActionsMixin",
+    "InputActionsMixin",
+]

overcode/tui_actions/daemon.py

@@ -0,0 +1,201 @@
+"""
+Daemon action methods for TUI.
+
+Handles Monitor Daemon, Supervisor Daemon, and Web Server controls.
+"""
+
+import subprocess
+import sys
+from typing import TYPE_CHECKING
+
+from textual.css.query import NoMatches
+
+if TYPE_CHECKING:
+    from ..tui_widgets import DaemonPanel
+
+
+class DaemonActionsMixin:
+    """Mixin providing daemon control actions for SupervisorTUI."""
+
+    def action_toggle_daemon(self) -> None:
+        """Toggle daemon panel visibility (like timeline)."""
+        from ..tui_widgets import DaemonPanel
+        try:
+            daemon_panel = self.query_one("#daemon-panel", DaemonPanel)
+            daemon_panel.display = not daemon_panel.display
+            if daemon_panel.display:
+                # Force immediate refresh when becoming visible
+                daemon_panel._refresh_logs()
+            # Save preference
+            self._prefs.daemon_panel_visible = daemon_panel.display
+            self._save_prefs()
+            state = "shown" if daemon_panel.display else "hidden"
+            self.notify(f"Daemon panel {state}", severity="information")
+        except NoMatches:
+            pass
+
+    def action_supervisor_start(self) -> None:
+        """Start the Supervisor Daemon (handles Claude orchestration)."""
+        from ..monitor_daemon import is_monitor_daemon_running
+        from ..supervisor_daemon import is_supervisor_daemon_running
+        from ..tui_widgets import DaemonPanel
+        import time
+
+        # Ensure Monitor Daemon is running first (Supervisor depends on it)
+        if not is_monitor_daemon_running(self.tmux_session):
+            self._ensure_monitor_daemon()
+            time.sleep(1.0)
+
+        if is_supervisor_daemon_running(self.tmux_session):
+            self.notify("Supervisor Daemon already running", severity="warning")
+            return
+
+        try:
+            panel = self.query_one("#daemon-panel", DaemonPanel)
+            panel.log_lines.append(">>> Starting Supervisor Daemon...")
+        except NoMatches:
+            pass
+
+        try:
+            subprocess.Popen(
+                [sys.executable, "-m", "overcode.supervisor_daemon",
+                 "--session", self.tmux_session],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+            self.notify("Started Supervisor Daemon", severity="information")
+            self.set_timer(1.0, self.update_daemon_status)
+        except (OSError, subprocess.SubprocessError) as e:
+            self.notify(f"Failed to start Supervisor Daemon: {e}", severity="error")
+
+    def action_supervisor_stop(self) -> None:
+        """Stop the Supervisor Daemon."""
+        from ..supervisor_daemon import is_supervisor_daemon_running, stop_supervisor_daemon
+        from ..tui_widgets import DaemonPanel
+
+        if not is_supervisor_daemon_running(self.tmux_session):
+            self.notify("Supervisor Daemon not running", severity="warning")
+            return
+
+        if stop_supervisor_daemon(self.tmux_session):
+            self.notify("Stopped Supervisor Daemon", severity="information")
+            try:
+                panel = self.query_one("#daemon-panel", DaemonPanel)
+                panel.log_lines.append(">>> Supervisor Daemon stopped")
+            except NoMatches:
+                pass
+        else:
+            self.notify("Failed to stop Supervisor Daemon", severity="error")
+
+        self.update_daemon_status()
+
+    def action_toggle_summarizer(self) -> None:
+        """Toggle the AI Summarizer on/off."""
+        from ..summarizer_client import SummarizerClient
+        from ..tui_widgets import SessionSummary
+
+        # Check if summarizer is available (OPENAI_API_KEY set)
+        if not SummarizerClient.is_available():
+            self.notify("AI Summarizer unavailable - set OPENAI_API_KEY", severity="warning")
+            return
+
+        # Toggle the state
+        self._summarizer.config.enabled = not self._summarizer.config.enabled
+
+        if self._summarizer.config.enabled:
+            # Enable: create client if needed
+            if not self._summarizer._client:
+                self._summarizer._client = SummarizerClient()
+            self.notify("AI Summarizer enabled", severity="information")
+            # Update all widgets to show summarizer is enabled
+            for widget in self.query(SessionSummary):
+                widget.summarizer_enabled = True
+            # Trigger an immediate update
+            self._update_summaries_async()
+        else:
+            # Disable: close client to release resources
+            if self._summarizer._client:
+                self._summarizer._client.close()
+                self._summarizer._client = None
+            # Clear cached summaries
+            self._summaries = {}
+            # Update all widgets to clear summaries and show disabled state
+            for widget in self.query(SessionSummary):
+                widget.ai_summary_short = ""
+                widget.ai_summary_context = ""
+                widget.summarizer_enabled = False
+                widget.refresh()
+            self.notify("AI Summarizer disabled", severity="information")
+
+        # Refresh status bar
+        self.update_daemon_status()
+
+    def action_monitor_restart(self) -> None:
+        """Restart the Monitor Daemon (handles metrics/state tracking)."""
+        from ..monitor_daemon import is_monitor_daemon_running, stop_monitor_daemon
+        from ..tui_widgets import DaemonPanel
+
+        try:
+            panel = self.query_one("#daemon-panel", DaemonPanel)
+            panel.log_lines.append(">>> Restarting Monitor Daemon...")
+        except NoMatches:
+            pass
+
+        # Stop if running
+        if is_monitor_daemon_running(self.tmux_session):
+            stop_monitor_daemon(self.tmux_session)
+            # Use non-blocking timer to wait before starting
+            # (avoids blocking the event loop which caused double-press issue)
+            self.set_timer(0.5, self._start_monitor_daemon)
+        else:
+            # Not running, start immediately
+            self._start_monitor_daemon()
+
+    def _start_monitor_daemon(self) -> None:
+        """Start the monitor daemon (called by action_monitor_restart)."""
+        from ..tui_widgets import DaemonPanel
+
+        try:
+            subprocess.Popen(
+                [sys.executable, "-m", "overcode.monitor_daemon",
+                 "--session", self.tmux_session],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+            )
+
+            self.notify("Monitor Daemon restarted", severity="information")
+            try:
+                panel = self.query_one("#daemon-panel", DaemonPanel)
+                panel.log_lines.append(">>> Monitor Daemon restarted")
+            except NoMatches:
+                pass
+            self.set_timer(1.0, self.update_daemon_status)
+        except (OSError, subprocess.SubprocessError) as e:
+            self.notify(f"Failed to restart Monitor Daemon: {e}", severity="error")
+
+    def action_toggle_web_server(self) -> None:
+        """Toggle the web analytics dashboard server on/off."""
+        from ..web_server import toggle_web_server, get_web_server_url
+        from ..tui_widgets import DaemonPanel
+
+        is_running, msg = toggle_web_server(self.tmux_session)
+
+        if is_running:
+            url = get_web_server_url(self.tmux_session)
+            self.notify(f"Web server: {url}", severity="information")
+            try:
+                panel = self.query_one("#daemon-panel", DaemonPanel)
+                panel.log_lines.append(f">>> Web server started: {url}")
+            except NoMatches:
+                pass
+        else:
+            self.notify(f"Web server: {msg}", severity="information")
+            try:
+                panel = self.query_one("#daemon-panel", DaemonPanel)
+                panel.log_lines.append(f">>> Web server: {msg}")
+            except NoMatches:
+                pass
+
+        self.update_daemon_status()

overcode/tui_actions/input.py

@@ -0,0 +1,128 @@
+"""
+Input action methods for TUI.
+
+Handles sending keys and commands to agents.
+"""
+
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..tui_widgets import SessionSummary
+
+
+class InputActionsMixin:
+    """Mixin providing input/send actions for SupervisorTUI."""
+
+    def action_send_enter_to_focused(self) -> None:
+        """Send Enter keypress to the focused agent (for approvals)."""
+        from ..tui_widgets import SessionSummary
+        from ..launcher import ClaudeLauncher
+
+        focused = self.focused
+        if not isinstance(focused, SessionSummary):
+            self.notify("No agent focused", severity="warning")
+            return
+
+        session_name = focused.session.name
+        launcher = ClaudeLauncher(
+            tmux_session=self.tmux_session,
+            session_manager=self.session_manager
+        )
+
+        # Send "enter" which the launcher handles as just pressing Enter
+        if launcher.send_to_session(session_name, "enter"):
+            self.notify(f"Sent Enter to {session_name}", severity="information")
+        else:
+            self.notify(f"Failed to send Enter to {session_name}", severity="error")
+
+    def _is_freetext_option(self, pane_content: str, key: str) -> bool:
+        """Check if a numbered menu option is a free-text instruction option.
+
+        Scans the pane content for patterns like "5. Tell Claude what to do"
+        or "3) Give custom instructions" to determine if selecting this option
+        should open the command bar for user input.
+
+        Args:
+            pane_content: The tmux pane content to scan
+            key: The number key being pressed (e.g., "5")
+
+        Returns:
+            True if this option expects free-text input
+        """
+        # Claude Code v2.x only has one freetext option format:
+        # "3. No, and tell Claude what to do differently (esc)"
+        # This appears on all permission prompts (Bash, Read, Write, etc.)
+        freetext_patterns = [
+            r"tell\s+claude\s+what\s+to\s+do",
+        ]
+
+        # Look for the numbered option in the content
+        # Match patterns like "5. text", "5) text", "5: text"
+        option_pattern = rf"^\s*{key}[\.\)\:]\s*(.+)$"
+
+        for line in pane_content.split('\n'):
+            match = re.match(option_pattern, line.strip(), re.IGNORECASE)
+            if match:
+                option_text = match.group(1).lower()
+                # Check if this option matches any freetext pattern
+                for pattern in freetext_patterns:
+                    if re.search(pattern, option_text):
+                        return True
+        return False
+
+    def _send_key_to_focused(self, key: str) -> None:
+        """Send a key to the focused agent.
+
+        If the key selects a "free text instruction" menu option (detected by
+        scanning the pane content), automatically opens the command bar (#72).
+
+        Args:
+            key: The key to send
+        """
+        from ..tui_widgets import SessionSummary
+        from ..launcher import ClaudeLauncher
+
+        focused = self.focused
+        if not isinstance(focused, SessionSummary):
+            self.notify("No agent focused", severity="warning")
+            return
+
+        session_name = focused.session.name
+        launcher = ClaudeLauncher(
+            tmux_session=self.tmux_session,
+            session_manager=self.session_manager
+        )
+
+        # Check if this option is a free-text instruction option before sending
+        pane_content = self.status_detector.get_pane_content(focused.session.tmux_window) or ""
+        is_freetext = self._is_freetext_option(pane_content, key)
+
+        # Send the key followed by Enter (to select the numbered option)
+        if launcher.send_to_session(session_name, key, enter=True):
+            self.notify(f"Sent '{key}' to {session_name}", severity="information")
+            # Open command bar if this was a free-text instruction option (#72)
+            if is_freetext:
+                self.action_focus_command_bar()
+        else:
+            self.notify(f"Failed to send '{key}' to {session_name}", severity="error")
+
+    def action_send_1_to_focused(self) -> None:
+        """Send '1' to focused agent."""
+        self._send_key_to_focused("1")
+
+    def action_send_2_to_focused(self) -> None:
+        """Send '2' to focused agent."""
+        self._send_key_to_focused("2")
+
+    def action_send_3_to_focused(self) -> None:
+        """Send '3' to focused agent."""
+        self._send_key_to_focused("3")
+
+    def action_send_4_to_focused(self) -> None:
+        """Send '4' to focused agent."""
+        self._send_key_to_focused("4")
+
+    def action_send_5_to_focused(self) -> None:
+        """Send '5' to focused agent."""
+        self._send_key_to_focused("5")

overcode/tui_actions/navigation.py

@@ -0,0 +1,117 @@
+"""
+Navigation action methods for TUI.
+
+Handles moving between sessions in the list.
+"""
+
+from typing import TYPE_CHECKING, List
+
+if TYPE_CHECKING:
+    from ..tui_widgets import SessionSummary
+
+
+class NavigationActionsMixin:
+    """Mixin providing navigation actions for SupervisorTUI."""
+
+    def action_focus_next_session(self) -> None:
+        """Focus the next session in the list."""
+        widgets = self._get_widgets_in_session_order()
+        if not widgets:
+            return
+        self.focused_session_index = (self.focused_session_index + 1) % len(widgets)
+        target_widget = widgets[self.focused_session_index]
+        target_widget.focus()
+        if self.view_mode == "list_preview":
+            self._update_preview()
+        self._sync_tmux_window(target_widget)
+
+    def action_focus_previous_session(self) -> None:
+        """Focus the previous session in the list."""
+        widgets = self._get_widgets_in_session_order()
+        if not widgets:
+            return
+        self.focused_session_index = (self.focused_session_index - 1) % len(widgets)
+        target_widget = widgets[self.focused_session_index]
+        target_widget.focus()
+        if self.view_mode == "list_preview":
+            self._update_preview()
+        self._sync_tmux_window(target_widget)
+
+    def action_jump_to_attention(self) -> None:
+        """Jump to next session needing attention.
+
+        Cycles through sessions prioritized by:
+        1. Bell indicator (is_unvisited_stalled=True) - highest priority
+        2. waiting_user status (red, no bell)
+        3. no_instructions status (yellow)
+        4. waiting_supervisor status (orange)
+        """
+        from ..status_constants import (
+            STATUS_WAITING_USER,
+            STATUS_NO_INSTRUCTIONS,
+            STATUS_WAITING_SUPERVISOR,
+            STATUS_RUNNING,
+        )
+
+        widgets = self._get_widgets_in_session_order()
+        if not widgets:
+            return
+
+        # Build prioritized list of sessions needing attention
+        # Priority: bell > waiting_user > no_instructions > waiting_supervisor
+        attention_sessions = []
+        for i, widget in enumerate(widgets):
+            status = getattr(widget, 'detected_status', STATUS_RUNNING)
+            is_bell = getattr(widget, 'is_unvisited_stalled', False)
+
+            # Bell indicator takes highest priority - these are the sessions
+            # that truly need attention (user hasn't seen them yet)
+            if is_bell:
+                attention_sessions.append((0, i, widget))  # Bell = highest priority
+            elif status == STATUS_WAITING_USER:
+                attention_sessions.append((1, i, widget))  # Red but no bell (already visited)
+            elif status == STATUS_NO_INSTRUCTIONS:
+                attention_sessions.append((2, i, widget))
+            elif status == STATUS_WAITING_SUPERVISOR:
+                attention_sessions.append((3, i, widget))
+            # Skip running, terminated, asleep
+
+        if not attention_sessions:
+            self.notify("No sessions need attention", severity="information")
+            return
+
+        # Sort by priority, then by original index
+        attention_sessions.sort(key=lambda x: (x[0], x[1]))
+
+        # Check if our cached list changed (sessions may have changed state)
+        current_widget_ids = [id(w) for _, _, w in attention_sessions]
+        cached_widget_ids = [id(w) for w in self._attention_jump_list]
+
+        if current_widget_ids != cached_widget_ids:
+            # List changed, reset index
+            self._attention_jump_list = [w for _, _, w in attention_sessions]
+            self._attention_jump_index = 0
+        else:
+            # Cycle to next
+            self._attention_jump_index = (self._attention_jump_index + 1) % len(self._attention_jump_list)
+
+        # Focus the target widget
+        target_widget = self._attention_jump_list[self._attention_jump_index]
+        # Find its index in the full widget list
+        for i, w in enumerate(widgets):
+            if w is target_widget:
+                self.focused_session_index = i
+                break
+
+        target_widget.focus()
+        if self.view_mode == "list_preview":
+            self._update_preview()
+        self._sync_tmux_window(target_widget)
+
+        # Show position indicator
+        pos = self._attention_jump_index + 1
+        total = len(self._attention_jump_list)
+        status = getattr(target_widget, 'detected_status', 'unknown')
+        is_bell = getattr(target_widget, 'is_unvisited_stalled', False)
+        bell_indicator = "🔔 " if is_bell else ""
+        self.notify(f"Attention {pos}/{total}: {bell_indicator}{target_widget.session.name} ({status})", severity="information")