janito 3.4.0__py3-none-any.whl → 3.5.1__py3-none-any.whl

janito/plugins/tools/search_text/core.py

@@ -0,0 +1,205 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import pluralize, display_path
+from janito.i18n import tr
+import os
+from janito.tools.path_utils import expand_path
+from .pattern_utils import prepare_pattern, format_result, summarize_total
+from .match_lines import read_file_lines
+from .traverse_directory import traverse_directory
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+from janito.plugins.tools.decorators import register_core_tool
+
+
+@register_core_tool
+class SearchText(ToolBase):
+    """
+    Search for a text query 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.
+        query (str): Text or regular expression to search for in files. Must not be empty. When use_regex=True, this is treated as a regex pattern; otherwise as plain text.
+        use_regex (bool): If True, treat query as a regular expression. If False, treat as plain text (default).
+        case_sensitive (bool): If False, perform a case-insensitive search. Default is True (case sensitive).
+        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.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "search_text"
+
+    def _handle_file(
+        self,
+        search_path,
+        query,
+        regex,
+        use_regex,
+        case_sensitive,
+        max_results,
+        total_results,
+        count_only,
+    ):
+        if count_only:
+            match_count, dir_limit_reached, _ = read_file_lines(
+                search_path,
+                query,
+                regex,
+                use_regex,
+                case_sensitive,
+                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,
+                query,
+                regex,
+                use_regex,
+                case_sensitive,
+                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,
+        query,
+        regex,
+        use_regex,
+        case_sensitive,
+        max_depth,
+        max_results,
+        total_results,
+        count_only,
+    ):
+        info_str = tr(
+            "🔍 Search {search_type} '{query}' in '{disp_path}'",
+            search_type=("regex" if use_regex else "text"),
+            query=query,
+            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_action(info_str, ReportAction.READ)
+        if os.path.isfile(search_path):
+            dir_output, dir_limit_reached, per_file_counts = self._handle_file(
+                search_path,
+                query,
+                regex,
+                use_regex,
+                case_sensitive,
+                max_results,
+                total_results,
+                count_only,
+            )
+        else:
+            if count_only:
+                per_file_counts, dir_limit_reached, _ = traverse_directory(
+                    search_path,
+                    query,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_depth,
+                    max_results,
+                    total_results,
+                    True,
+                )
+                dir_output = []
+            else:
+                dir_output, dir_limit_reached, per_file_counts = traverse_directory(
+                    search_path,
+                    query,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_depth,
+                    max_results,
+                    total_results,
+                    False,
+                )
+        count = sum(count for _, count in per_file_counts)
+        file_word = pluralize("match", count)
+        num_files = len(per_file_counts)
+        file_label = pluralize("file", num_files)
+        file_word_max = file_word + (" (max)" if dir_limit_reached else "")
+        self.report_success(
+            tr(
+                " ✅ {count} {file_word}/{num_files} {file_label}",
+                count=count,
+                file_word=file_word_max,
+                num_files=num_files,
+                file_label=file_label,
+            ),
+            ReportAction.READ,
+        )
+        return info_str, dir_output, dir_limit_reached, per_file_counts
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
+    def run(
+        self,
+        paths: str,
+        query: str,
+        use_regex: bool = False,
+        case_sensitive: bool = False,
+        max_depth: int = 0,
+        max_results: int = 100,
+        count_only: bool = False,
+    ) -> str:
+        regex, use_regex, error_msg = prepare_pattern(
+            query, use_regex, case_sensitive, self.report_error, self.report_warning
+        )
+        if error_msg:
+            return error_msg
+        paths_list = [expand_path(p) for p in 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,
+                    query,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_depth,
+                    max_results,
+                    0,
+                    count_only,
+                )
+            )
+            if count_only:
+                all_per_file_counts.extend(per_file_counts)
+            result_str = format_result(
+                query,
+                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/plugins/tools/search_text/match_lines.py

@@ -0,0 +1,67 @@
+import re
+from janito.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, query, regex, use_regex, case_sensitive):
+    if use_regex:
+        return regex and regex.search(line)
+    if not case_sensitive:
+        return query.lower() in line.lower()
+    return query 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,
+    query,
+    regex,
+    use_regex,
+    case_sensitive,
+    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, query, regex, use_regex, case_sensitive):
+                        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/plugins/tools/search_text/pattern_utils.py

@@ -0,0 +1,73 @@
+import re
+from janito.i18n import tr
+from janito.tools.tool_utils import pluralize
+
+
+def prepare_pattern(pattern, is_regex, case_sensitive, report_error, report_warning):
+    if not pattern:
+        report_error(
+            tr("Error: Empty search pattern provided. Operation aborted."),
+            ReportAction.SEARCH,
+        )
+        return (
+            None,
+            False,
+            tr("Error: Empty search pattern provided. Operation aborted."),
+        )
+    regex = None
+    use_regex = False
+    if is_regex:
+        try:
+            flags = 0
+            if not case_sensitive:
+                flags |= re.IGNORECASE
+            regex = re.compile(pattern, flags=flags)
+            use_regex = True
+        except re.error as e:
+            report_warning(tr("⚠️ 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
+        if not case_sensitive:
+            pattern = pattern.lower()
+    return regex, use_regex, None
+
+
+def format_result(
+    query, 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 path, count in per_file_counts:
+                lines.append(f"{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

janito/plugins/tools/search_text/traverse_directory.py

@@ -0,0 +1,145 @@
+import os
+from janito.gitignore_utils import GitignoreFilter
+from .match_lines import match_line, should_limit, read_file_lines
+
+
+def walk_directory(search_path, max_depth):
+    if max_depth == 1:
+        walk_result = next(os.walk(search_path), None)
+        if walk_result is None:
+            return [(search_path, [], [])]
+        else:
+            return [walk_result]
+    else:
+        return os.walk(search_path)
+
+
+def filter_dirs(dirs, root, gitignore_filter):
+    # Always exclude directories named .git, regardless of gitignore
+    return [
+        d
+        for d in dirs
+        if d != ".git" and not gitignore_filter.is_ignored(os.path.join(root, d))
+    ]
+
+
+def process_file_count_only(
+    path,
+    per_file_counts,
+    query,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_results,
+    total_results,
+):
+    match_count, file_limit_reached, _ = read_file_lines(
+        path,
+        query,
+        regex,
+        use_regex,
+        case_sensitive,
+        True,
+        max_results,
+        total_results + sum(count for _, count in per_file_counts),
+    )
+    if match_count > 0:
+        per_file_counts.append((path, match_count))
+    return file_limit_reached
+
+
+def process_file_collect(
+    path,
+    dir_output,
+    per_file_counts,
+    query,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_results,
+    total_results,
+):
+    actual_match_count, file_limit_reached, file_lines_output = read_file_lines(
+        path,
+        query,
+        regex,
+        use_regex,
+        case_sensitive,
+        False,
+        max_results,
+        total_results + len(dir_output),
+    )
+    dir_output.extend(file_lines_output)
+    if actual_match_count > 0:
+        per_file_counts.append((path, actual_match_count))
+    return file_limit_reached
+
+
+def should_limit_depth(root, search_path, max_depth, dirs):
+    if max_depth > 0:
+        rel_root = os.path.relpath(root, search_path)
+        if rel_root != ".":
+            depth = rel_root.count(os.sep) + 1
+            if depth >= max_depth:
+                del dirs[:]
+
+
+def traverse_directory(
+    search_path,
+    query,
+    regex,
+    use_regex,
+    case_sensitive,
+    max_depth,
+    max_results,
+    total_results,
+    count_only,
+):
+    dir_output = []
+    dir_limit_reached = False
+    per_file_counts = []
+    walker = walk_directory(search_path, max_depth)
+    gitignore_filter = GitignoreFilter(search_path)
+
+    for root, dirs, files in walker:
+        dirs[:] = filter_dirs(dirs, root, gitignore_filter)
+        for file in files:
+            path = os.path.join(root, file)
+            if gitignore_filter.is_ignored(path):
+                continue
+            if count_only:
+                file_limit_reached = process_file_count_only(
+                    path,
+                    per_file_counts,
+                    query,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_results,
+                    total_results,
+                )
+                if file_limit_reached:
+                    dir_limit_reached = True
+                    break
+            else:
+                file_limit_reached = process_file_collect(
+                    path,
+                    dir_output,
+                    per_file_counts,
+                    query,
+                    regex,
+                    use_regex,
+                    case_sensitive,
+                    max_results,
+                    total_results,
+                )
+                if file_limit_reached:
+                    dir_limit_reached = True
+                    break
+        if dir_limit_reached:
+            break
+        should_limit_depth(root, search_path, max_depth, dirs)
+    if count_only:
+        return per_file_counts, dir_limit_reached, []
+    else:
+        return dir_output, dir_limit_reached, per_file_counts

janito/{tools/adapters/local → plugins/tools}/show_image.py

@@ -1,12 +1,12 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
+from janito.plugins.tools.decorators import register_core_tool
 from janito.i18n import tr
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 
-@register_local_tool
-class ShowImageTool(ToolBase):
+@register_core_tool
+class ShowImage(ToolBase):
     """Display an image inline in the terminal using the rich library.
 
     Args:
