symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/tools/images.py

@@ -0,0 +1,250 @@
+"""Image attachments for the coding-agent TUI."""
+
+from __future__ import annotations
+
+import base64
+import io
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Sequence
+from urllib.parse import unquote, urlparse
+
+from rich.text import Text
+from textual.containers import Container
+from textual.widget import Widget
+from textual.widgets import Static
+
+from core_ai.content import IMAGE_MIME_BY_SUFFIX, image_part, normalize_content, sniff_image_media_type
+from core_ai.types import Content
+from coding_agent.tui.screens.modal import ModalBase, ModalCloseButton, ModalScroll
+from coding_agent.tui.theme import IMAGE_MODAL_CSS
+
+
+IMAGE_MARKER_RE = re.compile(r"\[Image (\d+)\]")
+IMAGE_EXTENSIONS = set(IMAGE_MIME_BY_SUFFIX)
+IMAGE_MIME_TYPES = IMAGE_MIME_BY_SUFFIX
+
+
+@dataclass(frozen=True)
+class ImageAttachment:
+    """One dropped or restored image, referenced in the composer as `[Image N]`."""
+
+    marker: str
+    filename: str
+    media_type: str
+    data: str
+    path: str | None = None
+
+    @property
+    def number(self) -> str:
+        match = IMAGE_MARKER_RE.fullmatch(self.marker)
+        return match.group(1) if match else self.marker
+
+    def to_part(self) -> dict[str, str]:
+        return image_part(
+            media_type=self.media_type,
+            data=self.data,
+            filename=self.filename,
+        )
+
+    def decoded(self) -> bytes:
+        return base64.b64decode(self.data) if self.data else b""
+
+    @classmethod
+    def from_path(cls, path: Path, marker: str) -> "ImageAttachment":
+        payload = path.read_bytes()
+        suffix = path.suffix.lower()
+        return cls(
+            marker=marker,
+            filename=path.name,
+            media_type=sniff_image_media_type(payload, filename=path.name) or IMAGE_MIME_TYPES.get(suffix, "image/png"),
+            data=base64.b64encode(payload).decode("ascii"),
+            path=str(path),
+        )
+
+    @classmethod
+    def from_part(cls, part: dict[str, object], marker: str) -> "ImageAttachment":
+        return cls(
+            marker=marker,
+            filename=str(part.get("filename") or "image"),
+            media_type=str(part.get("media_type") or "image/png"),
+            data=str(part.get("data") or ""),
+        )
+
+
+def dropped_image_paths(text: str) -> list[Path]:
+    """Return image files when the entire paste is one or more dropped paths."""
+    stripped = text.strip()
+    if not stripped:
+        return []
+    single = _resolve_image_path(stripped)
+    if single is not None:
+        return [single]
+    lines = [line.strip() for line in stripped.splitlines() if line.strip()]
+    if len(lines) > 1:
+        paths = [_resolve_image_path(line) for line in lines]
+        if all(path is not None for path in paths):
+            return [path for path in paths if path is not None]
+        return []
+    tokens = _split_path_tokens(stripped)
+    if not tokens:
+        return []
+    paths = []
+    for token in tokens:
+        path = _resolve_image_path(token)
+        if path is None:
+            return []
+        paths.append(path)
+    return paths
+
+
+def build_user_content(text: str, images: Sequence[ImageAttachment]) -> Content:
+    """Turn composer text plus `[Image N]` attachments into canonical content."""
+    active = [image for image in images if image.marker in text]
+    if not active:
+        return text
+    parts: list[dict[str, object]] = []
+    remaining = text
+    for image in active:
+        before, _marker, remaining = remaining.partition(image.marker)
+        if before:
+            parts.append({"type": "text", "text": before})
+        parts.append(image.to_part())
+    if remaining:
+        parts.append({"type": "text", "text": remaining})
+    return parts
+
+
+def display_from_content(content: Content) -> tuple[str, tuple[ImageAttachment, ...]]:
+    """Rebuild composer-style text and attachments from a stored message body."""
+    if isinstance(content, str) or content is None:
+        return content or "", ()
+    chunks: list[str] = []
+    images: list[ImageAttachment] = []
+    for part in normalize_content(content):
+        if part["type"] == "text":
+            text = str(part.get("text") or "")
+            if text:
+                chunks.append(text)
+            continue
+        marker = f"[Image {len(images) + 1}]"
+        images.append(ImageAttachment.from_part(part, marker))
+        if chunks and not chunks[-1].endswith((" ", "\n", "\t")):
+            chunks.append(" ")
+        chunks.append(marker)
+        chunks.append(" ")
+    return "".join(chunks).strip(), tuple(images)
+
+
+def textual_image(payload: bytes, *, widget_id: str | None = None) -> Widget:
+    """Render image bytes with textual-image, which picks the terminal's best protocol."""
+    from textual_image.widget import Image as TextualImage
+
+    image = TextualImage(io.BytesIO(payload) if payload else None, id=widget_id)
+    image.styles.max_width = 88
+    image.styles.max_height = 28
+    return image
+
+
+def _split_path_tokens(text: str) -> list[str]:
+    tokens: list[str] = []
+    current: list[str] = []
+    quote: str | None = None
+    index = 0
+    while index < len(text):
+        char = text[index]
+        if quote:
+            if char == quote:
+                quote = None
+            else:
+                current.append(char)
+            index += 1
+            continue
+        if char in {'"', "'"}:
+            quote = char
+            index += 1
+            continue
+        if char == "\\" and index + 1 < len(text) and text[index + 1] == " ":
+            current.append(" ")
+            index += 2
+            continue
+        if char.isspace():
+            if current:
+                tokens.append("".join(current))
+                current = []
+            index += 1
+            continue
+        current.append(char)
+        index += 1
+    if quote:
+        return []
+    if current:
+        tokens.append("".join(current))
+    return tokens
+
+
+def _resolve_image_path(token: str) -> Path | None:
+    raw = token.strip().replace("\\ ", " ")
+    if not raw or "\n" in raw or "\r" in raw or len(raw) > 1024:
+        return None
+    if raw.startswith("file://"):
+        raw = unquote(urlparse(raw).path)
+    path = Path(raw).expanduser()
+    if path.suffix.lower() not in IMAGE_EXTENSIONS:
+        return None
+    try:
+        path = path.resolve()
+        if not path.is_file():
+            return None
+    except OSError:
+        return None
+    return path
+
+
+class ImageModal(ModalBase[None]):
+    """Terminal image preview behind a compact `[Image 1]` chip."""
+
+    CSS = IMAGE_MODAL_CSS
+
+    def __init__(self, attachment: ImageAttachment) -> None:
+        super().__init__()
+        self.attachment = attachment
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        with Container(id="content-pane", classes="modal-pane"):
+            yield ModalCloseButton("Esc", id="modal-close")
+            yield Static(self._title(), id="image-title")
+            with ModalScroll(id="content-body", classes="modal-body"):
+                yield textual_image(self.attachment.decoded(), widget_id="image-preview")
+            yield Static("↑↓ scroll   ·   Esc close", classes="modal-footer")
+
+    def _title(self) -> Text:
+        title = Text()
+        title.append(self.attachment.filename, style="bold #d0d0d0")
+        details = self._details()
+        if details:
+            title.append(f"  ·  {details}", style="#686868")
+        return title
+
+    def _details(self) -> str:
+        bits = [self.attachment.media_type]
+        payload = self.attachment.decoded()
+        size = _image_size(payload)
+        if size is not None:
+            bits.insert(0, f"{size[0]}×{size[1]}")
+        return "  ·  ".join(bits)
+
+
+def _image_size(payload: bytes) -> tuple[int, int] | None:
+    if not payload:
+        return None
+    try:
+        from PIL import Image
+    except ImportError:
+        return None
+    try:
+        with Image.open(io.BytesIO(payload)) as image:
+            return image.size
+    except Exception:  # noqa: BLE001
+        return None

