patchfeld 0.2.0__py3-none-any.whl

patchfeld/widgets/agent_table.py

@@ -0,0 +1,236 @@
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Container
+from textual.widgets import DataTable
+
+from patchfeld.agents.sort import sort_agents
+from patchfeld.agents.state import AgentInfo
+from patchfeld.events import (
+    AgentArchiveChanged,
+    AgentFocusRequested,
+    AgentMessageAppended,
+    AgentSpawned,
+    AgentStateChanged,
+    EventBus,
+)
+from patchfeld.persistence.agents_index import AgentsIndex
+
+from patchfeld.agents.state import AgentState as _AgentState
+
+_STATUS_STYLES: dict[_AgentState, str] = {
+    _AgentState.IDLE: "dim",
+    _AgentState.RUNNING: "green",
+    _AgentState.WAITING: "yellow",
+    _AgentState.AWAITING_PERMISSION: "orange1",
+    _AgentState.DONE: "bold",
+    _AgentState.ERROR: "red",
+}
+
+
+class AgentTable(Container):
+    """Sortable table of agents — name, status, elapsed, last action, cost.
+
+    Archived agents are hidden by default; press `a` to toggle visibility,
+    `d` to archive (or un-archive, when shown) the cursor's agent.
+    """
+
+    DEFAULT_BORDER_TITLE = "Agents"
+
+    DEFAULT_CSS = """
+    AgentTable {
+        border: round $surface-lighten-2;
+        padding: 0 1;
+    }
+    AgentTable DataTable {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        Binding("d", "toggle_archive", "archive/unarchive"),
+        Binding("a", "toggle_show_archived", "show/hide archived"),
+    ]
+
+    COLUMNS = ("name", "status", "elapsed", "last action", "cost")
+
+    def __init__(self, *, event_bus: EventBus | None = None) -> None:
+        super().__init__()
+        self._bus = event_bus
+        # agent_id → row_key for DataTable updates. Only contains agents
+        # whose row is currently rendered (archived rows are absent when
+        # `_show_archived` is False).
+        self._rows: dict[str, str] = {}
+        # agent_id → last AgentInfo snapshot. This is the canonical source
+        # for filtering and re-rendering; it includes archived agents that
+        # may not currently have a row in the DataTable.
+        self._infos: dict[str, AgentInfo] = {}
+        # agent_id → most recent message text (last action).
+        self._last_actions: dict[str, str] = {}
+        # When False, archived agents are filtered out of the table.
+        self._show_archived: bool = False
+        self._unsubs: list = []
+
+    def compose(self) -> ComposeResult:
+        table = DataTable(zebra_stripes=True, cursor_type="row")
+        for col in self.COLUMNS:
+            table.add_column(col, key=col)
+        yield table
+
+    def on_mount(self) -> None:
+        # Seed past agents from disk so a fresh process boot still surfaces
+        # the agents the user spawned in the previous session. AgentManager
+        # has already reconciled any non-terminal records to ERROR, so what
+        # we read here is safe to display as-is.
+        cwd = getattr(self.app, "cwd", None)
+        if cwd is not None:
+            for info in AgentsIndex(cwd=cwd).load():
+                if info.id == "orchestrator":
+                    continue
+                # Just record into _infos; the rebuild below renders rows in order.
+                self._infos[info.id] = info
+            self._rebuild_sorted()
+
+        bus = self._bus or getattr(self.app, "event_bus", None)
+        if bus is None:
+            return
+        self._unsubs.append(bus.subscribe(AgentSpawned, self._on_spawned))
+        self._unsubs.append(bus.subscribe(AgentStateChanged, self._on_state))
+        self._unsubs.append(bus.subscribe(AgentMessageAppended, self._on_msg))
+        self._unsubs.append(
+            bus.subscribe(AgentArchiveChanged, self._on_archive_changed)
+        )
+        self._unsubs.append(
+            bus.subscribe(AgentFocusRequested, self._on_focus_requested)
+        )
+
+    def on_unmount(self) -> None:
+        for u in self._unsubs:
+            u()
+        self._unsubs = []
+
+    # --- event handlers ---------------------------------------------------
+
+    def _on_spawned(self, event: AgentSpawned) -> None:
+        # Record the new agent and rebuild so it lands at the right priority.
+        self._infos[event.info.id] = event.info
+        self._rebuild_sorted()
+
+    def _on_state(self, event: AgentStateChanged) -> None:
+        # Preserve any archived flag we already know about — AgentStateChanged
+        # is emitted by AgentSession with the live info, but the SDK side
+        # doesn't touch `archived`, so an existing snapshot's flag is the
+        # source of truth.
+        prev = self._infos.get(event.info.id)
+        if prev is not None and prev.archived and not event.info.archived:
+            event.info.archived = True
+        self._infos[event.info.id] = event.info
+        self._rebuild_sorted()
+
+    def _on_msg(self, event: AgentMessageAppended) -> None:
+        self._last_actions[event.agent_id] = f"[{event.role}] {event.text[:60]}"
+        if event.agent_id in self._infos:
+            # last_activity feeds the sort tiebreaker, so rebuild to let the
+            # row bubble up within its bucket and refresh its last-action cell.
+            self._rebuild_sorted()
+
+    def _on_archive_changed(self, event: AgentArchiveChanged) -> None:
+        self._infos[event.info.id] = event.info
+        self._rebuild_sorted()
+
+    def _on_focus_requested(self, event: AgentFocusRequested) -> None:
+        """Select the row matching event.agent_id and scroll it into view."""
+        agent_id = event.agent_id
+        if agent_id not in self._rows:
+            return
+        try:
+            table = self.query_one(DataTable)
+        except Exception:
+            return
+        for index, row_key in enumerate(table.rows.keys()):
+            if str(row_key.value) == agent_id:
+                table.move_cursor(row=index)
+                table.scroll_to(0, index, animate=False)
+                return
+
+    # --- actions ----------------------------------------------------------
+
+    def action_toggle_archive(self) -> None:
+        manager = getattr(self.app, "manager", None)
+        if manager is None:
+            return
+        agent_id = self._cursor_agent_id()
+        if agent_id is None:
+            return
+        info = self._infos.get(agent_id)
+        if info is None:
+            return
+        manager.set_archived(agent_id, archived=not info.archived)
+
+    def action_toggle_show_archived(self) -> None:
+        self._show_archived = not self._show_archived
+        self._rebuild_sorted()
+
+    # --- internals --------------------------------------------------------
+
+    def _cursor_agent_id(self) -> str | None:
+        table = self.query_one(DataTable)
+        if table.row_count == 0:
+            return None
+        try:
+            row_key = table.coordinate_to_cell_key(table.cursor_coordinate).row_key
+        except Exception:
+            return None
+        return None if row_key.value is None else str(row_key.value)
+
+    def _is_visible(self, info: AgentInfo) -> bool:
+        return self._show_archived or not info.archived
+
+    def _rebuild_sorted(self) -> None:
+        """Clear and re-add rows from `_infos` in default sort order, honoring
+        the visibility filter. Preserves the cursor's focused agent across the
+        rebuild so a sort-induced reorder doesn't snap the user back to row 0."""
+        table = self.query_one(DataTable)
+
+        # Capture cursor agent BEFORE clear(); coordinate_to_cell_key throws
+        # after the table is empty.
+        cursor_agent_id = self._cursor_agent_id()
+
+        table.clear()
+        self._rows.clear()
+
+        visible = [info for info in self._infos.values() if self._is_visible(info)]
+        for info in sort_agents(visible):
+            table.add_row(*self._render_cells(info), key=info.id)
+            self._rows[info.id] = info.id
+
+        # Restore cursor onto the same agent if it's still visible.
+        if cursor_agent_id is not None and cursor_agent_id in self._rows:
+            for index, row_key in enumerate(table.rows.keys()):
+                if str(row_key.value) == cursor_agent_id:
+                    table.move_cursor(row=index)
+                    break
+
+    def _render_cells(self, info: AgentInfo) -> tuple:
+        # Wrap each cell in Rich Text so values that may contain markup-like
+        # text (especially the "last action" cell which echoes tool args)
+        # render verbatim rather than tripping the markup parser.
+        from rich.text import Text
+        elapsed = info.elapsed_seconds()
+        elapsed_str = f"{elapsed:5.1f}s"
+        last = self._last_actions.get(info.id, "")
+        cost_str = f"${info.cost:.4f}"
+        if info.archived:
+            status = "archived"
+            status_style = ""
+            name = f"{info.name} (archived)"
+        else:
+            status = info.state.value
+            status_style = _STATUS_STYLES.get(info.state, "")
+            name = info.name
+        return (
+            Text(name),
+            Text(status, style=status_style),
+            Text(elapsed_str),
+            Text(last),
+            Text(cost_str),
+        )

