xg-cli 1.0__py3-none-any.whl

xg/tui/widgets/action_card.py

@@ -0,0 +1,94 @@
+"""Inline action cards used for all TUI confirmations.
+
+Cards are read-only text: context, risk and the input protocol.  Decisions
+are always typed into the main Composer, so no Button or inner Input lives
+here.
+"""
+
+from __future__ import annotations
+
+import json
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from xg.tui.state import ApprovalRequest, ConfirmationRequest
+
+APPROVAL_HINT = "输入 y 批准 · a 全部放行 · r 拒绝 · s 跳过 · e 修改参数"
+CONFIRMATION_HINTS = {
+    "init": "输入 y 确认写入 · n 取消",
+    "memory_clear": "输入 clear 确认清空 · 其他输入取消",
+}
+
+
+class InlineConfirmationCard(Vertical):
+    def __init__(self, request: ConfirmationRequest) -> None:
+        # Per-kind class lets the theme give each confirmation its own
+        # border color while sharing one simple layout.  No fixed widget id:
+        # TranscriptView keeps this card stable and updates its content in
+        # place, so no nested input or duplicate child id is required.
+        super().__init__(
+            classes=f"inline-action-card inline-confirmation-card confirmation-{request.kind}",
+        )
+        self.request = request
+        # The Static is created eagerly: compose() runs asynchronously, so
+        # updates must not depend on the card being mounted already.
+        hint = CONFIRMATION_HINTS.get(self.request.kind, "输入 y 确认 · n 取消")
+        self._text = Static(f"{self.request.title}\n\n{self.request.body}\n\n{hint}")
+
+    def compose(self) -> ComposeResult:
+        yield self._text
+
+    def update_request(self, request: ConfirmationRequest) -> None:
+        """Update the stable card without replacing its DOM node."""
+        self.request = request
+        hint = CONFIRMATION_HINTS.get(self.request.kind, "输入 y 确认 · n 取消")
+        self._text.update(f"{self.request.title}\n\n{self.request.body}\n\n{hint}")
+
+
+class InlineApprovalCard(Vertical):
+    def __init__(self, request: ApprovalRequest) -> None:
+        super().__init__(classes="inline-action-card inline-approval-card")
+        self.request = request
+        self._mode = ""
+        self._modified_args: dict | None = None
+        self._text = Static(self._render_text(), classes="inline-approval-text")
+
+    def compose(self) -> ComposeResult:
+        yield self._text
+
+    def update_request(self, request: ApprovalRequest) -> None:
+        """Update request data while preserving the card and its mode."""
+        self.request = request
+        self._text.update(self._render_text())
+
+    def set_mode(self, mode: str = "", modified_args: dict | None = None) -> None:
+        """Switch the card text; empty mode means waiting for the decision."""
+        self._mode = mode
+        self._modified_args = modified_args
+        self._text.update(self._render_text())
+
+    def _render_text(self) -> str:
+        if self._mode == "approval_edit":
+            return (
+                f"需要人工审批：{self.request.tool_name}\n\n"
+                "请输入修改后的完整 JSON 参数。\n"
+                "修改后的参数仍会经过 PathGuard / CommandGuard 检查。\n"
+                "输入 Esc 取消修改。"
+            )
+        if self._mode == "approval_confirm_modified":
+            args = json.dumps(self._modified_args or {}, ensure_ascii=False, indent=2)
+            return (
+                f"需要人工审批：{self.request.tool_name}\n\n"
+                f"参数已修改为：\n{args}\n\n"
+                "输入 y 确认执行 · r 拒绝执行 · Esc 取消"
+            )
+        args = json.dumps(self.request.args, ensure_ascii=False, indent=2)
+        return (
+            "需要人工审批\n"
+            f"工具：{self.request.tool_name}\n"
+            f"敏感级别：{self.request.level}\n"
+            f"当前参数：\n{args}\n\n"
+            f"{APPROVAL_HINT}"
+        )

xg/tui/widgets/agent_group_card.py

