janito 1.6.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

janito/agent/tools/replace_text_in_file.py

@@ -1,6 +1,6 @@
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.tools_utils import pluralize
+from janito.i18n import tr
 
 
 @register_tool(name="replace_text_in_file")
@@ -21,7 +21,7 @@ class ReplaceTextInFileTool(ToolBase):
             - "Error replacing text: <error message>"
     """
 
-    def call(
+    def run(
         self,
         file_path: str,
         search_text: str,
@@ -32,43 +32,83 @@ class ReplaceTextInFileTool(ToolBase):
         from janito.agent.tools.tools_utils import display_path
 
         disp_path = display_path(file_path)
-        action = "all occurrences" if replace_all else None
-        # Show only concise info (lengths, not full content)
-        search_preview = (
-            (search_text[:20] + "...") if len(search_text) > 20 else search_text
-        )
-        replace_preview = (
-            (replacement_text[:20] + "...")
-            if len(replacement_text) > 20
-            else replacement_text
-        )
+        action = "(all)" if replace_all else "(unique)"
         search_lines = len(search_text.splitlines())
         replace_lines = len(replacement_text.splitlines())
-        info_msg = f"\U0001f4dd Replacing in {disp_path}: {search_lines}\u2192{replace_lines} lines"
-        if action:
-            info_msg += f" ({action})"
-        self.report_info(info_msg)
-
+        if replace_lines == 0:
+            info_msg = tr(
+                "📝 Replacing in {disp_path} del {search_lines} lines {action}",
+                disp_path=disp_path,
+                search_lines=search_lines,
+                action=action,
+            )
+        else:
+            try:
+                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                    _content = f.read()
+                _new_content = _content.replace(
+                    search_text, replacement_text, -1 if replace_all else 1
+                )
+                _total_lines_before = _content.count("\n") + 1
+                _total_lines_after = _new_content.count("\n") + 1
+                _line_delta = _total_lines_after - _total_lines_before
+            except Exception:
+                _line_delta = replace_lines - search_lines
+            if _line_delta > 0:
+                delta_str = f"+{_line_delta} lines"
+            elif _line_delta < 0:
+                delta_str = f"{_line_delta} lines"
+            else:
+                delta_str = "+0"
+            info_msg = tr(
+                "📝 Replacing in {disp_path} {delta_str} {action}",
+                disp_path=disp_path,
+                delta_str=delta_str,
+                action=action,
+            )
+        self.report_info(
+            info_msg + (" ..." if not info_msg.rstrip().endswith("...") else "")
+        )
         try:
             with open(file_path, "r", encoding="utf-8", errors="replace") as f:
                 content = f.read()
 
+            def find_match_lines(content, search_text):
+                lines = content.splitlines(keepends=True)
+                joined = "".join(lines)
+                match_lines = []
+                idx = 0
+                while True:
+                    idx = joined.find(search_text, idx)
+                    if idx == -1:
+                        break
+                    upto = joined[:idx]
+                    line_no = upto.count("\n") + 1
+                    match_lines.append(line_no)
+                    idx += 1 if not search_text else len(search_text)
+                return match_lines
+
+            match_lines = find_match_lines(content, search_text)
             if replace_all:
                 replaced_count = content.count(search_text)
                 new_content = content.replace(search_text, replacement_text)
             else:
                 occurrences = content.count(search_text)
                 if occurrences > 1:
-                    self.report_warning("\u26a0\ufe0f Search text is not unique.")
-                    warning_detail = "The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
-                    return f"No changes made. {warning_detail}"
+                    self.report_warning(tr("⚠️ Search text is not unique."))
+                    warning_detail = tr(
+                        "The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
+                    )
+                    return tr(
+                        "No changes made. {warning_detail}",
+                        warning_detail=warning_detail,
+                    )
                 replaced_count = 1 if occurrences == 1 else 0
                 new_content = content.replace(search_text, replacement_text, 1)
             import shutil
 
             backup_path = file_path + ".bak"
             if backup and new_content != content:
-                # Create a .bak backup before writing changes
                 shutil.copy2(file_path, backup_path)
             if new_content != content:
                 with open(file_path, "w", encoding="utf-8", errors="replace") as f:
@@ -78,17 +118,24 @@ class ReplaceTextInFileTool(ToolBase):
                 file_changed = False
             warning = ""
             if replaced_count == 0:
-                warning = " [Warning: Search text not found in file]"
+                warning = tr(" [Warning: Search text not found in file]")
             if not file_changed:
-                self.report_warning(" \u2139\ufe0f No changes made.")
-                concise_warning = "The search text was not found. Expand your search context with surrounding lines if needed."
-                return f"No changes made. {concise_warning}"
-
-            self.report_success(
-                f" \u2705 {replaced_count} {pluralize('block', replaced_count)} replaced"
-            )
+                self.report_warning(tr(" ℹ️ No changes made."))
+                concise_warning = tr(
+                    "The search text was not found. Expand your search context with surrounding lines if needed."
+                )
+                return tr(
+                    "No changes made. {concise_warning}",
+                    concise_warning=concise_warning,
+                )
+            if match_lines:
+                lines_str = ", ".join(str(line_no) for line_no in match_lines)
+                self.report_success(
+                    tr(" ✅ replaced at {lines_str}", lines_str=lines_str)
+                )
+            else:
+                self.report_success(tr(" ✅ replaced (lines unknown)"))
 
-            # Indentation check for agent warning
             def leading_ws(line):
                 import re
 
@@ -107,11 +154,63 @@ class ReplaceTextInFileTool(ToolBase):
             )
             indent_warning = ""
             if search_indent != replace_indent:
-                indent_warning = f" [Warning: Indentation mismatch between search and replacement text: '{search_indent}' vs '{replace_indent}']"
+                indent_warning = tr(
+                    " [Warning: Indentation mismatch between search and replacement text: '{search_indent}' vs '{replace_indent}']",
+                    search_indent=search_indent,
+                    replace_indent=replace_indent,
+                )
+            total_lines_before = content.count("\n") + 1
+            total_lines_after = new_content.count("\n") + 1
+            line_delta = total_lines_after - total_lines_before
+            line_delta_str = (
+                f" (+{line_delta} lines)"
+                if line_delta > 0
+                else (
+                    f" ({line_delta} lines)"
+                    if line_delta < 0
+                    else " (no net line change)"
+                )
+            )
+            if replaced_count > 0:
+                if replace_all:
+                    match_info = tr(
+                        "Matches found at lines: {lines}. ",
+                        lines=", ".join(str(line) for line in match_lines),
+                    )
+                else:
+                    match_info = (
+                        tr("Match found at line {line}. ", line=match_lines[0])
+                        if match_lines
+                        else ""
+                    )
+                details = tr(
+                    "Replaced {replaced_count} occurrence(s) at above line(s): {search_lines} lines replaced with {replace_lines} lines each.{line_delta_str}",
+                    replaced_count=replaced_count,
+                    search_lines=search_lines,
+                    replace_lines=replace_lines,
+                    line_delta_str=line_delta_str,
+                )
+            else:
+                match_info = ""
+                details = ""
             if "warning_detail" in locals():
-                return f"Text replaced in {file_path}{warning}{indent_warning} (backup at {backup_path})\n{warning_detail}"
-            return f"Text replaced in {file_path}{warning}{indent_warning} (backup at {backup_path})"
-
+                return tr(
+                    "Text replaced in {file_path}{warning}{indent_warning} (backup at {backup_path})\n{warning_detail}",
+                    file_path=file_path,
+                    warning=warning,
+                    indent_warning=indent_warning,
+                    backup_path=backup_path,
+                    warning_detail=warning_detail,
+                )
+            return tr(
+                "Text replaced in {file_path}{warning}{indent_warning} (backup at {backup_path}). {match_info}{details}",
+                file_path=file_path,
+                warning=warning,
+                indent_warning=indent_warning,
+                backup_path=backup_path,
+                match_info=match_info,
+                details=details,
+            )
         except Exception as e:
-            self.report_error(" \u274c Error")
-            return f"Error replacing text: {e}"
+            self.report_error(tr(" ❌ Error"))
+            return tr("Error replacing text: {error}", error=e)

janito/agent/tools/run_bash_command.py

@@ -1,70 +1,48 @@
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-
+from janito.i18n import tr
 import subprocess
 import tempfile
 import sys
+import os
 
 
 @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.
         interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False. Non-interactive commands are preferred for automation and reliability.
-
     Returns:
         str: File paths and line counts for stdout and stderr.
     """
 
