janito 1.8.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

janito/agent/tools/remove_file.py

@@ -1,8 +1,11 @@
 import os
 import shutil
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.utils import expand_path, display_path
+
+# from janito.agent.tools_utils.expand_path import expand_path
+from janito.agent.tools_utils.utils import display_path
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.i18n import tr
 
 
@@ -22,27 +25,26 @@ class RemoveFileTool(ToolBase):
 
     def run(self, file_path: str, backup: bool = False) -> str:
         original_path = file_path
-        path = expand_path(file_path)
+        path = file_path  # Using file_path as is
         disp_path = display_path(original_path)
         backup_path = None
+        # Report initial info about what is going to be removed
+        self.report_info(
+            ActionType.WRITE,
+            tr("🗑️ Removing file '{disp_path}' ...", disp_path=disp_path),
+        )
         if not os.path.exists(path):
-            self.report_error(
-                tr("❌ File '{disp_path}' does not exist.", disp_path=disp_path)
-            )
-            return tr("❌ File '{disp_path}' does not exist.", disp_path=disp_path)
+            self.report_error(tr("❌ File does not exist."))
+            return tr("❌ File does not exist.")
         if not os.path.isfile(path):
-            self.report_error(
-                tr("❌ Path '{disp_path}' is not a file.", disp_path=disp_path)
-            )
-            return tr("❌ Path '{disp_path}' is not a file.", disp_path=disp_path)
+            self.report_error(tr("❌ Path is not a file."))
+            return tr("❌ Path is not a file.")
         try:
             if backup:
                 backup_path = path + ".bak"
                 shutil.copy2(path, backup_path)
             os.remove(path)
-            self.report_success(
-                tr("✅ File removed: '{disp_path}'", disp_path=disp_path)
-            )
+            self.report_success(tr("✅ File removed"))
             msg = tr(
                 "✅ Successfully removed the file at '{disp_path}'.",
                 disp_path=disp_path,

janito/agent/tools/replace_file.py

@@ -0,0 +1,72 @@
+import os
+import shutil
+from janito.agent.tool_registry import register_tool
+from janito.agent.tools_utils.utils import display_path
+from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
+from janito.i18n import tr
+
+from janito.agent.tools.validate_file_syntax.core import validate_file_syntax
+
+
+@register_tool(name="replace_file")
+class ReplaceFileTool(ToolBase):
+    """
+    Replace the entire content of an existing file. Fails if the file does not exist.
+    Args:
+        file_path (str): Path to the file to replace content.
+        content (str): The full new content to write to the file. You must provide the complete content as it will fully overwrite the existing file—do not use placeholders for original content.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "✅ Successfully replaced the file at ..."
+
+    Note: Syntax validation is automatically performed after this operation.
+    """
+
+    def run(self, file_path: str, content: str) -> str:
+        from janito.agent.tool_use_tracker import ToolUseTracker
+
+        expanded_file_path = file_path  # Using file_path as is
+        disp_path = display_path(expanded_file_path)
+        file_path = expanded_file_path
+        if not os.path.exists(file_path):
+            return tr(
+                "❗ Cannot replace: file does not exist at '{disp_path}'.",
+                disp_path=disp_path,
+            )
+        # Check previous operation
+        tracker = ToolUseTracker()
+        if not tracker.last_operation_is_full_read_or_replace(file_path):
+            self.report_info(
+                ActionType.WRITE,
+                tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path),
+            )
+            self.report_warning(tr("ℹ️ Missing full view."))
+            try:
+                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                    current_content = f.read()
+            except Exception as e:
+                current_content = f"[Error reading file: {e}]"
+            return (
+                "⚠️ [missing full view] Update was NOT performed. The full content of the file is included below for your review. Repeat the operation if you wish to proceed.\n"
+                f"--- Current content of {disp_path} ---\n"
+                f"{current_content}"
+            )
+        self.report_info(
+            ActionType.WRITE,
+            tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path),
+        )
+        backup_path = file_path + ".bak"
+        shutil.copy2(file_path, backup_path)
+        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(content)
+        new_lines = content.count("\n") + 1 if content else 0
+        self.report_success(tr("✅ {new_lines} lines", new_lines=new_lines))
+        msg = tr(
+            "✅ Replaced file ({new_lines} lines, backup at {backup_path}).",
+            new_lines=new_lines,
+            backup_path=backup_path,
+        )
+        # Perform syntax validation and append result
+        validation_result = validate_file_syntax(file_path)
+        return msg + f"\n{validation_result}"

