tunacode-cli 0.1.21__py3-none-any.whl

tunacode/ui/renderers/tools/research.py

@@ -0,0 +1,294 @@
+"""NeXTSTEP-style panel renderer for research_codebase tool output."""
+
+from __future__ import annotations
+
+import ast
+import re
+from dataclasses import dataclass, field
+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
+
+# Symbolic constants for magic values
+DEFAULT_DIRECTORY = "."
+DEFAULT_MAX_FILES = 3
+ELLIPSIS_LENGTH = 3
+MAX_QUERY_DISPLAY_LENGTH = 60
+MAX_DIRECTORIES_DISPLAY = 3
+MIN_LINES_FOR_RECOMMENDATIONS = 2
+MAX_FALLBACK_RESULT_LENGTH = 500
+
+
+@dataclass
+class ResearchData:
+    """Parsed research_codebase result for structured display."""
+
+    query: str
+    directories: list[str]
+    max_files: int
+    relevant_files: list[str] = field(default_factory=list)
+    key_findings: list[str] = field(default_factory=list)
+    code_examples: list[dict[str, str]] = field(default_factory=list)
+    recommendations: list[str] = field(default_factory=list)
+    is_error: bool = False
+    error_message: str | None = None
+
+
+def _parse_dict_result(result: str) -> dict[str, Any] | None:
+    """Parse dict result from string representation."""
+    if not result:
+        return None
+
+    # Try direct ast.literal_eval first
+    try:
+        parsed = ast.literal_eval(result.strip())
+        if isinstance(parsed, dict):
+            return parsed
+    except (ValueError, SyntaxError):
+        pass
+
+    # Try to find dict pattern in the result
+    dict_pattern = re.search(r"\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}", result, re.DOTALL)
+    if dict_pattern:
+        try:
+            parsed = ast.literal_eval(dict_pattern.group())
+            if isinstance(parsed, dict):
+                return parsed
+        except (ValueError, SyntaxError):
+            pass
+
+    return None
+
+
+def parse_result(args: dict[str, Any] | None, result: str) -> ResearchData | None:
+    """Extract structured data from research_codebase output.
+
+    Expected output format (dict):
+        {
+            "relevant_files": ["path1", "path2"],
+            "key_findings": ["finding1", "finding2"],
+            "code_examples": [{"file": "path", "code": "...", "explanation": "..."}],
+            "recommendations": ["rec1", "rec2"]
+        }
+    """
+    args = args or {}
+    query = args.get("query", "")
+    directories = args.get("directories", [DEFAULT_DIRECTORY])
+    max_files = args.get("max_files", DEFAULT_MAX_FILES)
+
+    if isinstance(directories, str):
+        directories = [directories]
+
+    parsed = _parse_dict_result(result)
+    if not parsed:
+        # Could not parse - return error state with raw result as finding
+        return ResearchData(
+            query=query,
+            directories=directories,
+            max_files=max_files,
+            key_findings=[result[:MAX_FALLBACK_RESULT_LENGTH] if result else "No results"],
+            is_error=True,
+            error_message="Could not parse structured result",
+        )
+
+    is_error = parsed.get("error", False)
+    error_message = parsed.get("error_message") if is_error else None
+
+    return ResearchData(
+        query=query,
+        directories=directories,
+        max_files=max_files,
+        relevant_files=parsed.get("relevant_files", []),
+        key_findings=parsed.get("key_findings", []),
+        code_examples=parsed.get("code_examples", []),
+        recommendations=parsed.get("recommendations", []),
+        is_error=is_error,
+        error_message=error_message,
+    )
+
+
+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 - ELLIPSIS_LENGTH] + "..."
+    return line
+
+
+def render_research_codebase(
+    args: dict[str, Any] | None,
+    result: str,
+    duration_ms: float | None = None,
+) -> RenderableType | None:
+    """Render research_codebase with NeXTSTEP zoned layout.
+
+    Zones:
+    - Header: query summary
+    - Selection context: directories, max_files
+    - Primary viewport: files, findings, recommendations
+    - Status: file count, duration
+    """
+    data = parse_result(args, result)
+    if not data:
+        return None
+
+    # Zone 1: Query header
+    header = Text()
+    header.append("Query: ", style="dim")
+    query_too_long = len(data.query) > MAX_QUERY_DISPLAY_LENGTH
+    query_display = data.query[:MAX_QUERY_DISPLAY_LENGTH] + "..." if query_too_long else data.query
+    header.append(f'"{query_display}"', style="bold")
+
+    # Zone 2: Parameters
+    dirs_display = ", ".join(data.directories[:MAX_DIRECTORIES_DISPLAY])
+    if len(data.directories) > MAX_DIRECTORIES_DISPLAY:
+        dirs_display += f" (+{len(data.directories) - MAX_DIRECTORIES_DISPLAY})"
+
+    params = Text()
+    params.append("dirs:", style="dim")
+    params.append(f" {dirs_display}", style="dim bold")
+    params.append("  max_files:", style="dim")
+    params.append(f" {data.max_files}", style="dim bold")
+
+    separator = Text(BOX_HORIZONTAL * SEPARATOR_WIDTH, style="dim")
+
+    # Zone 3: Primary viewport
+    viewport_lines: list[Text] = []
+    lines_used = 0
+    max_viewport_lines = TOOL_VIEWPORT_LINES
+
+    # Error state
+    if data.is_error:
+        error_text = Text()
+        error_text.append("Error: ", style="bold red")
+        error_text.append(data.error_message or "Unknown error", style="red")
+        viewport_lines.append(error_text)
+        lines_used += 1
+
+    # Relevant files section
+    if data.relevant_files and lines_used < max_viewport_lines:
+        files_header = Text()
+        files_header.append("Relevant Files", style="bold")
+        files_header.append(f" ({len(data.relevant_files)})", style="dim")
+        viewport_lines.append(files_header)
+        lines_used += 1
+
+        for filepath in data.relevant_files:
+            if lines_used >= max_viewport_lines:
+                break
+            file_line = Text()
+            file_line.append("  - ", style="dim")
+            file_line.append(_truncate_line(filepath), style="cyan")
+            viewport_lines.append(file_line)
+            lines_used += 1
+
+        viewport_lines.append(Text(""))
+        lines_used += 1
+
+    # Key findings section
+    if data.key_findings and lines_used < max_viewport_lines:
+        findings_header = Text()
+        findings_header.append("Key Findings", style="bold")
+        viewport_lines.append(findings_header)
+        lines_used += 1
+
+        for i, finding in enumerate(data.key_findings, 1):
+            if lines_used >= max_viewport_lines:
+                remaining = len(data.key_findings) - i + 1
+                viewport_lines.append(Text(f"  (+{remaining} more)", style="dim italic"))
+                lines_used += 1
+                break
+            finding_line = Text()
+            finding_line.append(f"  {i}. ", style="dim")
+            # Wrap long findings
+            finding_text = _truncate_line(finding)
+            finding_line.append(finding_text)
+            viewport_lines.append(finding_line)
+            lines_used += 1
+
+        viewport_lines.append(Text(""))
+        lines_used += 1
+
+    # Recommendations section (if space)
+    if data.recommendations and lines_used < max_viewport_lines - MIN_LINES_FOR_RECOMMENDATIONS:
+        rec_header = Text()
+        rec_header.append("Recommendations", style="bold")
+        viewport_lines.append(rec_header)
+        lines_used += 1
+
+        for rec in data.recommendations:
+            if lines_used >= max_viewport_lines:
+                break
+            rec_line = Text()
+            rec_line.append("  > ", style="dim")
+            rec_line.append(_truncate_line(rec), style="italic")
+            viewport_lines.append(rec_line)
+            lines_used += 1
+
+    # Pad viewport to minimum height for visual consistency
+    while lines_used < MIN_VIEWPORT_LINES:
+        viewport_lines.append(Text(""))
+        lines_used += 1
+
+    # Combine viewport
+    viewport = Text("\n").join(viewport_lines) if viewport_lines else Text("(no findings)")
+
+    # Zone 4: Status footer
+    status_items: list[str] = []
+    status_items.append(f"files: {len(data.relevant_files)}")
+    status_items.append(f"findings: {len(data.key_findings)}")
+    if duration_ms is not None:
+        status_items.append(f"{duration_ms:.0f}ms")
+
+    status = Text("  ".join(status_items), style="dim")
+
+    # Compose all zones
+    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 error styling if error occurred
+    if data.is_error:
+        border_color = UI_COLORS["error"]
+        title_color = UI_COLORS["error"]
+        status_suffix = "error"
+    else:
+        border_color = UI_COLORS["accent"]
+        title_color = UI_COLORS["accent"]
+        status_suffix = "done"
+
+    return Panel(
+        content,
+        title=f"[{title_color}]research_codebase[/] [{status_suffix}]",
+        subtitle=f"[{UI_COLORS['muted']}]{timestamp}[/]",
+        border_style=Style(color=border_color),
+        padding=(0, 1),
+        expand=True,
+        width=TOOL_PANEL_WIDTH,
+    )

