janito 3.14.2__py3-none-any.whl → 3.15.0__py3-none-any.whl

janito/plugins/tools/local/run_powershell_command.py

@@ -1,218 +1,217 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.plugins.tools.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)
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.plugins.tools.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)
+
+    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/tools/local/show_image.py

@@ -20,7 +20,6 @@ class ShowImageTool(ToolBase):
     """
 
     permissions = ToolPermissions(read=True)
-    tool_name = "show_image"
 
     @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
     def run(

janito/plugins/tools/local/show_image_grid.py

@@ -22,7 +22,6 @@ class ShowImageGridTool(ToolBase):
     """
 
     permissions = ToolPermissions(read=True)
-    tool_name = "show_image_grid"
 
     @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
     def run(

janito/plugins/tools/local/view_file.py

@@ -29,7 +29,6 @@ class ViewFileTool(ToolBase):
     """
 
     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, as_base64: bool = False) -> str:

janito/providers/alibaba/provider.py

@@ -19,7 +19,7 @@ class AlibabaProvider(LLMProvider):
     NAME = "alibaba"  # For backward compatibility
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "qwen3-next-80b-a3b-instruct"  # 256k context, latest Qwen3 Next model
+    DEFAULT_MODEL = "qwen3-max-preview"  # 256k context, Qwen3 Max Preview standard model
     available = OpenAIModelDriver.available
     unavailable_reason = OpenAIModelDriver.unavailable_reason
 

janito/tools/base.py

@@ -1,12 +1,19 @@
-class BaseTool:
-    """Base class for all tools."""
-
-    tool_name: str = ""
-
-    def __init__(self):
-        if not self.tool_name:
-            self.tool_name = self.__class__.__name__.lower()
-
-    def run(self, *args, **kwargs) -> str:
-        """Execute the tool."""
-        raise NotImplementedError
+class BaseTool:
+    """Base class for all tools."""
+
+    @property
+    def tool_name(self) -> str:
+        """Derive tool name from class name by convention."""
+        # Convert class name to snake_case and remove 'tool' suffix if present
+        class_name = self.__class__.__name__
+        if class_name.endswith('Tool'):
+            class_name = class_name[:-4]
+        
+        # Convert CamelCase to snake_case
+        import re
+        name = re.sub(r'(?<!^)(?=[A-Z])', '_', class_name).lower()
+        return name
+
+    def run(self, *args, **kwargs) -> str:
+        """Execute the tool."""
+        raise NotImplementedError