patchfeld/widgets/agent_transcript.py

@@ -0,0 +1,85 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Input
+
+from patchfeld.events import DirectMessageToAgent, EventBus, PermissionRequested, PermissionResolved
+from patchfeld.widgets.rich_transcript import RichTranscript
+
+
+class AgentTranscript(Vertical):
+    """Per-child-agent transcript panel: RichTranscript + input box."""
+
+    DEFAULT_CSS = """
+    AgentTranscript {
+        border: round $surface-lighten-2;
+        padding: 0 1;
+    }
+    AgentTranscript > RichTranscript {
+        height: 1fr;
+    }
+    AgentTranscript #transcript-input {
+        dock: bottom;
+        height: 3;
+    }
+    """
+
+    def __init__(
+        self,
+        *,
+        agent_id: str,
+        event_bus: EventBus | None = None,
+    ) -> None:
+        super().__init__()
+        self._agent_id = agent_id
+        self._bus = event_bus
+        self._unsub_perm_req = lambda: None
+        self._unsub_perm_res = lambda: None
+
+    def compose(self) -> ComposeResult:
+        yield RichTranscript(agent_id=self._agent_id, event_bus=self._bus)
+        yield Input(placeholder=f"Message {self._agent_id}…", id="transcript-input")
+
+    def on_mount(self) -> None:
+        bus = self._bus or getattr(self.app, "event_bus", None)
+        if bus is not None:
+            self._unsub_perm_req = bus.subscribe(PermissionRequested, self._on_perm_request)
+            self._unsub_perm_res = bus.subscribe(PermissionResolved, self._on_perm_resolved)
+
+    def on_unmount(self) -> None:
+        self._unsub_perm_req()
+        self._unsub_perm_res()
+
+    def _on_perm_request(self, event: PermissionRequested) -> None:
+        if event.agent_id != self._agent_id:
+            return
+        from patchfeld.widgets.permission_request_bar import PermissionRequestBar
+        bar = PermissionRequestBar(request=event)
+        self.mount(bar, before=self.query_one(RichTranscript))
+
+    def _on_perm_resolved(self, event: PermissionResolved) -> None:
+        if event.agent_id != self._agent_id:
+            return
+        from patchfeld.widgets.permission_request_bar import PermissionRequestBar
+        for bar in list(self.query(PermissionRequestBar)):
+            if bar.request_id == event.request_id:
+                bar.remove()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        text = event.value.strip()
+        if not text:
+            return
+        bus = self._bus or getattr(self.app, "event_bus", None)
+        if bus is not None:
+            bus.publish(DirectMessageToAgent(agent_id=self._agent_id, text=text))
+        event.input.value = ""
+
+    def rendered_text(self) -> str:
+        """Test helper — delegates to the inner RichTranscript."""
+        return self.query_one(RichTranscript).rendered_text()
+
+    @classmethod
+    def default_border_title(cls, props: dict) -> str:
+        agent_id = props.get("agent_id")
+        if agent_id:
+            return f"Agent: {agent_id}"
+        return "Agent"

