code-puppy 0.0.214__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/tools/display.py

@@ -0,0 +1,84 @@
+"""Common display utilities for rendering agent outputs.
+
+This module provides non-streaming display functions for rendering
+agent results and other structured content using termflow for markdown.
+"""
+
+from typing import Optional
+
+from rich.console import Console
+
+from code_puppy.config import get_banner_color, get_subagent_verbose
+from code_puppy.tools.subagent_context import is_subagent
+
+
+def display_non_streamed_result(
+    content: str,
+    console: Optional[Console] = None,
+    banner_text: str = "AGENT RESPONSE",
+    banner_name: str = "agent_response",
+) -> None:
+    """Display a non-streamed result with markdown rendering via termflow.
+
+    This function renders markdown content using termflow for beautiful
+    terminal output. Use this instead of streaming for sub-agent responses
+    or any other content that arrives all at once.
+
+    Args:
+        content: The content to display (can include markdown).
+        console: Rich Console to use for output. If None, creates a new one.
+        banner_text: Text to display in the banner (default: "AGENT RESPONSE").
+        banner_name: Banner config key for color lookup (default: "agent_response").
+
+    Example:
+        >>> display_non_streamed_result("# Hello\n\nThis is **bold** text.")
+        # Renders with AGENT RESPONSE banner and formatted markdown
+    """
+    # Skip display for sub-agents unless verbose mode
+    if is_subagent() and not get_subagent_verbose():
+        return
+
+    import time
+
+    from rich.text import Text
+    from termflow import Parser as TermflowParser
+    from termflow import Renderer as TermflowRenderer
+
+    from code_puppy.messaging.spinner import pause_all_spinners, resume_all_spinners
+
+    if console is None:
+        console = Console()
+
+    # Pause spinners and give time to clear
+    pause_all_spinners()
+    time.sleep(0.1)
+
+    # Clear line and print banner
+    console.print(" " * 50, end="\r")
+    console.print()  # Newline before banner
+
+    banner_color = get_banner_color(banner_name)
+    console.print(
+        Text.from_markup(
+            f"[bold white on {banner_color}] {banner_text} [/bold white on {banner_color}]"
+        )
+    )
+
+    # Use termflow for markdown rendering
+    parser = TermflowParser()
+    renderer = TermflowRenderer(output=console.file, width=console.width)
+
+    # Process content line by line
+    for line in content.split("\n"):
+        events = parser.parse_line(line)
+        renderer.render_all(events)
+
+    # Finalize to close any open markdown blocks
+    final_events = parser.finalize()
+    renderer.render_all(final_events)
+
+    # Resume spinners
+    resume_all_spinners()
+
+
+__all__ = ["display_non_streamed_result"]

code_puppy/tools/file_modifications.py

@@ -20,10 +20,58 @@ import json_repair
 from pydantic import BaseModel
 from pydantic_ai import RunContext
 
-from code_puppy.messaging import emit_error, emit_info, emit_warning
+from code_puppy.callbacks import on_delete_file, on_edit_file
+from code_puppy.messaging import (  # Structured messaging types
+    DiffLine,
+    DiffMessage,
+    emit_error,
+    emit_warning,
+    get_message_bus,
+)
 from code_puppy.tools.common import _find_best_window, generate_group_id
 
 
+def _create_rejection_response(file_path: str) -> Dict[str, Any]:
+    """Create a standardized rejection response with user feedback if available.
+
+    Args:
+        file_path: Path to the file that was rejected
+
+    Returns:
+        Dict containing rejection details and any user feedback
+    """
+    # Check for user feedback from permission handler
+    try:
+        from code_puppy.plugins.file_permission_handler.register_callbacks import (
+            clear_user_feedback,
+            get_last_user_feedback,
+        )
+
+        user_feedback = get_last_user_feedback()
+        # Clear feedback after reading it
+        clear_user_feedback()
+    except ImportError:
+        user_feedback = None
+
+    rejection_message = (
+        "USER REJECTED: The user explicitly rejected these file changes."
+    )
+    if user_feedback:
+        rejection_message += f" User feedback: {user_feedback}"
+    else:
+        rejection_message += " Please do not retry the same changes or any other changes - immediately ask for clarification."
+
+    return {
+        "success": False,
+        "path": file_path,
+        "message": rejection_message,
+        "changed": False,
+        "user_rejection": True,
+        "rejection_type": "explicit_user_denial",
+        "user_feedback": user_feedback,
+    }
+
+
 class DeleteSnippetPayload(BaseModel):
     file_path: str
     delete_snippet: str
