@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/tui/widgets/prompt.py

@@ -1,935 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-import shlex
-from typing import TYPE_CHECKING, Callable, Literal, Self
-
-from textual import on
-from textual.reactive import var, Initialize
-from textual.app import ComposeResult
-
-from textual.actions import SkipAction
-from textual.binding import Binding
-
-from textual.content import Content
-from textual import getters
-from textual.message import Message
-from textual.widgets import OptionList, TextArea, Label
-from textual import containers
-from textual.widget import Widget
-from textual.widgets.option_list import Option
-from textual.widgets.text_area import Selection
-from textual.document._document import EditResult
-from textual import events
-
-from tui.app import A2TUIApp
-from tui import messages
-from tui.widgets.highlighted_textarea import HighlightedTextArea
-from tui.widgets.condensed_path import CondensedPath
-from tui.widgets.path_search import PathSearch
-from tui.widgets.pending_prompts import PendingPrompts
-from tui.widgets.plan import Plan
-from tui.answer import Answer
-from tui.widgets.question import Ask, Question
-from tui.widgets.slash_complete import SlashComplete
-from tui.messages import UserInputSubmitted
-from tui.slash_command import SlashCommand
-from tui.prompt.extract import extract_paths_from_prompt
-from tui.path_complete import PathComplete
-
-if TYPE_CHECKING:
-    from tui.acp.agent import Mode
-
-
-class ModeSwitcher(OptionList):
-    BINDING_GROUP_TITLE = "Mode switcher"
-    BINDINGS = [Binding("escape", "dismiss", "Dismiss mode switcher")]
-
-    @on(OptionList.OptionSelected)
-    def on_option_selected(self, event: OptionList.OptionSelected):
-        self.post_message(messages.ChangeMode(event.option_id))
-        self.blur()
-
-    def action_dismiss(self):
-        self.blur()
-
-
-class InvokeFileSearch(Message):
-    pass
-
-
-class InvokeSlashComplete(Message):
-    pass
-
-
-class AgentInfo(Label):
-    pass
-
-
-class ModeInfo(Label):
-    pass
-
-
-class StatusLine(Label):
-    status: var[str] = var("")
-
-    def watch_status(self, status: str) -> None:
-        self.set_class(not bool(status), "-hidden")
-        self.update(status)
-        self.tooltip = status
-
-
-class PromptContainer(containers.HorizontalGroup):
-    def on_mouse_down(self, event: events.MouseUp) -> None:
-        for child in self.query("*"):
-            if child.has_focus:
-                return
-        prompt_text_area = self.query_one(PromptTextArea)
-        if not prompt_text_area.has_focus:
-            prompt_text_area.focus()
-
-
-class PromptTextArea(HighlightedTextArea):
-    HELP = """\
-## Prompt
-
-Talk to your agent in natural language.
-See on-screen instructions for details.
-
-- Be simple
-- Be direct
-- Nothing fancy
-"""
-
-    BINDING_GROUP_TITLE = "Prompt"
-
-    BINDINGS = [
-        Binding(
-            "enter",
-            "submit",
-            "Send",
-            key_display="⏎",
-            priority=True,
-            tooltip="Send the prompt to the agent",
-            show=False,
-        ),
-        Binding(
-            "alt+enter,shift+enter",
-            "newline",
-            "Line",
-            key_display="⌥+⏎",
-            tooltip="Insert a new line character",
-            show=False,
-        ),
-        Binding(
-            "alt+enter,shift+enter",
-            "multiline_submit",
-            "Send",
-            key_display="⌥+⏎",
-            tooltip="Send the prompt to the agent",
-        ),
-        Binding(
-            "tab",
-            "tab_complete",
-            "Complete",
-            tooltip="Complete path (if possible)",
-            priority=True,
-            show=False,
-        ),
-    ]
-
-    app = getters.app(A2TUIApp)
-
-    auto_completes: var[list[Option]] = var(list)
-    multi_line = var(False, bindings=True)
-    shell_mode = var(False, bindings=True)
-    agent_ready: var[bool] = var(False)
-    path_complete: var[PathComplete] = var(Initialize(lambda obj: PathComplete()))
-    suggestions: var[list[str] | None] = var(None)
-    suggestions_index: var[int] = var(0)
-
-    project_path = var(Path())
-    working_directory = var("")
-
-    slash_commands: var[list[SlashCommand]] = var([])
-    slash_command_prefixes: var[tuple[str, ...]] = var(())
-
-    class Submitted(Message):
-        def __init__(self, markdown: str) -> None:
-            self.markdown = markdown
-            super().__init__()
-
-    class RequestShellMode(Message):
-        pass
-
-    class CancelShell(Message):
-        pass
-
-    def watch_slash_commands(self, slash_commands: list[SlashCommand]) -> None:
-        """A tuple of slash commands for performance reasons (used with `str.startswith`)."""
-        self.slash_command_prefixes = tuple(
-            [slash_command.command for slash_command in slash_commands]
-        )
-
-    def highlight_slash_command(self, text: str) -> Content:
-        """Override slash command highlighting."""
-
-        if text.startswith(self.slash_command_prefixes):
-            content = Content(text)
-            for slash_command in self.slash_commands:
-                if text.startswith(slash_command.command + " "):
-                    content = content.stylize(
-                        "$text-success", 0, len(slash_command.command)
-                    )
-                    if (
-                        slash_command.hint
-                        and len(text) - (len(slash_command.command) + 1) == 0
-                    ):
-                        content += Content.styled(
-                            slash_command.hint, "$text-secondary 70%"
-                        )
-                    break
-            return content
-        return Content(text)
-
-    def highlight_shell(self, text: str) -> Content:
-        """Override shell highlighting with additional danger detection."""
-        content = super().highlight_shell(text)
-
-        if not self.app.settings.get("shell.warn_dangerous", bool):
-            return content
-
-        from tui import danger
-
-        spans, _danger_level = danger.detect(
-            str(self.project_path), self.working_directory, content.plain
-        )
-        content = content.add_spans(spans)
-        return content
-
-    def on_mount(self) -> None:
-        self.highlight_cursor_line = False
-        self.hide_suggestion_on_blur = False
-        self._paste_queue: list[tuple[str, str]] = []
-        self._paste_fingerprint = ""
-        self._paste_summary_enabled: bool = not bool(
-            self.app.settings.get("experimental.disable_paste_summary", bool)
-        )
-
-    QUICK_COUNT_SAMPLE = 1000
-    HUGE_PASTE_THRESHOLD = 100000
-
-    async def _on_paste(self, event: events.Paste) -> None:
-        """Handle paste events with fast path for large text to avoid blocking UI."""
-        if self.read_only:
-            return
-
-        text_len = len(event.text)
-        MAX_PASTE_CHARS = 50000
-
-        if text_len > MAX_PASTE_CHARS:
-            self.post_message(
-                messages.Flash(
-                    "内容过大，已截断",
-                    style="warning",
-                    duration=3,
-                )
-            )
-            self._paste_fingerprint = ""
-            self._paste_queue.clear()
-            text_copy = event.text[:MAX_PASTE_CHARS]
-            self._paste_queue.append((text_copy, "[Pasted large content]"))
-            self.insert("[Pasted large content] ")
-            return
-
-        await super()._on_paste(event)
-
-    def _replace_via_keyboard(self, text: str, start, end) -> EditResult | None:
-        if self.read_only:
-            return None
-
-        text_len = len(text)
-        MAX_PASTE_CHARS = 50000
-
-        if text_len > MAX_PASTE_CHARS:
-            self._paste_fingerprint = ""
-            self._paste_queue.clear()
-            sample = text[: self.QUICK_COUNT_SAMPLE]
-            sample_lines = sample.count("\n") + 1
-            estimated_line_count = int(sample_lines * text_len / len(sample))
-            marker = f"[Pasted ~{estimated_line_count} lines] (truncated)"
-            self._paste_queue.append((text[:MAX_PASTE_CHARS], marker))
-            self.post_message(
-                messages.Flash(
-                    f"[Pasted ~{estimated_line_count} lines, 内容过大已截断]",
-                    style="warning",
-                    duration=3,
-                )
-            )
-            self.insert(marker + " ")
-            return None
-
-        fingerprint = text.replace("\r\n", "\n").replace("\r", "\n").strip()
-
-        if fingerprint and self._paste_fingerprint == fingerprint:
-            self._paste_fingerprint = ""
-            self._paste_queue.clear()
-            return None
-
-        if text_len <= 150:
-            self._paste_fingerprint = ""
-            self._paste_queue.clear()
-            return super()._replace_via_keyboard(text, start, end)
-
-        if not self._paste_summary_enabled:
-            self._paste_fingerprint = ""
-            self._paste_queue.clear()
-            return super()._replace_via_keyboard(text, start, end)
-
-        self._paste_fingerprint = fingerprint
-
-        sample = text[: self.QUICK_COUNT_SAMPLE]
-        sample_normalized = sample.replace("\r\n", "\n").replace("\r", "\n")
-        sample_lines = sample_normalized.count("\n") + 1
-        if text_len <= self.QUICK_COUNT_SAMPLE:
-            line_count = sample_lines
-        else:
-            line_count = int(sample_lines * text_len / len(sample))
-
-        char_count = text_len
-        text_to_store = text
-        truncated = False
-
-        if char_count > MAX_PASTE_CHARS:
-            text_to_store = text[:MAX_PASTE_CHARS]
-            truncated = True
-            self.post_message(
-                messages.Flash(
-                    f"[Pasted ~{line_count} lines, 内容过大已截断]",
-                    style="warning",
-                    duration=3,
-                )
-            )
-        elif line_count > 30:
-            self.post_message(
-                messages.Flash(
-                    f"[Pasted ~{line_count} lines]",
-                    style="default",
-                    duration=2,
-                )
-            )
-
-        marker = f"[Pasted ~{line_count} lines]" + (" (truncated)" if truncated else "")
-        self._paste_queue.append((text_to_store, marker))
-        self.insert(marker + " ")
-        return None
-
-    def action_copy(self) -> None:
-        """Copy selection to clipboard; if no selection, clear the text area."""
-        if not self.selection.is_empty:
-            self.app.copy_to_clipboard(self.selected_text)
-        else:
-            self.clear()
-            self._paste_queue.clear()
-
-    def on_key(self, event: events.Key) -> None:
-        if (
-            not self.shell_mode
-            and self.cursor_location == (0, 0)
-            and event.character in {"!", "$"}
-        ):
-            self.post_message(self.RequestShellMode())
-            event.prevent_default()
-        elif self.shell_mode and event.key == "tab":
-            event.prevent_default()
-        elif event.key == "escape":
-            self._paste_queue.clear()
-        else:
-            self.suggestions = None
-            self.suggestion = ""
-
-    def update_suggestion(self) -> None:
-        prompt = self.query_ancestor(Prompt)
-
-        if self.selection.start == self.selection.end and self.text.startswith("/"):
-            return
-
-        if self.shell_mode and self.cursor_at_end_of_text and "\n" not in self.text:
-            if prompt.complete_callback is not None:
-                if completes := prompt.complete_callback(self.text):
-                    if self.text not in completes:
-                        self.suggestion = completes[-1]
-
-    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
-        if action == "newline" and self.multi_line:
-            return False
-        if action == "submit" and self.multi_line:
-            return False
-        if action == "multiline_submit":
-            return self.multi_line
-        return True
-
-    def action_multiline_submit(self) -> None:
-        if not self.agent_ready:
-            self.app.bell()
-            self.post_message(
-                messages.Flash(
-                    "Agent is not ready. Please wait while the agent connects…",
-                    "error",
-                )
-            )
-            return
-        body = self._expand_paste_markers(self.text)
-        self._paste_queue.clear()
-        self.post_message(UserInputSubmitted(body, self.shell_mode))
-        self.clear()
-
-    def action_newline(self) -> None:
-        self.insert("\n")
-
-    def _expand_paste_markers(self, body: str) -> str:
-        """Expand paste markers in body text by replacing them with original content."""
-        for original, marker in self._paste_queue:
-            if marker in body:
-                body = body.replace(marker, original, 1)
-        return body
-
-    def action_submit(self) -> None:
-        if not self.agent_ready and not self.shell_mode:
-            self.app.bell()
-            self.post_message(
-                messages.Flash(
-                    "Agent is not ready. Please wait while the agent connects…",
-                    "error",
-                )
-            )
-            return
-        if self.suggestion:
-            if " " not in self.text:
-                self.insert(self.suggestion + " ")
-            else:
-                prompt = self.query_ancestor(Prompt)
-                last_token = shlex.split(self.text + self.suggestion)[-1]
-                last_token_path = Path(prompt.working_directory) / last_token
-                if last_token_path.is_dir():
-                    self.insert(self.suggestion)
-                else:
-                    self.insert(self.suggestion + " ")
-                self.suggestion = ""
-            return
-        body = self._expand_paste_markers(self.text)
-        self._paste_queue.clear()
-        self.post_message(UserInputSubmitted(body, self.shell_mode))
-        self.clear()
-
-    def action_cursor_up(self, select: bool = False):
-        if self.selection.is_empty and not select:
-            row, _column = self.selection[0]
-            if row == 0:
-                self.post_message(messages.HistoryMove(-1, self.shell_mode, self.text))
-                return
-        super().action_cursor_up(select)
-
-    def action_cursor_down(self, select: bool = False):
-        if self.selection.is_empty and not select:
-            row, _column = self.selection[0]
-            if row == (self.wrapped_document.height - 1):
-                self.post_message(messages.HistoryMove(+1, self.shell_mode, self.text))
-                return
-        super().action_cursor_down(select)
-
-    def action_delete_left(self) -> None:
-        selection = self.selection
-        if selection.start == selection.end and self.selection.end == (0, 0):
-            self.post_message(self.CancelShell())
-            return
-        return super().action_delete_left()
-
-    def action_cursor_line_end(self, select: bool = False) -> None:
-        """Move the cursor to the end of the line."""
-        if not self._has_cursor:
-            self.scroll_end()
-            return
-        location = self.get_cursor_line_end_location()
-        if location == self.cursor_location:
-            # If the cursor is already at the end, then we assume the user wants to
-            # scroll the conversation to the end
-            from tui.widgets.conversation import Conversation
-
-            self.query_ancestor(Conversation).window.anchor()
-        else:
-            self.move_cursor(location, select=select)
-
-    async def action_tab_complete(self) -> None:
-        if not self.shell_mode:
-            raise SkipAction()
-
-        import shlex
-
-        prompt = self.query_ancestor(Prompt)
-
-        if not self.cursor_at_end_of_text:
-            return
-
-        _cursor_row, cursor_column = prompt.prompt_text_area.selection.end
-        pre_complete = self.text[:cursor_column]
-        post_complete = self.text[cursor_column:]
-        shlex_tokens = shlex.split(pre_complete)
-        if not shlex_tokens:
-            return
-
-        command = shlex_tokens[0]
-
-        exclude_node_type: Literal["file"] | Literal["dir"] | None = None
-        if (
-            command
-            in self.app.settings.get("shell.directory_commands", str).splitlines()
-        ):
-            exclude_node_type = "file"
-        elif command in self.app.settings.get("shell.file_commands", str).splitlines():
-            exclude_node_type = "dir"
-
-        tab_complete, suggestions = await self.path_complete(
-            Path(prompt.working_directory),
-            shlex_tokens[-1],
-            exclude_type=exclude_node_type,
-        )
-
-        if tab_complete is not None:
-            shlex_tokens = shlex_tokens[:-1] + [shlex_tokens[-1] + tab_complete]
-            path_component = Path(prompt.working_directory) / shlex_tokens[-1]
-            if path_component.is_file():
-                spaces = " "
-            else:
-                spaces = ""
-
-            self.clear()
-            self.insert(
-                " ".join(token.replace(" ", "\\ ") for token in shlex_tokens)
-                + post_complete
-                + spaces
-            )
-            self.suggestions = None
-        else:
-            if suggestions != self.suggestions:
-                self.suggestions = suggestions or None
-                self.suggestions_index = 0
-                if suggestions:
-                    self.suggestion = suggestions[0]
-            elif self.suggestions:
-                self.suggestions_index = (self.suggestions_index + 1) % len(
-                    self.suggestions
-                )
-                self.suggestion = self.suggestions[self.suggestions_index]
-
-    async def watch_selection(
-        self, previous_selection: Selection, selection: Selection
-    ) -> None:
-        if previous_selection == selection:
-            return
-        if selection.start == selection.end:
-            previous_y, previous_x = previous_selection.end
-            y, x = selection.end
-            if y == previous_y:
-                direction = -1 if x < previous_x else +1
-            else:
-                direction = 0
-            line = self.document.get_line(y)
-
-            if (
-                not self.shell_mode
-                and y == 0
-                and x == 1
-                and direction == +1
-                and line
-                and line[0] == "/"
-            ):
-                self.post_message(InvokeSlashComplete())
-                return
-
-            if y == 0 and line and line[0] == "/" and direction == -1:
-                if line in self.slash_command_prefixes:
-                    self.selection = Selection((0, 0), (0, len(line)))
-                    return
-
-            for _path, start, end in extract_paths_from_prompt(line):
-                if x > start and x < end:
-                    self.selection = Selection((y, start), (y, end))
-                    break
-                if direction == -1 and x == end:
-                    self.selection = Selection((y, start), (y, end))
-                    break
-
-            if x > 0 and x <= len(line) and line[x - 1] == "@":
-                remaining_line = line[x + 1 :]
-                if not remaining_line or remaining_line[0].isspace():
-                    self.post_message(InvokeFileSearch())
-
-
-class Prompt(containers.VerticalGroup):
-
-    BINDINGS = [
-        Binding("escape", "dismiss", "Dismiss", show=False),
-    ]
-
-    PROMPT_NULL = " "
-    PROMPT_SHELL = Content.styled("$", "$text-primary")
-    PROMPT_AI = Content.styled("❯", "$text-secondary")
-    PROMPT_MULTILINE = Content.styled("☰", "$text-secondary")
-
-    prompt_container = getters.query_one("#prompt-container", Widget)
-    prompt_text_area = getters.query_one(PromptTextArea)
-    prompt_label = getters.query_one("#prompt", Label)
-    current_directory = getters.query_one(CondensedPath)
-    path_search = getters.query_one(PathSearch)
-    slash_complete = getters.query_one(SlashComplete)
-    question = getters.query_one(Question)
-    mode_switcher = getters.query_one(ModeSwitcher)
-
-    slash_commands: var[list[SlashCommand]] = var(list)
-    shell_mode = var(False)
-    multi_line = var(False)
-    show_path_search = var(False, toggle_class="-show-path-search", bindings=True)
-    show_slash_complete = var(False, toggle_class="-show-slash-complete", bindings=True)
-    project_path = var(Path, init=False)
-    working_directory = var("")
-    agent_info = var(Content(""))
-    _ask: var[Ask | None] = var(None)
-    plan: var[list[Plan.Entry]]
-    agent_ready: var[bool] = var(False)
-    current_mode: var[Mode | None] = var(None)
-    modes: var[dict[str, Mode] | None] = var(None)
-    status: var[str] = var("")
-    pending_prompts: var[list[str]] = var([])
-
-    app = getters.app(A2TUIApp)
-
-    def __init__(
-        self,
-        *,
-        name: str | None = None,
-        id: str | None = None,
-        classes: str | None = None,
-        disabled: bool = False,
-        complete_callback: Callable[[str], list[str]] | None = None,
-    ):
-        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
-        self.ask_queue: list[Ask] = []
-        self.complete_callback = complete_callback
-
-    @property
-    def text(self) -> str:
-        return self.prompt_text_area.text
-
-    @text.setter
-    def text(self, text: str) -> None:
-        self.prompt_text_area.text = text
-        self.prompt_text_area.selection = Selection.cursor(
-            self.prompt_text_area.get_cursor_line_end_location()
-        )
-
-    def watch_current_mode(self, mode: Mode | None) -> None:
-        self.set_class(mode is not None, "-has-mode")
-        if mode is not None:
-            tooltip = Content.from_markup(
-                "[b]$description[/]\n\n[dim](click to open mode switcher)",
-                description=mode.description,
-            )
-            self.query_one(ModeInfo).with_tooltip(tooltip).update(mode.name)
-        self.watch_modes(self.modes)
-
-    async def watch_project_path(self, old_path: Path, new_path: Path) -> None:
-        """Initial refresh of paths."""
-        if old_path != new_path:
-            self.call_later(self.path_search.refresh_paths)
-
-    def ask(self, ask: Ask) -> None:
-        """Replace the textarea prompt with a menu of options.
-
-        Args:
-            ask: An `Ask` instance which contains a question and responses.
-        """
-        self.ask_queue.append(ask)
-        self.app.terminal_alert()
-        if self._ask is None:
-            self._ask = self.ask_queue.pop(0)
-
-    @on(events.Click, "ModeInfo")
-    def on_click(self):
-        self.mode_switcher.focus()
-
-    def watch_modes(self, modes: dict[str, Mode] | None) -> None:
-        from tui.visuals.columns import Columns
-
-        columns = Columns("auto", "auto", "flex")
-        if modes is not None:
-            mode_list = sorted(modes.values(), key=lambda mode: mode.name.lower())
-            for mode in mode_list:
-                columns.add_row(
-                    (
-                        Content.styled("✔", "$text-success")
-                        if self.current_mode and mode.id == self.current_mode.id
-                        else ""
-                    ),
-                    Content.from_markup("[bold]$mode[/]", mode=mode.name),
-                    Content.styled(mode.description or "", "dim"),
-                )
-        else:
-            mode_list = []
-
-        self.mode_switcher.set_options(
-            [Option(row, id=mode.id) for row, mode in zip(columns, mode_list)]
-        )
-        if self.current_mode is not None:
-            self.mode_switcher.highlighted = self.mode_switcher.get_option_index(
-                self.current_mode.id
-            )
-
-    def watch_agent_ready(self, ready: bool) -> None:
-        self.set_class(not ready, "-not-ready")
-        if ready:
-            self.query_one(AgentInfo).update(self.agent_info)
-
-    def watch_agent_info(self, agent_info: Content) -> None:
-        if self.agent_ready:
-            self.query_one(AgentInfo).update(agent_info)
-        else:
-            self.query_one(AgentInfo).update("Initializing…")
-
-    def watch_multiline(self) -> None:
-        self.update_prompt()
-
-    def watch_shell_mode(self) -> None:
-        self.update_prompt()
-
-    def watch_working_directory(self, working_directory: str) -> None:
-        if not working_directory:
-            return
-        out_of_bounds = not Path(working_directory).is_relative_to(self.project_path)
-        if out_of_bounds and not self.has_class("-working-directory-out-of-bounds"):
-            self.post_message(
-                messages.Flash(
-                    "You have navigated away from the project directory",
-                    style="error",
-                    duration=5,
-                )
-            )
-        self.set_class(
-            out_of_bounds,
-            "-working-directory-out-of-bounds",
-        )
-
-    def watch__ask(self, ask: Ask | None) -> None:
-        self.set_class(ask is not None, "-mode-ask")
-        if ask is None:
-            self.prompt_text_area.focus()
-        else:
-            self.question.update(ask)
-            self.question.focus()
-
-    def update_prompt(self):
-        """Update the prompt according to the current mode."""
-        if self.shell_mode:
-            self.prompt_label.update(self.PROMPT_SHELL, layout=False)
-            self.add_class("-shell-mode")
-            self.prompt_text_area.placeholder = Content.from_markup(
-                "Enter shell command\t[r]▌esc▐[/r] prompt mode"
-            ).expand_tabs(8)
-            self.prompt_text_area.highlight_language = "shell"
-        else:
-            self.prompt_label.update(
-                self.PROMPT_MULTILINE if self.multi_line else self.PROMPT_AI,
-                layout=False,
-            )
-            self.remove_class("-shell-mode")
-
-            prompt_message = self.app.settings.get("ui.prompt_message", str)
-            self.prompt_text_area.placeholder = Content.assemble(
-                f"{prompt_message}\t".expandtabs(8),
-                ("▌!▐", "r"),
-                " shell ",
-                ("▌/▐", "r"),
-                " commands ",
-                ("▌@▐", "r"),
-                " files",
-            )
-            self.prompt_text_area.highlight_language = "markdown"
-
-    @property
-    def likely_shell(self) -> bool:
-        text = self.prompt_text_area.text
-        if "\n" in text or " " in text or not text.strip():
-            return False
-
-        shell_commands = {
-            command.strip()
-            for command in self.app.settings.get(
-                "shell.allow_commands", expect_type=str
-            ).split()
-        }
-        if text.split(" ", 1)[0] in shell_commands:
-            return True
-        return False
-
-    @property
-    def is_shell_mode(self) -> bool:
-        return self.shell_mode or self.likely_shell
-
-    def focus(self, scroll_visible: bool = True) -> Self:
-        if self._ask is not None:
-            self.question.focus()
-        else:
-            self.query(HighlightedTextArea).focus()
-        return self
-
-    def append(self, text: str) -> None:
-        self.query_one(HighlightedTextArea).insert(
-            text, maintain_selection_offset=False
-        )
-
-    def watch_show_path_search(self, show: bool) -> None:
-        self.prompt_text_area.suggestion = ""
-
-    def watch_show_slash_complete(self, show: bool) -> None:
-        if show:
-            self.slash_complete.focus()
-
-    def project_directory_updated(self) -> None:
-        """Called when there is may be new files"""
-        self.path_search.refresh_paths()
-
-    @on(PromptTextArea.RequestShellMode)
-    def on_request_shell_mode(self, event: PromptTextArea.RequestShellMode):
-        self.shell_mode = True
-        self.update_prompt()
-
-    @on(TextArea.Changed)
-    def on_text_area_changed(self, event: TextArea.Changed) -> None:
-        text = event.text_area.text
-
-        self.multi_line = "```" in text
-
-        if not self.multi_line and self.likely_shell:
-            self.shell_mode = True
-
-        self.update_prompt()
-
-    @on(PromptTextArea.CancelShell)
-    def on_cancel_shell(self, event: PromptTextArea.CancelShell):
-        self.shell_mode = False
-
-    @on(InvokeFileSearch)
-    def on_invoke_file_search(self, event: InvokeFileSearch) -> None:
-        event.stop()
-        if not self.shell_mode:
-            self.show_path_search = True
-            self.path_search.reset()
-
-    @on(InvokeSlashComplete)
-    def on_invoke_slash_complete(self, event: InvokeSlashComplete) -> None:
-        event.stop()
-        self.show_slash_complete = True
-
-    @on(messages.PromptSuggestion)
-    def on_prompt_suggestion(self, event: messages.PromptSuggestion) -> None:
-        event.stop()
-        self.prompt_text_area.suggestion = event.suggestion
-
-    @on(SlashComplete.Completed)
-    def on_slash_complete_completed(self, event: SlashComplete.Completed) -> None:
-        self.prompt_text_area.clear()
-        self.prompt_text_area.insert(f"{event.command} ")
-        self.prompt_text_area.suggestion = ""
-        self.focus()
-
-    @on(messages.Dismiss)
-    def on_dismiss(self, event: messages.Dismiss) -> None:
-        event.stop()
-        if event.widget is self.slash_complete and self.show_slash_complete:
-            self.show_slash_complete = False
-            self.prompt_text_area.suggestion = ""
-            self.focus()
-        elif event.widget is self.path_search and self.show_path_search:
-            self.show_path_search = False
-            self.focus()
-
-    @on(messages.InsertPath)
-    def on_insert_path(self, event: messages.InsertPath) -> None:
-        event.stop()
-        if " " in event.path:
-            path = f'"{event.path}"'
-        else:
-            path = event.path
-            if (
-                self.prompt_text_area.get_text_range(*self.prompt_text_area.selection)
-                != " "
-            ):
-                path += " "
-        self.prompt_text_area.insert(path)
-
-    @on(Question.Answer)
-    def on_question_answer(self, event: Question.Answer) -> None:
-        """Question has been answered."""
-        event.stop()
-
-        def remove_question() -> None:
-            """Remove the question and restore the text prompt."""
-            if self.ask_queue:
-                self._ask = self.ask_queue.pop(0)
-            else:
-                self._ask = None
-            self.app.terminal_alert(False)
-
-        if self._ask is not None and (callback := self._ask.callback) is not None:
-            callback(event.answer)
-
-        self.set_timer(0.3, remove_question)
-
-    def suggest(self, suggestion: str) -> None:
-        if suggestion.startswith(self.text) and self.text != suggestion:
-            self.prompt_text_area.suggestion = suggestion[len(self.text) :]
-
-    def compose(self) -> ComposeResult:
-        yield PathSearch(self.project_path).data_bind(root=Prompt.project_path)
-        yield SlashComplete().data_bind(slash_commands=Prompt.slash_commands)
-        yield PendingPrompts().data_bind(_prompts=Prompt.pending_prompts)
-        with PromptContainer(id="prompt-container"):
-            yield Question()
-            with containers.HorizontalGroup(id="text-prompt"):
-                yield Label(self.PROMPT_AI, id="prompt", markup=False)
-                yield PromptTextArea().data_bind(
-                    multi_line=Prompt.multi_line,
-                    shell_mode=Prompt.shell_mode,
-                    agent_ready=Prompt.agent_ready,
-                    project_path=Prompt.project_path,
-                    working_directory=Prompt.working_directory,
-                    slash_commands=Prompt.slash_commands,
-                )
-        with containers.HorizontalGroup(id="info-container"):
-            yield AgentInfo()
-            yield CondensedPath().data_bind(path=Prompt.working_directory)
-            yield StatusLine(markup=False).data_bind(status=Prompt.status)
-            yield ModeSwitcher()
-            yield ModeInfo("mode")
-
-    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
-        return True
-
-    def action_dismiss(self) -> None:
-        if self._ask is not None:
-            ask = self._ask
-            if (callback := ask.callback) is not None:
-                callback(Answer("Cancelled", "reject_once", "reject_once"))
-            self.ask_queue.clear()
-            self._ask = None
-            self.app.terminal_alert(False)
-            return
-        if self.prompt_text_area.suggestion:
-            self.prompt_text_area.suggestion = ""
-            return
-        if self.shell_mode:
-            self.shell_mode = False
-        elif self.show_slash_complete:
-            self.show_slash_complete = False
-        else:
-            raise SkipAction()