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

janito/plugins/core_loader_fixed.py

@@ -0,0 +1,125 @@
+"""
+Fixed core plugin loader.
+
+This module provides a working implementation to load core plugins
+by directly using the Plugin base class properly.
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+from typing import Optional, List, Type
+
+from janito.plugins.base import Plugin, PluginMetadata
+from janito.tools.function_adapter import create_function_tool
+from janito.tools.tool_base import ToolBase
+
+
+class CorePlugin(Plugin):
+    """Working core plugin implementation."""
+    
+    def __init__(self, name: str, description: str, tools: list):
+        self._plugin_name = name
+        self._description = description
+        self._tools = tools
+        self._tool_classes = []
+        super().__init__()  # Call super after setting attributes
+        
+    def get_metadata(self) -> PluginMetadata:
+        return PluginMetadata(
+            name=self._plugin_name,
+            version="1.0.0",
+            description=self._description,
+            author="Janito",
+            license="MIT",
+        )
+    
+    def get_tools(self) -> List[Type[ToolBase]]:
+        return self._tool_classes
+    
+    def initialize(self):
+        """Initialize by creating tool classes."""
+        self._tool_classes = []
+        for tool_func in self._tools:
+            if callable(tool_func):
+                tool_class = create_function_tool(tool_func)
+                self._tool_classes.append(tool_class)
+
+
+def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
+    """
+    Load a core plugin by name.
+    
+    Args:
+        plugin_name: Name of the plugin (e.g., 'core.filemanager')
+        
+    Returns:
+        Plugin instance if loaded successfully
+    """
+    try:
+        # Parse plugin name
+        if "." not in plugin_name:
+            return None
+            
+        parts = plugin_name.split(".")
+        if len(parts) != 2:
+            return None
+            
+        package_name, submodule_name = parts
+        
+        # Handle imagedisplay specially
+        if plugin_name == "core.imagedisplay":
+            # Import the actual plugin class
+            try:
+                from plugins.core.imagedisplay.plugin import ImageDisplayPlugin
+                return ImageDisplayPlugin()
+            except ImportError:
+                # If import fails, return None - don't return True
+                return None
+        
+        # Build path to plugin
+        plugin_path = Path("plugins") / package_name / submodule_name / "__init__.py"
+        if not plugin_path.exists():
+            return None
+            
+        # Load the module
+        spec = importlib.util.spec_from_file_location(plugin_name, plugin_path)
+        if spec is None or spec.loader is None:
+            return None
+            
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        
+        # Get plugin info
+        name = getattr(module, "__plugin_name__", plugin_name)
+        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
+        tools = getattr(module, "__plugin_tools__", [])
+        
+        if not tools:
+            return None
+            
+        # Create plugin
+        plugin = CorePlugin(name, description, tools)
+        plugin.initialize()
+        return plugin
+        
+    except Exception as e:
+        print(f"Error loading core plugin {plugin_name}: {e}")
+        return None
+
+
+def get_core_plugins() -> list:
+    """Get list of all available core plugins."""
+    core_plugins = [
+        "core.filemanager",
+        "core.codeanalyzer",
+        "core.system",
+        "core.imagedisplay",
+        "dev.pythondev",
+        "dev.visualization",
+        "ui.userinterface",
+        "web.webtools",
+    ]
+    
+    # All core plugins are always available
+    return core_plugins

janito/plugins/discovery.py

@@ -31,9 +31,9 @@ from pathlib import Path
 from typing import Optional, List
 import logging
 
-from janito.plugin_system.base import Plugin
+from .base import Plugin
 from .builtin import load_builtin_plugin, BuiltinPluginRegistry
-from janito.plugin_system.core_loader import load_core_plugin
+from .core_loader import load_core_plugin
 
 logger = logging.getLogger(__name__)
 
@@ -75,13 +75,13 @@ def discover_plugins(
         parts = plugin_name.split(".")
         if len(parts) == 2:
             package_name, submodule_name = parts
-
+            
             # Handle core plugins with dedicated loader
             if plugin_name.startswith(("core.", "dev.", "ui.", "web.")):
                 plugin = load_core_plugin(plugin_name)
                 if plugin:
                     return plugin
-
+                    
             for base_path in all_paths:
                 package_path = base_path / package_name / submodule_name / "__init__.py"
                 if package_path.exists():
@@ -157,7 +157,7 @@ def _load_plugin_from_file(
 
         # Check for package-based plugin with __plugin_name__ metadata
         if hasattr(module, "__plugin_name__"):
-            from janito.plugin_system.base import PluginMetadata
+            from janito.plugins.base import PluginMetadata
 
             # Create a dynamic plugin class
             class PackagePlugin(Plugin):

janito/plugins/discovery_core.py

@@ -17,11 +17,11 @@ from .core_adapter import CorePluginAdapter
 def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
     """
     Load a core plugin from a package directory.
