janito 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

janito/agent/tools/move_file.py

@@ -1,10 +1,9 @@
 import os
 import shutil
 from janito.agent.tool_registry import register_tool
-
-# from janito.agent.tools_utils.expand_path import expand_path
 from janito.agent.tools_utils.utils import display_path
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.i18n import tr
 
 
@@ -31,16 +30,55 @@ class MoveFileTool(ToolBase):
     ) -> str:
         original_src = src_path
         original_dest = dest_path
-        src = src_path  # Using src_path as is
-        dest = dest_path  # Using dest_path as is
+        src = src_path
+        dest = dest_path
         disp_src = display_path(original_src)
         disp_dest = display_path(original_dest)
         backup_path = None
+
+        valid, is_src_file, is_src_dir, err_msg = self._validate_source(src, disp_src)
+        if not valid:
+            return err_msg
+
+        dest_result = self._handle_destination(dest, disp_dest, overwrite, backup)
+        if dest_result is not None:
+            backup_path, err_msg = dest_result
+            if err_msg:
+                return err_msg
+
+        try:
+            self.report_info(
+                ActionType.WRITE,
+                tr(
+                    "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
+                    disp_src=disp_src,
+                    disp_dest=disp_dest,
+                ),
+            )
+            shutil.move(src, dest)
+            self.report_success(tr("✅ Move complete."))
+            msg = tr("✅ Move complete.")
+            if backup_path:
+                msg += tr(
+                    " (backup at {backup_disp})",
+                    backup_disp=display_path(backup_path),
+                )
+            return msg
+        except Exception as e:
+            self.report_error(tr("❌ Error moving: {error}", error=e))
+            return tr("❌ Error moving: {error}", error=e)
+
+    def _validate_source(self, src, disp_src):
         if not os.path.exists(src):
             self.report_error(
                 tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
             )
-            return tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
+            return (
+                False,
+                False,
+                False,
+                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src),
+            )
         is_src_file = os.path.isfile(src)
         is_src_dir = os.path.isdir(src)
         if not (is_src_file or is_src_dir):
@@ -50,10 +88,19 @@ class MoveFileTool(ToolBase):
                     disp_src=disp_src,
                 )
             )
-            return tr(
-                "❌ Source path '{disp_src}' is neither a file nor a directory.",
-                disp_src=disp_src,
+            return (
+                False,
+                False,
+                False,
+                tr(
+                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                    disp_src=disp_src,
+                ),
             )
+        return True, is_src_file, is_src_dir, None
+
+    def _handle_destination(self, dest, disp_dest, overwrite, backup):
+        backup_path = None
         if os.path.exists(dest):
             if not overwrite:
                 self.report_error(
@@ -62,7 +109,7 @@ class MoveFileTool(ToolBase):
                         disp_dest=disp_dest,
                     )
                 )
