patchfeld 0.2.0__py3-none-any.whl

patchfeld/widgets/file_editor.py

@@ -0,0 +1,258 @@
+import logging
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static, TextArea
+
+from patchfeld.events import FileSelected
+from patchfeld.widgets._file_lang import load_text as _load_text
+
+log = logging.getLogger(__name__)
+
+
+def _stat_or_none(path: Path) -> tuple[float, int] | None:
+    try:
+        st = path.stat()
+    except OSError:
+        return None
+    return st.st_mtime, st.st_size
+
+
+class FileEditor(TextArea):
+    """Editable, syntax-highlighted file editor.
+
+    Mirrors `FileViewer` for loading and language detection, plus:
+
+    - `Ctrl+S` saves the buffer to disk; the border title shows ` *` when
+      the buffer differs from the loaded baseline.
+    - With `follow_selection=True`, subscribes to `FileSelected` events on
+      the EventBus and reloads to show the selected file. If unsaved edits
+      exist when the path changes, prompts via `ConfirmDirtySwitchScreen`.
+    - At save time, if the file's mtime/size on disk diverges from what was
+      cached at load, prompts via `ConfirmOverwriteScreen` before writing.
+    """
+
+    DEFAULT_CSS = """
+    FileEditor {
+        border: round $surface-lighten-2;
+    }
+    """
+
+    BINDINGS = [
+        Binding("ctrl+s", "save", "save", show=False),
+    ]
+
+    def __init__(
+        self,
+        *,
+        file_path: str | None = None,
+        follow_selection: bool = False,
+    ) -> None:
+        if file_path is not None:
+            text, language = _load_text(Path(file_path))
+        else:
+            text, language = "", None
+        kwargs: dict = {}
+        if language is not None:
+            kwargs["language"] = language
+        super().__init__(text, **kwargs)
+        self._follow_selection = follow_selection
+        self._current_path: Path | None = Path(file_path) if file_path else None
+        self._loaded_text: str = text
+        self._dirty: bool = False
+        if self._current_path is not None:
+            stat = _stat_or_none(self._current_path)
+        else:
+            stat = None
+        self._loaded_mtime: float | None = stat[0] if stat else None
+        self._loaded_size: int | None = stat[1] if stat else None
+        self._unsub = lambda: None
+
+    def load_file(self, file_path: str) -> None:
+        path = Path(file_path)
+        text, language = _load_text(path)
+        self.text = text
+        if language is not None:
+            try:
+                self.language = language
+            except Exception:
+                pass
+        self._current_path = path
+        self._loaded_text = text
+        stat = _stat_or_none(path)
+        self._loaded_mtime = stat[0] if stat else None
+        self._loaded_size = stat[1] if stat else None
+        self._dirty = False
+        self._refresh_border_title()
+
+    def _on_file_selected(self, event: FileSelected) -> None:
+        new_path = Path(event.path)
+        if not self._dirty or new_path == self._current_path:
+            self.load_file(event.path)
+            return
+        self.run_worker(
+            self._handle_dirty_switch(event.path),
+            exclusive=True,
+        )
+
+    async def _handle_dirty_switch(self, new_path: str) -> None:
+        verb = await self.app.push_screen_wait(
+            ConfirmDirtySwitchScreen(
+                current_name=self._current_path.name if self._current_path else "",
+                new_name=Path(new_path).name,
+            )
+        )
+        if verb == "save":
+            saved = await self.action_save()
+            if saved:
+                self.load_file(new_path)
+        elif verb == "discard":
+            self.load_file(new_path)
+        # cancel: no-op
+
+    @property
+    def is_dirty(self) -> bool:
+        return self._dirty
+
+    def on_mount(self) -> None:
+        self._refresh_border_title()
+        if not self._follow_selection:
+            return
+        bus = getattr(self.app, "event_bus", None)
+        if bus is not None:
+            self._unsub = bus.subscribe(FileSelected, self._on_file_selected)
+
+    def on_unmount(self) -> None:
+        self._unsub()
+
+    def on_text_area_changed(self, _event) -> None:
+        new_dirty = self.text != self._loaded_text
+        if new_dirty != self._dirty:
+            self._dirty = new_dirty
+            self._refresh_border_title()
+
+    def _refresh_border_title(self) -> None:
+        if self._current_path is None:
+            self.border_title = "Edit"
+            return
+        name = self._current_path.name
+        self.border_title = f"Edit: {name} *" if self._dirty else f"Edit: {name}"
+
+    async def action_save(self) -> bool:
+        """Save the current buffer to disk. Returns True iff the file was written."""
+        if self._current_path is None:
+            return False
+        # No-baseline + no-edit short circuit: avoid writing the
+        # error-placeholder text after a failed load.
+        if self._loaded_mtime is None and self.text == self._loaded_text:
+            return False
+        if self._loaded_mtime is not None:
+            current = _stat_or_none(self._current_path)
+            if current is not None and (
+                current[0] != self._loaded_mtime
+                or current[1] != self._loaded_size
+            ):
+                verb = await self.app.push_screen_wait(
+                    ConfirmOverwriteScreen(name=self._current_path.name)
+                )
+                if verb != "overwrite":
+                    return False
+        try:
+            self._current_path.parent.mkdir(parents=True, exist_ok=True)
+            self._current_path.write_text(self.text, encoding="utf-8")
+        except OSError:
+            self.border_title = f"Edit: {self._current_path.name} (save failed)"
+            log.warning("FileEditor save failed: %s", self._current_path)
+            return False
+        stat = _stat_or_none(self._current_path)
+        if stat is not None:
+            self._loaded_mtime, self._loaded_size = stat
+        self._loaded_text = self.text
+        self._dirty = False
+        self._refresh_border_title()
+        return True
+
+    @classmethod
+    def default_border_title(cls, props: dict) -> str:
+        fp = props.get("file_path")
+        return f"Edit: {Path(fp).name}" if fp else "Edit"
+
+
+class ConfirmOverwriteScreen(ModalScreen[str]):
+    """Modal shown when Ctrl+S detects the file changed on disk since load.
+
+    Dismisses with one of: 'overwrite', 'cancel'.
+    """
+
+    DEFAULT_CSS = """
+    ConfirmOverwriteScreen { align: center middle; }
+    ConfirmOverwriteScreen > Vertical {
+        width: 60; height: auto; padding: 1 2;
+        background: $surface; border: round $primary;
+    }
+    ConfirmOverwriteScreen .row { height: auto; }
+    ConfirmOverwriteScreen Button { margin-right: 1; }
+    """
+
+    BINDINGS = [("escape", "cancel", "cancel")]
+
+    def __init__(self, *, name: str) -> None:
+        super().__init__()
+        self._filename = name
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static(
+                f"{self._filename} was changed on disk since you opened it. "
+                f"Overwrite anyway?"
+            )
+            yield Button("Overwrite", id="overwrite", variant="warning")
+            yield Button("Cancel", id="cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id or "cancel")
+
+    def action_cancel(self) -> None:
+        self.dismiss("cancel")
+
+
+class ConfirmDirtySwitchScreen(ModalScreen[str]):
+    """Modal shown when a FileSelected event would discard unsaved edits.
+
+    Dismisses with one of: 'save', 'discard', 'cancel'.
+    """
+
+    DEFAULT_CSS = """
+    ConfirmDirtySwitchScreen { align: center middle; }
+    ConfirmDirtySwitchScreen > Vertical {
+        width: 70; height: auto; padding: 1 2;
+        background: $surface; border: round $primary;
+    }
+    ConfirmDirtySwitchScreen Button { margin-right: 1; }
+    """
+
+    BINDINGS = [("escape", "cancel", "cancel")]
+
+    def __init__(self, *, current_name: str, new_name: str) -> None:
+        super().__init__()
+        self._current_name = current_name
+        self._new_name = new_name
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static(
+                f"Unsaved changes in {self._current_name or '(unsaved buffer)'}. "
+                f"Save & switch to {self._new_name}, discard, or cancel?"
+            )
+            yield Button("Save & Switch", id="save", variant="primary")
+            yield Button("Discard & Switch", id="discard", variant="warning")
+            yield Button("Cancel", id="cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id or "cancel")
+
+    def action_cancel(self) -> None:
+        self.dismiss("cancel")

patchfeld/widgets/file_tree.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+from textual.widgets import DirectoryTree
+
+from patchfeld.events import FileSelected
+
+
+class FileTree(DirectoryTree):
+    """Wraps Textual's DirectoryTree with a kw-only `path` prop. Publishes a
+    `FileSelected` event on the EventBus when the user selects a file —
+    other widgets (e.g. `FileViewer(follow_selection=True)`) can react."""
+
+    DEFAULT_CSS = """
+    FileTree {
+        border: round $surface-lighten-2;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(self, *, path: str) -> None:
+        super().__init__(Path(path))
+
+    def on_directory_tree_file_selected(self, event) -> None:
+        bus = getattr(self.app, "event_bus", None)
+        if bus is not None:
+            bus.publish(FileSelected(path=str(event.path)))
+
+    @classmethod
+    def default_border_title(cls, props: dict) -> str:
+        path = props.get("path")
+        if path:
+            return f"Files: {path}"
+        return "Files"

patchfeld/widgets/file_viewer.py

@@ -0,0 +1,77 @@
+from pathlib import Path
+
+from textual.widgets import TextArea
+
+from patchfeld.events import FileSelected
+from patchfeld.widgets._file_lang import load_text as _load_text
+
+
+class FileViewer(TextArea):
+    """Read-only file display with extension-based syntax highlighting.
+
+    Loads the entire file into memory at mount time — fine for typical
+    source files, but for log-sized content (>~1MB) prefer the LogTail
+    widget which streams from the end and polls for additions.
+
+    If `follow_selection=True`, subscribes to `FileSelected` events on the
+    EventBus and reloads to show the selected file. Pair with a `FileTree`
+    panel to get a click-a-file → see-its-content workflow:
+
+        {"id": "tree",   "widget": "FileTree",   "props": {"path": "."}}
+        {"id": "viewer", "widget": "FileViewer", "props": {"follow_selection": true}}
+    """
+
+    DEFAULT_CSS = """
+    FileViewer {
+        border: round $surface-lighten-2;
+    }
+    """
+
+    def __init__(
+        self,
+        *,
+        file_path: str | None = None,
+        follow_selection: bool = False,
+    ) -> None:
+        if file_path is not None:
+            text, language = _load_text(Path(file_path))
+        else:
+            text, language = "", None
+        kwargs: dict = {"read_only": True}
+        if language is not None:
+            kwargs["language"] = language
+        super().__init__(text, **kwargs)
+        self._follow_selection = follow_selection
+        self._unsub = lambda: None
+
+    def on_mount(self) -> None:
+        if not self._follow_selection:
+            return
+        bus = getattr(self.app, "event_bus", None)
+        if bus is None:
+            return
+        self._unsub = bus.subscribe(FileSelected, self._on_file_selected)
+
+    def on_unmount(self) -> None:
+        self._unsub()
+
+    def _on_file_selected(self, event: FileSelected) -> None:
+        self.load_file(event.path)
+
+    def load_file(self, file_path: str) -> None:
+        path = Path(file_path)
+        text, language = _load_text(path)
+        self.text = text
+        if language is not None:
+            try:
+                self.language = language
+            except Exception:
+                pass
+
+    @classmethod
+    def default_border_title(cls, props: dict) -> str:
+        from pathlib import Path as _P
+        file_path = props.get("file_path")
+        if file_path:
+            return f"File: {_P(file_path).name}"
+        return "File"

patchfeld/widgets/history_screen.py

@@ -0,0 +1,58 @@
+from textual.binding import Binding
+from textual.containers import Container
+from textual.screen import ModalScreen
+from textual.widgets import DataTable, Footer, Label
+
+from patchfeld.persistence.agents_index import AgentsIndex
+
+
+class HistoryScreen(ModalScreen[str | None]):
+    """Modal listing every agent in agents.json. Selecting dismisses with the id."""
+
+    DEFAULT_CSS = """
+    HistoryScreen {
+        align: center middle;
+    }
+    HistoryScreen > Container {
+        width: 75%;
+        height: 75%;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    HistoryScreen DataTable {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [Binding("escape", "dismiss_none", "cancel")]
+
+    COLUMNS = ("id", "name", "state", "started", "cost")
+
+    def __init__(self, index: AgentsIndex) -> None:
+        super().__init__()
+        self._index = index
+
+    def compose(self):
+        with Container():
+            yield Label("Agent history (Enter to view transcript, Esc to close):")
+            table = DataTable(zebra_stripes=True, cursor_type="row")
+            for col in self.COLUMNS:
+                table.add_column(col, key=col)
+            for info in self._index.load():
+                table.add_row(
+                    info.id,
+                    info.name,
+                    info.state.value,
+                    f"{info.started_at:.0f}",
+                    f"${info.cost:.4f}",
+                    key=info.id,
+                )
+            yield table
+            yield Footer()
+
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        self.dismiss(str(event.row_key.value))
+
+    def action_dismiss_none(self) -> None:
+        self.dismiss(None)

patchfeld/widgets/layout_switcher.py

@@ -0,0 +1,126 @@
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Footer, Label, ListItem, ListView, Static
+
+from patchfeld.persistence.layouts_store import NamedLayoutsStore
+
+
+class LayoutSwitcherScreen(ModalScreen[str | None]):
+    """Pick a saved layout. Esc dismisses with None; selecting dismisses with the name.
+
+    Pressing `d` on a row prompts via :class:`ConfirmDeleteLayoutScreen` and,
+    on confirmation, removes the layout's JSON file from disk and the row
+    from the picker. The currently-active layout is deleted just like any
+    other — the in-memory copy keeps working until the user reloads.
+    """
+
+    DEFAULT_CSS = """
+    LayoutSwitcherScreen {
+        align: center middle;
+    }
+    LayoutSwitcherScreen > Container {
+        width: 50%;
+        height: 60%;
+        border: thick $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+    LayoutSwitcherScreen ListView {
+        height: 1fr;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "dismiss_none", "cancel"),
+        Binding("d", "delete_selected", "delete"),
+    ]
+
+    def __init__(self, store: NamedLayoutsStore) -> None:
+        super().__init__()
+        self._store = store
+
+    def compose(self) -> ComposeResult:
+        items = [ListItem(Label(name), name=name) for name in self._store.list()]
+        with Container():
+            yield Label("Load layout:")
+            yield ListView(*items)
+            yield Footer()
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        self.dismiss(event.item.name)
+
+    def action_dismiss_none(self) -> None:
+        self.dismiss(None)
+
+    def action_delete_selected(self) -> None:
+        list_view = self.query_one(ListView)
+        item = list_view.highlighted_child
+        if item is None:
+            return
+        name = item.name
+        if not name:
+            return
+        # Capture the row's index so we can keep the cursor on the same row
+        # number after removal (or clamp to the new last row if we removed it).
+        index = list_view.index or 0
+
+        def _on_choice(choice: str | None) -> None:
+            if choice != "delete":
+                return
+            self._store.delete(name)
+            # `pop` returns AwaitComplete, which schedules the removal as a
+            # task immediately on construction — fire-and-forget is fine here.
+            list_view.pop(index)
+            new_count = len(list_view) - 1
+            if new_count > 0:
+                list_view.index = min(index, new_count - 1)
+            else:
+                list_view.index = None
+            self.app.notify(f"Deleted layout '{name}'")
+
+        self.app.push_screen(ConfirmDeleteLayoutScreen(name=name), _on_choice)
+
+
+class ConfirmDeleteLayoutScreen(ModalScreen[str]):
+    """Yes/No confirmation before unlinking a saved layout.
+
+    Dismisses with one of: 'delete', 'cancel'. The Cancel button holds focus
+    by default so a stray Enter doesn't destroy data.
+    """
+
+    DEFAULT_CSS = """
+    ConfirmDeleteLayoutScreen { align: center middle; }
+    ConfirmDeleteLayoutScreen > Vertical {
+        width: 60; height: auto; padding: 1 2;
+        background: $surface; border: round $primary;
+    }
+    ConfirmDeleteLayoutScreen Button { margin-right: 1; }
+    """
+
+    BINDINGS = [Binding("escape", "cancel", "cancel")]
+
+    def __init__(self, *, name: str) -> None:
+        super().__init__()
+        self.layout_name = name
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static(
+                f"Delete saved layout '{self.layout_name}'? "
+                f"This removes the file from disk; the active layout in "
+                f"memory is unaffected until you reload."
+            )
+            yield Button("Delete", id="delete", variant="error")
+            yield Button("Cancel", id="cancel", variant="primary")
+
+    def on_mount(self) -> None:
+        # Default focus to Cancel so an accidental Enter doesn't delete.
+        self.query_one("#cancel", Button).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id or "cancel")
+
+    def action_cancel(self) -> None:
+        self.dismiss("cancel")

patchfeld/widgets/log_tail.py

@@ -0,0 +1,113 @@
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import VerticalScroll
+from textual.widgets import Static
+
+
+class LogTail(VerticalScroll):
+    """Tails a file: shows existing content, polls every 250ms for additions."""
+
+    DEFAULT_CSS = """
+    LogTail {
+        border: round $surface-lighten-2;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(self, *, file_path: str, tail_lines: int = 200) -> None:
+        super().__init__()
+        self._path = Path(file_path)
+        self._tail_lines = tail_lines
+        self._fp = None
+        self._inode = None
+        self.text = ""
+        self._timer = None
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="log-tail-content")
+
+    def on_mount(self) -> None:
+        if not self._path.exists():
+            self.text = f"File not found: {self._path}"
+            self._update_static()
+            return
+        try:
+            lines = self._path.read_text(encoding="utf-8", errors="replace").splitlines()
+            self.text = "\n".join(lines[-self._tail_lines:])
+        except Exception as e:
+            self.text = f"Error reading {self._path}: {e}"
+            self._update_static()
+            return
+        self._update_static()
+        self._open_at_end()
+        self._timer = self.set_interval(0.25, self._tick)
+
+    def _open_at_end(self) -> None:
+        try:
+            self._fp = self._path.open("r", encoding="utf-8", errors="replace")
+            self._fp.seek(0, 2)
+            self._inode = self._path.stat().st_ino
+        except Exception:
+            self._fp = None
+            self._inode = None
+
+    def on_unmount(self) -> None:
+        if self._timer is not None:
+            self._timer.stop()
+            self._timer = None
+        if self._fp is not None:
+            try:
+                self._fp.close()
+            except Exception:
+                pass
+            self._fp = None
+
+    def _tick(self) -> None:
+        # Detect rotation: if the file's inode changed (or it disappeared
+        # and a new one took its place), close the old fp and reopen.
+        try:
+            current_inode = self._path.stat().st_ino if self._path.exists() else None
+        except Exception:
+            current_inode = None
+        if current_inode != getattr(self, "_inode", None):
+            if self._fp is not None:
+                try:
+                    self._fp.close()
+                except Exception:
+                    pass
+                self._fp = None
+            if current_inode is not None:
+                self._open_at_end()
+                # After rotation, read from the start of the new file so
+                # the user doesn't miss the first lines.
+                if self._fp is not None:
+                    try:
+                        self._fp.seek(0, 0)
+                    except Exception:
+                        pass
+
+        if self._fp is None:
+            return
+        new = self._fp.read()
+        if not new:
+            return
+        self.text = (self.text + "\n" + new).strip("\n")
+        self._update_static()
+        self.scroll_end(animate=False)
+
+    def _update_static(self) -> None:
+        # Wrap in Rich Text so arbitrary file content (which may contain
+        # bracket sequences that look like markup) renders verbatim.
+        from rich.text import Text
+        try:
+            self.query_one("#log-tail-content", Static).update(Text(self.text))
+        except Exception:
+            pass
+
+    @classmethod
+    def default_border_title(cls, props: dict) -> str:
+        file_path = props.get("file_path")
+        if file_path:
+            return f"Log: {Path(file_path).name}"
+        return "Log"