ripperdoc 0.1.0__py3-none-any.whl

ripperdoc/tools/glob_tool.py

@@ -0,0 +1,134 @@
+"""Glob pattern matching tool.
+
+Allows the AI to find files using glob patterns.
+"""
+
+from pathlib import Path
+from typing import AsyncGenerator, Optional, List
+from pydantic import BaseModel, Field
+
+from ripperdoc.core.tool import (
+    Tool,
+    ToolUseContext,
+    ToolResult,
+    ToolOutput,
+    ToolUseExample,
+    ValidationResult,
+)
+
+
+GLOB_USAGE = (
+    "- Fast file pattern matching tool for 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"
+)
+
+
+class GlobToolInput(BaseModel):
+    """Input schema for GlobTool."""
+
+    pattern: str = Field(description="Glob pattern to match files (e.g., '**/*.py')")
+    path: Optional[str] = Field(
+        default=None, description="Directory to search in (default: current working directory)"
+    )
+
+
+class GlobToolOutput(BaseModel):
+    """Output from glob pattern matching."""
+
+    matches: List[str]
+    pattern: str
+    count: int
+
+
+class GlobTool(Tool[GlobToolInput, GlobToolOutput]):
+    """Tool for finding files using glob patterns."""
+
+    @property
+    def name(self) -> str:
+        return "Glob"
+
+    async def description(self) -> str:
+        return GLOB_USAGE
+
+    @property
+    def input_schema(self) -> type[GlobToolInput]:
+        return GlobToolInput
+
+    def input_examples(self) -> List[ToolUseExample]:
+        return [
+            ToolUseExample(
+                description="Find Python sources inside src",
+                input={"pattern": "src/**/*.py"},
+            ),
+            ToolUseExample(
+                description="Locate snapshot files within tests",
+                input={"pattern": "tests/**/__snapshots__/*.snap", "path": "/repo"},
+            ),
+        ]
+
+    async def prompt(self, safe_mode: bool = False) -> str:
+        return GLOB_USAGE
+
+    def is_read_only(self) -> bool:
+        return True
+
+    def is_concurrency_safe(self) -> bool:
+        return True
+
+    def needs_permissions(self, input_data: Optional[GlobToolInput] = None) -> bool:
+        return False
+
+    async def validate_input(
+        self, input_data: GlobToolInput, context: Optional[ToolUseContext] = None
+    ) -> ValidationResult:
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: GlobToolOutput) -> str:
+        """Format output for the AI."""
+        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
+
+    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}"
+
+    async def call(
+        self, input_data: GlobToolInput, context: ToolUseContext
+    ) -> AsyncGenerator[ToolOutput, None]:
+        """Find files matching the pattern."""
+
+        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))
+
+            def _mtime(path: Path) -> float:
+                try:
+                    return path.stat().st_mtime
+                except OSError:
+                    return float("-inf")
+
+            matches = [str(p) for p in sorted(paths, key=_mtime, reverse=True)]
+
+            output = GlobToolOutput(matches=matches, pattern=input_data.pattern, count=len(matches))
+
+            yield ToolResult(
+                data=output, result_for_assistant=self.render_result_for_assistant(output)
+            )
+
+        except Exception as e:
+            error_output = GlobToolOutput(matches=[], pattern=input_data.pattern, count=0)
+
+            yield ToolResult(
+                data=error_output, result_for_assistant=f"Error executing glob: {str(e)}"
+            )

ripperdoc/tools/grep_tool.py

