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

janito/plugins/tools/core_tools_plugin.py

@@ -0,0 +1,87 @@
+"""
+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

@@ -0,0 +1,70 @@
+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/{tools/adapters/local → plugins/tools}/create_file.py

@@ -1,6 +1,6 @@
 import os
 from janito.tools.path_utils import expand_path
-from janito.tools.adapters.local.adapter import register_local_tool
+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
@@ -8,11 +8,11 @@ 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
+from janito.plugins.tools.validate_file_syntax.core import validate_file_syntax
 
 
-@register_local_tool
-class CreateFileTool(ToolBase):
+@register_core_tool
+class CreateFile(ToolBase):
     """
     Create a new file with specified content at the given path.
 
@@ -55,7 +55,7 @@ class CreateFileTool(ToolBase):
         or file exists (when overwrite=False).
 
     Security Features:
-        - Loop protection: Maximum 5 calls per 10 seconds for the same file path
+        - 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
@@ -84,7 +84,7 @@ class CreateFileTool(ToolBase):
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    @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)

janito/plugins/tools/decorators.py

@@ -0,0 +1,19 @@
+"""
+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

@@ -0,0 +1,134 @@
+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/{tools/adapters/local → plugins/tools}/fetch_url.py

@@ -5,7 +5,7 @@ import json
 from pathlib import Path
 from bs4 import BeautifulSoup
 from typing import Dict, Any, Optional
-from janito.tools.adapters.local.adapter import register_local_tool
+from janito.plugins.tools.decorators import register_core_tool
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
@@ -13,8 +13,8 @@ from janito.tools.tool_utils import pluralize
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 
-@register_local_tool
-class FetchUrlTool(ToolBase):
+@register_core_tool
+class FetchUrl(ToolBase):
     """
     Fetch the content of a web page and extract its text.
 

janito/plugins/tools/find_files.py

@@ -0,0 +1,143 @@
+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

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

janito/plugins/tools/get_file_outline/core.py

@@ -0,0 +1,122 @@
+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,
+            )