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

ripperdoc/tools/background_shell.py

@@ -14,6 +14,9 @@ import uuid
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
+import atexit
+
+from ripperdoc.utils.shell_utils import build_shell_command, find_suitable_shell
 from ripperdoc.utils.log import get_logger
 
 
@@ -43,6 +46,7 @@ _tasks_lock = threading.Lock()
 _background_loop: Optional[asyncio.AbstractEventLoop] = None
 _background_thread: Optional[threading.Thread] = None
 _loop_lock = threading.Lock()
+_shutdown_registered = False
 
 
 def _ensure_background_loop() -> asyncio.AbstractEventLoop:
@@ -74,9 +78,18 @@ def _ensure_background_loop() -> asyncio.AbstractEventLoop:
 
         _background_loop = loop
         _background_thread = thread
+        _register_shutdown_hook()
         return loop
 
 
+def _register_shutdown_hook() -> None:
+    global _shutdown_registered
+    if _shutdown_registered:
+        return
+    atexit.register(shutdown_background_shell)
+    _shutdown_registered = True
+
+
 def _submit_to_background_loop(coro: Any) -> concurrent.futures.Future:
     """Run a coroutine on the background loop and return a thread-safe future."""
     loop = _ensure_background_loop()
@@ -95,7 +108,10 @@ async def _pump_stream(stream: asyncio.StreamReader, sink: List[str]) -> None:
                 sink.append(text)
     except Exception as exc:
         # Best effort; ignore stream read errors to avoid leaking tasks.
-        logger.debug(f"Stream pump error for background task: {exc}")
+        logger.debug(
+            f"Stream pump error for background task: {exc}",
+            exc_info=True,
+        )
 
 
 async def _finalize_reader_tasks(reader_tasks: List[asyncio.Task], timeout: float = 1.0) -> None:
@@ -133,8 +149,11 @@ async def _monitor_task(task: BackgroundTask) -> None:
             task.exit_code = -1
     except asyncio.CancelledError:
         return
-    except Exception as exc:
-        logger.error(f"Error monitoring background task {task.id}: {exc}")
+    except Exception:
+        logger.exception(
+            "Error monitoring background task",
+            extra={"task_id": task.id, "command": task.command},
+        )
         with _tasks_lock:
             task.exit_code = -1
     finally:
@@ -147,24 +166,15 @@ async def _start_background_command(
     command: str, timeout: Optional[float] = None, shell_executable: Optional[str] = None
 ) -> str:
     """Launch a background shell command on the dedicated loop."""
