code-puppy 0.0.150__tar.gz → 0.0.152__tar.gz

{code_puppy-0.0.150 → code_puppy-0.0.152}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.150
+Version: 0.0.152
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -30,6 +30,7 @@ Requires-Dist: pytest-cov>=6.1.1
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rapidfuzz>=3.13.0
 Requires-Dist: rich>=13.4.2
+Requires-Dist: ripgrep>=14.1.0
 Requires-Dist: ruff>=0.11.11
 Requires-Dist: termcolor>=3.1.0
 Requires-Dist: textual-dev>=1.7.0

{code_puppy-0.0.150 → code_puppy-0.0.152}/code_puppy/agents/agent_code_puppy.py

@@ -68,7 +68,7 @@ File Operations:
    - read_file(file_path: str, start_line: int | None = None, num_lines: int | None = None): ALWAYS use this to read existing files before modifying them. By default, read the entire file. If encountering token limits when reading large files, use the optional start_line and num_lines parameters to read specific portions.
    - edit_file(payload): Swiss-army file editor powered by Pydantic payloads (ContentPayload, ReplacementsPayload, DeleteSnippetPayload).
    - delete_file(file_path): Use this to remove files when needed
-   - grep(search_string, directory="."): Use this to recursively search for a string across files starting from the specified directory, capping results at 200 matches.
+   - grep(search_string, directory="."): Use this to recursively search for a string across files starting from the specified directory, capping results at 200 matches. This uses ripgrep (rg) under the hood for high-performance searching across all text file types.
 
 Tool Usage Instructions:
 
