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

janito/agent/tools/replace_text_in_file.py

@@ -2,6 +2,8 @@ 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")
@@ -9,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).
@@ -36,9 +42,151 @@ class ReplaceTextInFileTool(ToolBase):
         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,
@@ -48,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
@@ -61,158 +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(
-            ActionType.WRITE,
-            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

@@ -34,7 +34,7 @@ class RunBashCommandTool(ToolBase):
             return tr("Warning: Empty command provided. Operation skipped.")
         self.report_info(
             ActionType.EXECUTE,
-            tr("🖥️ Running bash command: {command} ...\n", command=command),
+            tr("🖥️ Run bash command: {command} ...\n", command=command),
         )
         if requires_user_input:
             self.report_warning(

janito/agent/tools/run_powershell_command.py

@@ -3,6 +3,7 @@ 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 os
 import tempfile
 import threading
 
@@ -44,6 +45,8 @@ class RunPowerShellCommandTool(ToolBase):
         return True
 
     def _launch_process(self, shell_exe, command_with_encoding):
+        env = os.environ.copy()
+        env["PYTHONIOENCODING"] = "utf-8"
         return subprocess.Popen(
             [
                 shell_exe,
@@ -59,6 +62,7 @@ class RunPowerShellCommandTool(ToolBase):
             bufsize=1,
             universal_newlines=True,
             encoding="utf-8",
+            env=env,
         )
 
     def _stream_output(self, stream, file_obj, report_func, count_func, counter):

janito/agent/tools/search_text/__init__.py

@@ -0,0 +1 @@
+from .core import SearchTextTool

janito/agent/tools/search_text/core.py

@@ -0,0 +1,176 @@
+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.agent.tools_utils.utils import pluralize, display_path
+from janito.i18n import tr
+import os
+from .pattern_utils import prepare_pattern, format_result, summarize_total
+from .match_lines import read_file_lines
+from .traverse_directory import traverse_directory
+
+
+@register_tool(name="search_text")
+class SearchTextTool(ToolBase):
+    """
+    Search for a text pattern (regex or plain string) in all files within one or more directories or file paths and return matching lines or counts. Respects .gitignore.
+    Args:
+        paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
+        pattern (str): Regex pattern or plain text substring to search for in files. Must not be empty. Tries regex first, falls back to substring if regex is invalid.
+        is_regex (bool): If True, treat pattern as a regular expression. If False, treat as plain text (default).
+        max_depth (int, optional): Maximum directory depth to search. If 0 (default), search is recursive with no depth limit. If >0, limits recursion to that depth. Setting max_depth=1 disables recursion (only top-level directory). Ignored for file paths.
+        max_results (int, optional): Maximum number of results to return. Defaults to 100. 0 means no limit.
+        count_only (bool): If True, return only the count of matches per file and total, not the matching lines. Default is False.
+    Returns:
+        str: If count_only is False, matching lines from files as a newline-separated string, each formatted as 'filepath:lineno: line'.
+             If count_only is True, returns per-file and total match counts.
+        If max_results is reached, appends a note to the output.
+    """
+
+    def _handle_file(
+        self,
+        search_path,
+        pattern,
+        regex,
+        use_regex,
+        max_results,
+        total_results,
+        count_only,
+    ):
+        if count_only:
+            match_count, dir_limit_reached, _ = read_file_lines(
+                search_path,
+                pattern,
+                regex,
+                use_regex,
+                True,
+                max_results,
+                total_results,
+            )
+            per_file_counts = [(search_path, match_count)] if match_count > 0 else []
+            return [], dir_limit_reached, per_file_counts
+        else:
+            dir_output, dir_limit_reached, match_count_list = read_file_lines(
+                search_path,
+                pattern,
+                regex,
+                use_regex,
+                False,
+                max_results,
+                total_results,
+            )
+            per_file_counts = (
+                [(search_path, len(match_count_list))]
+                if match_count_list and len(match_count_list) > 0
+                else []
+            )
+            return dir_output, dir_limit_reached, per_file_counts
+
+    def _handle_path(
+        self,
+        search_path,
+        pattern,
+        regex,
+        use_regex,
+        max_depth,
+        max_results,
+        total_results,
+        count_only,
+    ):
+        info_str = tr(
+            "\U0001f50d Search {search_type} '{pattern}' in '{disp_path}'",
+            search_type=("regex" if use_regex else "text"),
+            pattern=pattern,
+            disp_path=display_path(search_path),
+        )
+        if max_depth > 0:
+            info_str += tr(" [max_depth={max_depth}]", max_depth=max_depth)
+        if count_only:
+            info_str += " [count]"
+        self.report_info(ActionType.READ, info_str)
+        if os.path.isfile(search_path):
+            dir_output, dir_limit_reached, per_file_counts = self._handle_file(
+                search_path,
+                pattern,
+                regex,
+                use_regex,
+                max_results,
+                total_results,
+                count_only,
+            )
+        else:
+            if count_only:
+                per_file_counts, dir_limit_reached, _ = traverse_directory(
+                    search_path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_depth,
+                    max_results,
+                    total_results,
+                    True,
+                )
+                dir_output = []
+            else:
+                dir_output, dir_limit_reached, per_file_counts = traverse_directory(
+                    search_path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_depth,
+                    max_results,
+                    total_results,
+                    False,
+                )
+        count = sum(count for _, count in per_file_counts)
+        file_word = pluralize("match", count)
+        self.report_success(
+            tr(" \u2705 {count} {file_word}", count=count, file_word=file_word)
+        )
+        return info_str, dir_output, dir_limit_reached, per_file_counts
+
+    def run(
+        self,
+        paths: str,
+        pattern: str,
+        is_regex: bool = False,
+        max_depth: int = 0,
+        max_results: int = 100,
+        count_only: bool = False,
+    ) -> str:
+        regex, use_regex, error_msg = prepare_pattern(
+            pattern, is_regex, self.report_error, self.report_warning
+        )
+        if error_msg:
+            return error_msg
+        paths_list = paths.split()
+        results = []
+        all_per_file_counts = []
+        for search_path in paths_list:
+            info_str, dir_output, dir_limit_reached, per_file_counts = (
+                self._handle_path(
+                    search_path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_depth,
+                    max_results,
+                    0,
+                    count_only,
+                )
+            )
+            if count_only:
+                all_per_file_counts.extend(per_file_counts)
+            result_str = format_result(
+                pattern,
+                use_regex,
+                dir_output,
+                dir_limit_reached,
+                count_only,
+                per_file_counts,
+            )
+            results.append(info_str + "\n" + result_str)
+            if dir_limit_reached:
+                break
+        if count_only:
+            results.append(summarize_total(all_per_file_counts))
+        return "\n\n".join(results)

janito/agent/tools/search_text/match_lines.py

@@ -0,0 +1,58 @@
+import re
+from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
+import os
+
+
+def is_binary_file(path, blocksize=1024):
+    try:
+        with open(path, "rb") as f:
+            chunk = f.read(blocksize)
+            if b"\0" in chunk:
+                return True
+            text_characters = bytearray(
+                {7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100))
+            )
+            nontext = chunk.translate(None, text_characters)
+            if len(nontext) / max(1, len(chunk)) > 0.3:
+                return True
+    except Exception:
+        return True
+    return False
+
+
+def match_line(line, pattern, regex, use_regex):
+    if use_regex:
+        return regex and regex.search(line)
+    return pattern in line
+
+
+def should_limit(max_results, total_results, match_count, count_only, dir_output):
+    if max_results > 0:
+        current_count = total_results + (match_count if count_only else len(dir_output))
+        return current_count >= max_results
+    return False
+
+
+def read_file_lines(
+    path, pattern, regex, use_regex, count_only, max_results, total_results
+):
+    dir_output = []
+    dir_limit_reached = False
+    match_count = 0
+    if not is_binary_file(path):
+        try:
+            open_kwargs = {"mode": "r", "encoding": "utf-8"}
+            with open(path, **open_kwargs) as f:
+                for lineno, line in enumerate(f, 1):
+                    if match_line(line, pattern, regex, use_regex):
+                        match_count += 1
+                        if not count_only:
+                            dir_output.append(f"{path}:{lineno}: {line.rstrip()}")
+                    if should_limit(
+                        max_results, total_results, match_count, count_only, dir_output
+                    ):
+                        dir_limit_reached = True
+                        break
+        except Exception:
+            pass
+    return match_count, dir_limit_reached, dir_output