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

janito/plugins_backup_20250825_070018/core/filemanager/tools/view_file.py

@@ -0,0 +1,172 @@
+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.tools.tool_utils import pluralize
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+class ViewFileTool(ToolBase):
+    """
+    Read lines from a file. You can specify a line range, or read the entire file by simply omitting the from_line and to_line parameters.
+
+    Args:
+        path (str): Path to the file to read lines from.
+        from_line (int, optional): Starting line number (1-based). Omit to start from the first line.
+        to_line (int, optional): Ending line number (1-based). Omit to read to the end of the file.
+
+    To read the full file, just provide path and leave from_line and to_line unset.
+
+    Returns:
+        str: File content with a header indicating the file name and line range. Example:
+            - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
+            - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
+            - "Error reading file: <error message>"
+            - "❗ not found"
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "view_file"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str, from_line: int = None, to_line: int = None) -> str:
+        import os
+        from janito.tools.tool_utils import display_path
+        from janito.tools.path_utils import expand_path
+
+        path = expand_path(path)
+        disp_path = display_path(path)
+        self.report_action(
+            tr("📖 View '{disp_path}'", disp_path=disp_path),
+            ReportAction.READ,
+        )
+        try:
+            if os.path.isdir(path):
+                return self._list_directory(path, disp_path)
+            lines = self._read_file_lines(path)
+            selected, selected_len, total_lines = self._select_lines(
+                lines, from_line, to_line
+            )
+            self._report_success(selected_len, from_line, to_line, total_lines)
+            header = self._format_header(
+                disp_path, from_line, to_line, selected_len, total_lines
+            )
+            return header + "".join(selected)
+        except FileNotFoundError as e:
+            self.report_warning(tr("❗ not found"))
+            return f"Error reading file: {e}"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error reading file: {error}", error=e)
+
+    def _list_directory(self, path, disp_path):
+        import os
+
+        try:
+            entries = os.listdir(path)
+            entries.sort()
+            # Suffix subdirectories with '/'
+            formatted_entries = []
+            for entry in entries:
+                full_path = os.path.join(path, entry)
+                if os.path.isdir(full_path):
+                    formatted_entries.append(entry + "/")
+                else:
+                    formatted_entries.append(entry)
+            header = (
+                f"--- view_file: {disp_path} [directory, {len(entries)} entries] ---\n"
+            )
+            listing = "\n".join(formatted_entries)
+            self.report_success(tr("📁 Directory ({count} items)", count=len(entries)))
+            return header + listing + "\n"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error listing directory: {error}", error=e))
+            return tr("Error listing directory: {error}", error=e)
+
+    def _read_file_lines(self, path):
+        """Read all lines from the file."""
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            return f.readlines()
+
+    def _select_lines(self, lines, from_line, to_line):
+        """Select the requested lines and return them with their count and total lines."""
+        selected = lines[
+            (from_line - 1 if from_line else 0) : (to_line if to_line else None)
+        ]
+        selected_len = len(selected)
+        total_lines = len(lines)
+        return selected, selected_len, total_lines
+
+    def _report_success(self, selected_len, from_line, to_line, total_lines):
+        """Report the success message after reading lines."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = to_line >= total_lines or selected_len < requested
+            if at_end:
+                self.report_success(
+                    tr(
+                        " ✅ {selected_len} {line_word} (end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                    )
+                )
+            elif to_line < total_lines:
+                self.report_success(
+                    tr(
+                        " ✅ {selected_len} {line_word} ({remaining} to end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                        remaining=total_lines - to_line,
+                    )
+                )
+        else:
+            self.report_success(
+                tr(
+                    " ✅ {selected_len} {line_word} (all)",
+                    selected_len=selected_len,
+                    line_word=pluralize("line", selected_len),
+                )
+            )
+
+    def _format_header(self, disp_path, from_line, to_line, selected_len, total_lines):
+        """Format the header for the output."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = selected_len < requested or to_line >= total_lines
+            if at_end:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                )
+            else:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                    total_lines=total_lines,
+                )
+        elif from_line:
+            return tr(
+                "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
+                disp_path=disp_path,
+                from_line=from_line,
+                total_lines=total_lines,
+            )
+        else:
+            return tr(
+                "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
+                disp_path=disp_path,
+                total_lines=total_lines,
+            )
+
+    def _handle_read_error(self, e):
+        """Handle file read errors and report appropriately."""
+        if isinstance(e, FileNotFoundError):
+            self.report_error(tr("❗ not found"), ReportAction.READ)
+            return tr("❗ not found")
+        self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.READ)
+        return tr("Error reading file: {error}", error=e)

janito/plugins_backup_20250825_070018/core/imagedisplay/__init__.py

@@ -0,0 +1,14 @@
+"""
+Image Display Plugin - Core plugin for displaying images inline in the terminal.
+
+This plugin provides tools for displaying images directly in the terminal using
+rich library's image rendering capabilities.
+"""
+
+from .plugin import ImageDisplayPlugin
+
+# Plugin metadata for discovery/listing
+__plugin_name__ = "core.imagedisplay"
+__plugin_description__ = "Display images inline in the terminal using rich"
+
+__all__ = ["ImageDisplayPlugin"]

janito/plugins_backup_20250825_070018/core/imagedisplay/plugin.py

@@ -0,0 +1,51 @@
+"""
+Image Display Plugin implementation.
+"""
+
+from typing import Dict, Any, List, Type
+
+from janito.plugin_system.base import Plugin, PluginMetadata
+from janito.tools.tool_base import ToolBase
+from .tools.show_image import ShowImageTool
+from .tools.show_image_grid import ShowImageGridTool
+
+
+class ImageDisplayPlugin(Plugin):
+    """Plugin for displaying images inline in the terminal using rich."""
+
+    def get_metadata(self) -> PluginMetadata:
+        return PluginMetadata(
+            name="core.imagedisplay",
+            version="1.0.0",
+            description="Display images inline in the terminal using rich",
+            author="Janito",
+            dependencies=["rich", "pillow"],
+        )
+
+    def get_tools(self) -> List[Type[ToolBase]]:
+        # Return tool classes so the PluginManager can register them
+        return [ShowImageTool, ShowImageGridTool]
+
+    def get_config_schema(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "default_width": {
+                    "type": "integer",
+                    "description": "Default width for image display",
+                    "minimum": 1,
+                    "maximum": 200,
+                },
+                "default_height": {
+                    "type": "integer",
+                    "description": "Default height for image display",
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+                "preserve_aspect": {
+                    "type": "boolean",
+                    "description": "Preserve aspect ratio by default",
+                    "default": True,
+                },
+            },
+        }

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

@@ -0,0 +1 @@
+"""Tools for image display plugin."""

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)