janito 1.5.2__py3-none-any.whl → 1.6.0__py3-none-any.whl

janito/agent/tools/replace_file.py

@@ -0,0 +1,51 @@
+import os
+import shutil
+from janito.agent.tool_registry import register_tool
+from janito.agent.tools.utils import expand_path, display_path
+from janito.agent.tool_base import ToolBase
+
+
+@register_tool(name="replace_file")
+class ReplaceFileTool(ToolBase):
+    """
+    Overwrite (replace) a file with the given content. Creates the file if it does not exist.
+
+    Args:
+        path (str): Path to the file to overwrite or create.
+        content (str): Content to write to the file.
+        backup (bool, optional): If True, create a backup (.bak) before replacing if the file exists. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "\u2705 Successfully replaced the file at ..."
+            - "\u2705 Successfully created the file at ..."
+    """
+
+    def call(self, path: str, content: str, backup: bool = False) -> str:
+        original_path = path
+        path = expand_path(path)
+        disp_path = display_path(original_path, path)
+        updating = os.path.exists(path) and not os.path.isdir(path)
+        if os.path.exists(path) and os.path.isdir(path):
+            self.report_error("\u274c Error: is a directory")
+            return (
+                f"\u274c Cannot replace file: '{disp_path}' is an existing directory."
+            )
+        # Ensure parent directories exist
+        dir_name = os.path.dirname(path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        if backup and os.path.exists(path) and not os.path.isdir(path):
+            shutil.copy2(path, path + ".bak")
+        with open(path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(content)
+        new_lines = content.count("\n") + 1 if content else 0
+        if updating:
+            self.report_success(
+                f"\u2705 Successfully replaced the file at '{disp_path}' ({new_lines} lines)."
+            )
+            return f"\u2705 Successfully replaced the file at '{disp_path}' ({new_lines} lines)."
+        else:
+            self.report_success(
+                f"\u2705 Successfully created the file at '{disp_path}' ({new_lines} lines)."
+            )
+            return f"\u2705 Successfully created the file at '{disp_path}' ({new_lines} lines)."

janito/agent/tools/replace_text_in_file.py

@@ -1,46 +1,56 @@
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-
-@register_tool(name="replace_text_in_file")
+from janito.agent.tools.tools_utils import pluralize
 
 
+@register_tool(name="replace_text_in_file")
 class ReplaceTextInFileTool(ToolBase):
-    """Replace exact occurrences of a given text in a file.
+    """
+    Replace exact occurrences of a given text in a file.
 
-This tool is designed to make minimal, targeted changes—preferably a small region modifications—rather than rewriting large sections or the entire file. Use it for precise, context-aware edits.
+    Args:
+        file_path (str): Path to the file to modify.
+        search_text (str): The exact text to search for (including indentation).
+        replacement_text (str): The text to replace with (including indentation).
+        replace_all (bool): If True, replace all occurrences; otherwise, only the first occurrence.
+        backup (bool, optional): If True, create a backup (.bak) before replacing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+    Returns:
+        str: Status message. Example:
+            - "Text replaced in /path/to/file (backup at /path/to/file.bak)"
+            - "No changes made. [Warning: Search text not found in file] Please review the original file."
+            - "Error replacing text: <error message>"
+    """
 
-NOTE: Indentation (leading whitespace) must be included in both search_text and replacement_text. This tool does not automatically adjust or infer indentation; matches are exact, including whitespace.
-"""
-    def call(self, file_path: str, search_text: str, replacement_text: str, replace_all: bool = False) -> str:
-        """
-        Replace exact occurrences of a given text in a file.
-
-        Args:
-            file_path (str): Path to the file.
-            search_text (str): Text to search for. Must include indentation (leading whitespace) if present in the file.
-            replacement_text (str): Replacement text. Must include desired indentation (leading whitespace).
-            replace_all (bool): If True, replace all occurrences; otherwise, only the first occurrence.
-        Returns:
-            str: Status message. Example:
-                - "Text replaced in /path/to/file"
-                - "No changes made. [Warning: Search text not found in file] Please review the original file."
-                - "Error replacing text: <error message>"
-        """
+    def call(
+        self,
+        file_path: str,
+        search_text: str,
+        replacement_text: str,
+        replace_all: bool = False,
+        backup: bool = False,
+    ) -> str:
         from janito.agent.tools.tools_utils import display_path
+
         disp_path = display_path(file_path)
         action = "all occurrences" if replace_all else None
         # Show only concise info (lengths, not full content)
-        search_preview = (search_text[:20] + '...') if len(search_text) > 20 else search_text
-        replace_preview = (replacement_text[:20] + '...') if len(replacement_text) > 20 else replacement_text
+        search_preview = (
+            (search_text[:20] + "...") if len(search_text) > 20 else search_text
+        )
+        replace_preview = (
+            (replacement_text[:20] + "...")
+            if len(replacement_text) > 20
+            else replacement_text
+        )
         search_lines = len(search_text.splitlines())
         replace_lines = len(replacement_text.splitlines())
-        info_msg = f"📝 Replacing in {disp_path}: {search_lines}→{replace_lines} lines"
+        info_msg = f"\U0001f4dd Replacing in {disp_path}: {search_lines}\u2192{replace_lines} lines"
         if action:
             info_msg += f" ({action})"
         self.report_info(info_msg)
 
         try:
-            with open(file_path, 'r', encoding='utf-8') as f:
+            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
                 content = f.read()
 
             if replace_all:
@@ -49,42 +59,59 @@ NOTE: Indentation (leading whitespace) must be included in both search_text and
             else:
                 occurrences = content.count(search_text)
                 if occurrences > 1:
-                    self.report_warning("⚠️ Search text is not unique.")
+                    self.report_warning("\u26a0\ufe0f Search text is not unique.")
                     warning_detail = "The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
                     return f"No changes made. {warning_detail}"
                 replaced_count = 1 if occurrences == 1 else 0
                 new_content = content.replace(search_text, replacement_text, 1)
+            import shutil
+
+            backup_path = file_path + ".bak"
+            if backup and new_content != content:
+                # Create a .bak backup before writing changes
+                shutil.copy2(file_path, backup_path)
             if new_content != content:
-                with open(file_path, 'w', encoding='utf-8') as f:
+                with open(file_path, "w", encoding="utf-8", errors="replace") as f:
                     f.write(new_content)
                 file_changed = True
             else:
                 file_changed = False
-            warning = ''
+            warning = ""
             if replaced_count == 0:
                 warning = " [Warning: Search text not found in file]"
             if not file_changed:
-                self.report_warning(" ℹ No changes made.")
+                self.report_warning(" \u2139\ufe0f No changes made.")
                 concise_warning = "The search text was not found. Expand your search context with surrounding lines if needed."
                 return f"No changes made. {concise_warning}"
-            
-            self.report_success(f" ✅ {replaced_count} {pluralize('block', replaced_count)} replaced")
+
+            self.report_success(
+                f" \u2705 {replaced_count} {pluralize('block', replaced_count)} replaced"
+            )
+
             # Indentation check for agent warning
             def leading_ws(line):
                 import re
+
                 m = re.match(r"^\s*", line)
-                return m.group(0) if m else ''
-            search_indent = leading_ws(search_text.splitlines()[0]) if search_text.splitlines() else ''
-            replace_indent = leading_ws(replacement_text.splitlines()[0]) if replacement_text.splitlines() else ''
-            indent_warning = ''
+                return m.group(0) if m else ""
+
+            search_indent = (
+                leading_ws(search_text.splitlines()[0])
+                if search_text.splitlines()
+                else ""
+            )
+            replace_indent = (
+                leading_ws(replacement_text.splitlines()[0])
+                if replacement_text.splitlines()
+                else ""
+            )
+            indent_warning = ""
             if search_indent != replace_indent:
                 indent_warning = f" [Warning: Indentation mismatch between search and replacement text: '{search_indent}' vs '{replace_indent}']"
-            if 'warning_detail' in locals():
-                return f"Text replaced in {file_path}{warning}{indent_warning}\n{warning_detail}"
-            return f"Text replaced in {file_path}{warning}{indent_warning}"
+            if "warning_detail" in locals():
+                return f"Text replaced in {file_path}{warning}{indent_warning} (backup at {backup_path})\n{warning_detail}"
+            return f"Text replaced in {file_path}{warning}{indent_warning} (backup at {backup_path})"
 
         except Exception as e:
-            self.report_error(" ❌ Error")
+            self.report_error(" \u274c Error")
             return f"Error replacing text: {e}"
-
-from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/rich_live.py

@@ -7,23 +7,28 @@ console = Console()
 
 _global_live = None
 
+
 @contextmanager
 def global_live_panel(title="Working..."):
     global _global_live
     if _global_live is None:
-        _global_live = Live(Panel("", title=title), console=console, refresh_per_second=4)
+        _global_live = Live(
+            Panel("", title=title), console=console, refresh_per_second=4
+        )
         _global_live.start()
     try:
         yield _global_live
     finally:
         pass  # Do not stop here; stopping is handled explicitly
 
+
 def stop_global_live_panel():
     global _global_live
     if _global_live is not None:
         _global_live.stop()
         _global_live = None
 
+
 @contextmanager
 def live_panel(title="Working..."):
     global _global_live
@@ -33,5 +38,7 @@ def live_panel(title="Working..."):
         yield _global_live
     else:
         # Fallback: create a temporary panel if no global panel is running
-        with Live(Panel("", title=title), console=console, refresh_per_second=4) as live:
+        with Live(
+            Panel("", title=title), console=console, refresh_per_second=4
+        ) as live:
             yield live

janito/agent/tools/run_bash_command.py

@@ -1,107 +1,155 @@
-from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tool_registry import register_tool
-
-import subprocess
-import tempfile
-import sys
-
-@register_tool(name="run_bash_command")
-class RunBashCommandTool(ToolBase):
-    """
-    Execute a non-interactive command using the bash shell and capture live output.
-
-    This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).
-
-    Args:
-        command (str): The bash command to execute.
-        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
-        interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False. Non-interactive commands are preferred for automation and reliability.
-
-    Returns:
-        str: File paths and line counts for stdout and stderr.
-    """
-    def call(self, command: str, timeout: int = 60, require_confirmation: bool = False, interactive: bool = False) -> str:
-        """
-        Execute a bash command and capture live output.
-
-        Args:
-            command (str): The bash command to execute.
-            timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-            require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
-            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
-
-        Returns:
-            str: Output and status message.
-        """
-        """
-        Execute a bash command and capture live output.
-
-        Args:
-            command (str): The bash command to execute.
-            timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-            require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
-            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
-
-        Returns:
-            str: Output and status message.
-        """
-        if not command.strip():
-            self.report_warning("⚠️ Warning: Empty command provided. Operation skipped.")
-            return "Warning: Empty command provided. Operation skipped."
-        self.report_info(f"🖥️  Running bash command: {command}\n")
-        if interactive:
-            self.report_info("⚠️  Warning: This command might be interactive, require user input, and might hang.")
-
-            sys.stdout.flush()
-
-        try:
-            with tempfile.NamedTemporaryFile(mode='w+', prefix='run_bash_stdout_', delete=False, encoding='utf-8') as stdout_file, \
-                 tempfile.NamedTemporaryFile(mode='w+', prefix='run_bash_stderr_', delete=False, encoding='utf-8') as stderr_file:
-                # Use bash explicitly for command execution
-                process = subprocess.Popen(
-                    ["bash", "-c", command],
-                    stdout=stdout_file,
-                    stderr=stderr_file,
-                    text=True
-                )
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(f" ❌ Timed out after {timeout} seconds.")
-                    return f"Command timed out after {timeout} seconds."
-
-                # Print live output to user
-                stdout_file.flush()
-                stderr_file.flush()
-                with open(stdout_file.name, 'r', encoding='utf-8') as out_f:
-                    out_f.seek(0)
-                    for line in out_f:
-                        self.report_stdout(line)
-                with open(stderr_file.name, 'r', encoding='utf-8') as err_f:
-                    err_f.seek(0)
-                    for line in err_f:
-                        self.report_stderr(line)
-
-                # Count lines
-                with open(stdout_file.name, 'r', encoding='utf-8') as out_f:
-                    stdout_lines = sum(1 for _ in out_f)
-                with open(stderr_file.name, 'r', encoding='utf-8') as err_f:
-                    stderr_lines = sum(1 for _ in err_f)
-
-                self.report_success(f" ✅ return code {return_code}")
-                warning_msg = ""
-                if interactive:
-                    warning_msg = "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
-                return (
-                    warning_msg +
-                    f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
-                    f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
-                    f"returncode: {return_code}\n"
-                    f"Use the get_lines tool to inspect the contents of these files when needed."
-                )
-        except Exception as e:
-            self.report_error(f" ❌ Error: {e}")
-            return f"Error running command: {e}"
-
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+
+import subprocess
+import tempfile
+import sys
+
+
+@register_tool(name="run_bash_command")
+class RunBashCommandTool(ToolBase):
+    """
+    Execute a non-interactive command using the bash shell and capture live output.
+
+    This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).
+
+    Args:
+        command (str): The bash command to execute.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
+        interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False. Non-interactive commands are preferred for automation and reliability.
+
+    Returns:
+        str: File paths and line counts for stdout and stderr.
+    """
+
+    def call(
+        self,
+        command: str,
+        timeout: int = 60,
+        require_confirmation: bool = False,
+        interactive: bool = False,
+    ) -> str:
+        """
+        Execute a bash command and capture live output.
+
+        Args:
+            command (str): The bash command to execute.
+            timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+            require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
+            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
+
+        Returns:
+            str: Output and status message.
+        """
+        """
+        Execute a bash command and capture live output.
+
+        Args:
+            command (str): The bash command to execute.
+            timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+            require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
+            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
+
+        Returns:
+            str: Output and status message.
+        """
+        if not command.strip():
+            self.report_warning("⚠️ Warning: Empty command provided. Operation skipped.")
+            return "Warning: Empty command provided. Operation skipped."
+        self.report_info(f"🖥️  Running bash command: {command}\n")
+        if interactive:
+            self.report_info(
+                "⚠️  Warning: This command might be interactive, require user input, and might hang."
+            )
+
+            sys.stdout.flush()
+
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+", prefix="run_bash_stdout_", delete=False, encoding="utf-8"
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+", prefix="run_bash_stderr_", delete=False, encoding="utf-8"
+                ) as stderr_file,
+            ):
+                # Use bash explicitly for command execution
+                process = subprocess.Popen(
+                    ["bash", "-c", command],
+                    stdout=stdout_file,
+                    stderr=stderr_file,
+                    text=True,
+                )
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(f" ❌ Timed out after {timeout} seconds.")
+                    return f"Command timed out after {timeout} seconds."
+
+                # Print live output to user
+                stdout_file.flush()
+                stderr_file.flush()
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    out_f.seek(0)
+                    for line in out_f:
+                        self.report_stdout(line)
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    err_f.seek(0)
+                    for line in err_f:
+                        self.report_stderr(line)
+
+                # Count lines
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    stdout_lines = sum(1 for _ in out_f)
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    stderr_lines = sum(1 for _ in err_f)
+
+                self.report_success(f" ✅ return code {return_code}")
+                warning_msg = ""
+                if interactive:
+                    warning_msg = "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
+
+                # Read output contents
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    stdout_content = out_f.read()
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    stderr_content = err_f.read()
+
+                # Thresholds
+                max_lines = 100
+                if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    result = (
+                        warning_msg
+                        + f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    )
+                    if stderr_content.strip():
+                        result += f"\n--- STDERR ---\n{stderr_content}"
+                    return result
+                else:
+                    result = (
+                        warning_msg
+                        + f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    )
+                    if stderr_lines > 0 and stderr_content.strip():
+                        result += (
+                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        )
+                    result += f"returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed."
+                    return result
+        except Exception as e:
+            self.report_error(f" ❌ Error: {e}")
+            return f"Error running command: {e}"