@@ -0,0 +1,39 @@
+"""Collapsible conversation group for one Team AgentRun."""
+
+from __future__ import annotations
+
+from textual.events import Click
+from textual.widgets import Static
+
+from xg.tui.messages import AgentGroupToggled
+from xg.tui.renderables import agent_group_renderable
+from xg.tui.state import AgentGroupState
+
+
+class AgentGroupCard(Static):
+    """One Agent conversation inside the shared TranscriptView."""
+
+    can_focus = True
+    BINDINGS = [
+        ("enter", "toggle", "展开/折叠 Agent"),
+        ("space", "toggle", "展开/折叠 Agent"),
+    ]
+
+    def __init__(self, group: AgentGroupState) -> None:
+        self.group_id = group.group_id
+        self.group = group
+        super().__init__(agent_group_renderable(group))
+
+    def update_group(self, group: AgentGroupState) -> None:
+        self.group = group
+        self.update(agent_group_renderable(group))
+
+    def _toggle(self) -> None:
+        self.post_message(AgentGroupToggled(self.group_id))
+
+    def on_click(self, event: Click) -> None:
+        event.stop()
+        self._toggle()
+
+    def action_toggle(self) -> None:
+        self._toggle()

xg/tui/widgets/approval_modal.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Static
+
+from xg.safety.hitl import ApprovalDecision
+from xg.tui.state import ApprovalRequest
+
+
+class ApprovalModal(ModalScreen[str]):
+    BINDINGS = [("escape", "reject", "拒绝"), ("enter", "approve", "批准"), ("y", "approve", "批准"), ("a", "allow_all", "全部放行"), ("r", "reject", "拒绝"), ("s", "skip", "跳过"), ("e", "edit", "修改参数")]
+
+    def __init__(self, request: ApprovalRequest) -> None:
+        super().__init__()
+        self.request = request
+
+    def compose(self) -> ComposeResult:
+        args = json.dumps(self.request.args, ensure_ascii=False, indent=2)
+        with Vertical(id="approval-dialog"):
+            yield Static(f"需要审批：{self.request.tool_name}\n敏感级别：{self.request.level}\n\n{args}")
+            yield Input(placeholder="按 e 修改 JSON 参数", id="approval-json")
+            yield Button("批准 (Enter/y)", id="approve", variant="success")
+            yield Button("本会话全部放行 (a)", id="allow-all")
+            yield Button("拒绝 (r/Esc)", id="reject", variant="error")
+
+    def _close(self, value: str) -> None:
+        self.dismiss(value)
+
+    def action_approve(self) -> None:
+        self._close("approve")
+
+    def action_allow_all(self) -> None:
+        self._close("allow_all")
+
+    def action_reject(self) -> None:
+        self._close("reject")
+
+    def action_skip(self) -> None:
+        self._close("skip")
+
+    def action_edit(self) -> None:
+        self.query_one("#approval-json", Input).focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id != "approval-json":
+            return
+        try:
+            json.loads(event.value)
+        except json.JSONDecodeError:
+            event.input.value = ""
+            return
+        self._close("modify:" + event.value)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self._close(event.button.id or "reject")

xg/tui/widgets/collapsible_card.py

@@ -0,0 +1,40 @@
+"""Interactive execution-trace card for the fullscreen TUI."""
+
+from __future__ import annotations
+
+from textual.events import Click
+from textual.widgets import Static
+
+from xg.tui.messages import TraceCardToggled
+from xg.tui.renderables import trace_renderable
+from xg.tui.state import TranscriptItem
+
+
+class CollapsibleCard(Static):
+    """State-driven card whose header/body can be toggled by mouse or key."""
+
+    can_focus = True
+    BINDINGS = [
+        ("enter", "toggle", "展开/折叠"),
+        ("space", "toggle", "展开/折叠"),
+    ]
+
+    def __init__(self, item: TranscriptItem) -> None:
+        self.item_id = item.id
+        self.item = item
+        super().__init__(trace_renderable(item))
+
+    def update_item(self, item: TranscriptItem) -> None:
+        self.item = item
+        self.update(trace_renderable(item))
+
+    def _toggle(self) -> None:
+        self.post_message(TraceCardToggled(self.item_id))
+
+    def on_click(self, event: Click) -> None:
+        event.stop()
+        self._toggle()
+
+    def action_toggle(self) -> None:
+        self._toggle()
+

xg/tui/widgets/command_suggestions.py

