patchbai 0.1.0__py3-none-any.whl

patchbai/widgets/terminal.py

@@ -0,0 +1,251 @@
+import asyncio
+import os
+import select
+
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.widgets import Static
+
+import ptyprocess
+import pyte
+
+from patchbai.widgets._terminal_keys import encode_key
+from patchbai.widgets._terminal_render import render_screen
+
+
+def _default_command() -> list[str]:
+    return [os.environ.get("SHELL", "/bin/sh")]
+
+
+class Terminal(Container):
+    """Real PTY hosted in a Textual panel.
+
+    Spawns a subprocess via ptyprocess.PtyProcessUnicode, feeds output
+    through pyte for ANSI emulation, and re-renders whenever the PTY fd
+    becomes readable via asyncio.add_reader. Anything typed here is
+    OPAQUE to the orchestrator (intentional escape-hatch behavior — use
+    this for an interactive `claude` CLI session inside Patchbai).
+
+    Props:
+      command: argv list (default: [$SHELL])
+      cwd: working directory (default: process cwd)
+      env: extra env vars merged into os.environ
+
+    Limitations: no mouse forwarding; no bracketed paste; no Kitty
+    keyboard protocol. POSIX-only (ptyprocess).
+    """
+
+    DEFAULT_CSS = """
+    Terminal {
+        border: round $surface-lighten-2;
+        padding: 0 1;
+        background: black;
+        color: white;
+    }
+    Terminal Static {
+        background: black;
+    }
+    """
+
+    can_focus = True
+
+    DEFAULT_COLS = 80
+    DEFAULT_ROWS = 24
+    HISTORY_LINES = 2000  # scrollback rows; memory grows linearly with terminal width
+    READ_BUDGET_BYTES = 64 * 1024  # per-tick drain cap; hitting it is fine — add_reader fires again next tick
+
+    def __init__(
+        self,
+        *,
+        command: list[str] | None = None,
+        cwd: str | None = None,
+        env: dict | None = None,
+    ) -> None:
+        super().__init__()
+        self._command = command or _default_command()
+        self._cwd = cwd
+        environ = dict(os.environ)
+        if env:
+            environ.update(env)
+        self._env = environ
+        self._pty = None
+        self._screen = pyte.HistoryScreen(self.DEFAULT_COLS, self.DEFAULT_ROWS, history=self.HISTORY_LINES)
+        self._stream = pyte.Stream(self._screen)
+        self._timer = None
+        self._reader_registered: bool = False
+        self._last_write: bytes | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="terminal-screen")
+
+    def on_mount(self) -> None:
+        try:
+            self._pty = ptyprocess.PtyProcessUnicode.spawn(
+                self._command,
+                cwd=self._cwd,
+                env=self._env,
+                dimensions=(self.DEFAULT_ROWS, self.DEFAULT_COLS),
+            )
+        except Exception as e:
+            self._show_error(f"PTY spawn failed: {e}")
+            return
+        loop = asyncio.get_running_loop()
+        loop.add_reader(self._pty.fd, self._tick)
+        self._reader_registered = True
+
+    def on_resize(self, event) -> None:
+        """Propagate Textual size changes to the PTY and the pyte screen.
+
+        Uses `self.content_size` (region shrunk by the styles gutter, i.e.
+        border + padding) as the authoritative inner dimensions. This is
+        populated by the time the Resize event fires, so we don't need to
+        consult the inner Static (whose auto-height can collapse to 1) or
+        subtract CSS chrome by hand.
+        """
+        if self._pty is None:
+            return
+        inner = self.content_size
+        cols = max(1, inner.width)
+        rows = max(1, inner.height)
+        if cols == self._screen.columns and rows == self._screen.lines:
+            return
+        # setwinsize and screen.resize form a logical pair: if one fails the
+        # other leaves the system in an inconsistent state, so they share a
+        # single guard. No logging in Phase 1 — failures are silent for now.
+        try:
+            self._pty.setwinsize(rows, cols)
+            self._screen.resize(rows, cols)
+        except Exception:
+            return
+        self._refresh()
+
+    def on_unmount(self) -> None:
+        self._teardown()
+
+    def _teardown(self) -> None:
+        if self._reader_registered and self._pty is not None:
+            try:
+                asyncio.get_running_loop().remove_reader(self._pty.fd)
+            except Exception:
+                pass
+            self._reader_registered = False
+        if self._timer is not None:
+            try:
+                self._timer.stop()
+            except Exception:
+                pass
+            self._timer = None
+        if self._pty is not None:
+            try:
+                self._pty.close(force=True)
+            except Exception:
+                pass
+            self._pty = None
+
+    def _announce_exit(self) -> None:
+        # Capture status if available before teardown clears _pty.
+        # Banner status: int (real exit code), or "?" sentinel when we can't determine it.
+        status: int | str = "?"
+        if self._pty is not None:
+            try:
+                ex = self._pty.exitstatus
+                if ex is None:
+                    # isalive() polls waitpid(WNOHANG) and populates exitstatus
+                    # as a side effect. Non-blocking; safe even if a grandchild
+                    # inherited the slave fd and is still running.
+                    if not self._pty.isalive():
+                        ex = self._pty.exitstatus
+                if ex is not None:
+                    status = ex
+            except Exception:
+                pass
+        banner = f"\r\n[process exited {status}]\r\n"
+        try:
+            self._stream.feed(banner)
+        except Exception:
+            pass
+        self._teardown()
+        self._refresh()
+
+    def action_restart(self) -> None:
+        """Respawn the subprocess in-place. Safe to call after exit."""
+        if self._pty is not None:
+            # Already running — nothing to do.
+            return
+        # Reset the screen so the old session's tail doesn't accumulate forever.
+        self._screen = pyte.HistoryScreen(
+            self._screen.columns, self._screen.lines, history=self.HISTORY_LINES
+        )
+        self._stream = pyte.Stream(self._screen)
+        self.on_mount()
+
+    def _tick(self) -> None:
+        if self._pty is None:
+            return
+        # Drain everything available without blocking, but bounded so a flooding
+        # child can't starve the asyncio loop. add_reader will fire again next tick.
+        any_data = False
+        bytes_read = 0
+        eof = False
+        while bytes_read < self.READ_BUDGET_BYTES:
+            try:
+                ready, _, _ = select.select([self._pty.fd], [], [], 0)
+                if not ready:
+                    break
+                chunk = self._pty.read(4096)
+            except EOFError:
+                eof = True
+                break
+            except Exception:
+                # TODO(phase 2): surface PTY read errors via _show_error
+                break
+            if not chunk:
+                eof = True
+                break
+            self._stream.feed(chunk)
+            bytes_read += len(chunk)
+            any_data = True
+        if eof:
+            self._announce_exit()
+        elif any_data:
+            self._refresh()
+
+    def _refresh(self) -> None:
+        try:
+            screen = self.query_one("#terminal-screen", Static)
+        except Exception:
+            return
+        text = render_screen(self._screen, show_cursor=True)
+        screen.update(text)
+
+    def _show_error(self, msg: str) -> None:
+        from rich.text import Text
+        try:
+            self.query_one("#terminal-screen", Static).update(Text(msg))
+        except Exception:
+            pass
+
+    def on_key(self, event) -> None:
+        if self._pty is None:
+            return
+        data = encode_key(event.key, event.character)
+        if data is None:
+            return
+        try:
+            # encode_key returns bytes; PtyProcessUnicode.write wraps a utf-8 text
+            # stream, so decode->re-encode is lossless for any output of encode_key
+            # (all paths produce well-formed utf-8).
+            self._pty.write(data.decode("utf-8", errors="replace"))
+        except Exception:
+            # TODO(phase 2): surface PTY write errors via _show_error
+            return
+        self._last_write = data
+        event.stop()
+
+    @classmethod
+    def default_border_title(cls, props: dict) -> str:
+        from pathlib import Path as _P
+        command = props.get("command")
+        if command and isinstance(command, list) and len(command) > 0:
+            return f"Terminal: {_P(command[0]).name}"
+        return "Terminal"

