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

janito/agent/tools/search_text.py

@@ -1,10 +1,11 @@
 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
 from janito.i18n import tr
 import os
 import re
-from janito.agent.tools_utils.gitignore_utils import filter_ignored
+from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
 
 
 def is_binary_file(path, blocksize=1024):
@@ -28,12 +29,13 @@ def is_binary_file(path, blocksize=1024):
 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. 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.
             Note: When using regex mode, special characters (such as [, ], ., *, etc.) must be escaped if you want to match them literally (e.g., use '\\[DEBUG\\]' to match the literal string '[DEBUG]').
-        is_regex (bool): If True, treat pattern as regex. If False, treat as plain text. Defaults to False.
+        is_regex (bool): If True, treat pattern as a regular expression. If False, treat as plain text (default).
+            Only set is_regex=True if your pattern is a valid regular expression. Do NOT set is_regex=True for plain text patterns, as regex special characters (such as ., *, [, ], etc.) will be interpreted and may cause unexpected results.
+            For plain text substring search, leave is_regex as False or omit it.
         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): Maximum number of results to return. 0 means no limit (default).
         ignore_utf8_errors (bool): If True, ignore utf-8 decode errors. Defaults to True.
@@ -42,20 +44,16 @@ class SearchTextTool(ToolBase):
         If max_results is reached, appends a note to the output.
     """
 
-    def run(
-        self,
-        paths: str,
-        pattern: str,
-        is_regex: bool = False,
-        max_depth: int = 0,
-        max_results: int = 0,
-        ignore_utf8_errors: bool = True,
-    ) -> str:
+    def _prepare_pattern(self, pattern, is_regex):
         if not pattern:
             self.report_error(
                 tr("Error: Empty search pattern provided. Operation aborted.")
             )
-            return 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:
@@ -63,9 +61,11 @@ class SearchTextTool(ToolBase):
                 regex = re.compile(pattern)
                 use_regex = True
             except re.error as e:
-                self.report_warning(tr("⚠️ Invalid regex pattern."))
-                return tr(
-                    "Warning: Invalid regex pattern: {error}. No results.", error=e
+                self.report_warning(tr("\u26a0\ufe0f Invalid regex pattern."))
+                return (
+                    None,
+                    False,
+                    tr("Warning: Invalid regex pattern: {error}. No results.", error=e),
                 )
         else:
             try:
@@ -74,116 +74,100 @@ class SearchTextTool(ToolBase):
             except re.error:
                 regex = None
                 use_regex = False
-        output = []
-        limit_reached = False
-        total_results = 0
-        paths_list = paths.split()
-        for search_path in paths_list:
-            from janito.agent.tools_utils.utils import display_path
+        return regex, use_regex, None
 
-            info_str = tr(
-                "🔍 Searching for {search_type} '{pattern}' in '{disp_path}'",
-                search_type=("text-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)
-            self.report_info(info_str)
-            dir_output = []
-            dir_limit_reached = False
-            if os.path.isfile(search_path):
-                # Handle single file
-                path = search_path
-                if not is_binary_file(path):
-                    try:
-                        open_kwargs = {"mode": "r", "encoding": "utf-8"}
-                        if ignore_utf8_errors:
-                            open_kwargs["errors"] = "ignore"
-                        with open(path, **open_kwargs) as f:
-                            for lineno, line in enumerate(f, 1):
-                                if use_regex:
-                                    if regex.search(line):
-                                        dir_output.append(
-                                            f"{path}:{lineno}: {line.strip()}"
-                                        )
-                                else:
-                                    if pattern in line:
-                                        dir_output.append(
-                                            f"{path}:{lineno}: {line.strip()}"
-                                        )
-                                if (
-                                    max_results > 0
-                                    and (total_results + len(dir_output)) >= max_results
-                                ):
-                                    dir_limit_reached = True
-                                    break
-                    except Exception:
-                        pass
-                output.extend(dir_output)
-                total_results += len(dir_output)
-                if dir_limit_reached:
-                    limit_reached = True
-                    break
-                continue
-            # Directory logic as before
-            if max_depth == 1:
-                walk_result = next(os.walk(search_path), None)
-                if walk_result is None:
-                    walker = [(search_path, [], [])]
-                else:
-                    _, dirs, files = walk_result
-                    dirs, files = filter_ignored(search_path, dirs, files)
-                    walker = [(search_path, dirs, files)]
+    def _search_file(
+        self,
+        path,
+        pattern,
+        regex,
+        use_regex,
+        max_results,
+        total_results,
+        ignore_utf8_errors,
+    ):
+        dir_output = []
+        dir_limit_reached = False
+        if not is_binary_file(path):
+            try:
+                open_kwargs = {"mode": "r", "encoding": "utf-8"}
+                if ignore_utf8_errors:
+                    open_kwargs["errors"] = "ignore"
+                with open(path, **open_kwargs) as f:
+                    for lineno, line in enumerate(f, 1):
+                        if use_regex:
+                            if regex.search(line):
+                                dir_output.append(f"{path}:{lineno}: {line.strip()}")
+                        else:
+                            if pattern in line:
+                                dir_output.append(f"{path}:{lineno}: {line.strip()}")
+                        if (
+                            max_results > 0
+                            and (total_results + len(dir_output)) >= max_results
+                        ):
+                            dir_limit_reached = True
+                            break
+            except Exception:
+                pass
+        return dir_output, dir_limit_reached
+
+    def _search_directory(
+        self,
+        search_path,
+        pattern,
+        regex,
+        use_regex,
+        max_depth,
+        max_results,
+        total_results,
+        ignore_utf8_errors,
+    ):
+        dir_output = []
+        dir_limit_reached = False
+        if max_depth == 1:
+            walk_result = next(os.walk(search_path), None)
+            if walk_result is None:
+                walker = [(search_path, [], [])]
             else:
-                walker = os.walk(search_path)
-            stop_search = False
-            for root, dirs, files in walker:
+                _, dirs, files = walk_result
+                gitignore = GitignoreFilter()
+                dirs, files = gitignore.filter_ignored(search_path, dirs, files)
+                walker = [(search_path, dirs, files)]
+        else:
+            gitignore = GitignoreFilter()
+            walker = os.walk(search_path)
+        stop_search = False
+        for root, dirs, files in walker:
+            if stop_search:
+                break
+            rel_path = os.path.relpath(root, search_path)
+            depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
+            if max_depth == 1 and depth > 0:
+                break
+            if max_depth > 0 and depth > max_depth:
+                continue
+            dirs, files = gitignore.filter_ignored(root, dirs, files)
+            for filename in files:
                 if stop_search:
                     break
-                rel_path = os.path.relpath(root, search_path)
-                depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
-                if max_depth == 1 and depth > 0:
+                path = os.path.join(root, filename)
+                file_output, file_limit_reached = self._search_file(
+                    path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_results,
+                    total_results + len(dir_output),
+                    ignore_utf8_errors,
+                )
+                dir_output.extend(file_output)
+                if file_limit_reached:
+                    dir_limit_reached = True
+                    stop_search = True
                     break
-                if max_depth > 0 and depth > max_depth:
-                    continue
-                dirs, files = filter_ignored(root, dirs, files)
-                for filename in files:
-                    if stop_search:
-                        break
-                    path = os.path.join(root, filename)
-                    if is_binary_file(path):
-                        continue
-                    try:
-                        open_kwargs = {"mode": "r", "encoding": "utf-8"}
-                        if ignore_utf8_errors:
-                            open_kwargs["errors"] = "ignore"
-                        with open(path, **open_kwargs) as f:
-                            for lineno, line in enumerate(f, 1):
-                                if use_regex:
-                                    if regex.search(line):
-                                        dir_output.append(
-                                            f"{path}:{lineno}: {line.strip()}"
-                                        )
-                                else:
-                                    if pattern in line:
-                                        dir_output.append(
-                                            f"{path}:{lineno}: {line.strip()}"
-                                        )
-                                if (
-                                    max_results > 0
-                                    and (total_results + len(dir_output)) >= max_results
-                                ):
-                                    dir_limit_reached = True
-                                    stop_search = True
-                                    break
-                    except Exception:
-                        continue
-            output.extend(dir_output)
-            total_results += len(dir_output)
-            if dir_limit_reached:
-                limit_reached = True
-                break
+        return dir_output, dir_limit_reached
+
+    def _format_result(self, pattern, use_regex, output, limit_reached):
         header = tr(
             "[search_text] Pattern: '{pattern}' | Regex: {use_regex} | Results: {count}",
             pattern=pattern,
@@ -195,10 +179,76 @@ class SearchTextTool(ToolBase):
             result += tr("\n[Note: max_results limit reached, output truncated.]")
         self.report_success(
             tr(
-                " ✅ {count} {line_word}{limit}",
+                " \u2705 {count} {line_word}{limit}",
                 count=len(output),
                 line_word=pluralize("line", len(output)),
                 limit=(" (limit reached)" if limit_reached else ""),
             )
         )
         return result
+
+    def run(
+        self,
+        paths: str,
+        pattern: str,
+        is_regex: bool = False,
+        max_depth: int = 0,
+        max_results: int = 0,
+        ignore_utf8_errors: bool = True,
+    ) -> str:
+        regex, use_regex, error_msg = self._prepare_pattern(pattern, is_regex)
+        if error_msg:
+            return error_msg
+        paths_list = paths.split()
+        results = []
+        total_results = 0
+        limit_reached = False
+        for search_path in paths_list:
+            from janito.agent.tools_utils.utils import display_path
+
+            info_str = tr(
+                "\U0001f50d Searching for {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)
+            self.report_info(ActionType.READ, info_str)
+            dir_output = []
+            dir_limit_reached = False
+            if os.path.isfile(search_path):
+                dir_output, dir_limit_reached = self._search_file(
+                    search_path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_results,
+                    total_results,
+                    ignore_utf8_errors,
+                )
+                total_results += len(dir_output)
+                if dir_limit_reached:
+                    limit_reached = True
+            else:
+                dir_output, dir_limit_reached = self._search_directory(
+                    search_path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_depth,
+                    max_results,
+                    total_results,
+                    ignore_utf8_errors,
+                )
+                total_results += len(dir_output)
+                if dir_limit_reached:
+                    limit_reached = True
+            # Format and append result for this path
+            result_str = self._format_result(
+                pattern, use_regex, dir_output, dir_limit_reached
+            )
+            results.append(info_str + "\n" + result_str)
+            if limit_reached:
+                break
+        return "\n\n".join(results)

janito/agent/tools/validate_file_syntax/core.py

@@ -1,6 +1,7 @@
 import os
 from janito.i18n import tr
 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 display_path
 
@@ -77,7 +78,8 @@ class ValidateFileSyntaxTool(ToolBase):
     def run(self, file_path: str) -> str:
         disp_path = display_path(file_path)
         self.report_info(
-            tr("🔎 Validating syntax for file '{disp_path}' ...", disp_path=disp_path)
+            ActionType.READ,
+            tr("🔎 Validating syntax for file '{disp_path}' ...", disp_path=disp_path),
         )
         result = validate_file_syntax(
             file_path,

janito/agent/tools_utils/action_type.py

@@ -0,0 +1,7 @@
+from enum import Enum, auto
+
+
+class ActionType(Enum):
+    READ = auto()
+    WRITE = auto()
+    EXECUTE = auto()

janito/agent/tools_utils/dir_walk_utils.py

@@ -1,5 +1,5 @@
 import os
-from .gitignore_utils import filter_ignored
+from .gitignore_utils import GitignoreFilter
 
 
 def walk_dir_with_gitignore(root_dir, max_depth=None):
@@ -11,6 +11,7 @@ def walk_dir_with_gitignore(root_dir, max_depth=None):
     - If max_depth=1, only the root directory (matches 'find . -maxdepth 1').
     - If max_depth=N (N>1), yields files in root and up to N-1 levels below root (matches 'find . -maxdepth N').
     """