@@ -44,7 +44,9 @@ class ShowImageTool(ToolBase):
 
         path = expand_path(path)
         disp_path = display_path(path)
-        self.report_action(tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ)
+        self.report_action(
+            tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ
+        )
 
         if not os.path.exists(path):
             msg = tr("❗ not found")
@@ -55,9 +57,14 @@ class ShowImageTool(ToolBase):
             console = Console()
             from rich.console import Console
             from rich.text import Text
+
             console = Console()
             img = PILImage.open(path)
-            console.print(Text(f"Image: {disp_path} ({img.width}x{img.height})", style="bold green"))
+            console.print(
+                Text(
+                    f"Image: {disp_path} ({img.width}x{img.height})", style="bold green"
+                )
+            )
             console.print(img)
             self.report_success(tr("✅ Displayed"))
             details = []
@@ -68,7 +75,9 @@ class ShowImageTool(ToolBase):
             if not preserve_aspect:
                 details.append("preserve_aspect=False")
             info = ("; ".join(details)) if details else "auto-fit"
-            return tr("Image displayed: {disp_path} ({info})", disp_path=disp_path, info=info)
+            return tr(
+                "Image displayed: {disp_path} ({info})", disp_path=disp_path, info=info
+            )
         except Exception as e:
             self.report_error(tr(" ❌ Error: {error}", error=e))
             return tr("Error displaying image: {error}", error=e)