tunacode/ui/renderers/tools/update_file.py

@@ -0,0 +1,237 @@
+"""NeXTSTEP-style panel renderer for update_file tool output."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from rich.console import Group, RenderableType
+from rich.panel import Panel
+from rich.style import Style
+from rich.syntax import Syntax
+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
+LINE_TRUNCATION_SUFFIX: str = "..."
+
+
+@dataclass
+class UpdateFileData:
+    """Parsed update_file result for structured display."""
+
+    filepath: str
+    filename: str
+    message: str
+    diff_content: str
+    additions: int
+    deletions: int
+    hunks: int
+    diagnostics_block: str | None = None
+
+
+def parse_result(args: dict[str, Any] | None, result: str) -> UpdateFileData | None:
+    """Extract structured data from update_file output.
+
+    Expected format:
+        File 'path/to/file.py' updated successfully.
+
+        --- a/path/to/file.py
+        +++ b/path/to/file.py
+        @@ -10,5 +10,7 @@
+        ...diff content...
+
+        <file_diagnostics>
+        Error (line 10): type mismatch
+        </file_diagnostics>
+    """
+    if not result:
+        return None
+
+    # Extract diagnostics block before parsing diff
+    from tunacode.ui.renderers.tools.diagnostics import extract_diagnostics_from_result
+
+    result_clean, diagnostics_block = extract_diagnostics_from_result(result)
+
+    # Split message from diff
+    if "\n--- a/" not in result_clean:
+        return None
+
+    parts = result_clean.split("\n--- a/", 1)
+    message = parts[0].strip()
+    diff_content = "--- a/" + parts[1]
+
+    # Extract filepath from diff header
+    filepath_match = re.search(r"--- a/(.+)", diff_content)
+    if not filepath_match:
+        # Try from args
+        args = args or {}
+        filepath = args.get("filepath", "unknown")
+    else:
+        filepath = filepath_match.group(1).strip()
+
+    # Count additions and deletions
+    additions = 0
+    deletions = 0
+    hunks = 0
+
+    for line in diff_content.splitlines():
+        if line.startswith("+") and not line.startswith("+++"):
+            additions += 1
+        elif line.startswith("-") and not line.startswith("---"):
+            deletions += 1
+        elif line.startswith("@@"):
+            hunks += 1
+
+    return UpdateFileData(
+        filepath=filepath,
+        filename=Path(filepath).name,
+        message=message,
+        diff_content=diff_content,
+        additions=additions,
+        deletions=deletions,
+        hunks=hunks,
+        diagnostics_block=diagnostics_block,
+    )
+
+
+def _truncate_line_width(line: str, max_line_width: int) -> str:
+    if len(line) <= max_line_width:
+        return line
+    line_prefix = line[:max_line_width]
+    return f"{line_prefix}{LINE_TRUNCATION_SUFFIX}"
+
+
+def _truncate_diff(diff: str) -> tuple[str, int, int]:
+    """Truncate diff content, return (truncated, shown, total)."""
+    lines = diff.splitlines()
+    total = len(lines)
+    max_content = TOOL_VIEWPORT_LINES
+    max_line_width = MAX_PANEL_LINE_WIDTH
+
+    capped_lines = [_truncate_line_width(line, max_line_width) for line in lines[:max_content]]
+
+    if total <= max_content:
+        return "\n".join(capped_lines), total, total
+    return "\n".join(capped_lines), max_content, total
+
+
+def render_update_file(
+    args: dict[str, Any] | None,
+    result: str,
+    duration_ms: float | None = None,
+) -> RenderableType | None:
+    """Render update_file with NeXTSTEP zoned layout.
+
+    Zones:
+    - Header: filename + change summary
+    - Selection context: full filepath
+    - Primary viewport: syntax-highlighted diff
+    - Status: hunks, truncation info, duration
+    """
+    data = parse_result(args, result)
+    if not data:
+        return None
+
+    # Zone 1: Filename + change stats
+    header = Text()
+    header.append(data.filename, style="bold")
+    header.append("   ", style="")
+    header.append(f"+{data.additions}", style="green")
+    header.append(" ", style="")
+    header.append(f"-{data.deletions}", style="red")
+
+    # Zone 2: Full filepath
+    params = Text()
+    params.append("path:", style="dim")
+    params.append(f" {data.filepath}", style="dim bold")
+
+    separator = Text(BOX_HORIZONTAL * SEPARATOR_WIDTH, style="dim")
+
+    # Zone 3: Diff viewport with syntax highlighting
+    truncated_diff, shown, total = _truncate_diff(data.diff_content)
+
+    # Pad viewport to minimum height for visual consistency
+    diff_lines = truncated_diff.split("\n")
+    while len(diff_lines) < MIN_VIEWPORT_LINES:
+        diff_lines.append("")
+    truncated_diff = "\n".join(diff_lines)
+
+    diff_syntax = Syntax(truncated_diff, "diff", theme="monokai", word_wrap=True)
+
+    # Zone 4: Status
+    status_items: list[str] = []
+
+    hunk_word = "hunk" if data.hunks == 1 else "hunks"
+    status_items.append(f"{data.hunks} {hunk_word}")
+
+    if shown < total:
+        status_items.append(f"[{shown}/{total} 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("")
+
+    # Zone 5: Diagnostics (if present)
+    diagnostics_content: RenderableType | None = None
+    if data.diagnostics_block:
+        from tunacode.ui.renderers.tools.diagnostics import (
+            parse_diagnostics_block,
+            render_diagnostics_inline,
+        )
+
+        diag_data = parse_diagnostics_block(data.diagnostics_block)
+        if diag_data and diag_data.items:
+            diagnostics_content = render_diagnostics_inline(diag_data)
+
+    # Compose
+    content_parts: list[RenderableType] = [
+        header,
+        Text("\n"),
+        params,
+        Text("\n"),
+        separator,
+        Text("\n"),
+        diff_syntax,
+        Text("\n"),
+        separator,
+        Text("\n"),
+        status,
+    ]
+
+    # Add diagnostics zone if present
+    if diagnostics_content:
+        content_parts.extend(
+            [
+                Text("\n"),
+                separator,
+                Text("\n"),
+                diagnostics_content,
+            ]
+        )
+
+    content = Group(*content_parts)
+
+    timestamp = datetime.now().strftime("%H:%M:%S")
+
+    return Panel(
+        content,
+        title=f"[{UI_COLORS['success']}]update_file[/] [done]",
+        subtitle=f"[{UI_COLORS['muted']}]{timestamp}[/]",
+        border_style=Style(color=UI_COLORS["success"]),
+        padding=(0, 1),
+        expand=True,
+        width=TOOL_PANEL_WIDTH,
+    )

tunacode/ui/renderers/tools/web_fetch.py

@@ -0,0 +1,182 @@
+"""NeXTSTEP-style panel renderer for web_fetch tool output."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+from urllib.parse import urlparse
+
+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,
+    URL_DISPLAY_MAX_LENGTH,
+)
+
+BOX_HORIZONTAL = "\u2500"
+SEPARATOR_WIDTH = 52
+
+
+@dataclass
+class WebFetchData:
+    """Parsed web_fetch result for structured display."""
+
+    url: str
+    domain: str
+    content: str
+    content_lines: int
+    is_truncated: bool
+    timeout: int
+
+
+def parse_result(args: dict[str, Any] | None, result: str) -> WebFetchData | None:
+    """Extract structured data from web_fetch output.
+
+    The result is simply the text content from the fetched page.
+    """
+    if not result:
+        return None
+
+    args = args or {}
+    url = args.get("url", "")
+    timeout = args.get("timeout", 60)
+
+    # Extract domain from URL
+    domain = ""
+    if url:
+        try:
+            parsed = urlparse(url)
+            domain = parsed.netloc or parsed.hostname or ""
+        except Exception:
+            domain = url[:30]
+
+    # Check for truncation
+    is_truncated = "[Content truncated due to size]" in result
+
+    content_lines = len(result.splitlines())
+
+    return WebFetchData(
+        url=url,
+        domain=domain,
+        content=result,
+        content_lines=content_lines,
+        is_truncated=is_truncated,
+        timeout=timeout,
+    )
+
+
+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_content(content: str) -> tuple[str, int, int]:
+    """Truncate content, return (truncated, shown, total)."""
+    lines = content.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_web_fetch(
+    args: dict[str, Any] | None,
+    result: str,
+    duration_ms: float | None = None,
+) -> RenderableType | None:
+    """Render web_fetch with NeXTSTEP zoned layout.
+
+    Zones:
+    - Header: domain + content summary
+    - Selection context: full URL, timeout
+    - Primary viewport: content preview
+    - Status: truncation info, duration
+    """
+    data = parse_result(args, result)
+    if not data:
+        return None
+
+    # Zone 1: Domain + content summary
+    header = Text()
+    header.append(data.domain or "web", style="bold")
+    header.append(f"   {data.content_lines} lines", style="dim")
+
+    # Zone 2: Full URL + parameters
+    params = Text()
+    url_display = data.url
+    if len(url_display) > URL_DISPLAY_MAX_LENGTH:
+        url_display = url_display[: URL_DISPLAY_MAX_LENGTH - 3] + "..."
+    params.append("url:", style="dim")
+    params.append(f" {url_display}", style="dim bold")
+    params.append("\n", style="")
+    params.append("timeout:", style="dim")
+    params.append(f" {data.timeout}s", style="dim bold")
+
+    separator = Text(BOX_HORIZONTAL * SEPARATOR_WIDTH, style="dim")
+
+    # Zone 3: Content viewport
+    truncated_content, shown, total = _truncate_content(data.content)
+
+    # Pad viewport to minimum height for visual consistency
+    content_lines = truncated_content.split("\n")
+    while len(content_lines) < MIN_VIEWPORT_LINES:
+        content_lines.append("")
+    truncated_content = "\n".join(content_lines)
+
+    viewport = Text(truncated_content)
+
+    # Zone 4: Status
+    status_items: list[str] = []
+
+    if data.is_truncated:
+        status_items.append("(content truncated)")
+
+    if shown < total:
+        status_items.append(f"[{shown}/{total} 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")
+
+    return Panel(
+        content,
+        title=f"[{UI_COLORS['success']}]web_fetch[/] [done]",
+        subtitle=f"[{UI_COLORS['muted']}]{timestamp}[/]",
+        border_style=Style(color=UI_COLORS["success"]),
+        padding=(0, 1),
+        expand=True,
+        width=TOOL_PANEL_WIDTH,
+    )