janito 1.12.2__py3-none-any.whl → 1.13.0__py3-none-any.whl

janito/agent/tools/run_bash_command.py

@@ -6,6 +6,8 @@ import subprocess
 import tempfile
 import sys
 import os
+import threading
+from janito.agent.runtime_config import runtime_config
 
 
 @register_tool(name="run_bash_command")
@@ -22,6 +24,156 @@ class RunBashCommandTool(ToolBase):
         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,
@@ -30,7 +182,7 @@ class RunBashCommandTool(ToolBase):
         requires_user_input: bool = False,
     ) -> str:
         if not command.strip():
-            self.report_warning(tr("\u2139\ufe0f Empty command provided."))
+            self.report_warning(tr("ℹ️ Empty command provided."))
             return tr("Warning: Empty command provided. Operation skipped.")
         self.report_info(
             ActionType.EXECUTE,
@@ -39,90 +191,28 @@ class RunBashCommandTool(ToolBase):
         if requires_user_input:
             self.report_warning(
                 tr(
-                    "\u26a0\ufe0f  Warning: This command might be interactive, require user input, and might hang."
+                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
                 )
             )
             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,
-                )
-                try:
-                    stdout_content, stderr_content = process.communicate(
-                        timeout=timeout
-                    )
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr(
-                            " \u274c Timed out after {timeout} seconds.",
-                            timeout=timeout,
-                        )
-                    )
-                    return tr(
-                        "Command timed out after {timeout} seconds.", timeout=timeout
-                    )
-                self.report_success(
-                    tr(
-                        " \u2705 return code {return_code}",
-                        return_code=process.returncode,
-                    )
-                )
-                warning_msg = ""
-                if requires_user_input:
-                    warning_msg = tr(
-                        "\u26a0\ufe0f  Warning: This command might be interactive, require user input, and might hang.\n"
-                    )
-                max_lines = 100
-                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=process.returncode,
-                        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 get_lines tool to inspect the contents of these files when needed.",
-                        return_code=process.returncode,
-                    )
-                    return result
+            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(" \u274c Error: {error}", error=e))
+            self.report_error(tr(" ❌ Error: {error}", error=e))
             return tr("Error running command: {error}", error=e)

janito/agent/tools/run_powershell_command.py

@@ -6,6 +6,7 @@ import subprocess
 import os
 import tempfile
 import threading
+from janito.agent.runtime_config import runtime_config
 
 
 @register_tool(name="run_powershell_command")
@@ -29,7 +30,7 @@ class RunPowerShellCommandTool(ToolBase):
         if requires_user_input:
             self.report_warning(
                 tr(
-                    "\u26a0\ufe0f  Warning: This command might be interactive, require user input, and might hang."
+                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
                 )
             )
         if require_confirmation:
@@ -40,7 +41,7 @@ class RunPowerShellCommandTool(ToolBase):
                 )
             )
             if not confirmed:
-                self.report_warning(tr("\u26a0\ufe0f Execution cancelled by user."))
+                self.report_warning(tr("⚠️ Execution cancelled by user."))
                 return False
         return True
 
@@ -65,59 +66,114 @@ class RunPowerShellCommandTool(ToolBase):
             env=env,
         )
 
-    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
+    def _stream_output(
+        self,
+        stream,
+        report_func,
+        accum=None,
+        file_obj=None,
+        count_func=None,
+        counter=None,
+    ):
         for line in stream:
-            file_obj.write(line)
-            file_obj.flush()
+            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 count_func == "stdout":
-                counter["stdout"] += 1
-            else:
-                counter["stderr"] += 1
+            if counter is not None and count_func is not None:
+                counter[count_func] += 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(
-                "\u26a0\ufe0f  Warning: This command might be interactive, require user input, and might hang.\n"
+    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)
             )
-        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,
+            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,
+                ),
             )
-            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,
+            stderr_thread = threading.Thread(
+                target=self._stream_output,
+                args=(
+                    process.stderr,
+                    self.report_stderr,
+                    None,
+                    stderr_file,
+                    "stderr",
+                    counter,
+                ),
             )
-            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,
+            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)
                 )
