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

janito/plugins/tools/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 janito.plugins.tools.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_tools_plugin.py

@@ -1,87 +0,0 @@
-"""
-Core tools plugin implementation.
-"""
-
-from functools import wraps
-from typing import Type
-from janito.plugin_system.base import Plugin, PluginMetadata
-
-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 .fetch_url import FetchUrl
-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
-
-# 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
-
-
-class CoreToolsPlugin(Plugin):
-    """Core tools plugin providing essential janito functionality."""
-
-    def get_metadata(self):
-        return PluginMetadata(
-            name="core_tools",
-            version="1.0.0",
-            description="Core tools for file operations, code execution, and system interactions",
-            author="janito team",
-            license="MIT",
-        )
-
-    def get_tools(self):
-        return [
-            AskUser,
-            CopyFile,
-            CreateDirectory,
-            CreateFile,
-            DeleteTextInFile,
-            FetchUrl,
-            FindFiles,
-            MoveFile,
-            OpenHtmlInBrowser,
-            OpenUrl,
-            PythonCodeRun,
-            PythonCommandRun,
-            PythonFileRun,
-            ReadChart,
-            ReadFiles,
-            RemoveDirectory,
-            RemoveFile,
-            ReplaceTextInFile,
-            RunBashCommand,
-            RunPowershellCommand,
-            ShowImage,
-            ShowImageGrid,
-            ViewFile,
-            ValidateFileSyntax,
-            GetFileOutline,
-            SearchText,
-        ] + get_core_tools()

janito/plugins/tools/create_directory.py

@@ -1,70 +0,0 @@
-from janito.plugins.tools.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/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/delete_text_in_file.py

@@ -1,134 +0,0 @@
-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
-import shutil
-from janito.plugins.tools.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/find_files.py

@@ -1,143 +0,0 @@
-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.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/get_file_outline/__init__.py

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

janito/plugins/tools/get_file_outline/core.py

@@ -1,122 +0,0 @@
-from janito.tools.adapters.local.adapter import register_local_tool
-from .python_outline import parse_python_outline
-from .markdown_outline import parse_markdown_outline
-from janito.formatting import OutlineFormatter
-from .java_outline import parse_java_outline
-import os
-from janito.tools.path_utils import expand_path
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.tool_utils import display_path, pluralize
-from janito.i18n import tr
-
-from janito.plugins.tools.decorators import register_core_tool
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_core_tool
-class GetFileOutline(ToolBase):
-    """
-    Get an outline of a file's structure. Supports Python and Markdown files.
-
-    Args:
-        path (str): Path to the file to outline.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "get_file_outline"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str) -> str:
-        try:
-            path = expand_path(path)
-            self.report_action(
-                tr(
-                    "📄 Outline file '{disp_path}' ...",
-                    disp_path=display_path(path),
-                ),
-                ReportAction.READ,
-            )
-            ext = os.path.splitext(path)[1].lower()
-            with open(path, "r", encoding="utf-8", errors="replace") as f:
-                lines = f.readlines()
-            return self._outline_by_extension(ext, lines)
-        except Exception as e:
-            self.report_error(
-                tr("❌ Error reading file: {error}", error=e),
-                ReportAction.READ,
-            )
-            return tr("Error reading file: {error}", error=e)
-
-    def _outline_by_extension(self, ext, lines):
-        if ext == ".py":
-            outline_items = parse_python_outline(lines)
-            outline_type = "python"
-            table = OutlineFormatter.format_outline_table(outline_items)
-            self.report_success(
-                tr(
-                    "✅ Outlined {count} {item_word}",
-                    count=len(outline_items),
-                    item_word=pluralize("item", len(outline_items)),
-                ),
-                ReportAction.READ,
-            )
-            return (
-                tr(
-                    "Outline: {count} items ({outline_type})\n",
-                    count=len(outline_items),
-                    outline_type=outline_type,
-                )
-                + table
-            )
-        elif ext == ".md":
-            outline_items = parse_markdown_outline(lines)
-            outline_type = "markdown"
-            table = OutlineFormatter.format_markdown_outline_table(outline_items)
-            self.report_success(
-                tr(
-                    "✅ Outlined {count} {item_word}",
-                    count=len(outline_items),
-                    item_word=pluralize("item", len(outline_items)),
-                ),
-                ReportAction.READ,
-            )
-            return (
-                tr(
-                    "Outline: {count} items ({outline_type})\n",
-                    count=len(outline_items),
-                    outline_type=outline_type,
-                )
-                + table
-            )
-        elif ext == ".java":
-            outline_items = parse_java_outline(lines)
-            outline_type = "java"
-            table = OutlineFormatter.format_outline_table(outline_items)
-            self.report_success(
-                tr(
-                    "✅ Outlined {count} {item_word}",
-                    count=len(outline_items),
-                    item_word=pluralize("item", len(outline_items)),
-                ),
-                ReportAction.READ,
-            )
-            return (
-                tr(
-                    "Outline: {count} items ({outline_type})\n",
-                    count=len(outline_items),
-                    outline_type=outline_type,
-                )
-                + table
-            )
-        else:
-            outline_type = "default"
-            self.report_success(
-                tr("✅ Outlined {count} items", count=len(lines)),
-                ReportAction.READ,
-            )
-            return tr(
-                "Outline: {count} lines ({outline_type})\nFile has {count} lines.",
-                count=len(lines),
-                outline_type=outline_type,
-            )