gobby 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

gobby/tui/widgets/conductor.py

@@ -1,104 +0,0 @@
-"""Conductor widgets for haiku display and mode indicator."""
-
-from __future__ import annotations
-
-from textual.app import ComposeResult
-from textual.css.query import NoMatches
-from textual.reactive import reactive
-from textual.widget import Widget
-from textual.widgets import Static
-
-
-class HaikuDisplay(Widget):
-    """Widget displaying TARS-style status haiku."""
-
-    DEFAULT_CSS = """
-    HaikuDisplay {
-        height: auto;
-        padding: 1;
-    }
-
-    HaikuDisplay .haiku-line {
-        text-align: center;
-        color: #cdd6f4;
-    }
-
-    HaikuDisplay .haiku-line-first {
-        color: #a78bfa;
-    }
-    """
-
-    lines = reactive(("", "", ""))
-
-    def compose(self) -> ComposeResult:
-        for i, line in enumerate(self.lines):
-            classes = "haiku-line"
-            if i == 0:
-                classes += " haiku-line-first"
-            yield Static(line, classes=classes, id=f"haiku-{i}")
-
-    def update_haiku(self, lines: list[str]) -> None:
-        """Update the haiku text."""
-        if len(lines) >= 3:
-            self.lines = tuple(lines[:3])  # type: ignore[assignment]
-            for i, line in enumerate(self.lines):
-                try:
-                    widget = self.query_one(f"#haiku-{i}", Static)
-                    widget.update(line)
-                except NoMatches:
-                    pass  # nosec B110 - Widget may not be mounted yet
-
-
-class ModeIndicator(Widget):
-    """Widget showing current orchestrator mode."""
-
-    DEFAULT_CSS = """
-    ModeIndicator {
-        height: 3;
-        border: round #45475a;
-        padding: 0 1;
-        content-align: center middle;
-    }
-
-    ModeIndicator.--interactive {
-        border: round #22c55e;
-        color: #22c55e;
-    }
-
-    ModeIndicator.--autonomous {
-        border: round #f59e0b;
-        color: #f59e0b;
-    }
-
-    ModeIndicator.--paused {
-        border: round #6c7086;
-        color: #6c7086;
-    }
-    """
-
-    mode = reactive("interactive")
-
-    MODE_LABELS = {
-        "interactive": "INTERACTIVE",
-        "autonomous": "AUTONOMOUS",
-        "paused": "PAUSED",
-    }
-
-    def compose(self) -> ComposeResult:
-        label = self.MODE_LABELS.get(self.mode, "UNKNOWN")
-        yield Static(label, id="mode-label")
-
-    def watch_mode(self, mode: str) -> None:
-        """Update classes when mode changes."""
-        self.remove_class("--interactive", "--autonomous", "--paused")
-        self.add_class(f"--{mode}")
-
-        try:
-            label = self.query_one("#mode-label", Static)
-            label.update(self.MODE_LABELS.get(mode, "UNKNOWN"))
-        except NoMatches:
-            pass  # nosec B110 - Widget may not be mounted yet
-
-    def set_mode(self, mode: str) -> None:
-        """Set the current mode."""
-        self.mode = mode

gobby/tui/widgets/menu.py