-
+    
     Args:
         package_path: Path to the __init__.py file
         plugin_name: Full plugin name (e.g., core.filemanager)
-
+        
     Returns:
         Plugin instance if loaded successfully
     """
@@ -30,25 +30,20 @@ def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
         spec = importlib.util.spec_from_file_location(plugin_name, package_path)
         if spec is None or spec.loader is None:
             return None
-
+            
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)
-
+        
         # Get plugin metadata
         plugin_name_attr = getattr(module, "__plugin_name__", plugin_name)
-        description = getattr(
-            module, "__plugin_description__", f"Core plugin: {plugin_name}"
-        )
-
+        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
+        
         # Create and return the core plugin adapter
         plugin = CorePluginAdapter(plugin_name_attr, description, module)
         plugin.initialize()  # Initialize to set up tools
         return plugin
-
+        
     except Exception as e:
         import logging
-
-        logging.getLogger(__name__).error(
-            f"Failed to load core plugin {plugin_name}: {e}"
-        )
-        return None
+        logging.getLogger(__name__).error(f"Failed to load core plugin {plugin_name}: {e}")
+        return None

janito/plugins/manager.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from typing import Dict, List, Optional, Any
 import logging
 
-from janito.plugin_system.base import Plugin, PluginMetadata
+from .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/providers/__init__.py

@@ -10,4 +10,3 @@ import janito.providers.zai.provider
 import janito.providers.cerebras.provider
 import janito.providers.mistral.provider
 import janito.providers.ibm.provider
-import janito.providers.together.provider

janito/tools/__init__.py

@@ -1,6 +1,6 @@
-from janito.tools.adapters.local import LocalToolsAdapter
-from janito.tools.adapters.local.adapter import (
-    LocalToolsAdapter as _internal_local_tools_adapter,
+from janito.tools.adapters.local import (
+    local_tools_adapter as _internal_local_tools_adapter,
+    LocalToolsAdapter,
 )
 
 
@@ -11,10 +11,8 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     if workdir is not None and not os.path.exists(workdir):
         os.makedirs(workdir, exist_ok=True)
     # Permissions are now managed globally; ignore allowed_permissions argument except for backward compatibility
-    # Create and initialize adapter
-    from janito.tools.initialize import initialize_tools
-
-    registry = initialize_tools(LocalToolsAdapter(workdir=workdir))
+    # Reuse the singleton adapter defined in janito.tools.adapters.local to maintain tool registrations
+    registry = _internal_local_tools_adapter
     # Change workdir if requested
     if workdir is not None:
         try:
@@ -29,32 +27,10 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     return registry
 
 
-# Initialize the global adapter - defer import to avoid circular dependencies
-local_tools_adapter = None
-
-
-def get_local_tools_adapter(workdir=None, allowed_permissions=None):
-    """Get the global tools adapter, initializing on first use."""
-    global local_tools_adapter
-    if local_tools_adapter is None:
-        from janito.tools.initialize import initialize_tools
-
-        adapter = LocalToolsAdapter(workdir=workdir)
-        local_tools_adapter = initialize_tools(adapter)
-
-    # Handle workdir if provided
-    if workdir is not None and local_tools_adapter is not None:
-        import os
-
-        if not os.path.exists(workdir):
-            os.makedirs(workdir, exist_ok=True)
-        os.chdir(workdir)
-        local_tools_adapter.workdir = workdir
-
-    return local_tools_adapter
-
+local_tools_adapter = _internal_local_tools_adapter
 
 __all__ = [
     "LocalToolsAdapter",
     "get_local_tools_adapter",
+    "local_tools_adapter",
 ]

janito/tools/adapters/__init__.py

@@ -1,6 +1 @@
-"""
-Tools providers package: for plug-and-play tool collections, integrations, and adapters.
-
-This package contains the core adapter infrastructure for managing tools,
-while the actual tool implementations have been moved to the plugins system.
-"""
+# Tools providers package: for plug-and-play tool collections, integrations, and adapters.

janito/tools/adapters/local/__init__.py

@@ -1,10 +1,73 @@
-"""
-Local tools adapter for janito.
+from .adapter import LocalToolsAdapter
 
