zjcode 0.0.1__py3-none-any.whl

deepagents_code/tui/widgets/goal_review.py

@@ -0,0 +1,390 @@
+"""Goal acceptance-criteria review widget."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Literal, TypedDict
+
+from textual.binding import Binding, BindingType
+from textual.containers import Container, Vertical, VerticalScroll
+from textual.content import Content
+from textual.message import Message
+from textual.widgets import Markdown, Static
+
+if TYPE_CHECKING:
+    import asyncio
+
+    from textual import events
+    from textual.app import ComposeResult
+
+from deepagents_code import theme
+from deepagents_code.config import get_glyphs, is_ascii_mode
+from deepagents_code.tui.widgets.ask_user import AskUserTextArea
+
+# Menu options in display order: (label, `action_*` suffix). The list index is
+# the cursor position, so labels and dispatch stay aligned from one source.
+_OPTIONS: tuple[tuple[str, str], ...] = (
+    ("1. Accept proposed criteria (y)", "accept"),
+    ("2. Edit criteria (e)", "edit"),
+    ("3. Reject with message (r)", "reject_with_message"),
+    ("4. Cancel (n)", "cancel"),
+)
+
+
+class GoalReviewAccepted(TypedDict):
+    """Widget result when the generated criteria are accepted unchanged."""
+
+    type: Literal["accepted"]
+    """Discriminator tag for accepting generated criteria unchanged."""
+
+
+class GoalReviewEdited(TypedDict):
+    """Widget result when the user submits revised criteria."""
+
+    type: Literal["edited"]
+    """Discriminator tag for submitting revised criteria."""
+
+    criteria: str
+    """User-edited acceptance criteria to activate for the goal."""
+
+
+class GoalReviewRejected(TypedDict):
+    """Widget result when the user rejects criteria with feedback."""
+
+    type: Literal["rejected"]
+    """Discriminator tag for regenerating criteria from user feedback."""
+
+    message: str
+    """User feedback explaining how the criteria should be regenerated."""
+
+
+class GoalReviewCancelled(TypedDict):
+    """Widget result when the user cancels the proposal."""
+
+    type: Literal["cancelled"]
+    """Discriminator tag for cancelling the pending goal proposal."""
+
+
+GoalReviewResult = (
+    GoalReviewAccepted | GoalReviewEdited | GoalReviewRejected | GoalReviewCancelled
+)
+
+
+class GoalReviewTextArea(AskUserTextArea):
+    """Text input that keeps goal-review edit keystrokes inside the editor."""
+
+    class CancelEdit(Message):
+        """Posted when Escape should leave goal criteria edit mode."""
+
+    async def _on_key(self, event: events.Key) -> None:
+        if event.key == "escape":
+            event.prevent_default()
+            event.stop()
+            self.post_message(self.CancelEdit())
+            return
+
+        await super()._on_key(event)
+
+
+class GoalReviewMenu(Container):
+    """Inline review widget for generated goal acceptance criteria."""
+
+    can_focus = True
+    """Allow the menu itself to receive navigation and quick-key focus."""
+
+    can_focus_children = True
+    """Allow the inline criteria editor to receive text input focus."""
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("up", "move_up", "Up", show=False),
+        Binding("k", "move_up", "Up", show=False),
+        Binding("down", "move_down", "Down", show=False),
+        Binding("j", "move_down", "Down", show=False),
+        Binding("enter", "select", "Select", show=False),
+        Binding("1", "accept", "Accept", show=False),
+        Binding("y", "accept", "Accept", show=False),
+        Binding("2", "edit", "Edit", show=False),
+        Binding("e", "edit", "Edit", show=False),
+        Binding("3", "reject_with_message", "Reject with message", show=False),
+        Binding("r", "reject_with_message", "Reject with message", show=False),
+        Binding("4", "cancel", "Cancel", show=False),
+        Binding("n", "cancel", "Cancel", show=False),
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+    """Keyboard bindings for navigation, accepting, editing, and cancelling."""
+
+    class Decided(Message):
+        """Message sent when the user accepts, edits, or cancels."""
+
+        def __init__(
+            self,
+            result: GoalReviewResult,
+            widget: GoalReviewMenu | None = None,
+        ) -> None:
+            """Initialize a decision message."""
+            super().__init__()
+            self.result = result
+            """Decision payload emitted by the review widget."""
+
+            self.widget = widget
+            """Review widget that emitted the decision."""
+
+    def __init__(
+        self,
+        objective: str,
+        criteria: str,
+        *,
+        amendment: bool = False,
+        id: str | None = None,  # noqa: A002
+    ) -> None:
+        """Initialize the goal review menu."""
+        super().__init__(id=id or "goal-review-menu", classes="goal-review-menu")
+        self._objective = objective
+        """Goal objective whose generated criteria are being reviewed."""
+
+        self._criteria = criteria
+        """Generated acceptance criteria proposed for the goal."""
+
+        self._amendment = amendment
+        """Whether this review updates an existing goal."""
+
+        self._selected = 0
+        """Index of the currently highlighted action option."""
+
+        self._option_widgets: list[Static] = []
+        """Mounted option widgets updated when selection changes."""
+
+        self._help_widget: Static | None = None
+        """Mounted keyboard-help widget, populated during composition."""
+
+        self._edit_input: GoalReviewTextArea | None = None
+        """Inline editor used for revised criteria or rejection feedback."""
+
+        self._input_mode: Literal["edit", "reject"] | None = None
+        """Whether an inline text input is currently active."""
+
+        self._future: asyncio.Future[GoalReviewResult] | None = None
+        """Future resolved when the user accepts, edits, or cancels."""
+
+        self._submitted = False
+        """Whether a terminal decision has already been emitted."""
+
+    def set_future(self, future: asyncio.Future[GoalReviewResult]) -> None:
+        """Set the future to resolve when the user decides."""
+        self._future = future
+
+    def compose(self) -> ComposeResult:
+        """Compose the review widget.
+
+        Yields:
+            Widgets for the title, criteria preview, actions, editor, and help text.
+        """
+        glyphs = get_glyphs()
+        title = "Review goal amendment" if self._amendment else "Review goal criteria"
+        yield Static(
+            Content.from_markup("$cursor $title", cursor=glyphs.cursor, title=title),
+            classes="goal-review-title",
+        )
+        with (
+            VerticalScroll(classes="goal-review-content"),
+            Vertical(classes="goal-review-body"),
+        ):
+            source = f"**Proposed criteria**\n\n{self._criteria}"
+            if self._amendment:
+                source = (
+                    f"**Proposed objective**\n\n{self._objective}\n\n"
+                    f"**Proposed criteria**\n\n{self._criteria}"
+                )
+            yield Markdown(source, classes="goal-review-markdown")
+        with Container(classes="goal-review-options-container"):
+            for _ in _OPTIONS:
+                widget = Static("", classes="goal-review-option")
+                self._option_widgets.append(widget)
+                yield widget
+        self._edit_input = GoalReviewTextArea(classes="goal-review-edit-input")
+        self._edit_input.text = self._criteria
+        self._edit_input.display = False
+        yield self._edit_input
+        self._help_widget = Static("", classes="goal-review-help")
+        yield self._help_widget
+
+    async def on_mount(self) -> None:
+        """Focus the menu and render options after mount."""
+        if is_ascii_mode():
+            colors = theme.get_theme_colors(self)
+            self.styles.border = ("ascii", colors.success)
+        self._update_options()
+        self.focus()
+
+    def focus_active(self) -> None:
+        """Focus the active control."""
+        if self._input_mode is not None and self._edit_input is not None:
+            self._edit_input.focus()
+            return
+        self.focus()
+
+    def action_move_up(self) -> None:
+        """Move selection up."""
+        if self._input_mode is not None:
+            return
+        self._selected = (self._selected - 1) % len(_OPTIONS)
+        self._update_options()
+
+    def action_move_down(self) -> None:
+        """Move selection down."""
+        if self._input_mode is not None:
+            return
+        self._selected = (self._selected + 1) % len(_OPTIONS)
+        self._update_options()
+
+    def action_select(self) -> None:
+        """Select the highlighted option."""
+        if self._input_mode is not None:
+            return
+        action_name = _OPTIONS[self._selected][1]
+        getattr(self, f"action_{action_name}")()
+
+    def action_accept(self) -> None:
+        """Accept the proposed criteria unchanged."""
+        if self._input_mode is not None:
+            return
+        self._submit({"type": "accepted"})
+
+    def action_edit(self) -> None:
+        """Open the inline editor for revised criteria."""
+        if self._submitted or self._input_mode is not None:
+            return
+        self._input_mode = "edit"
+        if self._edit_input is not None:
+            self._edit_input.text = self._criteria
+            self._edit_input.display = True
+            self._edit_input.focus()
+        self._update_options()
+
+    def action_reject_with_message(self) -> None:
+        """Open the inline feedback input for regenerating criteria."""
+        if self._submitted or self._input_mode is not None:
+            return
+        self._input_mode = "reject"
+        if self._edit_input is not None:
+            self._edit_input.text = ""
+            self._edit_input.display = True
+            self._edit_input.focus()
+        self._update_options()
+
+    def action_cancel(self) -> None:
+        """Cancel editing or cancel the whole proposal."""
+        if self._submitted:
+            return
+        if self._input_mode is not None:
+            self._input_mode = None
+            if self._edit_input is not None:
+                self._edit_input.display = False
+            self._update_options()
+            self.focus()
+            return
+        self._submit({"type": "cancelled"})
+
+    def on_ask_user_text_area_submitted(
+        self,
+        event: AskUserTextArea.Submitted,
+    ) -> None:
+        """Submit edited criteria when Enter is pressed in the editor."""
+        if event.text_area is not self._edit_input:
+            return
+        event.stop()
+        if self._input_mode == "edit":
+            self._submit_edit()
+            return
+        if self._input_mode == "reject":
+            self._submit_rejection()
+
+    def on_goal_review_text_area_cancel_edit(
+        self,
+        event: GoalReviewTextArea.CancelEdit,
+    ) -> None:
+        """Return from edit mode when Escape is pressed in the editor."""
+        event.stop()
+        self.action_cancel()
+
+    def on_blur(self, event: events.Blur) -> None:  # noqa: PLR6301  # Textual event handler
+        """Prevent blur from dismissing the review prompt."""
+        event.stop()
+
+    def _submit_edit(self) -> None:
+        """Submit the current editor text as revised criteria."""
+        if self._edit_input is None:
+            return
+        criteria = self._edit_input.text.strip()
+        if not criteria:
+            self._hint_empty_submission("criteria")
+            return
+        self._submit({"type": "edited", "criteria": criteria})
+
+    def _submit_rejection(self) -> None:
+        """Submit the current editor text as regeneration feedback."""
+        if self._edit_input is None:
+            return
+        message = self._edit_input.text.strip()
+        if not message:
+            self._hint_empty_submission("feedback")
+            return
+        self._submit({"type": "rejected", "message": message})
+
+    def _hint_empty_submission(self, what: str) -> None:
+        """Explain why an empty editor submission did nothing.
+
+        Without this the editor silently no-ops on an empty Enter, leaving the
+        user unsure whether the keypress registered.
+
+        Args:
+            what: Noun for the missing content (e.g. `criteria`, `feedback`).
+        """
+        if self._help_widget is None:
+            return
+        glyphs = get_glyphs()
+        self._help_widget.update(
+            f"Enter some {what}, or press Esc to go back {glyphs.bullet} "
+            "Shift+Enter newline"
+        )
+
+    def _submit(self, result: GoalReviewResult) -> None:
+        """Resolve the result future and post the decision message."""
+        if self._submitted:
+            return
+        self._submitted = True
+        self.display = False
+        if self._future is not None and not self._future.done():
+            self._future.set_result(result)
+        self.post_message(self.Decided(result, self))
+
+    def _update_options(self) -> None:
+        """Render option labels and help text."""
+        for i, ((text, _), widget) in enumerate(
+            zip(_OPTIONS, self._option_widgets, strict=True)
+        ):
+            cursor = f"{get_glyphs().cursor} " if i == self._selected else "  "
+            widget.update(f"{cursor}{text}")
+            widget.remove_class("goal-review-option-selected")
+            if i == self._selected and self._input_mode is None:
+                widget.add_class("goal-review-option-selected")
+
+        if self._help_widget is None:
+            return
+        glyphs = get_glyphs()
+        if self._input_mode == "edit":
+            self._help_widget.update(
+                f"Enter save edits {glyphs.bullet} "
+                f"Shift+Enter newline {glyphs.bullet} Esc back"
+            )
+            return
+        if self._input_mode == "reject":
+            self._help_widget.update(
+                f"Enter regenerate {glyphs.bullet} "
+                f"Shift+Enter newline {glyphs.bullet} Esc back"
+            )
+            return
+        self._help_widget.update(
+            f"{glyphs.arrow_up}/{glyphs.arrow_down} navigate {glyphs.bullet} "
+            f"Enter select {glyphs.bullet} y/e/r/n quick keys {glyphs.bullet} "
+            "Esc cancel"
+        )

deepagents_code/tui/widgets/goal_status.py

@@ -0,0 +1,50 @@
+"""Persistent inline display for the current goal."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.content import Content
+from textual.widgets import Static
+
+if TYPE_CHECKING:
+    from deepagents_code.resume_state import GoalStatus
+
+
+class GoalStatusPanel(Static):
+    """Keep the current goal and lifecycle state visible above the input."""
+
+    def __init__(self, *, id: str | None = None) -> None:  # noqa: A002
+        """Initialize an empty hidden goal panel."""
+        super().__init__("", id=id, classes="goal-status-panel")
+        self.display = False
+
+    def set_goal(
+        self,
+        objective: str | None,
+        status: GoalStatus | None,
+        note: str | None,
+    ) -> None:
+        """Render the current goal or hide the panel when no goal exists.
+
+        Args:
+            objective: Persisted goal objective, if set.
+            status: Current lifecycle state.
+            note: Blocker or completion note associated with the state.
+        """
+        if not objective:
+            self.update("")
+            self.display = False
+            return
+
+        current = status or "active"
+        label = "completed" if current == "complete" else current
+        content = Content.from_markup(
+            "[bold]Goal · $status[/bold]\n$objective",
+            status=label,
+            objective=objective,
+        )
+        if note and current in {"blocked", "complete"}:
+            content += Content.from_markup("\n[dim]$note[/dim]", note=note)
+        self.update(content)
+        self.display = True