janito/plugins/tools/show_image_grid.py

@@ -0,0 +1,85 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.plugins.tools.decorators import register_core_tool
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+from typing import Sequence
+
+
+@register_core_tool
+class ShowImageGrid(ToolBase):
+    """Display multiple images in a grid inline in the terminal using rich.
+
+    Args:
+        paths (list[str]): List of image file paths.
+        columns (int, optional): Number of columns in the grid. Default: 2.
+        width (int, optional): Max width for each image cell. Default: None (auto).
+        height (int, optional): Max height for each image cell. Default: None (auto).
+        preserve_aspect (bool, optional): Preserve aspect ratio. Default: True.
+
+    Returns:
+        str: Status string summarizing the grid display.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "show_image_grid"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
+    def run(
+        self,
+        paths: Sequence[str],
+        columns: int = 2,
+        width: int | None = None,
+        height: int | None = None,
+        preserve_aspect: bool = True,
+    ) -> str:
+        from janito.tools.path_utils import expand_path
+        from janito.tools.tool_utils import display_path
+        import os
+
+        try:
+            from rich.console import Console
+            from rich.columns import Columns
+            from PIL import Image as PILImage
+            from rich.panel import Panel
+        except Exception as e:
+            msg = tr("⚠️ Missing dependency: PIL/Pillow ({error})", error=e)
+            self.report_error(msg)
+            return msg
+
+        if not paths:
+            return tr("No images provided")
+
+        self.report_action(
+            tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ
+        )
+
+        console = Console()
+        images = []
+        shown = 0
+        for p in paths:
+            fp = expand_path(p)
+            if not os.path.exists(fp):
+                self.report_warning(tr("❗ not found: {p}", p=display_path(fp)))
+                continue
+            try:
+                img = PILImage.open(fp)
+                title = f"{display_path(fp)} ({img.width}x{img.height})"
+                images.append(
+                    Panel.fit(title, title=display_path(fp), border_style="dim")
+                )
+                shown += 1
+            except Exception as e:
+                self.report_warning(tr("⚠️ Skipped {p}: {e}", p=display_path(fp), e=e))
+
+        if not images:
+            return tr("No images could be displayed")
+
+        console.print(Columns(images, equal=True, expand=True, columns=columns))
+        self.report_success(tr("✅ Displayed {n} images", n=shown))
+        return tr(
+            "Displayed {shown}/{total} images in a {cols}x? grid",
+            shown=shown,
+            total=len(paths),
+            cols=columns,
+        )

janito/plugins/tools/validate_file_syntax/__init__.py

@@ -0,0 +1,7 @@
+"""
+File syntax validation tools for janito.
+"""
+
+from .core import ValidateFileSyntax
+
+__all__ = ["ValidateFileSyntax"]