-This package provides the LocalToolsAdapter class which manages tool registration
-and execution for local, in-process tools.
-"""
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .read_files import ReadFilesTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .open_html_in_browser import OpenHtmlInBrowserTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+from .read_chart import ReadChartTool
+from .show_image import ShowImageTool
+from .show_image_grid import ShowImageGridTool
 
-from .adapter import LocalToolsAdapter
+from janito.tools.tool_base import ToolPermissions
+import os
+from janito.tools.permissions import get_global_allowed_permissions
+
+# Singleton tools adapter with all standard tools registered
+local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+
+
+def get_local_tools_adapter(workdir=None):
+    return LocalToolsAdapter(workdir=workdir or os.getcwd())
+
+
+# Register tools
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    ReadFilesTool,
+    MoveFileTool,
+    OpenUrlTool,
+    OpenHtmlInBrowserTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+    ReadChartTool,
+    ShowImageTool,
+    ShowImageGridTool,
+]:
+    local_tools_adapter.register_tool(tool_class)
 
-__all__ = ["LocalToolsAdapter"]
+# DEBUG: Print registered tools at startup

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

@@ -1,5 +1,5 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.plugins.tools.decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_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_core_tool
-class AskUser(ToolBase):
+@register_local_tool
+class AskUserTool(ToolBase):
     """
     Prompts the user for clarification or input with a question.
 

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

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

janito/{plugins/tools → tools/adapters/local}/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.plugins.tools.decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_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_core_tool
-class FetchUrl(ToolBase):
+@register_local_tool
+class FetchUrlTool(ToolBase):
     """
     Fetch the content of a web page and extract its text.
 

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

@@ -1,14 +1,14 @@
 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.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 import shutil
 import re
-from janito.plugins.tools.validate_file_syntax.core import validate_file_syntax
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
 
 
-@register_core_tool
-class ReplaceTextInFile(ToolBase):
+@register_local_tool
+class ReplaceTextInFileTool(ToolBase):
     """
     Replace exact occurrences of a given text in a file.
 

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

@@ -1,12 +1,12 @@
 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.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 
-@register_core_tool
-class ShowImage(ToolBase):
+@register_local_tool
+class ShowImageTool(ToolBase):
     """Display an image inline in the terminal using the rich library.
 
     Args:
@@ -44,9 +44,7 @@ class ShowImage(ToolBase):
 
         path = expand_path(path)
         disp_path = display_path(path)
-        self.report_action(
-            tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ
-        )
+        self.report_action(tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ)
 
         if not os.path.exists(path):
             msg = tr("❗ not found")
@@ -57,14 +55,9 @@ class ShowImage(ToolBase):
             console = Console()
             from rich.console import Console
             from rich.text import Text
-
             console = Console()
             img = PILImage.open(path)
-            console.print(
-                Text(
-                    f"Image: {disp_path} ({img.width}x{img.height})", style="bold green"
-                )
-            )
+            console.print(Text(f"Image: {disp_path} ({img.width}x{img.height})", style="bold green"))
             console.print(img)
             self.report_success(tr("✅ Displayed"))
             details = []
@@ -75,9 +68,7 @@ class ShowImage(ToolBase):
             if not preserve_aspect:
                 details.append("preserve_aspect=False")
             info = ("; ".join(details)) if details else "auto-fit"
-            return tr(
-                "Image displayed: {disp_path} ({info})", disp_path=disp_path, info=info
-            )
+            return tr("Image displayed: {disp_path} ({info})", disp_path=disp_path, info=info)
         except Exception as e:
             self.report_error(tr(" ❌ Error: {error}", error=e))
             return tr("Error displaying image: {error}", error=e)

janito/{plugins/core/imagedisplay/tools → tools/adapters/local}/show_image_grid.py

@@ -1,10 +1,12 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 from janito.tools.loop_protection_decorator import protect_against_loops
 from typing import Sequence
 
 
+@register_local_tool
 class ShowImageGridTool(ToolBase):
     """Display multiple images in a grid inline in the terminal using rich.
 