+    gitignore = GitignoreFilter()
     for root, dirs, files in os.walk(root_dir):
         rel_path = os.path.relpath(root, root_dir)
         depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
@@ -19,5 +20,5 @@ def walk_dir_with_gitignore(root_dir, max_depth=None):
                 # For max_depth=1, only root (depth=0). For max_depth=2, root and one level below (depth=0,1).
                 if depth > 0:
                     continue
-        dirs, files = filter_ignored(root, dirs, files)
+        dirs, files = gitignore.filter_ignored(root, dirs, files)
         yield root, dirs, files

janito/agent/tools_utils/formatting.py

@@ -1,23 +1,49 @@
-def format_outline_table(outline_items):
-    if not outline_items:
-        return "No classes, functions, or variables found."
-    header = "| Type    | Name        | Start | End | Parent   | Docstring                |\n|---------|-------------|-------|-----|----------|--------------------------|"
-    rows = []
-    for item in outline_items:
-        docstring = item.get("docstring", "").replace("\n", " ")
-        if len(docstring) > 24:
-            docstring = docstring[:21] + "..."
-        rows.append(
-            f"| {item['type']:<7} | {item['name']:<11} | {item['start']:<5} | {item['end']:<3} | {item['parent']:<8} | {docstring:<24} |"
-        )
-    return header + "\n" + "\n".join(rows)
+class OutlineFormatter:
+    """
+    Utility class for formatting code and markdown outlines into human-readable tables.
+    """
 
