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

janito/{plugins_backup_20250825_070018 → plugins}/core_adapter.py

@@ -5,7 +5,7 @@ This module provides proper Plugin class implementations for core plugins
 that use the function-based approach instead of class-based.
 """
 
-from janito.plugin_system.base import Plugin, PluginMetadata
+from janito.plugins.base import Plugin, PluginMetadata
 from typing import List, Type
 from janito.tools.tool_base import ToolBase
 from janito.tools.function_adapter import create_function_tool
@@ -13,17 +13,17 @@ from janito.tools.function_adapter import create_function_tool
 
 class CorePluginAdapter(Plugin):
     """Adapter for core plugins using function-based tools."""
-
+    
     def __init__(self, plugin_name: str, description: str, tools_module):
         super().__init__()
         self._plugin_name = plugin_name
         self._description = description
         self._tools_module = tools_module
         self._tool_classes = []
-
+        
         # Set the metadata attribute that Plugin expects
         self.metadata = self.get_metadata()
-
+        
     def get_metadata(self) -> PluginMetadata:
         return PluginMetadata(
             name=self._plugin_name,
@@ -32,15 +32,15 @@ class CorePluginAdapter(Plugin):
             author="Janito",
             license="MIT",
         )
-
+    
     def get_tools(self) -> List[Type[ToolBase]]:
         return self._tool_classes
-
+    
     def initialize(self):
         """Initialize the plugin by creating tool classes."""
         # Get tools from the module
         tools = getattr(self._tools_module, "__plugin_tools__", [])
-
+        
         self._tool_classes = []
         for tool_func in tools:
             if callable(tool_func):
@@ -48,8 +48,6 @@ class CorePluginAdapter(Plugin):
                 self._tool_classes.append(tool_class)
 
 
-def create_core_plugin(
-    plugin_name: str, description: str, tools_module
-) -> CorePluginAdapter:
+def create_core_plugin(plugin_name: str, description: str, tools_module) -> CorePluginAdapter:
     """Create a core plugin adapter."""
-    return CorePluginAdapter(plugin_name, description, tools_module)
+    return CorePluginAdapter(plugin_name, description, tools_module)

janito/plugins/core_loader.py

@@ -1,31 +1,30 @@
 """
-Fixed core plugin loader.
+Core plugin loader that properly handles function-based plugins.
 
-This module provides a working implementation to load core plugins
-by directly using the Plugin base class properly.
+This module provides a simplified approach to load core plugins
+without the complex discovery mechanism.
 """
 
-import importlib
 import importlib.util
 import sys
 from pathlib import Path
-from typing import Optional, List, Type
+from typing import Optional
 
-from .base import Plugin, PluginMetadata
+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."""
-
+    """Simple core plugin implementation."""
+    
     def __init__(self, name: str, description: str, tools: list):
+        super().__init__()
         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,
@@ -34,10 +33,10 @@ class CorePlugin(Plugin):
             author="Janito",
             license="MIT",
         )
-
-    def get_tools(self) -> List[Type[ToolBase]]:
+    
+    def get_tools(self) -> list:
         return self._tool_classes
-
+    
     def initialize(self):
         """Initialize by creating tool classes."""
         self._tool_classes = []
