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

janito/plugins/tools/core/__init__.py

@@ -1,65 +0,0 @@
-"""
-Core tools for janito.
-
-This package contains the essential tools that provide basic functionality
-for file operations, code execution, web scraping, and system interactions.
-"""
-
-from .fetch_url import FetchUrl
-from .ask_user import AskUser
-from .copy_file import CopyFile
-from .create_directory import CreateDirectory
-from .create_file import CreateFile
-from .delete_text_in_file import DeleteTextInFile
-from .find_files import FindFiles
-from .move_file import MoveFile
-from .open_html_in_browser import OpenHtmlInBrowser
-from .open_url import OpenUrl
-from .python_code_run import PythonCodeRun
-from .python_command_run import PythonCommandRun
-from .python_file_run import PythonFileRun
-from .read_chart import ReadChart
-from .read_files import ReadFiles
-from .remove_directory import RemoveDirectory
-from .remove_file import RemoveFile
-from .replace_text_in_file import ReplaceTextInFile
-from .run_bash_command import RunBashCommand
-from .run_powershell_command import RunPowershellCommand
-from .show_image import ShowImage
-from .show_image_grid import ShowImageGrid
-from .view_file import ViewFile
-from .validate_file_syntax.core import ValidateFileSyntax
-from .get_file_outline.core import GetFileOutline
-from .search_text.core import SearchText
-from .decorators import get_core_tools, register_core_tool
-
-__all__ = [
-    'FetchUrl',
-    'AskUser',
-    'CopyFile',
-    'CreateDirectory',
-    'CreateFile',
-    'DeleteTextInFile',
-    'FindFiles',
-    'MoveFile',
-    'OpenHtmlInBrowser',
-    'OpenUrl',
-    'PythonCodeRun',
-    'PythonCommandRun',
-    'PythonFileRun',
-    'ReadChart',
-    'ReadFiles',
-    'RemoveDirectory',
-    'RemoveFile',
-    'ReplaceTextInFile',
-    'RunBashCommand',
-    'RunPowershellCommand',
-    'ShowImage',
-    'ShowImageGrid',
-    'ViewFile',
-    'ValidateFileSyntax',
-    'GetFileOutline',
-    'SearchText',
-    'get_core_tools',
-    'register_core_tool',
-]

janito/plugins/tools/core/copy_file.py

@@ -1,87 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-import shutil
-from typing import List, Union
-from .decorators import register_core_tool
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.tools.tool_utils import display_path
-from janito.report_events import ReportAction
-from janito.i18n import tr
-
-
-@register_core_tool
-class CopyFile(ToolBase):
-    """
-    Copy one or more files to a target directory, or copy a single file to a new file.
-    Args:
-        sources (str): Space-separated path(s) to the file(s) to copy.
-            For multiple sources, provide a single string with paths separated by spaces.
-        target (str): Destination path. If copying multiple sources, this must be an existing directory.
-        overwrite (bool, optional): Overwrite existing files. Default: False.
-            Recommended only after reading the file to be overwritten.
-    Returns:
-        str: Status string for each copy operation.
-    """
-
-    permissions = ToolPermissions(read=True, write=True)
-    tool_name = "copy_file"
-
-    def run(self, sources: str, target: str, overwrite: bool = False) -> str:
-        source_list = [expand_path(src) for src in sources.split() if src]
-        target = expand_path(target)
-        messages = []
-        if len(source_list) > 1:
-            if not os.path.isdir(target):
-                return tr(
-                    "❗ Target must be an existing directory when copying multiple files: '{target}'",
-                    target=display_path(target),
-                )
-            for src in source_list:
-                if not os.path.isfile(src):
-                    messages.append(
-                        tr(
-                            "❗ Source file does not exist: '{src}'",
-                            src=display_path(src),
-                        )
-                    )
-                    continue
-                dst = os.path.join(target, os.path.basename(src))
-                messages.append(self._copy_one(src, dst, overwrite=overwrite))
-        else:
-            src = source_list[0]
-            if os.path.isdir(target):
-                dst = os.path.join(target, os.path.basename(src))
-            else:
-                dst = target
-            messages.append(self._copy_one(src, dst, overwrite=overwrite))
-        return "\n".join(messages)
-
-    def _copy_one(self, src, dst, overwrite=False) -> str:
-        disp_src = display_path(src)
-        disp_dst = display_path(dst)
-        if not os.path.isfile(src):
-            return tr("❗ Source file does not exist: '{src}'", src=disp_src)
-        if os.path.exists(dst) and not overwrite:
-            return tr(
-                "❗ Target already exists: '{dst}'. Set overwrite=True to replace.",
-                dst=disp_dst,
-            )
-        try:
-            os.makedirs(os.path.dirname(dst), exist_ok=True)
-            shutil.copy2(src, dst)
-            note = (
-                "\n⚠️ Overwrote existing file. (recommended only after reading the file to be overwritten)"
-                if (os.path.exists(dst) and overwrite)
-                else ""
-            )
-            self.report_success(
-                tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst)
-            )
-            return tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst) + note
-        except Exception as e:
-            return tr(
-                "❗ Copy failed from '{src}' to '{dst}': {err}",
-                src=disp_src,
-                dst=disp_dst,
-                err=str(e),
-            )

janito/plugins/tools/core/create_directory.py

@@ -1,70 +0,0 @@
-from .decorators import register_core_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
-import os
-from janito.tools.path_utils import expand_path
-
-
-@register_core_tool
-class CreateDirectory(ToolBase):
-    """
-    Create a new directory at the specified path.
-    Args:
-        path (str): Path for the new directory.
-    Returns:
-        str: Status message indicating the result. Example:
-            - "5c5 Successfully created the directory at ..."
-            - "5d7 Cannot create directory: ..."
-    """
-
-    permissions = ToolPermissions(write=True)
-    tool_name = "create_directory"
-
-    def run(self, path: str) -> str:
-        path = expand_path(path)
-        disp_path = display_path(path)
-        self.report_action(
-            tr("📁 Create directory '{disp_path}' ...", disp_path=disp_path),
-            ReportAction.CREATE,
-        )
-        try:
-            if os.path.exists(path):
-                if not os.path.isdir(path):
-                    self.report_error(
-                        tr(
-                            "❌ Path '{disp_path}' exists and is not a directory.",
-                            disp_path=disp_path,
-                        )
-                    )
-                    return tr(
-                        "❌ Path '{disp_path}' exists and is not a directory.",
-                        disp_path=disp_path,
-                    )
-                self.report_error(
-                    tr(
-                        "❗ Directory '{disp_path}' already exists.",
-                        disp_path=disp_path,
-                    )
-                )
-                return tr(
-                    "❗ Cannot create directory: '{disp_path}' already exists.",
-                    disp_path=disp_path,
-                )
-            os.makedirs(path, exist_ok=True)
-            self.report_success(tr("✅ Directory created"))
-            return tr(
-                "✅ Successfully created the directory at '{disp_path}'.",
-                disp_path=disp_path,
-            )
-        except Exception as e:
-            self.report_error(
-                tr(
-                    "❌ Error creating directory '{disp_path}': {error}",
-                    disp_path=disp_path,
-                    error=e,
-                )
-            )
-            return tr("❌ Cannot create directory: {error}", error=e)

janito/plugins/tools/core/create_file.py

@@ -1,138 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-from .decorators import register_core_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 .validate_file_syntax.core import validate_file_syntax
-
-
-@register_core_tool
-class CreateFile(ToolBase):
-    """
-    Create a new file with specified content at the given path.
-
-    This tool provides comprehensive file creation capabilities with built-in safety features,
-    automatic syntax validation, and detailed feedback. It handles path expansion, directory
-    creation, encoding issues, and provides clear status messages for both success and failure cases.
-
-    Key Features:
-    - Automatic directory creation for nested paths
-    - UTF-8 encoding with error handling for special characters
-    - Built-in syntax validation for common file types (Python, JavaScript, JSON, YAML, etc.)
-    - Loop protection to prevent excessive file creation
-    - Detailed error messages with context
-    - Safe overwrite protection with preview of existing content
-    - Cross-platform path handling (Windows, macOS, Linux)
-
-    Args:
-        path (str): Target file path. Supports relative and absolute paths, with automatic
-                   expansion of user home directory (~) and environment variables.
-                   Examples: "src/main.py", "~/Documents/config.json", "$HOME/.env"
-        content (str): File content to write. Empty string creates empty file.
-                      Supports any text content including Unicode characters, newlines,
-                      and binary-safe text representation.
-        overwrite (bool, optional): If True, allows overwriting existing files. Default: False.
-                                   When False, prevents accidental overwrites by checking
-                                   file existence and showing current content. Always review
-                                   existing content before enabling overwrite.
-
-    Returns:
-        str: Detailed status message including:
-            - Success confirmation with line count
-            - File path (display-friendly format)
-            - Syntax validation results
-            - Existing content preview (when overwrite blocked)
-            - Error details (when creation fails)
-
-    Raises:
-        No direct exceptions - all errors are caught and returned as user-friendly messages.
-        Common error cases include: permission denied, invalid path format, disk full,
-        or file exists (when overwrite=False).
-
-    Security Features:
-        - Loop protection: Prevents repeated create calls for the same file path within a short window (1 allowed per 10 seconds)
-        - Path traversal prevention: Validates and sanitizes file paths
-        - Permission checking: Respects file system permissions
-        - Atomic writes: Prevents partial file creation on errors
-
-    Examples:
-        Basic file creation:
-        >>> create_file("hello.py", "print('Hello, World!')")
-        ✅ Created file 1 lines.
-        ✅ Syntax OK
-
-        Creating nested directories:
-        >>> create_file("src/utils/helpers.py", "def helper(): pass")
-        ✅ Created file 2 lines.
-        ✅ Syntax OK
-
-        Overwrite protection:
-        >>> create_file("existing.txt", "new content")
-        ❗ Cannot create file: file already exists at 'existing.txt'.
-        --- Current file content ---
-        old content
-
-    Note: After successful creation, automatic syntax validation is performed based on
-    file extension. Results are appended to the return message for immediate feedback.
-    """
-
-    permissions = ToolPermissions(write=True)
-    tool_name = "create_file"
-
-    @protect_against_loops(max_calls=1, time_window=3600.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}"
-            )

janito/plugins/tools/core/decorators.py

@@ -1,19 +0,0 @@
-"""
-Decorators for core tools registration.
-"""
-
-from typing import Type
-
-# Registry for core tools
-_core_tools_registry = []
-
-
-def register_core_tool(cls: Type):
-    """Decorator to register a core tool."""
-    _core_tools_registry.append(cls)
-    return cls
-
-
-def get_core_tools():
-    """Get all registered core tools."""
-    return list(_core_tools_registry)

janito/plugins/tools/core/delete_text_in_file.py

@@ -1,134 +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
-import shutil
-from .validate_file_syntax.core import validate_file_syntax
-
-
-@register_core_tool
-class DeleteTextInFile(ToolBase):
-    """
-    Delete all occurrences of text between start_marker and end_marker (inclusive) in a file, using exact string markers.
-
-    Args:
-        path (str): Path to the file to modify.
-        start_marker (str): The starting delimiter string.
-        end_marker (str): The ending delimiter string.
-
-    Returns:
-        str: Status message indicating the result.
-    """
-
-    permissions = ToolPermissions(read=True, write=True)
-    tool_name = "delete_text_in_file"
-
-    def run(
-        self,
-        path: str,
-        start_marker: str,
-        end_marker: str,
-        backup: bool = False,
-    ) -> str:
-        from janito.tools.tool_utils import display_path
-
-        disp_path = display_path(path)
-        info_msg = tr(
-            "📝 Delete text in {disp_path} between markers: '{start_marker}' ... '{end_marker}'",
-            disp_path=disp_path,
-            start_marker=start_marker,
-            end_marker=end_marker,
-        )
-        self.report_action(info_msg, ReportAction.CREATE)
-        try:
-            content = self._read_file_content(path)
-            occurrences, match_lines = self._find_marker_blocks(
-                content, start_marker, end_marker
-            )
-            if occurrences == 0:
-                self.report_warning(
-                    tr(" ℹ️ No blocks found between markers."), ReportAction.CREATE
-                )
-                return tr(
-                    "No blocks found between markers in {path}.",
-                    path=path,
-                )
-
-            new_content, deleted_blocks = self._delete_blocks(
-                content, start_marker, end_marker
-            )
-            self._write_file_content(path, new_content)
-            validation_result = validate_file_syntax(path)
-            self._report_success(match_lines)
-            return tr(
-                "Deleted {count} block(s) between markers in {path}. ",
-                count=deleted_blocks,
-                path=path,
-            ) + (f"\n{validation_result}" if validation_result else "")
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.REPLACE)
-            return tr("Error deleting text: {error}", error=e)
-
-    def _read_file_content(self, path):
-        with open(path, "r", encoding="utf-8", errors="replace") as f:
-            return f.read()
-
-    def _find_marker_blocks(self, content, start_marker, end_marker):
-        """Find all blocks between start_marker and end_marker, return count and starting line numbers."""
-        lines = content.splitlines(keepends=True)
-        joined = "".join(lines)
-        match_lines = []
-        idx = 0
-        occurrences = 0
-        while True:
-            start_idx = joined.find(start_marker, idx)
-            if start_idx == -1:
-                break
-            end_idx = joined.find(end_marker, start_idx + len(start_marker))
-            if end_idx == -1:
-                break
-            upto = joined[:start_idx]
-            line_no = upto.count("\n") + 1
-            match_lines.append(line_no)
-            idx = end_idx + len(end_marker)
-            occurrences += 1
-        return occurrences, match_lines
-
-    def _delete_blocks(self, content, start_marker, end_marker):
-        """Delete all blocks between start_marker and end_marker (inclusive)."""
-        count = 0
-        new_content = content
-        while True:
-            start_idx = new_content.find(start_marker)
-            if start_idx == -1:
-                break
-            end_idx = new_content.find(end_marker, start_idx + len(start_marker))
-            if end_idx == -1:
-                break
-            new_content = (
-                new_content[:start_idx] + new_content[end_idx + len(end_marker) :]
-            )
-            count += 1
-        return new_content, count
-
-    def _backup_file(self, path, backup_path):
-        shutil.copy2(path, backup_path)
-
-    def _write_file_content(self, path, content):
-        with open(path, "w", encoding="utf-8", errors="replace") as f:
-            f.write(content)
-
-    def _report_success(self, match_lines):
-        if match_lines:
-            lines_str = ", ".join(str(line_no) for line_no in match_lines)
-            self.report_success(
-                tr(
-                    " ✅ deleted block(s) starting at line(s): {lines_str}",
-                    lines_str=lines_str,
-                ),
-                ReportAction.CREATE,
-            )
-        else:
-            self.report_success(
-                tr(" ✅ deleted block(s) (lines unknown)"), ReportAction.CREATE
-            )

janito/plugins/tools/core/find_files.py

@@ -1,143 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from .decorators import register_core_tool
-from janito.tools.tool_utils import pluralize, display_path
-from janito.dir_walk_utils import walk_dir_with_gitignore
-from janito.i18n import tr
-import fnmatch
-import os
-from janito.tools.path_utils import expand_path
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_core_tool
-class FindFiles(ToolBase):
-    """
-    Find files or directories in one or more directories matching a pattern. Respects .gitignore.
-
-    If a path is an existing file, it is checked against the provided pattern(s) and included in the results if it matches. This allows find_files to be used to look for a specific set of filenames in a single call, as well as searching directories.
-
-    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): File pattern(s) to match. Multiple patterns can be separated by spaces. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
-            - If the pattern ends with '/' or '\', only matching directory names (with trailing slash) are returned, not the files within those directories. For example, pattern '*/' will return only directories at the specified depth.
-        max_depth (int, optional): Maximum directory depth to search. If None, unlimited recursion. If 0, only the top-level directory. If 1, only the root directory (matches 'find . -maxdepth 1').
-        include_gitignored (bool, optional): If True, includes files/directories ignored by .gitignore. Defaults to False.
-    Returns:
-        str: Newline-separated list of matching file paths. Example:
-            "/path/to/file1.py\n/path/to/file2.py"
-            "Warning: Empty file pattern provided. Operation skipped."
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "find_files"
-
-    def _match_directories(self, root, dirs, pat):
-        dir_output = set()
-        dir_pat = pat.rstrip("/\\")
-        for d in dirs:
-            if fnmatch.fnmatch(d, dir_pat):
-                dir_output.add(os.path.join(root, d) + os.sep)
-        return dir_output
-
-    def _match_files(self, root, files, pat):
-        file_output = set()
-        for filename in fnmatch.filter(files, pat):
-            file_output.add(os.path.join(root, filename))
-        return file_output
-
-    def _match_dirs_without_slash(self, root, dirs, pat):
-        dir_output = set()
-        for d in fnmatch.filter(dirs, pat):
-            dir_output.add(os.path.join(root, d))
-        return dir_output
-
-    def _handle_path(self, directory, patterns):
-        dir_output = set()
-        filename = os.path.basename(directory)
-        for pat in patterns:
-            # Only match files, not directories, for file paths
-            if not (pat.endswith("/") or pat.endswith("\\")):
-                if fnmatch.fnmatch(filename, pat):
-                    dir_output.add(directory)
-                    break
-        return dir_output
-
-    def _handle_directory_path(
-        self, directory, patterns, max_depth, include_gitignored
-    ):
-        dir_output = set()
-        for root, dirs, files in walk_dir_with_gitignore(
-            directory,
-            max_depth=max_depth,
-            include_gitignored=include_gitignored,
-        ):
-            for pat in patterns:
-                if pat.endswith("/") or pat.endswith("\\"):
-                    dir_output.update(self._match_directories(root, dirs, pat))
-                else:
-                    dir_output.update(self._match_files(root, files, pat))
-                    dir_output.update(self._match_dirs_without_slash(root, dirs, pat))
-        return dir_output
-
-    def _report_search(self, pattern, disp_path, depth_msg):
-        self.report_action(
-            tr(
-                "🔍 Search for files '{pattern}' in '{disp_path}'{depth_msg} ...",
-                pattern=pattern,
-                disp_path=disp_path,
-                depth_msg=depth_msg,
-            ),
-            ReportAction.READ,
-        )
-
-    def _report_success(self, count):
-        self.report_success(
-            tr(
-                " ✅ {count} {file_word}",
-                count=count,
-                file_word=pluralize("file", count),
-            ),
-            ReportAction.READ,
-        )
-
-    def _format_output(self, directory, dir_output):
-        if directory.strip() == ".":
-            dir_output = {
-                p[2:] if (p.startswith("./") or p.startswith(".\\")) else p
-                for p in dir_output
-            }
-        return sorted(dir_output)
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
-    def run(
-        self,
-        paths: str,
-        pattern: str,
-        max_depth: int = None,
-        include_gitignored: bool = False,
-    ) -> str:
-        if not pattern:
-            self.report_warning(tr("ℹ️ Empty file pattern provided."), ReportAction.READ)
-            return tr("Warning: Empty file pattern provided. Operation skipped.")
-        patterns = pattern.split()
-        results = []
-        for directory in [expand_path(p) for p in paths.split()]:
-            disp_path = display_path(directory)
-            depth_msg = (
-                tr(" (max depth: {max_depth})", max_depth=max_depth)
-                if max_depth is not None and max_depth > 0
-                else ""
-            )
-            self._report_search(pattern, disp_path, depth_msg)
-            dir_output = set()
-            if os.path.isfile(directory):
-                dir_output = self._handle_path(directory, patterns)
-            elif os.path.isdir(directory):
-                dir_output = self._handle_directory_path(
-                    directory, patterns, max_depth, include_gitignored
-                )
-            self._report_success(len(dir_output))
-            results.extend(self._format_output(directory, dir_output))
-        result = "\n".join(results)
-        return result

janito/plugins/tools/core/get_file_outline/__init__.py

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