@@ -48,57 +96,110 @@ class ContentPayload(BaseModel):
 EditFilePayload = Union[DeleteSnippetPayload, ReplacementsPayload, ContentPayload]
 
 
-def _print_diff(diff_text: str, message_group: str = None) -> None:
-    """Pretty-print *diff_text* with colour-coding (always runs)."""
+def _parse_diff_lines(diff_text: str) -> List[DiffLine]:
+    """Parse unified diff text into structured DiffLine objects.
 
-    emit_info(
-        "[bold cyan]\n── DIFF ────────────────────────────────────────────────[/bold cyan]",
-        message_group=message_group,
-    )
-    if diff_text and diff_text.strip():
-        for line in diff_text.splitlines():
-            # Git-style diff coloring using markup strings for TUI compatibility
-            if line.startswith("+") and not line.startswith("+++"):
-                # Addition line - use markup string instead of Rich Text
-                emit_info(
-                    f"[bold green]{line}[/bold green]",
-                    highlight=False,
-                    message_group=message_group,
-                )
-            elif line.startswith("-") and not line.startswith("---"):
-                # Removal line - use markup string instead of Rich Text
-                emit_info(
-                    f"[bold red]{line}[/bold red]",
-                    highlight=False,
-                    message_group=message_group,
-                )
-            elif line.startswith("@@"):
-                # Hunk info - use markup string instead of Rich Text
-                emit_info(
-                    f"[bold cyan]{line}[/bold cyan]",
-                    highlight=False,
-                    message_group=message_group,
-                )
-            elif line.startswith("+++") or line.startswith("---"):
-                # Filename lines in diff - use markup string instead of Rich Text
-                emit_info(
-                    f"[dim white]{line}[/dim white]",
-                    highlight=False,
-                    message_group=message_group,
-                )
-            else:
-                # Context lines - no special formatting
-                emit_info(line, highlight=False, message_group=message_group)
-    else:
-        emit_info("[dim]-- no diff available --[/dim]", message_group=message_group)
-    emit_info(
-        "[bold cyan]───────────────────────────────────────────────────────[/bold cyan]",
-        message_group=message_group,
+    Args:
+        diff_text: Raw unified diff text
+
+    Returns:
+        List of DiffLine objects with line numbers and types
+    """
+    if not diff_text or not diff_text.strip():
+        return []
+
+    diff_lines = []
+    line_number = 0
+
+    for line in diff_text.splitlines():
+        # Determine line type based on diff markers
+        if line.startswith("+") and not line.startswith("+++"):
+            line_type = "add"
+            line_number += 1
+            content = line[1:]  # Remove the + prefix
+        elif line.startswith("-") and not line.startswith("---"):
+            line_type = "remove"
+            line_number += 1
+            content = line[1:]  # Remove the - prefix
+        elif line.startswith("@@"):
+            # Parse hunk header to get line number
+            # Format: @@ -start,count +start,count @@
+            import re
+
+            match = re.search(r"@@ -\d+(?:,\d+)? \+(\d+)", line)
+            if match:
+                line_number = (
+                    int(match.group(1)) - 1
+                )  # Will be incremented on next line
+            line_type = "context"
+            content = line
+        elif line.startswith("---") or line.startswith("+++"):
+            # File headers - treat as context
+            line_type = "context"
+            content = line
+        else:
+            line_type = "context"
+            line_number += 1
+            content = line
+
+        diff_lines.append(
+            DiffLine(
+                line_number=max(1, line_number),
+                type=line_type,
+                content=content,
+            )
+        )
+
+    return diff_lines
+
+
+def _emit_diff_message(
+    file_path: str,
+    operation: str,
+    diff_text: str,
+    old_content: str | None = None,
+    new_content: str | None = None,
+) -> None:
+    """Emit a structured DiffMessage for UI display.
+
+    Args:
+        file_path: Path to the file being modified
+        operation: One of 'create', 'modify', 'delete'
+        diff_text: Raw unified diff text
+        old_content: Original file content (optional)
+        new_content: New file content (optional)
+    """
+    # Check if diff was already shown during permission prompt
+    try:
+        from code_puppy.plugins.file_permission_handler.register_callbacks import (
+            clear_diff_shown_flag,
+            was_diff_already_shown,
+        )
+
+        if was_diff_already_shown():
+            # Diff already displayed in permission panel, skip redundant display
+            clear_diff_shown_flag()
+            return
+    except ImportError:
+        pass  # Permission handler not available, emit anyway
+
+    if not diff_text or not diff_text.strip():
+        return
+
+    diff_lines = _parse_diff_lines(diff_text)
+
+    diff_msg = DiffMessage(
+        path=file_path,
+        operation=operation,
+        old_content=old_content,
+        new_content=new_content,
+        diff_lines=diff_lines,
     )
