janito 1.14.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/agent/tools/run_bash_command.py

@@ -1,218 +0,0 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.i18n import tr
-import subprocess
-import tempfile
-import sys
-import os
-import threading
-from janito.agent.runtime_config import runtime_config
-
-
-@register_tool(name="run_bash_command")
-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, optional): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
-        requires_user_input (bool, optional): 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.
-    Returns:
-        str: File paths and line counts for stdout and stderr.
-    """
-
-    def _stream_output(
-        self,
-        stream,
-        report_func,
-        accum=None,
-        file_obj=None,
-        count_func=None,
-        counter=None,
-    ):
-        for line in stream:
-            if accum is not None:
-                accum.append(line)
-            if file_obj is not None:
-                file_obj.write(line)
-                file_obj.flush()
-            report_func(line)
-            if counter is not None and count_func is not None:
-                counter[count_func] += 1
-
-    def _handle_all_out(self, process, timeout):
-        stdout_accum = []
-        stderr_accum = []
-        stdout_thread = threading.Thread(
-            target=self._stream_output,
-            args=(process.stdout, self.report_stdout, stdout_accum),
-        )
-        stderr_thread = threading.Thread(
-            target=self._stream_output,
-            args=(process.stderr, self.report_stderr, stderr_accum),
-        )
-        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)
-            )
-            return tr("Command timed out after {timeout} seconds.", timeout=timeout)
-        stdout_thread.join()
-        stderr_thread.join()
-        self.report_success(
-            tr(" ✅ return code {return_code}", return_code=return_code)
-        )
-        stdout_content = "".join(stdout_accum)
-        stderr_content = "".join(stderr_accum)
-        result = 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
-
-    def _handle_file_out(self, process, timeout):
-        max_lines = 100
-        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,
-        ):
-            counter = {"stdout": 0, "stderr": 0}
-            stdout_thread = threading.Thread(
-                target=self._stream_output,
-                args=(
-                    process.stdout,
-                    self.report_stdout,
-                    None,
-                    stdout_file,
-                    "stdout",
-                    counter,
-                ),
-            )
-            stderr_thread = threading.Thread(
-                target=self._stream_output,
-                args=(
-                    process.stderr,
-                    self.report_stderr,
-                    None,
-                    stderr_file,
-                    "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)
-                )
-                return tr("Command timed out after {timeout} seconds.", timeout=timeout)
-            stdout_thread.join()
-            stderr_thread.join()
-            stdout_file.flush()
-            stderr_file.flush()
-            self.report_success(
-                tr(" ✅ return code {return_code}", return_code=return_code)
-            )
-            stdout_file.seek(0)
-            stderr_file.seek(0)
-            stdout_content = stdout_file.read()
-            stderr_content = stderr_file.read()
-            stdout_lines = stdout_content.count("\n")
-            stderr_lines = stderr_content.count("\n")
-            if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                result = 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 = 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 get_lines 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,
-    ) -> str:
-        if not command.strip():
-            self.report_warning(tr("ℹ️ Empty command provided."))
-            return tr("Warning: Empty command provided. Operation skipped.")
-        self.report_info(
-            ActionType.EXECUTE,
-            tr("🖥️ Run bash command: {command} ...\n", command=command),
-        )
-        if requires_user_input:
-            self.report_warning(
-                tr(
-                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
-                )
-            )
-            sys.stdout.flush()
-        try:
-            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,
-            )
-            if runtime_config.get("all_out"):
-                return self._handle_all_out(process, timeout)
-            else:
-                return self._handle_file_out(process, timeout)
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e))
-            return tr("Error running command: {error}", error=e)

janito/agent/tools/run_powershell_command.py

@@ -1,251 +0,0 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.i18n import tr
-import subprocess
-import os
-import tempfile
-import threading
-from janito.agent.runtime_config import runtime_config
-
-
-@register_tool(name="run_powershell_command")
-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, optional): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
-        requires_user_input (bool, optional): 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.
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    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."
-                )
-            )
-        if require_confirmation:
-            confirmed = self.ask_user_confirmation(
-                tr(
-                    "About to run PowerShell command: {command}\nContinue?",
-                    command=command,
-                )
-            )
-            if not confirmed:
-                self.report_warning(tr("⚠️ Execution cancelled by user."))
-                return False
-        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,
-        report_func,
-        accum=None,
-        file_obj=None,
-        count_func=None,
-        counter=None,
-    ):
-        for line in stream:
-            if accum is not None:
-                accum.append(line)
-            if file_obj is not None:
-                file_obj.write(line)
-                file_obj.flush()
-            report_func(line)
-            if counter is not None and count_func is not None:
-                counter[count_func] += 1
-
-    def _handle_all_out(self, process, timeout):
-        stdout_accum = []
-        stderr_accum = []
-        stdout_thread = threading.Thread(
-            target=self._stream_output,
-            args=(process.stdout, self.report_stdout, stdout_accum),
-        )
-        stderr_thread = threading.Thread(
-            target=self._stream_output,
-            args=(process.stderr, self.report_stderr, stderr_accum),
-        )
-        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)
-            )
-            return tr("Command timed out after {timeout} seconds.", timeout=timeout)
-        stdout_thread.join()
-        stderr_thread.join()
-        self.report_success(
-            tr(" ✅ return code {return_code}", return_code=return_code)
-        )
-        stdout = "".join(stdout_accum)
-        stderr = "".join(stderr_accum)
-        result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout}"
-        if stderr and stderr.strip():
-            result += f"\n--- STDERR ---\n{stderr}"
-        return result
-
-    def _handle_file_out(self, process, timeout):
-        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,
-        ):
-            counter = {"stdout": 0, "stderr": 0}
-            stdout_thread = threading.Thread(
-                target=self._stream_output,
-                args=(
-                    process.stdout,
-                    self.report_stdout,
-                    None,
-                    stdout_file,
-                    "stdout",
-                    counter,
-                ),
-            )
-            stderr_thread = threading.Thread(
-                target=self._stream_output,
-                args=(
-                    process.stderr,
-                    self.report_stderr,
-                    None,
-                    stderr_file,
-                    "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)
-                )
-                return tr("Command timed out after {timeout} seconds.", timeout=timeout)
-            stdout_thread.join()
-            stderr_thread.join()
-            stdout_file.flush()
-            stderr_file.flush()
-            self.report_success(
-                tr(" ✅ return code {return_code}", return_code=return_code)
-            )
-            return self._format_result(stdout_file.name, stderr_file.name, return_code)
-
-    def run(
-        self,
-        command: str,
-        timeout: int = 60,
-        require_confirmation: bool = False,
-        requires_user_input: bool = False,
-    ) -> str:
-        if not command.strip():
-            self.report_warning(tr("ℹ️ Empty command provided."))
-            return tr("Warning: Empty command provided. Operation skipped.")
-        encoding_prefix = "$OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; "
-        command_with_encoding = encoding_prefix + command
-        self.report_info(
-            ActionType.EXECUTE,
-            tr(
-                "🖥️ Running PowerShell command: {command} ...\n",
-                command=command,
-            ),
-        )
-        if not self._confirm_and_warn(
-            command, require_confirmation, requires_user_input
-        ):
-            return tr("❌ Command execution cancelled by user.")
-        from janito.agent.platform_discovery import PlatformDiscovery
-
-        pd = PlatformDiscovery()
-        shell_exe = "powershell.exe" if pd.is_windows() else "pwsh"
-        try:
-            if runtime_config.get("all_out"):
-                process = self._launch_process(shell_exe, command_with_encoding)
-                return self._handle_all_out(process, timeout)
-            else:
-                process = self._launch_process(shell_exe, command_with_encoding)
-                return self._handle_file_out(process, timeout)
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e))
-            return tr("Error running command: {error}", error=e)
-
-    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
-        with open(stdout_file_name, "r", encoding="utf-8", errors="replace") as out_f:
-            stdout_content = out_f.read()
-        with open(stderr_file_name, "r", encoding="utf-8", errors="replace") as err_f:
-            stderr_content = err_f.read()
-        max_lines = 100
-        stdout_lines = stdout_content.count("\n")
-        stderr_lines = stderr_content.count("\n")
-
-        def head_tail(text, n=10):
-            lines = text.splitlines()
-            if len(lines) <= 2 * n:
-                return "\n".join(lines)
-            return "\n".join(
-                lines[:n]
-                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
-                + lines[-n:]
-            )
-
-        if stdout_lines <= max_lines and stderr_lines <= max_lines:
-            result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
-            if stderr_content.strip():
-                result += f"\n--- STDERR ---\n{stderr_content}"
-            return result
-        else:
-            result = f"stdout_file: {stdout_file_name} (lines: {stdout_lines})\n"
-            if stderr_lines > 0 and stderr_content.strip():
-                result += f"stderr_file: {stderr_file_name} (lines: {stderr_lines})\n"
-            result += f"returncode: {return_code}\n"
-            result += "--- STDOUT (head/tail) ---\n" + head_tail(stdout_content) + "\n"
-            if stderr_content.strip():
-                result += (
-                    "--- STDERR (head/tail) ---\n" + head_tail(stderr_content) + "\n"
-                )
-            result += "Use the get_lines tool to inspect the contents of these files when needed."
-            return result

janito/agent/tools_utils/__init__.py

@@ -1 +0,0 @@
-# tools_utils package init

janito/agent/tools_utils/action_type.py

@@ -1,7 +0,0 @@
-from enum import Enum, auto
-
-
-class ActionType(Enum):
-    READ = auto()
-    WRITE = auto()
-    EXECUTE = auto()

janito/agent/tools_utils/test_gitignore_utils.py

@@ -1,46 +0,0 @@
-import os
-import tempfile
-import shutil
-import pytest
-from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
-
-
-def test_gitignore_filter_basic(tmp_path):
-    # Create a .gitignore file
-    gitignore_content = """
-ignored_file.txt
-ignored_dir/
-*.log
-"""
-    gitignore_path = tmp_path / ".gitignore"
-    gitignore_path.write_text(gitignore_content)
-
-    # Create files and directories
-    (tmp_path / "ignored_file.txt").write_text("should be ignored")
-    (tmp_path / "not_ignored.txt").write_text("should not be ignored")
-    (tmp_path / "ignored_dir").mkdir()
-    (tmp_path / "ignored_dir" / "file.txt").write_text("should be ignored")
-    (tmp_path / "not_ignored_dir").mkdir()
-    (tmp_path / "not_ignored_dir" / "file.txt").write_text("should not be ignored")
-    (tmp_path / "file.log").write_text("should be ignored")
-
-    gi = GitignoreFilter(str(gitignore_path))
-
-    assert gi.is_ignored(str(tmp_path / "ignored_file.txt"))
-    assert not gi.is_ignored(str(tmp_path / "not_ignored.txt"))
-    # Directory itself is not ignored, only its contents
-    assert not gi.is_ignored(str(tmp_path / "ignored_dir"))
-    assert gi.is_ignored(str(tmp_path / "ignored_dir" / "file.txt"))
-    assert not gi.is_ignored(str(tmp_path / "not_ignored_dir"))
-    assert not gi.is_ignored(str(tmp_path / "not_ignored_dir" / "file.txt"))
-    assert gi.is_ignored(str(tmp_path / "file.log"))
-
-    # Test filter_ignored
-    dirs = ["ignored_dir", "not_ignored_dir"]
-    files = ["ignored_file.txt", "not_ignored.txt", "file.log"]
-    filtered_dirs, filtered_files = gi.filter_ignored(str(tmp_path), dirs, files)
-    assert "ignored_dir" not in filtered_dirs
-    assert "not_ignored_dir" in filtered_dirs
-    assert "ignored_file.txt" not in filtered_files
-    assert "file.log" not in filtered_files
-    assert "not_ignored.txt" in filtered_files

janito/cli/_livereload_log_utils.py

@@ -1,13 +0,0 @@
-def print_livereload_logs(stdout_path, stderr_path):
-    print("\n[LiveReload stdout log]")
-    try:
-        with open(stdout_path, encoding="utf-8") as f:
-            print(f.read())
-    except Exception as e:
-        print(f"[Error reading stdout log: {e}]")
-    print("\n[LiveReload stderr log]")
-    try:
-        with open(stderr_path, encoding="utf-8") as f:
-            print(f.read())
-    except Exception as e:
-        print(f"[Error reading stderr log: {e}]")

janito/cli/_print_config.py

@@ -1,96 +0,0 @@
-import os
-from janito.rich_utils import RichPrinter
-
-_rich_printer = RichPrinter()
-from ._utils import home_shorten
-
-
-def print_config_items(items, color_label=None):
-    if not items:
-        return
-    if color_label:
-        _rich_printer.print_info(color_label)
-    home = os.path.expanduser("~")
-    for key, value in items.items():
-        if key == "system_prompt_template" and isinstance(value, str):
-            if value.startswith(home):
-                print(f"{key} = {home_shorten(value)}")
-            else:
-                _rich_printer.print_info(f"{key} = {value}")
-        else:
-            _rich_printer.print_info(f"{key} = {value}")
-    _rich_printer.print_info("")
-
-
-def _mask_api_key(value):
-    if value and len(value) > 8:
-        return value[:4] + "..." + value[-4:]
-    elif value:
-        return "***"
-    return None
-
-
-def _collect_config_items(config, unified_config, keys):
-    items = {}
-    for key in sorted(keys):
-        if key == "api_key":
-            value = config.get("api_key")
-            value = _mask_api_key(value)
-        else:
-            value = unified_config.get(key)
-        items[key] = value
-    return items
-
-
-def _print_defaults(config_defaults, shown_keys):
-    default_items = {
-        k: v
-        for k, v in config_defaults.items()
-        if k not in shown_keys and k != "api_key"
-    }
-    if default_items:
-        _rich_printer.print_magenta(
-            "[green]\U0001f7e2 Defaults (not set in config files)[/green]"
-        )
-        from pathlib import Path
-
-        template_path = (
-            Path(__file__).parent
-            / "agent"
-            / "templates"
-            / "system_prompt_template_default.j2"
-        )
-        for key, value in default_items.items():
-            if key == "system_prompt_template" and value is None:
-                _rich_printer.print_info(
-                    f"{key} = (default template path: {home_shorten(str(template_path))})"
-                )
-            else:
-                _rich_printer.print_info(f"{key} = {value}")
-        _rich_printer.print_info("")
-
-
-def print_full_config(
-    local_config, global_config, unified_config, config_defaults, console=None
-):
-    """
-    Print local, global, and default config values in a unified way.
-    Handles masking API keys and showing the template file for system_prompt_template if not set.
-    """
-    local_keys = set(local_config.all().keys())
-    global_keys = set(global_config.all().keys())
-    if not (local_keys or global_keys):
-        _rich_printer.print_warning("No configuration found.")
-    else:
-        local_items = _collect_config_items(local_config, unified_config, local_keys)
-        global_items = _collect_config_items(
-            global_config, unified_config, global_keys - local_keys
-        )
-        print_config_items(
-            local_items, color_label="[cyan]\U0001f3e0 Local Configuration[/cyan]"
-        )
-        print_config_items(
-            global_items, color_label="[yellow]\U0001f310 Global Configuration[/yellow]"
-        )
-        shown_keys = set(local_items.keys()) | set(global_items.keys())
-        _print_defaults(config_defaults, shown_keys)

janito/cli/_termweb_log_utils.py

@@ -1,17 +0,0 @@
-def print_termweb_logs(stdout_path, stderr_path, console):
-    try:
-        with open(stdout_path, encoding="utf-8") as f:
-            stdout_content = f.read().strip()
-    except Exception:
-        stdout_content = None
-    try:
-        with open(stderr_path, encoding="utf-8") as f:
-            stderr_content = f.read().strip()
-    except Exception:
-        stderr_content = None
-    if stdout_content:
-        console.print("[yellow][termweb][stdout] Output:\n" + stdout_content)
-    if stderr_content:
-        console.print("[red][termweb][stderr] Errors:\n" + stderr_content)
-    if not stdout_content and not stderr_content:
-        console.print("[termweb] No output or errors captured in logs.")

janito/cli/_utils.py

@@ -1,9 +0,0 @@
-import os
-
-
-def home_shorten(path: str) -> str:
-    """If path starts with the user's home directory, replace it with ~."""
-    home = os.path.expanduser("~")
-    if path and isinstance(path, str) and path.startswith(home):
-        return path.replace(home, "~", 1)
-    return path