-                return tr(
+                return None, tr(
                     "❗ Destination '{disp_dest}' already exists and overwrite is False.",
                     disp_dest=disp_dest,
                 )
@@ -82,26 +129,7 @@ class MoveFileTool(ToolBase):
                 self.report_error(
                     tr("❌ Error removing destination before move: {error}", error=e)
                 )
-                return tr("❌ Error removing destination before move: {error}", error=e)
-        try:
-            self.report_info(
-                tr(
-                    "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
-                    disp_src=disp_src,
-                    disp_dest=disp_dest,
+                return None, tr(
+                    "❌ Error removing destination before move: {error}", error=e
                 )
-            )
-            shutil.move(src, dest)
-            self.report_success(tr("✅ Move complete."))
-            msg = tr("✅ Move complete.")
-            if backup_path:
-                msg += tr(
-                    " (backup at {backup_disp})",
-                    backup_disp=display_path(
-                        original_dest + (".bak" if is_src_file else ".bak.zip")
-                    ),
-                )
-            return msg
-        except Exception as e:
-            self.report_error(tr("❌ Error moving: {error}", error=e))
-            return tr("❌ Error moving: {error}", error=e)
+        return backup_path, None

janito/agent/tools/open_url.py

@@ -0,0 +1,31 @@
+import webbrowser
+from janito.agent.tool_registry import register_tool
+from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
+from janito.i18n import tr
+
+
+@register_tool(name="open_url")
+class OpenUrlTool(ToolBase):
+    """
+    Open the supplied URL in the default web browser.
+    Args:
+        url (str): The URL to open.
+    Returns:
+        str: Status message indicating the result.
+    """
+
+    def run(self, url: str) -> str:
+        if not url.strip():
+            self.report_warning(tr("ℹ️ Empty URL provided."))
+            return tr("Warning: Empty URL provided. Operation skipped.")
+        self.report_info(ActionType.READ, tr("🌐 Opening URL '{url}' ...", url=url))
+        try:
+            webbrowser.open(url)
+        except Exception as err:
+            self.report_error(
+                tr("❗ Error opening URL: {url}: {err}", url=url, err=str(err))
+            )
+            return tr("Warning: Error opening URL: {url}: {err}", url=url, err=str(err))
+        self.report_success(tr("✅ URL opened in browser: {url}", url=url))
+        return tr("URL opened in browser: {url}", url=url)

janito/agent/tools/present_choices.py

@@ -1,5 +1,6 @@
 from typing import List
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 from janito.i18n import tr
 import questionary
@@ -36,11 +37,12 @@ class PresentChoicesTool(ToolBase):
         if not choices:
             return tr("⚠️ No choices provided.")
         self.report_info(
+            ActionType.EXECUTE,
             tr(
                 "ℹ️ Prompting user: {prompt} (multi_select={multi_select}) ...",
                 prompt=prompt,
                 multi_select=multi_select,
-            )
+            ),
         )
         if multi_select:
             result = questionary.checkbox(

janito/agent/tools/python_command_runner.py

@@ -0,0 +1,149 @@
+import subprocess
+import os
+import sys
+import tempfile
+import threading
+from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
+from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
+
+
+@register_tool(name="python_command_runner")
+class PythonCommandRunnerTool(ToolBase):
+    """
+    Tool to execute Python code using the `python -c` command-line flag.
+    Args:
+        code (str): The Python code to execute as a string.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+
+    def run(self, code: str, timeout: int = 60) -> str:
+        if not code.strip():
+            self.report_warning(tr("\u2139\ufe0f Empty code provided."))
+            return tr("Warning: Empty code provided. Operation skipped.")
+        self.report_info(
+            ActionType.EXECUTE, tr("🐍 Running: python -c ...\n{code}\n", code=code)
+        )
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_cmd_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_cmd_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = subprocess.Popen(
+                    [sys.executable, "-c", code],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    encoding="utf-8",
+                    env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                )
+                stdout_lines, stderr_lines = self._stream_process_output(
+                    process, stdout_file, stderr_file
+                )
+                return_code = self._wait_for_process(process, timeout)
+                if return_code is None:
+                    return tr(
+                        "Code timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_file.flush()
+                stderr_file.flush()
+                self.report_success(
+                    tr("\u2705 Return code {return_code}", return_code=return_code)
+                )
+                return self._format_result(
+                    stdout_file.name, stderr_file.name, return_code
+                )
+        except Exception as e:
+            self.report_error(tr("\u274c Error: {error}", error=e))
+            return tr("Error running code: {error}", error=e)
+
+    def _stream_process_output(self, process, stdout_file, stderr_file):
+        stdout_lines = 0
+        stderr_lines = 0
+
+        def stream_output(stream, file_obj, report_func, count_func):
+            nonlocal stdout_lines, stderr_lines
+            for line in stream:
+                file_obj.write(line)
+                file_obj.flush()
+                report_func(line)
+                if count_func == "stdout":
+                    stdout_lines += 1
+                else:
+                    stderr_lines += 1
+
+        stdout_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+        )
+        stderr_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+        )
+        stdout_thread.start()
+        stderr_thread.start()
+        stdout_thread.join()
+        stderr_thread.join()
+        return stdout_lines, stderr_lines
+
+    def _wait_for_process(self, process, timeout):
+        try:
+            return process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.report_error(
+                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+            )
+            return None
+
+    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
+        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()
+        max_lines = 100
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+
+        def head_tail(text, n=10):
+            lines = text.splitlines()
+            if len(lines) <= 2 * n:
+                return "\n".join(lines)
+            return "\n".join(
+                lines[:n]
+                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                + lines[-n:]
+            )
+
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = 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 = 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}\n"
+            result += "--- STDOUT (head/tail) ---\n" + head_tail(stdout_content) + "\n"
+            if stderr_content.strip():
+                result += (
+                    "--- STDERR (head/tail) ---\n" + head_tail(stderr_content) + "\n"
+                )
+            result += "Use the get_lines tool to inspect the contents of these files when needed."
+            return result

janito/agent/tools/python_file_runner.py

@@ -0,0 +1,147 @@
+import subprocess
+import os
+import sys
+import tempfile
+import threading
+from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
+from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
+
+
+@register_tool(name="python_file_runner")
+class PythonFileRunnerTool(ToolBase):
+    """
+    Tool to execute a specified Python script file.
+    Args:
+        file_path (str): Path to the Python script file to execute.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+
+    def run(self, file_path: str, timeout: int = 60) -> str:
+        self.report_info(
+            ActionType.EXECUTE,
+            tr("🚀 Running: python {file_path}", file_path=file_path),
+        )
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_file_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_file_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = subprocess.Popen(
+                    [sys.executable, file_path],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    encoding="utf-8",
+                    env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                )
+                stdout_lines, stderr_lines = self._stream_process_output(
+                    process, stdout_file, stderr_file
+                )
+                return_code = self._wait_for_process(process, timeout)
+                if return_code is None:
+                    return tr(
+                        "Code timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_file.flush()
+                stderr_file.flush()
+                self.report_success(
+                    tr("\u2705 Return code {return_code}", return_code=return_code)
+                )
+                return self._format_result(
+                    stdout_file.name, stderr_file.name, return_code
+                )
+        except Exception as e:
+            self.report_error(tr("\u274c Error: {error}", error=e))
+            return tr("Error running file: {error}", error=e)
+
+    def _stream_process_output(self, process, stdout_file, stderr_file):
+        stdout_lines = 0
+        stderr_lines = 0
+
+        def stream_output(stream, file_obj, report_func, count_func):
+            nonlocal stdout_lines, stderr_lines
+            for line in stream:
+                file_obj.write(line)
+                file_obj.flush()
+                report_func(line)
+                if count_func == "stdout":
+                    stdout_lines += 1
+                else:
+                    stderr_lines += 1
+
+        stdout_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+        )
+        stderr_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+        )
+        stdout_thread.start()
+        stderr_thread.start()
+        stdout_thread.join()
+        stderr_thread.join()
+        return stdout_lines, stderr_lines
+
+    def _wait_for_process(self, process, timeout):
+        try:
+            return process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.report_error(
+                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+            )
+            return None
+
+    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
+        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()
+        max_lines = 100
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+
+        def head_tail(text, n=10):
+            lines = text.splitlines()
+            if len(lines) <= 2 * n:
+                return "\n".join(lines)
+            return "\n".join(
+                lines[:n]
+                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                + lines[-n:]
+            )
+
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = 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 = 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}\n"
+            result += "--- STDOUT (head/tail) ---\n" + head_tail(stdout_content) + "\n"
+            if stderr_content.strip():
+                result += (
+                    "--- STDERR (head/tail) ---\n" + head_tail(stderr_content) + "\n"
+                )
+            result += "Use the get_lines tool to inspect the contents of these files when needed."
+            return result

