janito 1.7.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,6 +1,6 @@
 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
@@ -11,48 +11,38 @@ import os
 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.
-        """
         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(
@@ -66,23 +56,20 @@ class RunBashCommandTool(ToolBase):
                 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,  # line-buffered
+                    bufsize=1,
                     env=env,
                 )
-
                 stdout_lines = 0
                 stderr_lines = 0
                 stdout_content = []
                 stderr_content = []
                 max_lines = 100
-
                 import threading
 
                 def stream_reader(
@@ -120,29 +107,29 @@ class RunBashCommandTool(ToolBase):
                 )
                 stdout_thread.start()
                 stderr_thread.start()
-
                 try:
                     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."
-
+                    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()
-
-                # Count lines
                 stdout_lines = stdout_counter[0]
                 stderr_lines = stderr_counter[0]
-
-                self.report_success(f" ✅ return code {process.returncode}")
+                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 if small
+                    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:
-                    # Read files from disk to ensure all content is included
                     with open(
                         stdout_file.name, "r", encoding="utf-8", errors="replace"
                     ) as out_f:
@@ -151,24 +138,34 @@ class RunBashCommandTool(ToolBase):
                         stderr_file.name, "r", encoding="utf-8", errors="replace"
                     ) as err_f:
                         stderr_content_str = err_f.read()
-                    result = (
-                        warning_msg
-                        + f"Return code: {process.returncode}\n--- STDOUT ---\n{stdout_content_str}"
+                    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_str.strip():
-                        result += f"\n--- STDERR ---\n{stderr_content_str}"
+                        result += tr(
+                            "\n--- STDERR ---\n{stderr_content}",
+                            stderr_content=stderr_content_str,
+                        )
                     return result
                 else:
-                    result = (
-                        warning_msg
-                        + f"[LARGE OUTPUT]\nstdout_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:
-                        result += (
-                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        result += tr(
+                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
+                            stderr_file=stderr_file.name,
+                            stderr_lines=stderr_lines,
                         )
-                    result += f"returncode: {process.returncode}\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

@@ -1,6 +1,6 @@
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-
+from janito.i18n import tr
 import subprocess
 import tempfile
 
@@ -9,25 +9,20 @@ import tempfile
 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 call(
+    def run(
         self,
         command: str,
         timeout: int = 60,
@@ -35,23 +30,31 @@ class RunPowerShellCommandTool(ToolBase):
         interactive: bool = False,
     ) -> str:
         if not command.strip():
-            self.report_warning("⚠️ Warning: Empty command provided. Operation skipped.")
-            return "Warning: Empty command provided. Operation skipped."
-        # Prepend UTF-8 output encoding
+            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(f"🖥️  Running PowerShell command: {command}\n")
+        self.report_info(
+            tr("🖥️  Running PowerShell 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."
+                )
             )
         if require_confirmation:
             confirmed = self.ask_user_confirmation(
-                f"About to run PowerShell command: {command}\nContinue?"
+                tr(
+                    "About to run PowerShell command: {command}\nContinue?",
+                    command=command,
+                )
             )
             if not confirmed:
-                self.report_warning("Execution cancelled by user.")
-                return "❌ Command execution cancelled by user."
+                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"
@@ -87,9 +90,12 @@ class RunPowerShellCommandTool(ToolBase):
                     return_code = 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
+                    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(
@@ -104,7 +110,6 @@ class RunPowerShellCommandTool(ToolBase):
                     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:
@@ -113,11 +118,14 @@ class RunPowerShellCommandTool(ToolBase):
                     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_success(
+                    tr(" ✅ return code {return_code}", return_code=return_code)
+                )
                 warning_msg = ""
                 if interactive:
-                    warning_msg = "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
-                # Read output contents
+                    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:
@@ -126,28 +134,36 @@ class RunPowerShellCommandTool(ToolBase):
                     stderr_file.name, "r", encoding="utf-8", errors="replace"
                 ) as err_f:
                     stderr_content = err_f.read()
-                # Thresholds
                 max_lines = 100
                 if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = (
-                        warning_msg
-                        + f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    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 += f"\n--- STDERR ---\n{stderr_content}"
+                        result += tr(
+                            "\n--- STDERR ---\n{stderr_content}",
+                            stderr_content=stderr_content,
+                        )
                     return result
                 else:
-                    result = (
-                        warning_msg
-                        + f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    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 += (
-                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        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=return_code,
+                    )
                     return result
         except Exception as e:
-            self.report_error(f" ❌ Error: {e}")
-            return f"Error running command: {e}"
-        # No temp script file to clean up anymore
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error running command: {error}", error=e)