code-puppy 0.0.123__py3-none-any.whl → 0.0.125__py3-none-any.whl

code_puppy/tools/file_modifications.py

@@ -20,6 +20,7 @@ import json_repair
 from pydantic import BaseModel
 from pydantic_ai import RunContext
 
+from code_puppy.callbacks import on_delete_file, on_edit_file
 from code_puppy.messaging import emit_error, emit_info, emit_warning
 from code_puppy.tools.common import _find_best_window, generate_group_id
 
@@ -346,16 +347,19 @@ def _edit_file(
                 {"content": "full file contents", "overwrite": true}
                 {"replacements": [ {"old_str": "foo", "new_str": "bar"}, ... ] }
                 {"delete_snippet": "text to remove"}
+
     The function auto-detects the payload type and routes to the appropriate internal helper.
     """
+    # Extract file_path from payload
+    file_path = os.path.abspath(payload.file_path)
+
     # Use provided group_id or generate one if not provided
     if group_id is None:
-        group_id = generate_group_id("edit_file", payload.file_path)
+        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
     )
-    file_path = os.path.abspath(payload.file_path)
     try:
         if isinstance(payload, DeleteSnippetPayload):
             return delete_snippet_from_file(
@@ -448,9 +452,7 @@ def register_file_modifications_tools(agent):
     """Attach file-editing tools to *agent* with mandatory diff rendering."""
 
     @agent.tool(retries=5)
-    def edit_file(
-        context: RunContext, payload: EditFilePayload | str = ""
-    ) -> Dict[str, Any]:
+    def edit_file(context: RunContext, payload: EditFilePayload) -> Dict[str, Any]:
         """Comprehensive file editing tool supporting multiple modification strategies.
 
         This is the primary file modification tool that supports three distinct editing
@@ -476,8 +478,9 @@ def register_file_modifications_tools(agent):
                 DeleteSnippetPayload:
                     - delete_snippet (str): Exact text snippet to remove from file
 
-            file_path (str): Path to the target file. Can be relative or absolute.
-                File will be created if it doesn't exist (for ContentPayload).
+                file_path (str): Path to the target file. Can be relative or absolute.
+                    File will be created if it doesn't exist (for ContentPayload).
+
         Returns:
             Dict[str, Any]: Operation result containing:
                 - success (bool): True if operation completed successfully
@@ -497,16 +500,16 @@ def register_file_modifications_tools(agent):
         Examples:
             >>> # Create new file
             >>> payload = ContentPayload(file_path="foo.py", content="print('Hello World')")
-            >>> result = edit_file(payload)
+            >>> result = edit_file(context, payload)
 
             >>> # Replace specific text
             >>> replacements = [Replacement(old_str="foo", new_str="bar")]
             >>> payload = ReplacementsPayload(file_path="foo.py", replacements=replacements)
-            >>> result = edit_file(payload)
+            >>> result = edit_file(context, payload)
 
             >>> # Delete code block
             >>> payload = DeleteSnippetPayload(file_path="foo.py", delete_snippet="# TODO: remove this")
-            >>> result = edit_file(payload)
+            >>> result = edit_file(context, payload)
 
         Warning:
             - Always verify file contents after modification
@@ -542,12 +545,13 @@ def register_file_modifications_tools(agent):
                 }
         group_id = generate_group_id("edit_file", payload.file_path)
         result = _edit_file(context, payload, group_id)
+        on_edit_file(result)
         if "diff" in result:
             del result["diff"]
         return result
 
     @agent.tool(retries=5)
