raggiecode 0.2.1__py3-none-any.whl

Tools/search.py

@@ -0,0 +1,41 @@
+from ripgrep_rs import search
+from .utils import is_within_cwd
+
+def handle(arguments, toolcall_id, parent_session_id=None):
+    search_term = arguments.get("search_term")
+    directory = arguments.get("directory")
+
+    # Check if the directory is outside the current working directory
+    if directory and not is_within_cwd(directory):
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: access denied - path is outside the current working directory",
+        }
+    
+    print(f"Searching for '{search_term}' in '{directory}'")
+    
+    try:
+        results = search(
+            patterns=[search_term],
+            paths=[directory]
+        )
+        
+        # ripgrep_rs returns a list of strings
+        if not results:
+            result = "No matches found."
+        else:
+            result = "".join(results)
+            
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": result.strip(),
+        }
+    except Exception as e:
+        print(f"Search error: {str(e)}")
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error executing search: {str(e)}",
+        }

Tools/shell.py

@@ -0,0 +1,149 @@
+import os
+import re
+import subprocess
+
+from .utils import is_ignored_by_gitignore, is_within_cwd, BLUE, RESET, reindex_after_change, remove_em_dashes
+
+
+def _extract_paths(command):
+    """Extract potential file paths from a shell command string.
+
+    Uses a simple heuristic: find tokens that look like paths (contain '/'
+    or a known extension) and resolve them relative to cwd. This catches
+    common cases like 'cat .env', 'sed -i file', 'rm -rf dir/', etc.
+    """
+    paths = set()
+    cwd = os.getcwd()
+
+    # Split on whitespace and common shell operators
+    tokens = re.split(r'[\s;|&<>`$()]+', command)
+    for token in tokens:
+        token = token.strip().strip("'\"")
+        if not token or len(token) < 2:
+            continue
+        # Skip flags and options
+        if token.startswith('-'):
+            continue
+        # Resolve relative to cwd
+        candidate = os.path.join(cwd, token)
+        if os.path.lexists(candidate):
+            paths.add(os.path.normpath(candidate))
+        elif os.path.lexists(token):
+            paths.add(os.path.normpath(token))
+
+    return paths
+
+
+def handle(arguments, toolcall_id, code_indexer=None):
+
+    command = arguments["command"]
+    timeout = arguments.get("timeout", 30)
+    print(f"{BLUE}Shell{RESET}")
+
+    # Enforce sandbox: block commands that touch paths outside cwd
+    for path in _extract_paths(command):
+        if not is_within_cwd(path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": (
+                    f"Error: The command would operate on '{path}', "
+                    "which is outside the current working directory. "
+                    "Access to paths outside the project is not allowed."
+                ),
+            }
+
+    # Enforce gitignore: block commands that touch gitignored files
+    for path in _extract_paths(command):
+        if is_ignored_by_gitignore(path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": (
+                    f"Error: The command would operate on '{path}', "
+                    "which is matched by .gitignore. Use the dedicated "
+                    "tools (WriteFile, ReplaceText, RemoveFile) for "
+                    "non-gitignored files, or instruct the user to make "
+                    "this change themselves."
+                ),
+            }
+
+    try:
+        confirmation = ""
+        try:
+            confirmation = input(f"{BLUE}Execute command: {command}\n? (y/n): {RESET}")
+        except KeyboardInterrupt:
+            print()
+            exit(0)
+        except EOFError:
+            print()
+            exit(0)
+
+        if confirmation.lower() != "y":
+            print("Command execution cancelled by user.")
+            try:
+                reason = input(f"{BLUE}Reason for refusal (optional, press Enter to skip): {RESET}").strip()
+            except (KeyboardInterrupt, EOFError):
+                reason = ""
+            if reason:
+                return {
+                    "role": "tool",
+                    "tool_call_id": toolcall_id,
+                    "content": f"The user refused running this command. Reason: {reason}",
+                }
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": "The user refused running this command.",
+            }
+
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=timeout,
+            )
+        except subprocess.TimeoutExpired as e:
+            output = (e.stdout or "").strip()
+            error_msg = (e.stderr or "").strip()
+            msg = f"Command timed out after {timeout} seconds and was killed."
+            if output:
+                msg += f"\nPartial stdout:\n{output}"
+            if error_msg:
+                msg += f"\nPartial stderr:\n{error_msg}"
+            print(msg)
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": msg,
+            }
+
+        output = result.stdout
+        if result.returncode != 0:
+            error_msg = result.stderr.strip()
+            if output:
+                output += f"\n(exit code {result.returncode})\nstderr: {error_msg}"
+            else:
+                output = f"Command failed with exit code {result.returncode}\n{error_msg}"
+
+        output = remove_em_dashes(output)
+        stripped = output.strip()
+        if stripped:
+            print(stripped)
+
+        reindex_after_change(code_indexer)
+
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"{output.strip()}",
+        }
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error executing command: {str(e)}",
+        }

Tools/shell_kill.py

