sondera-harness 0.6.0__py3-none-any.whl

sondera/tui/screens/trajectory.py

@@ -0,0 +1,158 @@
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Container
+from textual.screen import Screen
+from textual.widget import Widget
+from textual.widgets import Footer, Header, ListItem, ListView, Markdown, Pretty, Tree
+
+from sondera.types import AdjudicatedTrajectory
+
+
+class TrajectoryScreen(Screen):
+    """A screen for displaying a trajectory."""
+
+    BINDINGS = [
+        Binding("escape", "app.pop_screen", "Back to Dashboard"),
+        Binding("tab", "focus_next", "Next Widget", show=False),
+        Binding("shift+tab", "focus_previous", "Previous Widget", show=False),
+        Binding("j", "cursor_down", "Move Down", show=False),
+        Binding("k", "cursor_up", "Move Up", show=False),
+        Binding("h", "cursor_left", "Move Left", show=False),
+        Binding("l", "cursor_right", "Move Right", show=False),
+    ]
+
+    def __init__(self, trajectory: AdjudicatedTrajectory):
+        super().__init__()
+        self.trajectory = trajectory
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Container(id="sidebar"):
+            tree = Tree(f"Trajectory {self.trajectory.id}", id="trajectory-tree")
+            tree.root.expand()
+            for i, step in enumerate(self.trajectory.steps):
+                if step.step.role.value == "model":
+                    name = "🤖"
+                elif step.step.role.value == "tool":
+                    tool_id = step.step.content.tool_id
+                    name = f"🛠 [bold]({tool_id})[/bold]"
+                elif step.step.role.value == "user":
+                    name = "👤"
+                elif step.step.role.value == "system":
+                    name = "💻"
+                else:
+                    name = "UNKNOWN"
+                tree.root.add(f"[{i}] {name}")
+            yield tree
+        with ListView(id="trajectory-list"):
+            for i, step in enumerate(self.trajectory.steps):
+                with ListItem():
+                    if step.step.content.content_type == "prompt":
+                        row = Markdown(step.step.content.text, classes="step")
+                    else:
+                        row = Pretty(step.step.content, classes="step")
+                    title = f"Stage:{step.step.stage.value} | Decision:{step.adjudication.decision.value}"
+                    if step.step.role.value == "model":
+                        title = "🤖 [bold]MODEL[/bold] | " + title
+                    elif step.step.role.value == "tool":
+                        title = "🛠 [bold]TOOL[/bold] | " + title
+                    elif step.step.role.value == "user":
+                        title = "👤 [bold]USER[/bold] | " + title
+                    elif step.step.role.value == "system":
+                        title = "💻 [bold]SYSTEM[/bold] | " + title
+                    row.border_title = f"[{i}] {title}"
+                    row.border_subtitle = step.step.created_at.strftime(
+                        "%Y-%m-%d %H:%M:%S"
+                    )
+                    yield row
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Ensure widgets can receive focus."""
+        tree = self.query_one("#trajectory-tree", Tree)
+        list_view = self.query_one("#trajectory-list", ListView)
+        tree.can_focus = True
+        list_view.can_focus = True
+        # Focus the list view by default
+        list_view.focus()
+
+    def _get_focusable_widgets(self) -> list[Tree | ListView]:
+        """Get list of focusable widgets in order."""
+        return [
+            self.query_one("#trajectory-tree", Tree),
+            self.query_one("#trajectory-list", ListView),
+        ]
+
+    def _find_current_index(
+        self, widgets: list[Tree | ListView], focused: Widget | None
+    ) -> int | None:
+        """Find index of currently focused widget."""
+        if not focused:
+            return None
+
+        for i, widget in enumerate(widgets):
+            if widget == focused:
+                return i
+            # Check parent chain
+            parent = focused.parent
+            while parent:
+                if parent == widget:
+                    return i
+                parent = parent.parent
+        return None
+
+    def action_focus_next(self) -> None:
+        """Move focus to next focusable widget."""
+        widgets = self._get_focusable_widgets()
+        if not widgets:
+            return
+
+        current_index = self._find_current_index(widgets, self.focused)
+        next_index = (
+            (current_index + 1) % len(widgets) if current_index is not None else 0
+        )
+        widgets[next_index].focus()
+
+    def action_focus_previous(self) -> None:
+        """Move focus to previous focusable widget."""
+        widgets = self._get_focusable_widgets()
+        if not widgets:
+            return
+
+        current_index = self._find_current_index(widgets, self.focused)
+        prev_index = (
+            (current_index - 1) % len(widgets)
+            if current_index is not None
+            else len(widgets) - 1
+        )
+        widgets[prev_index].focus()
+
+    def action_cursor_left(self) -> None:
+        """Move cursor left or go to parent node."""
+        focused = self.focused
+        if isinstance(focused, Tree):
+            focused.action_cursor_parent()
+        elif isinstance(focused, ListView):
+            # ListView doesn't have left/right, so do nothing
+            pass
+
+    def action_cursor_right(self) -> None:
+        """Move cursor right or go to next sibling."""
+        focused = self.focused
+        if isinstance(focused, Tree):
+            focused.action_cursor_next_sibling()
+        elif isinstance(focused, ListView):
+            # ListView doesn't have left/right, so do nothing
+            pass
+
+    def action_cursor_up(self) -> None:
+        """Move cursor up."""
+        focused = self.focused
+        if isinstance(focused, (Tree, ListView)):
+            focused.action_cursor_up()
+
+    def action_cursor_down(self) -> None:
+        """Move cursor down."""
+        focused = self.focused
+        if isinstance(focused, (Tree, ListView)):
+            focused.action_cursor_down()

sondera/tui/widgets/__init__.py

@@ -0,0 +1,23 @@
+from .agent_card import AgentCard
+from .agent_list import AgentItem, AgentList, AgentRecord
+from .recent_adjudications import RecentAdjudications
+from .recent_trajectories import RecentTrajectories
+from .summary import Summary
+from .tool_card import ToolCard
+from .violation_panel import ViolationPanel
+from .violations_list import ViolationsList
+from .violations_summary import ViolationsSummary
+
+__all__ = [
+    "AgentCard",
+    "AgentItem",
+    "AgentList",
+    "AgentRecord",
+    "RecentAdjudications",
+    "RecentTrajectories",
+    "Summary",
+    "ToolCard",
+    "ViolationPanel",
+    "ViolationsList",
+    "ViolationsSummary",
+]

sondera/tui/widgets/agent_card.py

@@ -0,0 +1,94 @@
+from textual.app import ComposeResult
+from textual.containers import Grid, Vertical
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import ListView, Static
+
+from sondera.types import Agent
+
+from .tool_card import ToolCard
+
+
+class AgentCard(Widget):
+    """A reusable widget for displaying agent details in a grid layout."""
+
+    BORDER_TITLE = "Agent Details"
+
+    agent: reactive[Agent | None] = reactive(None)
+
+    def __init__(self, agent: Agent | None = None, **kwargs):
+        super().__init__(**kwargs)
+        self.agent = agent
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="agent-card-container"):
+            with Grid(id="agent-details-grid", classes="agent-details-grid"):
+                yield Static("[bold]ID:[/bold]", classes="label")
+                yield Static(
+                    self.agent.id if self.agent else "N/A",
+                    id="agent-id",
+                    classes="value",
+                )
+
+                yield Static("[bold]Name:[/bold]", classes="label")
+                yield Static(
+                    self.agent.name if self.agent else "N/A",
+                    id="agent-name",
+                    classes="value",
+                )
+
+                yield Static("[bold]Provider:[/bold]", classes="label")
+                yield Static(
+                    self.agent.provider_id if self.agent else "N/A",
+                    id="agent-provider",
+                    classes="value",
+                )
+
+                yield Static("[bold]Description:[/bold]", classes="label")
+                yield Static(
+                    self.agent.description if self.agent else "N/A",
+                    id="agent-description",
+                    classes="value description",
+                )
+
+                yield Static("[bold]Instruction:[/bold]", classes="label")
+                yield Static(
+                    self.agent.instruction if self.agent else "N/A",
+                    id="agent-instruction",
+                    classes="value instruction",
+                )
+
+            yield Static("[bold]Tools[/bold]", classes="section-header")
+            yield ListView(id="tools-list")
+
+    def on_mount(self) -> None:
+        """Populate tools list on mount."""
+        self._update_tools_list()
+
+    def watch_agent(self, _old_agent: Agent | None, new_agent: Agent | None) -> None:
+        """Update display when agent changes."""
+        if new_agent:
+            self._update_agent_details(new_agent)
+            self._update_tools_list()
+
+    def _update_agent_details(self, agent: Agent) -> None:
+        """Update the agent detail fields."""
+        try:
+            self.query_one("#agent-id", Static).update(agent.id)
+            self.query_one("#agent-name", Static).update(agent.name)
+            self.query_one("#agent-provider", Static).update(agent.provider_id)
+            self.query_one("#agent-description", Static).update(agent.description)
+            self.query_one("#agent-instruction", Static).update(agent.instruction)
+        except Exception:
+            pass  # Widgets may not be mounted yet during reactive updates
+
+    def _update_tools_list(self) -> None:
+        """Update the tools ListView."""
+        try:
+            tools_list = self.query_one("#tools-list", ListView)
+            tools_list.clear()
+            if self.agent and self.agent.tools:
+                for tool in self.agent.tools:
+                    tools_list.append(ToolCard(tool))
+        except Exception:
+            pass  # Widget may not be mounted yet during reactive updates

sondera/tui/widgets/agent_list.py

@@ -0,0 +1,73 @@
+from pydantic import BaseModel
+from textual.app import ComposeResult
+from textual.containers import Horizontal, HorizontalScroll
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Digits, ListItem, ListView, Markdown, Sparkline, Static
+
+from sondera.types import Agent
+
+
+class AgentRecord(BaseModel):
+    agent: Agent
+    total_trajectories: int
+    recent_trajectories: list[int] = [1, 2, 2, 1, 1, 4, 3, 1, 1, 8, 8, 2]
+
+
+class AgentItem(ListItem):
+    def __init__(self, element: AgentRecord):
+        super().__init__()
+        self.element = element
+        self.border_title = self.element.agent.name
+
+    def compose(self) -> ComposeResult:
+        with HorizontalScroll():
+            yield Static(self.element.agent.id, classes="column")
+            yield Static(self.element.agent.provider_id or "", classes="column")
+            yield Markdown(self.element.agent.description, classes="column")
+            tools = ", ".join([tool.name for tool in self.element.agent.tools])
+            yield Static(tools, classes="column")
+            yield Digits(str(self.element.total_trajectories))
+            yield Sparkline(
+                self.element.recent_trajectories, summary_function=max, classes="column"
+            )
+
+
+class AgentList(Widget):
+    BORDER_TITLE = "Agents"
+    BORDER_SUBTITLE = "List of agents"
+
+    records: reactive[list[AgentRecord]] = reactive([])
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="header"):
+            yield Static("Id", classes="header-column")
+            yield Static("Provider", classes="header-column")
+            yield Static("Description", classes="header-column")
+            yield Static("Tools", classes="header-column")
+            yield Static("Total Trajectories", classes="header-column")
+            yield Static("Recent Trajectories", classes="header-column")
+        yield ListView()
+
+    def on_mount(self) -> None:
+        """Ensure ListView can receive focus."""
+        list_view = self.query_one(ListView)
+        list_view.can_focus = True
+
+    def watch_records(
+        self, _old_agents: list[AgentRecord], new_agents: list[AgentRecord]
+    ) -> None:
+        """Update the list view when agents change."""
+        list_view = self.query_one(ListView)
+        list_view.clear()
+        for agent in new_agents:
+            list_view.append(AgentItem(agent))
+
+    def get_selected_agent(self) -> Agent | None:
+        """Get the currently selected agent from the list."""
+        list_view = self.query_one(ListView)
+        if list_view.highlighted_child is not None and isinstance(
+            list_view.highlighted_child, AgentItem
+        ):
+            return list_view.highlighted_child.element.agent
+        return None

sondera/tui/widgets/recent_adjudications.py

@@ -0,0 +1,52 @@
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import DataTable
+
+from sondera.types import AdjudicationRecord
+
+
+class RecentAdjudications(Widget):
+    BORDER_TITLE = "Recent Adjudications"
+
+    adjudications: reactive[list[AdjudicationRecord]] = reactive([])
+    agents_map: reactive[dict[str, str]] = reactive({})
+
+    HEADERS = ["Id", "Agent", "Provider", "Decision", "Reason"]
+
+    def compose(self) -> ComposeResult:
+        yield DataTable()
+
+    def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        table.add_columns(*self.HEADERS)
+        table.cursor_type = "row"
+        table.zebra_stripes = True
+        table.can_focus = True
+
+    def watch_adjudications(
+        self,
+        _old_adjudications: list[AdjudicationRecord],
+        new_adjudications: list[AdjudicationRecord],
+    ) -> None:
+        table = self.query_one(DataTable)
+        table.clear()
+        for record in new_adjudications:
+            provider = self.agents_map.get(record.agent_id, "N/A")
+            table.add_row(
+                record.trajectory_id[:6] + "...",
+                record.agent_id,
+                provider,
+                record.adjudication.decision.value.upper(),
+                record.adjudication.reason[:30] + "..."
+                if len(record.adjudication.reason) > 30
+                else record.adjudication.reason,
+            )
+
+    def get_selected_adjudication(self) -> AdjudicationRecord | None:
+        """Get the currently selected adjudication from the table."""
+        table = self.query_one(DataTable)
+        cursor_row = table.cursor_row
+        if cursor_row is not None and 0 <= cursor_row < len(self.adjudications):
+            return self.adjudications[cursor_row]
+        return None

sondera/tui/widgets/recent_trajectories.py

@@ -0,0 +1,54 @@
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import DataTable
+
+from sondera.types import AdjudicatedTrajectory
+
+
+class RecentTrajectories(Widget):
+    BORDER_TITLE = "Recent Trajectories"
+
+    trajectories: reactive[list[AdjudicatedTrajectory]] = reactive([])
+    agents_map: reactive[dict[str, str]] = reactive({})
+
+    HEADERS = ["Id", "Agent", "Provider", "Status", "Turns", "Last Active"]
+
+    def compose(self) -> ComposeResult:
+        yield DataTable()
+
+    def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        table.add_columns(*self.HEADERS)
+        table.cursor_type = "row"
+        table.zebra_stripes = True
+        # Ensure table can receive focus
+        table.can_focus = True
+
+    def watch_trajectories(
+        self,
+        _old_trajectories: list[AdjudicatedTrajectory],
+        new_trajectories: list[AdjudicatedTrajectory],
+    ) -> None:
+        table = self.query_one(DataTable)
+        table.clear()
+        for trajectory in new_trajectories:
+            provider = self.agents_map.get(trajectory.agent_id, "N/A")
+            table.add_row(
+                trajectory.id[:6] + "...",
+                trajectory.agent_id,
+                provider,
+                trajectory.status.value,
+                len(trajectory.steps),
+                trajectory.updated_at.strftime("%Y-%m-%d %H:%M:%S")
+                if trajectory.ended_at
+                else "N/A",
+            )
+
+    def get_selected_trajectory(self) -> AdjudicatedTrajectory | None:
+        """Get the currently selected trajectory from the table."""
+        table = self.query_one(DataTable)
+        cursor_row = table.cursor_row
+        if cursor_row is not None and 0 <= cursor_row < len(self.trajectories):
+            return self.trajectories[cursor_row]
+        return None

sondera/tui/widgets/summary.py

@@ -0,0 +1,57 @@
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Digits, Sparkline, Static
+
+
+class Summary(Widget):
+    BORDER_TITLE = "Summary"
+
+    running = reactive(0, recompose=True)
+    suspended = reactive(0, recompose=True)
+    completed = reactive(0, recompose=True)
+    failed = reactive(0, recompose=True)
+    pending = reactive(0, recompose=True)
+
+    violations = reactive(0, recompose=True)
+    approved = reactive(0, recompose=True)
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes="summary-section"):
+            yield Static("[bold]Trajectories[/bold]", classes="section-label")
+            with Container(classes="stat"):
+                yield Static("Running", classes="stat-label")
+                yield Digits(str(self.running), classes="stat-running")
+            with Container(classes="stat"):
+                yield Static("Suspended", classes="stat-label")
+                yield Digits(str(self.suspended), classes="stat-suspended")
+            with Container(classes="stat"):
+                yield Static("Completed", classes="stat-label")
+                yield Digits(str(self.completed), classes="stat-completed")
+            with Container(classes="stat"):
+                yield Static("Pending", classes="stat-label")
+                yield Digits(str(self.pending), classes="stat-pending")
+            with Container(classes="stat"):
+                yield Static("Failed", classes="stat-label")
+                yield Digits(str(self.failed), classes="stat-failed")
+        with Horizontal(classes="summary-section"):
+            yield Static("[bold]Policies[/bold]", classes="section-label")
+            with Container(classes="stat"):
+                yield Static("Violations", classes="stat-label")
+                yield Digits(str(self.violations), classes="stat-violations")
+            with Container(classes="stat"):
+                yield Static("Approved", classes="stat-label")
+                yield Digits(str(self.approved), classes="stat-approved")
+        with Horizontal(classes="summary-section"):
+            yield Static("[bold]Utility[/bold]", classes="section-label")
+            with Container(classes="stat"):
+                yield Static("Tokens: 0 tokens", classes="stat-label")
+                yield Sparkline(
+                    [0, 0, 100, 200, 300, 400, 500, 600, 700, 800], summary_function=max
+                )
+            with Container(classes="stat"):
+                yield Static("Cost: $0", classes="stat-label")
+                yield Sparkline(
+                    [0, 0, 100, 200, 300, 400, 500, 600, 700, 800], summary_function=max
+                )

sondera/tui/widgets/tool_card.py

@@ -0,0 +1,33 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import ListItem, Static
+
+from sondera.types import Tool
+
+
+class ToolCard(ListItem):
+    """A reusable widget for displaying tool details as a ListItem."""
+
+    def __init__(self, tool: Tool):
+        super().__init__()
+        self.tool = tool
+        self.border_title = f"🛠 {tool.name}"
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="tool-card-content"):
+            yield Static(
+                f"[bold]Description:[/bold] {self.tool.description}",
+                classes="tool-description",
+            )
+            if self.tool.parameters:
+                params_text = ", ".join(
+                    f"[cyan]{p.name}[/cyan]: {p.type}" for p in self.tool.parameters
+                )
+                yield Static(
+                    f"[bold]Parameters:[/bold] {params_text}", classes="tool-parameters"
+                )
+            if self.tool.response:
+                yield Static(
+                    f"[bold]Returns:[/bold] {self.tool.response}",
+                    classes="tool-response",
+                )

sondera/tui/widgets/violation_panel.py

@@ -0,0 +1,72 @@
+from textual.app import ComposeResult
+from textual.containers import Container, Grid, VerticalScroll
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Markdown, Static
+
+from sondera.types import AdjudicationRecord, Decision
+
+
+class ViolationPanel(Widget):
+    """Widget displaying detailed information about a selected violation/adjudication."""
+
+    BORDER_TITLE = "Violation Details"
+
+    adjudication: reactive[AdjudicationRecord | None] = reactive(None, recompose=True)
+
+    def compose(self) -> ComposeResult:
+        if self.adjudication is None:
+            yield Static(
+                "Select an adjudication to view details", classes="empty-message"
+            )
+            return
+
+        record = self.adjudication
+        decision = record.adjudication.decision
+
+        # Decision badge
+        if decision == Decision.DENY:
+            decision_class = "decision-deny"
+            decision_text = "❌ DENIED"
+        elif decision == Decision.ESCALATE:
+            decision_class = "decision-escalate"
+            decision_text = "⚠️ ESCALATED"
+        else:
+            decision_class = "decision-allow"
+            decision_text = "✅ ALLOWED"
+
+        yield Static(decision_text, classes=f"decision-badge {decision_class}")
+
+        # Details grid
+        with Grid(id="violation-details-grid"):
+            yield Static("Agent ID:", classes="label")
+            yield Static(record.agent_id, classes="value")
+
+            yield Static("Trajectory ID:", classes="label")
+            yield Static(record.trajectory_id, classes="value")
+
+            yield Static("Step ID:", classes="label")
+            yield Static(record.step_id, classes="value")
+
+        # Reason section
+        yield Static("[bold]Reason[/bold]", classes="section-header")
+        with Container(classes="reason-container"):
+            yield Markdown(record.adjudication.reason, classes="reason-text")
+
+        # Annotations section
+        annotations = record.adjudication.annotations
+        if annotations:
+            yield Static("[bold]Policy Annotations[/bold]", classes="section-header")
+            with VerticalScroll(classes="annotations-container"):
+                for ann in annotations:
+                    with Container(classes="annotation-card"):
+                        yield Static(f"[bold]{ann.id}[/bold]", classes="annotation-id")
+                        if ann.description:
+                            yield Static(
+                                ann.description, classes="annotation-description"
+                            )
+                        if ann.custom:
+                            with Grid(classes="annotation-custom-grid"):
+                                for key, value in ann.custom.items():
+                                    yield Static(f"{key}:", classes="label")
+                                    yield Static(value, classes="value")