janito/agent/tools/python_stdin_runner.py

@@ -0,0 +1,153 @@
+import subprocess
+import os
+import sys
+import tempfile
+import threading
+from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
+from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
+
+
+@register_tool(name="python_stdin_runner")
+class PythonStdinRunnerTool(ToolBase):
+    """
+    Tool to execute Python code by passing it to the interpreter via standard input (stdin).
+    Args:
+        code (str): The Python code to execute as a string.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+
+    def run(self, code: str, timeout: int = 60) -> str:
+        if not code.strip():
+            self.report_warning(tr("\u2139\ufe0f Empty code provided."))
+            return tr("Warning: Empty code provided. Operation skipped.")
+        self.report_info(
+            ActionType.EXECUTE,
+            tr("⚡ Running: python (stdin mode) ...\n{code}\n", code=code),
+        )
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_stdin_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_stdin_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = subprocess.Popen(
+                    [sys.executable],
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    encoding="utf-8",
+                    env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                )
+                stdout_lines, stderr_lines = self._stream_process_output(
+                    process, stdout_file, stderr_file, code
+                )
+                return_code = self._wait_for_process(process, timeout)
+                if return_code is None:
+                    return tr(
+                        "Code timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_file.flush()
+                stderr_file.flush()
+                self.report_success(
+                    tr("\u2705 Return code {return_code}", return_code=return_code)
+                )
+                return self._format_result(
+                    stdout_file.name, stderr_file.name, return_code
+                )
+        except Exception as e:
+            self.report_error(tr("\u274c Error: {error}", error=e))
+            return tr("Error running code via stdin: {error}", error=e)
+
+    def _stream_process_output(self, process, stdout_file, stderr_file, code):
+        stdout_lines = 0
+        stderr_lines = 0
+
+        def stream_output(stream, file_obj, report_func, count_func):
+            nonlocal stdout_lines, stderr_lines
+            for line in stream:
+                file_obj.write(line)
+                file_obj.flush()
+                report_func(line)
+                if count_func == "stdout":
+                    stdout_lines += 1
+                else:
+                    stderr_lines += 1
+
+        stdout_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+        )
+        stderr_thread = threading.Thread(
+            target=stream_output,
+            args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+        )
+        stdout_thread.start()
+        stderr_thread.start()
+        process.stdin.write(code)
+        process.stdin.close()
+        stdout_thread.join()
+        stderr_thread.join()
+        return stdout_lines, stderr_lines
+
+    def _wait_for_process(self, process, timeout):
+        try:
+            return process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            self.report_error(
+                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+            )
+            return None
+
+    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
+        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()
+        max_lines = 100
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+
+        def head_tail(text, n=10):
+            lines = text.splitlines()
+            if len(lines) <= 2 * n:
+                return "\n".join(lines)
+            return "\n".join(
+                lines[:n]
+                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                + lines[-n:]
+            )
+
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = 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 = 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}\n"
+            result += "--- STDOUT (head/tail) ---\n" + head_tail(stdout_content) + "\n"
+            if stderr_content.strip():
+                result += (
+                    "--- STDERR (head/tail) ---\n" + head_tail(stderr_content) + "\n"
+                )
+            result += "Use the get_lines tool to inspect the contents of these files when needed."
+            return result

janito/agent/tools/remove_directory.py

@@ -1,4 +1,5 @@
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools_utils.utils import pluralize, display_path
 from janito.i18n import tr
@@ -24,7 +25,8 @@ class RemoveDirectoryTool(ToolBase):
     def run(self, file_path: str, recursive: bool = False) -> str:
         disp_path = display_path(file_path)
         self.report_info(
-            tr("🗃️ Removing directory '{disp_path}' ...", disp_path=disp_path)
+            ActionType.WRITE,
+            tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
         )
         backup_zip = None
         try:

janito/agent/tools/remove_file.py

@@ -5,6 +5,7 @@ from janito.agent.tool_registry import register_tool
 # from janito.agent.tools_utils.expand_path import expand_path
 from janito.agent.tools_utils.utils import display_path
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.i18n import tr
 
 
@@ -28,7 +29,10 @@ class RemoveFileTool(ToolBase):
         disp_path = display_path(original_path)
         backup_path = None
         # Report initial info about what is going to be removed
-        self.report_info(tr("🗑️ Removing file '{disp_path}' ...", disp_path=disp_path))
+        self.report_info(
+            ActionType.WRITE,
+            tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
+        )
         if not os.path.exists(path):
             self.report_error(tr("❌ File does not exist."))
             return tr("❌ File does not exist.")