coding_agent/tui/tools/labels.py

@@ -0,0 +1,135 @@
+"""One-line labels, argument summaries, and result previews for tool cards."""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Mapping
+
+from textual.content import Content
+
+from coding_agent.tui.tools.partial_args import string_field
+from coding_agent.tui.transcript.messages import clip_text, compact_json
+
+TOOL_LABELS = {
+    "bash": ("Bash", "$"),
+    "search": ("Search", "⌕"),
+    "web_search": ("Web Search", "⌕"),
+    "write_file": ("Write", "+"),
+    "generate_image": ("Image", "└"),
+    "patch": ("Update", "±"),
+    "read_file": ("Read", "└"),
+}
+
+
+def tool_label(tool_name: str) -> tuple[str, str]:
+    return TOOL_LABELS.get(tool_name, (tool_name.replace("_", " ").title(), "›"))
+
+
+def tool_detail(
+    tool_name: str,
+    arguments: Mapping[str, Any] | None = None,
+    raw_arguments: str = "",
+) -> str:
+    args = dict(arguments or {})
+    if tool_name == "bash":
+        return str(args.get("command") or raw_arguments)
+    if tool_name in {"search", "web_search"}:
+        return str(args.get("query") or args.get("pattern") or compact_json(args))
+    if tool_name == "patch":
+        return patch_path(args, raw_arguments)
+    if tool_name in {"write_file", "generate_image", "read_file"}:
+        path = str(args.get("path") or "")
+        if path:
+            return path
+        return compact_json(args) or raw_arguments
+    return compact_json(args) or raw_arguments
+
+
+def patch_path(arguments: Mapping[str, Any], raw_arguments: str = "", result: str = "") -> str:
+    """Recover the target even when a restored patch has only its result."""
+    path = str(arguments.get("path") or "").strip()
+    if path:
+        return path
+    raw_path = string_field(raw_arguments, "path")
+    if raw_path is not None:
+        return raw_path
+    for pattern in (
+        r"^(?:patched|updated) (.+?)(?: \(|$)",
+        r"^noop: .* in (.+?); no change",
+        r"^old_str not found in (.+)$",
+        r"^error: (?:file not found|not a file|file is not valid UTF-8 text): (.+)$",
+        r"^error: failed to (?:read|write) (.+?): ",
+    ):
+        match = re.search(pattern, result, re.MULTILINE | re.IGNORECASE)
+        if match:
+            return match.group(1).strip()
+    return ""
+
+
+def tool_header_text(label: str, target: str, status: str) -> Content:
+    """Status-colored tool name plus a muted target, without parsing the target as markup."""
+    color = {
+        "preparing": "#d7a84b",
+        "running": "#d7a84b",
+        "done": "#72a57a",
+        "failed": "#d66b73",
+    }.get(status, "#9aa7b2")
+    parts: list[tuple[str, str]] = [(label, f"bold {color}")]
+    if target:
+        parts.append((f" {target}", "#9aa7b2"))
+    return Content.assemble(*parts)
+
+
+def header_target(summary: str) -> str:
+    """Show the protocol value beside the verb: path, command, or query."""
+    text = " ".join(str(summary or "").split())
+    if not text:
+        return ""
+    head, _, rest = text.partition(" ")
+    if "/" in head or head.startswith(("~", ".")):
+        leaf = head.replace("\\", "/").rstrip("/").split("/")[-1].strip()
+        if leaf:
+            return f"{leaf} {rest}".strip() if rest else leaf
+    return text
+
+
+def result_preview(tool_name: str, result: str) -> str:
+    if not result:
+        return ""
+    if tool_name == "bash":
+        return clip_text("\n".join(result.splitlines()[-4:]), 360)
+    return clip_text(result, 260)
+
+
+def read_file_detail(arguments: Mapping[str, Any], raw_arguments: str) -> str:
+    path = arguments.get("path")
+    if not path:
+        path = string_field(raw_arguments or "", "path")
+        if path is None:
+            return raw_arguments
+    offset = int(arguments.get("offset") or 1)
+    limit = int(arguments.get("limit") or 0)
+    if offset == 1 and not limit:
+        return str(path)
+    end = offset + limit - 1 if limit else "…"
+    return f"{path}  lines {offset}–{end}"
+
+
+def read_file_result(result: str) -> str:
+    if not result:
+        return ""
+    if result.startswith("error:"):
+        return result
+    if result.startswith("Read image ") or "[image:" in result:
+        return result.splitlines()[0]
+    count = len(result.splitlines())
+    size = len(result.encode("utf-8"))
+    return f"Read {count} lines ({size:,} bytes)"
+
+
+def generate_image_result(result: str) -> str:
+    if not result:
+        return ""
+    if result.startswith("error:"):
+        return result
+    return result.splitlines()[0]