@@ -0,0 +1,232 @@
+"""Grep tool for searching code.
+
+Allows the AI to search for patterns in files.
+"""
+
+import asyncio
+from typing import AsyncGenerator, Optional, List
+from pydantic import BaseModel, Field
+
+from ripperdoc.core.tool import (
+    Tool,
+    ToolUseContext,
+    ToolResult,
+    ToolOutput,
+    ToolUseExample,
+    ValidationResult,
+)
+
+
+GREP_USAGE = (
+    "A powerful search tool built on ripgrep.\n\n"
+    "Usage:\n"
+    "- ALWAYS use the Grep tool for search tasks. NEVER invoke `grep` or `rg` as a Bash command; this tool is optimized for permissions and access.\n"
+    '- 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'
+    "- 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{}`)"
+)
+
+
+class GrepToolInput(BaseModel):
+    """Input schema for GrepTool."""
+
+    pattern: str = Field(description="Regular expression pattern to search for")
+    path: Optional[str] = Field(
+        default=None, description="Directory or file to search in (default: current directory)"
+    )
+    glob: Optional[str] = Field(default=None, description="File pattern to filter (e.g., '*.py')")
+    case_insensitive: bool = Field(default=False, description="Case insensitive search")
+    output_mode: str = Field(
+        default="files_with_matches",
+        description="Output mode: 'files_with_matches', 'content', or 'count'",
+    )
+
+
+class GrepMatch(BaseModel):
+    """A single grep match."""
+
+    file: str
+    line_number: Optional[int] = None
+    content: Optional[str] = None
+    count: Optional[int] = None
+
+
+class GrepToolOutput(BaseModel):
+    """Output from grep search."""
+
+    matches: List[GrepMatch]
+    pattern: str
+    total_files: int
+    total_matches: int
+
+
+class GrepTool(Tool[GrepToolInput, GrepToolOutput]):
+    """Tool for searching code with grep."""
+
+    @property
+    def name(self) -> str:
+        return "Grep"
+
+    async def description(self) -> str:
+        return GREP_USAGE
+
+    @property
+    def input_schema(self) -> type[GrepToolInput]:
+        return GrepToolInput
+
+    def input_examples(self) -> List[ToolUseExample]:
+        return [
+            ToolUseExample(
+                description="Find TODO comments in TypeScript files",
+                input={"pattern": "TODO", "glob": "**/*.ts", "output_mode": "content"},
+            ),
+            ToolUseExample(
+                description="List files referencing a function name",
+                input={
+                    "pattern": "fetchUserData",
+                    "output_mode": "files_with_matches",
+                    "path": "/repo/src",
+                },
+            ),
+        ]
+
+    async def prompt(self, safe_mode: bool = False) -> str:
+        return GREP_USAGE
+
+    def is_read_only(self) -> bool:
+        return True
+
+    def is_concurrency_safe(self) -> bool:
+        return True
+
+    def needs_permissions(self, input_data: Optional[GrepToolInput] = None) -> bool:
+        return False
+
+    async def validate_input(
+        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}"
+            )
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: GrepToolOutput) -> str:
+        """Format output for the AI."""
+        if output.total_files == 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"
+
+        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 len(output.matches) > 100:
+            result += f"\n... and {len(output.matches) - 100} more matches"
+
+        return result
+
+    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}"
+        return msg
+
+    async def call(
+        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"]
+
+            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
+
+            cmd.append(input_data.pattern)
+            cmd.append(search_path)
+
+            if input_data.glob:
+                cmd.extend(["--include", input_data.glob])
+
+            # Run grep asynchronously
+            process = await asyncio.create_subprocess_exec(
+                *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+
+            stdout, stderr = await process.communicate()
+            returncode = process.returncode
+
+            # Parse output
+            matches: List[GrepMatch] = []
+
+            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
+                        parts = line.rsplit(":", 1)
+                        if len(parts) == 2:
+                            matches.append(
+                                GrepMatch(
+                                    file=parts[0], count=int(parts[1]) if parts[1].isdigit() else 0
+                                )
+                            )
+
+                    else:  # content mode
+                        # Format: file:line:content
+                        parts = line.split(":", 2)
+                        if len(parts) >= 3:
+                            matches.append(
+                                GrepMatch(
+                                    file=parts[0],
+                                    line_number=int(parts[1]) if parts[1].isdigit() else None,
+                                    content=parts[2] if len(parts) > 2 else "",
+                                )
+                            )
+
+            output = GrepToolOutput(
+                matches=matches,
+                pattern=input_data.pattern,
+                total_files=len(set(m.file for m in matches)),
+                total_matches=len(matches),
+            )
+
+            yield ToolResult(
+                data=output, result_for_assistant=self.render_result_for_assistant(output)
+            )
+
+        except Exception as e:
+            error_output = GrepToolOutput(
+                matches=[], pattern=input_data.pattern, total_files=0, total_matches=0
+            )
+
+            yield ToolResult(
+                data=error_output, result_for_assistant=f"Error executing grep: {str(e)}"
+            )

ripperdoc/tools/kill_bash_tool.py

@@ -0,0 +1,136 @@
+"""Tool to terminate a running background bash task."""
+
+from __future__ import annotations
+
+from typing import AsyncGenerator, Optional
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+
+from ripperdoc.core.tool import Tool, ToolResult, ToolUseContext, ValidationResult
+from ripperdoc.tools.background_shell import (
+    get_background_status,
+    kill_background_task,
+)
+from ripperdoc.utils.permissions import PermissionDecision
+
+
+KILL_BASH_PROMPT = """
+- Kills a running background bash shell by its ID
+- Takes a shell_id parameter identifying the shell to kill
+- Returns a success or failure status
+- Use this tool when you need to terminate a long-running shell
+- Shell IDs can be found using the Bash tool (run_in_background) and BashOutput
+""".strip()
+
+
+class KillBashInput(BaseModel):
+    """Input schema for KillBash."""
+
+    task_id: str = Field(
+        description="Background task id to kill",
+        validation_alias=AliasChoices("task_id", "shell_id"),
+        serialization_alias="task_id",
+    )
+    model_config = ConfigDict(validate_by_alias=True, validate_by_name=True, extra="ignore")
+
+
+class KillBashOutput(BaseModel):
+    """Result of attempting to kill a background task."""
+
+    task_id: str
+    success: bool
+    message: str
+    status: Optional[str] = None
+
+
+class KillBashTool(Tool[KillBashInput, KillBashOutput]):
+    """Terminate a background bash command."""
+
+    @property
+    def name(self) -> str:
+        return "KillBash"
+
+    async def description(self) -> str:
+        return "Kill a background bash shell by ID"
+
+    async def prompt(self, safe_mode: bool = False) -> str:
+        return KILL_BASH_PROMPT
+
+    @property
+    def input_schema(self) -> type[KillBashInput]:
+        return KillBashInput
+
+    def is_read_only(self) -> bool:
+        return False
+
+    def is_concurrency_safe(self) -> bool:
+        return True
+
+    def needs_permissions(self, input_data: Optional[KillBashInput] = None) -> bool:
+        return True
+
+    async def check_permissions(
+        self, input_data: KillBashInput, permission_context: object
+    ) -> PermissionDecision:
+        # Killing is destructive; require explicit confirmation upstream.
+        return PermissionDecision(behavior="allow", updated_input=input_data)
+
+    async def validate_input(
+        self, input_data: KillBashInput, context: Optional[ToolUseContext] = None
+    ) -> ValidationResult:
+        try:
+            get_background_status(input_data.task_id, consume=False)
+        except KeyError:
+            return ValidationResult(
+                result=False, message=f"No background task found with id '{input_data.task_id}'"
+            )
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: KillBashOutput) -> str:
+        return output.message
+
+    def render_tool_use_message(self, input_data: KillBashInput, verbose: bool = False) -> str:
+        return f"$ kill-background {input_data.task_id}"
+
+    async def call(
+        self, input_data: KillBashInput, context: ToolUseContext
+    ) -> AsyncGenerator[ToolResult, None]:
+        try:
+            status = get_background_status(input_data.task_id, consume=False)
+        except KeyError:
+            output = KillBashOutput(
+                task_id=input_data.task_id,
+                success=False,
+                message=f"No shell found with ID: {input_data.task_id}",
+                status=None,
+            )
+            yield ToolResult(
+                data=output, result_for_assistant=self.render_result_for_assistant(output)
+            )
+            return
+
+        if status["status"] != "running":
+            output = KillBashOutput(
+                task_id=input_data.task_id,
+                success=False,
+                message=f"Shell {input_data.task_id} is not running (status: {status['status']}).",
+                status=status["status"],
+            )
+            yield ToolResult(
+                data=output, result_for_assistant=self.render_result_for_assistant(output)
+            )
+            return
+
+        killed = await kill_background_task(input_data.task_id)
+        message = (
+            f"Successfully killed shell: {input_data.task_id} ({status['command']})"
+            if killed
+            else f"Failed to kill shell: {input_data.task_id}"
+        )
+        output = KillBashOutput(
+            task_id=input_data.task_id,
+            success=killed,
+            message=message,
+            status="killed" if killed else status["status"],
+        )
+        yield ToolResult(data=output, result_for_assistant=self.render_result_for_assistant(output))