+    @staticmethod
+    def format_outline_table(outline_items):
+        """
+        Format a list of code outline items (classes, functions, variables) into a table.
 
-def format_markdown_outline_table(outline_items):
-    if not outline_items:
-        return "No headers found."
-    header = "| Level | Header                          | Line |\n|-------|----------------------------------|------|"
-    rows = []
-    for item in outline_items:
-        rows.append(f"| {item['level']:<5} | {item['title']:<32} | {item['line']:<4} |")
-    return header + "\n" + "\n".join(rows)
+        Args:
+            outline_items (list of dict): Each dict should contain keys: 'type', 'name', 'start', 'end', 'parent', 'docstring'.
+
+        Returns:
+            str: Formatted table as a string.
+        """
+        if not outline_items:
+            return "No classes, functions, or variables found."
+        header = "| Type    | Name        | Start | End | Parent   | Docstring                |\n|---------|-------------|-------|-----|----------|--------------------------|"
+        rows = []
+        for item in outline_items:
+            docstring = item.get("docstring", "").replace("\n", " ")
+            if len(docstring) > 24:
+                docstring = docstring[:21] + "..."
+            rows.append(
+                f"| {item['type']:<7} | {item['name']:<11} | {item['start']:<5} | {item['end']:<3} | {item['parent']:<8} | {docstring:<24} |"
+            )
+        return header + "\n" + "\n".join(rows)
+
+    @staticmethod
+    def format_markdown_outline_table(outline_items):
+        """
+        Format a list of markdown outline items (headers) into a table.
+
+        Args:
+            outline_items (list of dict): Each dict should contain keys: 'level', 'title', 'line'.
+
+        Returns:
+            str: Formatted table as a string.
+        """
+        if not outline_items:
+            return "No headers found."
+        header = "| Level | Header                          | Line |\n|-------|----------------------------------|------|"
+        rows = []
+        for item in outline_items:
+            rows.append(
+                f"| {item['level']:<5} | {item['title']:<32} | {item['line']:<4} |"
+            )
+        return header + "\n" + "\n".join(rows)