patchbai/widgets/theme_switcher.py

@@ -0,0 +1,63 @@
+from textual.binding import Binding
+from textual.containers import Container
+from textual.screen import ModalScreen
+from textual.widgets import Footer, Label, ListItem, ListView
+
+from patchbai.persistence.themes_store import NamedThemesStore
+
+
+class ThemeSwitcherScreen(ModalScreen[str | None]):
+    """Pick a theme. Esc dismisses with None; selecting dismisses with the name."""
+
+    DEFAULT_CSS = """
+    ThemeSwitcherScreen {
+        align: center middle;
+    }
+    ThemeSwitcherScreen > Container {
+        width: 50%;
+        height: 60%;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    ThemeSwitcherScreen ListView {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [Binding("escape", "dismiss_none", "cancel")]
+
+    def __init__(
+        self,
+        *,
+        store: NamedThemesStore,
+        available_builtins: list[str],
+        active: str,
+    ) -> None:
+        super().__init__()
+        self._store = store
+        self._builtins = list(available_builtins)
+        self._active = active
+
+    def compose(self):
+        items: list[ListItem] = []
+        for name in self._store.list():
+            label = f"* {name}" if name == self._active else f"  {name}"
+            items.append(ListItem(Label(label), name=name))
+        if self._builtins:
+            items.append(ListItem(Label("─ built-ins ─"), name=None))
+        for name in self._builtins:
+            label = f"* {name}" if name == self._active else f"  {name}"
+            items.append(ListItem(Label(label), name=name))
+        with Container():
+            yield Label("Load theme:")
+            yield ListView(*items)
+            yield Footer()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        if event.item.name is None:
+            return  # separator row — ignore
+        self.dismiss(event.item.name)
+
+    def action_dismiss_none(self) -> None:
+        self.dismiss(None)

patchbai/widgets/transcript_screen.py

@@ -0,0 +1,39 @@
+from textual.binding import Binding
+from textual.containers import Container
+from textual.screen import ModalScreen
+from textual.widgets import Footer
+
+from patchbai.events import EventBus
+from patchbai.widgets.agent_transcript import AgentTranscript
+
+
+class TranscriptScreen(ModalScreen[None]):
+    """Modal overlay showing one agent's transcript. Esc to dismiss."""
+
+    DEFAULT_CSS = """
+    TranscriptScreen {
+        align: center middle;
+    }
+    TranscriptScreen > Container {
+        width: 80%;
+        height: 80%;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    """
+
+    BINDINGS = [Binding("escape", "dismiss", "close")]
+
+    def __init__(self, agent_id: str, event_bus: EventBus | None = None) -> None:
+        super().__init__()
+        self._agent_id = agent_id
+        self._bus = event_bus
+
+    def compose(self):
+        with Container():
+            yield AgentTranscript(agent_id=self._agent_id, event_bus=self._bus)
+            yield Footer()
+
+    def action_dismiss(self) -> None:
+        self.dismiss(None)