@@ -99,17 +99,12 @@ edit_file(
   payload={{file_path="example.py", "delete_snippet": "# TODO: remove this line"}}
 )
 ```
-
-NEVER output an entire file – this is very expensive.
-You may not edit file extensions: [.ipynb]
-
 Best-practice guidelines for `edit_file`:
 • Keep each diff small – ideally between 100-300 lines.
 • Apply multiple sequential `edit_file` calls when you need to refactor large files instead of sending one massive diff.
 • Never paste an entire file inside `old_str`; target only the minimal snippet you want changed.
 • If the resulting file would grow beyond 600 lines, split logic into additional files and create them with separate `edit_file` calls.
 
-
 System Operations:
    - run_shell_command(command, cwd=None, timeout=60): Use this to execute commands, run tests, or start services
 

{code_puppy-0.0.150 → code_puppy-0.0.152}/code_puppy/tools/file_operations.py

@@ -380,8 +380,15 @@ def _read_file(
 
 
 def _grep(context: RunContext, search_string: str, directory: str = ".") -> GrepOutput:
-    matches: List[MatchInfo] = []
+    import subprocess
+    import json
+    import tempfile
+    import os
+    import shutil
+    import sys
+    
     directory = os.path.abspath(directory)
+    matches: List[MatchInfo] = []
 
     # Generate group_id for this tool execution
     group_id = generate_group_id("grep", f"{directory}_{search_string}")
@@ -392,67 +399,106 @@ def _grep(context: RunContext, search_string: str, directory: str = ".") -> Grep
     )
     emit_divider(message_group=group_id)
 
-    for root, dirs, files in os.walk(directory, topdown=True):
-        # Filter out ignored directories
-        dirs[:] = [d for d in dirs if not should_ignore_path(os.path.join(root, d))]
-
-        for f_name in files:
-            file_path = os.path.join(root, f_name)
-
-            if should_ignore_path(file_path):
+    # Create a temporary ignore file with our ignore patterns
+    ignore_file = None
+    try:
+        # Use ripgrep to search for the string
+        # Use absolute path to ensure it works from any directory
+        # --json for structured output
+        # --max-count 50 to limit results
+        # --max-filesize 5M to avoid huge files (increased from 1M)
+        # --type=all to search across all recognized text file types
+        # --ignore-file to obey our ignore list
+        
+        # Find ripgrep executable - first check system PATH, then virtual environment
+        rg_path = shutil.which("rg")
+        if not rg_path:
+            # Try to find it in the virtual environment
+            # Use sys.executable to determine the Python environment path
+            python_dir = os.path.dirname(sys.executable)
+            # Check both 'bin' (Unix) and 'Scripts' (Windows) directories
+            for rg_dir in ["bin", "Scripts"]:
+                venv_rg_path = os.path.join(python_dir, "rg")
+                if os.path.exists(venv_rg_path):
+                    rg_path = venv_rg_path
+                    break
+                # Also check with .exe extension for Windows
+                venv_rg_exe_path = os.path.join(python_dir, "rg.exe")
+                if os.path.exists(venv_rg_exe_path):
+                    rg_path = venv_rg_exe_path
+                    break
+        
+        if not rg_path:
+            emit_error(f"ripgrep (rg) not found. Please install ripgrep to use this tool.", message_group=group_id)
+            return GrepOutput(matches=[])
+            
+        cmd = [rg_path, "--json", "--max-count", "50", "--max-filesize", "5M", "--type=all"]
+        
+        # Add ignore patterns to the command via a temporary file
+        from code_puppy.tools.common import IGNORE_PATTERNS
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.ignore') as f:
+            ignore_file = f.name
+            for pattern in IGNORE_PATTERNS:
+                f.write(f"{pattern}\n")
+        
+        cmd.extend(["--ignore-file", ignore_file])
+        cmd.extend([search_string, directory])
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        
+        # Parse the JSON output from ripgrep
+        for line in result.stdout.strip().split('\n'):
+            if not line:
                 continue
-
             try:
-                with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
-                    for line_number, line_content in enumerate(fh, 1):
-                        if search_string in line_content:
-                            match_info = MatchInfo(
-                                **{
-                                    "file_path": file_path,
-                                    "line_number": line_number,
-                                    "line_content": line_content.rstrip("\n\r")[512:],
-                                }
-                            )
-                            matches.append(match_info)
-                            emit_system_message(
-                                f"[green]Match:[/green] {file_path}:{line_number} - {line_content.strip()}",
-                                message_group=group_id,
-                            )
-                            if len(matches) >= 50:
-                                emit_warning(
-                                    "Limit of 50 matches reached. Stopping search.",
-                                    message_group=group_id,
-                                )
-                                return GrepOutput(matches=matches)
-            except FileNotFoundError:
-                emit_warning(
-                    f"File not found (possibly a broken symlink): {file_path}",
-                    message_group=group_id,
-                )
-                continue
-            except UnicodeDecodeError:
-                emit_warning(
-                    f"Cannot decode file (likely binary): {file_path}",
-                    message_group=group_id,
-                )
+                match_data = json.loads(line)
+                # Only process match events, not context or summary
+                if match_data.get('type') == 'match':
+                    data = match_data.get('data', {})
+                    path_data = data.get('path', {})
+                    file_path = path_data.get('text', '') if path_data.get('text') else ''
+                    line_number = data.get('line_number', None)
+                    line_content = data.get('lines', {}).get('text', '') if data.get('lines', {}).get('text') else ''
+                    
+                    if file_path and line_number:
+                        match_info = MatchInfo(
+                            file_path=file_path,
+                            line_number=line_number,
+                            line_content=line_content.strip()
+                        )
+                        matches.append(match_info)
+                        # Limit to 50 matches total, same as original implementation
+                        if len(matches) >= 50:
+                            break
+                        emit_system_message(
+                            f"[green]Match:[/green] {file_path}:{line_number} - {line_content.strip()}",
+                            message_group=group_id,
+                        )
+            except json.JSONDecodeError:
+                # Skip lines that aren't valid JSON
                 continue
-            except Exception as e:
-                emit_error(
-                    f"Error processing file {file_path}: {e}", message_group=group_id
-                )
-                continue
-
-    if not matches:
-        emit_warning(
-            f"No matches found for '{search_string}' in {directory}",
-            message_group=group_id,
-        )
-    else:
-        emit_success(
-            f"Found {len(matches)} match(es) for '{search_string}' in {directory}",
-            message_group=group_id,
-        )
-
+                
+        if not matches:
+            emit_warning(
+                f"No matches found for '{search_string}' in {directory}",
+                message_group=group_id,
+            )
+        else:
+            emit_success(
+                f"Found {len(matches)} match(es) for '{search_string}' in {directory}",
+                message_group=group_id,
+            )
+            
+    except subprocess.TimeoutExpired:
+        emit_error(f"Grep command timed out after 30 seconds", message_group=group_id)
+    except FileNotFoundError:
+        emit_error(f"ripgrep (rg) not found. Please install ripgrep to use this tool.", message_group=group_id)
+    except Exception as e:
+        emit_error(f"Error during grep operation: {e}", message_group=group_id)
+    finally:
+        # Clean up the temporary ignore file
+        if ignore_file and os.path.exists(ignore_file):
+            os.unlink(ignore_file)
+        
     return GrepOutput(matches=matches)
 
 
@@ -590,17 +636,22 @@ def register_grep(agent):
     def grep(
         context: RunContext, search_string: str = "", directory: str = "."
     ) -> GrepOutput:
-        """Recursively search for text patterns across files with intelligent filtering.
+        """Recursively search for text patterns across files using ripgrep (rg).
 
-        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.
+        This tool leverages the high-performance ripgrep utility for fast text 
+        searching across directory trees. It searches across all recognized text file
+        types (Python, JavaScript, HTML, CSS, Markdown, etc.) while automatically 
+        filtering binary files and limiting results for performance.
+
+        The search_string parameter supports ripgrep's full flag syntax, allowing
+        advanced searches including regex patterns, case-insensitive matching,
+        and other ripgrep features.
 
         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.
+            search_string (str): The text pattern to search for. Can include ripgrep
+                flags like '--ignore-case', '-w' (word boundaries), etc.
+                Cannot be empty.
             directory (str, optional): Root directory to start the recursive search.
                 Can be relative or absolute. Defaults to "." (current directory).
 
@@ -613,23 +664,23 @@ def register_grep(agent):
                   - line_content (str | None): Full line content containing the match
 
         Examples:
-            >>> # Search for function definitions
+            >>> # Simple text search
             >>> 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")
+            >>> # Case-insensitive search
+            >>> result = grep(ctx, "--ignore-case 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}
+            >>> # Word boundary search (regex)
+            >>> result = grep(ctx, "-w \\w+State\\b")
+            >>> files_with_state = {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
+            - Leverage ripgrep's powerful regex and flag features for advanced searches
+            - ripgrep is much faster than naive implementations
+            - Results are capped at 50 matches for performance
         """
         return _grep(context, search_string, directory)

{code_puppy-0.0.150 → code_puppy-0.0.152}/code_puppy/tools/tools_content.py

@@ -12,7 +12,7 @@ Woof! 🐶 Here's my complete toolkit! I'm like a Swiss Army knife but way more
 - **`delete_file(file_path)`** - Remove files when needed (use with caution!)
 
 # **Search & Analysis**
-- **`grep(search_string, directory)`** - Search for text across files recursively (up to 200 matches)
+- **`grep(search_string, directory)`** - Search for text across files recursively using ripgrep (rg) for high-performance searching (up to 200 matches). Searches across all text file types, not just Python files. Supports ripgrep flags in the search string.
 
 # 💻 **System Operations**
 - **`agent_run_shell_command(command, cwd, timeout)`** - Execute shell commands with full output capture (stdout, stderr, exit codes)

{code_puppy-0.0.150 → code_puppy-0.0.152}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.150"
+version = "0.0.152"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,7 +32,7 @@ dependencies = [
     "termcolor>=3.1.0",
     "textual-dev>=1.7.0",
     "openai>=1.99.1",
-
+    "ripgrep>=14.1.0",
 ]
 dev-dependencies = [
     "pytest>=8.3.4",