janito/agent/tools_utils/gitignore_utils.py

@@ -1,43 +1,69 @@
 import os
 import pathspec
 
-_spec = None
-
-
-def load_gitignore_patterns(gitignore_path=".gitignore"):
-    global _spec
-    if not os.path.exists(gitignore_path):
-        _spec = pathspec.PathSpec.from_lines("gitwildmatch", [])
-        return _spec
-    with open(gitignore_path, "r", encoding="utf-8", errors="replace") as f:
-        lines = f.readlines()
-    _spec = pathspec.PathSpec.from_lines("gitwildmatch", lines)
-    return _spec
-
-
-def is_ignored(path):
-    global _spec
-    if _spec is None:
-        _spec = load_gitignore_patterns()
-    # Normalize path to be relative and use forward slashes
-    rel_path = os.path.relpath(path).replace(os.sep, "/")
-    return _spec.match_file(rel_path)
-
-
-def filter_ignored(root, dirs, files, spec=None):
-    if spec is None:
-        global _spec
-        if _spec is None:
-            _spec = load_gitignore_patterns()
-        spec = _spec
-
-    def not_ignored(p):
-        rel_path = os.path.relpath(os.path.join(root, p)).replace(os.sep, "/")
-        # Always ignore .git directory (like git does)
-        if rel_path == ".git" or rel_path.startswith(".git/"):
-            return False
-        return not spec.match_file(rel_path)
-
-    dirs[:] = [d for d in dirs if not_ignored(d)]
-    files = [f for f in files if not_ignored(f)]
-    return dirs, files
+
+class GitignoreFilter:
+    """
+    Utility class for loading, interpreting, and applying .gitignore patterns to file and directory paths.
+
+    Methods
+    -------
+    __init__(self, gitignore_path: str = ".gitignore")
+        Loads and parses .gitignore patterns from the specified path.
+
+    is_ignored(self, path: str) -> bool
+        Returns True if the given path matches any of the loaded .gitignore patterns.
+
+    filter_ignored(self, root: str, dirs: list, files: list) -> tuple[list, list]
+        Filters out ignored directories and files from the provided lists, returning only those not ignored.
+    """
+
+    def __init__(self, gitignore_path: str = ".gitignore"):
+        self.gitignore_path = os.path.abspath(gitignore_path)
+        self.base_dir = os.path.dirname(self.gitignore_path)
+        lines = []
+        if not os.path.exists(self.gitignore_path):
+            self._spec = pathspec.PathSpec.from_lines("gitwildmatch", [])
+        else:
+            with open(
+                self.gitignore_path, "r", encoding="utf-8", errors="replace"
+            ) as f:
+                lines = f.readlines()
+            self._spec = pathspec.PathSpec.from_lines("gitwildmatch", lines)
+        # Collect directory patterns (ending with /)
+        self.dir_patterns = [
+            line.strip() for line in lines if line.strip().endswith("/")
+        ]
+
+    def is_ignored(self, path: str) -> bool:
+        """Return True if the given path is ignored by the loaded .gitignore patterns."""
+        abs_path = os.path.abspath(path)
+        rel_path = os.path.relpath(abs_path, self.base_dir).replace(os.sep, "/")
+        return self._spec.match_file(rel_path)
+
+    def filter_ignored(self, root: str, dirs: list, files: list) -> tuple[list, list]:
+        """
+        Filter out ignored directories and files from the provided lists.
+        Always ignores the .git directory (like git does).
+        """
+
+        def dir_is_ignored(d):
+            abs_path = os.path.abspath(os.path.join(root, d))
+            rel_path = os.path.relpath(abs_path, self.base_dir).replace(os.sep, "/")
+            if rel_path == ".git" or rel_path.startswith(".git/"):
+                return True
+            # Remove directory if it matches a directory pattern
+            for pat in self.dir_patterns:
+                pat_clean = pat.rstrip("/")
+                if rel_path == pat_clean or rel_path.startswith(pat_clean + "/"):
+                    return True
+            return self._spec.match_file(rel_path)
+
+        def file_is_ignored(f):
+            abs_path = os.path.abspath(os.path.join(root, f))
+            rel_path = os.path.relpath(abs_path, self.base_dir).replace(os.sep, "/")
+            return self._spec.match_file(rel_path)
+
+        dirs[:] = [d for d in dirs if not dir_is_ignored(d)]
+        files = [f for f in files if not file_is_ignored(f)]
+        return dirs, files