-    if shell_executable:
-        process = await asyncio.create_subprocess_exec(
-            shell_executable,
-            "-c",
-            command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            stdin=asyncio.subprocess.DEVNULL,
-            start_new_session=False,
-        )
-    else:
-        process = await asyncio.create_subprocess_shell(
-            command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            stdin=asyncio.subprocess.DEVNULL,
-            start_new_session=False,
-        )
+    selected_shell = shell_executable or find_suitable_shell()
+    argv = build_shell_command(selected_shell, command)
+    process = await asyncio.create_subprocess_exec(
+        *argv,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.DEVNULL,
+        start_new_session=False,
+    )
 
     task_id = f"bash_{uuid.uuid4().hex[:8]}"
     record = BackgroundTask(
@@ -289,3 +299,35 @@ def list_background_tasks() -> List[str]:
     """Return known background task ids."""
     with _tasks_lock:
         return list(_tasks.keys())
+
+
+def shutdown_background_shell() -> None:
+    """Stop background tasks/loop to avoid asyncio 'Event loop is closed' warnings."""
+    global _background_loop, _background_thread
+
+    loop = _background_loop
+    with _tasks_lock:
+        tasks = list(_tasks.values())
+        _tasks.clear()
+
+    for task in tasks:
+        try:
+            task.killed = True
+            task.process.kill()
+        except Exception:
+            pass
+        for reader in task.reader_tasks:
+            if loop and loop.is_running():
+                loop.call_soon_threadsafe(reader.cancel)
+        task.done_event.set()
+
+    if loop and loop.is_running():
+        try:
+            loop.call_soon_threadsafe(loop.stop)
+        except Exception:
+            pass
+    if _background_thread and _background_thread.is_alive():
+        _background_thread.join(timeout=2)
+
+    _background_loop = None
+    _background_thread = None

ripperdoc/tools/bash_tool.py

@@ -49,6 +49,10 @@ from ripperdoc.utils.permissions.tool_permission_utils import (
 from ripperdoc.utils.permissions import PermissionDecision
 from ripperdoc.utils.sandbox_utils import create_sandbox_wrapper, is_sandbox_available
 from ripperdoc.utils.safe_get_cwd import get_original_cwd, safe_get_cwd
+from ripperdoc.utils.shell_utils import build_shell_command, find_suitable_shell
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 DEFAULT_TIMEOUT_MS = get_bash_default_timeout_ms()
@@ -148,6 +152,15 @@ build projects, run tests, and interact with the file system."""
 
     async def prompt(self, safe_mode: bool = False) -> str:
         sandbox_available = is_sandbox_available()
+        try:
+            current_shell = find_suitable_shell()
+        except Exception as exc:  # pragma: no cover - defensive guard
+            current_shell = f"Unavailable ({exc})"
+
+        shell_info = (
+            f"Current shell used for execution: {current_shell}\n"
+            f"- Override via RIPPERDOC_SHELL or RIPPERDOC_SHELL_PATH env vars, or pass shellExecutable input.\n"
+        )
 
         read_only_section = ""
         if sandbox_available:
@@ -232,6 +245,8 @@ build projects, run tests, and interact with the file system."""
             f"""\
             Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.
 
+            {shell_info}
+
             Before executing the command, please follow these steps:
 
             1. Directory Verification:
@@ -483,6 +498,23 @@ build projects, run tests, and interact with the file system."""
         """Execute the bash command."""
 
         effective_command, auto_background = self._detect_auto_background(input_data.command)
+        try:
+            resolved_shell = input_data.shell_executable or find_suitable_shell()
+        except Exception as exc:  # pragma: no cover - defensive guard
+            error_output = BashToolOutput(
+                stdout="",
+                stderr=f"Failed to select shell: {exc}",
+                exit_code=-1,
+                command=effective_command,
+                sandbox=bool(input_data.sandbox),
+                is_error=True,
+            )
+            yield ToolResult(
+                data=error_output,
+                result_for_assistant=self.render_result_for_assistant(error_output),
+            )
+            return
+
         timeout_ms = input_data.timeout or DEFAULT_TIMEOUT_MS
         if MAX_BASH_TIMEOUT_MS:
             timeout_ms = min(timeout_ms, MAX_BASH_TIMEOUT_MS)
@@ -516,6 +548,10 @@ build projects, run tests, and interact with the file system."""
                 final_command = wrapper.final_command
                 sandbox_cleanup = wrapper.cleanup
             except Exception as exc:
+                logger.exception(
+                    "[bash_tool] Failed to enable sandbox",
+                    extra={"command": effective_command, "error": str(exc)},
+                )
                 error_output = BashToolOutput(
                     stdout="",
                     stderr=f"Failed to enable sandbox: {exc}",
@@ -537,18 +573,9 @@ build projects, run tests, and interact with the file system."""
             should_background = False
 
         async def _spawn_process() -> asyncio.subprocess.Process:
-            if input_data.shell_executable:
-                return await asyncio.create_subprocess_exec(
-                    input_data.shell_executable,
-                    "-c",
-                    final_command,
-                    stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE,
-                    stdin=asyncio.subprocess.DEVNULL,
-                    start_new_session=False,
-                )
-            return await asyncio.create_subprocess_shell(
-                final_command,
+            argv = build_shell_command(resolved_shell, final_command)
+            return await asyncio.create_subprocess_exec(
+                *argv,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
                 stdin=asyncio.subprocess.DEVNULL,
@@ -561,6 +588,10 @@ build projects, run tests, and interact with the file system."""
                 try:
                     from ripperdoc.tools.background_shell import start_background_command
                 except Exception as e:  # pragma: no cover - defensive import
+                    logger.exception(
+                        "[bash_tool] Failed to import background shell runner",
+                        extra={"command": effective_command},
+                    )
                     error_output = BashToolOutput(
                         stdout="",
                         stderr=f"Failed to start background task: {str(e)}",
@@ -581,7 +612,7 @@ build projects, run tests, and interact with the file system."""
                     else (timeout_seconds if timeout_seconds > 0 else None)
                 )
                 task_id = await start_background_command(
-                    final_command, timeout=bg_timeout, shell_executable=input_data.shell_executable
+                    final_command, timeout=bg_timeout, shell_executable=resolved_shell
                 )
 
                 output = BashToolOutput(
@@ -767,6 +798,10 @@ build projects, run tests, and interact with the file system."""
             )
 
         except Exception as e:
+            logger.exception(
+                "[bash_tool] Error executing command",
+                extra={"command": effective_command, "error": str(e)},
+            )
             error_output = BashToolOutput(
                 stdout="",
                 stderr=f"Error executing command: {str(e)}",

ripperdoc/tools/file_edit_tool.py

@@ -15,6 +15,10 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
+
+logger = get_logger()
 
 
 class FileEditToolInput(BaseModel):
@@ -182,6 +186,18 @@ match exactly (including whitespace and indentation)."""
             with open(input_data.file_path, "w", encoding="utf-8") as f:
                 f.write(new_content)
 
+            try:
+                record_snapshot(
+                    input_data.file_path,
+                    new_content,
+                    getattr(context, "file_state_cache", {}),
+                )
+            except Exception:
+                logger.exception(
+                    "[file_edit_tool] Failed to record file snapshot",
+                    extra={"file_path": input_data.file_path},
+                )
+
             # Generate diff for display
             import difflib
 
@@ -268,6 +284,10 @@ match exactly (including whitespace and indentation)."""
             )
 
         except Exception as e:
+            logger.exception(
+                "[file_edit_tool] Error editing file",
+                extra={"file_path": input_data.file_path, "error": str(e)},
+            )
             error_output = FileEditToolOutput(
                 file_path=input_data.file_path,
                 replacements_made=0,

ripperdoc/tools/file_read_tool.py

@@ -15,6 +15,10 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
+
+logger = get_logger()
 
 
 class FileReadToolInput(BaseModel):
@@ -140,6 +144,21 @@ and limit to read only a portion of the file."""
 
             content = "".join(selected_lines)
 
+            # Remember what we read so we can detect user edits later.
+            try:
+                record_snapshot(
+                    input_data.file_path,
+                    content,
+                    getattr(context, "file_state_cache", {}),
+                    offset=offset,
+                    limit=limit,
+                )
+            except Exception:
+                logger.exception(
+                    "[file_read_tool] Failed to record file snapshot",
+                    extra={"file_path": input_data.file_path},
+                )
+
             output = FileReadToolOutput(
                 content=content,
                 file_path=input_data.file_path,
@@ -153,6 +172,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,10 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
+
+logger = get_logger()
 
 
 class FileWriteToolInput(BaseModel):
@@ -122,6 +126,18 @@ NEVER write new files unless explicitly required by the user."""
 
             bytes_written = len(input_data.content.encode("utf-8"))
 
+            try:
+                record_snapshot(
+                    input_data.file_path,
+                    input_data.content,
+                    getattr(context, "file_state_cache", {}),
+                )
+            except Exception:
+                logger.exception(
+                    "[file_write_tool] Failed to record file snapshot",
+                    extra={"file_path": input_data.file_path},
+                )
+
             output = FileWriteToolOutput(
                 file_path=input_data.file_path,
                 bytes_written=bytes_written,
@@ -134,6 +150,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,38 @@ 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 +138,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 +147,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
             )