tunacode-cli 0.1.21__py3-none-any.whl

tunacode/ui/renderers/tools/diagnostics.py

@@ -0,0 +1,186 @@
+"""NeXTSTEP-style renderer for LSP diagnostics."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from rich.console import Group, RenderableType
+from rich.text import Text
+
+from tunacode.constants import UI_COLORS
+from tunacode.lsp.diagnostics import truncate_diagnostic_message
+
+MAX_DIAGNOSTICS_DISPLAY = 10
+
+BOX_HORIZONTAL = "\u2500"
+SEPARATOR_WIDTH = 52
+
+
+@dataclass
+class DiagnosticItem:
+    """A single diagnostic for display."""
+
+    severity: str  # "error", "warning", "info", "hint"
+    line: int
+    message: str
+
+
+@dataclass
+class DiagnosticsData:
+    """Parsed diagnostics for structured display."""
+
+    items: list[DiagnosticItem]
+    error_count: int
+    warning_count: int
+    info_count: int
+
+
+def parse_diagnostics_block(content: str) -> DiagnosticsData | None:
+    """Extract diagnostics from <file_diagnostics> XML block.
+
+    Expected format:
+        <file_diagnostics>
+        Error (line 10): message text
+        Warning (line 15): another message
+        </file_diagnostics>
+    """
+    if not content:
+        return None
+
+    # Extract content between tags
+    match = re.search(r"<file_diagnostics>(.*?)</file_diagnostics>", content, re.DOTALL)
+    if not match:
+        return None
+
+    block_content = match.group(1).strip()
+    if not block_content:
+        return None
+
+    items: list[DiagnosticItem] = []
+    error_count = 0
+    warning_count = 0
+    info_count = 0
+
+    # Parse each diagnostic line
+    # Format: "Error (line 10): message" or "Warning (line 15): message"
+    pattern = re.compile(r"^(Error|Warning|Info|Hint)\s+\(line\s+(\d+)\):\s*(.+)$", re.IGNORECASE)
+
+    for line in block_content.splitlines():
+        line = line.strip()
+        if not line or line.startswith("Summary:"):
+            continue
+
+        match = pattern.match(line)
+        if match:
+            severity = match.group(1).lower()
+            line_num = int(match.group(2))
+            message = match.group(3)
+
+            items.append(
+                DiagnosticItem(
+                    severity=severity,
+                    line=line_num,
+                    message=message,
+                )
+            )
+
+            if severity == "error":
+                error_count += 1
+            elif severity == "warning":
+                warning_count += 1
+            else:
+                info_count += 1
+
+    if not items:
+        return None
+
+    return DiagnosticsData(
+        items=items,
+        error_count=error_count,
+        warning_count=warning_count,
+        info_count=info_count,
+    )
+
+
+def render_diagnostics_inline(data: DiagnosticsData) -> RenderableType:
+    """Render diagnostics as inline zone within update_file panel.
+
+    NeXTSTEP 4-Zone Layout:
+    +----------------------------------+
+    | HEADER: 2 errors, 1 warning      |  <- color-coded counts
+    +----------------------------------+
+    | VIEWPORT:                        |
+    |   L170: Type mismatch...         |  <- red
+    |   L336: Argument type...         |  <- red
+    |   L42:  Unused import            |  <- yellow
+    +----------------------------------+
+    """
+    content_parts: list[RenderableType] = []
+
+    # Zone 1: Header - counts with color coding
+    header = Text()
+    header.append("LSP Diagnostics", style="bold")
+    header.append("  ", style="")
+
+    if data.error_count > 0:
+        error_suffix = "s" if data.error_count > 1 else ""
+        header.append(f"{data.error_count} error{error_suffix}", style=UI_COLORS["error"])
+        if data.warning_count > 0 or data.info_count > 0:
+            header.append(", ", style="")
+
+    if data.warning_count > 0:
+        warning_suffix = "s" if data.warning_count > 1 else ""
+        header.append(f"{data.warning_count} warning{warning_suffix}", style=UI_COLORS["warning"])
+        if data.info_count > 0:
+            header.append(", ", style="")
+
+    if data.info_count > 0:
+        header.append(f"{data.info_count} info", style=UI_COLORS["muted"])
+
+    content_parts.append(header)
+    content_parts.append(Text("\n"))
+
+    separator = Text(BOX_HORIZONTAL * SEPARATOR_WIDTH, style="dim")
+    content_parts.append(separator)
+    content_parts.append(Text("\n"))
+
+    # Zone 2: Viewport - diagnostic list
+    for idx, item in enumerate(data.items):
+        if idx >= MAX_DIAGNOSTICS_DISPLAY:
+            remaining = len(data.items) - idx
+            content_parts.append(Text(f"  +{remaining} more...", style="dim italic"))
+            content_parts.append(Text("\n"))
+            break
+
+        # Severity color
+        severity_style = UI_COLORS["error"] if item.severity == "error" else UI_COLORS["warning"]
+        if item.severity in ("info", "hint"):
+            severity_style = UI_COLORS["muted"]
+
+        line_text = Text()
+        line_text.append(f"  L{item.line:<4}", style="dim")
+        line_text.append(truncate_diagnostic_message(item.message), style=severity_style)
+        content_parts.append(line_text)
+        content_parts.append(Text("\n"))
+
+    return Group(*content_parts)
+
+
+def extract_diagnostics_from_result(result: str) -> tuple[str, str | None]:
+    """Extract and remove diagnostics block from tool result.
+
+    Returns:
+        Tuple of (result_without_diagnostics, diagnostics_block_or_none)
+    """
+    if "<file_diagnostics>" not in result:
+        return result, None
+
+    match = re.search(r"<file_diagnostics>.*?</file_diagnostics>", result, re.DOTALL)
+    if not match:
+        return result, None
+
+    diagnostics_block = match.group(0)
+    result_without = result.replace(diagnostics_block, "").strip()
+
+    return result_without, diagnostics_block

tunacode/ui/renderers/tools/glob.py

@@ -0,0 +1,226 @@
+"""NeXTSTEP-style panel renderer for glob 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.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 GlobData:
+    """Parsed glob result for structured display."""
+
+    pattern: str
+    file_count: int
+    files: list[str]
+    source: str  # "index" or "filesystem"
+    is_truncated: bool
+    recursive: bool
+    include_hidden: bool
+    sort_by: str
+
+
+def parse_result(args: dict[str, Any] | None, result: str) -> GlobData | None:
+    """Extract structured data from glob output.
+
+    Expected format:
+        [source:index]
+        Found N file(s) matching pattern: <pattern>
+
+        /path/to/file1.py
+        /path/to/file2.py
+        (truncated at N)
+    """
+    if not result:
+        return None
+
+    lines = result.strip().splitlines()
+    if not lines:
+        return None
+
+    # Extract source marker
+    source = "filesystem"
+    start_idx = 0
+    if lines[0].startswith("[source:"):
+        marker = lines[0]
+        source = marker[8:-1]  # Extract between "[source:" and "]"
+        start_idx = 1
+
+    # Parse header
+    if start_idx >= len(lines):
+        return None
+
+    header_line = lines[start_idx]
+    header_match = re.match(r"Found (\d+) files? matching pattern: (.+)", header_line)
+    if not header_match:
+        # Check for "No files found" case
+        if "No files found" in header_line:
+            return None
+        return None
+
+    file_count = int(header_match.group(1))
+    pattern = header_match.group(2).strip()
+
+    # Parse file list
+    files: list[str] = []
+    is_truncated = False
+
+    for line in lines[start_idx + 1 :]:
+        line = line.strip()
+        if not line:
+            continue
+        if line.startswith("(truncated"):
+            is_truncated = True
+            continue
+        # File paths
+        if line.startswith("/") or line.startswith("./") or "/" in line:
+            files.append(line)
+
+    args = args or {}
+    return GlobData(
+        pattern=pattern,
+        file_count=file_count,
+        files=files,
+        source=source,
+        is_truncated=is_truncated,
+        recursive=args.get("recursive", True),
+        include_hidden=args.get("include_hidden", False),
+        sort_by=args.get("sort_by", "modified"),
+    )
+
+
+def _truncate_path(path: str) -> str:
+    """Truncate a path if too wide, keeping filename visible."""
+    if len(path) <= MAX_PANEL_LINE_WIDTH:
+        return path
+
+    p = Path(path)
+    filename = p.name
+    max_dir_len = MAX_PANEL_LINE_WIDTH - len(filename) - 4  # ".../"
+
+    if max_dir_len <= 0:
+        return "..." + filename[-(MAX_PANEL_LINE_WIDTH - 3) :]
+
+    dir_part = str(p.parent)
+    if len(dir_part) > max_dir_len:
+        dir_part = "..." + dir_part[-(max_dir_len - 3) :]
+
+    return f"{dir_part}/{filename}"
+
+
+def render_glob(
+    args: dict[str, Any] | None,
+    result: str,
+    duration_ms: float | None = None,
+) -> RenderableType | None:
+    """Render glob with NeXTSTEP zoned layout.
+
+    Zones:
+    - Header: pattern + file count
+    - Selection context: recursive, hidden, sort parameters
+    - Primary viewport: file list
+    - Status: source (indexed/scanned), truncation, duration
+    """
+    data = parse_result(args, result)
+    if not data:
+        return None
+
+    # Zone 1: Pattern + counts
+    header = Text()
+    header.append(f'"{data.pattern}"', style="bold")
+    file_word = "file" if data.file_count == 1 else "files"
+    header.append(f"   {data.file_count} {file_word}", style="dim")
+
+    # Zone 2: Parameters
+    recursive_val = "on" if data.recursive else "off"
+    hidden_val = "on" if data.include_hidden else "off"
+    params = Text()
+    params.append("recursive:", style="dim")
+    params.append(f" {recursive_val}", style="dim bold")
+    params.append("  hidden:", style="dim")
+    params.append(f" {hidden_val}", style="dim bold")
+    params.append("  sort:", style="dim")
+    params.append(f" {data.sort_by}", style="dim bold")
+
+    separator = Text(BOX_HORIZONTAL * SEPARATOR_WIDTH, style="dim")
+
+    # Zone 3: File list viewport
+    viewport_lines: list[str] = []
+    max_display = TOOL_VIEWPORT_LINES
+
+    for i, filepath in enumerate(data.files):
+        if i >= max_display:
+            break
+        viewport_lines.append(_truncate_path(filepath))
+
+    # Pad viewport to minimum height for visual consistency
+    while len(viewport_lines) < MIN_VIEWPORT_LINES:
+        viewport_lines.append("")
+
+    viewport = Text("\n".join(viewport_lines)) if viewport_lines else Text("(no files)")
+
+    # Zone 4: Status
+    status_items: list[str] = []
+
+    # Source indicator (cache hit/miss)
+    if data.source == "index":
+        status_items.append("indexed")
+    else:
+        status_items.append("scanned")
+
+    if data.is_truncated or len(data.files) < data.file_count:
+        shown = min(len(data.files), max_display)
+        status_items.append(f"[{shown}/{data.file_count} shown]")
+
+    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")
+
+    border_color = UI_COLORS["success"]
+
+    return Panel(
+        content,
+        title=f"[{UI_COLORS['success']}]glob[/] [done]",
+        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/grep.py

@@ -0,0 +1,228 @@
+"""NeXTSTEP-style panel renderer for grep 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 GrepData:
+    """Parsed grep result for structured display."""
+
+    pattern: str
+    total_matches: int
+    strategy: str
+    candidates: int
+    matches: list[dict[str, Any]]
+    is_truncated: bool
+    case_sensitive: bool
+    use_regex: bool
+    context_lines: int
+
+
+def parse_result(args: dict[str, Any] | None, result: str) -> GrepData | None:
+    """Extract structured data from grep output.
+
+    Expected format:
+        Found N matches for pattern: <pattern>
+        Strategy: <strategy> | Candidates: <N> files | ...
+        <matches>
+    """
+    if not result or "Found" not in result:
+        return None
+
+    lines = result.strip().splitlines()
+    if len(lines) < 2:
+        return None
+
+    # Parse header: "Found N match(es) for pattern: <pattern>"
+    header_match = re.match(r"Found (\d+) match(?:es)? for pattern: (.+)", lines[0])
+    if not header_match:
+        return None
+
+    total_matches = int(header_match.group(1))
+    pattern = header_match.group(2).strip()
+
+    # Parse strategy line
+    strategy = "smart"
+    candidates = 0
+    if len(lines) > 1 and lines[1].startswith("Strategy:"):
+        strat_match = re.match(r"Strategy: (\w+) \| Candidates: (\d+)", lines[1])
+        if strat_match:
+            strategy = strat_match.group(1)
+            candidates = int(strat_match.group(2))
+
+    # Parse matches
+    matches: list[dict[str, Any]] = []
+    current_file: str | None = None
+    file_pattern = re.compile(r"\U0001f4c1 (.+?):(\d+)")
+    match_pattern = re.compile(r"\u25b6\s*(\d+)\u2502\s*(.*?)\u27e8(.+?)\u27e9(.*)")
+
+    for line in lines:
+        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)
+
+            matches.append(
+                {
+                    "file": current_file,
+                    "line": line_num,
+                    "before": before,
+                    "match": match_text,
+                    "after": after,
+                }
+            )
+
+    if not matches and total_matches == 0:
+        return None
+
+    args = args or {}
+    return GrepData(
+        pattern=pattern,
+        total_matches=total_matches,
+        strategy=strategy,
+        candidates=candidates,
+        matches=matches,
+        is_truncated=len(matches) < total_matches,
+        case_sensitive=args.get("case_sensitive", False),
+        use_regex=args.get("use_regex", False),
+        context_lines=args.get("context_lines", 2),
+    )
+
+
+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 render_grep(
+    args: dict[str, Any] | None,
+    result: str,
+    duration_ms: float | None = None,
+) -> RenderableType | None:
+    """Render grep with NeXTSTEP zoned layout.
+
+    Zones:
+    - Header: pattern + match count
+    - Selection context: strategy, case, regex parameters
+    - Primary viewport: grouped matches by file
+    - Status: truncation info, duration
+    """
+    data = parse_result(args, result)
+    if not data:
+        return None
+
+    # Zone 1: Pattern + counts
+    header = Text()
+    header.append(f'"{data.pattern}"', style="bold")
+    match_word = "match" if data.total_matches == 1 else "matches"
+    header.append(f"   {data.total_matches} {match_word}", style="dim")
+
+    # Zone 2: Parameters
+    case_val = "yes" if data.case_sensitive else "no"
+    regex_val = "yes" if data.use_regex else "no"
+    params = Text()
+    params.append("strategy:", style="dim")
+    params.append(f" {data.strategy}", style="dim bold")
+    params.append("  case:", style="dim")
+    params.append(f" {case_val}", style="dim bold")
+    params.append("  regex:", style="dim")
+    params.append(f" {regex_val}", style="dim bold")
+    params.append("  context:", style="dim")
+    params.append(f" {data.context_lines}", style="dim bold")
+
+    separator = Text(BOX_HORIZONTAL * SEPARATOR_WIDTH, style="dim")
+
+    # Zone 3: Matches viewport grouped by file
+    viewport_lines: list[str] = []
+    current_file: str | None = None
+    shown_matches = 0
+
+    for match in data.matches:
+        if shown_matches >= TOOL_VIEWPORT_LINES:
+            break
+
+        if match["file"] != current_file:
+            if current_file is not None:
+                viewport_lines.append("")
+                shown_matches += 1
+            current_file = match["file"]
+            viewport_lines.append(f"  {current_file}")
+            shown_matches += 1
+
+        line_content = f"    {match['line']:>4}| {match['before']}{match['match']}{match['after']}"
+        viewport_lines.append(_truncate_line(line_content))
+        shown_matches += 1
+
+    # Pad viewport to minimum height for visual consistency
+    while len(viewport_lines) < MIN_VIEWPORT_LINES:
+        viewport_lines.append("")
+
+    viewport = Text("\n".join(viewport_lines)) if viewport_lines else Text("(no matches)")
+
+    # Zone 4: Status
+    status_items: list[str] = []
+    if data.is_truncated:
+        status_items.append(f"[{len(data.matches)}/{data.total_matches} shown]")
+    if data.candidates > 0:
+        status_items.append(f"{data.candidates} files searched")
+    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']}]grep[/] [done]",
+        subtitle=f"[{UI_COLORS['muted']}]{timestamp}[/]",
+        border_style=Style(color=UI_COLORS["success"]),
+        padding=(0, 1),
+        expand=True,
+        width=TOOL_PANEL_WIDTH,
+    )