janito/agent/tools_utils/test_gitignore_utils.py

@@ -0,0 +1,46 @@
+import os
+import tempfile
+import shutil
+import pytest
+from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
+
+
+def test_gitignore_filter_basic(tmp_path):
+    # Create a .gitignore file
+    gitignore_content = """
+ignored_file.txt
+ignored_dir/
+*.log
+"""
+    gitignore_path = tmp_path / ".gitignore"
+    gitignore_path.write_text(gitignore_content)
+
+    # Create files and directories
+    (tmp_path / "ignored_file.txt").write_text("should be ignored")
+    (tmp_path / "not_ignored.txt").write_text("should not be ignored")
+    (tmp_path / "ignored_dir").mkdir()
+    (tmp_path / "ignored_dir" / "file.txt").write_text("should be ignored")
+    (tmp_path / "not_ignored_dir").mkdir()
+    (tmp_path / "not_ignored_dir" / "file.txt").write_text("should not be ignored")
+    (tmp_path / "file.log").write_text("should be ignored")
+
+    gi = GitignoreFilter(str(gitignore_path))
+
+    assert gi.is_ignored(str(tmp_path / "ignored_file.txt"))
+    assert not gi.is_ignored(str(tmp_path / "not_ignored.txt"))
+    # Directory itself is not ignored, only its contents
+    assert not gi.is_ignored(str(tmp_path / "ignored_dir"))
+    assert gi.is_ignored(str(tmp_path / "ignored_dir" / "file.txt"))
+    assert not gi.is_ignored(str(tmp_path / "not_ignored_dir"))
+    assert not gi.is_ignored(str(tmp_path / "not_ignored_dir" / "file.txt"))
+    assert gi.is_ignored(str(tmp_path / "file.log"))
+
+    # Test filter_ignored
+    dirs = ["ignored_dir", "not_ignored_dir"]
+    files = ["ignored_file.txt", "not_ignored.txt", "file.log"]
+    filtered_dirs, filtered_files = gi.filter_ignored(str(tmp_path), dirs, files)
+    assert "ignored_dir" not in filtered_dirs
+    assert "not_ignored_dir" in filtered_dirs
+    assert "ignored_file.txt" not in filtered_files
+    assert "file.log" not in filtered_files
+    assert "not_ignored.txt" in filtered_files