-            result += tr(
-                "returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed.",
-                return_code=return_code,
+                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 result
+            return self._format_result(stdout_file.name, stderr_file.name, return_code)
 
     def run(
         self,
@@ -127,87 +183,69 @@ class RunPowerShellCommandTool(ToolBase):
         requires_user_input: bool = False,
     ) -> str:
         if not command.strip():
-            self.report_warning(tr("\u2139\ufe0f Empty command provided."))
+            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(
-                "\U0001f5a5\ufe0f Running PowerShell command: {command} ...\n",
+                "🖥️ Running PowerShell command: {command} ...\n",
                 command=command,
             ),
         )
         if not self._confirm_and_warn(
             command, require_confirmation, requires_user_input
         ):
-            return tr("\u274c Command execution cancelled by user.")
+            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:
-            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,
-            ):
+            if runtime_config.get("all_out"):
                 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(
-                            " \u274c 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(" \u2705 return code {return_code}", return_code=return_code)
-                )
-                return self._format_result(
-                    requires_user_input, return_code, stdout_file, stderr_file
-                )
+                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(" \u274c Error: {error}", error=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/search_text/core.py

@@ -125,7 +125,7 @@ class SearchTextTool(ToolBase):
         file_word = pluralize("match", count)
         self.report_success(
             tr(
-                " \u2705 {count} {file_word}{max_flag}",
+                " ✅ {count} {file_word}{max_flag}",
                 count=count,
                 file_word=file_word,
                 max_flag=" (max)" if dir_limit_reached else "",

janito/agent/tools/search_text/pattern_utils.py

@@ -18,7 +18,7 @@ def prepare_pattern(pattern, is_regex, report_error, report_warning):
             regex = re.compile(pattern)
             use_regex = True
         except re.error as e:
-            report_warning(tr("\u26a0\ufe0f Invalid regex pattern."))
+            report_warning(tr("⚠️ Invalid regex pattern."))
             return (
                 None,
                 False,

janito/agent/tools/validate_file_syntax/core.py

@@ -36,7 +36,7 @@ def _get_validator(ext):
 
 
 def _handle_validation_error(e, report_warning):
-    msg = tr("\u26a0\ufe0f Warning: Syntax error: {error}", error=e)
+    msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
     if report_warning:
         report_warning(msg)
     return msg
@@ -51,7 +51,7 @@ def validate_file_syntax(
         if validator:
             return validator(file_path)
         else:
-            msg = tr("\u26a0\ufe0f Warning: Unsupported file extension: {ext}", ext=ext)
+            msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
             if report_warning:
                 report_warning(msg)
             return msg
@@ -78,9 +78,9 @@ class ValidateFileSyntaxTool(ToolBase):
         file_path (str): Path to the file to validate.
     Returns:
         str: Validation status message. Example:
-            - "\u2705 Syntax OK"
-            - "\u26a0\ufe0f Warning: Syntax error: <error message>"
-            - "\u26a0\ufe0f Warning: Unsupported file extension: <ext>"
+            - "✅ Syntax OK"
+            - "⚠️ Warning: Syntax error: <error message>"
+            - "⚠️ Warning: Unsupported file extension: <ext>"
     """
 
     def run(self, file_path: str) -> str:
@@ -98,8 +98,8 @@ class ValidateFileSyntaxTool(ToolBase):
             report_warning=self.report_warning,
             report_success=self.report_success,
         )
-        if result.startswith("\u2705"):
+        if result.startswith("✅"):
             self.report_success(result)
-        elif result.startswith("\u26a0\ufe0f"):
-            self.report_warning(tr("\u26a0\ufe0f ") + result.lstrip("\u26a0\ufe0f "))
+        elif result.startswith("⚠️"):
+            self.report_warning(tr("⚠️ ") + result.lstrip("⚠️ "))
         return result

janito/agent/tools/validate_file_syntax/markdown_validator.py

@@ -102,8 +102,8 @@ def _check_unclosed_inline_code(content):
 def _build_markdown_result(errors):
     if errors:
         msg = tr(
-            "\u26a0\ufe0f Warning: Markdown syntax issues found:\n{errors}",
+            "⚠️ Warning: Markdown syntax issues found:\n{errors}",
             errors="\n".join(errors),
         )
         return msg
-    return "\u2705 Syntax valid"
+    return "✅ Syntax valid"