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

code_puppy/tools/common.py

@@ -1,16 +1,44 @@
+import asyncio
 import fnmatch
+import functools
 import hashlib
+import logging
 import os
+import sys
 import time
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Any, Callable, Optional, Tuple
 
+from prompt_toolkit import Application
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
 from rapidfuzz.distance import JaroWinkler
 from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.text import Text
+
+# Syntax highlighting imports for "syntax" diff mode
+try:
+    from pygments import lex
+    from pygments.lexers import TextLexer, get_lexer_by_name
+    from pygments.token import Token
+
+    PYGMENTS_AVAILABLE = True
+except ImportError:
+    PYGMENTS_AVAILABLE = False
 
 # Import our queue-based console system
 try:
-    from code_puppy.messaging import get_queue_console
+    from code_puppy.messaging import (
+        emit_error,
+        emit_info,
+        emit_success,
+        emit_warning,
+        get_queue_console,
+    )
 
     # Use queue console by default, but allow fallback
     NO_COLOR = bool(int(os.environ.get("CODE_PUPPY_NO_COLOR", "0")))
@@ -23,11 +51,59 @@ except ImportError:
     NO_COLOR = bool(int(os.environ.get("CODE_PUPPY_NO_COLOR", "0")))
     console = Console(no_color=NO_COLOR)
 
+    # Provide fallback emit functions
+    def emit_error(msg: str) -> None:
+        console.print(f"[bold red]{msg}[/bold red]")
+
+    def emit_info(msg: str) -> None:
+        console.print(msg)
+
+    def emit_success(msg: str) -> None:
+        console.print(f"[bold green]{msg}[/bold green]")
+
+    def emit_warning(msg: str) -> None:
+        console.print(f"[bold yellow]{msg}[/bold yellow]")
+
+
+def should_suppress_browser() -> bool:
+    """Check if browsers should be suppressed (headless mode).
+
+    Returns:
+        True if browsers should be suppressed, False if they can open normally
+
+    This respects multiple headless mode controls:
+    - HEADLESS=true environment variable (suppresses ALL browsers)
+    - BROWSER_HEADLESS=true environment variable (for browser automation)
+    - CI=true environment variable (continuous integration)
+    - PYTEST_CURRENT_TEST environment variable (running under pytest)
+    """
+    # Explicit headless mode
+    if os.getenv("HEADLESS", "").lower() == "true":
+        return True
+
+    # Browser-specific headless mode
+    if os.getenv("BROWSER_HEADLESS", "").lower() == "true":
+        return True
+
+    # Continuous integration environments
+    if os.getenv("CI", "").lower() == "true":
+        return True
+
+    # Running under pytest
+    if "PYTEST_CURRENT_TEST" in os.environ:
+        return True
+
+    # Default to allowing browsers
+    return False
+
 
 # -------------------
 # Shared ignore patterns/helpers
+# Split into directory vs file patterns so tools can choose appropriately
+# - list_files should ignore only directories (still show binary files inside non-ignored dirs)
+# - grep should ignore both directories and files (avoid grepping binaries)
 # -------------------