-    def delete_file(context: RunContext, file_path: str = "") -> Dict[str, Any]:
+    def delete_file(context: RunContext, file_path: str) -> Dict[str, Any]:
         """Safely delete files with comprehensive logging and diff generation.
 
         This tool provides safe file deletion with automatic diff generation to show
@@ -600,6 +604,170 @@ def register_file_modifications_tools(agent):
         # Generate group_id for delete_file tool execution
         group_id = generate_group_id("delete_file", file_path)
         result = _delete_file(context, file_path, message_group=group_id)
+        on_delete_file(result)
+        if "diff" in result:
+            del result["diff"]
+        return result
+
+
+def register_edit_file(agent):
+    """Register only the edit_file tool."""
+
+    @agent.tool(strict=False)
+    def edit_file(
+        context: RunContext,
+        payload: EditFilePayload | str = "",
+    ) -> Dict[str, Any]:
+        """Comprehensive file editing tool supporting multiple modification strategies.
+
+        This is the primary file modification tool that supports three distinct editing
+        approaches: full content replacement, targeted text replacements, and snippet
+        deletion. It provides robust diff generation, error handling, and automatic
+        retry capabilities for reliable file operations.
+
+        Args:
+            context (RunContext): The PydanticAI runtime context for the agent.
+            payload: One of three payload types:
+
+                ContentPayload:
+                    - content (str): Full file content to write
+                    - overwrite (bool, optional): Whether to overwrite existing files.
+                      Defaults to False (safe mode).
+
+                ReplacementsPayload:
+                    - replacements (List[Replacement]): List of text replacements where
+                      each Replacement contains:
+                      - old_str (str): Exact text to find and replace
+                      - new_str (str): Replacement text
+
+                DeleteSnippetPayload:
+                    - delete_snippet (str): Exact text snippet to remove from file
+
+        Returns:
+            Dict[str, Any]: Operation result containing:
+                - success (bool): True if operation completed successfully
+                - path (str): Absolute path to the modified file
+                - message (str): Human-readable description of changes
+                - changed (bool): True if file content was actually modified
+                - diff (str, optional): Unified diff showing changes made
+                - error (str, optional): Error message if operation failed
+
+        Examples:
+            >>> # Create new file with content
+            >>> payload = {"file_path": "hello.py", "content": "print('Hello!')"}
+            >>> result = edit_file(ctx, payload)
+
+            >>> # Replace text in existing file
+            >>> payload = {
+            ...     "file_path": "config.py",
+            ...     "replacements": [
+            ...         {"old_str": "debug = False", "new_str": "debug = True"}
+            ...     ]
+            ... }
+            >>> result = edit_file(ctx, payload)
+
+            >>> # Delete snippet from file
+            >>> payload = {
+            ...     "file_path": "main.py",
+            ...     "delete_snippet": "# TODO: remove this comment"
+            ... }
+            >>> result = edit_file(ctx, payload)
+
+        Best Practices:
+            - Use replacements for targeted changes (most efficient)
+            - Use content payload only for new files or complete rewrites
+            - Always check the 'success' field before assuming changes worked
+            - Review the 'diff' field to understand what changed
+            - Use delete_snippet for removing specific code blocks
+        """
+        # Handle string payload parsing (for models that send JSON strings)
+        if isinstance(payload, str):
+            # 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 and "file_path" in payload:
+                payload = ReplacementsPayload(**payload)
+            elif "delete_snippet" in payload and "file_path" in payload:
+                payload = DeleteSnippetPayload(**payload)
+            elif "content" in payload and "file_path" in payload:
+                payload = ContentPayload(**payload)
+            else:
+                file_path = "Unknown"
+                if "file_path" in payload:
+                    file_path = payload["file_path"]
+                # Diagnose what's missing
+                missing = []
+                if "file_path" not in payload:
+                    missing.append("file_path")
+
+                payload_type = "unknown"
+                if "content" in payload:
+                    payload_type = "content"
+                elif "replacements" in payload:
+                    payload_type = "replacements"
+                elif "delete_snippet" in payload:
+                    payload_type = "delete_snippet"
+                else:
+                    missing.append("content/replacements/delete_snippet")
+
+                missing_str = ", ".join(missing) if missing else "none"
+                return {
+                    "success": False,
+                    "path": file_path,
+                    "message": f"Invalid payload for {payload_type} operation. Missing required fields: {missing_str}. Payload keys: {list(payload.keys())}",
+                    "changed": False,
+                }
+
+        # Call _edit_file which will extract file_path from payload and handle group_id generation
+        result = _edit_file(context, payload)
+        if "diff" in result:
+            del result["diff"]
+        return result
+
+
+def register_delete_file(agent):
+    """Register only the delete_file tool."""
+
+    @agent.tool(strict=False)
+    def delete_file(context: RunContext, file_path: str = "") -> Dict[str, Any]:
+        """Safely delete files with comprehensive logging and diff generation.
+
+        This tool provides safe file deletion with automatic diff generation to show
+        exactly what content was removed. It includes proper error handling and
+        automatic retry capabilities for reliable operation.
+
+        Args:
+            context (RunContext): The PydanticAI runtime context for the agent.
+            file_path (str): Path to the file to delete. Can be relative or absolute.
+                Must be an existing regular file (not a directory).
+
+        Returns:
+            Dict[str, Any]: Operation result containing:
+                - success (bool): True if file was successfully deleted
+                - path (str): Absolute path to the deleted file
+                - message (str): Human-readable description of the operation
+                - changed (bool): True if file was actually removed
+                - error (str, optional): Error message if deletion failed
+
+        Examples:
+            >>> # Delete a specific file
+            >>> result = delete_file(ctx, "temp_file.txt")
+            >>> if result['success']:
+            ...     print(f"Deleted: {result['path']}")
+
+            >>> # Handle deletion errors
+            >>> result = delete_file(ctx, "missing.txt")
+            >>> if not result['success']:
+            ...     print(f"Error: {result.get('error', 'Unknown error')}")
+
+        Best Practices:
+            - Always verify file exists before attempting deletion
+            - Check 'success' field to confirm operation completed
+            - Use list_files first to confirm file paths
+            - Cannot delete directories (use shell commands for that)
+        """
+        # Generate group_id for delete_file tool execution
+        group_id = generate_group_id("delete_file", file_path)
+        result = _delete_file(context, file_path, message_group=group_id)
         if "diff" in result:
             del result["diff"]
         return result

code_puppy/tools/file_operations.py

@@ -173,13 +173,14 @@ def _list_files(
         if rel_path == ".":
             rel_path = ""
         if rel_path:
-            os.path.join(directory, rel_path)
+            dir_path = os.path.join(directory, rel_path)
             results.append(
                 ListedFile(
                     **{
                         "path": rel_path,
                         "type": "directory",
                         "size": 0,
+                        "full_path": dir_path,
                         "depth": depth,
                     }
                 )
@@ -187,6 +188,7 @@ def _list_files(
             folder_structure[rel_path] = {
                 "path": rel_path,
                 "depth": depth,
+                "full_path": dir_path,
             }
         for file in files:
             file_path = os.path.join(root, file)
@@ -199,6 +201,7 @@ def _list_files(
                     "path": rel_file_path,
                     "type": "file",
                     "size": size,
+                    "full_path": file_path,
                     "depth": depth,
                 }
                 results.append(ListedFile(**file_info))
@@ -621,3 +624,170 @@ def register_file_operations_tools(agent):
             - For case-insensitive search, try multiple variants manually
         """
         return _grep(context, search_string, directory)
+
+
+def register_list_files(agent):
+    """Register only the list_files tool."""
+
+    @agent.tool(strict=False)
+    def list_files(
+        context: RunContext, directory: str = ".", recursive: bool = True
+    ) -> ListFileOutput:
+        """List files and directories with intelligent filtering and safety features.
+
+        This tool provides comprehensive directory listing with smart home directory
+        detection, project-aware recursion, and token-safe output. It automatically
+        ignores common build artifacts, cache directories, and other noise while
+        providing rich file metadata and visual formatting.
+
+        Args:
+            context (RunContext): The PydanticAI runtime context for the agent.
+            directory (str, optional): Path to the directory to list. Can be relative
+                or absolute. Defaults to "." (current directory).
+            recursive (bool, optional): Whether to recursively list subdirectories.
+                Automatically disabled for home directories unless they contain
+                project indicators. Defaults to True.
+
+        Returns:
+            ListFileOutput: A structured response containing:
+                - files (List[ListedFile]): List of files and directories found, where
+                  each ListedFile contains:
+                  - path (str | None): Relative path from the listing directory
+                  - type (str | None): "file" or "directory"
+                  - size (int): File size in bytes (0 for directories)
+                  - full_path (str | None): Absolute path to the item
+                  - depth (int | None): Nesting depth from the root directory
+                - error (str | None): Error message if listing failed
+
+        Examples:
+            >>> # List current directory
+            >>> result = list_files(ctx)
+            >>> for file in result.files:
+            ...     print(f"{file.type}: {file.path} ({file.size} bytes)")
+
+            >>> # List specific directory non-recursively
+            >>> result = list_files(ctx, "/path/to/project", recursive=False)
+            >>> print(f"Found {len(result.files)} items")
+
+            >>> # Handle potential errors
+            >>> result = list_files(ctx, "/nonexistent/path")
+            >>> if result.error:
+            ...     print(f"Error: {result.error}")
+
+        Best Practices:
+            - Always use this before reading/modifying files
+            - Use non-recursive for quick directory overviews
+            - Check for errors in the response
+            - Combine with grep to find specific file patterns
+        """
+        return _list_files(context, directory, recursive)
+
+
+def register_read_file(agent):
+    """Register only the read_file tool."""
+
+    @agent.tool(strict=False)
+    def read_file(
+        context: RunContext,
+        file_path: str = "",
+        start_line: int | None = None,
+        num_lines: int | None = None,
+    ) -> ReadFileOutput:
+        """Read file contents with optional line-range selection and token safety.
+
+        This tool provides safe file reading with automatic token counting and
+        optional line-range selection for handling large files efficiently.
+        It protects against reading excessively large files that could overwhelm
+        the agent's context window.
+
+        Args:
+            context (RunContext): The PydanticAI runtime context for the agent.
+            file_path (str): Path to the file to read. Can be relative or absolute.
+                Cannot be empty.
+            start_line (int | None, optional): Starting line number for partial reads
+                (1-based indexing). If specified, num_lines must also be provided.
+                Defaults to None (read entire file).
+            num_lines (int | None, optional): Number of lines to read starting from
+                start_line. Must be specified if start_line is provided.
+                Defaults to None (read to end of file).
+
+        Returns:
+            ReadFileOutput: A structured response containing:
+                - content (str | None): The file contents or error message
+                - num_tokens (int): Estimated token count (constrained to < 10,000)
+                - error (str | None): Error message if reading failed
+
+        Examples:
+            >>> # Read entire file
+            >>> result = read_file(ctx, "example.py")
+            >>> print(f"Read {result.num_tokens} tokens")
+            >>> print(result.content)
+
+            >>> # Read specific line range
+            >>> result = read_file(ctx, "large_file.py", start_line=10, num_lines=20)
+            >>> print("Lines 10-29:", result.content)
+
+            >>> # Handle errors
+            >>> result = read_file(ctx, "missing.txt")
+            >>> if result.error:
+            ...     print(f"Error: {result.error}")
+
+        Best Practices:
+            - Always check for errors before using content
+            - Use line ranges for large files to avoid token limits
+            - Monitor num_tokens to stay within context limits
+            - Combine with list_files to find files first
+        """
+        return _read_file(context, file_path, start_line, num_lines)
+
+
+def register_grep(agent):
+    """Register only the grep tool."""
+
+    @agent.tool(strict=False)
+    def grep(
+        context: RunContext, search_string: str = "", directory: str = "."
+    ) -> GrepOutput:
+        """Recursively search for text patterns across files with intelligent filtering.
+
+        This tool provides powerful text searching across directory trees with
+        automatic filtering of irrelevant files, binary detection, and match limiting
+        for performance. It's essential for code exploration and finding specific
+        patterns or references.
+
+        Args:
+            context (RunContext): The PydanticAI runtime context for the agent.
+            search_string (str): The text pattern to search for. Performs exact
+                string matching (not regex). Cannot be empty.
+            directory (str, optional): Root directory to start the recursive search.
+                Can be relative or absolute. Defaults to "." (current directory).
+
+        Returns:
+            GrepOutput: A structured response containing:
+                - matches (List[MatchInfo]): List of matches found, where each
+                  MatchInfo contains:
+                  - file_path (str | None): Absolute path to the file containing the match
+                  - line_number (int | None): Line number where match was found (1-based)
+                  - line_content (str | None): Full line content containing the match
+
+        Examples:
+            >>> # Search for function definitions
+            >>> result = grep(ctx, "def my_function")
+            >>> for match in result.matches:
+            ...     print(f"{match.file_path}:{match.line_number}: {match.line_content}")
+
+            >>> # Search in specific directory
+            >>> result = grep(ctx, "TODO", "/path/to/project/src")
+            >>> print(f"Found {len(result.matches)} TODO items")
+
+            >>> # Search for imports
+            >>> result = grep(ctx, "import pandas")
+            >>> files_using_pandas = {match.file_path for match in result.matches}
+
+        Best Practices:
+            - Use specific search terms to avoid too many results
+            - Search is case-sensitive; try variations if needed
+            - Combine with read_file to examine matches in detail
+            - For case-insensitive search, try multiple variants manually
+        """
+        return _grep(context, search_string, directory)

code_puppy/tui/app.py

@@ -10,7 +10,7 @@ from textual.binding import Binding
 from textual.containers import Container
 from textual.events import Resize
 from textual.reactive import reactive
-from textual.widgets import Footer, Label, ListItem, ListView
+from textual.widgets import Footer, ListView
 
 from code_puppy.agent import get_code_generation_agent, get_custom_usage_limits
 from code_puppy.command_line.command_handler import handle_command
@@ -27,7 +27,11 @@ from code_puppy.message_history_processor import (
 
 # Import our message queue system
 from code_puppy.messaging import TUIRenderer, get_global_queue
-from code_puppy.state_management import clear_message_history, get_message_history, set_message_history
+from code_puppy.state_management import (
+    clear_message_history,
+    get_message_history,
+    set_message_history,
+)
 from code_puppy.tui.components import (
     ChatView,
     CustomTextArea,
@@ -404,6 +408,15 @@ class CodePuppyTUI(App):
                     self.action_clear_chat()
                     return
 
+                # Let the command handler process all /agent commands
+                # result will be handled by the command handler directly through messaging system
+                if message.strip().startswith("/agent"):
+                    # The command handler will emit messages directly to our messaging system
+                    handle_command(message.strip())
+                    # Refresh our agent instance after potential change
+                    self.agent = get_code_generation_agent()
+                    return
+
                 # Handle exit commands
                 if message.strip().lower() in ("/exit", "/quit"):
                     self.add_system_message("Goodbye!")
@@ -412,36 +425,11 @@ class CodePuppyTUI(App):
                     return
 
                 # Use the existing command handler
+                # The command handler directly uses the messaging system, so we don't need to capture stdout
                 try:
-                    import sys
-                    from io import StringIO
-
-                    from code_puppy.tools.common import console as rich_console
-
-                    # Capture the output from the command handler
-                    old_stdout = sys.stdout
-                    captured_output = StringIO()
-                    sys.stdout = captured_output
-
-                    # Also capture Rich console output
-                    rich_console.file = captured_output
-
-                    try:
-                        # Call the existing command handler
-                        result = handle_command(message.strip())
-                        if result:  # Command was handled
-                            output = captured_output.getvalue()
-                            if output.strip():
-                                self.add_system_message(output.strip())
-                            else:
-                                self.add_system_message(f"Command '{message}' executed")
-                        else:
-                            self.add_system_message(f"Unknown command: {message}")
-                    finally:
-                        # Restore stdout and console
-                        sys.stdout = old_stdout
-                        rich_console.file = sys.__stdout__
-
+                    result = handle_command(message.strip())
+                    if not result:
+                        self.add_system_message(f"Unknown command: {message}")
                 except Exception as e:
                     self.add_error_message(f"Error executing command: {str(e)}")
                 return
@@ -499,7 +487,9 @@ class CodePuppyTUI(App):
                             # Handle regular exceptions
                             self.add_error_message(f"MCP/Agent error: {str(eg)}")
                     finally:
-                        set_message_history(prune_interrupted_tool_calls(get_message_history()))
+                        set_message_history(
+                            prune_interrupted_tool_calls(get_message_history())
+                        )
                 except Exception as agent_error:
                     # Handle any other errors in agent processing
                     self.add_error_message(
@@ -662,134 +652,6 @@ class CodePuppyTUI(App):
             # Automatically submit the message
             self.action_send_message()
 
-    # History management methods
-    def load_history_list(self) -> None:
-        """Load session history into the history tab."""
-        try:
-            from datetime import datetime, timezone
-
-            history_list = self.query_one("#history-list", ListView)
-
-            # Get history from session memory
-            if self.session_memory:
-                # Get recent history (last 24 hours by default)
-                recent_history = self.session_memory.get_history(within_minutes=24 * 60)
-
-                if not recent_history:
-                    # No history available
-                    history_list.append(
-                        ListItem(Label("No recent history", classes="history-empty"))
-                    )
-                    return
-
-                # Filter out model loading entries and group history by type, display most recent first
-                filtered_history = [
-                    entry
-                    for entry in recent_history
-                    if not entry.get("description", "").startswith("Agent loaded")
-                ]
-
-                # Get sidebar width for responsive text truncation
-                try:
-                    sidebar_width = (
-                        self.query_one("Sidebar").size.width
-                        if hasattr(self.query_one("Sidebar"), "size")
-                        else 30
-                    )
-                except Exception:
-                    sidebar_width = 30
-
-                # Adjust text length based on sidebar width
-                if sidebar_width >= 35:
-                    max_text_length = 45
-                    time_format = "%H:%M:%S"
-                elif sidebar_width >= 25:
-                    max_text_length = 30
-                    time_format = "%H:%M"
-                else:
-                    max_text_length = 20
-                    time_format = "%H:%M"
-
-                for entry in reversed(filtered_history[-20:]):  # Show last 20 entries
-                    timestamp_str = entry.get("timestamp", "")
-                    description = entry.get("description", "Unknown task")
-
-                    # Parse timestamp for display with safe parsing
-                    def parse_timestamp_safely_for_display(timestamp_str: str) -> str:
-                        """Parse timestamp string safely for display purposes."""
-                        try:
-                            # Handle 'Z' suffix (common UTC format)
-                            cleaned_timestamp = timestamp_str.replace("Z", "+00:00")
-                            parsed_dt = datetime.fromisoformat(cleaned_timestamp)
-
-                            # If the datetime is naive (no timezone), assume UTC
-                            if parsed_dt.tzinfo is None:
-                                parsed_dt = parsed_dt.replace(tzinfo=timezone.utc)
-
-                            return parsed_dt.strftime(time_format)
-                        except (ValueError, AttributeError, TypeError):
-                            # Handle invalid timestamp formats gracefully
-                            fallback = (
-                                timestamp_str[:5]
-                                if sidebar_width < 25
-                                else timestamp_str[:8]
-                            )
-                            return "??:??" if len(fallback) < 5 else fallback
-
-                    time_display = parse_timestamp_safely_for_display(timestamp_str)
-
-                    # Format description for display with responsive truncation
-                    if description.startswith("Interactive task:"):
-                        task_text = description[
-                            17:
-                        ].strip()  # Remove "Interactive task: "
-                        truncated = task_text[:max_text_length] + (
-                            "..." if len(task_text) > max_text_length else ""
-                        )
-                        display_text = f"[{time_display}] 💬 {truncated}"
-                        css_class = "history-interactive"
-                    elif description.startswith("TUI interaction:"):
-                        task_text = description[
-                            16:
-                        ].strip()  # Remove "TUI interaction: "
-                        truncated = task_text[:max_text_length] + (
-                            "..." if len(task_text) > max_text_length else ""
-                        )
-                        display_text = f"[{time_display}] 🖥️ {truncated}"
-                        css_class = "history-tui"
-                    elif description.startswith("Command executed"):
-                        cmd_text = description[
-                            18:
-                        ].strip()  # Remove "Command executed: "
-                        truncated = cmd_text[: max_text_length - 5] + (
-                            "..." if len(cmd_text) > max_text_length - 5 else ""
-                        )
-                        display_text = f"[{time_display}] ⚡ {truncated}"
-                        css_class = "history-command"
-                    else:
-                        # Generic entry
-                        truncated = description[:max_text_length] + (
-                            "..." if len(description) > max_text_length else ""
-                        )
-                        display_text = f"[{time_display}] 📝 {truncated}"
-                        css_class = "history-generic"
-
-                    label = Label(display_text, classes=css_class)
-                    history_item = ListItem(label)
-                    history_item.history_entry = (
-                        entry  # Store full entry for detail view
-                    )
-                    history_list.append(history_item)
-            else:
-                history_list.append(
-                    ListItem(
-                        Label("Session memory not available", classes="history-error")
-                    )
-                )
-
-        except Exception as e:
-            self.add_error_message(f"Failed to load history: {e}")
-
     def show_history_details(self, history_entry: dict) -> None:
         """Show detailed information about a selected history entry."""
         try: