ferp 0.7.1__py3-none-any.whl

ferp/widgets/forms.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.suggester import SuggestFromList
+from textual.widget import Widget
+from textual.widgets import Button, Checkbox, Input, Label, SelectionList
+
+
+@dataclass(frozen=True)
+class BooleanField:
+    id: str
+    label: str
+    value: bool = False
+
+
+@dataclass(frozen=True)
+class SelectionField:
+    id: str
+    label: str
+    options: list[str]
+    values: list[str] | None = None
+
+
+def _selection_list_values(selection_list: SelectionList) -> list[str]:
+    selected = selection_list.selected
+    if isinstance(selected, list):
+        return [str(item) for item in selected]
+    return []
+
+
+class PromptDialog(ModalScreen[dict[str, str | bool | list[str]] | None]):
+    def __init__(
+        self,
+        message: str,
+        id: str,
+        *,
+        default: str | None = None,
+        suggestions: Iterable[str] | None = None,
+        boolean_fields: Iterable[BooleanField] | None = None,
+        selection_fields: Iterable[SelectionField] | None = None,
+        show_text_input: bool = True,
+    ) -> None:
+        super().__init__(id=id)
+        self._message = message
+        self._default = default or ""
+        self._suggestions = list(suggestions or [])
+        self._bool_fields = list(boolean_fields or [])
+        self._selection_fields = list(selection_fields or [])
+        self._show_text_input = show_text_input
+
+    def compose(self) -> ComposeResult:
+        contents: list[Widget] = [Label(self._message, id="dialog_message")]
+        if self._show_text_input:
+            suggester = None
+            if self._suggestions:
+                suggester = SuggestFromList(
+                    self._suggestions,
+                    case_sensitive=False,
+                )
+            contents.append(
+                Input(value=self._default, id="prompt_input", suggester=suggester)
+            )
+        for field in self._selection_fields:
+            contents.append(
+                Label(
+                    field.label,
+                    id=f"{field.id}_label",
+                    classes="selection_list_subtitle",
+                )
+            )
+            contents.append(
+                SelectionList(
+                    *[(option, option) for option in field.options],
+                    id=field.id,
+                    classes="prompt_selection_list",
+                )
+            )
+        contents.append(
+            Horizontal(
+                *(
+                    Checkbox(label=field.label, value=field.value, id=field.id)
+                    for field in self._bool_fields
+                ),
+                id="prompt_flags",
+                classes="hidden" if not self._bool_fields else "",
+            )
+        )
+        contents.append(
+            Horizontal(
+                Button("OK", id="ok", variant="primary", flat=True),
+                Button("Cancel", id="cancel", flat=True),
+                classes="dialog_buttons",
+            )
+        )
+        yield Vertical(*contents, id="dialog_container")
+
+    def on_mount(self) -> None:
+        if self._show_text_input:
+            self.query_one(Input).focus()
+        for field in self._selection_fields:
+            selection_list = self.query_one(f"#{field.id}", SelectionList)
+            if field.values:
+                for value in field.values:
+                    selector = getattr(selection_list, "select", None)
+                    if callable(selector):
+                        try:
+                            selector(value)
+                        except Exception:
+                            pass
+        if not self._show_text_input:
+            if self._selection_fields:
+                self.query_one(SelectionList).focus()
+                return
+            if self._bool_fields:
+                self.query_one(Checkbox).focus()
+                return
+            self.query_one("#ok", Button).focus()
+
+    def on_screen_resume(self) -> None:
+        if getattr(self, "_dismiss_on_resume", False):
+            self.dismiss(None)
+
+    def _collect_state(self) -> dict[str, str | bool | list[str]]:
+        state: dict[str, str | bool | list[str]] = {}
+        if self._show_text_input:
+            state["value"] = self.query_one(Input).value.strip()
+        else:
+            state["value"] = ""
+        for field in self._bool_fields:
+            checkbox = self.query_one(f"#{field.id}", Checkbox)
+            state[field.id] = bool(checkbox.value)
+        for field in self._selection_fields:
+            selection_list = self.query_one(f"#{field.id}", SelectionList)
+            state[field.id] = _selection_list_values(selection_list)
+        return state
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "ok":
+            self.dismiss(self._collect_state())
+        else:
+            self.dismiss(None)

ferp/widgets/output_panel.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from rich.markup import escape
+from textual.containers import Vertical
+from textual.widgets import ProgressBar, Static
+
+from ferp.core.script_runner import ScriptResult
+from ferp.core.state import AppState, AppStateStore, ScriptRunState
+from ferp.widgets.panels import ContentPanel
+
+
+class ScriptOutputPanel(ContentPanel):
+    """Specialized panel responsible for rendering script status and errors."""
+
+    _MAX_VALUE_CHARS = 2500
+    _TRUNCATION_SUFFIX = "\n... (truncated)"
+
+    def __init__(
+        self,
+        *,
+        title: str = "Script Output",
+        panel_id: str = "output_panel",
+        initial_message: str = "No script output.",
+        state_store: AppStateStore,
+    ) -> None:
+        super().__init__(initial_message, id=panel_id, title=title)
+        self._state_store = state_store
+        self._state_subscription = self._handle_state_update
+        self._last_script_run: ScriptRunState | None = None
+        self._progress_header: Static | None = None
+        self._progress_message: Static | None = None
+        self._progress_bar: ProgressBar | None = None
+        self._progress_status: Static | None = None
+
+    def on_mount(self) -> None:
+        super().on_mount()
+        self._state_store.subscribe(self._state_subscription)
+
+    def on_unmount(self) -> None:
+        self._state_store.unsubscribe(self._state_subscription)
+
+    def show_error(self, error: BaseException) -> None:
+        self.remove_children()
+        self.update_content("[bold $error]Error:[/bold $error]\n" + escape(str(error)))
+
+    def show_result(
+        self,
+        script_name: str,
+        target: Path,
+        result: ScriptResult,
+        transcript_path: Path | None = None,
+    ) -> None:
+        status = result.status.value.replace("_", " ").title()
+        lines: list[str] = [
+            f"[bold $text-primary]Script:[/bold $text-primary] {escape(script_name)}",
+            f"[bold $text-primary]Target:[/bold $text-primary] {escape(str(target.name))}",
+            f"[bold $text-primary]Status:[/bold $text-primary] {status}",
+        ]
+
+        if result.exit_code is not None:
+            lines.append(
+                f"[bold $text-primary]Exit Code:[/bold $text-primary] {result.exit_code}"
+            )
+
+        if result.results:
+            total = len(result.results)
+            for index, payload in enumerate(result.results, start=1):
+                header_text, header_style = self._result_header(payload, index, total)
+                lines.append(
+                    f"\n[bold {header_style}]{escape(header_text)}[/bold {header_style}]\n"
+                )
+                format_hint = payload.get("_format")
+                if (
+                    isinstance(format_hint, str)
+                    and format_hint.strip().lower() == "json"
+                ):
+                    cleaned = {
+                        key: value
+                        for key, value in payload.items()
+                        if not (isinstance(key, str) and key.startswith("_"))
+                    }
+                    lines.append(self._format_pair("json", cleaned))
+                    continue
+                for key, value in payload.items():
+                    if isinstance(key, str) and key.startswith("_"):
+                        continue
+                    lines.append(self._format_pair(key, value))
+
+        if result.error:
+            lines.append("\n[bold $error]Error:[/bold $error]\n" + escape(result.error))
+
+        if transcript_path:
+            lines.append(
+                f"\n[bold $secondary]Transcript:[/bold $secondary] [$text-secondary]{escape(str(transcript_path.name))}[/$text-secondary]"
+            )
+
+        self.remove_children()
+        self.update_content("\n".join(lines))
+
+    def _handle_state_update(self, state: AppState) -> None:
+        script_run = state.script_run
+        if self._last_script_run == script_run:
+            return
+        self._last_script_run = script_run
+        self._render_script_state(script_run)
+
+    def _render_script_state(self, script_run: ScriptRunState) -> None:
+        phase = script_run.phase
+        if phase == "running":
+            self._render_progress(script_run)
+            return
+        if phase == "awaiting_input":
+            self._clear_progress()
+            self.remove_children()
+            prompt = script_run.input_prompt or "Input required"
+            self.update_content(
+                "[bold $primary]Input requested:[/bold $primary] " + escape(prompt)
+            )
+            return
+        if phase == "result" and script_run.result is not None:
+            self._clear_progress()
+            script_name = script_run.script_name or "Script"
+            target = script_run.target_path or Path(".")
+            self.show_result(
+                script_name,
+                target,
+                script_run.result,
+                script_run.transcript_path,
+            )
+            return
+        if phase == "error" and script_run.error:
+            self._clear_progress()
+            self.remove_children()
+            self.update_content(
+                "[bold $error]Error:[/bold $error]\n" + escape(script_run.error)
+            )
+
+    def _render_progress(self, script_run: ScriptRunState) -> None:
+        script_name = script_run.script_name or "Script"
+        target = script_run.target_path
+        target_label = escape(str(target)) if target else "Unknown"
+        header_text = (
+            f"[bold $primary]Script:[/bold $primary] {escape(script_name)}\n"
+            f"[bold $primary]Target:[/bold $primary] {target_label}"
+        )
+
+        if self._progress_bar is None or self._progress_header is None:
+            self.remove_children()
+            self._progress_header = Static(header_text, id="progress_header")
+            self._progress_message = Static("", id="progress_message")
+            self._progress_bar = ProgressBar(
+                total=None,
+                show_eta=False,
+                id="script_progress_bar",
+                show_percentage=False,
+            )
+            self._progress_status = Static(
+                "[dim]Working, please wait...[/dim]",
+                id="progress_status",
+            )
+            self.mount(
+                self._progress_header,
+                Vertical(
+                    self._progress_message,
+                    self._progress_bar,
+                    self._progress_status,
+                    id="progress-container",
+                ),
+            )
+        else:
+            self._progress_header.update(header_text)
+
+        if self._progress_message is not None:
+            self._progress_message.update(escape(script_run.progress_message or ""))
+        if self._progress_bar is not None:
+            total = script_run.progress_total
+            current = script_run.progress_current
+            if total is not None and total >= 0 and current is not None:
+                self._progress_bar.update(
+                    total=total, progress=max(0.0, min(current, total))
+                )
+            else:
+                self._progress_bar.update(total=None)
+        if self._progress_status is not None and script_run.progress_line:
+            self._progress_status.update(script_run.progress_line)
+
+    def _clear_progress(self) -> None:
+        self._progress_header = None
+        self._progress_message = None
+        self._progress_bar = None
+        self._progress_status = None
+
+    def _format_pair(self, key: Any, value: Any) -> str:
+        label = f"[bold $text-primary]{escape(str(key))}:[/bold $text-primary]"
+        body = escape(self._stringify_value(value))
+        return f"{label} {body}"
+
+    def _result_header(
+        self,
+        payload: dict[str, Any],
+        index: int,
+        total: int,
+    ) -> tuple[str, str]:
+        header_text = f"Result {index} of {total}"
+        status = "success"
+        custom_title = payload.get("_title")
+        if isinstance(custom_title, str) and custom_title.strip():
+            header_text = custom_title.strip()
+        custom_status = payload.get("_status")
+        if isinstance(custom_status, str):
+            status = custom_status.strip().lower()
+        status_to_style = {
+            "success": "$success",
+            "ok": "$success",
+            "warn": "$warning",
+            "warning": "$warning",
+            "error": "$error",
+            "fail": "$error",
+            "failed": "$error",
+        }
+        return header_text, status_to_style.get(status, "$success")
+
+    def _stringify_value(self, value: Any) -> str:
+        if value is None:
+            return "null"
+        if isinstance(value, (str, int, float, bool)):
+            return self._truncate_value(str(value))
+        if isinstance(value, (dict, list)):
+            try:
+                return self._truncate_value(
+                    json.dumps(value, indent=2, ensure_ascii=True)
+                )
+            except (TypeError, ValueError):
+                return self._truncate_value(str(value))
+        return self._truncate_value(str(value))
+
+    def _truncate_value(self, value: str) -> str:
+        if len(value) <= self._MAX_VALUE_CHARS:
+            return value
+        return value[: self._MAX_VALUE_CHARS] + self._TRUNCATION_SUFFIX

ferp/widgets/panels.py

@@ -0,0 +1,13 @@
+from textual.widgets import Static
+
+
+class ContentPanel(Static):
+    def __init__(self, content: str, id: str, title: str) -> None:
+        super().__init__(content, id=id)
+        self.title = title
+
+    def on_mount(self) -> None:
+        self.border_title = self.title
+
+    def update_content(self, content: str) -> None:
+        self.update(content)

ferp/widgets/process_list.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Callable
+
+from textual import on
+from textual.binding import Binding
+from textual.containers import Container, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Footer, ListItem, ListView, Static
+
+from ferp.fscp.host.process_registry import ProcessRecord, ProcessRegistry
+
+
+class ProcessListItem(ListItem):
+    """Row showing a single tracked process."""
+
+    def __init__(self, record: ProcessRecord) -> None:
+        self.record = record
+        body = Vertical(
+            Static(self._render_title(record), classes="process_row_title"),
+            Static(self._render_meta(record), classes="process_row_meta"),
+        )
+        super().__init__(body, classes="process_row")
+
+    @staticmethod
+    def _render_title(record: ProcessRecord) -> str:
+        pid = record.pid if record.pid is not None else "?"
+        state = record.state.name.replace("_", " ").title()
+        return f"{record.metadata.script_name} · pid {pid} · {state}"
+
+    @staticmethod
+    def _render_meta(record: ProcessRecord) -> str:
+        started = datetime.fromtimestamp(record.start_time).strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+        target = record.metadata.target_path
+        exit_code = (
+            f" · exit {record.exit_code}" if record.exit_code is not None else ""
+        )
+        mode = f" · {record.termination_mode}" if record.termination_mode else ""
+        return f"{target} · started {started}{exit_code}{mode}"
+
+
+class ProcessListScreen(ModalScreen[None]):
+    """Modal view over currently tracked processes."""
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+        Binding("r", "refresh", "Refresh", show=True),
+        Binding("p", "prune_finished", "Prune finished", show=True),
+        Binding("k", "kill_selected", "Kill selected", show=True),
+    ]
+
+    def __init__(
+        self,
+        registry: ProcessRegistry,
+        request_abort: Callable[[ProcessRecord], bool],
+    ) -> None:
+        super().__init__()
+        self._registry = registry
+        self._request_abort = request_abort
+        self._status: Static | None = None
+        self._status_locked = False
+
+    def compose(self):
+        list_view = ListView(id="process_list_view")
+        list_view.border_title = "Processes"
+        status = Static("", id="process_list_status")
+        self._status = status
+        yield Container(
+            Vertical(
+                list_view,
+                status,
+                Footer(),
+            ),
+            id="process_list_modal",
+        )
+
+    def on_mount(self) -> None:
+        self._refresh()
+        list_view = self.query_one(ListView)
+        list_view.focus()
+
+    def on_screen_resume(self) -> None:
+        self._refresh()
+
+    @on(ListView.Highlighted, "#process_list_view")
+    def _clear_status_on_move(self, _: ListView.Highlighted) -> None:
+        if self._status_locked:
+            return
+        self._set_status("")
+
+    def action_close(self) -> None:
+        self.dismiss(None)
+
+    def action_refresh(self) -> None:
+        self._refresh()
+
+    def action_prune_finished(self) -> None:
+        removed = self._registry.prune_finished()
+        self._set_status(f"Pruned {len(removed)} finished process(es).")
+        self._refresh()
+
+    def action_kill_selected(self) -> None:
+        list_view = self.query_one(ListView)
+        if list_view.index is None:
+            self._set_status("Select a process first.")
+            return
+        try:
+            item = list_view.children[list_view.index]
+        except IndexError:
+            self._set_status("No process selected.")
+            return
+        if not isinstance(item, ProcessListItem):
+            self._set_status("Invalid selection.")
+            return
+        record = item.record
+        if record.is_terminal:
+            self._set_status("Process already finished.")
+            return
+        killed = self._request_abort(record)
+        if killed:
+            self._status_locked = True
+            self._refresh()
+            self._set_status("Termination requested.")
+            self.set_timer(0.2, self._refresh)
+            self.set_timer(0.8, self._refresh)
+            self.set_timer(1.2, self._unlock_status)
+        else:
+            self._set_status("Unable to terminate this process.")
+
+    def _refresh(self) -> None:
+        list_view = self.query_one(ListView)
+        list_view.clear()
+        records = sorted(
+            self._registry.list_all(), key=lambda rec: rec.start_time, reverse=True
+        )
+        if not records:
+            placeholder = ListItem(
+                Static("No tracked processes."),
+                classes="process_row process_row--empty",
+            )
+            placeholder.disabled = True
+            list_view.append(placeholder)
+            return
+        for record in records:
+            list_view.append(ProcessListItem(record))
+
+    def _set_status(self, message: str) -> None:
+        status = self._status
+        if status is None:
+            return
+        status.update(message)
+
+    def _unlock_status(self) -> None:
+        self._status_locked = False
+        self._set_status("")

ferp/widgets/readme_modal.py

@@ -0,0 +1,59 @@
+from textual.binding import Binding
+from textual.containers import Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Label, MarkdownViewer
+
+
+class ReadmeScreen(ModalScreen):
+    BINDINGS = [
+        Binding("j", "scroll_down", "Scroll down", show=False),
+        Binding("down", "scroll_down", "Scroll down", show=False),
+        Binding("k", "scroll_up", "Scroll up", show=False),
+        Binding("up", "scroll_up", "Scroll up", show=False),
+        Binding("escape", "close", "Close README", show=True),
+        Binding("q", "close", "Close README", show=False),
+    ]
+
+    def __init__(self, title: str, content: str, id: str) -> None:
+        super().__init__(id=id)
+        self.heading = title
+        self._content = content or "*No README available for this script.*"
+        self._markdown: MarkdownViewer | None = None
+
+    def compose(self):
+        markdown = MarkdownViewer(self._content, id="readme_content")
+        self._markdown = markdown
+        yield Vertical(
+            VerticalScroll(markdown, id="readme_scroll"),
+            id="readme_modal",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one("#readme_scroll", VerticalScroll).focus()
+
+    def action_close(self) -> None:
+        self.app.pop_screen()
+
+    def action_scroll_down(self) -> None:
+        scroll = self.query_one("#readme_scroll", VerticalScroll)
+        scroll.scroll_down()
+
+    def action_scroll_up(self) -> None:
+        scroll = self.query_one("#readme_scroll", VerticalScroll)
+        scroll.scroll_up()
+
+    def update_content(self, title: str, content: str) -> None:
+        self.heading = title
+        self._content = content or "*No README available for this script.*"
+        if self._markdown is not None:
+            setter = getattr(self._markdown, "set_markdown", None)
+            if callable(setter):
+                setter(self._content)
+            else:
+                updater = getattr(self._markdown, "update", None)
+                if callable(updater):
+                    updater(self._content)
+        try:
+            self.query_one("#readme_title", Label).update(self.heading)
+        except Exception:
+            pass