dlab-cli 0.1.0__py3-none-any.whl

dlab/tui/widgets/log_view.py

@@ -0,0 +1,505 @@
+"""
+Main log display widget with collapsible events.
+
+Displays formatted log events for the selected agent with
+real-time updates and expand/collapse functionality.
+"""
+
+from textual.widgets import Static
+from textual.containers import VerticalScroll, Horizontal
+from textual.reactive import reactive
+from textual import events
+from rich.text import Text
+from rich.markdown import Markdown
+from rich.console import Group
+
+from dlab.tui.models import LogEvent
+
+
+# Monokai-native color palette
+_CYAN: str = "#66D9EF"
+_GREEN: str = "#A6E22E"
+_ORANGE: str = "#FD971F"
+_RED: str = "#F92672"
+_PURPLE: str = "#AE81FF"
+_COMMENT: str = "#75715E"
+_FG: str = "#F8F8F2"
+
+# Color styles by event type
+EVENT_STYLES: dict[str, str] = {
+    "step_start": _CYAN,
+    "step_finish": _GREEN,
+    "text": _FG,
+    "tool_use": _ORANGE,
+    "task_start": _ORANGE,
+    "task_finish": _GREEN,
+    "additional_output": _COMMENT,
+    "raw_text": _COMMENT,
+    "error": f"bold {_RED}",
+}
+
+
+def format_relative_time(event_ts: int, global_start_ts: int | None) -> str:
+    """
+    Format timestamp relative to global start.
+
+    Parameters
+    ----------
+    event_ts : int
+        Event timestamp in ms, or 0 for events without timestamp.
+    global_start_ts : int | None
+        Global start timestamp in ms, or None if unknown.
+
+    Returns
+    -------
+    str
+        Formatted relative time (e.g., "+5.2s"), "---" for no timestamp,
+        or "????.?s" if start unknown.
+    """
+    # Events with timestamp=0 have no time (additional_output events)
+    # All returns must be exactly 10 chars for column alignment
+    if event_ts == 0:
+        return "       ---"  # 10 chars
+    if global_start_ts is None:
+        return "   ????.?s"  # 10 chars
+    rel_seconds = (event_ts - global_start_ts) / 1000
+    return f"+{rel_seconds:8.1f}s"  # 10 chars
+
+
+def format_duration(ms: int | None) -> str:
+    """
+    Format duration in milliseconds.
+
+    Parameters
+    ----------
+    ms : int | None
+        Duration in milliseconds.
+
+    Returns
+    -------
+    str
+        Formatted duration or empty string.
+    """
+    if ms is None:
+        return ""
+    seconds = ms / 1000
+    if seconds < 60:
+        return f"[{seconds:.1f}s]"
+    minutes = seconds / 60
+    return f"[{minutes:.1f}m]"
+
+
+class LogEventPrefix(Static):
+    """Fixed-width prefix showing selection, time, and event type."""
+
+    DEFAULT_CSS = """
+    LogEventPrefix {
+        width: 27;
+        min-width: 27;
+        max-width: 27;
+    }
+    """
+
+    def __init__(
+        self,
+        time_str: str,
+        event_type: str,
+        style: str,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._time_str = time_str
+        self._event_type = event_type
+        self._style = style
+        self._is_selected = False
+
+    def set_selected(self, selected: bool) -> None:
+        """Update selection state."""
+        self._is_selected = selected
+        self.refresh()
+
+    def render(self) -> Text:
+        """Render the prefix."""
+        if self._is_selected:
+            text = Text("► ", style=f"bold {_PURPLE}")
+        else:
+            text = Text("  ")
+
+        text.append(self._time_str, style="dim")
+        text.append("  ", style="dim")
+        text.append(f"{self._event_type:12}", style=self._style)
+        text.append(" ", style="dim")
+
+        return text
+
+
+class LogEventDescription(Static):
+    """Flexible-width description that wraps properly."""
+
+    DEFAULT_CSS = """
+    LogEventDescription {
+        width: 1fr;
+    }
+    """
+
+    def __init__(
+        self,
+        description: str,
+        full_description: str,
+        event_type: str,
+        style: str,
+        duration_str: str,
+        is_long: bool,
+        start_expanded: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._description = description
+        self._full_description = full_description
+        self._event_type = event_type
+        self._style = style
+        self._duration_str = duration_str
+        self._is_long = is_long
+        self._is_collapsed = not start_expanded
+
+    def set_collapsed(self, collapsed: bool) -> None:
+        """Update collapsed state."""
+        self._is_collapsed = collapsed
+        self.refresh(layout=True)
+
+    def render(self):
+        """Render the description."""
+        if self._is_long and self._is_collapsed:
+            # Only take first line if multiline, then truncate
+            first_line = self._description.split("\n")[0]
+            if len(first_line) > 100:
+                first_line = first_line[:100] + "..."
+            text = Text(first_line, style=self._style)
+            text.append(" [+]", style="dim italic")
+            if self._duration_str:
+                text.append(f" {self._duration_str}", style="dim")
+            return text
+        else:
+            # Use full description when expanded
+            desc = self._full_description
+
+            # Check if this should be rendered as Markdown
+            is_markdown = self._event_type == "text"
+            # Also render "write: *.md" content as Markdown
+            if desc.startswith("write:") and ".md" in desc.split("\n")[0]:
+                is_markdown = True
+
+            if is_markdown:
+                md = Markdown(desc)
+                if self._is_long or self._duration_str:
+                    suffix = Text()
+                    if self._is_long:
+                        suffix.append(" [-]", style="dim italic")
+                    if self._duration_str:
+                        suffix.append(f" {self._duration_str}", style="dim")
+                    return Group(md, suffix)
+                return md
+            else:
+                text = Text(desc, style=self._style)
+                if self._is_long:
+                    text.append(" [-]", style="dim italic")
+                if self._duration_str:
+                    text.append(f" {self._duration_str}", style="dim")
+                return text
+
+
+class LogEventWidget(Horizontal):
+    """
+    Single log event display using horizontal layout.
+
+    Shows timestamp, event type, and description with appropriate styling.
+    Long text content can be collapsed. Description wraps properly.
+    """
+
+    DEFAULT_CSS = """
+    LogEventWidget {
+        height: auto;
+        width: 100%;
+    }
+    """
+
+    is_collapsed: reactive[bool] = reactive(True)
+    is_selected: reactive[bool] = reactive(False)
+
+    def __init__(
+        self,
+        event: LogEvent,
+        global_start_ts: int | None,
+        start_expanded: bool = False,
+        **kwargs,
+    ) -> None:
+        """
+        Initialize event widget.
+
+        Parameters
+        ----------
+        event : LogEvent
+            The log event to display.
+        global_start_ts : int | None
+            Global start timestamp for relative time calculation, or None if unknown.
+        """
+        super().__init__(**kwargs)
+        self.event = event
+        self.global_start_ts = global_start_ts
+        self._start_expanded = start_expanded
+        # Check if description has multiple lines or is long
+        self._is_long = len(event.description) > 100 or "\n" in event.description
+
+        self._style = EVENT_STYLES.get(event.event_type, "white")
+        self._time_str = format_relative_time(event.timestamp, global_start_ts)
+        self._duration_str = format_duration(event.duration_ms)
+
+    def compose(self):
+        """Create child widgets."""
+        yield LogEventPrefix(
+            self._time_str,
+            self.event.event_type,
+            self._style,
+        )
+        yield LogEventDescription(
+            self.event.description,
+            self.event.full_description,
+            self.event.event_type,
+            self._style,
+            self._duration_str,
+            self._is_long,
+            start_expanded=self._start_expanded,
+        )
+
+    def on_mount(self) -> None:
+        """Apply initial expanded state after mounting."""
+        if self._start_expanded:
+            self.is_collapsed = False
+
+    def watch_is_collapsed(self, value: bool) -> None:
+        """Update description collapsed state."""
+        try:
+            desc = self.query_one(LogEventDescription)
+            desc.set_collapsed(value)
+        except Exception:
+            pass
+
+    def watch_is_selected(self, value: bool) -> None:
+        """Update prefix selected state."""
+        try:
+            prefix = self.query_one(LogEventPrefix)
+            prefix.set_selected(value)
+        except Exception:
+            pass
+
+    def toggle_collapse(self) -> None:
+        """Toggle collapsed state."""
+        if self._is_long:
+            self.is_collapsed = not self.is_collapsed
+
+
+class LogView(VerticalScroll, can_focus=True):
+    """
+    Scrollable container of log events for selected agent.
+
+    Features:
+    - Real-time event appending
+    - Auto-scroll to bottom (toggleable)
+    - Collapsible long events
+    - Search highlighting
+    - Keyboard navigation with selection
+    """
+
+    # Override scroll bindings to use for message navigation instead
+    BINDINGS = [
+        ("up", "select_prev", "Previous"),
+        ("down", "select_next", "Next"),
+        ("enter", "toggle_expand", "Expand"),
+    ]
+
+    auto_scroll: reactive[bool] = reactive(True)
+    search_query: reactive[str] = reactive("")
+    selected_index: reactive[int] = reactive(-1)
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._events: list[LogEvent] = []
+        self._global_start_ts: int | None = None
+        self._widgets: list[LogEventWidget] = []
+        self._expand_all_mode: bool = False
+
+    def watch_selected_index(self, old_index: int, new_index: int) -> None:
+        """Update selection visuals when index changes."""
+        if 0 <= old_index < len(self._widgets):
+            self._widgets[old_index].is_selected = False
+        if 0 <= new_index < len(self._widgets):
+            self._widgets[new_index].is_selected = True
+            self._widgets[new_index].scroll_visible()
+
+    def on_focus(self) -> None:
+        """Auto-select first event when focusing if none selected."""
+        if self.selected_index == -1 and self._widgets:
+            self.selected_index = 0
+
+    def set_events(
+        self,
+        events: list[LogEvent],
+        global_start_ts: int | None,
+    ) -> None:
+        """
+        Replace all events (when switching agents).
+
+        Parameters
+        ----------
+        events : list[LogEvent]
+            List of events to display.
+        global_start_ts : int | None
+            Global start timestamp for relative time (from main.log), or None if unknown.
+        """
+        self._events = list(events)  # Copy to avoid shared reference with AgentState
+        self._global_start_ts = global_start_ts
+        self.selected_index = -1  # Reset selection
+        self._expand_all_mode = False  # Reset expand state
+        self._rebuild_widgets()
+
+    def _rebuild_widgets(self) -> None:
+        """Rebuild all event widgets."""
+        # Clear existing
+        self.remove_children()
+        self._widgets = []
+
+        # Create new widgets
+        for event in self._events:
+            widget = LogEventWidget(event, self._global_start_ts)
+            self._widgets.append(widget)
+            self.mount(widget)
+
+        if self.auto_scroll:
+            self.scroll_end(animate=False)
+
+    def append_event(self, event: LogEvent) -> None:
+        """
+        Add new event (real-time update).
+
+        Parameters
+        ----------
+        event : LogEvent
+            Event to append.
+        """
+        self._events.append(event)
+        widget = LogEventWidget(
+            event,
+            self._global_start_ts,
+            start_expanded=self._expand_all_mode,
+        )
+        self._widgets.append(widget)
+        self.mount(widget)
+
+        if self.auto_scroll:
+            self.scroll_end(animate=False)
+
+    def expand_all(self) -> None:
+        """Expand all collapsible events."""
+        self._expand_all_mode = True
+        for widget in self._widgets:
+            widget.is_collapsed = False
+        self.refresh(layout=True)
+        if 0 <= self.selected_index < len(self._widgets):
+            self._widgets[self.selected_index].scroll_visible()
+
+    def collapse_all(self) -> None:
+        """Collapse all collapsible events."""
+        self._expand_all_mode = False
+        for widget in self._widgets:
+            widget.is_collapsed = True
+        self.refresh(layout=True)
+        if 0 <= self.selected_index < len(self._widgets):
+            self._widgets[self.selected_index].scroll_visible()
+
+    def highlight_search(self, query: str) -> list[int]:
+        """
+        Highlight search matches.
+
+        Parameters
+        ----------
+        query : str
+            Search query.
+
+        Returns
+        -------
+        list[int]
+            Indices of matching events.
+        """
+        self.search_query = query
+        matches: list[int] = []
+
+        if not query:
+            return matches
+
+        query_lower = query.lower()
+        for i, event in enumerate(self._events):
+            if query_lower in event.description.lower():
+                matches.append(i)
+
+        return matches
+
+    def scroll_to_event(self, index: int) -> None:
+        """
+        Scroll to event at index.
+
+        Parameters
+        ----------
+        index : int
+            Event index.
+        """
+        if 0 <= index < len(self._widgets):
+            self._widgets[index].scroll_visible()
+
+    def select_next(self) -> None:
+        """Select the next event."""
+        if not self._widgets:
+            return
+        if self.selected_index < len(self._widgets) - 1:
+            self.selected_index += 1
+        elif self.selected_index == -1:
+            self.selected_index = 0
+
+    def select_prev(self) -> None:
+        """Select the previous event."""
+        if not self._widgets:
+            return
+        if self.selected_index > 0:
+            self.selected_index -= 1
+        elif self.selected_index == -1:
+            self.selected_index = len(self._widgets) - 1
+
+    def toggle_selected(self) -> None:
+        """Toggle expand/collapse of selected event."""
+        if 0 <= self.selected_index < len(self._widgets):
+            self._widgets[self.selected_index].toggle_collapse()
+            self.refresh(layout=True)
+
+    def action_select_next(self) -> None:
+        """Action handler for down key."""
+        self.select_next()
+
+    def action_select_prev(self) -> None:
+        """Action handler for up key."""
+        self.select_prev()
+
+    def action_toggle_expand(self) -> None:
+        """Action handler for enter key."""
+        self.toggle_selected()
+
+    def get_selected_content(self) -> str | None:
+        """
+        Get the full content of the selected event.
+
+        Returns
+        -------
+        str | None
+            Full description of selected event, or None if nothing selected.
+        """
+        if 0 <= self.selected_index < len(self._events):
+            return self._events[self.selected_index].full_description
+        return None

dlab/tui/widgets/search_popup.py

@@ -0,0 +1,151 @@
+"""
+Search popup overlay widget for the TUI.
+
+Provides a popup search interface that appears on '/' key
+and searches the current view (logs or file content).
+"""
+
+from textual.containers import Horizontal
+from textual.widgets import Input, Static
+from textual.message import Message
+
+
+class SearchPopup(Horizontal):
+    """
+    Search popup overlay that appears on '/' key.
+
+    Shows a search input with match count indicator.
+    Searches only the current active view (Logs or Files tab).
+    """
+
+    DEFAULT_CSS = """
+    SearchPopup {
+        layer: popup;
+        width: 50;
+        height: 3;
+        align: center middle;
+        background: $surface;
+        border: hkey $accent;
+        padding: 0 1;
+        display: none;
+    }
+
+    SearchPopup.visible {
+        display: block;
+    }
+
+    SearchPopup #search-input {
+        width: 1fr;
+        border: none;
+    }
+
+    SearchPopup #search-count {
+        width: auto;
+        min-width: 6;
+        padding: 0 1;
+        text-align: right;
+    }
+    """
+
+    class SearchSubmitted(Message):
+        """Message sent when search is submitted."""
+
+        def __init__(self, query: str) -> None:
+            self.query = query
+            super().__init__()
+
+    class SearchChanged(Message):
+        """Message sent when search text changes."""
+
+        def __init__(self, query: str) -> None:
+            self.query = query
+            super().__init__()
+
+    class SearchClosed(Message):
+        """Message sent when search popup is closed."""
+
+        pass
+
+    class NextMatch(Message):
+        """Message sent to jump to next match."""
+
+        pass
+
+    class PrevMatch(Message):
+        """Message sent to jump to previous match."""
+
+        pass
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._match_index: int = 0
+        self._match_count: int = 0
+
+    def compose(self):
+        """Compose the widget."""
+        yield Input(placeholder="Search...", id="search-input")
+        yield Static("", id="search-count")
+
+    def show(self) -> None:
+        """Show the popup and focus the input."""
+        self.add_class("visible")
+        search_input = self.query_one("#search-input", Input)
+        search_input.focus()
+
+    def hide(self) -> None:
+        """Hide the popup and clear search."""
+        self.remove_class("visible")
+        search_input = self.query_one("#search-input", Input)
+        search_input.value = ""
+        self._match_index = 0
+        self._match_count = 0
+        self._update_count_display()
+        self.post_message(self.SearchClosed())
+
+    def is_visible(self) -> bool:
+        """Check if popup is currently visible."""
+        return self.has_class("visible")
+
+    def update_match_count(self, current: int, total: int) -> None:
+        """
+        Update the match count display.
+
+        Parameters
+        ----------
+        current : int
+            Current match index (1-based).
+        total : int
+            Total number of matches.
+        """
+        self._match_index = current
+        self._match_count = total
+        self._update_count_display()
+
+    def _update_count_display(self) -> None:
+        """Update the count label."""
+        count_label = self.query_one("#search-count", Static)
+        if self._match_count > 0:
+            count_label.update(f"{self._match_index}/{self._match_count}")
+        elif self.query_one("#search-input", Input).value:
+            count_label.update("0/0")
+        else:
+            count_label.update("")
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle input text changes."""
+        if event.input.id == "search-input":
+            self.post_message(self.SearchChanged(event.value))
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle Enter key - jump to next match."""
+        if event.input.id == "search-input":
+            self.post_message(self.NextMatch())
+
+    def on_key(self, event) -> None:
+        """Handle key events."""
+        if event.key == "escape":
+            self.hide()
+            event.stop()
+        elif event.key == "shift+enter":
+            self.post_message(self.PrevMatch())
+            event.stop()