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

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

@@ -1,204 +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):
-        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)
-            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,
-                )
-                # 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,
-                    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)
-                    # 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(
-                        tr(
-                            " ❌ Timed out after {timeout} seconds.",
-                            timeout=timeout,
-                        ),
-                        ReportAction.EXECUTE,
-                    )
-                    return tr(
-                        "Command timed out after {timeout} seconds.", timeout=timeout
-                    )
-                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:
-                    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/core/system/tools/run_powershell_command.py

@@ -1,234 +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:
-            # 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)
-            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,
-            ):
-                # 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(
-                    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)
-                    # 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(
-                        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/dev/__init__.py

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

janito/plugins/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/dev/visualization/__init__.py

@@ -1,23 +0,0 @@
-"""
-Visualization Plugin
-
-Data visualization and charting tools.
-"""
-
-from typing import Dict, Any
-
-
-def read_chart(
-    data: Dict[str, Any], title: str = "Chart", width: int = 80, height: int = 20
-) -> str:
-    """Display charts in terminal (bar, line, pie, table)"""
-    return f"read_chart(type='{data.get('type')}', title='{title}')"
-
-
-read_chart.tool_name = "read_chart"
-
-
-# Plugin metadata
-__plugin_name__ = "dev.visualization"
-__plugin_description__ = "Data visualization and charts"
-__plugin_tools__ = [read_chart]

janito/plugins/example_plugin.py

@@ -1,108 +0,0 @@
-"""
-Example plugin demonstrating the plugin system.
-"""
-
-from janito.plugin_system.base import Plugin, PluginMetadata, PluginResource
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from typing import Dict, Any
-
-
-class HelloWorldTool(ToolBase):
-    """A simple tool that says hello."""
-
-    tool_name = "hello_world"
-    permissions = ToolPermissions(read=True, write=False, execute=True)
-
-    def run(self, name: str = "World") -> str:
-        """
-        Say hello to someone.
-
-        Args:
-            name: Name of the person to greet
-
-        Returns:
-            Greeting message
-        """
-        self.report_action(f"Saying hello to {name}", "greet")
-        return f"Hello, {name}!"
-
-
-class CalculatorTool(ToolBase):
-    """A simple calculator tool."""
-
-    tool_name = "calculator"
-    permissions = ToolPermissions(read=True, write=False, execute=True)
-
-    def run(self, operation: str, a: float, b: float) -> str:
-        """
-        Perform basic calculations.
-
-        Args:
-            operation: Operation to perform (add, subtract, multiply, divide)
-            a: First number
-            b: Second number
-
-        Returns:
-            Result as string
-        """
-        self.report_action(f"Calculating {a} {operation} {b}", "calculate")
-
-        if operation == "add":
-            result = a + b
-        elif operation == "subtract":
-            result = a - b
-        elif operation == "multiply":
-            result = a * b
-        elif operation == "divide":
-            if b == 0:
-                return "Error: Division by zero"
-            result = a / b
-        else:
-            return f"Error: Unknown operation '{operation}'"
-
-        return str(result)
-
-
-class ExamplePlugin(Plugin):
-    """Example plugin providing basic tools."""
-
-    def get_metadata(self) -> PluginMetadata:
-        return PluginMetadata(
-            name="example",
-            version="1.0.0",
-            description="Example plugin with basic tools",
-            author="Janito Team",
-            license="MIT",
-            homepage="https://github.com/janito/example-plugin",
-        )
-
-    def get_tools(self):
-        return [HelloWorldTool, CalculatorTool]
-
-    def initialize(self):
-        print("Example plugin initialized!")
-
-    def cleanup(self):
-        print("Example plugin cleaned up!")
-
-    def get_config_schema(self) -> Dict[str, Any]:
-        """Return JSON schema for plugin configuration."""
-        return {
-            "type": "object",
-            "properties": {
-                "greeting_prefix": {
-                    "type": "string",
-                    "description": "Custom greeting prefix for hello_world tool",
-                    "default": "Hello",
-                },
-                "max_calculation": {
-                    "type": "number",
-                    "description": "Maximum allowed calculation result",
-                    "default": 1000000,
-                },
-            },
-        }
-
-
-# This makes the plugin discoverable
-PLUGIN_CLASS = ExamplePlugin

janito/plugins/tools/__init__.py

@@ -1,10 +0,0 @@
-"""
-Core tools plugin for janito.
-
-This plugin provides the essential tools for file operations, code execution,
-and system interactions that are core to janito's functionality.
-"""
-
-from .core_tools_plugin import CoreToolsPlugin
-
-__all__ = ["CoreToolsPlugin"]