patchfeld/widgets/change_cwd_screen.py

@@ -0,0 +1,39 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, Static
+
+
+class ChangeCwdScreen(ModalScreen[str | None]):
+    """Tiny modal that asks for a new workspace cwd. Dismisses with the
+    trimmed string on submit, or None on escape."""
+
+    DEFAULT_CSS = """
+    ChangeCwdScreen { align: center middle; }
+    ChangeCwdScreen > Vertical {
+        width: 70; height: auto; padding: 1 2;
+        background: $surface; border: round $primary;
+    }
+    """
+
+    BINDINGS = [("escape", "cancel", "cancel")]
+
+    def __init__(self, *, initial: str = "") -> None:
+        super().__init__()
+        self._initial = initial
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static("Change workspace cwd:")
+            yield Input(
+                value=self._initial,
+                placeholder="e.g., ~/Developer/other-project",
+                id="change-cwd-input",
+            )
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        path = (event.value or "").strip()
+        self.dismiss(path or None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

patchfeld/widgets/chrome.py

@@ -0,0 +1,210 @@
+import os
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Input, Static
+
+from patchfeld.events import EventBus, OrchestratorReply, UserMessageToOrchestrator
+
+
+def _format_cwd(path: Path, *, available_width: int) -> str:
+    """Render `path` for the StatusBar, abbreviating under $HOME and
+    left-truncating with '…/' to fit `available_width` characters.
+
+    Pure: no I/O, no widget access. Drives `_on_cwd_changed` and
+    `on_resize` in StatusBar.
+
+    Uses ``os.path.abspath`` rather than ``Path.resolve`` so the
+    formatter does not follow symlinks — the user sees the path they
+    typed (e.g. ``/var/log/foo``) rather than the kernel-canonical form
+    (``/private/var/log/foo`` on macOS). Path canonicalisation belongs
+    in the validation step inside ``App.change_cwd``, not in the footer.
+    """
+    try:
+        home = Path.home()
+        abs_p = Path(os.path.abspath(path))
+        try:
+            rel = abs_p.relative_to(home)
+            display = "~" + ("/" + str(rel) if str(rel) != "." else "")
+        except ValueError:
+            display = str(abs_p)
+    except Exception:
+        display = str(path)
+
+    if available_width <= 0 or len(display) <= available_width:
+        return display
+    # Try left-truncation that ends at a segment boundary.
+    parts = display.split("/")
+    # Keep peeling leading segments until "…/" + tail fits.
+    for keep in range(len(parts) - 1, 0, -1):
+        candidate = "…/" + "/".join(parts[-keep:])
+        if len(candidate) <= available_width:
+            return candidate
+    # Budget too tight even for "…/leaf" — return bare basename.
+    return parts[-1]
+
+
+class CommandBar(Horizontal):
+    """Top bar — `/` focuses; submitting sends to the orchestrator."""
+
+    DEFAULT_CSS = """
+    CommandBar {
+        height: 3;
+    }
+    """
+
+    def __init__(self, *, event_bus: EventBus | None = None) -> None:
+        super().__init__()
+        self._bus = event_bus
+        # True between a command-bar submit and the next OrchestratorReply.
+        # Gates the toast so replies from other input surfaces (the
+        # orchestrator chat panel) don't pop a toast as well.
+        self._awaiting_reply = False
+        self._unsub_reply = lambda: None
+
+    def compose(self) -> ComposeResult:
+        # Plain Textual Input with no styling overrides — default 3-row
+        # height, default colors, default focus behavior. Earlier attempts
+        # to compress this to 1-row (custom CSS, -textual-compact) clashed
+        # with Textual's color/cursor internals and produced invisible text.
+        yield Input(placeholder="message orchestrator", id="cmd-input")
+
+    def on_mount(self) -> None:
+        bus = self._bus or getattr(self.app, "event_bus", None)
+        if bus is not None:
+            self._unsub_reply = bus.subscribe(OrchestratorReply, self._on_reply)
+
+    def on_unmount(self) -> None:
+        self._unsub_reply()
+
+    def focus_input(self) -> None:
+        self.query_one("#cmd-input", Input).focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if not event.value.strip():
+            return
+        bus = self._bus or getattr(self.app, "event_bus", None)
+        if bus is not None:
+            self._awaiting_reply = True
+            bus.publish(UserMessageToOrchestrator(event.value))
+        event.input.value = ""
+
+    def _on_reply(self, event: OrchestratorReply) -> None:
+        if not self._awaiting_reply:
+            return
+        self._awaiting_reply = False
+        text = (event.text or "").strip()
+        if not text:
+            return
+        try:
+            self.app.notify(text, title="orchestrator")
+        except Exception:
+            pass
+
+
+class StatusBar(Horizontal):
+    """Bottom bar: tokens / cost / active agents / current layout name / [E]."""
+
+    DEFAULT_CSS = """
+    StatusBar {
+        height: 1;
+        background: $surface-darken-1;
+    }
+    StatusBar Static {
+        width: auto;
+        padding: 0 1;
+    }
+    /* The hints Static expands to absorb all leftover horizontal space and
+       right-aligns its text, parking the shortcut hint flush with the right
+       edge of the bar regardless of how wide the terminal is. The id selector
+       outranks the type selector above (CSS specificity), so it overrides
+       `width: auto` for this one widget. */
+    StatusBar #sb-hints {
+        width: 1fr;
+        text-align: right;
+        color: $text-muted;
+    }
+    """
+
+    def __init__(self, *, event_bus: EventBus | None = None,
+                 layout_name: str = "default") -> None:
+        super().__init__()
+        self._bus = event_bus
+        self._layout_name = layout_name
+        self._unsub = lambda: None
+        self._unsub_layout = lambda: None
+        self._unsub_cwd = lambda: None
+        self._cwd_path: Path | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static("tokens 0/0", id="sb-tokens")
+        yield Static("$0.00", id="sb-cost")
+        yield Static("0 agents", id="sb-agents")
+        yield Static(f"layout: {self._layout_name}", id="sb-layout")
+        yield Static("", id="sb-cwd")
+        yield Static("", id="sb-error")
+        # Always-visible hint for the two most fundamental keybindings:
+        # `?` opens the help notification, `Ctrl+Q` quits. Verified against
+        # PatchfeldApp.BINDINGS. New users never have to guess how to escape.
+        yield Static("? help · ^Q quit", id="sb-hints")
+
+    def on_mount(self) -> None:
+        from patchfeld.events import LayoutApplied, StatsUpdated, WorkspaceCwdChanged
+        bus = self._bus or getattr(self.app, "event_bus", None)
+        # Initial cwd render — read app.cwd directly so we display correctly
+        # even if the WorkspaceCwdChanged event was published before this
+        # widget mounted.
+        try:
+            cwd = getattr(self.app, "cwd", None)
+            if cwd is not None:
+                self._render_cwd(Path(cwd))
+        except Exception:
+            pass
+        if bus is None:
+            return
+        self._unsub = bus.subscribe(StatsUpdated, self._on_stats)
+        self._unsub_layout = bus.subscribe(LayoutApplied, self._on_layout_applied)
+        self._unsub_cwd = bus.subscribe(WorkspaceCwdChanged, self._on_cwd_changed)
+
+    def on_unmount(self) -> None:
+        self._unsub()
+        self._unsub_layout()
+        self._unsub_cwd()
+
+    def _on_stats(self, event) -> None:
+        self.query_one("#sb-tokens", Static).update(
+            f"tokens {event.tokens_in}/{event.tokens_out}"
+        )
+        self.query_one("#sb-cost", Static).update(f"${event.cost:.2f}")
+        self.query_one("#sb-agents", Static).update(f"{event.active_agents} agents")
+
+    def _on_layout_applied(self, event) -> None:
+        name = event.layout_name or "default"
+        self.set_layout_name(name)
+
+    def _render_cwd(self, path: Path) -> None:
+        self._cwd_path = path
+        widget = self.query_one("#sb-cwd", Static)
+        # Allocate roughly half the bar width to cwd, capped at 40 chars.
+        try:
+            container_width = max(self.size.width, 0)
+        except Exception:
+            container_width = 0
+        budget = max(0, min(40, container_width // 2 if container_width else 40))
+        widget.update(f"cwd: {_format_cwd(path, available_width=budget)}")
+
+    def _on_cwd_changed(self, event) -> None:
+        self._render_cwd(Path(event.cwd))
+
+    def on_resize(self, _event) -> None:
+        # Re-render so the cwd budget tracks the actual container width.
+        if self._cwd_path is not None:
+            self._render_cwd(self._cwd_path)
+
+    def set_layout_name(self, name: str) -> None:
+        self._layout_name = name
+        self.query_one("#sb-layout", Static).update(f"layout: {name}")
+
+    def set_error(self, msg: str | None) -> None:
+        self.query_one("#sb-error", Static).update("[E]" if msg else "")

patchfeld/widgets/diff_viewer.py

@@ -0,0 +1,52 @@
+import difflib
+
+from rich.syntax import Syntax
+from textual.containers import VerticalScroll
+from textual.widgets import Static
+
+
+def _compute_diff(before: str, after: str) -> str:
+    return "".join(
+        difflib.unified_diff(
+            before.splitlines(keepends=True),
+            after.splitlines(keepends=True),
+            fromfile="before",
+            tofile="after",
+        )
+    )
+
+
+class DiffViewer(VerticalScroll):
+    """Scrollable unified-diff viewer.
+
+    Accepts either a precomputed `diff: str` or a `before` + `after` pair from
+    which a unified diff is computed. The result is rendered as syntax-
+    highlighted `diff` content.
+    """
+
+    DEFAULT_BORDER_TITLE = "Diff"
+
+    DEFAULT_CSS = """
+    DiffViewer {
+        border: round $surface-lighten-2;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(
+        self,
+        *,
+        diff: str | None = None,
+        before: str | None = None,
+        after: str | None = None,
+    ) -> None:
+        super().__init__()
+        if diff is None and (before is not None or after is not None):
+            diff = _compute_diff(before or "", after or "")
+        self.diff_text = diff or ""
+
+    def compose(self):
+        if self.diff_text:
+            yield Static(Syntax(self.diff_text, "diff", theme="ansi_dark"))
+        else:
+            yield Static("[dim]No diff to display[/dim]")