janito 2.33.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

janito/plugins/example_plugin.py

@@ -0,0 +1,108 @@
+"""
+Example plugin demonstrating the plugin system.
+"""
+
+from janito.plugin_system.base import Plugin, PluginMetadata, PluginResource
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from typing import Dict, Any
+
+
+class HelloWorldTool(ToolBase):
+    """A simple tool that says hello."""
+
+    tool_name = "hello_world"
+    permissions = ToolPermissions(read=True, write=False, execute=True)
+
+    def run(self, name: str = "World") -> str:
+        """
+        Say hello to someone.
+
+        Args:
+            name: Name of the person to greet
+
+        Returns:
+            Greeting message
+        """
+        self.report_action(f"Saying hello to {name}", "greet")
+        return f"Hello, {name}!"
+
+
+class CalculatorTool(ToolBase):
+    """A simple calculator tool."""
+
+    tool_name = "calculator"
+    permissions = ToolPermissions(read=True, write=False, execute=True)
+
+    def run(self, operation: str, a: float, b: float) -> str:
+        """
+        Perform basic calculations.
+
+        Args:
+            operation: Operation to perform (add, subtract, multiply, divide)
+            a: First number
+            b: Second number
+
+        Returns:
+            Result as string
+        """
+        self.report_action(f"Calculating {a} {operation} {b}", "calculate")
+
+        if operation == "add":
+            result = a + b
+        elif operation == "subtract":
+            result = a - b
+        elif operation == "multiply":
+            result = a * b
+        elif operation == "divide":
+            if b == 0:
+                return "Error: Division by zero"
+            result = a / b
+        else:
+            return f"Error: Unknown operation '{operation}'"
+
+        return str(result)
+
+
+class ExamplePlugin(Plugin):
+    """Example plugin providing basic tools."""
+
+    def get_metadata(self) -> PluginMetadata:
+        return PluginMetadata(
+            name="example",
+            version="1.0.0",
+            description="Example plugin with basic tools",
+            author="Janito Team",
+            license="MIT",
+            homepage="https://github.com/janito/example-plugin",
+        )
+
+    def get_tools(self):
+        return [HelloWorldTool, CalculatorTool]
+
+    def initialize(self):
+        print("Example plugin initialized!")
+
+    def cleanup(self):
+        print("Example plugin cleaned up!")
+
+    def get_config_schema(self) -> Dict[str, Any]:
+        """Return JSON schema for plugin configuration."""
+        return {
+            "type": "object",
+            "properties": {
+                "greeting_prefix": {
+                    "type": "string",
+                    "description": "Custom greeting prefix for hello_world tool",
+                    "default": "Hello",
+                },
+                "max_calculation": {
+                    "type": "number",
+                    "description": "Maximum allowed calculation result",
+                    "default": 1000000,
+                },
+            },
+        }
+
+
+# This makes the plugin discoverable
+PLUGIN_CLASS = ExamplePlugin

janito/plugins/manager.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from typing import Dict, List, Optional, Any
 import logging
 
-from .base import Plugin, PluginMetadata
+from janito.plugin_system.base import Plugin, PluginMetadata
 from .discovery import discover_plugins
 from .config import load_plugins_config, get_user_plugins_dir
 from .builtin import BuiltinPluginRegistry, load_builtin_plugin

janito/plugins/tools/__init__.py

@@ -0,0 +1,10 @@
+"""
+Core tools plugin for janito.
+
+This plugin provides the essential tools for file operations, code execution,
+and system interactions that are core to janito's functionality.
+"""
+
+from .core_tools_plugin import CoreToolsPlugin
+
+__all__ = ["CoreToolsPlugin"]

janito/{tools/adapters/local → plugins/tools}/ask_user.py

@@ -1,5 +1,5 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.tools.adapters.local.adapter import register_local_tool
+from janito.plugins.tools.decorators import register_core_tool
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 from rich import print as rich_print
@@ -16,8 +16,8 @@ from prompt_toolkit.styles import Style
 toolbar_style = Style.from_dict({"bottom-toolbar": "fg:yellow bg:darkred"})
 
 
-@register_local_tool
-class AskUserTool(ToolBase):
+@register_core_tool
+class AskUser(ToolBase):
     """
     Prompts the user for clarification or input with a question.
 

janito/plugins/tools/copy_file.py

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

@@ -0,0 +1,88 @@
+"""
+Core tools plugin implementation.
+"""
+
+from functools import wraps
+from typing import Type
+from janito.plugin_system.base import Plugin, PluginMetadata
+
+# 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
+
+
+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
+
+
+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.
 

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.