janito 3.3.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

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

@@ -1,183 +0,0 @@
-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
-import subprocess
-import tempfile
-import sys
-import os
-import threading
-
-
-@register_local_tool
-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): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
-        requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
-        silent (bool): If True, suppresses progress and status messages. Defaults to False.
-
-    Returns:
-        str: File paths and line counts for stdout and stderr.
-    """
-
-    permissions = ToolPermissions(execute=True)
-    tool_name = "run_bash_command"
-
-    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
-        for line in stream:
-            file_obj.write(line)
-            file_obj.flush()
-            report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
-            if count_func == "stdout":
-                counter["stdout"] += 1
-            else:
-                counter["stderr"] += 1
-
-    def run(
-        self,
-        command: str,
-        timeout: int = 60,
-        require_confirmation: bool = False,
-        requires_user_input: bool = False,
-        silent: bool = False,
-    ) -> str:
-        if not command.strip():
-            self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
-            return tr("Warning: Empty command provided. Operation skipped.")
-        if not silent:
-            self.report_action(
-                tr("🖥️  Run bash command: {command} ...\n", command=command),
-                ReportAction.EXECUTE,
-            )
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        if requires_user_input and not silent:
-            self.report_warning(
-                tr(
-                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
-                ),
-                ReportAction.EXECUTE,
-            )
-            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,
-            ):
-                env = os.environ.copy()
-                env["PYTHONIOENCODING"] = "utf-8"
-                env["LC_ALL"] = "C.UTF-8"
-                env["LANG"] = "C.UTF-8"
-                process = subprocess.Popen(
-                    ["bash", "-c", command],
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True,
-                    encoding="utf-8",
-                    bufsize=1,
-                    env=env,
-                )
-                counter = {"stdout": 0, "stderr": 0}
-                stdout_thread = threading.Thread(
-                    target=self._stream_output,
-                    args=(
-                        process.stdout,
-                        stdout_file,
-                        self.report_stdout,
-                        "stdout",
-                        counter,
-                    ),
-                )
-                stderr_thread = threading.Thread(
-                    target=self._stream_output,
-                    args=(
-                        process.stderr,
-                        stderr_file,
-                        self.report_stderr,
-                        "stderr",
-                        counter,
-                    ),
-                )
-                stdout_thread.start()
-                stderr_thread.start()
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr(
-                            " ❌ Timed out after {timeout} seconds.",
-                            timeout=timeout,
-                        ),
-                        ReportAction.EXECUTE,
-                    )
-                    return tr(
-                        "Command timed out after {timeout} seconds.", timeout=timeout
-                    )
-                stdout_thread.join()
-                stderr_thread.join()
-                stdout_file.flush()
-                stderr_file.flush()
-                if not silent:
-                    self.report_success(
-                        tr(
-                            " ✅ return code {return_code}",
-                            return_code=return_code,
-                        ),
-                        ReportAction.EXECUTE,
-                    )
-                max_lines = 100
-                # Read back the output for summary
-                stdout_file.seek(0)
-                stderr_file.seek(0)
-                stdout_content = stdout_file.read()
-                stderr_content = stderr_file.read()
-                stdout_lines = counter["stdout"]
-                stderr_lines = counter["stderr"]
-                warning_msg = ""
-                if requires_user_input:
-                    warning_msg = tr(
-                        "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
-                    )
-                if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = warning_msg + tr(
-                        "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
-                        return_code=return_code,
-                        stdout_content=stdout_content,
-                    )
-                    if stderr_content.strip():
-                        result += tr(
-                            "\n--- STDERR ---\n{stderr_content}",
-                            stderr_content=stderr_content,
-                        )
-                    return result
-                else:
-                    result = warning_msg + tr(
-                        "[LARGE OUTPUT]\nstdout_file: {stdout_file} (lines: {stdout_lines})\n",
-                        stdout_file=stdout_file.name,
-                        stdout_lines=stdout_lines,
-                    )
-                    if stderr_lines > 0:
-                        result += tr(
-                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
-                            stderr_file=stderr_file.name,
-                            stderr_lines=stderr_lines,
-                        )
-                    result += tr(
-                        "returncode: {return_code}\nUse the view_file tool to inspect the contents of these files when needed.",
-                        return_code=return_code,
-                    )
-                    return result
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            return tr("Error running command: {error}", error=e)

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

@@ -1,218 +0,0 @@
-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
-import subprocess
-import os
-from janito.tools.path_utils import expand_path
-import tempfile
-import threading
-
-
-@register_local_tool
-class RunPowershellCommandTool(ToolBase):
-    """
-    Execute a non-interactive command using the PowerShell shell and capture live output.
-    This tool explicitly invokes 'powershell.exe' (on Windows) or 'pwsh' (on other platforms if available).
-    All commands are automatically prepended with UTF-8 output encoding:
-    $OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
-    For file output, it is recommended to use -Encoding utf8 in your PowerShell commands (e.g., Out-File -Encoding utf8) to ensure correct file encoding.
-
-    Args:
-        command (str): The PowerShell command to execute. This string is passed directly to PowerShell using the --Command argument (not as a script file).
-        timeout (int): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
-        requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
-        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 = "run_powershell_command"
-
-    def _confirm_and_warn(self, command, require_confirmation, requires_user_input):
-        if requires_user_input:
-            self.report_warning(
-                tr(
-                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
-                ),
-                ReportAction.EXECUTE,
-            )
-        if require_confirmation:
-            self.report_warning(
-                tr("⚠️ Confirmation requested, but no handler (auto-confirmed)."),
-                ReportAction.EXECUTE,
-            )
-            return True  # Auto-confirm for now
-        return True
-
-    def _launch_process(self, shell_exe, command_with_encoding):
-        env = os.environ.copy()
-        env["PYTHONIOENCODING"] = "utf-8"
-        return subprocess.Popen(
-            [
-                shell_exe,
-                "-NoProfile",
-                "-ExecutionPolicy",
-                "Bypass",
-                "-Command",
-                command_with_encoding,
-            ],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            bufsize=1,
-            universal_newlines=True,
-            encoding="utf-8",
-            env=env,
-        )
-
-    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
-        for line in stream:
-            file_obj.write(line)
-            file_obj.flush()
-            report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
-            if count_func == "stdout":
-                counter["stdout"] += 1
-            else:
-                counter["stderr"] += 1
-
-    def _format_result(
-        self, requires_user_input, return_code, stdout_file, stderr_file, max_lines=100
-    ):
-        warning_msg = ""
-        if requires_user_input:
-            warning_msg = tr(
-                "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
-            )
-        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()
-        stdout_lines = stdout_content.count("\n")
-        stderr_lines = stderr_content.count("\n")
-        if stdout_lines <= max_lines and stderr_lines <= max_lines:
-            result = warning_msg + tr(
-                "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
-                return_code=return_code,
-                stdout_content=stdout_content,
-            )
-            if stderr_content.strip():
-                result += tr(
-                    "\n--- STDERR ---\n{stderr_content}",
-                    stderr_content=stderr_content,
-                )
-            return result
-        else:
-            result = warning_msg + tr(
-                "stdout_file: {stdout_file} (lines: {stdout_lines})\n",
-                stdout_file=stdout_file.name,
-                stdout_lines=stdout_lines,
-            )
-            if stderr_lines > 0 and stderr_content.strip():
-                result += tr(
-                    "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
-                    stderr_file=stderr_file.name,
-                    stderr_lines=stderr_lines,
-                )
-            result += tr(
-                "returncode: {return_code}\nUse the view_file tool to inspect the contents of these files when needed.",
-                return_code=return_code,
-            )
-            return result
-
-    def run(
-        self,
-        command: str,
-        timeout: int = 60,
-        require_confirmation: bool = False,
-        requires_user_input: bool = False,
-        silent: bool = False,
-    ) -> str:
-        if not command.strip():
-            self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
-            return tr("Warning: Empty command provided. Operation skipped.")
-        encoding_prefix = "$OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; "
-        command_with_encoding = encoding_prefix + command
-        if not silent:
-            self.report_action(
-                tr("🖥️ Running PowerShell command: {command} ...\n", command=command),
-                ReportAction.EXECUTE,
-            )
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        self._confirm_and_warn(command, require_confirmation, requires_user_input)
-        from janito.platform_discovery import PlatformDiscovery
-
-        pd = PlatformDiscovery()
-        shell_exe = "powershell.exe" if pd.is_windows() else "pwsh"
-        try:
-            with (
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="run_powershell_stdout_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stdout_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="run_powershell_stderr_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stderr_file,
-            ):
-                process = self._launch_process(shell_exe, command_with_encoding)
-                counter = {"stdout": 0, "stderr": 0}
-                stdout_thread = threading.Thread(
-                    target=self._stream_output,
-                    args=(
-                        process.stdout,
-                        stdout_file,
-                        self.report_stdout,
-                        "stdout",
-                        counter,
-                    ),
-                )
-                stderr_thread = threading.Thread(
-                    target=self._stream_output,
-                    args=(
-                        process.stderr,
-                        stderr_file,
-                        self.report_stderr,
-                        "stderr",
-                        counter,
-                    ),
-                )
-                stdout_thread.start()
-                stderr_thread.start()
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr(
-                            " ❌ Timed out after {timeout} seconds.",
-                            timeout=timeout,
-                        ),
-                        ReportAction.EXECUTE,
-                    )
-                    return tr(
-                        "Command timed out after {timeout} seconds.", timeout=timeout
-                    )
-                stdout_thread.join()
-                stderr_thread.join()
-                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(
-                    requires_user_input, return_code, stdout_file, stderr_file
-                )
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            return tr("Error running command: {error}", error=e)