@@ -1,132 +0,0 @@
-"""Menu panel widget for screen navigation."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-
-from textual.app import ComposeResult
-from textual.containers import Vertical
-from textual.css.query import NoMatches
-from textual.message import Message
-from textual.reactive import reactive
-from textual.widget import Widget
-from textual.widgets import Static
-
-
-@dataclass
-class MenuItem:
-    """A menu item with key binding and label."""
-
-    key: str
-    label: str
-    screen_id: str
-
-
-class MenuItemWidget(Static):
-    """Individual menu item widget."""
-
-    DEFAULT_CSS = """
-    MenuItemWidget {
-        height: 3;
-        padding: 0 1;
-        content-align: left middle;
-    }
-
-    MenuItemWidget:hover {
-        background: #45475a;
-    }
-
-    MenuItemWidget.--selected {
-        background: #7c3aed;
-        color: white;
-        text-style: bold;
-    }
-    """
-
-    selected = reactive(False)
-
-    def __init__(
-        self,
-        item: MenuItem,
-        selected: bool = False,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        self.item = item
-        self.selected = selected
-
-    def compose(self) -> ComposeResult:
-        yield Static(f"[{self.item.key.upper()}] {self.item.label}")
-
-    def watch_selected(self, selected: bool) -> None:
-        self.set_class(selected, "--selected")
-
-    def on_click(self) -> None:
-        self.post_message(MenuPanel.ItemSelected(self.item))
-
-
-class MenuPanel(Widget):
-    """Left sidebar menu panel with keyboard navigation."""
-
-    DEFAULT_CSS = """
-    MenuPanel {
-        width: 14;
-        background: #313244;
-        border-right: solid #45475a;
-    }
-    """
-
-    MENU_ITEMS = [
-        MenuItem("d", "Dashboard", "dashboard"),
-        MenuItem("t", "Tasks", "tasks"),
-        MenuItem("s", "Sessions", "sessions"),
-        MenuItem("c", "Chat", "chat"),
-        MenuItem("a", "Agents", "agents"),
-        MenuItem("w", "Worktrees", "worktrees"),
-        MenuItem("f", "Workflows", "workflows"),
-        MenuItem("m", "Memory", "memory"),
-        MenuItem("e", "Metrics", "metrics"),
-        MenuItem("o", "Orchestrator", "orchestrator"),
-    ]
-
-    current_screen = reactive("dashboard")
-
-    @dataclass
-    class ItemSelected(Message):
-        """Message sent when a menu item is selected."""
-
-        item: MenuItem
-
-    def compose(self) -> ComposeResult:
-        with Vertical():
-            for item in self.MENU_ITEMS:
-                yield MenuItemWidget(
-                    item,
-                    selected=(item.screen_id == self.current_screen),
-                    id=f"menu-{item.screen_id}",
-                )
-
-    def watch_current_screen(self, screen_id: str) -> None:
-        """Update selected state when current screen changes."""
-        # Skip if not yet composed
-        if not self.is_mounted:
-            return
-        for item in self.MENU_ITEMS:
-            try:
-                widget = self.query_one(f"#menu-{item.screen_id}", MenuItemWidget)
-                widget.selected = item.screen_id == screen_id
-            except NoMatches:
-                pass  # Widget not yet mounted
-
-    def select_screen(self, screen_id: str) -> None:
-        """Programmatically select a screen."""
-        self.current_screen = screen_id
-        for item in self.MENU_ITEMS:
-            if item.screen_id == screen_id:
-                self.post_message(self.ItemSelected(item))
-                break
-
-    def get_key_bindings(self) -> dict[str, str]:
-        """Return key -> screen_id mapping for binding setup."""
-        return {item.key: item.screen_id for item in self.MENU_ITEMS}

gobby/tui/widgets/message_panel.py

@@ -1,160 +0,0 @@
-"""Inter-agent message panel widget."""
-
-from __future__ import annotations
-
-from datetime import datetime
-from typing import Any
-
-from textual.app import ComposeResult
-from textual.containers import Horizontal, VerticalScroll
-from textual.reactive import reactive
-from textual.widget import Widget
-from textual.widgets import Static
-
-
-class AgentMessage(Static):
-    """A single agent message display."""
-
-    DEFAULT_CSS = """
-    AgentMessage {
-        height: 1;
-        padding: 0 1;
-    }
-
-    AgentMessage.--outgoing {
-        color: #06b6d4;
-    }
-
-    AgentMessage.--incoming {
-        color: #cdd6f4;
-    }
-
-    AgentMessage .message-arrow {
-        width: 2;
-    }
-
-    AgentMessage .message-sender {
-        color: #a6adc8;
-        width: 12;
-    }
-
-    AgentMessage .message-content {
-        width: 1fr;
-    }
-
-    AgentMessage .message-time {
-        color: #6c7086;
-        width: 8;
-    }
-    """
-
-    def __init__(
-        self,
-        sender: str,
-        content: str,
-        direction: str = "incoming",
-        timestamp: str | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        self.sender = sender
-        self.content = content
-        self.direction = direction
-        self.timestamp = timestamp or datetime.now().strftime("%H:%M:%S")
-        self.add_class(f"--{direction}")
-
-    def compose(self) -> ComposeResult:
-        arrow = "→" if self.direction == "outgoing" else "←"
-        with Horizontal():
-            yield Static(arrow, classes="message-arrow")
-            yield Static(f"[{self.sender}]", classes="message-sender")
-            yield Static(str(self.content)[:60], classes="message-content")
-            yield Static(self.timestamp[-8:], classes="message-time")
-
-
-class InterAgentMessagePanel(Widget):
-    """Panel showing real-time inter-agent messages."""
-
-    DEFAULT_CSS = """
-    InterAgentMessagePanel {
-        height: 1fr;
-        border: round #45475a;
-    }
-
-    InterAgentMessagePanel .panel-header {
-        height: 1;
-        padding: 0 1;
-        background: #313244;
-    }
-
-    InterAgentMessagePanel .panel-title {
-        text-style: bold;
-        color: #a78bfa;
-    }
-
-    InterAgentMessagePanel .messages-scroll {
-        height: 1fr;
-        padding: 1;
-    }
-
-    InterAgentMessagePanel .empty-state {
-        content-align: center middle;
-        height: 1fr;
-        color: #6c7086;
-    }
-    """
-
-    messages: reactive[list[dict[str, Any]]] = reactive(list)
-    max_messages = 100
-
-    def compose(self) -> ComposeResult:
-        yield Static("💬 Inter-Agent Messages", classes="panel-header panel-title")
-
-        if not self.messages:
-            yield Static("No messages yet", classes="empty-state")
-        else:
-            with VerticalScroll(classes="messages-scroll", id="messages-scroll"):
-                for msg in self.messages[-20:]:  # Show last 20
-                    yield AgentMessage(
-                        sender=msg.get("sender", "unknown"),
-                        content=msg.get("content", ""),
-                        direction=msg.get("direction", "incoming"),
-                        timestamp=msg.get("timestamp"),
-                    )
-
-    def watch_messages(self, messages: list[dict[str, Any]]) -> None:
-        """Scroll to bottom when messages change."""
-        # Schedule scroll after recompose completes
-        self.call_after_refresh(self._scroll_to_end)
-
-    def _scroll_to_end(self) -> None:
-        """Scroll the message panel to the end."""
-        try:
-            scroll = self.query_one("#messages-scroll", VerticalScroll)
-            scroll.scroll_end(animate=False)
-        except Exception:
-            pass  # nosec B110 - widget may not be mounted yet
-
-    def add_message(
-        self,
-        sender: str,
-        content: str,
-        direction: str = "incoming",
-    ) -> None:
-        """Add a new message to the panel."""
-        new_messages = list(self.messages)
-        new_messages.append(
-            {
-                "sender": sender,
-                "content": content,
-                "direction": direction,
-                "timestamp": datetime.now().isoformat(),
-            }
-        )
-
-        # Keep only the last max_messages - reactive will trigger recompose
-        self.messages = new_messages[-self.max_messages :]
-
-    def clear_messages(self) -> None:
-        """Clear all messages."""
-        self.messages = []

gobby/tui/widgets/review_gate.py

@@ -1,224 +0,0 @@
-"""Review gate panel widget."""
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-from datetime import UTC, datetime
-from typing import Any
-
-from textual.app import ComposeResult
-from textual.containers import Horizontal, VerticalScroll
-from textual.message import Message
-from textual.reactive import reactive
-from textual.widget import Widget
-from textual.widgets import Button, Static
-
-
-class ReviewItem(Static):
-    """A single review queue item."""
-
-    DEFAULT_CSS = """
-    ReviewItem {
-        height: 2;
-        padding: 0 1;
-    }
-
-    ReviewItem:hover {
-        background: #45475a;
-    }
-
-    ReviewItem.--selected {
-        background: #6d28d9;
-    }
-
-    ReviewItem .review-content {
-        layout: horizontal;
-    }
-
-    ReviewItem .review-ref {
-        color: #a855f7;
-        width: 12;
-    }
-
-    ReviewItem .review-title {
-        width: 1fr;
-    }
-
-    ReviewItem .review-wait {
-        color: #6c7086;
-        width: 8;
-    }
-    """
-
-    selected = reactive(False)
-
-    def __init__(self, task_data: dict[str, Any], **kwargs: Any) -> None:
-        super().__init__(**kwargs)
-        self.task_data = task_data
-
-    def compose(self) -> ComposeResult:
-        ref = self.task_data.get("ref", "")
-        title = self.task_data.get("title", "Untitled")[:30]
-        if len(self.task_data.get("title", "")) > 30:
-            title += "..."
-
-        # Calculate wait time
-        updated = self.task_data.get("updated_at", "")
-        if updated:
-            try:
-                # Parse ISO format, normalize to UTC
-                updated_dt = datetime.fromisoformat(updated.replace("Z", "+00:00"))
-                # Ensure timezone-aware comparison
-                if updated_dt.tzinfo is None:
-                    updated_dt = updated_dt.replace(tzinfo=UTC)
-                now = datetime.now(UTC)
-                wait = now - updated_dt
-                minutes = int(wait.total_seconds() // 60)
-                wait_str = f"⏳{minutes}m"
-            except ValueError as e:
-                # Log parsing errors for debugging
-                logging.getLogger(__name__).debug(f"Failed to parse updated_at: {updated!r}: {e}")
-                wait_str = "⏳?"
-        else:
-            wait_str = "⏳?"
-
-        with Horizontal(classes="review-content"):
-            yield Static(ref, classes="review-ref")
-            yield Static(title, classes="review-title")
-            yield Static(wait_str, classes="review-wait")
-
-    def watch_selected(self, selected: bool) -> None:
-        """Update selected class."""
-        self.set_class(selected, "--selected")
-
-    def on_click(self) -> None:
-        """Handle click to select."""
-        self.post_message(ReviewGatePanel.ItemSelected(self.task_data))
-
-
-class ReviewGatePanel(Widget):
-    """Panel showing tasks awaiting review with approve/reject actions."""
-
-    DEFAULT_CSS = """
-    ReviewGatePanel {
-        height: 1fr;
-        border: round #45475a;
-    }
-
-    ReviewGatePanel .panel-header {
-        layout: horizontal;
-        height: 1;
-        padding: 0 1;
-        background: #313244;
-    }
-
-    ReviewGatePanel .panel-title {
-        text-style: bold;
-        color: #a78bfa;
-        width: 1fr;
-    }
-
-    ReviewGatePanel .queue-count {
-        color: #a855f7;
-    }
-
-    ReviewGatePanel .review-list {
-        height: 1fr;
-        padding: 1;
-    }
-
-    ReviewGatePanel .action-row {
-        layout: horizontal;
-        height: 3;
-        padding: 1;
-        border-top: solid #45475a;
-    }
-
-    ReviewGatePanel .action-row Button {
-        margin-right: 1;
-    }
-
-    ReviewGatePanel .empty-state {
-        content-align: center middle;
-        height: 1fr;
-        color: #6c7086;
-    }
-    """
-
-    tasks: reactive[list[dict[str, Any]]] = reactive(list)
-    selected_task: reactive[dict[str, Any] | None] = reactive(None)
-
-    @dataclass
-    class ItemSelected(Message):
-        """Message sent when a review item is selected."""
-
-        task: dict[str, Any]
-
-    @dataclass
-    class TaskApproved(Message):
-        """Message sent when a task is approved."""
-
-        task: dict[str, Any]
-
-    @dataclass
-    class TaskRejected(Message):
-        """Message sent when a task is rejected."""
-
-        task: dict[str, Any]
-
-    def compose(self) -> ComposeResult:
-        review_tasks = [t for t in self.tasks if t.get("status") == "review"]
-
-        with Horizontal(classes="panel-header"):
-            yield Static("📋 Review Queue", classes="panel-title")
-            yield Static(f"({len(review_tasks)})", classes="queue-count")
-
-        if not review_tasks:
-            yield Static("No tasks awaiting review", classes="empty-state")
-        else:
-            with VerticalScroll(classes="review-list"):
-                for task in review_tasks:
-                    item = ReviewItem(task_data=task, id=f"review-{task.get('id', '')}")
-                    if self.selected_task and task.get("id") == self.selected_task.get("id"):
-                        item.selected = True
-                    yield item
-
-            with Horizontal(classes="action-row"):
-                yield Button("Approve", variant="success", id="btn-approve")
-                yield Button("Reject", variant="error", id="btn-reject")
-
-    def on_review_gate_panel_item_selected(self, event: ItemSelected) -> None:
-        """Handle item selection."""
-        self.selected_task = event.task
-        self._update_selection()
-
-    def _update_selection(self) -> None:
-        """Update selected state of all items."""
-        for task in self.tasks:
-            try:
-                item = self.query_one(f"#review-{task.get('id', '')}", ReviewItem)
-                item.selected = self.selected_task is not None and task.get(
-                    "id"
-                ) == self.selected_task.get("id")
-            except Exception:
-                pass  # nosec B110 - widget may not be mounted yet
-
-    def on_button_pressed(self, event: Button.Pressed) -> None:
-        """Handle action button presses."""
-        if not self.selected_task:
-            return
-
-        if event.button.id == "btn-approve":
-            self.post_message(self.TaskApproved(self.selected_task))
-        elif event.button.id == "btn-reject":
-            self.post_message(self.TaskRejected(self.selected_task))
-
-    def update_tasks(self, tasks: list[dict[str, Any]]) -> None:
-        """Update the tasks list."""
-        self.tasks = tasks
-        self.refresh(recompose=True)
-
-    def get_selected_task(self) -> dict[str, Any] | None:
-        """Get the currently selected task."""
-        return self.selected_task