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

janito/plugins_backup_20250825_070018/core/imagedisplay/tools/show_image.py

@@ -0,0 +1,83 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+class ShowImageTool(ToolBase):
+    """Display an image inline in the terminal using the rich library.
+
+    Args:
+        path (str): Path to the image file.
+        width (int, optional): Target width in terminal cells. If unset, auto-fit.
+        height (int, optional): Target height in terminal rows. If unset, auto-fit.
+        preserve_aspect (bool, optional): Preserve aspect ratio. Default: True.
+
+    Returns:
+        str: Status message indicating display result or error details.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "show_image"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(
+        self,
+        path: str,
+        width: int | None = None,
+        height: int | None = None,
+        preserve_aspect: bool = True,
+    ) -> str:
+        from janito.tools.tool_utils import display_path
+        from janito.tools.path_utils import expand_path
+        import os
+
+        # Defer heavy imports to runtime
+        try:
+            from rich.console import Console
+            from PIL import Image as PILImage
+        except Exception as e:
+            msg = tr("⚠️ Missing dependency: PIL/Pillow ({error})", error=e)
+            self.report_error(msg)
+            return msg
+
+        path = expand_path(path)
+        disp_path = display_path(path)
+        self.report_action(
+            tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ
+        )
+
+        if not os.path.exists(path):
+            msg = tr("❗ not found")
+            self.report_warning(msg)
+            return tr("Error: file not found: {path}", path=disp_path)
+
+        try:
+            console = Console()
+            # rich.image.Image handles inline terminal display of common formats
+            from rich.console import Console
+            from rich.text import Text
+
+            console = Console()
+            img = PILImage.open(path)
+            console.print(
+                Text(
+                    f"Image: {disp_path} ({img.width}x{img.height})", style="bold green"
+                )
+            )
+            console.print(img)
+            self.report_success(tr("✅ Displayed"))
+            details = []
+            if width:
+                details.append(f"width={width}")
+            if height:
+                details.append(f"height={height}")
+            if not preserve_aspect:
+                details.append("preserve_aspect=False")
+            info = ("; ".join(details)) if details else "auto-fit"
+            return tr(
+                "Image displayed: {disp_path} ({info})", disp_path=disp_path, info=info
+            )
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error displaying image: {error}", error=e)

janito/plugins_backup_20250825_070018/core/imagedisplay/tools/show_image_grid.py

@@ -0,0 +1,84 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+from typing import Sequence
+
+
+class ShowImageGridTool(ToolBase):
+    """Display multiple images in a grid inline in the terminal using rich.
+
+    Args:
+        paths (list[str]): List of image file paths.
+        columns (int, optional): Number of columns in the grid. Default: 2.
+        width (int, optional): Max width for each image cell. Default: None (auto).
+        height (int, optional): Max height for each image cell. Default: None (auto).
+        preserve_aspect (bool, optional): Preserve aspect ratio. Default: True.
+
+    Returns:
+        str: Status string summarizing the grid display.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "show_image_grid"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
+    def run(
+        self,
+        paths: Sequence[str],
+        columns: int = 2,
+        width: int | None = None,
+        height: int | None = None,
+        preserve_aspect: bool = True,
+    ) -> str:
+        from janito.tools.path_utils import expand_path
+        from janito.tools.tool_utils import display_path
+        import os
+
+        try:
+            from rich.console import Console
+            from rich.columns import Columns
+            from PIL import Image as PILImage
+            from rich.panel import Panel
+        except Exception as e:
+            msg = tr("⚠️ Missing dependency: PIL/Pillow ({error})", error=e)
+            self.report_error(msg)
+            return msg
+
+        if not paths:
+            return tr("No images provided")
+
+        self.report_action(
+            tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ
+        )
+
+        console = Console()
+        images = []
+        shown = 0
+        for p in paths:
+            fp = expand_path(p)
+            if not os.path.exists(fp):
+                self.report_warning(tr("❗ not found: {p}", p=display_path(fp)))
+                continue
+            try:
+                img = PILImage.open(fp)
+                title = f"{display_path(fp)} ({img.width}x{img.height})"
+                images.append(
+                    Panel.fit(title, title=display_path(fp), border_style="dim")
+                )
+                shown += 1
+            except Exception as e:
+                self.report_warning(tr("⚠️ Skipped {p}: {e}", p=display_path(fp), e=e))
+
+        if not images:
+            return tr("No images could be displayed")
+
+        # Render in columns (grid-like)
+        console.print(Columns(images, equal=True, expand=True, columns=columns))
+        self.report_success(tr("✅ Displayed {n} images", n=shown))
+        return tr(
+            "Displayed {shown}/{total} images in a {cols}x? grid",
+            shown=shown,
+            total=len(paths),
+            cols=columns,
+        )

janito/plugins_backup_20250825_070018/core/system/__init__.py

@@ -0,0 +1,23 @@
+"""
+System Tools Plugin
+
+System-level operations and shell access.
+"""
+
+from typing import Optional
+
+
+def run_powershell_command(
+    command: str, timeout: int = 60, require_confirmation: bool = False
+) -> str:
+    """Execute PowerShell commands"""
+    return f"run_powershell_command(command='{command[:50]}...', timeout={timeout})"
+
+
+run_powershell_command.tool_name = "run_powershell_command"
+
+
+# Plugin metadata
+__plugin_name__ = "core.system"
+__plugin_description__ = "System-level operations and shell access"
+__plugin_tools__ = [run_powershell_command]

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

@@ -0,0 +1,183 @@
+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

@@ -0,0 +1,218 @@
+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

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

janito/plugins_backup_20250825_070018/dev/pythondev/__init__.py

@@ -0,0 +1,37 @@
+"""
+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]