janito/agent/tools/run_python_command.py

@@ -0,0 +1,139 @@
+import subprocess
+import tempfile
+import sys
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+
+
+@register_tool(name="run_python_command")
+class RunPythonCommandTool(ToolBase):
+    """
+    Tool to execute Python code in a subprocess and capture output.
+
+    Args:
+        code (str): The Python code to execute.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
+        interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
+    Returns:
+        str: File paths and line counts for stdout and stderr, or direct output if small enough.
+    """
+
+    def call(
+        self,
+        code: str,
+        timeout: int = 60,
+        require_confirmation: bool = False,
+        interactive: bool = False,
+    ) -> str:
+        if not code.strip():
+            self.report_warning("⚠️ Warning: Empty code provided. Operation skipped.")
+            return "Warning: Empty code provided. Operation skipped."
+        self.report_info(f"🐍 Running Python code:\n{code}\n")
+        if interactive:
+            self.report_info(
+                "⚠️  Warning: This code might be interactive, require user input, and might hang."
+            )
+        sys.stdout.flush()
+        if require_confirmation:
+            confirmed = self.confirm_action("Do you want to execute this Python code?")
+            if not confirmed:
+                self.report_warning("Execution cancelled by user.")
+                return "Execution cancelled by user."
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    suffix=".py",
+                    prefix="run_python_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as code_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="run_python_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="run_python_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                code_file.write(code)
+                code_file.flush()
+                process = subprocess.Popen(
+                    [sys.executable, code_file.name],
+                    stdout=stdout_file,
+                    stderr=stderr_file,
+                    text=True,
+                )
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(f" ❌ Timed out after {timeout} seconds.")
+                    return f"Code timed out after {timeout} seconds."
+                # Print live output to user
+                stdout_file.flush()
+                stderr_file.flush()
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    out_f.seek(0)
+                    for line in out_f:
+                        self.report_stdout(line)
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    err_f.seek(0)
+                    for line in err_f:
+                        self.report_stderr(line)
+                # Count lines
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    stdout_lines = sum(1 for _ in out_f)
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    stderr_lines = sum(1 for _ in err_f)
+                self.report_success(f" ✅ return code {return_code}")
+                warning_msg = ""
+                if interactive:
+                    warning_msg = "⚠️  Warning: This code might be interactive, require user input, and might hang.\n"
+                # Read output contents
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    stdout_content = out_f.read()
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    stderr_content = err_f.read()
+                # Thresholds
+                max_lines = 100
+                if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    result = (
+                        warning_msg
+                        + f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    )
+                    if stderr_content.strip():
+                        result += f"\n--- STDERR ---\n{stderr_content}"
+                    return result
+                else:
+                    result = (
+                        warning_msg
+                        + f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    )
+                    if stderr_lines > 0 and stderr_content.strip():
+                        result += (
+                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        )
+                    result += f"returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed."
+                    return result
+        except Exception as e:
+            self.report_error(f" ❌ Error: {e}")
+            return f"Error running code: {e}"