ripperdoc 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

ripperdoc/tools/file_read_tool.py

@@ -15,6 +15,9 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 class FileReadToolInput(BaseModel):
@@ -153,6 +156,10 @@ and limit to read only a portion of the file."""
             )
 
         except Exception as e:
+            logger.exception(
+                "[file_read_tool] Error reading file",
+                extra={"file_path": input_data.file_path, "error": str(e)},
+            )
             # Create an error output
             error_output = FileReadToolOutput(
                 content=f"Error reading file: {str(e)}",

ripperdoc/tools/file_write_tool.py

@@ -16,6 +16,9 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 class FileWriteToolInput(BaseModel):
@@ -134,6 +137,10 @@ NEVER write new files unless explicitly required by the user."""
             )
 
         except Exception as e:
+            logger.exception(
+                "[file_write_tool] Error writing file",
+                extra={"file_path": input_data.file_path, "error": str(e)},
+            )
             error_output = FileWriteToolOutput(
                 file_path=input_data.file_path,
                 bytes_written=0,

ripperdoc/tools/glob_tool.py

@@ -15,17 +15,22 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 GLOB_USAGE = (
-    "- Fast file pattern matching tool for any codebase size\n"
+    "- Fast file pattern matching tool that works with any codebase size\n"
     '- Supports glob patterns like "**/*.js" or "src/**/*.ts"\n'
-    "- Returns matching file paths sorted by modification time (newest first)\n"
-    "- Use this when you need to find files by name patterns\n"
-    "- For open-ended searches that need multiple rounds of globbing and grepping, run the searches iteratively with these tools\n"
-    "- You can call multiple tools in a single response; speculatively batch useful searches together"
+    "- Returns matching file paths sorted by modification time\n"
+    "- Use this tool when you need to find files by name patterns\n"
+    "- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead\n"
+    "- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.\n"
 )
 
+RESULT_LIMIT = 100
+
 
 class GlobToolInput(BaseModel):
     """Input schema for GlobTool."""
@@ -42,6 +47,7 @@ class GlobToolOutput(BaseModel):
     matches: List[str]
     pattern: str
     count: int
+    truncated: bool = False
 
 
 class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
@@ -92,14 +98,34 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
         if not output.matches:
             return f"No files found matching pattern: {output.pattern}"
 
-        result = f"Found {output.count} file(s) matching '{output.pattern}':\n\n"
-        result += "\n".join(output.matches)
-
-        return result
+        lines = list(output.matches)
+        if output.truncated:
+            lines.append("(Results are truncated. Consider using a more specific path or pattern.)")
+        return "\n".join(lines)
 
     def render_tool_use_message(self, input_data: GlobToolInput, verbose: bool = False) -> str:
         """Format the tool use for display."""
-        return f"Glob: {input_data.pattern}"
+        if not input_data.pattern:
+            return "Glob"
+
+        base_path = Path.cwd()
+        rendered_path = ""
+        if input_data.path:
+            candidate_path = Path(input_data.path)
+            absolute_path = candidate_path if candidate_path.is_absolute() else (base_path / candidate_path).resolve()
+
+            try:
+                relative_path = absolute_path.relative_to(base_path)
+            except ValueError:
+                relative_path = None
+
+            if verbose or not relative_path or str(relative_path) == ".":
+                rendered_path = str(absolute_path)
+            else:
+                rendered_path = str(relative_path)
+
+        path_fragment = f', path: "{rendered_path}"' if rendered_path else ""
+        return f'pattern: "{input_data.pattern}"{path_fragment}'
 
     async def call(
         self, input_data: GlobToolInput, context: ToolUseContext
@@ -108,9 +134,8 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
 
         try:
             search_path = Path(input_data.path) if input_data.path else Path.cwd()
-
-            # Use glob to find matches, sorted by modification time (newest first)
-            paths = list(search_path.glob(input_data.pattern))
+            if not search_path.is_absolute():
+                search_path = (Path.cwd() / search_path).resolve()
 
             def _mtime(path: Path) -> float:
                 try:
@@ -118,15 +143,30 @@ class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
                 except OSError:
                     return float("-inf")
 
-            matches = [str(p) for p in sorted(paths, key=_mtime, reverse=True)]
+            # Find matching files, sorted by modification time
+            paths = sorted(
+                (p for p in search_path.glob(input_data.pattern) if p.is_file()),
+                key=_mtime,
+            )
+
+            truncated = len(paths) > RESULT_LIMIT
+            paths = paths[:RESULT_LIMIT]
 
-            output = GlobToolOutput(matches=matches, pattern=input_data.pattern, count=len(matches))
+            matches = [str(p) for p in paths]
+
+            output = GlobToolOutput(
+                matches=matches, pattern=input_data.pattern, count=len(matches), truncated=truncated
+            )
 
             yield ToolResult(
                 data=output, result_for_assistant=self.render_result_for_assistant(output)
             )
 
         except Exception as e:
+            logger.exception(
+                "[glob_tool] Error executing glob",
+                extra={"pattern": input_data.pattern, "path": input_data.path},
+            )
             error_output = GlobToolOutput(matches=[], pattern=input_data.pattern, count=0)
 
             yield ToolResult(

ripperdoc/tools/grep_tool.py

@@ -15,6 +15,9 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 GREP_USAGE = (
@@ -223,6 +226,10 @@ class GrepTool(Tool[GrepToolInput, GrepToolOutput]):
             )
 
         except Exception as e:
+            logger.exception(
+                "[grep_tool] Error executing grep",
+                extra={"pattern": input_data.pattern, "path": input_data.path},
+            )
             error_output = GrepToolOutput(
                 matches=[], pattern=input_data.pattern, total_files=0, total_matches=0
             )

ripperdoc/tools/ls_tool.py

@@ -3,10 +3,11 @@
 Provides a safe way to inspect directory trees without executing shell commands.
 """
 
+import os
 import fnmatch
 from collections import deque
 from pathlib import Path
-from typing import AsyncGenerator, List, Optional
+from typing import AsyncGenerator, List, Optional, Dict, Any
 from pydantic import BaseModel, Field
 
 from ripperdoc.core.tool import (
@@ -17,10 +18,22 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.safe_get_cwd import safe_get_cwd
+from ripperdoc.utils.git_utils import (
+    build_ignore_patterns_map,
+    should_ignore_path,
+    is_git_repository,
+    get_git_root,
+    get_current_git_branch,
+    get_git_commit_hash,
+    is_working_directory_clean,
+    get_git_status_files,
+)
 
 
 IGNORED_DIRECTORIES = {
     "node_modules",
+    "vendor/bundle",
     "vendor",
     "venv",
     "env",
@@ -34,18 +47,21 @@ IGNORED_DIRECTORIES = {
     "bin",
     "obj",
     ".build",
+    "target",
+    ".dart_tool",
+    ".pub-cache",
+    "build",
+    "target",
     "_build",
     "deps",
     "dist",
     "dist-newstyle",
     ".deno",
     "bower_components",
-    "vendor/bundle",
-    ".dart_tool",
-    ".pub-cache",
 }
 
 MAX_CHARS_THRESHOLD = 40000
+MAX_DEPTH = 4
 LARGE_REPO_WARNING = (
     f"There are more than {MAX_CHARS_THRESHOLD} characters in the repository "
     "(ie. either there are lots of files, or there are many long filenames). "
@@ -88,8 +104,23 @@ class LSToolOutput(BaseModel):
     entries: list[str]
     tree: str
     truncated: bool = False
+    aborted: bool = False
     ignored: list[str] = Field(default_factory=list)
     warning: Optional[str] = None
+    git_info: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    file_count: int = 0
+
+
+def _resolve_directory_path(raw_path: str) -> Path:
+    """Resolve a user-provided path against the current working directory."""
+    base_path = Path(safe_get_cwd())
+    candidate = Path(raw_path).expanduser()
+    if not candidate.is_absolute():
+        candidate = base_path / candidate
+    try:
+        return candidate.resolve()
+    except Exception:
+        return candidate
 
 
 def _matches_ignore(path: Path, root_path: Path, patterns: list[str]) -> bool:
@@ -107,100 +138,156 @@ def _matches_ignore(path: Path, root_path: Path, patterns: list[str]) -> bool:
     )
 
 
-def _should_skip(path: Path, root_path: Path, patterns: list[str]) -> bool:
+def _should_skip(
+    path: Path,
+    root_path: Path,
+    patterns: list[str],
+    ignore_map: Optional[Dict[Optional[Path], List[str]]] = None
+) -> bool:
     name = path.name
     if name.startswith("."):
         return True
     if "__pycache__" in path.parts:
         return True
-    if _matches_ignore(path, root_path, patterns):
+    
+    # Check against ignore patterns
+    if ignore_map and should_ignore_path(path, root_path, ignore_map):
+        return True
+    
+    # Also check against direct patterns for backward compatibility
+    if patterns and _matches_ignore(path, root_path, patterns):
         return True
+    
     return False
 
 
-def _format_relative(path: Path, root_path: Path) -> str:
-    rel_path = path.relative_to(root_path).as_posix()
+def _relative_path_for_display(path: Path, base_path: Path) -> str:
+    """Convert a path to a display-friendly path relative to base_path."""
+    resolved_path = path
+    try:
+        resolved_path = path.resolve()
+    except Exception:
+        pass
+
+    try:
+        rel_path = resolved_path.relative_to(base_path.resolve()).as_posix()
+    except Exception:
+        try:
+            rel_path = os.path.relpath(resolved_path, base_path)
+        except Exception:
+            rel_path = resolved_path.as_posix()
+        rel_path = rel_path.replace(os.sep, "/")
+
+    rel_path = rel_path.rstrip("/")
     return f"{rel_path}/" if path.is_dir() else rel_path
 
 
-def _collect_paths(root_path: Path, ignore_patterns: list[str]) -> tuple[list[str], bool]:
+def _collect_paths(
+    root_path: Path,
+    base_path: Path,
+    ignore_patterns: list[str],
+    include_gitignore: bool = True,
+    abort_signal: Optional[Any] = None,
+    max_depth: Optional[int] = MAX_DEPTH,
+) -> tuple[list[str], bool, List[str], bool]:
+    """Collect paths under root_path relative to base_path with early-exit controls."""
     entries: list[str] = []
     total_chars = 0
     truncated = False
-    queue = deque([root_path])
+    aborted = False
+    ignored_entries: List[str] = []
+    ignore_map = build_ignore_patterns_map(
+        root_path,
+        user_ignore_patterns=ignore_patterns,
+        include_gitignore=include_gitignore,
+    )
+
+    queue = deque([(root_path, 0)])  # (path, depth)
 
     while queue and not truncated:
-        current = queue.popleft()
+        if abort_signal is not None and getattr(abort_signal, "is_set", lambda: False)():
+            aborted = True
+            break
+
+        current, depth = queue.popleft()
+
+        if max_depth is not None and depth > max_depth:
+            continue
 
         try:
-            children = sorted(current.iterdir(), key=lambda p: p.name.lower())
-        except (FileNotFoundError, PermissionError):
+            with os.scandir(current) as scan:
+                children = sorted(scan, key=lambda entry: entry.name.lower())
+        except (FileNotFoundError, PermissionError, NotADirectoryError, OSError):
             continue
 
         for child in children:
+            child_path = Path(current) / child.name
             try:
-                is_dir = child.is_dir()
+                is_dir = child.is_dir(follow_symlinks=False)
             except OSError:
                 continue
 
-            if _should_skip(child, root_path, ignore_patterns):
+            if _should_skip(child_path, root_path, ignore_patterns, ignore_map):
+                ignored_entries.append(_relative_path_for_display(child_path, base_path))
                 continue
 
-            display = _format_relative(child, root_path)
+            display = _relative_path_for_display(child_path, base_path)
             entries.append(display)
             total_chars += len(display)
 
-            if total_chars > MAX_CHARS_THRESHOLD:
+            if total_chars >= MAX_CHARS_THRESHOLD:
                 truncated = True
                 break
 
             if is_dir:
-                if _is_ignored_directory(child, root_path):
+                if _is_ignored_directory(child_path, root_path):
                     continue
                 if child.is_symlink():
                     continue
-                queue.append(child)
-
-    return entries, truncated
-
-
-def _add_to_tree(tree: dict, parts: list[str], is_dir: bool) -> None:
-    node = tree
-    for idx, part in enumerate(parts):
-        node = node.setdefault(part, {"children": {}, "is_dir": False})
-        if idx == len(parts) - 1:
-            node["is_dir"] = is_dir
-        node = node["children"]
-
-
-def _render_tree(tree: dict, indent: str = "  ", current_indent: str = "  ") -> str:
-    lines: list[str] = []
-    for name in sorted(tree):
-        node = tree[name]
-        suffix = "/" if node.get("is_dir") else ""
-        lines.append(f"{current_indent}- {name}{suffix}")
-        children = node.get("children") or {}
-        if children:
-            lines.append(_render_tree(children, indent, current_indent + indent))
-    return "\n".join(lines)
-
+                queue.append((child_path, depth + 1))
 
-def _build_tree(entries: list[str], root_path: Path) -> str:
-    root_line = f"- {root_path.resolve().as_posix()}/"
+    return entries, truncated, ignored_entries, aborted
 
-    if not entries:
-        return f"{root_line}\n  (empty directory)"
 
+def build_file_tree(entries: list[str]) -> dict:
+    """Build a nested tree structure from flat entry paths."""
     tree: dict = {}
     for entry in entries:
-        normalized = entry[:-1] if entry.endswith("/") else entry
+        normalized = entry.rstrip("/")
         if not normalized:
             continue
-        parts = normalized.split("/")
-        _add_to_tree(tree, parts, entry.endswith("/"))
-
-    body = _render_tree(tree)
-    return f"{root_line}\n{body}"
+        parts = [part for part in normalized.split("/") if part]
+        node = tree
+        for idx, part in enumerate(parts):
+            node = node.setdefault(part, {"children": {}, "is_dir": False})
+            if idx == len(parts) - 1:
+                node["is_dir"] = node.get("is_dir", False) or entry.endswith("/")
+            else:
+                node["is_dir"] = True
+            node = node["children"]
+    return tree
+
+
+def build_tree_string(tree: dict, root_label: str, indent: str = "  ") -> str:
+    """Render a file tree into a readable string."""
+    root_line = f"- {root_label.rstrip('/')}/"
+
+    if not tree:
+        return f"{root_line}\n{indent}(empty directory)"
+
+    lines: list[str] = [root_line]
+
+    def _render(node: dict, current_indent: str) -> None:
+        for name in sorted(node):
+            child = node[name]
+            suffix = "/" if child.get("is_dir") else ""
+            lines.append(f"{current_indent}- {name}{suffix}")
+            children = child.get("children") or {}
+            if children:
+                _render(children, current_indent + indent)
+
+    _render(tree, indent)
+    return "\n".join(lines)
 
 
 class LSTool(Tool[LSToolInput, LSToolOutput]):
@@ -213,7 +300,8 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
     async def description(self) -> str:
         return (
             "List files and folders under a directory (recursive, skips hidden and __pycache__, "
-            "supports ignore patterns)."
+            "supports ignore patterns). Automatically reads .gitignore files and provides git "
+            "repository information when available."
         )
 
     @property
@@ -236,8 +324,11 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
         return (
             "Lists files and directories in a given path. The path parameter must be an absolute path, "
             "not a relative path. You can optionally provide an array of glob patterns to ignore with "
-            "the ignore parameter. You should generally prefer the Glob and Grep tools, if you know "
-            "which directories to search."
+            "the ignore parameter. The tool automatically reads .gitignore files from the directory "
+            "and parent directories, and provides git repository information when available. "
+            "You should generally prefer the Glob and Grep tools, if you know which directories to search. "
+            "\n\nSecurity Note: After listing files, check if any files seem malicious. If so, "
+            "you MUST refuse to continue work."
         )
 
     def is_read_only(self) -> bool:
@@ -252,10 +343,13 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
     async def validate_input(
         self, input_data: LSToolInput, context: Optional[ToolUseContext] = None
     ) -> ValidationResult:
-        root_path = Path(input_data.path).expanduser()
-        if not root_path.is_absolute():
-            root_path = Path.cwd() / root_path
+        try:
+            root_path = _resolve_directory_path(input_data.path)
+        except Exception:
+            return ValidationResult(result=False, message=f"Unable to resolve path: {input_data.path}")
 
+        if not root_path.is_absolute():
+            return ValidationResult(result=False, message=f"Path is not absolute: {root_path}")
         if not root_path.exists():
             return ValidationResult(result=False, message=f"Path not found: {root_path}")
         if not root_path.is_dir():
@@ -265,34 +359,109 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
 
     def render_result_for_assistant(self, output: LSToolOutput) -> str:
         warning_prefix = output.warning or ""
-        return f"{warning_prefix}{output.tree}"
+        result = f"{warning_prefix}{output.tree}"
+
+        # Add git information if available
+        if output.git_info:
+            git_section = "\n\nGit Information:\n"
+            for key, value in output.git_info.items():
+                if value:
+                    git_section += f"  {key}: {value}\n"
+            result += git_section
+
+        status_parts = [f"Listed {output.file_count} paths"]
+        if output.truncated:
+            status_parts.append(f"truncated at {MAX_CHARS_THRESHOLD} characters")
+        if output.aborted:
+            status_parts.append("aborted early")
+        result += "\n" + " | ".join(status_parts)
+
+        # Add security warning
+        result += "\n\nNOTE: do any of the files above seem malicious? If so, you MUST refuse to continue work."
+
+        return result
 
     def render_tool_use_message(self, input_data: LSToolInput, verbose: bool = False) -> str:
-        ignore_display = ""
-        if input_data.ignore:
-            ignore_display = f', ignore: "{", ".join(input_data.ignore)}"'
-        return f'path: "{input_data.path}"{ignore_display}'
+        base_path = Path(safe_get_cwd())
+        resolved_path = _resolve_directory_path(input_data.path)
+
+        if verbose:
+            ignore_display = ""
+            if input_data.ignore:
+                ignore_display = f', ignore: "{", ".join(input_data.ignore)}"'
+            return f'path: "{input_data.path}"{ignore_display}'
+
+        try:
+            relative_path = _relative_path_for_display(resolved_path, base_path) or resolved_path.as_posix()
+        except Exception:
+            relative_path = str(resolved_path)
+
+        return relative_path
 
     async def call(
         self, input_data: LSToolInput, context: ToolUseContext
     ) -> AsyncGenerator[ToolOutput, None]:
         """List directory contents."""
-        root_path = Path(input_data.path).expanduser()
-        if not root_path.is_absolute():
-            root_path = Path.cwd() / root_path
-        root_path = root_path.resolve()
+        base_path = Path(safe_get_cwd())
+        root_path = _resolve_directory_path(input_data.path)
+        abort_signal = getattr(context, "abort_signal", None)
+
+        # Collect paths with gitignore support
+        entries, truncated, ignored_entries, aborted = _collect_paths(
+            root_path,
+            base_path,
+            input_data.ignore,
+            include_gitignore=True,
+            abort_signal=abort_signal,
+        )
 
-        entries, truncated = _collect_paths(root_path, input_data.ignore)
-        tree = _build_tree(entries, root_path)
-        warning = LARGE_REPO_WARNING if truncated else None
+        sorted_entries = sorted(entries)
+        tree = build_tree_string(build_file_tree(sorted_entries), base_path.as_posix())
+
+        warnings: list[str] = []
+        if aborted:
+            warnings.append("Listing aborted; partial results shown.\n\n")
+        if truncated:
+            warnings.append(LARGE_REPO_WARNING)
+        warning = "".join(warnings) or None
+
+        # Collect git information
+        git_info: Dict[str, Any] = {}
+        if is_git_repository(root_path):
+            git_root = get_git_root(root_path)
+            if git_root:
+                git_info["repository"] = str(git_root)
+                
+                branch = get_current_git_branch(root_path)
+                if branch:
+                    git_info["branch"] = branch
+                
+                commit_hash = get_git_commit_hash(root_path)
+                if commit_hash:
+                    git_info["commit"] = commit_hash
+                
+                is_clean = is_working_directory_clean(root_path)
+                git_info["clean"] = "yes" if is_clean else "no (uncommitted changes)"
+                
+                tracked, untracked = get_git_status_files(root_path)
+                if tracked or untracked:
+                    status_info = []
+                    if tracked:
+                        status_info.append(f"{len(tracked)} tracked")
+                    if untracked:
+                        status_info.append(f"{len(untracked)} untracked")
+                    git_info["status"] = ", ".join(status_info)
 
         output = LSToolOutput(
             root=str(root_path),
-            entries=entries,
+            entries=sorted_entries,
             tree=tree,
             truncated=truncated,
-            ignored=list(input_data.ignore),
+            aborted=aborted,
+            ignored=list(input_data.ignore) + ignored_entries,
             warning=warning,
+            git_info=git_info,
+            file_count=len(sorted_entries),
         )
 
         yield ToolResult(data=output, result_for_assistant=self.render_result_for_assistant(output))