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

janito/agent/tools/run_powershell_command.py

@@ -1,7 +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 subprocess
+import os
 import tempfile
 import threading
 
@@ -18,30 +20,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():
-            self.report_warning(tr("ℹ️ 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(
-            tr("🖥️ Running PowerShell command: {command} ...\n", command=command)
-        )
-        if interactive:
+    def _confirm_and_warn(self, command, require_confirmation, requires_user_input):
+        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."
                 )
             )
         if require_confirmation:
@@ -52,11 +40,112 @@ 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
 
-        shell_exe = "powershell.exe" if is_windows() else "pwsh"
+    def _launch_process(self, shell_exe, command_with_encoding):
+        env = os.environ.copy()
+        env["PYTHONIOENCODING"] = "utf-8"
+        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",
+            env=env,
+        )
+
+    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
+
+    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(
@@ -72,44 +161,27 @@ class RunPowerShellCommandTool(ToolBase):
                     encoding="utf-8",
                 ) as stderr_file,
             ):
-                process = 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",
-                )
-
-                stdout_lines = 0
-                stderr_lines = 0
-
-                def stream_output(stream, file_obj, report_func, count_func):
-                    nonlocal stdout_lines, stderr_lines
-                    for line in stream:
-                        file_obj.write(line)
-                        file_obj.flush()
-                        report_func(line)
-                        if count_func == "stdout":
-                            stdout_lines += 1
-                        else:
-                            stderr_lines += 1
-
+                process = self._launch_process(shell_exe, command_with_encoding)
+                counter = {"stdout": 0, "stderr": 0}
                 stdout_thread = threading.Thread(
-                    target=stream_output,
-                    args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+                    target=self._stream_output,
+                    args=(
+                        process.stdout,
+                        stdout_file,
+                        self.report_stdout,
+                        "stdout",
+                        counter,
+                    ),
                 )
                 stderr_thread = threading.Thread(
-                    target=stream_output,
-                    args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+                    target=self._stream_output,
+                    args=(
+                        process.stderr,
+                        stderr_file,
+                        self.report_stderr,
+                        "stderr",
+                        counter,
+                    ),
                 )
                 stdout_thread.start()
                 stderr_thread.start()
@@ -118,7 +190,10 @@ class RunPowerShellCommandTool(ToolBase):
                 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
@@ -127,54 +202,12 @@ class RunPowerShellCommandTool(ToolBase):
                 stderr_thread.join()
                 stdout_file.flush()
                 stderr_file.flush()
-
                 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"
-                    )
-                # Read back the content for summary if not too large
-                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)

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

janito/agent/tools/search_text/pattern_utils.py

@@ -0,0 +1,65 @@
+import re
+from janito.i18n import tr
+from janito.agent.tools_utils.utils import pluralize
+
+
+def prepare_pattern(pattern, is_regex, report_error, report_warning):
+    if not pattern:
+        report_error(tr("Error: Empty search pattern provided. Operation aborted."))
+        return (
+            None,
+            False,
+            tr("Error: Empty search pattern provided. Operation aborted."),
+        )
+    regex = None
+    use_regex = False
+    if is_regex:
+        try:
+            regex = re.compile(pattern)
+            use_regex = True
+        except re.error as e:
+            report_warning(tr("\u26a0\ufe0f Invalid regex pattern."))
+            return (
+                None,
+                False,
+                tr(
+                    "Error: Invalid regex pattern: {error}. Operation aborted.", error=e
+                ),
+            )
+    else:
+        # Do not compile as regex if is_regex is False; treat as plain text
+        regex = None
+        use_regex = False
+    return regex, use_regex, None
+
+
+def format_result(
+    pattern, use_regex, output, limit_reached, count_only=False, per_file_counts=None
+):
+    # Ensure output is always a list for joining
+    if output is None or not isinstance(output, (list, tuple)):
+        output = []
+    if count_only:
+        lines = []
+        total = 0
+        if per_file_counts:
+            for file_path, count in per_file_counts:
+                lines.append(f"{file_path}: {count}")
+                total += count
+        lines.append(f"Total matches: {total}")
+        if limit_reached:
+            lines.append(tr("[Max results reached. Output truncated.]"))
+        return "\n".join(lines)
+    else:
+        if not output:
+            return tr("No matches found.")
+        result = "\n".join(output)
+        if limit_reached:
+            result += tr("\n[Max results reached. Output truncated.]")
+        return result
+
+
+def summarize_total(all_per_file_counts):
+    total = sum(count for _, count in all_per_file_counts)
+    summary = f"\nGrand total matches: {total}"
+    return summary