symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/composer/input.py

@@ -0,0 +1,219 @@
+"""Prompt editor and composer chrome."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from textual import events
+from textual.containers import Container, Horizontal
+from textual.message import Message
+from textual.widgets import Button, Static, TextArea
+
+from coding_agent.tui.screens.modal import ContentModal
+from core_ai.types import Content
+from coding_agent.tui.tools.images import ImageAttachment, ImageModal, dropped_image_paths
+from coding_agent.tui.transcript import UserMessage
+
+
+@dataclass(frozen=True)
+class QueuedTurn:
+    """Composer submission: model content, visible text, pastes, and images."""
+
+    content: Content
+    text: str
+    pasted_chunks: tuple[str, ...]
+    images: tuple[ImageAttachment, ...]
+    voice: bool = False
+
+
+class PromptInput(TextArea):
+    """Multiline prompt editor with compact handling for large pastes and images."""
+
+    class Submitted(Message):
+        def __init__(self, text_area: "PromptInput") -> None:
+            self.input = text_area
+            super().__init__()
+
+    COMPACT_PASTE_AFTER = UserMessage.COMPACT_PASTE_AFTER
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self._pasted_chunks: list[tuple[str, str]] = []
+        self._images: list[ImageAttachment] = []
+        self._image_seq = 0
+        self.submit_on_enter = True
+        super().__init__(*args, **kwargs)
+
+    @property
+    def value(self) -> str:
+        return self.text
+
+    @value.setter
+    def value(self, value: str) -> None:
+        self.load_text(value)
+
+    @property
+    def cursor_position(self) -> int:
+        return self.document.get_index_from_location(self.cursor_location)
+
+    @cursor_position.setter
+    def cursor_position(self, value: int) -> None:
+        self.cursor_location = self.document.get_location_from_index(value)
+
+    def action_submit(self) -> None:
+        self.post_message(self.Submitted(self))
+
+    def on_key(self, event: events.Key) -> None:
+        """Submit on Enter; preserve Shift+Enter for inserting a newline."""
+        if event.key == "shift+enter":
+            return
+        if event.key != "enter":
+            return
+        # Voice mode is listening. Enter commits the utterance; it must not
+        # submit the partial transcript as a typed turn.
+        if getattr(self.app, "_voice_active", False):
+            from coding_agent.tui.composer.voice_mode import commit_voice
+
+            commit_voice(self.app)
+            event.prevent_default()
+            event.stop()
+            return
+        from coding_agent.tui.composer.slash_menu import SlashMenu
+
+        approval_menu = self.app.query_one("#approval-menu", SlashMenu)
+        if approval_menu.display and approval_menu.selected_value:
+            self.app._choose_menu_option(approval_menu, submit=True)
+        else:
+            menu = self.app.query_one("#slash-menu", SlashMenu)
+            if menu.display and menu.selected_value:
+                self.app._choose_menu_option(menu, submit=True)
+            elif self.submit_on_enter:
+                self.action_submit()
+            else:
+                return
+        event.prevent_default()
+        event.stop()
+
+    @property
+    def pasted_chunks(self) -> tuple[str, ...]:
+        return tuple(content for _marker, content in self._pasted_chunks)
+
+    @property
+    def images(self) -> tuple[ImageAttachment, ...]:
+        return tuple(self._images)
+
+    def expanded_value(self, value: str | None = None) -> str:
+        """Restore compact markers to the clipboard text sent to the agent."""
+        expanded = self.value if value is None else value
+        for marker, content in self._pasted_chunks:
+            expanded = expanded.replace(marker, content, 1)
+        return expanded
+
+    def take_pasted_chunks(self) -> tuple[str, ...]:
+        chunks = self.pasted_chunks
+        self._pasted_chunks.clear()
+        return chunks
+
+    def take_images(self) -> tuple[ImageAttachment, ...]:
+        images = self.images
+        self._images.clear()
+        self._image_seq = 0
+        return images
+
+    def _insert_paste(self, content: str) -> None:
+        if not content:
+            return
+        paths = dropped_image_paths(content)
+        if paths:
+            for path in paths:
+                self._attach_image(path)
+            return
+        start, end = self.selection.start, self.selection.end
+        should_compact = (
+            len(content) > self.COMPACT_PASTE_AFTER or "\n" in content or "\r" in content
+        )
+        if not should_compact:
+            self.replace(content, start, end)
+            return
+        marker = f"[{len(content):,} chars]"
+        self.replace(marker, start, end)
+        self._pasted_chunks.append((marker, content))
+
+    def _attach_image(self, path: Path) -> None:
+        self._image_seq += 1
+        marker = f"[Image {self._image_seq}]"
+        self._images.append(ImageAttachment.from_path(path, marker))
+        start, end = self.selection.start, self.selection.end
+        index = self.document.get_index_from_location(start)
+        prefix = ""
+        if index > 0 and self.value[index - 1] not in " \n\t":
+            prefix = " "
+        self.replace(f"{prefix}{marker} ", start, end)
+
+    def _on_paste(self, event: Any) -> None:
+        self._insert_paste(str(event.text))
+        event.prevent_default()
+        event.stop()
+
+    def action_paste(self) -> None:
+        self._insert_paste(self.app.clipboard)
+
+    def on_click(self, event: Any) -> None:
+        position = self.cursor_position
+        search_from = 0
+        for marker, content in self._pasted_chunks:
+            start = self.value.find(marker, search_from)
+            if start < 0:
+                continue
+            end = start + len(marker)
+            if start <= position <= end:
+                self.app.push_screen(ContentModal(content))
+                event.stop()
+                return
+            search_from = end
+        search_from = 0
+        for image in self._images:
+            start = self.value.find(image.marker, search_from)
+            if start < 0:
+                continue
+            end = start + len(image.marker)
+            if start <= position <= end:
+                self.app.push_screen(ImageModal(image))
+                event.stop()
+                return
+            search_from = end
+
+
+PROMPT_PLACEHOLDER = "Ask Symphony..."
+
+
+class QueuedPrompt(Container):
+    """Follow-up prompt controls shown on one line inside the composer."""
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        yield Static("", id="queued-prompt-text", markup=False)
+        yield Button("Send now", id="queued-send-now", variant="default")
+        yield Button("Edit", id="queued-edit", variant="default")
+
+    def refresh_queue(self, queued: Sequence[QueuedTurn]) -> None:
+        visible = bool(queued)
+        if self.display != visible:
+            self.display = visible
+        if queued:
+            self.query_one("#queued-prompt-text", Static).update(queued[0].text)
+
+
+class Composer(Container):
+    """Borderless prompt under a thin separator, for composing messages."""
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        yield QueuedPrompt(id="queued-prompt-row")
+        with Horizontal(id="composer-row"):
+            yield PromptInput(
+                placeholder=PROMPT_PLACEHOLDER,
+                id="prompt",
+                soft_wrap=True,
+                show_line_numbers=False,
+            )

coding_agent/tui/composer/slash_menu.py

@@ -0,0 +1,341 @@
+"""Slash-command, file, and question selection menu."""
+
+from __future__ import annotations
+
+from pathlib import PurePosixPath
+from typing import Any
+
+from rich.text import Text
+from textual import events
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+
+from coding_agent.commands.catalog import (
+    EffortOption,
+    ModelOption,
+    PersonalityOption,
+    SlashCommand,
+)
+from coding_agent.tui.screens.file_selector import FileOption
+from coding_agent.tui.theme import SYMPHONY_COLORS
+
+
+class SlashMenu(OptionList):
+    """Cached completion menu for files and commands."""
+
+    _files_cache: tuple[FileOption, ...] | None = None
+    _matches_cache: dict[tuple[str, str], tuple[Option, ...]] = {}
+
+    @classmethod
+    def clear_session_cache(cls) -> None:
+        cls._files_cache = None
+        cls._matches_cache.clear()
+
+    """Discoverable command suggestions displayed above the composer."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, markup=False, **kwargs)
+        self.selected_index = 0
+        self._option_offset = 0
+        self._commands: tuple[SlashCommand, ...] = ()
+        self._models: tuple[ModelOption, ...] = ()
+        self._personalities: tuple[PersonalityOption, ...] = ()
+        self._efforts: tuple[EffortOption, ...] = ()
+        self._files: tuple[FileOption, ...] = ()
+        self._questions: tuple[str, ...] = ()
+        self._question_text = ""
+        self._question_kind = ""
+        self._current_model = ""
+        self._current_personality = ""
+        self._current_effort = ""
+
+    @property
+    def selected_value(self) -> str:
+        if self._files:
+            return f"@{self._files[self.selected_index].path}"
+        if self._models:
+            return f"/model {self._models[self.selected_index].id}"
+        if self._personalities:
+            return f"/personality {self._personalities[self.selected_index].id}"
+        if self._efforts:
+            return f"/effort {self._efforts[self.selected_index].id}"
+        if self._questions:
+            return self._questions[self.selected_index]
+        if self._commands:
+            return f"/{self._commands[self.selected_index].name}"
+        return ""
+
+    @property
+    def is_file_selector(self) -> bool:
+        return bool(self._files)
+
+    @property
+    def _choice_count(self) -> int:
+        return (
+            len(self._files)
+            or len(self._models)
+            or len(self._personalities)
+            or len(self._efforts)
+            or len(self._questions)
+            or len(self._commands)
+        )
+
+    def move_selection(self, offset: int) -> None:
+        count = self._choice_count
+        if not count:
+            return
+        self.selected_index = (self.selected_index + offset) % count
+        self.highlighted = self.selected_index + self._option_offset
+
+    def _move_pointer_selection(self, offset: int) -> None:
+        """Move selection without wrapping at the ends for pointer scrolling."""
+        selected_index = min(
+            max(0, self.selected_index + offset), self._choice_count - 1
+        )
+        if selected_index != self.selected_index:
+            self.selected_index = selected_index
+            self.highlighted = selected_index + self._option_offset
+
+    def select_option_index(self, option_index: int) -> bool:
+        """Synchronize selection from an OptionList pointer event."""
+        selected_index = option_index - self._option_offset
+        if not 0 <= selected_index < self._choice_count:
+            return False
+        self.selected_index = selected_index
+        self.highlighted = option_index
+        return True
+
+    def on_option_list_option_highlighted(
+        self, event: OptionList.OptionHighlighted
+    ) -> None:
+        """Keep pointer hover and keyboard selection on the same option."""
+        selected_index = event.option_index - self._option_offset
+        if 0 <= selected_index < self._choice_count:
+            self.selected_index = selected_index
+
+    def on_mouse_scroll_down(self, event: events.MouseScrollDown) -> None:
+        if self._choice_count:
+            self._move_pointer_selection(1)
+            event.prevent_default()
+            event.stop()
+
+    def on_mouse_scroll_up(self, event: events.MouseScrollUp) -> None:
+        if self._choice_count:
+            self._move_pointer_selection(-1)
+            event.prevent_default()
+            event.stop()
+
+    def _replace_choices(
+        self,
+        *,
+        commands: tuple[SlashCommand, ...] = (),
+        models: tuple[ModelOption, ...] = (),
+        personalities: tuple[PersonalityOption, ...] = (),
+        efforts: tuple[EffortOption, ...] = (),
+        files: tuple[FileOption, ...] = (),
+        questions: tuple[str, ...] = (),
+        question_text: str = "",
+        question_kind: str = "",
+        selected_index: int = 0,
+    ) -> None:
+        self._commands = commands
+        self._models = models
+        self._personalities = personalities
+        self._efforts = efforts
+        self._files = files
+        self._questions = questions
+        self._question_text = question_text
+        self._question_kind = question_kind
+        self.selected_index = selected_index
+        self.set_class(question_kind == "approval", "permission-menu")
+        self.set_class(bool(files), "file-menu")
+
+        if self._choice_count or question_text:
+            self._render_options()
+        elif self.display:
+            self._hide()
+
+    def _hide(self) -> None:
+        self._option_offset = 0
+        self.clear_options()
+        self.remove_class("permission-menu")
+        self.remove_class("file-menu")
+        self.display = False
+
+    def set_commands(self, commands: tuple[SlashCommand, ...]) -> None:
+        self._replace_choices(commands=commands)
+
+    def set_models(self, models: tuple[ModelOption, ...], current: str = "") -> None:
+        self._current_model = current
+        self._replace_choices(models=models)
+
+    def set_personalities(
+        self, personalities: tuple[PersonalityOption, ...], current: str = ""
+    ) -> None:
+        self._current_personality = current
+        self._replace_choices(personalities=personalities)
+
+    def set_efforts(self, efforts: tuple[EffortOption, ...], current: str = "") -> None:
+        self._current_effort = current
+        selected_index = next(
+            (index for index, effort in enumerate(efforts) if effort.id == current),
+            0,
+        )
+        self._replace_choices(efforts=efforts, selected_index=selected_index)
+
+
+    def set_files(self, files: tuple[FileOption, ...]) -> None:
+        if self._files_cache == files:
+            files = self._files_cache
+        else:
+            self._files_cache = files
+        self._replace_choices(files=files)
+
+    def set_question(
+        self,
+        question: str,
+        choices: list[str],
+        *,
+        default: str = "",
+        kind: str = "",
+    ) -> None:
+        selected_index = choices.index(default) if default in choices else 0
+        self._replace_choices(
+            questions=tuple(choices),
+            question_text=question,
+            question_kind=kind,
+            selected_index=selected_index,
+        )
+
+    def _render_options(self) -> None:
+        if self._question_text:
+            rows, headers, hint = self._question_rows()
+            self._set_rendered_options(rows, headers=headers, hint=hint)
+            return
+
+        rows = self._choice_rows()
+        if self._files:
+            self._set_rendered_options(
+                rows,
+                headers=[Text("  FILES", style="#666666")],
+                hint="  ↑↓ select   Tab insert   Enter choose",
+            )
+            return
+        self._set_rendered_options(
+            rows, hint="   ↑/↓ select  ·  Enter choose  ·  Tab complete"
+        )
+
+    def _question_rows(self) -> tuple[list[Text], list[Text], str]:
+        if self._question_kind == "approval":
+            rows = [self._approval_choice(choice) for choice in self._questions]
+            return rows, self._approval_headers(), "   Enter confirm  ·  Esc deny"
+
+        rows = [Text(f"   {choice}", style="#c5c5c5") for choice in self._questions]
+        headers = [Text(f"?  {self._question_text}", style="bold #d7d7d7")]
+        hint = (
+            "   ↑/↓ select  ·  Enter choose"
+            if self._questions
+            else "   Type an answer  ·  Enter submit"
+        )
+        return rows, headers, hint
+
+    @staticmethod
+    def _approval_choice(choice: str) -> Text:
+        if choice == "Allow once":
+            return Text("   ✓  Allow once", style="bold #8fc49a")
+        if choice == "Always allow":
+            return Text("   ⚡  Always allow", style="bold #e0b66b")
+        if choice == "Deny":
+            return Text("   ×  Deny", style="bold #df8b91")
+        return Text(f"   {choice}", style="#c5c5c5")
+
+    def _choice_rows(self) -> list[Text]:
+        if self._files:
+            return [self._file_row(file) for file in self._files]
+        if self._models:
+            return [self._model_row(model) for model in self._models]
+        if self._personalities:
+            return [
+                self._described_row(
+                    f"{'●' if item.id == self._current_personality else '○'} {item.id:<27}",
+                    item.description,
+                )
+                for item in self._personalities
+            ]
+        if self._efforts:
+            return [
+                self._described_row(
+                    f"{'●' if effort.id == self._current_effort else '○'} {effort.label:<27}",
+                    effort.description,
+                )
+                for effort in self._efforts
+            ]
+        return [
+            self._described_row(f"{command.usage:<22}", command.description)
+            for command in self._commands
+        ]
+
+    def _model_row(self, model: ModelOption) -> Text:
+        """Active model gets a mark. The rest stay plain so the list can scroll."""
+        current = model.id == self._current_model
+        name = model.label or model.id.split(":", 1)[-1]
+        provider = model.id.split(":", 1)[0]
+        row = Text("  ▸ " if current else "    ", style=f"bold {SYMPHONY_COLORS['accent']}")
+        row.append(name, style="bold #ededed" if current else "#d0d0d0")
+        row.append(f"   {provider}", style="#737373")
+        if model.description and model.description != provider:
+            detail = model.description.split("·", 1)[-1].strip()
+            row.append(f"  {detail}", style="#5f5f5f")
+        return row
+
+    @staticmethod
+    def _described_row(label: str, description: str) -> Text:
+        row = Text(f"   {label}", style="bold #c5c5c5")
+        row.append(description, style="#858585")
+        return row
+
+    @staticmethod
+    def _file_row(file: FileOption) -> Text:
+        path = PurePosixPath(file.path)
+        parent = "" if str(path.parent) == "." else f"{path.parent}/"
+        row = Text("  @  ", style="#7085ba")
+        row.append(parent, style="#737373")
+        row.append(path.name, style="#d0d0d0")
+        occupied = 5 + len(parent) + len(path.name)
+        row.append(" " * max(3, 58 - occupied))
+        row.append(file.description, style="#5f5f5f")
+        return row
+
+    def _set_rendered_options(
+        self,
+        rows: list[Text],
+        *,
+        headers: list[Text] | None = None,
+        hint: str,
+    ) -> None:
+        headers = headers or []
+        self._option_offset = len(headers)
+        options = [Option(header, disabled=True) for header in headers]
+        options.extend(
+            Option(row, id=f"choice-{index}") for index, row in enumerate(rows)
+        )
+        options.append(Option(Text(hint, style="#505050"), disabled=True))
+        self.set_options(options)
+        if rows:
+            self.selected_index = min(self.selected_index, len(rows) - 1)
+            self.highlighted = self.selected_index + self._option_offset
+        self.display = True
+
+    def _approval_headers(self) -> list[Text]:
+        summary, _, detail = self._question_text.partition("\n")
+        action = detail.strip().strip("`") or summary.replace("`", "")
+        preview = Text()
+        for index, line in enumerate(action.splitlines() or [action]):
+            if index:
+                preview.append("\n")
+            preview.append("  │ ", style="#666666")
+            preview.append(line, style="bold #d0d0d0")
+        return [
+            Text("  Allow Symphony to run the following command?", style="bold #d0d0d0"),
+            preview,
+        ]