janito 3.6.1__py3-none-any.whl → 3.8.0__py3-none-any.whl

janito/plugins/tools/core/search_text/core.py

@@ -1,205 +0,0 @@
-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 ..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/core/search_text/match_lines.py

@@ -1,67 +0,0 @@
-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/core/search_text/pattern_utils.py

@@ -1,73 +0,0 @@
-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/core/search_text/traverse_directory.py

@@ -1,145 +0,0 @@
-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/plugins/tools/core/show_image_grid.py

@@ -1,85 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from .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/core/validate_file_syntax/__init__.py

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

janito/plugins/tools/core/validate_file_syntax/core.py

@@ -1,114 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-from janito.i18n import tr
-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 display_path
-from ..decorators import register_core_tool as register_tool
-
-from .python_validator import validate_python
-from .json_validator import validate_json
-from .yaml_validator import validate_yaml
-from .ps1_validator import validate_ps1
-from .xml_validator import validate_xml
-from .html_validator import validate_html
-from .markdown_validator import validate_markdown
-from .js_validator import validate_js
-from .css_validator import validate_css
-from .jinja2_validator import validate_jinja2
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-def _get_validator(ext):
-    """Return the appropriate validator function for the file extension."""
-    mapping = {
-        ".py": validate_python,
-        ".pyw": validate_python,
-        ".json": validate_json,
-        ".yml": validate_yaml,
-        ".yaml": validate_yaml,
-        ".ps1": validate_ps1,
-        ".xml": validate_xml,
-        ".html": validate_html,
-        ".htm": validate_html,
-        ".md": validate_markdown,
-        ".js": validate_js,
-        ".css": validate_css,
-        ".j2": validate_jinja2,
-        ".jinja2": validate_jinja2,
-    }
-    return mapping.get(ext)
-
-
-def _handle_validation_error(e, report_warning):
-    msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
-    if report_warning:
-        report_warning(msg)
-    return msg
-
-
-def validate_file_syntax(
-    path: str, report_info=None, report_warning=None, report_success=None
-) -> str:
-    ext = os.path.splitext(path)[1].lower()
-    validator = _get_validator(ext)
-    try:
-        if validator:
-            return validator(path)
-        else:
-            msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
-            if report_warning:
-                report_warning(msg)
-            return msg
-    except Exception as e:
-        return _handle_validation_error(e, report_warning)
-
-
-class ValidateFileSyntax(ToolBase):
-    """
-    Validate a file for syntax issues.
-
-    Supported types:
-      - Python (.py, .pyw)
-      - JSON (.json)
-      - YAML (.yml, .yaml)
-      - PowerShell (.ps1)
-      - XML (.xml)
-      - HTML (.html, .htm) [lxml]
-      - Markdown (.md)
-      - JavaScript (.js)
-      - Jinja2 templates (.j2, .jinja2)
-
-    Args:
-        path (str): Path to the file to validate.
-    Returns:
-        str: Validation status message. Example:
-            - "✅ Syntax OK"
-            - "⚠️ Warning: Syntax error: <error message>"
-            - "⚠️ Warning: Unsupported file extension: <ext>"
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "validate_file_syntax"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str) -> str:
-        path = expand_path(path)
-        disp_path = display_path(path)
-        self.report_action(
-            tr(
-                "🔎 Validate syntax for file '{disp_path}' ...",
-                disp_path=disp_path,
-            ),
-            ReportAction.READ,
-        )
-        result = validate_file_syntax(
-            path,
-            report_warning=self.report_warning,
-            report_success=self.report_success,
-        )
-        if result.startswith("✅"):
-            self.report_success(result, ReportAction.READ)
-
-        return result