@@ -50,10 +49,10 @@ class CorePlugin(Plugin):
 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
     """
@@ -61,67 +60,39 @@ def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
         # 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:
-                # Use dynamic import to avoid circular dependency
-                plugin_module = importlib.import_module(
-                    "janito.plugins.core.imagedisplay.plugin"
-                )
-                return plugin_module.ImageDisplayPlugin()
-            except ImportError as e:
-                print(f"Failed to load imagedisplay: {e}")
-                return None
-
+        
         # Build path to plugin
-        plugin_path = (
-            Path("janito/plugins") / package_name / submodule_name / "__init__.py"
-        )
+        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}"
-        )
+        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
         tools = getattr(module, "__plugin_tools__", [])
-
+        
         if not tools:
             return None
-
-        # Filter out None values and ensure all tools have tool_name
-        valid_tools = []
-        for tool in tools:
-            if tool is not None:
-                if not hasattr(tool, "tool_name"):
-                    tool.tool_name = tool.__name__
-                valid_tools.append(tool)
-
-        if not valid_tools:
-            return None
-
+            
         # Create plugin
-        plugin = CorePlugin(name, description, valid_tools)
+        plugin = CorePlugin(name, description, tools)
         plugin.initialize()
         return plugin
-
+        
     except Exception as e:
         print(f"Error loading core plugin {plugin_name}: {e}")
         return None
@@ -139,6 +110,11 @@ def get_core_plugins() -> list:
         "ui.userinterface",
         "web.webtools",
     ]
-
-    # All core plugins are always available
-    return core_plugins
+    
+    available = []
+    for plugin_name in core_plugins:
+        plugin = load_core_plugin(plugin_name)
+        if plugin:
+            available.append(plugin_name)
+    
+    return available

janito/{plugin_system_backup_20250825_070018/core_loader.py → plugins/core_loader_fixed.py}

@@ -5,27 +5,26 @@ This module provides a working implementation to load core plugins
 by directly using the Plugin base class properly.
 """
 
-import importlib
 import importlib.util
 import sys
 from pathlib import Path
 from typing import Optional, List, Type
 
-from janito.plugin_system.base import Plugin, PluginMetadata
+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,
@@ -34,10 +33,10 @@ class CorePlugin(Plugin):
             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 = []
@@ -50,10 +49,10 @@ class CorePlugin(Plugin):
 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
     """
@@ -61,67 +60,49 @@ def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
         # 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:
-                # Use dynamic import to avoid circular dependency
-                plugin_module = importlib.import_module(
-                    "janito.plugins.core.imagedisplay.plugin"
-                )
-                return plugin_module.ImageDisplayPlugin()
-            except ImportError as e:
-                print(f"Failed to load imagedisplay: {e}")
+                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("janito/plugins") / package_name / submodule_name / "__init__.py"
-        )
+        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}"
-        )
+        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
         tools = getattr(module, "__plugin_tools__", [])
-
+        
         if not tools:
             return None
-
-        # Filter out None values and ensure all tools have tool_name
-        valid_tools = []
-        for tool in tools:
-            if tool is not None:
-                if not hasattr(tool, "tool_name"):
-                    tool.tool_name = tool.__name__
-                valid_tools.append(tool)
-
-        if not valid_tools:
-            return None
-
+            
         # Create plugin
-        plugin = CorePlugin(name, description, valid_tools)
+        plugin = CorePlugin(name, description, tools)
         plugin.initialize()
         return plugin
-
+        
     except Exception as e:
         print(f"Error loading core plugin {plugin_name}: {e}")
         return None
@@ -139,6 +120,6 @@ def get_core_plugins() -> list:
         "ui.userinterface",
         "web.webtools",
     ]
-
+    
     # All core plugins are always available
-    return core_plugins
+    return core_plugins

janito/plugins/discovery.py

@@ -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 .base import PluginMetadata
+            from janito.plugins.base import PluginMetadata
 
             # Create a dynamic plugin class
             class PackagePlugin(Plugin):

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_backup_20250825_070018/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_backup_20250825_070018/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.
 

janito/{plugins/core/filemanager/tools → tools/adapters/local}/delete_text_in_file.py

@@ -15,7 +15,6 @@ class DeleteTextInFileTool(ToolBase):
         path (str): Path to the file to modify.
         start_marker (str): The starting delimiter string.
         end_marker (str): The ending delimiter string.
-        backup (bool, optional): Deprecated. No backups are created anymore and this flag is ignored. Defaults to False.
 
     Returns:
         str: Status message indicating the result.

janito/{plugins_backup_20250825_070018/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_backup_20250825_070018/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.