symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/screens/diff.py

@@ -0,0 +1,302 @@
+"""Workspace diff modal screen."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+from rich.text import Text
+from textual import events
+from textual.binding import Binding
+from textual.containers import Container, Horizontal
+from textual.widgets import Static
+from textual.worker import get_current_worker
+
+from coding_agent.tui.screens.modal import EmptyState, ModalBase, ModalCloseButton, ModalScroll
+from coding_agent.tui.theme import DIFF_MODAL_CSS
+from coding_agent.tui.tools.calls import diff_stats
+
+
+# Cards mount in batches so a large diff never holds the UI loop for one
+# long layout pass; the loop paints and takes keys between batches.
+CARD_MOUNT_BATCH = 16
+_HUNK_RE = re.compile(r"@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)")
+# git diff runs in a worker thread; a hung git (lock, network FS) ends here
+# with a message instead of holding the worker forever.
+GIT_DIFF_TIMEOUT_S = 10.0
+
+
+def read_workspace_diff(workspace: Path) -> str:
+    """Return the current workspace diff, or a user-facing failure message."""
+    try:
+        result = subprocess.run(
+            # Context is intentional: the modal is a code review surface, not just a
+            # change counter. It also makes the line-number gutter useful.
+            ["git", "-C", str(workspace), "diff", "--unified=3", "--", "."],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=GIT_DIFF_TIMEOUT_S,
+        )
+    except Exception as exc:  # noqa: BLE001
+        return f"Failed to run git diff: {exc}"
+
+    output = (result.stdout or "").strip()
+    if output:
+        return output
+    if result.returncode != 0:
+        err = (result.stderr or "").strip()
+        return err or "git diff failed"
+    return "No local changes found."
+
+
+def split_diff(diff_text: str) -> list[tuple[str, str]]:
+    """Split a Git diff into a path and body for each changed file."""
+    files: list[tuple[str, str]] = []
+    path = ""
+    lines: list[str] = []
+    for line in diff_text.splitlines():
+        if line.startswith("diff --git "):
+            if path:
+                files.append((path, "\n".join(lines)))
+            paths = line.removeprefix("diff --git ")
+            path = paths.split(" b/", 1)[-1].removeprefix("b/")
+            lines = []
+        elif line.startswith(("index ", "--- ", "+++ ", "new file", "deleted file")):
+            continue
+        elif path:
+            lines.append(line)
+
+    if path:
+        files.append((path, "\n".join(lines)))
+    return files
+
+
+def _numbered_diff(body: str) -> Text:
+    """Render a unified patch with the compact gutter used by the diff modal."""
+    # Diff rows must stay on one terminal line. Wrapping long generated source
+    # makes continuation rows look like unnumbered diff lines.
+    rendered = Text(no_wrap=True, overflow="crop")
+    hunks = [match for line in body.splitlines() if (match := _HUNK_RE.match(line))]
+    number_width = max(
+        2,
+        *(len(match.group(1)) for match in hunks),
+        *(len(match.group(3)) for match in hunks),
+    )
+    # A patch can start with a hunk header followed by no context. Keep the
+    # gutter stable and reserve one extra column for the change marker.
+    old_line = new_line = 0
+
+    for source in body.splitlines():
+        match = _HUNK_RE.match(source)
+        if match:
+            old_line = int(match.group(1))
+            new_line = int(match.group(3))
+            # Keep the hunk marker aligned with the source below it. The section
+            # name is retained because it is useful when scanning a large file.
+            rendered.append(" " * (number_width + 5), style="#687e8b")
+            rendered.append(source, style="bold #83a9bd")
+            rendered.append("\n")
+            continue
+
+        if source.startswith("+"):
+            line_number = new_line
+            new_line += 1
+            marker = "+"
+            style = "#a8d58d on #19301d"
+        elif source.startswith("-"):
+            line_number = old_line
+            old_line += 1
+            marker = "-"
+            style = "#e49a9d on #321c20"
+        elif source.startswith(" "):
+            line_number = new_line
+            old_line += 1
+            new_line += 1
+            marker = " "
+            style = "#b8bec1"
+        else:
+            line_number = 0
+            marker = " "
+            style = "#737b7f"
+
+        number = str(line_number) if line_number else ""
+        gutter = f"{number:>{number_width}} {marker} │ "
+        content = source[1:] if source[:1] in {"+", "-", " "} else source
+        rendered.append(gutter + content, style=style)
+        rendered.append("\n")
+
+    if rendered.plain.endswith("\n"):
+        rendered = rendered[:-1]
+    return rendered
+
+
+class DiffFileCard(Container):
+    """One changed file with its compact header and patch."""
+
+    def __init__(self, path: str, body: str, *, patch: Text | None = None) -> None:
+        self.path = path
+        self.body = body
+        # ``patch`` is the rendered body when a worker already built it.
+        self.patch = patch
+        self.additions, self.deletions = diff_stats(body.splitlines())
+        super().__init__(classes="diff-file-card")
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        stats = Text()
+        stats.append(f"+{self.additions}", style="bold #8fc49a")
+        stats.append(f"  −{self.deletions}", style="bold #df8b91")
+        with Horizontal(classes="diff-file-header"):
+            yield Static("▾", classes="diff-file-chevron")
+            yield Static(Text(self.path, style="bold #d0d0d0"), classes="diff-file-path")
+            yield Static(stats, classes="diff-file-stats")
+        patch = self.patch if self.patch is not None else _numbered_diff(self.body)
+        yield Static(patch, classes="diff-patch", markup=False)
+
+    def toggle_collapsed(self) -> bool:
+        """Toggle this card and return whether it is now collapsed."""
+        collapsed = self.has_class("collapsed")
+        if collapsed:
+            self.remove_class("collapsed")
+        else:
+            self.add_class("collapsed")
+        self.query_one(".diff-file-chevron", Static).update("▸" if not collapsed else "▾")
+        return not collapsed
+
+
+class DiffModal(ModalBase[None]):
+    """Fullscreen modal for inspecting one changed file at a time."""
+
+    CSS = DIFF_MODAL_CSS
+    BINDINGS = [
+        Binding("escape", "close_modal", "Close", show=False, priority=True),
+        Binding("n", "next_file", "Next file", show=False, priority=True),
+        Binding("p", "previous_file", "Previous file", show=False, priority=True),
+        Binding("enter", "toggle_collapse", "Collapse", show=False, priority=True),
+    ]
+
+    def __init__(self, workspace: Path) -> None:
+        super().__init__()
+        self.workspace = workspace
+        self._file_data: list[tuple[str, str]] = []
+        self._file_index = 0
+        self._cards: list[DiffFileCard] = []
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        # git diff can take seconds on a large tree. It runs in a worker after
+        # mount; the frame and a loading state paint first.
+        with Container(id="diff-pane", classes="modal-pane"):
+            # Keep the left side compact, then use a dedicated spacer to pin the
+            # file count and close affordance to the right edge.
+            yield Horizontal(
+                Static("diff", id="diff-title"),
+                Static("", id="diff-path"),
+                Static(
+                    Text.assemble(
+                        ("+0", "bold #8fc49a"),
+                        ("  ", "#777777"),
+                        ("−0", "bold #df8b91"),
+                    ),
+                    id="diff-total-stats",
+                ),
+                Static("", id="diff-header-spacer"),
+                Static("loading", id="diff-file-counter"),
+                ModalCloseButton("esc  close", id="modal-close"),
+                id="diff-header",
+            )
+            with ModalScroll(id="diff-body", classes="modal-body"):
+                yield EmptyState("Loading diff", "Running git diff…", id="diff-loading")
+            yield Static(
+                "↑↓ scroll    n next file    p previous file    enter collapse    esc close",
+                id="diff-hint",
+                classes="modal-footer",
+            )
+
+    def on_mount(self) -> None:
+        self.run_worker(self._read_diff, thread=True, group="workspace-diff", exit_on_error=False)
+
+    def _read_diff(self) -> None:
+        """Worker thread: run git, split and render the patches, then hand off."""
+        diff_text = read_workspace_diff(self.workspace)
+        files = split_diff(diff_text)
+        patches = [_numbered_diff(file_body) for _path, file_body in files]
+        if not get_current_worker().is_cancelled:
+            self.app.call_from_thread(self._show_diff, diff_text, files, patches)
+
+    async def _show_diff(
+        self, diff_text: str, files: list[tuple[str, str]], patches: list[Text]
+    ) -> None:
+        if not self.is_attached:
+            return  # closed while git was running
+        self._file_data = files
+        body = self.query_one("#diff-body", ModalScroll)
+        await self.query_one("#diff-loading", EmptyState).remove()
+        if not self._file_data:
+            is_clean = diff_text.strip() in {"", "No local changes found."}
+            self.query_one("#diff-file-counter", Static).update("0 files")
+            await body.mount(EmptyState(
+                "Working tree is clean" if is_clean else "Diff unavailable",
+                diff_text.strip() or "There are no uncommitted changes to review.",
+            ))
+            return
+        self._cards = [
+            DiffFileCard(path, file_body, patch=patch)
+            for (path, file_body), patch in zip(files, patches)
+        ]
+        for start in range(0, len(self._cards), CARD_MOUNT_BATCH):
+            await body.mount_all(self._cards[start:start + CARD_MOUNT_BATCH])
+            if start == 0:
+                self._show_file(0, scroll=False)
+            if not self.is_attached:
+                return
+
+    def on_key(self, event: events.Key) -> None:
+        """Keep modal shortcuts active while the scroll container has focus."""
+        actions = {
+            "n": self.action_next_file,
+            "p": self.action_previous_file,
+            "enter": self.action_toggle_collapse,
+        }
+        action = actions.get(event.key)
+        if action is not None:
+            event.stop()
+            action()
+
+    def _show_file(self, index: int, *, scroll: bool = True) -> None:
+        if not self._cards:
+            return
+        for card in self._cards:
+            card.remove_class("selected")
+            card.add_class("inactive")
+        self._file_index = index % len(self._cards)
+        card = self._cards[self._file_index]
+        card.remove_class("inactive")
+        card.add_class("selected")
+        path, body = self._file_data[self._file_index]
+        additions, deletions = diff_stats(body.splitlines())
+        self.query_one("#diff-path", Static).update(path)
+        self.query_one("#diff-file-counter", Static).update(
+            f"{self._file_index + 1} of {len(self._cards)} files"
+        )
+        self.query_one("#diff-total-stats", Static).update(
+            Text.assemble(
+                (f"+{additions}", "bold #8fc49a"),
+                ("  ", "#777777"),
+                (f"−{deletions}", "bold #df8b91"),
+            )
+        )
+        if scroll:
+            card.scroll_visible(animate=False, top=True)
+
+    def action_next_file(self) -> None:
+        if self._cards:
+            self._show_file(self._file_index + 1)
+
+    def action_previous_file(self) -> None:
+        if self._cards:
+            self._show_file(self._file_index - 1)
+
+    def action_toggle_collapse(self) -> None:
+        if self._cards:
+            self._cards[self._file_index].toggle_collapsed()

coding_agent/tui/screens/extensions.py

@@ -0,0 +1,68 @@
+"""Installed skills and plugins inspector."""
+from __future__ import annotations
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import Static
+
+from coding_agent.addons.skills.args import render_args
+from coding_agent.addons.plugins import LoadedPlugin
+from coding_agent.addons.skills import Skill
+from coding_agent.tui.screens.modal import EmptyState, ModalBase, ModalCloseButton, ModalScroll
+from coding_agent.tui.theme import EXTENSIONS_MODAL_CSS
+
+
+def _skill_card(skill: Skill):
+    """Render one skill as a compact card: name, origin, description, args, and path."""
+    with Vertical(classes="extension-card"):
+        with Horizontal(classes="extension-card-header"):
+            yield Static(skill.name, classes="extension-name")
+            yield Static(skill.origin, classes="extension-origin")
+        yield Static(skill.description, classes="extension-description", markup=False)
+        if skill.args:
+            yield Static(f"args  {render_args(skill.args)}", classes="extension-path", markup=False)
+        yield Static(f"SKILL.md  {skill.root / 'SKILL.md'}", classes="extension-path", markup=False)
+
+
+def _plugin_card(plugin: LoadedPlugin):
+    """Render one plugin manifest as a card: id, enabled state, description, and root."""
+    with Vertical(classes="extension-card"):
+        with Horizontal(classes="extension-card-header"):
+            yield Static(plugin.plugin_id, classes="extension-name", markup=False)
+            yield Static("ENABLED" if plugin.enabled else "DISABLED", classes=(
+                "extension-status enabled" if plugin.enabled else "extension-status disabled"
+            ))
+        if plugin.description:
+            yield Static(plugin.description, classes="extension-description", markup=False)
+        yield Static(str(plugin.root), classes="extension-path", markup=False)
+
+class ExtensionsModal(ModalBase[None]):
+    """Show the skills and plugins available to this workspace."""
+    CSS = EXTENSIONS_MODAL_CSS
+
+    def __init__(self, skills: tuple[Skill, ...], plugins: tuple[LoadedPlugin, ...]) -> None:
+        super().__init__()
+        self.skills, self.plugins = skills, plugins
+
+    def compose(self):
+        total = len(self.skills) + len(self.plugins)
+        with Container(id="extensions-pane", classes="modal-pane"):
+            with Horizontal(id="extensions-header"):
+                yield Static("Installed extensions", id="extensions-title")
+                yield Static(f"{total} total", id="extensions-counter")
+                yield ModalCloseButton("Esc  close", id="modal-close")
+            yield Static(
+                "Skills and plugins available from your Symphony configuration",
+                id="extensions-subtitle",
+            )
+            with ModalScroll(id="extensions-body", classes="modal-body"):
+                if not total:
+                    yield EmptyState("No extensions installed", "Add skills or plugins to ~/.symphony.")
+                else:
+                    if self.skills:
+                        yield Static(f"SKILLS  ·  {len(self.skills)}", classes="extensions-section")
+                        for skill in self.skills:
+                            yield from _skill_card(skill)
+                    if self.plugins:
+                        yield Static(f"PLUGINS  ·  {len(self.plugins)}", classes="extensions-section")
+                        for plugin in self.plugins:
+                            yield from _plugin_card(plugin)
+            yield Static("↑↓ scroll   ·   Esc close", classes="modal-footer")

coding_agent/tui/screens/file_selector.py

@@ -0,0 +1,167 @@
+"""Workspace-file suggestions for ``@path`` composer mentions."""
+
+from __future__ import annotations
+
+import os
+import re
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+
+from coding_agent.tools.search import DEFAULT_SKIP_DIRS, is_ignored
+
+_ACTIVE_MENTION = re.compile(r"(?<!\S)@([^\s@]*)$")
+
+
+@dataclass(frozen=True)
+class FileOption:
+    path: str
+    description: str
+
+
+@dataclass(frozen=True)
+class _IndexedFile:
+    path: str
+    name: str
+    size: int
+
+
+class WorkspaceFileIndex:
+    """Walk the workspace once, then filter in memory until invalidated.
+
+    The TUI calls ``rebuild`` from a worker thread and filters the last
+    finished walk with ``cached_matches`` meanwhile, so a large tree never
+    walks on the UI thread. ``matches`` stays synchronous for other callers.
+    """
+
+    def __init__(self, workspace: str | Path) -> None:
+        self.workspace = Path(workspace).resolve()
+        self._entries: tuple[_IndexedFile, ...] | None = None
+        self._fresh = False
+        self._generation = 0
+        self._lock = threading.Lock()
+
+    @property
+    def fresh(self) -> bool:
+        """True when the last walk finished after the last ``invalidate``."""
+        return self._fresh
+
+    def invalidate(self) -> None:
+        """Mark the walk stale. The old entries keep serving until a rebuild lands."""
+        with self._lock:
+            self._generation += 1
+            self._fresh = False
+
+    def rebuild(self) -> bool:
+        """Walk the workspace; safe off the UI thread. False if invalidated meanwhile."""
+        with self._lock:
+            generation = self._generation
+        entries = _scan_workspace(self.workspace)
+        with self._lock:
+            self._entries = entries
+            self._fresh = generation == self._generation
+            return self._fresh
+
+    def matches(self, query: str) -> tuple[FileOption, ...]:
+        if not self._fresh:
+            self.rebuild()
+        return self.cached_matches(query) or ()
+
+    def cached_matches(self, query: str) -> tuple[FileOption, ...] | None:
+        """Rank the last finished walk, or ``None`` before the first one."""
+        entries = self._entries
+        if entries is None:
+            return None
+        return _rank_files(entries, query)
+
+
+def active_file_mention(value: str) -> tuple[int, str] | None:
+    """Return the active mention's start and query when the cursor is at its end."""
+    match = _ACTIVE_MENTION.search(value)
+    if match is None:
+        return None
+    return match.start(), match.group(1)
+
+
+def complete_file_mention(value: str, path: str) -> tuple[str, int]:
+    """Replace the active ``@query`` while preserving the rest of the prompt."""
+    active = active_file_mention(value)
+    if active is None:
+        completed = f"{value}@{path} "
+        return completed, len(completed)
+    start, _query = active
+    completed = f"{value[:start]}@{path} "
+    return completed, len(completed)
+
+
+def file_matches(
+    workspace: Path,
+    query: str,
+    *,
+    index: WorkspaceFileIndex | None = None,
+) -> tuple[FileOption, ...]:
+    """Return gitignore-aware file matches ranked by path relevance."""
+    if index is None or index.workspace != Path(workspace).resolve():
+        index = WorkspaceFileIndex(workspace)
+    return index.matches(query)
+
+
+def _scan_workspace(workspace: Path) -> tuple[_IndexedFile, ...]:
+    entries: list[_IndexedFile] = []
+    for root, dirs, filenames in os.walk(workspace):
+        root_path = Path(root)
+        dirs[:] = [
+            name
+            for name in dirs
+            if name not in DEFAULT_SKIP_DIRS
+            and not name.startswith(".")
+            and not is_ignored(root_path / name, workspace)
+        ]
+        for filename in filenames:
+            path = root_path / filename
+            if filename.startswith(".") or is_ignored(path, workspace):
+                continue
+            try:
+                size = path.stat().st_size
+            except OSError:
+                size = 0
+            entries.append(
+                _IndexedFile(path.relative_to(workspace).as_posix(), filename, size)
+            )
+    return tuple(entries)
+
+
+def _rank_files(entries: tuple[_IndexedFile, ...], query: str) -> tuple[FileOption, ...]:
+    needle = query.strip().lower()
+    ranked: list[tuple[tuple[int, int, int, str], FileOption]] = []
+    for entry in entries:
+        relative_lower = entry.path.lower()
+        name_lower = entry.name.lower()
+        if needle and needle not in relative_lower:
+            continue
+        rank = (
+            0 if name_lower.startswith(needle) else 1,
+            0 if f"/{needle}" in relative_lower else 1,
+            len(entry.path),
+            relative_lower,
+        )
+        ranked.append((rank, FileOption(entry.path, _size_label(entry.size))))
+    ranked.sort(key=lambda item: item[0])
+    return tuple(option for _rank, option in ranked)
+
+
+def _size_label(size: int) -> str:
+    if size < 1024:
+        return f"{size} B"
+    if size < 1024 * 1024:
+        return f"{size / 1024:.1f} KB"
+    return f"{size / (1024 * 1024):.1f} MB"
+
+
+__all__ = [
+    "FileOption",
+    "WorkspaceFileIndex",
+    "active_file_mention",
+    "complete_file_mention",
+    "file_matches",
+]