@@ -48,9 +50,7 @@ class ShowImageGridTool(ToolBase):
         if not paths:
             return tr("No images provided")
 
-        self.report_action(
-            tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ
-        )
+        self.report_action(tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ)
 
         console = Console()
         images = []
@@ -63,9 +63,7 @@ class ShowImageGridTool(ToolBase):
             try:
                 img = PILImage.open(fp)
                 title = f"{display_path(fp)} ({img.width}x{img.height})"
-                images.append(
-                    Panel.fit(title, title=display_path(fp), border_style="dim")
-                )
+                images.append(Panel.fit(title, title=display_path(fp), border_style="dim"))
                 shown += 1
             except Exception as e:
                 self.report_warning(tr("⚠️ Skipped {p}: {e}", p=display_path(fp), e=e))
@@ -73,12 +71,6 @@ class ShowImageGridTool(ToolBase):
         if not images:
             return tr("No images could be displayed")
 
-        # Render in columns (grid-like)
         console.print(Columns(images, equal=True, expand=True, columns=columns))
         self.report_success(tr("✅ Displayed {n} images", n=shown))
-        return tr(
-            "Displayed {shown}/{total} images in a {cols}x? grid",
-            shown=shown,
-            total=len(paths),
-            cols=columns,
-        )
+        return tr("Displayed {shown}/{total} images in a {cols}x? grid", shown=shown, total=len(paths), cols=columns)

janito/tools/function_adapter.py

@@ -0,0 +1,65 @@
+"""
+Function-to-Tool adapter for core plugins.
+
+This module provides a way to wrap function-based tools into proper ToolBase classes.
+"""
+
+import inspect
+from typing import Any, Dict, List, Optional, get_type_hints
+from janito.tools.tool_base import ToolBase, ToolPermissions
+
+
+class FunctionToolAdapter(ToolBase):
+    """Adapter that wraps a function into a ToolBase class."""
+    
+    def __init__(self, func, tool_name: str = None, description: str = None):
+        super().__init__()
+        self._func = func
+        self.tool_name = tool_name or func.__name__
+        self._description = description or func.__doc__ or f"Tool: {self.tool_name}"
+        self.permissions = ToolPermissions(read=True, write=True, execute=True)
+        
+    def run(self, **kwargs) -> Any:
+        """Execute the wrapped function."""
+        return self._func(**kwargs)
+    
+    def get_signature(self) -> Dict[str, Any]:
+        """Get function signature for documentation."""
+        sig = inspect.signature(self._func)
+        type_hints = get_type_hints(self._func)
+        
+        params = {}
+        for name, param in sig.parameters.items():
+            param_info = {
+                "type": str(type_hints.get(name, Any)),
+                "default": param.default if param.default != inspect.Parameter.empty else None,
+                "required": param.default == inspect.Parameter.empty,
+            }
+            params[name] = param_info
+            
+        return {
+            "name": self.tool_name,
+            "description": self._description,
+            "parameters": params,
+            "return_type": str(type_hints.get("return", Any))
+        }
+
+
+def create_function_tool(func, tool_name: str = None, description: str = None) -> type:
+    """
+    Create a ToolBase class from a function.
+    
+    Args:
+        func: The function to wrap
+        tool_name: Optional custom tool name
+        description: Optional custom description
+        
+    Returns:
+        A ToolBase subclass that wraps the function
+    """
+    
+    class DynamicFunctionTool(FunctionToolAdapter):
+        def __init__(self):
+            super().__init__(func, tool_name, description)
+    
+    return DynamicFunctionTool