@@ -0,0 +1,87 @@
+import os
+
+from .utils import BLUE, RED, RESET
+from .temp_background_service import _background_processes
+
+
+def handle(arguments, toolcall_id):
+    pid = arguments.get("pid")
+    print(f"{BLUE}ShellKill{RESET}")
+
+    if pid is None:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: 'pid' parameter is required.",
+        }
+
+    pid = int(pid)
+
+    if pid not in _background_processes:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error: No background process found with PID {pid}.",
+        }
+
+    entry = _background_processes[pid]
+    process = entry["process"]
+    command = entry["command"]
+
+    try:
+        process.terminate()
+        try:
+            process.wait(timeout=5)
+        except Exception:
+            process.kill()
+            process.wait(timeout=5)
+
+        # Read any captured output
+        output = ""
+        stdout_path = entry.get("stdout_path")
+        stderr_path = entry.get("stderr_path")
+
+        if stdout_path and os.path.exists(stdout_path):
+            with open(stdout_path, "r") as f:
+                stdout_content = f.read().strip()
+            if stdout_content:
+                output += stdout_content
+
+        if stderr_path and os.path.exists(stderr_path):
+            with open(stderr_path, "r") as f:
+                stderr_content = f.read().strip()
+            if stderr_content:
+                if output:
+                    output += f"\nstderr: {stderr_content}"
+                else:
+                    output = f"stderr: {stderr_content}"
+
+        # Clean up temp files
+        for path in [stdout_path, stderr_path]:
+            if path and os.path.exists(path):
+                try:
+                    os.unlink(path)
+                except OSError as e:
+                    print(f"{RED}Warning: Failed to clean up temp file {path}: {e}{RESET}")
+
+        del _background_processes[pid]
+
+        return_code = process.returncode
+        result = (
+            f"Process {pid} terminated (exit code {return_code}).\n"
+            f"Command: {command}"
+        )
+        if output:
+            result += f"\nOutput:\n{output}"
+
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": result,
+        }
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error killing process {pid}: {str(e)}",
+        }

Tools/temp_background_service.py

@@ -0,0 +1,113 @@
+import subprocess
+import tempfile
+
+from .utils import is_ignored_by_gitignore, is_within_cwd, BLUE, RESET
+from .shell import _extract_paths
+
+# Module-level registry of background processes
+_background_processes = {}
+
+
+def handle(arguments, toolcall_id):
+    command = arguments["command"]
+    print(f"{BLUE}TempBackgroundService{RESET}")
+
+    # Enforce sandbox: block commands that touch paths outside cwd
+    for path in _extract_paths(command):
+        if not is_within_cwd(path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": (
+                    f"Error: The command would operate on '{path}', "
+                    "which is outside the current working directory. "
+                    "Access to paths outside the project is not allowed."
+                ),
+            }
+
+    # Enforce gitignore: block commands that touch gitignored files
+    for path in _extract_paths(command):
+        if is_ignored_by_gitignore(path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": (
+                    f"Error: The command would operate on '{path}', "
+                    "which is matched by .gitignore. Use the dedicated "
+                    "tools (WriteFile, ReplaceText, RemoveFile) for "
+                    "non-gitignored files, or instruct the user to make "
+                    "this change themselves."
+                ),
+            }
+
+    try:
+        confirmation = ""
+        try:
+            confirmation = input(f"{BLUE}Start background service: {command}\n? (y/n): {RESET}")
+        except KeyboardInterrupt:
+            print()
+            exit(0)
+        except EOFError:
+            print()
+            exit(0)
+
+        if confirmation.lower() != "y":
+            print("Command execution cancelled by user.")
+            try:
+                reason = input(f"{BLUE}Reason for refusal (optional, press Enter to skip): {RESET}").strip()
+            except (KeyboardInterrupt, EOFError):
+                reason = ""
+            if reason:
+                return {
+                    "role": "tool",
+                    "tool_call_id": toolcall_id,
+                    "content": f"The user refused running this command. Reason: {reason}",
+                }
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": "The user refused running this command.",
+            }
+
+        # Create temp files for stdout and stderr
+        stdout_file = tempfile.NamedTemporaryFile(
+            mode="w+", delete=False, suffix=".out", prefix="raggie_bg_"
+        )
+        stderr_file = tempfile.NamedTemporaryFile(
+            mode="w+", delete=False, suffix=".err", prefix="raggie_bg_"
+        )
+
+        process = subprocess.Popen(
+            command,
+            shell=True,
+            stdout=stdout_file,
+            stderr=stderr_file,
+            text=True,
+        )
+
+        pid = process.pid
+        _background_processes[pid] = {
+            "process": process,
+            "command": command,
+            "stdout_path": stdout_file.name,
+            "stderr_path": stderr_file.name,
+        }
+
+        stdout_file.close()
+        stderr_file.close()
+
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": (
+                f"Background process started with PID {pid}.\n"
+                f"Command: {command}\n"
+                f"Use ShellKill with pid={pid} to terminate it."
+            ),
+        }
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error starting background command: {str(e)}",
+        }