janito 3.5.0__py3-none-any.whl → 3.5.1__py3-none-any.whl

janito/plugins/core/system/tools/run_bash_command.py

@@ -30,7 +30,11 @@ class RunBashCommandTool(ToolBase):
     tool_name = "run_bash_command"
 
     def _stream_output(self, stream, file_obj, report_func, count_func, counter):
+        import threading
         for line in stream:
+            # Check for cancellation
+            if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                break
             file_obj.write(line)
             file_obj.flush()
             report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
@@ -87,6 +91,11 @@ class RunBashCommandTool(ToolBase):
                     bufsize=1,
                     env=env,
                 )
+                # Set up cancellation event
+                from janito.llm.cancellation_manager import get_cancellation_manager
+                cancel_manager = get_cancellation_manager()
+                self._cancel_event = cancel_manager.get_current_cancel_event()
+                
                 counter = {"stdout": 0, "stderr": 0}
                 stdout_thread = threading.Thread(
                     target=self._stream_output,
@@ -112,6 +121,14 @@ class RunBashCommandTool(ToolBase):
                 stderr_thread.start()
                 try:
                     return_code = process.wait(timeout=timeout)
+                    # Check if cancelled
+                    if self._cancel_event and self._cancel_event.is_set():
+                        process.kill()
+                        self.report_warning(
+                            tr("Command cancelled by user"),
+                            ReportAction.EXECUTE,
+                        )
+                        return tr("Command cancelled by user")
                 except subprocess.TimeoutExpired:
                     process.kill()
                     self.report_error(
@@ -124,8 +141,12 @@ class RunBashCommandTool(ToolBase):
                     return tr(
                         "Command timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_thread.join()
-                stderr_thread.join()
+                finally:
+                    # Ensure threads are stopped
+                    if self._cancel_event:
+                        self._cancel_event.set()
+                    stdout_thread.join(timeout=0.1)
+                    stderr_thread.join(timeout=0.1)
                 stdout_file.flush()
                 stderr_file.flush()
                 if not silent:

janito/plugins/core/system/tools/run_powershell_command.py

@@ -71,6 +71,9 @@ class RunPowershellCommandTool(ToolBase):
 
     def _stream_output(self, stream, file_obj, report_func, count_func, counter):
         for line in stream:
+            # Check for cancellation
+            if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                break
             file_obj.write(line)
             file_obj.flush()
             report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
@@ -163,6 +166,11 @@ class RunPowershellCommandTool(ToolBase):
                     encoding="utf-8",
                 ) as stderr_file,
             ):
+                # Set up cancellation event
+                from janito.llm.cancellation_manager import get_cancellation_manager
+                cancel_manager = get_cancellation_manager()
+                self._cancel_event = cancel_manager.get_current_cancel_event()
+                
                 process = self._launch_process(shell_exe, command_with_encoding)
                 counter = {"stdout": 0, "stderr": 0}
                 stdout_thread = threading.Thread(
@@ -189,6 +197,14 @@ class RunPowershellCommandTool(ToolBase):
                 stderr_thread.start()
                 try:
                     return_code = process.wait(timeout=timeout)
+                    # Check if cancelled
+                    if self._cancel_event and self._cancel_event.is_set():
+                        process.kill()
+                        self.report_warning(
+                            tr("Command cancelled by user"),
+                            ReportAction.EXECUTE,
+                        )
+                        return tr("Command cancelled by user")
                 except subprocess.TimeoutExpired:
                     process.kill()
                     self.report_error(

janito/plugins/tools/python_code_run.py

@@ -93,6 +93,9 @@ class PythonCodeRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
+                # Check for cancellation
+                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                    break
                 file_obj.write(line)
                 file_obj.flush()
                 report_func(line.rstrip("\r\n"))
@@ -101,6 +104,11 @@ class PythonCodeRun(ToolBase):
                 else:
                     stderr_lines += 1
 
+        # Set up cancellation event
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        self._cancel_event = cancel_manager.get_current_cancel_event()
+        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -111,10 +119,18 @@ class PythonCodeRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        process.stdin.write(code)
-        process.stdin.close()
-        stdout_thread.join()
-        stderr_thread.join()
+        
+        try:
+            process.stdin.write(code)
+            process.stdin.close()
+            stdout_thread.join()
+            stderr_thread.join()
+        except Exception as e:
+            # Handle cancellation or other errors
+            if self._cancel_event and self._cancel_event.is_set():
+                process.kill()
+                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/plugins/tools/python_command_run.py

@@ -92,6 +92,9 @@ class PythonCommandRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
+                # Check for cancellation
+                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                    break
                 file_obj.write(line)
                 file_obj.flush()
                 from janito.tools.tool_base import ReportAction
@@ -102,6 +105,11 @@ class PythonCommandRun(ToolBase):
                 else:
                     stderr_lines += 1
 
+        # Set up cancellation event
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        self._cancel_event = cancel_manager.get_current_cancel_event()
+        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -112,8 +120,16 @@ class PythonCommandRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        stdout_thread.join()
-        stderr_thread.join()
+        
+        try:
+            stdout_thread.join()
+            stderr_thread.join()
+        except Exception as e:
+            # Handle cancellation
+            if self._cancel_event and self._cancel_event.is_set():
+                process.kill()
+                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/plugins/tools/python_file_run.py

@@ -92,6 +92,9 @@ class PythonFileRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
+                # Check for cancellation
+                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                    break
                 file_obj.write(line)
                 file_obj.flush()
                 # Always supply a default action for stdout/stderr reporting
@@ -103,6 +106,11 @@ class PythonFileRun(ToolBase):
                 else:
                     stderr_lines += 1
 
+        # Set up cancellation event
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        self._cancel_event = cancel_manager.get_current_cancel_event()
+        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -113,8 +121,16 @@ class PythonFileRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        stdout_thread.join()
-        stderr_thread.join()
+        
+        try:
+            stdout_thread.join()
+            stderr_thread.join()
+        except Exception as e:
+            # Handle cancellation
+            if self._cancel_event and self._cancel_event.is_set():
+                process.kill()
+                self.report_warning(tr("File execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

{janito-3.5.0.dist-info → janito-3.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.5.0
+Version: 3.5.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

{janito-3.5.0.dist-info → janito-3.5.1.dist-info}/RECORD

@@ -192,13 +192,10 @@ janito/plugins/core/imagedisplay/tools/__init__.py,sha256=z4xyfhiLUYaHBzus1AxaAW
 janito/plugins/core/imagedisplay/tools/show_image.py,sha256=NpQTCMfBZ4NM6DpMe0lTJYH4NHkBCruUR11E4SdLCUw,3095
 janito/plugins/core/imagedisplay/tools/show_image_grid.py,sha256=ZsTbDCBr38xYXbbAJBgRKTLuAOw-_C8799LwHA-1yYQ,3078
 janito/plugins/core/system/__init__.py,sha256=tuaUFus8jTljReloESjdYFWXIEfSEYDct59I-4gZAyc,584
-janito/plugins/core/system/tools/run_bash_command.py,sha256=7fABqAeAu7WJwzzwHmT54_m5OSwPMcgpQ74lQhPG7TA,7955
-janito/plugins/core/system/tools/run_powershell_command.py,sha256=uQSJVQe40wSGbesyvZxDmIKJthAbDJFaxXm1dEN3gBs,9313
+janito/plugins/core/system/tools/run_bash_command.py,sha256=oxDbsLHkznN7WhW4WzIblABk27onJ5EgpAlzyrJ3AfU,9020
+janito/plugins/core/system/tools/run_powershell_command.py,sha256=gWviIUtZvRUgde9TN_kUqYeseyVpsFmOJPMWLOb9_Nw,10152
 janito/plugins/dev/__init__.py,sha256=V7wIaP_LMGBtg6ldz5fmiWf0eL-lSz4vcFgZjKcHAZo,136
 janito/plugins/dev/pythondev/__init__.py,sha256=qAO8Ub1lwBAMcfIt6oX0clTTB2msjIIJNHBRZczhHy8,991
-janito/plugins/dev/pythondev/tools/python_code_run.py,sha256=HdDuiRb7Fd7WC6bFS292XnSI1EYhn9XKlh8Hs_4Cz8E,6981
-janito/plugins/dev/pythondev/tools/python_command_run.py,sha256=BT9emL3PsNGupkENNfUymPECiQEAm9tBhniCaOuatj0,6935
-janito/plugins/dev/pythondev/tools/python_file_run.py,sha256=p0iOoxByCoKqW7QqfxTdHbPbRzEd_KWyZqnzrSb1qLQ,6859
 janito/plugins/dev/visualization/__init__.py,sha256=2zJuePRWKBzuC1_XHg3cguh-JGh4GcvkdENUV3xplz4,547
 janito/plugins/dev/visualization/tools/read_chart.py,sha256=qQebp_MEE_x2AL_pl85uA58A4lbhLQsyGl7wiG_Cjhc,10411
 janito/plugins/tools/__init__.py,sha256=vNqUVWA0guwAYuPgdmiDsjmgibj9siP0e61pfTHZ8-8,271
@@ -214,9 +211,9 @@ janito/plugins/tools/find_files.py,sha256=S4CLC-WmifyEIO7B1Mk52TAEpy4fIFr9GW9QVQ
 janito/plugins/tools/move_file.py,sha256=IgBTH2V3z83K3HT0cHWxAag-E5FoUTKS5nJa-_akvvs,4685
 janito/plugins/tools/open_html_in_browser.py,sha256=82ONg0OSo_8puznWbrgaiZSyBK_G-TejYgsDQM8a2KU,2091
 janito/plugins/tools/open_url.py,sha256=X-fdPCTkJ5WBkNDAjV_XVUh3MDEuDGcv-5PbvfC8y68,1542
-janito/plugins/tools/python_code_run.py,sha256=mepw0_VsP-iE1uN6QoxfiRKp6jEkFLWNiGjRwUi0rDk,6971
-janito/plugins/tools/python_command_run.py,sha256=SxmamLHqmv6JX0VtOzM_JM2NXqHi3TM0g0duNtC8Hr4,6925
-janito/plugins/tools/python_file_run.py,sha256=y6oj636Ue0c5ybylDu4l7n-heLhegMGn1CP_B0_hc-M,6849
+janito/plugins/tools/python_code_run.py,sha256=BIc7hPTsEqsCo3BTZviVZjoj8baQE9wNz7pQLUT8HFI,7715
+janito/plugins/tools/python_command_run.py,sha256=nbXxuoDADPw5wR5ysNm5tIwFN9RrrshoQISBscXd_Ow,7645
+janito/plugins/tools/python_file_run.py,sha256=jIbzBwjAHLY2xy2crQpdFj9KH3VjaD4qc7TxbkeNW88,7569
 janito/plugins/tools/read_chart.py,sha256=8KT-Zzfpdp68QN6Pl8enDLPrKRBY2lhcKsJ8scS6i3o,10401
 janito/plugins/tools/read_files.py,sha256=7RVj4qescT__VHe1k_VdnpHKHY5YeG0fqPiNIopd3Is,2319
 janito/plugins/tools/remove_directory.py,sha256=jmY0pSrOJVQqR-_P7OuZijovAKkNB5cDk8BAAKVvvLI,1903
@@ -328,9 +325,9 @@ janito/tools/url_whitelist.py,sha256=0CPLkHTp5HgnwgjxwgXnJmwPeZQ30q4j3YjW59hiUUE
 janito/tools/adapters/__init__.py,sha256=H25uYM2ETMLKpKPPEPAu9-AFjxkKfSyfx3pnoXSQlVA,255
 janito/tools/adapters/local/__init__.py,sha256=1DVnka4iEQp8Xrs7rJVVx45fPpuVahjTFmuJhv-gN8s,249
 janito/tools/adapters/local/adapter.py,sha256=u4nLHTaYdwZXMi1J8lsKvlG6rOmdq9xjey_3zeyCG4k,8707
-janito-3.5.0.dist-info/licenses/LICENSE,sha256=dXV4fOF2ZErugtN8l_Nrj5tsRTYgtjE3cgiya0UfBio,11356
-janito-3.5.0.dist-info/METADATA,sha256=voeu6zQPSo_wytQfWnCUoe6wYviDtAxgX_f9ktc6N_g,6093
-janito-3.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-janito-3.5.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
-janito-3.5.0.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
-janito-3.5.0.dist-info/RECORD,,
+janito-3.5.1.dist-info/licenses/LICENSE,sha256=dXV4fOF2ZErugtN8l_Nrj5tsRTYgtjE3cgiya0UfBio,11356
+janito-3.5.1.dist-info/METADATA,sha256=1r4YjdQ2OvewXvPBmWjeog5ssJCkjZR_xFgEO_gkJzI,6093
+janito-3.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+janito-3.5.1.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
+janito-3.5.1.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
+janito-3.5.1.dist-info/RECORD,,

janito/plugins/dev/pythondev/tools/python_code_run.py

@@ -1,172 +0,0 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.i18n import tr
-
-
-@register_local_tool
-class PythonCodeRunTool(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): Timeout in seconds for the command. Defaults to 60.
-        silent (bool): If True, suppresses progress and status messages. Defaults to False.
-
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    permissions = ToolPermissions(execute=True)
-    tool_name = "python_code_run"
-
-    def run(self, code: str, timeout: int = 60, silent: bool = False) -> str:
-        if not code.strip():
-            self.report_warning(tr("ℹ️ Empty code provided."), ReportAction.EXECUTE)
-            return tr("Warning: Empty code provided. Operation skipped.")
-        if not silent:
-            self.report_action(
-                tr("⚡ Running: python (stdin mode) ...\n{code}\n", code=code),
-                ReportAction.EXECUTE,
-            )
-            self.report_stdout("\n")
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        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()
-                if not silent:
-                    self.report_success(
-                        tr("✅ Return code {return_code}", return_code=return_code),
-                        ReportAction.EXECUTE,
-                    )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
-                )
-        except Exception as e:
-            self.report_error(tr("❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            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.rstrip("\r\n"))
-                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("❌ Timed out after {timeout} seconds.", timeout=timeout),
-                ReportAction.EXECUTE,
-            )
-            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--- python_code_run: STDOUT ---\n{stdout_content}"
-            if stderr_content.strip():
-                result += f"\n--- python_code_run: 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 += (
-                "--- python_code_run: STDOUT (head/tail) ---\n"
-                + head_tail(stdout_content)
-                + "\n"
-            )
-            if stderr_content.strip():
-                result += (
-                    "--- python_code_run: STDERR (head/tail) ---\n"
-                    + head_tail(stderr_content)
-                    + "\n"
-                )
-            result += "Use the view_file tool to inspect the contents of these files when needed."
-            return result

janito/plugins/dev/pythondev/tools/python_command_run.py

@@ -1,171 +0,0 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.i18n import tr
-
-
-@register_local_tool
-class PythonCommandRunTool(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): Timeout in seconds for the command. Defaults to 60.
-        silent (bool): If True, suppresses progress and status messages. Defaults to False.
-
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    permissions = ToolPermissions(execute=True)
-    tool_name = "python_command_run"
-
-    def run(self, code: str, timeout: int = 60, silent: bool = False) -> str:
-        if not code.strip():
-            self.report_warning(tr("ℹ️ Empty code provided."), ReportAction.EXECUTE)
-            return tr("Warning: Empty code provided. Operation skipped.")
-        if not silent:
-            self.report_action(
-                tr("🐍 Running: python -c ...\n{code}\n", code=code),
-                ReportAction.EXECUTE,
-            )
-            self.report_stdout("\n")
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        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()
-                if not silent:
-                    self.report_success(
-                        tr("✅ Return code {return_code}", return_code=return_code),
-                        ReportAction.EXECUTE,
-                    )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
-                )
-        except Exception as e:
-            self.report_error(tr("❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            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()
-                from janito.tools.tool_base import ReportAction
-
-                report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
-                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("❌ Timed out after {timeout} seconds.", timeout=timeout),
-                ReportAction.EXECUTE,
-            )
-            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--- python_command_run: STDOUT ---\n{stdout_content}"
-            if stderr_content.strip():
-                result += f"\n--- python_command_run: 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 += (
-                "--- python_command_run: STDOUT (head/tail) ---\n"
-                + head_tail(stdout_content)
-                + "\n"
-            )
-            if stderr_content.strip():
-                result += (
-                    "--- python_command_run: STDERR (head/tail) ---\n"
-                    + head_tail(stderr_content)
-                    + "\n"
-                )
-            result += "Use the view_file tool to inspect the contents of these files when needed."
-            return result

janito/plugins/dev/pythondev/tools/python_file_run.py

@@ -1,172 +0,0 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.i18n import tr
-
-
-@register_local_tool
-class PythonFileRunTool(ToolBase):
-    """
-    Tool to execute a specified Python script file.
-
-    Args:
-        path (str): Path to the Python script file to execute.
-        timeout (int): Timeout in seconds for the command. Defaults to 60.
-        silent (bool): If True, suppresses progress and status messages. Defaults to False.
-
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    permissions = ToolPermissions(execute=True)
-    tool_name = "python_file_run"
-
-    def run(self, path: str, timeout: int = 60, silent: bool = False) -> str:
-        from janito.tools.path_utils import expand_path
-
-        path = expand_path(path)
-        if not silent:
-            self.report_action(
-                tr("🚀 Running: python {path}", path=path),
-                ReportAction.EXECUTE,
-            )
-            self.report_stdout("\n")
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        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, 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()
-                if not silent:
-                    self.report_success(
-                        tr("✅ Return code {return_code}", return_code=return_code),
-                        ReportAction.EXECUTE,
-                    )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
-                )
-        except Exception as e:
-            self.report_error(tr("❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            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()
-                # Always supply a default action for stdout/stderr reporting
-                from janito.report_events import ReportAction
-
-                report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
-                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("❌ Timed out after {timeout} seconds.", timeout=timeout),
-                ReportAction.EXECUTE,
-            )
-            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--- python_file_run: STDOUT ---\n{stdout_content}"
-            if stderr_content.strip():
-                result += f"\n--- python_file_run: 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 += (
-                "--- python_file_run: STDOUT (head/tail) ---\n"
-                + head_tail(stdout_content)
-                + "\n"
-            )
-            if stderr_content.strip():
-                result += (
-                    "--- python_file_run: STDERR (head/tail) ---\n"
-                    + head_tail(stderr_content)
-                    + "\n"
-                )
-            result += "Use the view_file tool to inspect the contents of these files when needed."
-            return result