janito/agent/tools/replace_text_in_file.py

@@ -1,4 +1,5 @@
 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
 
@@ -29,10 +30,10 @@ class ReplaceTextInFileTool(ToolBase):
         replace_all: bool = False,
         backup: bool = False,
     ) -> str:
-        from janito.agent.tools.tools_utils import display_path
+        from janito.agent.tools_utils.utils import display_path
 
         disp_path = display_path(file_path)
-        action = "(all)" if replace_all else "(unique)"
+        action = "(all)" if replace_all else ""
         search_lines = len(search_text.splitlines())
         replace_lines = len(replacement_text.splitlines())
         if replace_lines == 0:
@@ -67,7 +68,8 @@ class ReplaceTextInFileTool(ToolBase):
                 action=action,
             )
         self.report_info(
-            info_msg + (" ..." if not info_msg.rstrip().endswith("...") else "")
+            ActionType.WRITE,
+            info_msg + (" ..." if not info_msg.rstrip().endswith("...") else ""),
         )
         try:
             with open(file_path, "r", encoding="utf-8", errors="replace") as f:
@@ -95,7 +97,7 @@ class ReplaceTextInFileTool(ToolBase):
             else:
                 occurrences = content.count(search_text)
                 if occurrences > 1:
-                    self.report_warning(tr("⚠️ Search text is not unique."))
+                    self.report_warning(tr(" ℹ️ No changes made. [not unique]"))
                     warning_detail = tr(
                         "The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
                     )
@@ -120,7 +122,7 @@ class ReplaceTextInFileTool(ToolBase):
             if replaced_count == 0:
                 warning = tr(" [Warning: Search text not found in file]")
             if not file_changed:
-                self.report_warning(tr(" ℹ️ No changes made."))
+                self.report_warning(tr(" ℹ️ No changes made. [not found]"))
                 concise_warning = tr(
                     "The search text was not found. Expand your search context with surrounding lines if needed."
                 )

janito/agent/tools/run_bash_command.py

@@ -1,4 +1,5 @@
 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
@@ -16,7 +17,7 @@ class RunBashCommandTool(ToolBase):
         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.