-IGNORE_PATTERNS = [
+DIR_IGNORE_PATTERNS = [
     # Version control
     "**/.git/**",
     "**/.git",
@@ -304,6 +380,10 @@ IGNORE_PATTERNS = [
     "**/*.save",
     # Hidden files (but be careful with this one)
     "**/.*",  # Commented out as it might be too aggressive
+    # Directory-only section ends here
+]
+
+FILE_IGNORE_PATTERNS = [
     # Binary image formats
     "**/*.png",
     "**/*.jpg",
@@ -354,6 +434,9 @@ IGNORE_PATTERNS = [
     "**/*.sqlite3",
 ]
 
+# Backwards compatibility for any imports still referring to IGNORE_PATTERNS
+IGNORE_PATTERNS = DIR_IGNORE_PATTERNS + FILE_IGNORE_PATTERNS
+
 
 def should_ignore_path(path: str) -> bool:
     """Return True if *path* matches any pattern in IGNORE_PATTERNS."""
@@ -389,6 +472,890 @@ def should_ignore_path(path: str) -> bool:
     return False
 
 
+def should_ignore_dir_path(path: str) -> bool:
+    """Return True if path matches any directory ignore pattern (directories only)."""
+    path_obj = Path(path)
+    for pattern in DIR_IGNORE_PATTERNS:
+        try:
+            if path_obj.match(pattern):
+                return True
+        except ValueError:
+            if fnmatch.fnmatch(path, pattern):
+                return True
+        if "**" in pattern:
+            simplified = pattern.replace("**/", "").replace("/**", "")
+            parts = path_obj.parts
+            for i in range(len(parts)):
+                subpath = Path(*parts[i:])
+                if fnmatch.fnmatch(str(subpath), simplified):
+                    return True
+                if fnmatch.fnmatch(parts[i], simplified):
+                    return True
+    return False
+
+
+# ============================================================================
+# SYNTAX HIGHLIGHTING FOR DIFFS ("syntax" mode)
+# ============================================================================
+
+# Monokai color scheme - because we have taste 🎨
+TOKEN_COLORS = (
+    {
+        Token.Keyword: "#f92672" if PYGMENTS_AVAILABLE else "magenta",
+        Token.Name.Builtin: "#66d9ef" if PYGMENTS_AVAILABLE else "cyan",
+        Token.Name.Function: "#a6e22e" if PYGMENTS_AVAILABLE else "green",
+        Token.String: "#e6db74" if PYGMENTS_AVAILABLE else "yellow",
+        Token.Number: "#ae81ff" if PYGMENTS_AVAILABLE else "magenta",
+        Token.Comment: "#75715e" if PYGMENTS_AVAILABLE else "bright_black",
+        Token.Operator: "#f92672" if PYGMENTS_AVAILABLE else "magenta",
+    }
+    if PYGMENTS_AVAILABLE
+    else {}
+)
+
+EXTENSION_TO_LEXER_NAME = {
+    ".py": "python",
+    ".js": "javascript",
+    ".jsx": "jsx",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".java": "java",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".hpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".cs": "csharp",
+    ".rs": "rust",
+    ".go": "go",
+    ".rb": "ruby",
+    ".php": "php",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".md": "markdown",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".sql": "sql",
+    ".txt": "text",
+}
+
+
+def _get_lexer_for_extension(extension: str):
+    """Get the appropriate Pygments lexer for a file extension.
+
+    Args:
+        extension: File extension (with or without leading dot)
+
+    Returns:
+        A Pygments lexer instance or None if Pygments not available
+    """
+    if not PYGMENTS_AVAILABLE:
+        return None
+
+    # Normalize extension to have leading dot and be lowercase
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    extension = extension.lower()
+
+    lexer_name = EXTENSION_TO_LEXER_NAME.get(extension, "text")
+
+    try:
+        return get_lexer_by_name(lexer_name)
+    except Exception:
+        # Fallback to plain text if lexer not found
+        return TextLexer()
+
+
+def _get_token_color(token_type) -> str:
+    """Get color for a token type from our Monokai scheme.
+
+    Args:
+        token_type: Pygments token type
+
+    Returns:
+        Hex color string or color name
+    """
+    if not PYGMENTS_AVAILABLE:
+        return "#cccccc"
+
+    for ttype, color in TOKEN_COLORS.items():
+        if token_type in ttype:
+            return color
+    return "#cccccc"  # Default light-grey for unmatched tokens
+
+
+def _highlight_code_line(code: str, bg_color: str | None, lexer) -> Text:
+    """Highlight a line of code with syntax highlighting and optional background color.
+
+    Args:
+        code: The code string to highlight
+        bg_color: Background color in hex format, or None for no background
+        lexer: Pygments lexer instance to use
+
+    Returns:
+        Rich Text object with styling applied
+    """
+    if not PYGMENTS_AVAILABLE or lexer is None:
+        # Fallback: just return text with optional background
+        if bg_color:
+            return Text(code, style=f"on {bg_color}")
+        return Text(code)
+
+    text = Text()
+
+    for token_type, value in lex(code, lexer):
+        # Strip trailing newlines that Pygments adds
+        # Pygments lexer always adds a \n at the end of the last token
+        value = value.rstrip("\n")
+
+        # Skip if the value is now empty (was only whitespace/newlines)
+        if not value:
+            continue
+
+        fg_color = _get_token_color(token_type)
+        # Apply foreground color and optional background
+        if bg_color:
+            text.append(value, style=f"{fg_color} on {bg_color}")
+        else:
+            text.append(value, style=fg_color)
+
+    return text
+
+
+def _extract_file_extension_from_diff(diff_text: str) -> str:
+    """Extract file extension from diff headers.
+
+    Args:
+        diff_text: Unified diff text
+
+    Returns:
+        File extension (e.g., '.py') or '.txt' as fallback
+    """
+    import re
+
+    # Look for +++ b/filename.ext or --- a/filename.ext headers
+    pattern = r"^(?:\+\+\+|---) [ab]/.*?(\.[a-zA-Z0-9]+)$"
+
+    for line in diff_text.split("\n")[:10]:  # Check first 10 lines
+        match = re.search(pattern, line)
+        if match:
+            return match.group(1)
+
+    return ".txt"  # Fallback to plain text
+
+
+# ============================================================================
+# COLOR PAIR OPTIMIZATION (for "highlighted" mode)
+# ============================================================================
+
+
+def brighten_hex(hex_color: str, factor: float) -> str:
+    """
+    Darken a hex color by multiplying each RGB channel by `factor`.
+    factor=1.0 -> no change
+    factor=0.0 -> black
+    factor=0.18 -> good for diff backgrounds (recommended)
+    """
+    hex_color = hex_color.lstrip("#")
+    if len(hex_color) != 6:
+        raise ValueError(f"Expected #RRGGBB, got {hex_color!r}")
+
+    r = int(hex_color[0:2], 16)
+    g = int(hex_color[2:4], 16)
+    b = int(hex_color[4:6], 16)
+
+    r = max(0, min(255, int(r * (1 + factor))))
+    g = max(0, min(255, int(g * (1 + factor))))
+    b = max(0, min(255, int(b * (1 + factor))))
+
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _format_diff_with_syntax_highlighting(
+    diff_text: str,
+    addition_color: str | None = None,
+    deletion_color: str | None = None,
+) -> Text:
+    """Format diff with full syntax highlighting using Pygments.
+
+    This renders diffs with:
+    - Syntax highlighting for code tokens
+    - Colored backgrounds for context/added/removed lines
+    - Monokai color scheme
+    - Optional custom colors for additions/deletions
+
+    Args:
+        diff_text: Raw unified diff text
+        addition_color: Optional custom color for added lines (default: green)
+        deletion_color: Optional custom color for deleted lines (default: red)
+
+    Returns:
+        Rich Text object with syntax highlighting (can be passed to emit_info)
+    """
+    if not PYGMENTS_AVAILABLE:
+        return Text(diff_text)
+
+    # Extract file extension from diff headers
+    extension = _extract_file_extension_from_diff(diff_text)
+    lexer = _get_lexer_for_extension(extension)
+
+    # Generate background colors from foreground colors
+    add_fg = brighten_hex(addition_color, 0.6)
+    del_fg = brighten_hex(deletion_color, 0.6)
+
+    # Background colors for different line types
+    # Context lines have no background (None) for clean, minimal diffs
+    bg_colors = {
+        "removed": deletion_color,
+        "added": addition_color,
+        "context": None,  # No background for unchanged lines
+    }
+
+    lines = diff_text.split("\n")
+    # Remove trailing empty line if it exists (from trailing \n in diff)
+    if lines and lines[-1] == "":
+        lines = lines[:-1]
+    result = Text()
+
+    for i, line in enumerate(lines):
+        if not line:
+            # Empty line - just add a newline if not the last line
+            if i < len(lines) - 1:
+                result.append("\n")
+            continue
+
+        # Skip diff headers - they're redundant noise since we show the filename in the banner
+        if line.startswith(("---", "+++", "@@", "diff ", "index ")):
+            continue
+        else:
+            # Determine line type and extract code content
+            if line.startswith("-"):
+                line_type = "removed"
+                code = line[1:]  # Remove the '-' prefix
+                marker_style = f"bold {del_fg} on {bg_colors[line_type]}"
+                prefix = "- "
+            elif line.startswith("+"):
+                line_type = "added"
+                code = line[1:]  # Remove the '+' prefix
+                marker_style = f"bold {add_fg} on {bg_colors[line_type]}"
+                prefix = "+ "
+            else:
+                line_type = "context"
+                code = line[1:] if line.startswith(" ") else line
+                # Context lines have no background - clean and minimal
+                marker_style = ""  # No special styling for context markers
+                prefix = "  "
+
+            # Add the marker prefix
+            if marker_style:  # Only apply style if we have one
+                result.append(prefix, style=marker_style)
+            else:
+                result.append(prefix)
+
+            # Add syntax-highlighted code
+            highlighted = _highlight_code_line(code, bg_colors[line_type], lexer)
+            result.append_text(highlighted)
+
+        # Add newline after each line except the last
+        if i < len(lines) - 1:
+            result.append("\n")
+
+    return result
+
+
+def format_diff_with_colors(diff_text: str) -> Text:
+    """Format diff text with beautiful syntax highlighting.
+
+    This is the canonical diff formatting function used across the codebase.
+    It applies user-configurable color coding with full syntax highlighting using Pygments.
+
+    The function respects user preferences from config:
+    - get_diff_addition_color(): Color for added lines (markers and backgrounds)
+    - get_diff_deletion_color(): Color for deleted lines (markers and backgrounds)
+
+    Args:
+        diff_text: Raw diff text to format
+
+    Returns:
+        Rich Text object with syntax highlighting
+    """
+    from code_puppy.config import (
+        get_diff_addition_color,
+        get_diff_deletion_color,
+    )
+
+    if not diff_text or not diff_text.strip():
+        return Text("-- no diff available --", style="dim")
+
+    addition_base_color = get_diff_addition_color()
+    deletion_base_color = get_diff_deletion_color()
+
+    # Always use beautiful syntax highlighting!
+    if not PYGMENTS_AVAILABLE:
+        emit_warning("Pygments not available, diffs will look plain")
+        # Return plain text as fallback
+        return Text(diff_text)
+
+    # Return Text object with custom colors - emit_info handles this correctly
+    return _format_diff_with_syntax_highlighting(
+        diff_text,
+        addition_color=addition_base_color,
+        deletion_color=deletion_base_color,
+    )
+
+
+async def arrow_select_async(
+    message: str,
+    choices: list[str],
+    preview_callback: Optional[Callable[[int], str]] = None,
+) -> str:
+    """Async version: Show an arrow-key navigable selector with optional preview.
+
+    Args:
+        message: The prompt message to display
+        choices: List of choice strings
+        preview_callback: Optional callback that takes the selected index and returns
+                         preview text to display below the choices
+
+    Returns:
+        The selected choice string
+
+    Raises:
+        KeyboardInterrupt: If user cancels with Ctrl-C
+    """
+    import html
+
+    selected_index = [0]  # Mutable container for selected index
+    result = [None]  # Mutable container for result
+
+    def get_formatted_text():
+        """Generate the formatted text for display."""
+        # Escape XML special characters to prevent parsing errors
+        safe_message = html.escape(message)
+        lines = [f"<b>{safe_message}</b>", ""]
+        for i, choice in enumerate(choices):
+            safe_choice = html.escape(choice)
+            if i == selected_index[0]:
+                lines.append(f"<ansigreen>❯ {safe_choice}</ansigreen>")
+            else:
+                lines.append(f"  {safe_choice}")
+        lines.append("")
+
+        # Add preview section if callback provided
+        if preview_callback is not None:
+            preview_text = preview_callback(selected_index[0])
+            if preview_text:
+                import textwrap
+
+                # Box width (excluding borders and padding)
+                box_width = 60
+                border_top = (
+                    "<ansiyellow>┌─ Preview "
+                    + "─" * (box_width - 10)
+                    + "┐</ansiyellow>"
+                )
+                border_bottom = "<ansiyellow>└" + "─" * box_width + "┘</ansiyellow>"
+
+                lines.append(border_top)
+
+                # Wrap text to fit within box width (minus padding)
+                wrapped_lines = textwrap.wrap(preview_text, width=box_width - 2)
+
+                # If no wrapped lines (empty text), add empty line
+                if not wrapped_lines:
+                    wrapped_lines = [""]
+
+                for wrapped_line in wrapped_lines:
+                    safe_preview = html.escape(wrapped_line)
+                    # Pad line to box width for consistent appearance
+                    padded_line = safe_preview.ljust(box_width - 2)
+                    lines.append(f"<dim>│ {padded_line} │</dim>")
+
+                lines.append(border_bottom)
+                lines.append("")
+
+        lines.append("<ansicyan>(Use ↑↓ arrows to select, Enter to confirm)</ansicyan>")
+        return HTML("\n".join(lines))
+
+    # Key bindings
+    kb = KeyBindings()
+
+    @kb.add("up")
+    def move_up(event):
+        selected_index[0] = (selected_index[0] - 1) % len(choices)
+        event.app.invalidate()  # Force redraw to update preview
+
+    @kb.add("down")
+    def move_down(event):
+        selected_index[0] = (selected_index[0] + 1) % len(choices)
+        event.app.invalidate()  # Force redraw to update preview
+
+    @kb.add("enter")
+    def accept(event):
+        result[0] = choices[selected_index[0]]
+        event.app.exit()
+
+    @kb.add("c-c")  # Ctrl-C
+    def cancel(event):
+        result[0] = None
+        event.app.exit()
+
+    # Layout
+    control = FormattedTextControl(get_formatted_text)
+    layout = Layout(Window(content=control))
+
+    # Application
+    app = Application(
+        layout=layout,
+        key_bindings=kb,
+        full_screen=False,
+    )
+
+    # Flush output before prompt_toolkit takes control
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    # Run the app asynchronously
+    await app.run_async()
+
+    if result[0] is None:
+        raise KeyboardInterrupt()
+
+    return result[0]
+
+
+def arrow_select(message: str, choices: list[str]) -> str:
+    """Show an arrow-key navigable selector (synchronous version).
+
+    Args:
+        message: The prompt message to display
+        choices: List of choice strings
+
+    Returns:
+        The selected choice string
+
+    Raises:
+        KeyboardInterrupt: If user cancels with Ctrl-C
+    """
+    import asyncio
+
+    selected_index = [0]  # Mutable container for selected index
+    result = [None]  # Mutable container for result
+
+    def get_formatted_text():
+        """Generate the formatted text for display."""
+        lines = [f"<b>{message}</b>", ""]
+        for i, choice in enumerate(choices):
+            if i == selected_index[0]:
+                lines.append(f"<ansigreen>❯ {choice}</ansigreen>")
+            else:
+                lines.append(f"  {choice}")
+        lines.append("")
+        lines.append("<ansicyan>(Use ↑↓ arrows to select, Enter to confirm)</ansicyan>")
+        return HTML("\n".join(lines))
+
+    # Key bindings
+    kb = KeyBindings()
+
+    @kb.add("up")
+    def move_up(event):
+        selected_index[0] = (selected_index[0] - 1) % len(choices)
+        event.app.invalidate()  # Force redraw to update preview
+
+    @kb.add("down")
+    def move_down(event):
+        selected_index[0] = (selected_index[0] + 1) % len(choices)
+        event.app.invalidate()  # Force redraw to update preview
+
+    @kb.add("enter")
+    def accept(event):
+        result[0] = choices[selected_index[0]]
+        event.app.exit()
+
+    @kb.add("c-c")  # Ctrl-C
+    def cancel(event):
+        result[0] = None
+        event.app.exit()
+
+    # Layout
+    control = FormattedTextControl(get_formatted_text)
+    layout = Layout(Window(content=control))
+
+    # Application
+    app = Application(
+        layout=layout,
+        key_bindings=kb,
+        full_screen=False,
+    )
+
+    # Flush output before prompt_toolkit takes control
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    # Check if we're already in an async context
+    try:
+        asyncio.get_running_loop()
+        # We're in an async context - can't use app.run()
+        # Caller should use arrow_select_async instead
+        raise RuntimeError(
+            "arrow_select() called from async context. Use arrow_select_async() instead."
+        )
+    except RuntimeError as e:
+        if "no running event loop" in str(e).lower():
+            # No event loop, safe to use app.run()
+            app.run()
+        else:
+            # Re-raise if it's our error message
+            raise
+
+    if result[0] is None:
+        raise KeyboardInterrupt()
+
+    return result[0]
+
+
+def get_user_approval(
+    title: str,
+    content: Text | str,
+    preview: str | None = None,
+    border_style: str = "dim white",
+    puppy_name: str | None = None,
+) -> tuple[bool, str | None]:
+    """Show a beautiful approval panel with arrow-key selector.
+
+    Args:
+        title: Title for the panel (e.g., "File Operation", "Shell Command")
+        content: Main content to display (Rich Text object or string)
+        preview: Optional preview content (like a diff)
+        border_style: Border color/style for the panel
+        puppy_name: Name of the assistant (defaults to config value)
+
+    Returns:
+        Tuple of (confirmed: bool, user_feedback: str | None)
+        - confirmed: True if approved, False if rejected
+        - user_feedback: Optional feedback text if user provided it
+    """
+    import time
+
+    from code_puppy.tools.command_runner import set_awaiting_user_input
+
+    if puppy_name is None:
+        from code_puppy.config import get_puppy_name
+
+        puppy_name = get_puppy_name().title()
+
+    # Build panel content
+    if isinstance(content, str):
+        panel_content = Text(content)
+    else:
+        panel_content = content
+
+    # Add preview if provided
+    if preview:
+        panel_content.append("\n\n", style="")
+        panel_content.append("Preview of changes:", style="bold underline")
+        panel_content.append("\n", style="")
+        formatted_preview = format_diff_with_colors(preview)
+
+        # Handle both string (text mode) and Text object (highlight mode)
+        if isinstance(formatted_preview, Text):
+            preview_text = formatted_preview
+        else:
+            preview_text = Text.from_markup(formatted_preview)
+
+        panel_content.append(preview_text)
+
+        # Mark that we showed a diff preview
+        try:
+            from code_puppy.plugins.file_permission_handler.register_callbacks import (
+                set_diff_already_shown,
+            )
+
+            set_diff_already_shown(True)
+        except ImportError:
+            pass
+
+    # Create panel
+    panel = Panel(
+        panel_content,
+        title=f"[bold white]{title}[/bold white]",
+        border_style=border_style,
+        padding=(1, 2),
+    )
+
+    # Pause spinners BEFORE showing panel
+    set_awaiting_user_input(True)
+    # Also explicitly pause spinners to ensure they're fully stopped
+    try:
+        from code_puppy.messaging.spinner import pause_all_spinners
+
+        pause_all_spinners()
+    except (ImportError, Exception):
+        pass
+
+    time.sleep(0.3)  # Let spinners fully stop
+
+    # Display panel
+    local_console = Console()
+    emit_info("")
+    local_console.print(panel)
+    emit_info("")
+
+    # Flush and buffer before selector
+    sys.stdout.flush()
+    sys.stderr.flush()
+    time.sleep(0.1)
+
+    user_feedback = None
+    confirmed = False
+
+    try:
+        # Final flush
+        sys.stdout.flush()
+
+        # Show arrow-key selector
+        choice = arrow_select(
+            "💭 What would you like to do?",
+            [
+                "✓ Approve",
+                "✗ Reject",
+                f"💬 Reject with feedback (tell {puppy_name} what to change)",
+            ],
+        )
+
+        if choice == "✓ Approve":
+            confirmed = True
+        elif choice == "✗ Reject":
+            confirmed = False
+        else:
+            # User wants to provide feedback
+            confirmed = False
+            emit_info("")
+            emit_info(f"Tell {puppy_name} what to change:")
+            user_feedback = Prompt.ask(
+                "[bold green]➤[/bold green]",
+                default="",
+            ).strip()
+
+            if not user_feedback:
+                user_feedback = None
+
+    except (KeyboardInterrupt, EOFError):
+        emit_error("Cancelled by user")
+        confirmed = False
+
+    finally:
+        set_awaiting_user_input(False)
+
+        # Force Rich console to reset display state to prevent artifacts
+        try:
+            # Clear Rich's internal display state to prevent artifacts
+            local_console.file.write("\r")  # Return to start of line
+            local_console.file.write("\x1b[K")  # Clear current line
+            local_console.file.flush()
+        except Exception:
+            pass
+
+        # Ensure streams are flushed
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+    # Show result BEFORE resuming spinners (no puppy litter!)
+    emit_info("")
+    if not confirmed:
+        if user_feedback:
+            emit_error("Rejected with feedback!")
+            emit_warning(f'Telling {puppy_name}: "{user_feedback}"')
+        else:
+            emit_error("Rejected.")
+    else:
+        emit_success("Approved!")
+
+    # NOW resume spinners after showing the result
+    try:
+        from code_puppy.messaging.spinner import resume_all_spinners
+
+        resume_all_spinners()
+    except (ImportError, Exception):
+        pass
+
+    return confirmed, user_feedback
+
+
+async def get_user_approval_async(
+    title: str,
+    content: Text | str,
+    preview: str | None = None,
+    border_style: str = "dim white",
+    puppy_name: str | None = None,
+) -> tuple[bool, str | None]:
+    """Async version of get_user_approval - show a beautiful approval panel with arrow-key selector.
+
+    Args:
+        title: Title for the panel (e.g., "File Operation", "Shell Command")
+        content: Main content to display (Rich Text object or string)
+        preview: Optional preview content (like a diff)
+        border_style: Border color/style for the panel
+        puppy_name: Name of the assistant (defaults to config value)
+
+    Returns:
+        Tuple of (confirmed: bool, user_feedback: str | None)
+        - confirmed: True if approved, False if rejected
+        - user_feedback: Optional feedback text if user provided it
+    """
+    import asyncio
+
+    from code_puppy.tools.command_runner import set_awaiting_user_input
+
+    if puppy_name is None:
+        from code_puppy.config import get_puppy_name
+
+        puppy_name = get_puppy_name().title()
+
+    # Build panel content
+    if isinstance(content, str):
+        panel_content = Text(content)
+    else:
+        panel_content = content
+
+    # Add preview if provided
+    if preview:
+        panel_content.append("\n\n", style="")
+        panel_content.append("Preview of changes:", style="bold underline")
+        panel_content.append("\n", style="")
+        formatted_preview = format_diff_with_colors(preview)
+
+        # Handle both string (text mode) and Text object (highlight mode)
+        if isinstance(formatted_preview, Text):
+            preview_text = formatted_preview
+        else:
+            preview_text = Text.from_markup(formatted_preview)
+
+        panel_content.append(preview_text)
+
+        # Mark that we showed a diff preview
+        try:
+            from code_puppy.plugins.file_permission_handler.register_callbacks import (
+                set_diff_already_shown,
+            )
+
+            set_diff_already_shown(True)
+        except ImportError:
+            pass
+
+    # Create panel
+    panel = Panel(
+        panel_content,
+        title=f"[bold white]{title}[/bold white]",
+        border_style=border_style,
+        padding=(1, 2),
+    )
+
+    # Pause spinners BEFORE showing panel
+    set_awaiting_user_input(True)
+    # Also explicitly pause spinners to ensure they're fully stopped
+    try:
+        from code_puppy.messaging.spinner import pause_all_spinners
+
+        pause_all_spinners()
+    except (ImportError, Exception):
+        pass
+
+    await asyncio.sleep(0.3)  # Let spinners fully stop
+
+    # Display panel
+    local_console = Console()
+    emit_info("")
+    local_console.print(panel)
+    emit_info("")
+
+    # Flush and buffer before selector
+    sys.stdout.flush()
+    sys.stderr.flush()
+    await asyncio.sleep(0.1)
+
+    user_feedback = None
+    confirmed = False
+
+    try:
+        # Final flush
+        sys.stdout.flush()
+
+        # Show arrow-key selector (ASYNC VERSION)
+        choice = await arrow_select_async(
+            "💭 What would you like to do?",
+            [
+                "✓ Approve",
+                "✗ Reject",
+                f"💬 Reject with feedback (tell {puppy_name} what to change)",
+            ],
+        )
+
+        if choice == "✓ Approve":
+            confirmed = True
+        elif choice == "✗ Reject":
+            confirmed = False
+        else:
+            # User wants to provide feedback
+            confirmed = False
+            emit_info("")
+            emit_info(f"Tell {puppy_name} what to change:")
+            user_feedback = Prompt.ask(
+                "[bold green]➤[/bold green]",
+                default="",
+            ).strip()
+
+            if not user_feedback:
+                user_feedback = None
+
+    except (KeyboardInterrupt, EOFError):
+        emit_error("Cancelled by user")
+        confirmed = False
+
+    finally:
+        set_awaiting_user_input(False)
+
+        # Force Rich console to reset display state to prevent artifacts
+        try:
+            # Clear Rich's internal display state to prevent artifacts
+            local_console.file.write("\r")  # Return to start of line
+            local_console.file.write("\x1b[K")  # Clear current line
+            local_console.file.flush()
+        except Exception:
+            pass
+
+        # Ensure streams are flushed
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+    # Show result BEFORE resuming spinners (no puppy litter!)
+    emit_info("")
+    if not confirmed:
+        if user_feedback:
+            emit_error("Rejected with feedback!")
+            emit_warning(f'Telling {puppy_name}: "{user_feedback}"')
+        else:
+            emit_error("Rejected.")
+    else:
+        emit_success("Approved!")
+
+    # NOW resume spinners after showing the result
+    try:
+        from code_puppy.messaging.spinner import resume_all_spinners
+
+        resume_all_spinners()
+    except (ImportError, Exception):
+        pass
+
+    return confirmed, user_feedback
+
+
 def _find_best_window(
     haystack_lines: list[str],
     needle: str,
@@ -413,9 +1380,10 @@ def _find_best_window(
             best_span = (i, i + win_size)
             best_window = window
 
-    console.log(f"Best span: {best_span}")
-    console.log(f"Best window: {best_window}")
-    console.log(f"Best score: {best_score}")
+    # Debug logging
+    console.log(best_span)
+    console.log(best_window)
+    console.log(best_score)
     return best_span, best_score
 
 
@@ -441,3 +1409,175 @@ def generate_group_id(tool_name: str, extra_context: str = "") -> str:
     short_hash = hash_obj.hexdigest()[:8]
 
     return f"{tool_name}_{short_hash}"
+
+
+# =============================================================================
+# TOOL CALLBACK WRAPPER
+# =============================================================================
+
+logger = logging.getLogger(__name__)
+
+
+def with_tool_callbacks(tool_name: str) -> Callable:
+    """Decorator that wraps tool functions with pre/post callback hooks.
+
+    This decorator enables plugins to hook into tool execution for:
+    - Logging and analytics
+    - Pre-execution validation or modification
+    - Post-execution result processing
+    - Performance monitoring
+
+    Args:
+        tool_name: The name of the tool being wrapped (e.g., 'edit_file', 'list_files')
+
+    Returns:
+        A decorator function that wraps the tool with callbacks.
+
+    Example:
+        @with_tool_callbacks('my_tool')
+        async def my_tool_impl(ctx, **kwargs):
+            return result
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs) -> Any:
+            # Extract context from args if available (usually first arg is RunContext)
+            context = None
+            tool_args = kwargs.copy()
+
+            # Try to get session context
+            try:
+                from code_puppy.messaging import get_session_context
+
+                context = get_session_context()
+            except ImportError:
+                pass
+
+            # Fire pre-tool callback (non-blocking)
+            try:
+                from code_puppy import callbacks
+
+                asyncio.create_task(
+                    callbacks.on_pre_tool_call(tool_name, tool_args, context)
+                )
+            except ImportError:
+                logger.debug("callbacks module not available for pre_tool_call")
+            except Exception as e:
+                logger.debug(f"Error in pre_tool_call callback: {e}")
+
+            # Execute the tool and measure duration
+            start_time = time.perf_counter()
+            result = None
+            error = None
+
+            try:
+                result = await func(*args, **kwargs)
+                return result
+            except Exception as e:
+                error = e
+                raise
+            finally:
+                end_time = time.perf_counter()
+                duration_ms = (end_time - start_time) * 1000
+
+                # Fire post-tool callback (non-blocking)
+                final_result = result if error is None else {"error": str(error)}
+                try:
+                    from code_puppy import callbacks
+
+                    asyncio.create_task(
+                        callbacks.on_post_tool_call(
+                            tool_name, tool_args, final_result, duration_ms, context
+                        )
+                    )
+                except ImportError:
+                    logger.debug("callbacks module not available for post_tool_call")
+                except Exception as e:
+                    logger.debug(f"Error in post_tool_call callback: {e}")
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs) -> Any:
+            """Sync wrapper for non-async tool functions."""
+            # Extract context
+            context = None
+            tool_args = kwargs.copy()
+
+            try:
+                from code_puppy.messaging import get_session_context
+
+                context = get_session_context()
+            except ImportError:
+                pass
+
+            # For sync functions, we can't use asyncio.create_task directly
+            # Instead, we'll try to schedule it if there's a running loop
+            def fire_pre_callback():
+                try:
+                    from code_puppy import callbacks
+
+                    loop = asyncio.get_running_loop()
+                    asyncio.run_coroutine_threadsafe(
+                        callbacks.on_pre_tool_call(tool_name, tool_args, context),
+                        loop,
+                    )
+                except RuntimeError:
+                    # No running loop - skip async callback
+                    pass
+                except ImportError:
+                    pass
+                except Exception as e:
+                    logger.debug(f"Error in sync pre_tool_call: {e}")
+
+            fire_pre_callback()
+
+            # Execute the tool
+            start_time = time.perf_counter()
+            result = None
+            error = None
+
+            try:
+                result = func(*args, **kwargs)
+                return result
+            except Exception as e:
+                error = e
+                raise
+            finally:
+                end_time = time.perf_counter()
+                duration_ms = (end_time - start_time) * 1000
+
+                # Fire post-tool callback
+                final_result = result if error is None else {"error": str(error)}
+
+                def fire_post_callback():
+                    try:
+                        from code_puppy import callbacks
+
+                        loop = asyncio.get_running_loop()
+                        asyncio.run_coroutine_threadsafe(
+                            callbacks.on_post_tool_call(
+                                tool_name,
+                                tool_args,
+                                final_result,
+                                duration_ms,
+                                context,
+                            ),
+                            loop,
+                        )
+                    except RuntimeError:
+                        # No running loop - skip async callback
+                        pass
+                    except ImportError:
+                        pass
+                    except Exception as e:
+                        logger.debug(f"Error in sync post_tool_call: {e}")
+
+                fire_post_callback()
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator