ripperdoc 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

ripperdoc/tools/grep_tool.py

@@ -4,7 +4,10 @@ Allows the AI to search for patterns in files.
 """
 
 import asyncio
-from typing import AsyncGenerator, Optional, List
+import re
+import shutil
+import subprocess
+from typing import AsyncGenerator, Optional, List, Tuple
 from pydantic import BaseModel, Field
 
 from ripperdoc.core.tool import (
@@ -19,6 +22,8 @@ from ripperdoc.utils.log import get_logger
 
 logger = get_logger()
 
+MAX_GREP_OUTPUT_CHARS = 20000
+
 
 GREP_USAGE = (
     "A powerful search tool built on ripgrep.\n\n"
@@ -27,11 +32,52 @@ GREP_USAGE = (
     '- Supports regex patterns (e.g., "log.*Error", "function\\s+\\w+")\n'
     '- Filter files with the glob parameter (e.g., "*.js", "**/*.tsx")\n'
     '- Output modes: "content" shows matching lines, "files_with_matches" (default) shows only file paths, "count" shows match counts\n'
+    "- Use head_limit to cap the number of returned entries (similar to piping through head -N) to avoid overwhelming output\n"
+    f"- Outputs are automatically truncated to around {MAX_GREP_OUTPUT_CHARS} characters to stay within context limits; narrow patterns for more detail\n"
     "- For open-ended searches that need multiple rounds, iterate with Glob and Grep rather than shell commands\n"
     "- Patterns are line-based; craft patterns accordingly and escape braces if needed (e.g., use `interface\\{\\}` to find `interface{}`)"
 )
 
 
+def truncate_with_ellipsis(
+    text: str, max_chars: int = MAX_GREP_OUTPUT_CHARS
+) -> Tuple[str, bool, int]:
+    """Trim long output and note how many lines were removed."""
+    if len(text) <= max_chars:
+        return text, False, 0
+
+    remaining = text[max_chars:]
+    truncated_lines = remaining.count("\n") + (1 if remaining else 0)
+    truncated_text = f"{text[:max_chars]}\n\n... [{truncated_lines} lines truncated] ..."
+    return truncated_text, True, truncated_lines
+
+
+def apply_head_limit(lines: List[str], head_limit: Optional[int]) -> Tuple[List[str], int]:
+    """Limit the number of lines returned, recording how many were omitted."""
+    if head_limit is None or head_limit <= 0:
+        return lines, 0
+    if len(lines) <= head_limit:
+        return lines, 0
+    return lines[:head_limit], len(lines) - head_limit
+
+
+def _split_globs(glob_value: str) -> List[str]:
+    """Split a glob string by whitespace and commas."""
+    if not glob_value:
+        return []
+    globs: List[str] = []
+    for token in re.split(r"\s+", glob_value.strip()):
+        if not token:
+            continue
+        globs.extend([part for part in token.split(",") if part])
+    return globs
+
+
+def _normalize_glob_for_grep(glob_pattern: str) -> str:
+    """grep --include matches basenames; drop path components to avoid mismatches like **/*.py."""
+    return glob_pattern.split("/")[-1] or glob_pattern
+
+
 class GrepToolInput(BaseModel):
     """Input schema for GrepTool."""
 
@@ -45,6 +91,10 @@ class GrepToolInput(BaseModel):
         default="files_with_matches",
         description="Output mode: 'files_with_matches', 'content', or 'count'",
     )
+    head_limit: Optional[int] = Field(
+        default=None,
+        description="Limit output to the first N results (similar to piping to head -N) to avoid huge responses.",
+    )
 
 
 class GrepMatch(BaseModel):
@@ -63,6 +113,9 @@ class GrepToolOutput(BaseModel):
     pattern: str
     total_files: int
     total_matches: int
+    output_mode: str = "files_with_matches"
+    head_limit: Optional[int] = None
+    omitted_results: int = 0
 
 
 class GrepTool(Tool[GrepToolInput, GrepToolOutput]):
@@ -95,7 +148,7 @@ class GrepTool(Tool[GrepToolInput, GrepToolOutput]):
             ),
         ]
 
-    async def prompt(self, safe_mode: bool = False) -> str:
+    async def prompt(self, _safe_mode: bool = False) -> str:
         return GREP_USAGE
 
     def is_read_only(self) -> bool:
@@ -104,72 +157,133 @@ class GrepTool(Tool[GrepToolInput, GrepToolOutput]):
     def is_concurrency_safe(self) -> bool:
         return True
 
-    def needs_permissions(self, input_data: Optional[GrepToolInput] = None) -> bool:
+    def needs_permissions(self, _input_data: Optional[GrepToolInput] = None) -> bool:
         return False
 
     async def validate_input(
-        self, input_data: GrepToolInput, context: Optional[ToolUseContext] = None
+        self, input_data: GrepToolInput, _context: Optional[ToolUseContext] = None
     ) -> ValidationResult:
         valid_modes = ["files_with_matches", "content", "count"]
         if input_data.output_mode not in valid_modes:
             return ValidationResult(
                 result=False, message=f"Invalid output_mode. Must be one of: {valid_modes}"
             )
+        if input_data.head_limit is not None and input_data.head_limit <= 0:
+            return ValidationResult(result=False, message="head_limit must be positive")
         return ValidationResult(result=True)
 
     def render_result_for_assistant(self, output: GrepToolOutput) -> str:
         """Format output for the AI."""
-        if output.total_files == 0:
+        if output.total_files == 0 or output.total_matches == 0:
             return f"No matches found for pattern: {output.pattern}"
 
-        result = f"Found {output.total_matches} match(es) in {output.total_files} file(s) for '{output.pattern}':\n\n"
+        lines: List[str] = []
+        summary: str
 
-        for match in output.matches[:100]:  # Limit to first 100
-            if match.content:
-                result += f"{match.file}:{match.line_number}: {match.content}\n"
-            elif match.count:
-                result += f"{match.file}: {match.count} matches\n"
-            else:
-                result += f"{match.file}\n"
+        if output.output_mode == "files_with_matches":
+            summary = f"Found {output.total_files} file(s) matching '{output.pattern}'."
+            lines = [match.file for match in output.matches if match.file]
+        elif output.output_mode == "count":
+            summary = (
+                f"Found {output.total_matches} total match(es) across {output.total_files} file(s) "
+                f"for '{output.pattern}'."
+            )
+            lines = [
+                f"{match.file}: {match.count if match.count is not None else 0}"
+                for match in output.matches
+                if match.file
+            ]
+        else:
+            summary = (
+                f"Found {output.total_matches} match(es) in {output.total_files} file(s) "
+                f"for '{output.pattern}':"
+            )
+            for match in output.matches:
+                if match.content is None:
+                    continue
+                line_number = f":{match.line_number}" if match.line_number is not None else ""
+                lines.append(f"{match.file}{line_number}: {match.content}")
+
+        if output.omitted_results:
+            lines.append(
+                f"... and {output.omitted_results} more result(s) not shown"
+                f"{' (use head_limit to control output size)' if output.head_limit else ''}"
+            )
 
-        if len(output.matches) > 100:
-            result += f"\n... and {len(output.matches) - 100} more matches"
+        result = summary
+        if lines:
+            result += "\n\n" + "\n".join(lines)
 
-        return result
+        truncated_result, did_truncate, _ = truncate_with_ellipsis(result)
+        if did_truncate:
+            truncated_result += (
+                "\n(Output truncated; refine the pattern or lower head_limit for more detail.)"
+            )
+        return truncated_result
 
-    def render_tool_use_message(self, input_data: GrepToolInput, verbose: bool = False) -> str:
+    def render_tool_use_message(self, input_data: GrepToolInput, _verbose: bool = False) -> str:
         """Format the tool use for display."""
         msg = f"Grep: {input_data.pattern}"
         if input_data.glob:
             msg += f" in {input_data.glob}"
+        if input_data.head_limit:
+            msg += f" (head_limit={input_data.head_limit})"
         return msg
 
     async def call(
-        self, input_data: GrepToolInput, context: ToolUseContext
+        self, input_data: GrepToolInput, _context: ToolUseContext
     ) -> AsyncGenerator[ToolOutput, None]:
         """Search for the pattern."""
 
         try:
             search_path = input_data.path or "."
 
-            # Build grep command
-            cmd = ["grep", "-r"]
+            use_ripgrep = shutil.which("rg") is not None
+            pattern = input_data.pattern
+
+            if use_ripgrep:
+                cmd = ["rg", "--color", "never"]
+                if input_data.case_insensitive:
+                    cmd.append("-i")
+                if input_data.output_mode == "files_with_matches":
+                    cmd.append("-l")
+                elif input_data.output_mode == "count":
+                    cmd.append("-c")
+                else:
+                    cmd.append("-n")
+
+                for glob_pattern in _split_globs(input_data.glob or ""):
+                    cmd.extend(["--glob", glob_pattern])
+
+                if pattern.startswith("-"):
+                    cmd.extend(["-e", pattern])
+                else:
+                    cmd.append(pattern)
+
+                cmd.append(search_path)
+            else:
+                # Fallback to grep (note: grep --include matches basenames only)
+                cmd = ["grep", "-r", "--color=never", "-P"]
 
-            if input_data.case_insensitive:
-                cmd.append("-i")
+                if input_data.case_insensitive:
+                    cmd.append("-i")
 
-            if input_data.output_mode == "files_with_matches":
-                cmd.extend(["-l"])  # Files with matches
-            elif input_data.output_mode == "count":
-                cmd.extend(["-c"])  # Count per file
-            else:
-                cmd.extend(["-n"])  # Line numbers
+                if input_data.output_mode == "files_with_matches":
+                    cmd.extend(["-l"])  # Files with matches
+                elif input_data.output_mode == "count":
+                    cmd.extend(["-c"])  # Count per file
+                else:
+                    cmd.extend(["-n"])  # Line numbers
 
-            cmd.append(input_data.pattern)
-            cmd.append(search_path)
+                for glob_pattern in _split_globs(input_data.glob or ""):
+                    cmd.extend(["--include", _normalize_glob_for_grep(glob_pattern)])
 
-            if input_data.glob:
-                cmd.extend(["--include", input_data.glob])
+                if pattern.startswith("-"):
+                    cmd.extend(["-e", pattern])
+                else:
+                    cmd.append(pattern)
+
+                cmd.append(search_path)
 
             # Run grep asynchronously
             process = await asyncio.create_subprocess_exec(
@@ -181,19 +295,30 @@ class GrepTool(Tool[GrepToolInput, GrepToolOutput]):
 
             # Parse output
             matches: List[GrepMatch] = []
+            total_matches = 0
+            total_files = 0
+            omitted_results = 0
+            stdout_text = stdout.decode("utf-8", errors="ignore") if stdout else ""
+            lines = [line for line in stdout_text.split("\n") if line]
+
+            if returncode in (0, 1):  # 0 = matches found, 1 = no matches (ripgrep/grep)
+                display_lines, omitted_results = apply_head_limit(lines, input_data.head_limit)
+
+                if input_data.output_mode == "files_with_matches":
+                    total_files = len(set(lines))
+                    total_matches = len(lines)
+                    matches = [GrepMatch(file=line) for line in display_lines]
+
+                elif input_data.output_mode == "count":
+                    total_files = len(set(line.split(":", 1)[0] for line in lines if line))
+                    total_match_count = 0
+                    for line in lines:
+                        parts = line.rsplit(":", 1)
+                        if len(parts) == 2 and parts[1].isdigit():
+                            total_match_count += int(parts[1])
+                    total_matches = total_match_count
 
-            if returncode == 0:
-                lines = stdout.decode("utf-8").strip().split("\n")
-
-                for line in lines:
-                    if not line:
-                        continue
-
-                    if input_data.output_mode == "files_with_matches":
-                        matches.append(GrepMatch(file=line))
-
-                    elif input_data.output_mode == "count":
-                        # Format: file:count
+                    for line in display_lines:
                         parts = line.rsplit(":", 1)
                         if len(parts) == 2:
                             matches.append(
@@ -202,8 +327,10 @@ class GrepTool(Tool[GrepToolInput, GrepToolOutput]):
                                 )
                             )
 
-                    else:  # content mode
-                        # Format: file:line:content
+                else:  # content mode
+                    total_files = len({line.split(":", 1)[0] for line in lines if line})
+                    total_matches = len(lines)
+                    for line in display_lines:
                         parts = line.split(":", 2)
                         if len(parts) >= 3:
                             matches.append(
@@ -217,17 +344,21 @@ class GrepTool(Tool[GrepToolInput, GrepToolOutput]):
             output = GrepToolOutput(
                 matches=matches,
                 pattern=input_data.pattern,
-                total_files=len(set(m.file for m in matches)),
-                total_matches=len(matches),
+                total_files=total_files,
+                total_matches=total_matches,
+                output_mode=input_data.output_mode,
+                head_limit=input_data.head_limit,
+                omitted_results=omitted_results,
             )
 
             yield ToolResult(
                 data=output, result_for_assistant=self.render_result_for_assistant(output)
             )
 
-        except Exception as e:
-            logger.exception(
-                "[grep_tool] Error executing grep",
+        except (OSError, RuntimeError, ValueError, subprocess.SubprocessError) as e:
+            logger.warning(
+                "[grep_tool] Error executing grep: %s: %s",
+                type(e).__name__, e,
                 extra={"pattern": input_data.pattern, "path": input_data.path},
             )
             error_output = GrepToolOutput(

ripperdoc/tools/ls_tool.py

@@ -119,7 +119,7 @@ def _resolve_directory_path(raw_path: str) -> Path:
         candidate = base_path / candidate
     try:
         return candidate.resolve()
-    except Exception:
+    except (OSError, RuntimeError):
         return candidate
 
 
@@ -166,15 +166,15 @@ def _relative_path_for_display(path: Path, base_path: Path) -> str:
     resolved_path = path
     try:
         resolved_path = path.resolve()
-    except Exception:
+    except (OSError, RuntimeError):
         pass
 
     try:
         rel_path = resolved_path.relative_to(base_path.resolve()).as_posix()
-    except Exception:
+    except (OSError, ValueError, RuntimeError):
         try:
             rel_path = os.path.relpath(resolved_path, base_path)
-        except Exception:
+        except (OSError, ValueError):
             rel_path = resolved_path.as_posix()
         rel_path = rel_path.replace(os.sep, "/")
 
@@ -345,7 +345,7 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
     ) -> ValidationResult:
         try:
             root_path = _resolve_directory_path(input_data.path)
-        except Exception:
+        except (OSError, RuntimeError, ValueError):
             return ValidationResult(
                 result=False, message=f"Unable to resolve path: {input_data.path}"
             )
@@ -397,7 +397,7 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
             relative_path = (
                 _relative_path_for_display(resolved_path, base_path) or resolved_path.as_posix()
             )
-        except Exception:
+        except (OSError, RuntimeError, ValueError):
             relative_path = str(resolved_path)
 
         return relative_path