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

janito/plugins_backup_20250825_070018/core/codeanalyzer/tools/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 janito.tools.adapters.local.adapter import register_local_tool as register_tool
-
-
-@register_tool
-class SearchTextTool(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_backup_20250825_070018/core/codeanalyzer/tools/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_backup_20250825_070018/core/codeanalyzer/tools/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_backup_20250825_070018/core/codeanalyzer/tools/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_backup_20250825_070018/core/filemanager/__init__.py

@@ -1,124 +0,0 @@
-"""
-File Manager Plugin
-
-Core file and directory operations for managing project files.
-"""
-
-from typing import List, Optional
-import os
-
-
-def create_file(path: str, content: str = "", overwrite: bool = False) -> str:
-    """Create a new file with content"""
-    return f"create_file(path='{path}', content='{len(content)} chars', overwrite={overwrite})"
-
-
-create_file.tool_name = "create_file"
-
-
-def read_files(paths: List[str]) -> str:
-    """Read multiple files at once"""
-    return f"read_files(paths={paths})"
-
-
-read_files.tool_name = "read_files"
-
-
-def view_file(
-    path: str, from_line: Optional[int] = None, to_line: Optional[int] = None
-) -> str:
-    """Read specific lines or entire files"""
-    range_str = f"{from_line}-{to_line}" if from_line or to_line else "all"
-    return f"view_file(path='{path}', range='{range_str}')"
-
-
-view_file.tool_name = "view_file"
-
-
-def replace_text_in_file(
-    path: str, search_text: str, replacement_text: str, replace_all: bool = True
-) -> str:
-    """Find and replace text in files"""
-    return f"replace_text_in_file(path='{path}', search='{search_text[:20]}...', replace='{replacement_text[:20]}...')"
-
-
-replace_text_in_file.tool_name = "replace_text_in_file"
-
-
-def validate_file_syntax(path: str) -> str:
-    """Check file syntax (Python/Markdown)"""
-    return f"validate_file_syntax(path='{path}')"
-
-
-validate_file_syntax.tool_name = "validate_file_syntax"
-
-
-def create_directory(path: str) -> str:
-    """Create new directories"""
-    return f"create_directory(path='{path}')"
-
-
-create_directory.tool_name = "create_directory"
-
-
-def remove_directory(path: str, recursive: bool = False) -> str:
-    """Remove directories (recursive option)"""
-    return f"remove_directory(path='{path}', recursive={recursive})"
-
-
-remove_directory.tool_name = "remove_directory"
-
-
-def remove_file(path: str) -> str:
-    """Delete single files"""
-    return f"remove_file(path='{path}')"
-
-
-remove_file.tool_name = "remove_file"
-
-
-def copy_file(sources: str, target: str, overwrite: bool = False) -> str:
-    """Copy files or directories"""
-    return f"copy_file(sources='{sources}', target='{target}', overwrite={overwrite})"
-
-
-copy_file.tool_name = "copy_file"
-
-
-def move_file(src_path: str, dest_path: str, overwrite: bool = False) -> str:
-    """Move/rename files or directories"""
-    return f"move_file(src='{src_path}', dest='{dest_path}', overwrite={overwrite})"
-
-
-move_file.tool_name = "move_file"
-
-
-def find_files(
-    paths: str,
-    pattern: str,
-    max_depth: Optional[int] = None,
-    include_gitignored: bool = False,
-) -> str:
-    """Search for files by pattern (respects .gitignore)"""
-    return f"find_files(paths='{paths}', pattern='{pattern}', max_depth={max_depth})"
-
-
-find_files.tool_name = "find_files"
-
-
-# Plugin metadata
-__plugin_name__ = "core.filemanager"
-__plugin_description__ = "Core file and directory operations"
-__plugin_tools__ = [
-    create_file,
-    read_files,
-    view_file,
-    replace_text_in_file,
-    validate_file_syntax,
-    create_directory,
-    remove_directory,
-    remove_file,
-    copy_file,
-    move_file,
-    find_files,
-]

janito/plugins_backup_20250825_070018/core/filemanager/tools/create_file.py

@@ -1,87 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-from janito.tools.adapters.local.adapter import register_local_tool
-
-from janito.tools.tool_utils import display_path
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
-
-
-@register_local_tool
-class CreateFileTool(ToolBase):
-    """
-    Create a new file with the given content.
-
-    Args:
-        path (str): Path to the file to create.
-        content (str): Content to write to the file.
-        overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
-    Returns:
-        str: Status message indicating the result. Example:
-            - "✅ Successfully created the file at ..."
-
-    Note: Syntax validation is automatically performed after this operation.
-
-    Security: This tool includes loop protection to prevent excessive file creation operations.
-    Maximum 5 calls per 10 seconds for the same file path.
-    """
-
-    permissions = ToolPermissions(write=True)
-    tool_name = "create_file"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str, content: str, overwrite: bool = False) -> str:
-        path = expand_path(path)
-        disp_path = display_path(path)
-        if os.path.exists(path) and not overwrite:
-            try:
-                with open(path, "r", encoding="utf-8", errors="replace") as f:
-                    existing_content = f.read()
-            except Exception as e:
-                existing_content = f"[Error reading file: {e}]"
-            return tr(
-                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
-                disp_path=disp_path,
-                existing_content=existing_content,
-            )
-        # Determine if we are overwriting an existing file
-        is_overwrite = os.path.exists(path) and overwrite
-        if is_overwrite:
-            # Overwrite branch: log only overwrite warning (no create message)
-            self.report_action(
-                tr("⚠️  Overwriting file '{disp_path}'", disp_path=disp_path),
-                ReportAction.CREATE,
-            )
-        dir_name = os.path.dirname(path)
-        if dir_name:
-            os.makedirs(dir_name, exist_ok=True)
-        if not is_overwrite:
-            # Create branch: log file creation message
-            self.report_action(
-                tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
-                ReportAction.CREATE,
-            )
-        with open(path, "w", encoding="utf-8", errors="replace") as f:
-            f.write(content)
-        new_lines = content.count("\n") + 1 if content else 0
-        self.report_success(
-            tr("✅ {new_lines} lines", new_lines=new_lines), ReportAction.CREATE
-        )
-        # Perform syntax validation and append result
-        validation_result = validate_file_syntax(path)
-        if is_overwrite:
-            # Overwrite branch: return minimal overwrite info to user
-            return (
-                tr("✅ {new_lines} lines", new_lines=new_lines)
-                + f"\n{validation_result}"
-            )
-        else:
-            # Create branch: return detailed create success to user
-            return (
-                tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
-                + f"\n{validation_result}"
-            )