gobby 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

gobby/tui/screens/workflows.py

@@ -1,289 +0,0 @@
-"""Workflows screen with active workflow state visualization."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any
-
-from textual.app import ComposeResult
-from textual.containers import Container, Horizontal, Vertical
-from textual.reactive import reactive
-from textual.widget import Widget
-from textual.widgets import (
-    Button,
-    DataTable,
-    LoadingIndicator,
-    Select,
-    Static,
-)
-
-from gobby.tui.api_client import GobbyAPIClient
-from gobby.tui.ws_client import GobbyWebSocketClient
-
-logger = logging.getLogger(__name__)
-
-
-class WorkflowStatePanel(Widget):
-    """Panel showing current workflow state."""
-
-    DEFAULT_CSS = """
-    WorkflowStatePanel {
-        height: auto;
-        padding: 1;
-        border: round #7c3aed;
-        margin: 1;
-    }
-
-    WorkflowStatePanel .state-title {
-        text-style: bold;
-        color: #a78bfa;
-        padding-bottom: 1;
-    }
-
-    WorkflowStatePanel .state-row {
-        layout: horizontal;
-        height: 1;
-    }
-
-    WorkflowStatePanel .state-label {
-        color: #a6adc8;
-        width: 16;
-    }
-
-    WorkflowStatePanel .state-value {
-        width: 1fr;
-    }
-
-    WorkflowStatePanel .state-active {
-        color: #22c55e;
-    }
-
-    WorkflowStatePanel .state-inactive {
-        color: #6c7086;
-    }
-    """
-
-    workflow_status: reactive[dict[str, Any] | None] = reactive(None)
-
-    def compose(self) -> ComposeResult:
-        yield Static("⚙️ Active Workflow", classes="state-title")
-
-        if self.workflow_status is None:
-            yield Static("No workflow active", classes="state-inactive")
-        else:
-            workflow = self.workflow_status.get("workflow")
-            if workflow:
-                with Horizontal(classes="state-row"):
-                    yield Static("Workflow:", classes="state-label")
-                    yield Static(
-                        workflow.get("name", "Unknown"), classes="state-value state-active"
-                    )
-                with Horizontal(classes="state-row"):
-                    yield Static("Current Step:", classes="state-label")
-                    yield Static(workflow.get("current_step", "N/A"), classes="state-value")
-                with Horizontal(classes="state-row"):
-                    yield Static("Type:", classes="state-label")
-                    yield Static(workflow.get("type", "unknown"), classes="state-value")
-            else:
-                yield Static("No workflow active", classes="state-inactive")
-
-    def watch_workflow_status(self, status: dict[str, Any] | None) -> None:
-        """Recompose when status changes."""
-        asyncio.create_task(self.recompose())
-
-
-class WorkflowsScreen(Widget):
-    """Workflows screen showing workflow state and controls."""
-
-    DEFAULT_CSS = """
-    WorkflowsScreen {
-        width: 1fr;
-        height: 1fr;
-    }
-
-    WorkflowsScreen .screen-header {
-        height: auto;
-        padding: 1;
-        background: #313244;
-    }
-
-    WorkflowsScreen .header-row {
-        layout: horizontal;
-    }
-
-    WorkflowsScreen .panel-title {
-        text-style: bold;
-        color: #a78bfa;
-        width: 1fr;
-    }
-
-    WorkflowsScreen #workflow-selector {
-        width: 30;
-        margin-right: 1;
-    }
-
-    WorkflowsScreen .content-area {
-        height: 1fr;
-        padding: 1;
-    }
-
-    WorkflowsScreen #available-workflows {
-        height: 1fr;
-    }
-
-    WorkflowsScreen .loading-container {
-        width: 1fr;
-        height: 1fr;
-        content-align: center middle;
-    }
-    """
-
-    loading = reactive(True)
-    workflow_status: reactive[dict[str, Any] | None] = reactive(None)
-    available_workflows: reactive[list[str]] = reactive(list)
-
-    def __init__(
-        self,
-        api_client: GobbyAPIClient,
-        ws_client: GobbyWebSocketClient,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        self.api_client = api_client
-        self.ws_client = ws_client
-
-    def compose(self) -> ComposeResult:
-        with Vertical(classes="screen-header"):
-            with Horizontal(classes="header-row"):
-                yield Static("🔄 Workflows", classes="panel-title")
-                yield Select(
-                    [(name, name) for name in self.available_workflows] or [("None", "")],
-                    value="",
-                    id="workflow-selector",
-                )
-                yield Button("Activate", variant="primary", id="btn-activate")
-                yield Button("Clear", id="btn-clear")
-                yield Button("Refresh", id="btn-refresh")
-
-        if self.loading:
-            with Container(classes="loading-container"):
-                yield LoadingIndicator()
-        else:
-            with Vertical(classes="content-area"):
-                yield WorkflowStatePanel(id="state-panel")
-                yield Static("Available Workflows", classes="panel-title")
-                yield DataTable(id="available-workflows")
-
-    async def on_mount(self) -> None:
-        """Load data when mounted."""
-        await self.refresh_data()
-
-    async def refresh_data(self) -> None:
-        """Refresh workflow status."""
-        workflows: list[dict[str, Any]] = []
-        try:
-            async with GobbyAPIClient(self.api_client.base_url) as client:
-                status = await client.get_workflow_status()
-                self.workflow_status = status
-
-                # Get available workflows list
-                result = await client.call_tool(
-                    "gobby-workflows",
-                    "list_workflows",
-                    {},
-                )
-                workflows = result.get("workflows", [])
-                self.available_workflows = [w.get("name", "") for w in workflows if w.get("name")]
-
-        except Exception as e:
-            self.notify(f"Failed to load workflow status: {e}", severity="error")
-        finally:
-            self.loading = False
-            await self.recompose()
-            await self._update_state_panel()
-            await self._setup_table(workflows)
-
-    async def _update_state_panel(self) -> None:
-        """Update the workflow state panel."""
-        try:
-            panel = self.query_one("#state-panel", WorkflowStatePanel)
-            panel.workflow_status = self.workflow_status
-        except Exception:
-            logger.debug("Failed to query state panel during async update", exc_info=True)  # nosec B110
-
-    async def _setup_table(self, workflows: list[dict[str, Any]] | None = None) -> None:
-        """Set up the available workflows table."""
-        try:
-            table = self.query_one("#available-workflows", DataTable)
-            table.clear(columns=True)
-            table.add_columns("Name", "Type", "Description")
-            table.cursor_type = "row"
-
-            # Use provided workflows instead of fetching again
-            if workflows is None:
-                workflows = []
-
-            for wf in workflows:
-                name = wf.get("name", "Unknown")
-                wf_type = wf.get("type", "unknown")
-                desc = wf.get("description", "")[:50]
-                table.add_row(name, wf_type, desc, key=name)
-
-        except Exception:
-            pass  # nosec B110 - TUI update failure is non-critical
-
-    async def on_button_pressed(self, event: Button.Pressed) -> None:
-        """Handle button presses."""
-        button_id = event.button.id
-
-        if button_id == "btn-activate":
-            await self._activate_workflow()
-
-        elif button_id == "btn-clear":
-            await self._clear_workflow()
-
-        elif button_id == "btn-refresh":
-            self.loading = True
-            await self.refresh_data()
-
-    async def _activate_workflow(self) -> None:
-        """Activate the selected workflow."""
-        try:
-            selector = self.query_one("#workflow-selector", Select)
-            workflow_name = str(selector.value)
-
-            if not workflow_name:
-                self.notify("Select a workflow first", severity="warning")
-                return
-
-            async with GobbyAPIClient(self.api_client.base_url) as client:
-                await client.activate_workflow(workflow_name)
-                self.notify(f"Activated workflow: {workflow_name}")
-
-            await self.refresh_data()
-
-        except Exception as e:
-            self.notify(f"Failed to activate workflow: {e}", severity="error")
-
-    async def _clear_workflow(self) -> None:
-        """Clear the active workflow."""
-        try:
-            async with GobbyAPIClient(self.api_client.base_url) as client:
-                await client.call_tool(
-                    "gobby-workflows",
-                    "deactivate_workflow",
-                    {},
-                )
-                self.notify("Workflow cleared")
-
-            await self.refresh_data()
-
-        except Exception as e:
-            self.notify(f"Failed to clear workflow: {e}", severity="error")
-
-    def on_ws_event(self, event_type: str, data: dict[str, Any]) -> None:
-        """Handle WebSocket events."""
-        # Refresh on workflow-related events
-        if event_type == "hook_event":
-            asyncio.create_task(self.refresh_data())

gobby/tui/screens/worktrees.py

@@ -1,174 +0,0 @@
-"""Worktrees screen with git worktree management."""
-
-from __future__ import annotations
-
-import asyncio
-from typing import Any
-
-from textual.app import ComposeResult
-from textual.containers import Container, Horizontal, Vertical
-from textual.reactive import reactive
-from textual.widget import Widget
-from textual.widgets import (
-    Button,
-    DataTable,
-    LoadingIndicator,
-    Static,
-)
-
-from gobby.tui.api_client import GobbyAPIClient
-from gobby.tui.ws_client import GobbyWebSocketClient
-
-
-class WorktreesScreen(Widget):
-    """Worktrees screen showing git worktree status."""
-
-    DEFAULT_CSS = """
-    WorktreesScreen {
-        width: 1fr;
-        height: 1fr;
-    }
-
-    WorktreesScreen .screen-header {
-        height: auto;
-        padding: 1;
-        background: #313244;
-    }
-
-    WorktreesScreen .header-row {
-        layout: horizontal;
-    }
-
-    WorktreesScreen .panel-title {
-        text-style: bold;
-        color: #a78bfa;
-        width: 1fr;
-    }
-
-    WorktreesScreen #worktrees-table {
-        height: 1fr;
-    }
-
-    WorktreesScreen .loading-container {
-        width: 1fr;
-        height: 1fr;
-        content-align: center middle;
-    }
-
-    WorktreesScreen .empty-state {
-        content-align: center middle;
-        height: 1fr;
-        color: #a6adc8;
-    }
-    """
-
-    loading = reactive(True)
-    worktrees: reactive[list[dict[str, Any]]] = reactive(list)
-    selected_worktree_id: reactive[str | None] = reactive(None)
-
-    def __init__(
-        self,
-        api_client: GobbyAPIClient,
-        ws_client: GobbyWebSocketClient,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        self.api_client = api_client
-        self.ws_client = ws_client
-
-    def compose(self) -> ComposeResult:
-        with Vertical(classes="screen-header"):
-            with Horizontal(classes="header-row"):
-                yield Static("🌳 Worktrees", classes="panel-title")
-                yield Button("+ Create", variant="primary", id="btn-create")
-                yield Button("Cleanup", id="btn-cleanup")
-                yield Button("Refresh", id="btn-refresh")
-
-        if self.loading:
-            with Container(classes="loading-container"):
-                yield LoadingIndicator()
-        elif not self.worktrees:
-            yield Static(
-                "No worktrees found. Create one to enable parallel development.",
-                classes="empty-state",
-            )
-        else:
-            yield DataTable(id="worktrees-table")
-
-    async def on_mount(self) -> None:
-        """Load data when mounted."""
-        await self.refresh_data()
-
-    async def refresh_data(self) -> None:
-        """Refresh worktree list."""
-        try:
-            worktrees = await self.api_client.list_worktrees()
-            self.worktrees = worktrees
-        except Exception as e:
-            self.notify(f"Failed to load worktrees: {e}", severity="error")
-        finally:
-            self.loading = False
-            await self.recompose()
-            await self._setup_table()
-
-    async def _setup_table(self) -> None:
-        """Set up and populate the worktrees table."""
-        if not self.worktrees:
-            return
-
-        try:
-            table = self.query_one("#worktrees-table", DataTable)
-            table.clear(columns=True)
-            table.add_columns("ID", "Branch", "Status", "Task", "Path")
-            table.cursor_type = "row"
-
-            for wt in self.worktrees:
-                wt_id = wt.get("id", "")[:12]
-                branch = wt.get("branch_name", "N/A")
-                status = wt.get("status", "unknown")
-                task_id = wt.get("task_id", "-")[:12] if wt.get("task_id") else "-"
-                wt_path = wt.get("path", "")
-                path = wt_path[-30:] if len(wt_path) > 30 else wt_path
-                table.add_row(wt_id, branch, status, task_id, path, key=wt.get("id"))
-
-        except Exception:
-            pass  # nosec B110 - TUI update failure is non-critical
-
-    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
-        """Handle worktree selection."""
-        self.selected_worktree_id = str(event.row_key.value) if event.row_key else None
-
-    async def on_button_pressed(self, event: Button.Pressed) -> None:
-        """Handle button presses."""
-        button_id = event.button.id
-
-        if button_id == "btn-create":
-            self.notify("Worktree creation dialog coming soon", severity="information")
-
-        elif button_id == "btn-cleanup":
-            await self._cleanup_worktrees()
-
-        elif button_id == "btn-refresh":
-            self.loading = True
-            await self.refresh_data()
-
-    async def _cleanup_worktrees(self) -> None:
-        """Clean up stale worktrees."""
-        try:
-            result = await self.api_client.call_tool(
-                "gobby-worktrees",
-                "cleanup_worktrees",
-                {},
-            )
-            cleaned = result.get("cleaned", 0)
-            self.notify(f"Cleaned up {cleaned} worktrees")
-
-            await self.refresh_data()
-
-        except Exception as e:
-            self.notify(f"Cleanup failed: {e}", severity="error")
-
-    def on_ws_event(self, event_type: str, data: dict[str, Any]) -> None:
-        """Handle WebSocket events."""
-        if event_type == "worktree_event":
-            asyncio.create_task(self.refresh_data())

gobby/tui/widgets/__init__.py

@@ -1,21 +0,0 @@
-"""TUI widgets for reusable components."""
-
-from gobby.tui.widgets.chat import ChatHistory, ChatInput
-from gobby.tui.widgets.conductor import HaikuDisplay, ModeIndicator
-from gobby.tui.widgets.menu import MenuPanel
-from gobby.tui.widgets.message_panel import InterAgentMessagePanel
-from gobby.tui.widgets.review_gate import ReviewGatePanel
-from gobby.tui.widgets.task_tree import TaskTree
-from gobby.tui.widgets.token_budget import TokenBudgetMeter
-
-__all__ = [
-    "MenuPanel",
-    "HaikuDisplay",
-    "ModeIndicator",
-    "TaskTree",
-    "TokenBudgetMeter",
-    "ReviewGatePanel",
-    "InterAgentMessagePanel",
-    "ChatHistory",
-    "ChatInput",
-]

gobby/tui/widgets/chat.py

@@ -1,210 +0,0 @@
-"""Chat widgets for LLM interface."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import 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, TextArea
-
-
-class ChatMessage(Static):
-    """A single chat message display."""
-
-    DEFAULT_CSS = """
-    ChatMessage {
-        padding: 1;
-        margin-bottom: 1;
-        height: auto;
-    }
-
-    ChatMessage.--user {
-        margin-left: 8;
-        background: #313244;
-        border: round #06b6d4;
-    }
-
-    ChatMessage.--assistant {
-        margin-right: 8;
-        background: #313244;
-        border: round #7c3aed;
-    }
-
-    ChatMessage.--system {
-        margin-left: 4;
-        margin-right: 4;
-        background: #45475a;
-        border: round #6c7086;
-    }
-
-    ChatMessage .message-header {
-        layout: horizontal;
-        height: 1;
-        margin-bottom: 1;
-    }
-
-    ChatMessage .message-sender {
-        text-style: bold;
-        width: 1fr;
-    }
-
-    ChatMessage.--user .message-sender {
-        color: #06b6d4;
-    }
-
-    ChatMessage.--assistant .message-sender {
-        color: #a78bfa;
-    }
-
-    ChatMessage.--system .message-sender {
-        color: #6c7086;
-    }
-
-    ChatMessage .message-time {
-        color: #6c7086;
-        width: auto;
-    }
-
-    ChatMessage .message-content {
-        color: #cdd6f4;
-    }
-    """
-
-    def __init__(
-        self,
-        sender: str,
-        content: str,
-        role: str = "user",
-        timestamp: str | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        self.sender = sender
-        self.content = content
-        self.role = role
-        self.timestamp = timestamp or datetime.now().strftime("%H:%M")
-        self.add_class(f"--{role}")
-
-    def compose(self) -> ComposeResult:
-        with Horizontal(classes="message-header"):
-            yield Static(self.sender, classes="message-sender")
-            yield Static(self.timestamp, classes="message-time")
-        yield Static(self.content, classes="message-content")
-
-
-class ChatHistory(VerticalScroll):
-    """Scrollable chat history container."""
-
-    DEFAULT_CSS = """
-    ChatHistory {
-        height: 1fr;
-        padding: 1;
-        background: #1e1e2e;
-    }
-    """
-
-    messages: reactive[list[dict[str, Any]]] = reactive(list)
-
-    def add_message(
-        self,
-        sender: str,
-        content: str,
-        role: str = "user",
-        timestamp: str | None = None,
-    ) -> None:
-        """Add a new message to the chat history."""
-        # Store message data
-        new_messages = list(self.messages)
-        new_messages.append(
-            {
-                "sender": sender,
-                "content": content,
-                "role": role,
-                "timestamp": timestamp or datetime.now().strftime("%H:%M"),
-            }
-        )
-        self.messages = new_messages
-
-        # Mount the widget
-        message = ChatMessage(sender, content, role, timestamp)
-        self.mount(message)
-        self.scroll_end(animate=False)
-
-    def clear_history(self) -> None:
-        """Clear all messages."""
-        self.messages = []
-        self.remove_children()
-
-
-class ChatInput(Widget):
-    """Chat input widget with send button."""
-
-    DEFAULT_CSS = """
-    ChatInput {
-        height: auto;
-        min-height: 4;
-        max-height: 10;
-        padding: 1;
-        border-top: solid #45475a;
-        background: #313244;
-    }
-
-    ChatInput .input-row {
-        layout: horizontal;
-        height: auto;
-    }
-
-    ChatInput #message-input {
-        width: 1fr;
-        height: auto;
-        min-height: 3;
-        margin-right: 1;
-    }
-
-    ChatInput #send-button {
-        width: 10;
-        height: 3;
-    }
-    """
-
-    @dataclass
-    class Submitted(Message):
-        """Message sent when user submits input."""
-
-        text: str
-
-    def compose(self) -> ComposeResult:
-        with Horizontal(classes="input-row"):
-            yield TextArea(id="message-input")
-            yield Button("Send", variant="primary", id="send-button")
-
-    def on_button_pressed(self, event: Button.Pressed) -> None:
-        """Handle send button press."""
-        if event.button.id == "send-button":
-            self._submit()
-
-    def _submit(self) -> None:
-        """Submit the current input."""
-        text_area = self.query_one("#message-input", TextArea)
-        text = text_area.text.strip()
-        if text:
-            self.post_message(self.Submitted(text))
-            text_area.clear()
-
-    def get_text(self) -> str:
-        """Get the current input text."""
-        return self.query_one("#message-input", TextArea).text
-
-    def clear(self) -> None:
-        """Clear the input."""
-        self.query_one("#message-input", TextArea).clear()
-
-    def focus_input(self) -> None:
-        """Focus the input field."""
-        self.query_one("#message-input", TextArea).focus()