janito/plugins_backup_20250825_070018/dev/__init__.py

@@ -1,7 +0,0 @@
-"""
-Development Plugin Package
-
-Contains development-specific tools and utilities.
-"""
-
-__all__ = ["pythondev", "visualization"]

janito/plugins_backup_20250825_070018/dev/pythondev/__init__.py

@@ -1,37 +0,0 @@
-"""
-Python Development Plugin
-
-Python development and execution tools.
-"""
-
-from typing import Optional
-
-
-def python_code_run(code: str, timeout: int = 60) -> str:
-    """Execute Python code via stdin"""
-    return f"python_code_run(code='{len(code)} chars', timeout={timeout})"
-
-
-python_code_run.tool_name = "python_code_run"
-
-
-def python_command_run(code: str, timeout: int = 60) -> str:
-    """Execute Python with -c flag"""
-    return f"python_command_run(code='{len(code)} chars', timeout={timeout})"
-
-
-python_command_run.tool_name = "python_command_run"
-
-
-def python_file_run(path: str, timeout: int = 60) -> str:
-    """Run Python script files"""
-    return f"python_file_run(path='{path}', timeout={timeout})"
-
-
-python_file_run.tool_name = "python_file_run"
-
-
-# Plugin metadata
-__plugin_name__ = "dev.pythondev"
-__plugin_description__ = "Python development and execution"
-__plugin_tools__ = [python_code_run, python_command_run, python_file_run]

janito/plugins_backup_20250825_070018/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