coding_agent/tui/tools/modal.py

@@ -0,0 +1,137 @@
+"""Details card for one finished tool call."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.console import Group
+from rich.text import Text
+from textual import events
+from textual.containers import Container, Horizontal
+from textual.widgets import Input, Static
+
+from coding_agent.tui.screens.modal import ModalBase, ModalCloseButton, ModalScroll
+from coding_agent.tui.theme import CONTENT_MODAL_CSS
+from coding_agent.tui.transcript.messages import SelectableStatic
+
+if TYPE_CHECKING:
+    from coding_agent.tui.tools.calls import ToolCallWidget
+
+_FILE_TOKEN = re.compile(r"(?<!\S)([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)(?!\S)")
+_CODE_SUFFIXES = {".py", ".js", ".ts", ".json", ".md", ".toml", ".yaml", ".yml", ".sh"}
+
+
+class ToolCallModal(ModalBase[None]):
+    """A snapshot of one finished tool call, opened from its transcript row.
+
+    The card is rendered once when it opens. Live calls stay in the transcript
+    and do not push updates into this modal, so a busy run cannot stall the UI
+    by rebuilding a card on every chunk.
+    """
+
+    BINDINGS = [("slash", "focus_search", "Search"), ("w", "toggle_wrap", "Wrap"), ("y", "copy_detail", "Copy")]
+
+    CSS = CONTENT_MODAL_CSS + """
+    ToolCallModal { align: center middle; background: rgba(0, 0, 0, 0.52); }
+    #tool-meta, #tool-command, #tool-detail { width: 100%; height: auto; background: #0d0d0d; }
+    #tool-detail { padding: 1 2; }
+    #tool-search { display: none; width: 100%; height: 1; }
+    .jump-chip { width: auto; height: 1; margin-right: 1; color: #87b5b1; }
+    """
+
+    def __init__(self, tool: ToolCallWidget) -> None:
+        super().__init__()
+        self.tool = tool
+        self._wrap = False
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        with Container(id="content-pane", classes="modal-pane"):
+            yield ModalCloseButton("Esc", id="modal-close")
+            yield Static(self.tool.detail_title(), id="content-title", markup=False)
+            yield Static(self._meta(), id="tool-meta", markup=False)
+            command = self.tool._summary()
+            if command:
+                yield Static(command, id="tool-command", markup=False)
+            chips = self._jump_targets()
+            if chips:
+                with Horizontal(id="tool-jumps"):
+                    for path in chips:
+                        yield Static(path, classes="jump-chip", markup=False)
+            yield Input(placeholder="Search", id="tool-search")
+            with ModalScroll(id="content-body", classes="modal-body"):
+                yield SelectableStatic(self._body(), id="tool-detail", markup=False)
+            yield Static("↑↓ scroll   ·   / search   ·   w wrap   ·   y copy   ·   Esc close", classes="modal-footer")
+
+    def on_mount(self) -> None:
+        self.query_one(ModalScroll).focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id != "tool-search":
+            return
+        query = event.value.strip().lower()
+        body = self.query_one("#tool-detail", Static)
+        if not query:
+            body.update(self._body())
+            return
+        lines = self.tool.detail_plain().splitlines()
+        matches = [line for line in lines if query in line.lower()]
+        body.update(Text("\n".join(matches) or "No matches.", style="#d0d0d0"))
+
+    def action_focus_search(self) -> None:
+        search = self.query_one("#tool-search", Input)
+        search.display = True
+        search.focus()
+
+    def action_toggle_wrap(self) -> None:
+        self._wrap = not self._wrap
+        self.query_one("#tool-detail", Static).update(self._body())
+
+    def action_copy_detail(self) -> None:
+        copy = getattr(self.app, "copy_to_clipboard", None)
+        if not callable(copy):
+            return
+        copy(self.tool.detail_plain())
+        notify = getattr(self.app, "notify", None)
+        if callable(notify):
+            notify("Copied tool details.")
+
+    def _body(self) -> object:
+        rows = self.tool.detail_rows(wrap=self._wrap) or [Text("No details yet.", style="#686868")]
+        return Group(*rows)
+
+    def _meta(self) -> str:
+        lines = len(self.tool.detail_plain().splitlines())
+        timeout = self.tool.arguments.get("timeout")
+        parts = [f"{lines} lines"]
+        if timeout:
+            parts.insert(0, f"timeout {timeout}s")
+        return "  ·  ".join(parts)
+
+    def _jump_targets(self) -> tuple[str, ...]:
+        workspace = getattr(self.tool, "workspace", None)
+        if not isinstance(workspace, Path):
+            return ()
+        candidates = [str(self.tool.arguments.get("path") or "")]
+        candidates.extend(_FILE_TOKEN.findall(self.tool._summary()))
+        found: list[str] = []
+        root = workspace.resolve()
+        for candidate in candidates:
+            path = Path(candidate)
+            if path.suffix.lower() not in _CODE_SUFFIXES or path.is_absolute():
+                continue
+            if (root / path).is_file() and candidate not in found:
+                found.append(candidate)
+            if len(found) == 4:
+                break
+        return tuple(found)
+
+    def on_click(self, event: events.Click) -> None:
+        target = getattr(event.widget, "classes", None)
+        if target is None or "jump-chip" not in target:
+            return
+        path = str(event.widget.render())
+        opener = getattr(self.app, "open_file_preview", None)
+        if callable(opener):
+            opener(path)

coding_agent/tui/tools/partial_args.py

@@ -0,0 +1,19 @@
+"""Read string values out of tool-call JSON that may still be streaming."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Optional
+
+
+def string_field(raw: str, key: str) -> Optional[str]:
+    """Decoded value of the first complete ``"key": "..."`` string in ``raw``.
+
+    ``raw`` may be a partial JSON blob, so this does not parse the whole
+    document. Returns None when no complete string value for ``key`` exists.
+    """
+    match = re.search(rf'"{re.escape(key)}"\s*:\s*"((?:\\.|[^"\\])*)"', raw)
+    if match is None:
+        return None
+    return json.loads(f'"{match.group(1)}"')