janito 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

janito/agent/tools/replace_file.py

@@ -3,6 +3,7 @@ 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
@@ -18,6 +19,8 @@ class ReplaceFileTool(ToolBase):
     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:
@@ -34,6 +37,10 @@ class ReplaceFileTool(ToolBase):
         # Check previous operation
         tracker = ToolUseTracker()
         if not tracker.last_operation_is_full_read_or_replace(file_path):
+            self.report_info(
+                ActionType.WRITE,
+                tr("📝 Replace 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:
@@ -41,11 +48,14 @@ class ReplaceFileTool(ToolBase):
             except Exception as e:
                 current_content = f"[Error reading file: {e}]"
             return (
-                "⚠️ [missing full view] You must fully view or replace the file before updating.\n"
+                "⚠️ [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(tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path))
+        self.report_info(
+            ActionType.WRITE,
+            tr("📝 Replace 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:

janito/agent/tools/replace_text_in_file.py

@@ -1,6 +1,9 @@
 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 shutil
+import re
 
 
 @register_tool(name="replace_text_in_file")
@@ -8,6 +11,10 @@ class ReplaceTextInFileTool(ToolBase):
     """
     Replace exact occurrences of a given text in a file.
 
+    Note:
+        To avoid syntax errors, ensure your replacement text is pre-indented as needed, matching the indentation of the
+        search text in its original location.
+
     Args:
         file_path (str): Path to the file to modify.
         search_text (str): The exact text to search for (including indentation).
@@ -32,12 +39,154 @@ class ReplaceTextInFileTool(ToolBase):
         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())
+        info_msg = self._format_info_msg(
+            disp_path,
+            search_lines,
+            replace_lines,
+            action,
+            search_text,
+            replacement_text,
+            file_path,
+        )
+        self.report_info(ActionType.WRITE, info_msg)
+        try:
+            content = self._read_file_content(file_path)
+            match_lines = self._find_match_lines(content, search_text)
+            occurrences = content.count(search_text)
+            replaced_count, new_content = self._replace_content(
+                content, search_text, replacement_text, replace_all, occurrences
+            )
+            file_changed = new_content != content
+            backup_path = file_path + ".bak"
+            if backup and file_changed:
+                self._backup_file(file_path, backup_path)
+            if file_changed:
+                self._write_file_content(file_path, new_content)
+            warning, concise_warning = self._handle_warnings(
+                replaced_count, file_changed, occurrences
+            )
+            if warning:
+                self.report_warning(warning)
+            if concise_warning:
+                return concise_warning
+            self._report_success(match_lines)
+            line_delta_str = self._get_line_delta_str(content, new_content)
+            match_info, details = self._format_match_details(
+                replaced_count,
+                match_lines,
+                search_lines,
+                replace_lines,
+                line_delta_str,
+                replace_all,
+            )
+            return self._format_final_msg(
+                file_path, warning, backup_path, match_info, details
+            )
+        except Exception as e:
+            self.report_error(tr(" \u274c Error"))
+            return tr("Error replacing text: {error}", error=e)
+
+    def _read_file_content(self, file_path):
+        """Read the entire content of the file."""
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            return f.read()
+
+    def _find_match_lines(self, content, search_text):
+        """Find all line numbers where search_text occurs in content."""
+        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
+
+    def _replace_content(
+        self, content, search_text, replacement_text, replace_all, occurrences
+    ):
+        """Replace occurrences of search_text with replacement_text in content."""
+        if replace_all:
+            replaced_count = content.count(search_text)
+            new_content = content.replace(search_text, replacement_text)
+        else:
+            if occurrences > 1:
+                return 0, content  # No changes made, not unique
+            replaced_count = 1 if occurrences == 1 else 0
+            new_content = content.replace(search_text, replacement_text, 1)
+        return replaced_count, new_content
+
+    def _backup_file(self, file_path, backup_path):
+        """Create a backup of the file."""
+        shutil.copy2(file_path, backup_path)
+
+    def _write_file_content(self, file_path, content):
+        """Write content to the file."""
+        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(content)
+
+    def _handle_warnings(self, replaced_count, file_changed, occurrences):
+        """Handle and return warnings and concise warnings if needed."""
+        warning = ""
+        concise_warning = None
+        if replaced_count == 0:
+            warning = tr(" [Warning: Search text not found in file]")
+        if not file_changed:
+            self.report_warning(tr(" \u2139\ufe0f No changes made. [not found]"))
+            concise_warning = tr(
+                "No changes made. The search text was not found. Expand your search context with surrounding lines if needed."
+            )
+        if occurrences > 1 and replaced_count == 0:
+            self.report_warning(tr(" \u2139\ufe0f No changes made. [not unique]"))
+            concise_warning = tr(
+                "No changes made. The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
+            )
+        return warning, concise_warning
+
+    def _report_success(self, match_lines):
+        """Report success with line numbers where replacements occurred."""
+        if match_lines:
+            lines_str = ", ".join(str(line_no) for line_no in match_lines)
+            self.report_success(
+                tr(" \u2705 replaced at {lines_str}", lines_str=lines_str)
+            )
+        else:
+            self.report_success(tr(" \u2705 replaced (lines unknown)"))
+
+    def _get_line_delta_str(self, content, new_content):
+        """Return a string describing the net line change after replacement."""
+        total_lines_before = content.count("\n") + 1
+        total_lines_after = new_content.count("\n") + 1
+        line_delta = total_lines_after - total_lines_before
+        if line_delta > 0:
+            return f" (+{line_delta} lines)"
+        elif line_delta < 0:
+            return f" ({line_delta} lines)"
+        else:
+            return " (no net line change)"
+
+    def _format_info_msg(
+        self,
+        disp_path,
+        search_lines,
+        replace_lines,
+        action,
+        search_text,
+        replacement_text,
+        file_path,
+    ):
+        """Format the info message for the operation."""
         if replace_lines == 0:
-            info_msg = tr(
-                "📝 Replacing in {disp_path} del {search_lines} lines {action}",
+            return tr(
+                "📝 Replace in {disp_path} del {search_lines} lines {action}",
                 disp_path=disp_path,
                 search_lines=search_lines,
                 action=action,
@@ -47,7 +196,7 @@ class ReplaceTextInFileTool(ToolBase):
                 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
+                    search_text, replacement_text, -1 if action else 1
                 )
                 _total_lines_before = _content.count("\n") + 1
                 _total_lines_after = _new_content.count("\n") + 1
@@ -60,157 +209,54 @@ class ReplaceTextInFileTool(ToolBase):
                 delta_str = f"{_line_delta} lines"
             else:
                 delta_str = "+0"
-            info_msg = tr(
-                "📝 Replacing in {disp_path} {delta_str} {action}",
+            return tr(
+                "📝 Replace 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(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."
-                    )
-                    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:
-                shutil.copy2(file_path, backup_path)
-            if new_content != content:
-                with open(file_path, "w", encoding="utf-8", errors="replace") as f:
-                    f.write(new_content)
-                file_changed = True
-            else:
-                file_changed = False
-            warning = ""
-            if replaced_count == 0:
-                warning = tr(" [Warning: Search text not found in file]")
-            if not file_changed:
-                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."
-                )
-                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)"))
 
-            def leading_ws(line):
-                import re
-
-                m = re.match(r"^\s*", line)
-                return m.group(0) if m else ""
-
-            search_indent = (
-                leading_ws(search_text.splitlines()[0])
-                if search_text.splitlines()
-                else ""
-            )
-            replace_indent = (
-                leading_ws(replacement_text.splitlines()[0])
-                if replacement_text.splitlines()
-                else ""
-            )
-            indent_warning = ""
-            if search_indent != 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,
+    def _format_match_details(
+        self,
+        replaced_count,
+        match_lines,
+        search_lines,
+        replace_lines,
+        line_delta_str,
+        replace_all,
+    ):
+        """Format match info and details for the final message."""
+        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 = ""
-                details = ""
-            if "warning_detail" in locals():
-                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,
+                match_info = (
+                    tr("Match found at line {line}. ", line=match_lines[0])
+                    if match_lines
+                    else ""
                 )
-            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,
+            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,
             )
-        except Exception as e:
-            self.report_error(tr(" ❌ Error"))
-            return tr("Error replacing text: {error}", error=e)
+        else:
+            match_info = ""
+            details = ""
+        return match_info, details
+
+    def _format_final_msg(self, file_path, warning, backup_path, match_info, details):
+        """Format the final status message."""
+        return tr(
+            "Text replaced in {file_path}{warning} (backup at {backup_path}). {match_info}{details}",
+            file_path=file_path,
+            warning=warning,
+            backup_path=backup_path,
+            match_info=match_info,
+            details=details,
+        )

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,16 +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("ℹ️ Empty command provided."))
+            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))
-        if interactive:
+        self.report_info(
+            ActionType.EXECUTE,
+            tr("🖥️ Run bash command: {command} ...\n", command=command),
+        )
+        if requires_user_input:
             self.report_warning(
                 tr(
-                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
+                    "\u26a0\ufe0f  Warning: This command might be interactive, require user input, and might hang."
                 )
             )
             sys.stdout.flush()
@@ -61,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:
@@ -163,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)