tunacode-cli 0.1.21__py3-none-any.whl

tunacode/ui/renderers/search.py

@@ -0,0 +1,314 @@
+"""Search Result Display for Textual TUI."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, TypeVar
+
+from rich.console import RenderableType
+from rich.panel import Panel
+from rich.style import Style
+from rich.text import Text
+
+from tunacode.constants import TOOL_PANEL_WIDTH, UI_COLORS
+from tunacode.ui.renderers.panels import RichPanelRenderer, SearchResultData
+
+T = TypeVar("T")
+
+
+def _paginate(items: list[T], page: int, page_size: int) -> tuple[list[T], int, int]:
+    start_idx = (page - 1) * page_size
+    end_idx = start_idx + page_size
+    total_pages = (len(items) + page_size - 1) // page_size if items else 1
+    return items[start_idx:end_idx], start_idx, total_pages
+
+
+@dataclass
+class FileSearchResult:
+    file_path: str
+    line_number: int | None = None
+    content: str = ""
+    match_start: int | None = None
+    match_end: int | None = None
+    relevance: float | None = None
+
+
+@dataclass
+class CodeSearchResult:
+    file_path: str
+    symbol_name: str
+    symbol_type: str
+    line_number: int
+    context: str = ""
+    relevance: float | None = None
+
+
+class SearchDisplayRenderer:
+    @staticmethod
+    def render_file_results(
+        query: str,
+        results: list[FileSearchResult],
+        page: int = 1,
+        page_size: int = 10,
+        search_time_ms: float | None = None,
+    ) -> RenderableType:
+        generic_results = []
+        for r in results:
+            result_dict: dict[str, Any] = {
+                "file": r.file_path,
+                "content": r.content,
+            }
+            if r.line_number is not None:
+                result_dict["title"] = f"{r.file_path}:{r.line_number}"
+            else:
+                result_dict["title"] = r.file_path
+
+            if r.relevance is not None:
+                result_dict["relevance"] = r.relevance
+
+            if r.match_start is not None and r.match_end is not None:
+                before = r.content[: r.match_start]
+                match = r.content[r.match_start : r.match_end]
+                after = r.content[r.match_end :]
+                result_dict["snippet"] = f"{before}[{match}]{after}"
+            else:
+                result_dict["snippet"] = r.content
+
+            generic_results.append(result_dict)
+
+        page_results, _, _ = _paginate(generic_results, page, page_size)
+
+        data = SearchResultData(
+            query=query,
+            results=page_results,
+            total_count=len(results),
+            current_page=page,
+            page_size=page_size,
+            search_time_ms=search_time_ms,
+        )
+
+        return RichPanelRenderer.render_search_results(data)
+
+    @staticmethod
+    def render_code_results(
+        query: str,
+        results: list[CodeSearchResult],
+        page: int = 1,
+        page_size: int = 10,
+        search_time_ms: float | None = None,
+    ) -> RenderableType:
+        generic_results = []
+        for r in results:
+            type_icons = {
+                "function": "fn",
+                "class": "cls",
+                "variable": "var",
+                "method": "mtd",
+                "constant": "const",
+            }
+            type_label = type_icons.get(r.symbol_type, r.symbol_type[:3])
+
+            result_dict: dict[str, Any] = {
+                "title": f"[{type_label}] {r.symbol_name}",
+                "file": f"{r.file_path}:{r.line_number}",
+                "snippet": r.context,
+            }
+            if r.relevance is not None:
+                result_dict["relevance"] = r.relevance
+
+            generic_results.append(result_dict)
+
+        page_results, _, _ = _paginate(generic_results, page, page_size)
+
+        data = SearchResultData(
+            query=query,
+            results=page_results,
+            total_count=len(results),
+            current_page=page,
+            page_size=page_size,
+            search_time_ms=search_time_ms,
+        )
+
+        return RichPanelRenderer.render_search_results(data)
+
+    @staticmethod
+    def render_inline_results(
+        results: list[dict[str, Any]],
+        max_display: int = 5,
+    ) -> RenderableType:
+        if not results:
+            return Text("No results found", style="dim")
+
+        content = Text()
+        display_results = results[:max_display]
+
+        for i, result in enumerate(display_results):
+            title = result.get("title", result.get("file", "..."))
+            content.append(f"{i + 1}. ", style="dim")
+            content.append(str(title), style=UI_COLORS["primary"])
+            content.append("\n")
+
+        if len(results) > max_display:
+            remaining = len(results) - max_display
+            content.append(f"   ...and {remaining} more", style="dim")
+
+        return content
+
+    @staticmethod
+    def render_empty_results(query: str) -> RenderableType:
+        content = Text()
+        content.append("No results found for: ", style="dim")
+        content.append(query, style="bold")
+        content.append("\n\nSuggestions:\n", style="dim")
+        content.append("  - Try a different search term\n", style="dim")
+        content.append("  - Use broader patterns\n", style="dim")
+        content.append("  - Check file paths and extensions", style="dim")
+
+        return Panel(
+            content,
+            title=f"[{UI_COLORS['warning']}]No Results[/]",
+            border_style=Style(color=UI_COLORS["warning"]),
+            padding=(0, 1),
+            expand=True,
+            width=TOOL_PANEL_WIDTH,
+        )
+
+    @staticmethod
+    def parse_grep_output(text: str, query: str | None = None) -> SearchResultData | None:
+        if not text or "Found" not in text:
+            return None
+
+        header_match = re.match(r"Found (\d+) match(?:es)? for pattern: (.+)", text)
+        if not header_match:
+            return None
+
+        total_count = int(header_match.group(1))
+        detected_query = header_match.group(2).strip()
+        final_query = query or detected_query
+
+        results: list[dict[str, Any]] = []
+        file_pattern = re.compile(r"📁 (.+?):(\d+)")
+        match_pattern = re.compile(r"▶\s*(\d+)│\s*(.*?)⟨(.+?)⟩(.*)")
+
+        current_file: str | None = None
+
+        for line in text.split("\n"):
+            file_match = file_pattern.search(line)
+            if file_match:
+                current_file = file_match.group(1)
+                continue
+
+            match_line = match_pattern.search(line)
+            if match_line and current_file:
+                line_num = int(match_line.group(1))
+                before = match_line.group(2)
+                match_text = match_line.group(3)
+                after = match_line.group(4)
+
+                results.append(
+                    {
+                        "title": f"{current_file}:{line_num}",
+                        "file": current_file,
+                        "snippet": f"{before}[{match_text}]{after}",
+                        "line_number": line_num,
+                    }
+                )
+
+        if not results:
+            return None
+
+        return SearchResultData(
+            query=final_query,
+            results=results,
+            total_count=total_count,
+            current_page=1,
+            page_size=len(results),
+        )
+
+    @staticmethod
+    def parse_glob_output(text: str, pattern: str | None = None) -> SearchResultData | None:
+        if not text:
+            return None
+
+        # Extract source marker if present
+        source: str | None = None
+        lines = text.split("\n")
+        if lines and lines[0].startswith("[source:"):
+            marker = lines[0]
+            source = marker[8:-1]  # Extract between "[source:" and "]"
+            text = "\n".join(lines[1:])  # Remove marker from text
+
+        if "Found" not in text:
+            return None
+
+        header_match = re.match(r"Found (\d+) files? matching pattern: (.+)", text)
+        if not header_match:
+            return None
+
+        total_count = int(header_match.group(1))
+        detected_pattern = header_match.group(2).strip()
+        final_pattern = pattern or detected_pattern
+
+        results: list[dict[str, Any]] = []
+
+        # Parse file paths - supports both plain paths and formatted output
+        for line in text.split("\n"):
+            line = line.strip()
+            # Skip header line, empty lines, and truncation notice
+            if not line or line.startswith("Found ") or line.startswith("(truncated"):
+                continue
+
+            # Handle plain file paths (new format)
+            if line.startswith("/") or line.startswith("./") or "/" in line:
+                path = Path(line)
+                results.append(
+                    {
+                        "title": line,
+                        "file": line,
+                        "snippet": path.name,
+                    }
+                )
+
+        if not results:
+            return None
+
+        return SearchResultData(
+            query=final_pattern,
+            results=results,
+            total_count=total_count,
+            current_page=1,
+            page_size=len(results),
+            source=source,
+        )
+
+
+def file_search_panel(
+    query: str,
+    results: list[FileSearchResult],
+    page: int = 1,
+    search_time_ms: float | None = None,
+) -> RenderableType:
+    if not results:
+        return SearchDisplayRenderer.render_empty_results(query)
+    return SearchDisplayRenderer.render_file_results(
+        query, results, page, search_time_ms=search_time_ms
+    )
+
+
+def code_search_panel(
+    query: str,
+    results: list[CodeSearchResult],
+    page: int = 1,
+    search_time_ms: float | None = None,
+) -> RenderableType:
+    if not results:
+        return SearchDisplayRenderer.render_empty_results(query)
+    return SearchDisplayRenderer.render_code_results(
+        query, results, page, search_time_ms=search_time_ms
+    )
+
+
+def quick_results(results: list[dict[str, Any]], max_display: int = 5) -> RenderableType:
+    return SearchDisplayRenderer.render_inline_results(results, max_display)

tunacode/ui/renderers/tools/__init__.py

@@ -0,0 +1,21 @@
+"""Tool-specific panel renderers following NeXTSTEP UI principles."""
+
+from tunacode.ui.renderers.tools.bash import render_bash
+from tunacode.ui.renderers.tools.glob import render_glob
+from tunacode.ui.renderers.tools.grep import render_grep
+from tunacode.ui.renderers.tools.list_dir import render_list_dir
+from tunacode.ui.renderers.tools.read_file import render_read_file
+from tunacode.ui.renderers.tools.research import render_research_codebase
+from tunacode.ui.renderers.tools.update_file import render_update_file
+from tunacode.ui.renderers.tools.web_fetch import render_web_fetch
+
+__all__ = [
+    "render_bash",
+    "render_glob",
+    "render_grep",
+    "render_list_dir",
+    "render_read_file",
+    "render_research_codebase",
+    "render_update_file",
+    "render_web_fetch",
+]

tunacode/ui/renderers/tools/bash.py

@@ -0,0 +1,247 @@
+"""NeXTSTEP-style panel renderer for bash tool output."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from rich.console import Group, RenderableType
+from rich.panel import Panel
+from rich.style import Style
+from rich.text import Text
+
+from tunacode.constants import (
+    MAX_PANEL_LINE_WIDTH,
+    MIN_VIEWPORT_LINES,
+    TOOL_PANEL_WIDTH,
+    TOOL_VIEWPORT_LINES,
+    UI_COLORS,
+)
+
+BOX_HORIZONTAL = "\u2500"
+SEPARATOR_WIDTH = 52
+
+
+@dataclass
+class BashData:
+    """Parsed bash result for structured display."""
+
+    command: str
+    exit_code: int
+    working_dir: str
+    stdout: str
+    stderr: str
+    is_truncated: bool
+
+
+def parse_result(args: dict[str, Any] | None, result: str) -> BashData | None:
+    """Extract structured data from bash output.
+
+    Expected format:
+        Command: <command>
+        Exit Code: <code>
+        Working Directory: <path>
+
+        STDOUT:
+        <output>
+
+        STDERR:
+        <errors>
+    """
+    if not result:
+        return None
+
+    # Parse structured output
+    command_match = re.search(r"Command: (.+)", result)
+    exit_match = re.search(r"Exit Code: (\d+)", result)
+    cwd_match = re.search(r"Working Directory: (.+)", result)
+
+    if not command_match or not exit_match:
+        return None
+
+    command = command_match.group(1).strip()
+    exit_code = int(exit_match.group(1))
+    working_dir = cwd_match.group(1).strip() if cwd_match else "."
+
+    # Extract stdout and stderr
+    stdout = ""
+    stderr = ""
+
+    stdout_match = re.search(r"STDOUT:\n(.*?)(?=\n\nSTDERR:|\Z)", result, re.DOTALL)
+    if stdout_match:
+        stdout = stdout_match.group(1).strip()
+        if stdout == "(no output)":
+            stdout = ""
+
+    stderr_match = re.search(r"STDERR:\n(.*?)(?:\Z)", result, re.DOTALL)
+    if stderr_match:
+        stderr = stderr_match.group(1).strip()
+        if stderr == "(no errors)":
+            stderr = ""
+
+    # Check for truncation marker
+    is_truncated = "[truncated]" in result
+
+    return BashData(
+        command=command,
+        exit_code=exit_code,
+        working_dir=working_dir,
+        stdout=stdout,
+        stderr=stderr,
+        is_truncated=is_truncated,
+    )
+
+
+def _truncate_line(line: str) -> str:
+    """Truncate a single line if too wide."""
+    if len(line) > MAX_PANEL_LINE_WIDTH:
+        return line[: MAX_PANEL_LINE_WIDTH - 3] + "..."
+    return line
+
+
+def _truncate_output(output: str) -> tuple[str, int, int]:
+    """Truncate output, return (truncated, shown, total)."""
+    lines = output.splitlines()
+    total = len(lines)
+
+    max_lines = TOOL_VIEWPORT_LINES
+
+    if total <= max_lines:
+        return "\n".join(_truncate_line(ln) for ln in lines), total, total
+
+    truncated = [_truncate_line(ln) for ln in lines[:max_lines]]
+    return "\n".join(truncated), max_lines, total
+
+
+def render_bash(
+    args: dict[str, Any] | None,
+    result: str,
+    duration_ms: float | None = None,
+) -> RenderableType | None:
+    """Render bash with NeXTSTEP zoned layout.
+
+    Zones:
+    - Header: command + exit code indicator
+    - Selection context: working directory, timeout
+    - Primary viewport: stdout/stderr output
+    - Status: truncation info, duration
+    """
+    data = parse_result(args, result)
+    if not data:
+        return None
+
+    # Zone 1: Command + exit status
+    header = Text()
+
+    # Truncate command for header
+    cmd_display = data.command
+    if len(cmd_display) > 50:
+        cmd_display = cmd_display[:47] + "..."
+    header.append(f"$ {cmd_display}", style="bold")
+
+    # Exit code indicator
+    if data.exit_code == 0:
+        header.append("   ", style="")
+        header.append("ok", style="green bold")
+    else:
+        header.append("   ", style="")
+        header.append(f"exit {data.exit_code}", style="red bold")
+
+    # Zone 2: Parameters
+    args = args or {}
+    timeout = args.get("timeout", 30)
+    params = Text()
+    params.append("cwd:", style="dim")
+    params.append(f" {data.working_dir}", style="dim bold")
+    params.append("  timeout:", style="dim")
+    params.append(f" {timeout}s", style="dim bold")
+
+    separator = Text(BOX_HORIZONTAL * SEPARATOR_WIDTH, style="dim")
+
+    # Zone 3: Output viewport
+    viewport_parts: list[Text] = []
+
+    if data.stdout:
+        truncated_stdout, shown_stdout, total_stdout = _truncate_output(data.stdout)
+        stdout_text = Text()
+        stdout_text.append("stdout:\n", style="dim")
+        stdout_text.append(truncated_stdout)
+        viewport_parts.append(stdout_text)
+
+    if data.stderr:
+        if viewport_parts:
+            viewport_parts.append(Text("\n"))
+        truncated_stderr, shown_stderr, total_stderr = _truncate_output(data.stderr)
+        stderr_text = Text()
+        stderr_text.append("stderr:\n", style="dim")
+        stderr_text.append(truncated_stderr, style="red")
+        viewport_parts.append(stderr_text)
+
+    if not viewport_parts:
+        viewport_parts.append(Text("(no output)", style="dim"))
+
+    # Pad viewport to minimum height for visual consistency
+    viewport_line_count = sum(
+        1 + str(part).count("\n") for part in viewport_parts if isinstance(part, Text)
+    )
+    while viewport_line_count < MIN_VIEWPORT_LINES:
+        viewport_parts.append(Text(""))
+        viewport_line_count += 1
+
+    viewport = Group(*viewport_parts)
+
+    # Zone 4: Status
+    status_items: list[str] = []
+
+    if data.is_truncated:
+        status_items.append("(truncated)")
+
+    if data.stdout:
+        stdout_lines = len(data.stdout.splitlines())
+        status_items.append(f"stdout: {stdout_lines} lines")
+
+    if data.stderr:
+        stderr_lines = len(data.stderr.splitlines())
+        status_items.append(f"stderr: {stderr_lines} lines")
+
+    if duration_ms is not None:
+        status_items.append(f"{duration_ms:.0f}ms")
+
+    status = Text("  ".join(status_items), style="dim") if status_items else Text("")
+
+    # Compose
+    content = Group(
+        header,
+        Text("\n"),
+        params,
+        Text("\n"),
+        separator,
+        Text("\n"),
+        viewport,
+        Text("\n"),
+        separator,
+        Text("\n"),
+        status,
+    )
+
+    timestamp = datetime.now().strftime("%H:%M:%S")
+
+    # Use different colors based on exit code
+    if data.exit_code == 0:
+        border_color = UI_COLORS["success"]
+        status_text = "done"
+    else:
+        border_color = UI_COLORS["warning"]
+        status_text = f"exit {data.exit_code}"
+
+    return Panel(
+        content,
+        title=f"[{border_color}]bash[/] [{status_text}]",
+        subtitle=f"[{UI_COLORS['muted']}]{timestamp}[/]",
+        border_style=Style(color=border_color),
+        padding=(0, 1),
+        expand=True,
+        width=TOOL_PANEL_WIDTH,
+    )