deepagents_code/tui/widgets/history.py

@@ -0,0 +1,194 @@
+"""Command history manager for input persistence."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class HistoryManager:
+    """Manages command history with file persistence.
+
+    Uses append-only writes for concurrent safety. Multiple agents can
+    safely write to the same history file without corruption.
+    """
+
+    def __init__(self, history_file: Path, max_entries: int = 100) -> None:
+        """Initialize the history manager.
+
+        Args:
+            history_file: Path to the JSON-lines history file
+            max_entries: Maximum number of entries to keep
+        """
+        self.history_file = history_file
+        self.max_entries = max_entries
+        self._entries: list[str] = []
+        self._current_index: int = -1
+        self._temp_input: str = ""
+        self._query: str = ""
+        self._load_history()
+
+    def _load_history(self) -> None:
+        """Load history from file."""
+        if not self.history_file.exists():
+            return
+
+        try:
+            with self.history_file.open("r", encoding="utf-8") as f:
+                entries = []
+                for raw_line in f:
+                    line = raw_line.rstrip("\n\r")
+                    if not line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                    except json.JSONDecodeError:
+                        entry = line
+                    entries.append(entry if isinstance(entry, str) else str(entry))
+                self._entries = entries[-self.max_entries :]
+        except (OSError, UnicodeDecodeError):
+            logger.warning(
+                "Failed to load history from %s; starting with empty history",
+                self.history_file,
+                exc_info=True,
+            )
+            self._entries = []
+
+    def _append_to_file(self, text: str) -> None:
+        """Append a single entry to history file (concurrent-safe)."""
+        try:
+            self.history_file.parent.mkdir(parents=True, exist_ok=True)
+            with self.history_file.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(text) + "\n")
+        except OSError:
+            logger.warning(
+                "Failed to append history entry to %s",
+                self.history_file,
+                exc_info=True,
+            )
+
+    def _compact_history(self) -> None:
+        """Rewrite history file to remove old entries.
+
+        Only called when entries exceed 2x max_entries to minimize rewrites.
+        """
+        try:
+            self.history_file.parent.mkdir(parents=True, exist_ok=True)
+            with self.history_file.open("w", encoding="utf-8") as f:
+                for entry in self._entries:
+                    f.write(json.dumps(entry) + "\n")
+        except OSError:
+            logger.warning(
+                "Failed to compact history file %s",
+                self.history_file,
+                exc_info=True,
+            )
+
+    def add(self, text: str) -> None:
+        """Add a command to history.
+
+        Args:
+            text: The command text to add
+        """
+        text = text.strip()
+        # Skip empty input and slash commands, except the explicit
+        # `/skill:<name>` form (case-insensitive), which is kept so users can
+        # recall it with up-arrow. Note: history stores the raw submitted text
+        # *before* app-layer alias rewriting, so convenience aliases such as
+        # `/remember` (later rewritten to `/skill:remember`) are dropped here
+        # despite being skill invocations.
+        lower_text = text.lower()
+        if not text or (text.startswith("/") and not lower_text.startswith("/skill:")):
+            return
+
+        # Skip duplicates of the last entry
+        if self._entries and self._entries[-1] == text:
+            return
+
+        self._entries.append(text)
+
+        # Append to file (fast, concurrent-safe)
+        self._append_to_file(text)
+
+        # Compact only when we have 2x max entries (rare operation)
+        if len(self._entries) > self.max_entries * 2:
+            self._entries = self._entries[-self.max_entries :]
+            self._compact_history()
+
+        self.reset_navigation()
+
+    def get_previous(self, current_input: str, *, query: str = "") -> str | None:
+        """Get the previous history entry matching a substring query.
+
+        The query is captured on the first call of a navigation session
+        (when `_current_index == -1`) and reused for all subsequent calls until
+        `reset_navigation`. Passing a different value on later calls has
+        no effect.
+
+        Args:
+            current_input: Current input text. Saved only on the first call of a
+                navigation session; ignored on subsequent calls.
+            query: Substring to match against history entries.
+                Captured once on the first call of a navigation session.
+
+        Returns:
+            Previous matching entry or `None`.
+        """
+        if not self._entries:
+            return None
+
+        # Save current input and capture query on first navigation
+        if self._current_index == -1:
+            self._temp_input = current_input
+            self._current_index = len(self._entries)
+            self._query = query.strip().lower()
+
+        # Search backwards for matching entry
+        for i in range(self._current_index - 1, -1, -1):
+            if not self._query or self._query in self._entries[i].lower():
+                self._current_index = i
+                return self._entries[i]
+
+        return None
+
+    def get_next(self) -> str | None:
+        """Get the next history entry matching the stored query.
+
+        Uses the query captured by the most recent `get_previous` call.
+
+        Returns:
+            The next matching entry, or the original input when past the newest
+                match.
+
+                `None` if not currently navigating history.
+        """
+        if self._current_index == -1:
+            return None
+
+        # Search forwards for matching entry
+        for i in range(self._current_index + 1, len(self._entries)):
+            if not self._query or self._query in self._entries[i].lower():
+                self._current_index = i
+                return self._entries[i]
+
+        # Return to original input at the end
+        result = self._temp_input
+        self.reset_navigation()
+        return result
+
+    @property
+    def in_history(self) -> bool:
+        """Whether currently navigating history entries."""
+        return self._current_index >= 0
+
+    def reset_navigation(self) -> None:
+        """Reset navigation state."""
+        self._current_index = -1
+        self._temp_input = ""
+        self._query = ""