+        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.
     """
@@ -26,20 +27,19 @@ class RunBashCommandTool(ToolBase):
         command: str,
         timeout: int = 60,
         require_confirmation: bool = False,
-        interactive: bool = False,
+        requires_user_input: bool = False,
     ) -> str:
         if not command.strip():
-            self.report_warning(
-                tr("⚠️ Warning: Empty command provided. Operation skipped.")
-            )
+            self.report_warning(tr("\u2139\ufe0f Empty command provided."))
             return tr("Warning: Empty command provided. Operation skipped.")
         self.report_info(
-            tr("🖥️  Running bash command: {command} ...\n", command=command)
+            ActionType.EXECUTE,
+            tr("🖥️ Running bash command: {command} ...\n", command=command),
         )
-        if interactive:
-            self.report_info(
+        if requires_user_input:
+            self.report_warning(
                 tr(
-                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
+                    "\u26a0\ufe0f  Warning: This command might be interactive, require user input, and might hang."
                 )
             )
             sys.stdout.flush()
@@ -65,88 +65,45 @@ class RunBashCommandTool(ToolBase):
                     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:
-                    process.wait(timeout=timeout)
+                    stdout_content, stderr_content = process.communicate(
+                        timeout=timeout
+                    )
                 except subprocess.TimeoutExpired:
                     process.kill()
                     self.report_error(
-                        tr(" ❌ Timed out after {timeout} seconds.", timeout=timeout)
+                        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_lines = stdout_counter[0]
-                stderr_lines = stderr_counter[0]
                 self.report_success(
-                    tr(" ✅ return code {return_code}", return_code=process.returncode)
+                    tr(
+                        " \u2705 return code {return_code}",
+                        return_code=process.returncode,
+                    )
                 )
                 warning_msg = ""
-                if interactive:
+                if requires_user_input:
                     warning_msg = tr(
-                        "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
+                        "\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:
-                    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,
+                        stdout_content=stdout_content,
                     )
-                    if stderr_content_str.strip():
+                    if stderr_content.strip():
                         result += tr(
                             "\n--- STDERR ---\n{stderr_content}",
-                            stderr_content=stderr_content_str,
+                            stderr_content=stderr_content,
                         )
                     return result
                 else:
@@ -167,5 +124,5 @@ class RunBashCommandTool(ToolBase):
                     )
                     return result
         except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e))
+            self.report_error(tr(" \u274c Error: {error}", error=e))
             return tr("Error running command: {error}", error=e)

janito/agent/tools/run_powershell_command.py

@@ -1,8 +1,10 @@
 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 threading
 
 
 @register_tool(name="run_powershell_command")
@@ -17,32 +19,16 @@ class RunPowerShellCommandTool(ToolBase):
         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.
+        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 run(
-        self,
-        command: str,
-        timeout: int = 60,
-        require_confirmation: bool = False,
-        interactive: bool = False,
-    ) -> str:
-        if not command.strip():
+    def _confirm_and_warn(self, command, require_confirmation, requires_user_input):
+        if requires_user_input:
             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."
+                    "\u26a0\ufe0f  Warning: This command might be interactive, require user input, and might hang."
                 )
             )
         if require_confirmation:
@@ -53,11 +39,109 @@ class RunPowerShellCommandTool(ToolBase):
                 )
             )
             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
+                self.report_warning(tr("\u26a0\ufe0f Execution cancelled by user."))
+                return False
+        return True
+
+    def _launch_process(self, shell_exe, command_with_encoding):
+        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",
+        )
+
+    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
+        for line in stream:
+            file_obj.write(line)
+            file_obj.flush()
+            report_func(line)
+            if count_func == "stdout":
+                counter["stdout"] += 1
+            else:
+                counter["stderr"] += 1
+
+    def _format_result(
+        self, requires_user_input, return_code, stdout_file, stderr_file, max_lines=100
+    ):
+        warning_msg = ""
+        if requires_user_input:
+            warning_msg = tr(
+                "\u26a0\ufe0f  Warning: This command might be interactive, require user input, and might hang.\n"
+            )
+        with open(stdout_file.name, "r", encoding="utf-8", errors="replace") as out_f:
+            stdout_content = out_f.read()
+        with open(stderr_file.name, "r", encoding="utf-8", errors="replace") as err_f:
+            stderr_content = err_f.read()
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = warning_msg + tr(
+                "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
+                return_code=return_code,
+                stdout_content=stdout_content,
+            )
+            if stderr_content.strip():
+                result += tr(
+                    "\n--- STDERR ---\n{stderr_content}",
+                    stderr_content=stderr_content,
+                )
+            return result
+        else:
+            result = warning_msg + tr(
+                "stdout_file: {stdout_file} (lines: {stdout_lines})\n",
+                stdout_file=stdout_file.name,
+                stdout_lines=stdout_lines,
+            )
+            if stderr_lines > 0 and stderr_content.strip():
+                result += tr(
+                    "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
+                    stderr_file=stderr_file.name,
+                    stderr_lines=stderr_lines,
+                )
+            result += tr(
+                "returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed.",
+                return_code=return_code,
+            )
+            return result
 
-        shell_exe = "powershell.exe" if is_windows() else "pwsh"
+    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("\u2139\ufe0f 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",
+                command=command,
+            ),
+        )
+        if not self._confirm_and_warn(
+            command, require_confirmation, requires_user_input
+        ):
+            return tr("\u274c 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(
@@ -73,97 +157,53 @@ class RunPowerShellCommandTool(ToolBase):
                     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,
+                process = self._launch_process(shell_exe, command_with_encoding)
+                counter = {"stdout": 0, "stderr": 0}
+                stdout_thread = threading.Thread(
+                    target=self._stream_output,
+                    args=(
+                        process.stdout,
+                        stdout_file,
+                        self.report_stdout,
+                        "stdout",
+                        counter,
+                    ),
+                )
+                stderr_thread = threading.Thread(
+                    target=self._stream_output,
+                    args=(
+                        process.stderr,
+                        stderr_file,
+                        self.report_stderr,
+                        "stderr",
+                        counter,
+                    ),
                 )
+                stdout_thread.start()
+                stderr_thread.start()
                 try:
                     return_code = process.wait(timeout=timeout)
                 except subprocess.TimeoutExpired:
                     process.kill()
                     self.report_error(
-                        tr(" ❌ Timed out after {timeout} seconds.", timeout=timeout)
+                        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()
-                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)
+                    tr(" \u2705 return code {return_code}", return_code=return_code)
+                )
+                return self._format_result(
+                    requires_user_input, return_code, stdout_file, stderr_file
                 )
-                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))
+            self.report_error(tr(" \u274c Error: {error}", error=e))
             return tr("Error running command: {error}", error=e)