patchfeld 0.2.0__py3-none-any.whl

patchfeld/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 patchfeld.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

patchfeld/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)

patchfeld/widgets/notebook.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+
+from textual.widgets import TextArea
+
+
+class Notebook(TextArea):
+    """Persistent scratch buffer at <cwd>/.patchfeld/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) / ".patchfeld" / "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"

patchfeld/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 patchfeld.events import EventBus, UserMessageToOrchestrator
+from patchfeld.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()

patchfeld/widgets/permission_modal.py

@@ -0,0 +1,185 @@
+from typing import Callable, Literal
+
+from claude_agent_sdk import PermissionResultAllow, PermissionResultDeny
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical, Horizontal, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+from patchfeld.agents.permission_grants import PermissionGrants
+from patchfeld.agents.permission_inbox import PermissionInbox
+from patchfeld.events import (
+    EventBus, PermissionRequested, PermissionResolved,
+)
+
+
+_ORCHESTRATOR = "orchestrator"
+
+
+class PermissionModal(ModalScreen[None]):
+    """Global permission-prompt modal.
+
+    Subscribes to PermissionRequested. While at least one request is
+    pending, displays the head of the queue with Allow/Deny buttons +
+    explicit-scope variants. Resolves directly via the session's
+    PermissionInbox; uses the bus to receive new requests and to broadcast
+    PermissionResolved so the per-agent transcript bar can clear its
+    inline view.
+    """
+
+    DEFAULT_CSS = """
+    PermissionModal { align: center middle; }
+    PermissionModal > Vertical {
+        width: 90; height: auto; padding: 1 2;
+        background: $surface; border: round $warning;
+    }
+    PermissionModal #title { text-style: bold; }
+    PermissionModal #scope-hint { color: $text-muted; text-style: italic; }
+    PermissionModal #buttons { height: 3; align-horizontal: center; }
+    PermissionModal Button { margin: 0 1; }
+    PermissionModal #tool-args-scroll {
+        max-height: 8;
+        height: auto;
+        border: round $surface-lighten-1;
+        margin: 1 0;
+        padding: 0 1;
+    }
+    PermissionModal #tool-args {
+        width: auto;
+    }
+    """
+
+    BINDINGS = [Binding("escape", "deny_once", "deny once")]
+
+    def __init__(
+        self,
+        *,
+        inbox_lookup: Callable[[str], PermissionInbox | None],
+        grants: PermissionGrants,
+        initial_request: PermissionRequested | None = None,
+    ) -> None:
+        super().__init__()
+        self._inbox_lookup = inbox_lookup
+        self._grants = grants
+        self._queue: list[PermissionRequested] = []
+        self._current_request: PermissionRequested | None = initial_request
+        self._unsub_req = lambda: None
+        self._unsub_res = lambda: None
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static("Permission requested", id="title")
+            yield Label("(no pending request)", id="prompt")
+            yield Label("", id="agent")
+            with VerticalScroll(id="tool-args-scroll"):
+                yield Static("", id="tool-args")
+            yield Label("", id="scope-hint")
+            with Horizontal(id="buttons"):
+                yield Button("Allow once", id="allow-once", variant="success")
+                yield Button(
+                    "Allow for the rest of this run",
+                    id="allow-session", variant="success",
+                )
+                yield Button("Always allow", id="allow-always", variant="success")
+                yield Button("Deny once", id="deny-once", variant="error")
+                yield Button("Always deny", id="deny-always", variant="error")
+
+    def on_mount(self) -> None:
+        bus: EventBus = self.app.event_bus
+        self._unsub_req = bus.subscribe(PermissionRequested, self._on_request)
+        self._unsub_res = bus.subscribe(PermissionResolved, self._on_resolved_elsewhere)
+        if self._current_request is not None:
+            self._render_current()
+
+    def on_unmount(self) -> None:
+        self._unsub_req()
+        self._unsub_res()
+
+    def _on_request(self, event: PermissionRequested) -> None:
+        if self._current_request is None:
+            self._current_request = event
+            self._render_current()
+        else:
+            self._queue.append(event)
+
+    def _on_resolved_elsewhere(self, event: PermissionResolved) -> None:
+        if (self._current_request is not None
+                and self._current_request.request_id == event.request_id):
+            self._advance()
+            return
+        self._queue = [q for q in self._queue if q.request_id != event.request_id]
+
+    def _render_current(self) -> None:
+        req = self._current_request
+        if req is None:
+            return
+        self.query_one("#prompt", Label).update(
+            req.title or f"Allow {req.tool_name}?"
+        )
+        self.query_one("#agent", Label).update(f"agent: {req.agent_name}")
+        import json as _json
+        try:
+            pretty = _json.dumps(req.tool_input, indent=2, ensure_ascii=False)
+        except (TypeError, ValueError):
+            pretty = repr(req.tool_input)
+        self.query_one("#tool-args", Static).update(
+            f"{req.tool_name}\n{pretty}"
+        )
+        if req.agent_name == _ORCHESTRATOR:
+            scope_text = "Always applies to the orchestrator session"
+        else:
+            scope_text = f"Always applies to future agents named {req.agent_name!r}"
+        self.query_one("#scope-hint", Label).update(scope_text)
+
+    def _advance(self) -> None:
+        if self._queue:
+            self._current_request = self._queue.pop(0)
+            self._render_current()
+        else:
+            self._current_request = None
+            self.dismiss(None)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if self._current_request is None:
+            return
+        bid = event.button.id
+        if bid == "allow-once":
+            self._resolve("allow", scope=None)
+        elif bid == "allow-session":
+            self._resolve("allow", scope="session")
+        elif bid == "allow-always":
+            self._resolve("allow", scope="persistent")
+        elif bid == "deny-once":
+            self._resolve("deny", scope=None)
+        elif bid == "deny-always":
+            self._resolve("deny", scope="persistent")
+
+    def action_deny_once(self) -> None:
+        if self._current_request is None:
+            self.dismiss(None)
+            return
+        self._resolve("deny", scope=None)
+
+    def _resolve(self, behavior: Literal["allow", "deny"], *, scope: Literal["persistent", "session"] | None) -> None:
+        req = self._current_request
+        if req is None:
+            return
+        if scope is not None:
+            self._grants.remember(
+                agent_name=req.agent_name, tool_name=req.tool_name,
+                behavior=behavior, scope=scope,
+            )
+        result = (
+            PermissionResultAllow() if behavior == "allow"
+            else PermissionResultDeny(message="user denied")
+        )
+        inbox = self._inbox_lookup(req.agent_id)
+        if inbox is not None:
+            inbox.resolve(req.request_id, result)
+        # Advance before publishing so _on_resolved_elsewhere skips this ID.
+        self._advance()
+        self.app.event_bus.publish(PermissionResolved(
+            agent_id=req.agent_id, request_id=req.request_id,
+            behavior=behavior,
+        ))

patchfeld/widgets/permission_request_bar.py

@@ -0,0 +1,90 @@
+from typing import Literal, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from patchfeld.agents.permission_grants import PermissionGrants
+
+from claude_agent_sdk import PermissionResultAllow, PermissionResultDeny
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Button, Static
+
+from patchfeld.events import PermissionRequested, PermissionResolved
+
+
+class PermissionRequestBar(Horizontal):
+    """A single inline approval row mounted at the top of an AgentTranscript
+    while a permission request is pending for that agent.
+
+    Clicks call into the agent's PermissionInbox via the App's manager;
+    coordination with the global modal happens through PermissionResolved.
+    """
+
+    DEFAULT_CSS = """
+    PermissionRequestBar {
+        height: 3;
+        background: $warning-darken-2;
+        padding: 0 1;
+    }
+    PermissionRequestBar Static.label { width: 1fr; }
+    PermissionRequestBar Button { margin: 0 1; }
+    """
+
+    def __init__(self, *, request: PermissionRequested) -> None:
+        super().__init__()
+        self._request = request
+
+    @property
+    def request_id(self) -> str:
+        return self._request.request_id
+
+    def compose(self) -> ComposeResult:
+        req = self._request
+        title = req.title or f"Allow {req.tool_name}?"
+        yield Static(
+            f"⚠ {title} — {req.tool_name}({_short(req.tool_input)})",
+            classes="label",
+        )
+        yield Button("Allow", id="bar-allow-once", variant="success")
+        yield Button("Always allow", id="bar-allow-always", variant="success")
+        yield Button("Deny", id="bar-deny-once", variant="error")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = event.button.id
+        grants = getattr(self.app, "_permission_grants", None)
+        if bid == "bar-allow-once":
+            self._resolve("allow", scope=None, grants=grants)
+        elif bid == "bar-allow-always":
+            self._resolve("allow", scope="persistent", grants=grants)
+        elif bid == "bar-deny-once":
+            self._resolve("deny", scope=None, grants=grants)
+
+    def _resolve(
+        self,
+        behavior: Literal["allow", "deny"],
+        *,
+        scope: Literal["persistent", "session"] | None,
+        grants: "PermissionGrants | None",
+    ) -> None:
+        req = self._request
+        if scope is not None and grants is not None:
+            grants.remember(
+                agent_name=req.agent_name, tool_name=req.tool_name,
+                behavior=behavior, scope=scope,
+            )
+        manager = getattr(self.app, "manager", None)
+        inbox = manager.get_permission_inbox(req.agent_id) if manager else None
+        if inbox is not None:
+            result = (
+                PermissionResultAllow() if behavior == "allow"
+                else PermissionResultDeny(message="user denied")
+            )
+            inbox.resolve(req.request_id, result)
+        self.app.event_bus.publish(PermissionResolved(
+            agent_id=req.agent_id, request_id=req.request_id,
+            behavior=behavior,
+        ))
+
+
+def _short(value: object, limit: int = 80) -> str:
+    s = repr(value)
+    return s if len(s) <= limit else s[: limit - 1] + "…"

patchfeld/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 patchfeld.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)"
+
+