patchbai/workspace/__init__.py

@@ -0,0 +1,3 @@
+from patchbai.workspace.spec import Tab, Workspace, workspace_from_layout
+
+__all__ = ["Tab", "Workspace", "workspace_from_layout"]

patchbai/workspace/spec.py

@@ -0,0 +1,72 @@
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from patchbai.layout.spec import LayoutSpec, Node, Panel, Tabs
+
+
+class Tab(BaseModel):
+    """One app-level tab. Owns its own LayoutSpec, which is independently
+    mutable. `id` is stable across the tab's lifetime and used by
+    switch_tab/close_tab tool calls. `title` is the user-facing tab-strip
+    label."""
+    model_config = ConfigDict(extra="forbid")
+
+    id: str
+    title: str
+    layout: LayoutSpec
+
+
+class Workspace(BaseModel):
+    """Top-level container. Holds a list of Tabs and an active id.
+
+    Invariants:
+    - Non-empty tab list.
+    - `active` references one of `tabs[].id`.
+    - At least one OrchestratorChat panel exists across all tabs combined.
+    - Tab ids are unique.
+    """
+    model_config = ConfigDict(extra="forbid")
+
+    version: int = 1
+    tabs: list[Tab] = Field(min_length=1)
+    active: str
+    active_theme: str | None = None
+
+    @model_validator(mode="after")
+    def _validate(self) -> "Workspace":
+        ids = [t.id for t in self.tabs]
+        if len(ids) != len(set(ids)):
+            raise ValueError(f"duplicate tab id in {ids}")
+        if self.active not in set(ids):
+            raise ValueError(
+                f"active tab id {self.active!r} not in tab ids {ids}"
+            )
+        if not any(_contains_chat(t.layout.layout) for t in self.tabs):
+            raise ValueError(
+                "Workspace must contain at least one OrchestratorChat panel "
+                "across all tabs"
+            )
+        return self
+
+
+def _contains_chat(node: Node) -> bool:
+    if isinstance(node, Panel):
+        return node.widget == "OrchestratorChat"
+    if isinstance(node, Tabs):
+        # Tabs.children is list[Panel] (leaf-only invariant in spec.py), so
+        # a flat scan is sufficient — no recursion needed. If Tabs ever
+        # accepts nested containers, this branch must recurse like Container.
+        return any(c.widget == "OrchestratorChat" for c in node.children)
+    # node is Container — exhausted by the discriminated Node union.
+    return any(_contains_chat(c) for c in node.children)
+
+
+def workspace_from_layout(spec: LayoutSpec, *, tab_id: str = "default",
+                          title: str = "default") -> Workspace:
+    """Build a single-tab Workspace wrapping a LayoutSpec — used by app
+    launch to seed the workspace from the built-in dashboard or migrate
+    a legacy layout.json."""
+    return Workspace(
+        version=1,
+        tabs=[Tab(id=tab_id, title=title, layout=spec)],
+        active=tab_id,
+    )