@@ -0,0 +1,128 @@
+"""Local slash-command suggestions for the Composer."""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual.widgets import OptionList
+
+from xg.cli.commands import SLASH_COMMANDS, SlashCommandSpec
+from xg.cli.completion import (
+    CompletionCandidate,
+    CompletionProviderRegistry,
+    completion_candidates,
+    dynamic_candidates,
+)
+from xg.tui.messages import CommandSuggestionSelected
+
+
+class CommandSuggestions(OptionList):
+    """A non-focusable, mouse-selectable list above the Composer.
+
+    The list shows layered candidates (command / subcommand / static option /
+    dynamic value) in front of a thin horizontal rule... The displayed text
+    keeps the candidate's insert_text separate, so help text never leaks into
+    the value.
+    """
+
+    can_focus = False
+
+    def __init__(self) -> None:
+        super().__init__(id="command-suggestions", markup=False)
+        self._visible_candidates: list[CompletionCandidate] = []
+        self._revision = 0
+        self._registry: CompletionProviderRegistry | None = None
+        self.display = False
+
+    def set_dynamic_registry(self, registry: CompletionProviderRegistry | None) -> None:
+        """Attach the runtime provider registry for dynamic value candidates."""
+        self._registry = registry
+
+    @property
+    def visible_candidates(self) -> list[CompletionCandidate]:
+        return self._visible_candidates
+
+    @property
+    def visible_specs(self) -> tuple[SlashCommandSpec, ...]:
+        """Top-level command specs (backward-compatible accessor).
+
+        Only meaningful while the candidate list is a pure command list; empty
+        otherwise. New callers should use ``visible_candidates`` instead.
+        """
+        return tuple(
+            spec
+            for cand in self._visible_candidates
+            if cand.kind == "command"
+            for spec in SLASH_COMMANDS
+            if spec.name == cand.insert_text
+        )
+
+    @property
+    def is_open(self) -> bool:
+        return self.display and bool(self._visible_candidates)
+
+    def update_query(self, query: str, cursor_position: int | None = None) -> None:
+        """Refresh layered candidates (static + dynamic) for the input line.
+
+        Static candidates come first, then dynamic value candidates (the
+        providers are synchronous and read only in-memory agent state), then
+        the list is re-rendered. Dynamic updates use a per-query revision so
+        a stale refresh from an older input never clobbers a newer one.
+        """
+        revision = self._revision + 1
+        self._revision = revision
+        static = completion_candidates(query, cursor_position)
+        dynamic = (
+            dynamic_candidates(query, cursor_position, self._registry)
+            if self._registry is not None
+            else []
+        )
+        candidates = list(static) + dynamic
+        # Defensive: if a newer update_query() bumped the revision before we
+        # applied this result, drop it. Synchronous path never races in
+        # practice, but the guard keeps a stale refresh from winning.
+        if self._revision != revision:
+            return
+        self._visible_candidates = candidates
+        if not candidates:
+            self.set_options(())
+            self.display = False
+            return
+
+        self.set_options(self._render_candidate(cand) for cand in candidates)
+        self.highlighted = 0
+        self.display = True
+
+    def close(self) -> None:
+        """Hide suggestions without changing the Composer value."""
+
+        self.display = False
+
+    def move_selection(self, direction: int) -> None:
+        if not self._visible_candidates:
+            return
+        current = self.highlighted if self.highlighted is not None else 0
+        self.highlighted = (current + direction) % len(self._visible_candidates)
+        self.scroll_to_highlight()
+
+    def selected_candidate(self) -> CompletionCandidate | None:
+        if self.highlighted is None or not self._visible_candidates:
+            return None
+        return self._visible_candidates[self.highlighted]
+
+    @staticmethod
+    def _render_candidate(candidate: CompletionCandidate) -> Text:
+        text = Text()
+        text.append(candidate.label, style="bold")
+        if candidate.detail:
+            text.append("  ")
+            text.append(candidate.detail, style="dim")
+        return text
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Turn a mouse click into a Composer fill operation."""
+
+        if 0 <= event.option_index < len(self._visible_candidates):
+            event.stop()
+            self.post_message(
+                CommandSuggestionSelected(self._visible_candidates[event.option_index])
+            )

xg/tui/widgets/composer.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import asyncio
+
+from textual.events import Key
+from textual.widgets import Input
+
+from xg.input_history import InputHistory
+from xg.tui.widgets.command_suggestions import CommandSuggestions
+
+
+class Composer(Input):
+    """Single-line Composer with bounded XG input history navigation."""
+
+    BINDINGS = [("escape", "escape_input", "清除输入或取消当前操作")]
+
+    def __init__(self) -> None:
+        super().__init__(placeholder="输入任务或 /help …", id="composer")
+        self.suggestions_enabled = True
+        self.input_history: InputHistory | None = None
+
+    def set_input_history(self, history: InputHistory | None) -> None:
+        self.input_history = history
+
+    def record_submission(self, text: str, accepted: bool) -> None:
+        if self.input_history is None:
+            return
+        if accepted:
+            self.input_history.add(text)
+        else:
+            self.input_history.reset_cursor()
+
+    def reset_history_cursor(self) -> None:
+        if self.input_history is not None:
+            self.input_history.reset_cursor()
+
+    def _history_blocked(self, app) -> bool:
+        if getattr(app, "_replan_mode", False):
+            return True
+        controller = getattr(app, "controller", None)
+        state = getattr(controller, "state", None)
+        return bool(
+            getattr(app, "_has_pending_plan", lambda: False)()
+            or getattr(state, "pending_approval", None) is not None
+            or getattr(state, "pending_confirmation", None) is not None
+        )
+
+    def _navigate_history(self, direction: str) -> None:
+        if self.input_history is None:
+            return
+        suggestions = self._suggestions()
+        if suggestions is not None:
+            suggestions.close()
+        value = (
+            self.input_history.previous(self.value)
+            if direction == "previous"
+            else self.input_history.next()
+        )
+        self.value = value
+        self.cursor_position = len(value)
+        self.focus()
+
+    def set_suggestions_enabled(self, enabled: bool) -> None:
+        self.suggestions_enabled = enabled
+
+    def _suggestions(self) -> CommandSuggestions | None:
+        try:
+            return self.app.query_one("#command-suggestions", CommandSuggestions)
+        except Exception:
+            # Input can receive an event while the app is mounting or
+            # unmounting. In that short window there is no suggestion widget.
+            return None
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Keep filtering local and leave submission to the App."""
+        if event.input is not self or not self.suggestions_enabled:
+            return
+        suggestions = self._suggestions()
+        if suggestions is not None:
+            suggestions.update_query(event.value, self.cursor_position)
+
+    def on_key(self, event: Key) -> None:
+        """Keep plan-review shortcuts working while the input stays enabled."""
+        app = self.app
+        suggestions = self._suggestions()
+        if suggestions is not None and suggestions.is_open:
+            if event.key == "up":
+                event.prevent_default()
+                event.stop()
+                suggestions.move_selection(-1)
+                return
+            if event.key == "down":
+                event.prevent_default()
+                event.stop()
+                suggestions.move_selection(1)
+                return
+            if event.key == "tab":
+                candidate = suggestions.selected_candidate()
+                if candidate is not None:
+                    event.prevent_default()
+                    event.stop()
+                    app.complete_command_suggestion(candidate)
+                return
+            if event.key == "escape":
+                event.prevent_default()
+                event.stop()
+                suggestions.close()
+                return
+
+        has_pending_plan = getattr(app, "_has_pending_plan", lambda: False)()
+        if not self._history_blocked(app) and event.key == "up":
+            event.prevent_default()
+            event.stop()
+            self._navigate_history("previous")
+            return
+        if not self._history_blocked(app) and event.key == "down":
+            event.prevent_default()
+            event.stop()
+            self._navigate_history("next")
+            return
+        if not has_pending_plan or getattr(app, "_replan_mode", False):
+            if (
+                event.key == "d"
+                and not self.value
+                and getattr(app, "_has_detail_toggle_target", lambda: False)()
+            ):
+                event.prevent_default()
+                event.stop()
+                app.action_plan_details()
+            return
+        if event.key == "r":
+            event.prevent_default()
+            event.stop()
+            app.action_plan_replan()
+        elif event.key == "d":
+            event.prevent_default()
+            event.stop()
+            app.action_plan_details()
+        elif event.key == "enter":
+            event.prevent_default()
+            event.stop()
+            app.action_plan_execute()
+        elif event.key == "escape":
+            event.prevent_default()
+            event.stop()
+            asyncio.create_task(app.action_escape())
+
+    async def action_escape_input(self) -> None:
+        # Input consumes Escape before it bubbles to the App. Delegate to the
+        # app so idle, running, plan-review and replan states share one policy.
+        await self.app.action_escape()