patchbai 0.1.0__py3-none-any.whl

patchbai/widgets/markdown.py

@@ -0,0 +1,65 @@
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import VerticalScroll
+from textual.widgets import Markdown as _TxMarkdown
+
+
+class MarkdownPanel(VerticalScroll):
+    """Renders markdown text from `source` or `file_path`, wrapped in a
+    VerticalScroll so long documents are scrollable. The internal
+    `_markdown` attribute holds the source string for tests.
+
+    The class is named `MarkdownPanel` rather than `Markdown` to avoid
+    a CSS type-selector collision with `textual.widgets.Markdown`. Textual's
+    Markdown widget declares `Markdown { height: auto; overflow-y: hidden; }`
+    in its DEFAULT_CSS; because Textual matches type selectors by class
+    `__name__` and (when SCOPED_CSS=True) only prepends the scope when the
+    rule's first selector differs from the scope name, those rules would
+    otherwise leak onto our outer container — sizing it to its content and
+    suppressing the scrollbar. With distinct class names, each widget's
+    DEFAULT_CSS stays in its own lane. The public alias `Markdown` below
+    preserves the existing import surface and registry name."""
+
+    DEFAULT_CSS = """
+    MarkdownPanel {
+        border: round $surface-lighten-2;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(
+        self,
+        *,
+        source: str | None = None,
+        file_path: str | None = None,
+    ) -> None:
+        super().__init__()
+        if source is None and file_path is not None:
+            try:
+                source = Path(file_path).read_text(encoding="utf-8")
+            except FileNotFoundError:
+                source = f"*File not found: {file_path}*"
+            except Exception as e:
+                source = f"*Error loading {file_path}: {e}*"
+        if source is None:
+            source = ""
+        self._markdown = source
+
+    def compose(self) -> ComposeResult:
+        yield _TxMarkdown(self._markdown)
+
+    @classmethod
+    def default_border_title(cls, props: dict) -> str:
+        file_path = props.get("file_path")
+        if file_path:
+            return f"Markdown: {Path(file_path).name}"
+        return "Markdown"
+
+
+# Public alias: keep `from patchbai.widgets.markdown import Markdown` working
+# and the registry name "Markdown" stable. Aliasing does NOT change the
+# class's `__name__` (still "MarkdownPanel"), which is the property Textual
+# uses for CSS type-selector matching — so the leak from textual's own
+# Markdown rule is avoided.
+Markdown = MarkdownPanel

patchbai/widgets/new_tab_screen.py

@@ -0,0 +1,31 @@
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, Static
+
+
+class NewTabScreen(ModalScreen[str | None]):
+    """Tiny modal that asks for a tab title and dismisses with the entered
+    string (or None on escape)."""
+
+    DEFAULT_CSS = """
+    NewTabScreen { align: center middle; }
+    NewTabScreen > Vertical {
+        width: 50; height: auto; padding: 1 2;
+        background: $surface; border: round $primary;
+    }
+    """
+
+    BINDINGS = [("escape", "cancel", "cancel")]
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static("New tab title:")
+            yield Input(placeholder="e.g., Logs", id="new-tab-input")
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        title = (event.value or "").strip()
+        self.dismiss(title or None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

patchbai/widgets/notebook.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+
+from textual.widgets import TextArea
+
+
+class Notebook(TextArea):
+    """Persistent scratch buffer at <cwd>/.patchbai/scratch/<name>.md."""
+
+    DEFAULT_CSS = """
+    Notebook {
+        border: round $surface-lighten-2;
+    }
+    """
+
+    def __init__(self, *, name: str) -> None:
+        super().__init__("", language="markdown")
+        self._name = name
+
+    def _path(self) -> Path:
+        cwd = getattr(self.app, "cwd", Path.cwd())
+        return Path(cwd) / ".patchbai" / "scratch" / f"{self._name}.md"
+
+    def on_mount(self) -> None:
+        path = self._path()
+        if path.exists():
+            try:
+                self.text = path.read_text(encoding="utf-8")
+            except Exception:
+                pass
+
+    def _save(self) -> None:
+        path = self._path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(self.text, encoding="utf-8")
+
+    def on_text_area_changed(self, _event) -> None:
+        # Saves on every keystroke. Cheap for a scratchpad-sized file.
+        self._save()
+
+    @classmethod
+    def default_border_title(cls, props: dict) -> str:
+        name = props.get("name")
+        if name:
+            return f"Note: {name}"
+        return "Note"

patchbai/widgets/orchestrator_chat.py

@@ -0,0 +1,73 @@
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.widgets import Input
+
+from patchbai.events import EventBus, UserMessageToOrchestrator
+from patchbai.widgets.rich_transcript import RichTranscript
+
+
+class OrchestratorChat(Vertical):
+    """Manager-Claude chat panel: RichTranscript + input box."""
+
+    AGENT_ID = "orchestrator"
+    DEFAULT_BORDER_TITLE = "Orchestrator"
+
+    DEFAULT_CSS = """
+    OrchestratorChat {
+        border: round $primary;
+        padding: 0 1;
+    }
+    OrchestratorChat > RichTranscript {
+        height: 1fr;
+    }
+    OrchestratorChat #orch-input {
+        dock: bottom;
+        height: 3;
+    }
+    """
+
+    # priority=True so the binding fires even when the Input child has
+    # focus — without it, ctrl+c is consumed by Textual's default driver
+    # handling (which would quit the app).
+    BINDINGS = [
+        Binding("ctrl+c", "interrupt", "interrupt orchestrator", priority=True),
+    ]
+
+    def __init__(self, *, event_bus: EventBus | None = None) -> None:
+        super().__init__()
+        self._bus = event_bus
+
+    def compose(self) -> ComposeResult:
+        path = None
+        try:
+            orch = getattr(self.app, "orchestrator", None)
+            if orch is not None:
+                path = orch.active_transcript_path
+        except Exception:
+            path = None
+        yield RichTranscript(
+            agent_id=self.AGENT_ID, event_bus=self._bus, transcript_path=path,
+        )
+        yield Input(
+            placeholder=(
+                "Message orchestrator… "
+                "(/reset, /resume, /rename, /help, ctrl+c to interrupt)"
+            ),
+            id="orch-input",
+        )
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if not event.value.strip():
+            return
+        text = event.value
+        bus = self._bus or getattr(self.app, "event_bus", None)
+        event.input.value = ""
+        if bus is not None:
+            bus.publish(UserMessageToOrchestrator(text))
+
+    async def action_interrupt(self) -> None:
+        orch = getattr(self.app, "orchestrator", None)
+        if orch is None:
+            return
+        await orch.interrupt()

patchbai/widgets/resume_screen.py

@@ -0,0 +1,179 @@
+import time
+
+from textual.binding import Binding
+from textual.containers import Container
+from textual.screen import ModalScreen
+from textual.widgets import DataTable, Footer, Input, Label
+
+from patchbai.persistence.orchestrator_sessions import (
+    OrchestratorSessionEntry,
+    OrchestratorSessionsIndex,
+)
+
+
+class ResumeScreen(ModalScreen[str | None]):
+    """Pick a past orchestrator session. Esc dismisses with None;
+    Enter dismisses with the selected session_id."""
+
+    DEFAULT_CSS = """
+    ResumeScreen {
+        align: center middle;
+    }
+    ResumeScreen > Container {
+        width: 80%;
+        height: 70%;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    ResumeScreen DataTable {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "dismiss_none", "cancel"),
+        Binding("enter", "select", "resume"),
+        Binding("e", "rename_row", "rename"),
+    ]
+
+    def __init__(self, *, index: OrchestratorSessionsIndex) -> None:
+        super().__init__()
+        self._index = index
+        self._ordered_ids: list[str] = []
+
+    def compose(self):
+        with Container():
+            yield Label("Resume orchestrator session  ·  e: rename"
+                        "  ·  enter: resume  ·  esc: cancel")
+            yield DataTable(cursor_type="row")
+            yield Footer()
+
+    def on_mount(self) -> None:
+        self._refresh_table()
+
+    def _refresh_table(self) -> None:
+        table = self.query_one(DataTable)
+        table.clear(columns=True)
+        table.add_columns("when", "title", "turns", "tokens", "id")
+        entries = sorted(self._index.list(), key=lambda e: e.last_activity, reverse=True)
+        now = time.time()
+        self._ordered_ids = []
+        for e in entries:
+            table.add_row(
+                _relative_time(now - e.last_activity),
+                _display_title(e),
+                str(e.num_turns),
+                f"{e.tokens_in}/{e.tokens_out}",
+                e.session_id,
+                key=e.session_id,
+            )
+            self._ordered_ids.append(e.session_id)
+        table.focus()
+
+    def _row_session_ids(self) -> list[str]:
+        return list(self._ordered_ids)
+
+    def action_dismiss_none(self) -> None:
+        self.dismiss(None)
+
+    def action_select(self) -> None:
+        table = self.query_one(DataTable)
+        if table.row_count == 0:
+            self.dismiss(None)
+            return
+        row_key = table.coordinate_to_cell_key(table.cursor_coordinate).row_key
+        self.dismiss(str(row_key.value))
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        # Stop the event so the App's global on_data_table_row_selected
+        # handler doesn't also fire and open a TranscriptScreen with our
+        # session_id (which isn't a real agent_id).
+        event.stop()
+        self.dismiss(str(event.row_key.value))
+
+    def action_rename_row(self) -> None:
+        table = self.query_one(DataTable)
+        if table.row_count == 0:
+            return
+        row_key = table.coordinate_to_cell_key(table.cursor_coordinate).row_key
+        sid = str(row_key.value)
+        entry = self._index.get(sid)
+        if entry is None:
+            return
+        current = entry.title or ""
+
+        def _on_renamed(new_title: str | None) -> None:
+            if new_title is None:
+                return  # cancelled
+            cleaned = new_title.strip()
+            self._index.set_title(sid, cleaned if cleaned else None)
+            self._refresh_table()
+
+        self.app.push_screen(_RenameTitleScreen(initial=current), _on_renamed)
+
+
+class _RenameTitleScreen(ModalScreen[str | None]):
+    """Tiny single-input modal for renaming a session title.
+
+    Returns the entered string (possibly empty) or None on cancel.
+    """
+
+    DEFAULT_CSS = """
+    _RenameTitleScreen {
+        align: center middle;
+    }
+    _RenameTitleScreen > Container {
+        width: 60%;
+        height: 7;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    """
+
+    BINDINGS = [Binding("escape", "cancel", "cancel")]
+
+    def __init__(self, *, initial: str = "") -> None:
+        super().__init__()
+        self._initial = initial
+
+    def compose(self):
+        with Container():
+            yield Label("Rename session title (enter to save, esc to cancel):")
+            yield Input(value=self._initial, id="rename-input")
+
+    def on_mount(self) -> None:
+        self.query_one("#rename-input", Input).focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+def _relative_time(seconds: float) -> str:
+    if seconds < 60:
+        return f"{int(seconds)}s ago"
+    if seconds < 3600:
+        return f"{int(seconds / 60)}m ago"
+    if seconds < 86400:
+        return f"{int(seconds / 3600)}h ago"
+    return f"{int(seconds / 86400)}d ago"
+
+
+def _truncate(s: str, n: int) -> str:
+    if len(s) <= n:
+        return s
+    return s[: n - 1] + "…"
+
+
+def _display_title(entry: OrchestratorSessionEntry) -> str:
+    if entry.title:
+        return _truncate(entry.title, 80)
+    if entry.first_user_message:
+        return _truncate(entry.first_user_message, 80)
+    return "(no title)"
+
+