+    get_message_bus().emit(diff_msg)
 
 
 def _log_error(
-    msg: str, exc: Exception | None = None, message_group: str = None
+    msg: str, exc: Exception | None = None, message_group: str | None = None
 ) -> None:
     emit_error(f"{msg}", message_group=message_group)
     if exc is not None:
@@ -106,28 +207,40 @@ def _log_error(
 
 
 def _delete_snippet_from_file(
-    context: RunContext | None, file_path: str, snippet: str, message_group: str = None
+    context: RunContext | None,
+    file_path: str,
+    snippet: str,
+    message_group: str | None = None,
 ) -> Dict[str, Any]:
     file_path = os.path.abspath(file_path)
     diff_text = ""
     try:
         if not os.path.exists(file_path) or not os.path.isfile(file_path):
             return {"error": f"File '{file_path}' does not exist.", "diff": diff_text}
-        with open(file_path, "r", encoding="utf-8") as f:
+        with open(file_path, "r", encoding="utf-8", errors="surrogateescape") as f:
             original = f.read()
+        # Sanitize any surrogate characters from reading
+        try:
+            original = original.encode("utf-8", errors="surrogatepass").decode(
+                "utf-8", errors="replace"
+            )
+        except (UnicodeEncodeError, UnicodeDecodeError):
+            pass
         if snippet not in original:
             return {
                 "error": f"Snippet not found in file '{file_path}'.",
                 "diff": diff_text,
             }
         modified = original.replace(snippet, "")
+        from code_puppy.config import get_diff_context_lines
+
         diff_text = "".join(
             difflib.unified_diff(
                 original.splitlines(keepends=True),
                 modified.splitlines(keepends=True),
                 fromfile=f"a/{os.path.basename(file_path)}",
                 tofile=f"b/{os.path.basename(file_path)}",
-                n=3,
+                n=get_diff_context_lines(),
             )
         )
         with open(file_path, "w", encoding="utf-8") as f:
@@ -147,14 +260,22 @@ def _replace_in_file(
     context: RunContext | None,
     path: str,
     replacements: List[Dict[str, str]],
-    message_group: str = None,
+    message_group: str | None = None,
 ) -> Dict[str, Any]:
     """Robust replacement engine with explicit edge‑case reporting."""
     file_path = os.path.abspath(path)
 
-    with open(file_path, "r", encoding="utf-8") as f:
+    with open(file_path, "r", encoding="utf-8", errors="surrogateescape") as f:
         original = f.read()
 
+    # Sanitize any surrogate characters from reading
+    try:
+        original = original.encode("utf-8", errors="surrogatepass").decode(
+            "utf-8", errors="replace"
+        )
+    except (UnicodeEncodeError, UnicodeDecodeError):
+        pass
+
     modified = original
     for rep in replacements:
         old_snippet = rep.get("old_str", "")
@@ -197,13 +318,15 @@ def _replace_in_file(
             "diff": "",
         }
 
+    from code_puppy.config import get_diff_context_lines
+
     diff_text = "".join(
         difflib.unified_diff(
             original.splitlines(keepends=True),
             modified.splitlines(keepends=True),
             fromfile=f"a/{os.path.basename(file_path)}",
             tofile=f"b/{os.path.basename(file_path)}",
-            n=3,
+            n=get_diff_context_lines(),
         )
     )
     with open(file_path, "w", encoding="utf-8") as f:
@@ -222,7 +345,7 @@ def _write_to_file(
     path: str,
     content: str,
     overwrite: bool = False,
-    message_group: str = None,
+    message_group: str | None = None,
 ) -> Dict[str, Any]:
     file_path = os.path.abspath(path)
 
@@ -237,12 +360,14 @@ def _write_to_file(
                 "diff": "",
             }
 
+        from code_puppy.config import get_diff_context_lines
+
         diff_lines = difflib.unified_diff(
             [] if not exists else [""],
             content.splitlines(keepends=True),
             fromfile="/dev/null" if not exists else f"a/{os.path.basename(file_path)}",
             tofile=f"b/{os.path.basename(file_path)}",
-            n=3,
+            n=get_diff_context_lines(),
         )
         diff_text = "".join(diff_lines)
 
@@ -265,18 +390,28 @@ def _write_to_file(
 
 
 def delete_snippet_from_file(
-    context: RunContext, file_path: str, snippet: str, message_group: str = None
+    context: RunContext, file_path: str, snippet: str, message_group: str | None = None
 ) -> Dict[str, Any]:
-    emit_info(
-        f"🗑️ Deleting snippet from file [bold red]{file_path}[/bold red]",
-        message_group=message_group,
+    # Use the plugin system for permission handling with operation data
+    from code_puppy.callbacks import on_file_permission
+
+    operation_data = {"snippet": snippet}
+    permission_results = on_file_permission(
+        context, file_path, "delete snippet from", None, message_group, operation_data
     )
+
+    # If any permission handler denies the operation, return cancelled result
+    if permission_results and any(
+        not result for result in permission_results if result is not None
+    ):
+        return _create_rejection_response(file_path)
+
     res = _delete_snippet_from_file(
         context, file_path, snippet, message_group=message_group
     )
     diff = res.get("diff", "")
     if diff:
-        _print_diff(diff, message_group=message_group)
+        _emit_diff_message(file_path, "modify", diff)
     return res
 
 
@@ -285,17 +420,30 @@ def write_to_file(
     path: str,
     content: str,
     overwrite: bool,
-    message_group: str = None,
+    message_group: str | None = None,
 ) -> Dict[str, Any]:
-    emit_info(
-        f"✏️ Writing file [bold blue]{path}[/bold blue]", message_group=message_group
+    # Use the plugin system for permission handling with operation data
+    from code_puppy.callbacks import on_file_permission
+
+    operation_data = {"content": content, "overwrite": overwrite}
+    permission_results = on_file_permission(
+        context, path, "write", None, message_group, operation_data
     )
+
+    # If any permission handler denies the operation, return cancelled result
+    if permission_results and any(
+        not result for result in permission_results if result is not None
+    ):
+        return _create_rejection_response(path)
+
     res = _write_to_file(
         context, path, content, overwrite=overwrite, message_group=message_group
     )
     diff = res.get("diff", "")
     if diff:
-        _print_diff(diff, message_group=message_group)
+        # Determine operation type based on whether file existed
+        operation = "modify" if overwrite else "create"
+        _emit_diff_message(path, operation, diff, new_content=content)
     return res
 
 
@@ -303,21 +451,31 @@ def replace_in_file(
     context: RunContext,
     path: str,
     replacements: List[Dict[str, str]],
-    message_group: str = None,
+    message_group: str | None = None,
 ) -> Dict[str, Any]:
-    emit_info(
-        f"♻️ Replacing text in [bold yellow]{path}[/bold yellow]",
-        message_group=message_group,
+    # Use the plugin system for permission handling with operation data
+    from code_puppy.callbacks import on_file_permission
+
+    operation_data = {"replacements": replacements}
+    permission_results = on_file_permission(
+        context, path, "replace text in", None, message_group, operation_data
     )
+
+    # If any permission handler denies the operation, return cancelled result
+    if permission_results and any(
+        not result for result in permission_results if result is not None
+    ):
+        return _create_rejection_response(path)
+
     res = _replace_in_file(context, path, replacements, message_group=message_group)
     diff = res.get("diff", "")
     if diff:
-        _print_diff(diff, message_group=message_group)
+        _emit_diff_message(path, "modify", diff)
     return res
 
 
 def _edit_file(
-    context: RunContext, payload: EditFilePayload, group_id: str = None
+    context: RunContext, payload: EditFilePayload, group_id: str | None = None
 ) -> Dict[str, Any]:
     """
     High-level implementation of the *edit_file* behaviour.
@@ -356,9 +514,6 @@ def _edit_file(
     if group_id is None:
         group_id = generate_group_id("edit_file", file_path)
 
-    emit_info(
-        "\n[bold white on blue] EDIT FILE [/bold white on blue]", message_group=group_id
-    )
     try:
         if isinstance(payload, DeleteSnippetPayload):
             return delete_snippet_from_file(
@@ -411,25 +566,46 @@ def _edit_file(
 
 
 def _delete_file(
-    context: RunContext, file_path: str, message_group: str = None
+    context: RunContext, file_path: str, message_group: str | None = None
 ) -> Dict[str, Any]:
-    emit_info(
-        f"🗑️ Deleting file [bold red]{file_path}[/bold red]", message_group=message_group
-    )
     file_path = os.path.abspath(file_path)
+
+    # Use the plugin system for permission handling with operation data
+    from code_puppy.callbacks import on_file_permission
+
+    operation_data = {}  # No additional data needed for delete operations
+    permission_results = on_file_permission(
+        context, file_path, "delete", None, message_group, operation_data
+    )
+
+    # If any permission handler denies the operation, return cancelled result
+    if permission_results and any(
+        not result for result in permission_results if result is not None
+    ):
+        return _create_rejection_response(file_path)
+
     try:
         if not os.path.exists(file_path) or not os.path.isfile(file_path):
             res = {"error": f"File '{file_path}' does not exist.", "diff": ""}
         else:
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(file_path, "r", encoding="utf-8", errors="surrogateescape") as f:
                 original = f.read()
+            # Sanitize any surrogate characters from reading
+            try:
+                original = original.encode("utf-8", errors="surrogatepass").decode(
+                    "utf-8", errors="replace"
+                )
+            except (UnicodeEncodeError, UnicodeDecodeError):
+                pass
+            from code_puppy.config import get_diff_context_lines
+
             diff_text = "".join(
                 difflib.unified_diff(
                     original.splitlines(keepends=True),
                     [],
                     fromfile=f"a/{os.path.basename(file_path)}",
                     tofile=f"b/{os.path.basename(file_path)}",
-                    n=3,
+                    n=get_diff_context_lines(),
                 )
             )
             os.remove(file_path)
@@ -443,7 +619,10 @@ def _delete_file(
     except Exception as exc:
         _log_error("Unhandled exception in delete_file", exc)
         res = {"error": str(exc), "diff": ""}
-    _print_diff(res.get("diff", ""), message_group=message_group)
+
+    diff = res.get("diff", "")
+    if diff:
+        _emit_diff_message(file_path, "delete", diff)
     return res
 
 
@@ -546,17 +725,17 @@ def register_edit_file(agent):
         if isinstance(payload, str):
             try:
                 # Fallback for weird models that just can't help but send json strings...
-                payload = json.loads(json_repair.repair_json(payload))
-                if "replacements" in payload:
-                    payload = ReplacementsPayload(**payload)
-                elif "delete_snippet" in payload:
-                    payload = DeleteSnippetPayload(**payload)
-                elif "content" in payload:
-                    payload = ContentPayload(**payload)
+                payload_dict = json.loads(json_repair.repair_json(payload))
+                if "replacements" in payload_dict:
+                    payload = ReplacementsPayload(**payload_dict)
+                elif "delete_snippet" in payload_dict:
+                    payload = DeleteSnippetPayload(**payload_dict)
+                elif "content" in payload_dict:
+                    payload = ContentPayload(**payload_dict)
                 else:
                     file_path = "Unknown"
-                    if "file_path" in payload:
-                        file_path = payload["file_path"]
+                    if "file_path" in payload_dict:
+                        file_path = payload_dict["file_path"]
                     return {
                         "success": False,
                         "path": file_path,
@@ -575,6 +754,16 @@ def register_edit_file(agent):
         result = _edit_file(context, payload)
         if "diff" in result:
             del result["diff"]
+
+        # Trigger edit_file callbacks to enhance the result with rejection details
+        enhanced_results = on_edit_file(context, result, payload)
+        if enhanced_results:
+            # Use the first non-None enhanced result
+            for enhanced_result in enhanced_results:
+                if enhanced_result is not None:
+                    result = enhanced_result
+                    break
+
         return result
 
 
@@ -624,4 +813,14 @@ def register_delete_file(agent):
         result = _delete_file(context, file_path, message_group=group_id)
         if "diff" in result:
             del result["diff"]
+
+        # Trigger delete_file callbacks to enhance the result with rejection details
+        enhanced_results = on_delete_file(context, result, file_path)
+        if enhanced_results:
+            # Use the first non-None enhanced result
+            for enhanced_result in enhanced_results:
+                if enhanced_result is not None:
+                    result = enhanced_result
+                    break
+
         return result