-    def call(
+    def run(
         self,
         command: str,
         timeout: int = 60,
         require_confirmation: bool = False,
         interactive: bool = False,
     ) -> str:
-        """
-        Execute a bash command and capture live output.
-
-        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.
-            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
-
-        Returns:
-            str: Output and status message.
-        """
-        """
-        Execute a bash command and capture live output.
-
-        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.
-            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
-
-        Returns:
-            str: Output and status message.
-        """
         if not command.strip():
-            self.report_warning("⚠️ Warning: Empty command provided. Operation skipped.")
-            return "Warning: Empty command provided. Operation skipped."
-        self.report_info(f"🖥️  Running bash command: {command}\n")
+            self.report_warning(
+                tr("⚠️ Warning: Empty command provided. Operation skipped.")
+            )
+            return tr("Warning: Empty command provided. Operation skipped.")
+        self.report_info(
+            tr("🖥️  Running bash command: {command} ...\n", command=command)
+        )
         if interactive:
             self.report_info(
-                "⚠️  Warning: This command might be interactive, require user input, and might hang."
+                tr(
+                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
+                )
             )
-
             sys.stdout.flush()
-
         try:
             with (
                 tempfile.NamedTemporaryFile(
@@ -74,82 +52,120 @@ class RunBashCommandTool(ToolBase):
                     mode="w+", prefix="run_bash_stderr_", delete=False, encoding="utf-8"
                 ) as stderr_file,
             ):
-                # Use bash explicitly for command execution
+                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=stdout_file,
-                    stderr=stderr_file,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
                     text=True,
+                    encoding="utf-8",
+                    bufsize=1,
+                    env=env,
+                )
+                stdout_lines = 0
+                stderr_lines = 0
+                stdout_content = []
+                stderr_content = []
+                max_lines = 100
+                import threading
+
+                def stream_reader(
+                    stream, file_handle, report_func, content_list, line_counter
+                ):
+                    for line in iter(stream.readline, ""):
+                        file_handle.write(line)
+                        file_handle.flush()
+                        report_func(line)
+                        content_list.append(line)
+                        line_counter[0] += 1
+                    stream.close()
+
+                stdout_counter = [0]
+                stderr_counter = [0]
+                stdout_thread = threading.Thread(
+                    target=stream_reader,
+                    args=(
+                        process.stdout,
+                        stdout_file,
+                        self.report_stdout,
+                        stdout_content,
+                        stdout_counter,
+                    ),
                 )
+                stderr_thread = threading.Thread(
+                    target=stream_reader,
+                    args=(
+                        process.stderr,
+                        stderr_file,
+                        self.report_stderr,
+                        stderr_content,
+                        stderr_counter,
+                    ),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
                 try:
-                    return_code = process.wait(timeout=timeout)
+                    process.wait(timeout=timeout)
                 except subprocess.TimeoutExpired:
                     process.kill()
-                    self.report_error(f" ❌ Timed out after {timeout} seconds.")
-                    return f"Command timed out after {timeout} seconds."
-
-                # Print live output to user
-                stdout_file.flush()
-                stderr_file.flush()
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    out_f.seek(0)
-                    for line in out_f:
-                        self.report_stdout(line)
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    err_f.seek(0)
-                    for line in err_f:
-                        self.report_stderr(line)
-
-                # Count lines
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_lines = sum(1 for _ in out_f)
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_lines = sum(1 for _ in err_f)
-
-                self.report_success(f" ✅ return code {return_code}")
+                    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_lines = stdout_counter[0]
+                stderr_lines = stderr_counter[0]
+                self.report_success(
+                    tr(" ✅ return code {return_code}", return_code=process.returncode)
+                )
                 warning_msg = ""
                 if interactive:
-                    warning_msg = "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
-
-                # Read output contents
-                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()
-
-                # Thresholds
-                max_lines = 100
+                    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
-                        + f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    with open(
+                        stdout_file.name, "r", encoding="utf-8", errors="replace"
+                    ) as out_f:
+                        stdout_content_str = out_f.read()
+                    with open(
+                        stderr_file.name, "r", encoding="utf-8", errors="replace"
+                    ) as err_f:
+                        stderr_content_str = err_f.read()
+                    result = warning_msg + tr(
+                        "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
+                        return_code=process.returncode,
+                        stdout_content=stdout_content_str,
                     )
-                    if stderr_content.strip():
-                        result += f"\n--- STDERR ---\n{stderr_content}"
+                    if stderr_content_str.strip():
+                        result += tr(
+                            "\n--- STDERR ---\n{stderr_content}",
+                            stderr_content=stderr_content_str,
+                        )
                     return result
                 else:
-                    result = (
-                        warning_msg
-                        + f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    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 and stderr_content.strip():
-                        result += (
-                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                    if stderr_lines > 0:
+                        result += tr(
+                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
+                            stderr_file=stderr_file.name,
+                            stderr_lines=stderr_lines,
                         )
-                    result += f"returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed."
+                    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
         except Exception as e:
-            self.report_error(f" ❌ Error: {e}")
-            return f"Error running command: {e}"
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error running command: {error}", error=e)

janito/agent/tools/run_powershell_command.py

@@ -0,0 +1,169 @@
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
+import subprocess
+import tempfile
+
+
+@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.
+        interactive (bool, optional): If True, warns that the command may require user interaction. 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 run(
+        self,
+        command: str,
+        timeout: int = 60,
+        require_confirmation: bool = False,
+        interactive: bool = False,
+    ) -> str:
+        if not command.strip():
+            self.report_warning(
+                tr("⚠️ Warning: Empty command provided. Operation skipped.")
+            )
+            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(
+            tr("🖥️  Running PowerShell command: {command} ...\n", command=command)
+        )
+        if interactive:
+            self.report_info(
+                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 tr("❌ Command execution cancelled by user.")
+        from janito.agent.platform_discovery import is_windows
+
+        shell_exe = "powershell.exe" if 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 = subprocess.Popen(
+                    [
+                        shell_exe,
+                        "-NoProfile",
+                        "-ExecutionPolicy",
+                        "Bypass",
+                        "-Command",
+                        command_with_encoding,
+                    ],
+                    stdout=stdout_file,
+                    stderr=stderr_file,
+                    text=True,
+                )
+                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_file.flush()
+                stderr_file.flush()
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    out_f.seek(0)
+                    for line in out_f:
+                        self.report_stdout(line)
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    err_f.seek(0)
+                    for line in err_f:
+                        self.report_stderr(line)
+                with open(
+                    stdout_file.name, "r", encoding="utf-8", errors="replace"
+                ) as out_f:
+                    stdout_lines = sum(1 for _ in out_f)
+                with open(
+                    stderr_file.name, "r", encoding="utf-8", errors="replace"
+                ) as err_f:
+                    stderr_lines = sum(1 for _ in err_f)
+                self.report_success(
+                    tr(" ✅ return code {return_code}", return_code=return_code)
+                )
+                warning_msg = ""
+                if interactive:
+                    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()
+                max_lines = 100
+                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 get_lines 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))
+            return tr("Error running command: {error}", error=e)