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

janito/{plugin_system → plugin_system_backup_20250825_070018}/core_loader_fixed.py

@@ -11,7 +11,8 @@ from pathlib import Path
 from typing import Optional, List, Type
 
 from janito.plugin_system.base import Plugin, PluginMetadata
-from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.tools.function_adapter import create_function_tool
+from janito.tools.tool_base import ToolBase
 
 
 class CorePlugin(Plugin):
@@ -36,89 +37,12 @@ class CorePlugin(Plugin):
     def get_tools(self) -> List[Type[ToolBase]]:
         return self._tool_classes
 
-    def _create_tool_class(self, func):
-        """Create a ToolBase class from a function."""
-        resolved_tool_name = getattr(func, "tool_name", func.__name__)
-        
-        # Create a proper tool class with explicit parameters and documentation
-        import inspect
-        from typing import get_type_hints
-        
-        func_sig = inspect.signature(func)
-        type_hints = get_type_hints(func)
-        
-        # Build parameter definitions for the run method
-        param_defs = []
-        param_docs = []
-        for name, param in func_sig.parameters.items():
-            type_hint = type_hints.get(name, str)
-            if param.default == inspect.Parameter.empty:
-                param_defs.append(f"{name}: {type_hint.__name__}")
-            else:
-                param_defs.append(f"{name}: {type_hint.__name__} = {repr(param.default)}")
-            
-            # Add parameter documentation
-            param_docs.append(f"    {name}: {type_hint.__name__} - Parameter {name}")
-        
-        # Get function docstring or create one
-        func_doc = func.__doc__ or f"Execute {resolved_tool_name} tool"
-        
-        # Create the tool class with proper signature and documentation
-        exec_globals = {
-            'ToolBase': ToolBase,
-            'ToolPermissions': ToolPermissions,
-            'func': func,
-            'inspect': inspect,
-            'str': str,
-            'List': list,
-            'Dict': dict,
-            'Optional': type(None),
-        }
-        
-        param_docs_str = '\n'.join(param_docs)
-        
-        class_def = f'''
-class DynamicTool(ToolBase):
-    """
-    {func_doc}
-    
-    Parameters:
-{param_docs_str}
-    
-    Returns:
-        str: Execution result
-    """
-    tool_name = "{resolved_tool_name}"
-    permissions = ToolPermissions(read=True, write=True, execute=True)
-    
-    def __init__(self):
-        super().__init__()
-    
-    def run(self, {', '.join(param_defs)}) -> str:
-        kwargs = locals()
-        sig = inspect.signature(func)
-        
-        # Filter kwargs to only include parameters the function accepts
-        filtered_kwargs = {{}}
-        for name, param in sig.parameters.items():
-            if name in kwargs and kwargs[name] is not None:
-                filtered_kwargs[name] = kwargs[name]
-        
-        result = func(**filtered_kwargs)
-        return str(result) if result is not None else ""
-'''
-        
-        exec(class_def, exec_globals)
-        return exec_globals['DynamicTool']
-        
-        return DynamicTool
-
     def initialize(self):
         """Initialize by creating tool classes."""
         self._tool_classes = []
         for tool_func in self._tools:
             if callable(tool_func):
-                tool_class = self._create_tool_class(tool_func)
+                tool_class = create_function_tool(tool_func)
                 self._tool_classes.append(tool_class)
 
 

janito/plugins/__init__.py

@@ -1,36 +1,28 @@
 """
-Plugin System for Development Tools
+Unified Plugin System for Janito
 
-This package organizes all available tools into logical plugin groups
-for easier discovery and usage.
+This package provides a clean, unified plugin architecture for janito.
 """
 
 __version__ = "1.0.0"
 __author__ = "Development Assistant"
 
-from .core import filemanager, codeanalyzer, system, imagedisplay
-from .web import webtools
-from .dev import pythondev, visualization
-from .ui import userinterface
-
-# Plugin registry
-PLUGINS = {
-    "core.filemanager": filemanager,
-    "core.codeanalyzer": codeanalyzer,
-    "core.system": system,
-    "core.imagedisplay": imagedisplay,
-    "web.webtools": webtools,
-    "dev.pythondev": pythondev,
-    "dev.visualization": visualization,
-    "ui.userinterface": userinterface,
-}
-
-
-def list_plugins():
-    """Return all available plugins"""
-    return list(PLUGINS.keys())
-
-
-def get_plugin(name):
-    """Get a specific plugin by name"""
-    return PLUGINS.get(name)
+# Import core components
+from .base import Plugin, PluginMetadata, PluginResource
+from .manager import PluginManager
+from .discovery import discover_plugins, list_available_plugins
+from .config import load_plugins_config, save_plugins_config
+from .builtin import BuiltinPluginRegistry, load_builtin_plugin
+
+__all__ = [
+    "Plugin",
+    "PluginMetadata", 
+    "PluginResource",
+    "PluginManager",
+    "discover_plugins",
+    "list_available_plugins",
+    "load_plugins_config",
+    "save_plugins_config",
+    "BuiltinPluginRegistry",
+    "load_builtin_plugin",
+]

janito/plugins/__main__.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Plugin system CLI entry point.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .manager import PluginManager
+from .discovery import list_available_plugins
+from .core_loader import get_core_plugins
+
+
+def list_plugins():
+    """List all available plugins."""
+    print("📋 Available Plugins:")
+    print("=" * 50)
+    
+    # Get available plugins
+    available = list_available_plugins()
+    
+    # Get core plugins
+    core_plugins = get_core_plugins()
+    
+    if available:
+        print("\n🔌 Available Plugins:")
+        for plugin in sorted(available):
+            if plugin in core_plugins:
+                print(f"  ✅ {plugin} (core)")
+            else:
+                print(f"  🔌 {plugin}")
+    else:
+        print("  No plugins found in search paths")
+    
+    print(f"\n📊 Total: {len(available)} plugins")
+
+
+def list_loaded():
+    """List currently loaded plugins."""
+    print("🔧 Currently Loaded Plugins:")
+    print("=" * 50)
+    
+    pm = PluginManager()
+    
+    # Load core plugins
+    core_plugins = get_core_plugins()
+    for plugin in core_plugins:
+        pm.load_plugin(plugin)
+    
+    loaded = pm.list_plugins()
+    
+    if loaded:
+        for plugin in sorted(loaded):
+            metadata = pm.get_plugin_metadata(plugin)
+            if metadata:
+                print(f"  📦 {plugin} v{metadata.version}")
+                print(f"     {metadata.description}")
+            else:
+                print(f"  📦 {plugin}")
+    else:
+        print("  No plugins currently loaded")
+    
+    print(f"\n📊 Total: {len(loaded)} plugins loaded")
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(description="Janito Plugin System CLI")
+    parser.add_argument(
+        "--list-plugins", 
+        action="store_true", 
+        help="List all loaded plugins"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.list_plugins:
+        list_loaded()
+    else:
+        list_loaded()
+
+
+if __name__ == "__main__":
+    main()

janito/plugins/base.py

@@ -0,0 +1,57 @@
+"""
+Base classes for janito plugins.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Dict, Any, List, Optional, Type
+
+@dataclass
+class PluginMetadata:
+    name: str
+    version: str
+    description: str
+    author: str
+    license: str = "MIT"
+    homepage: Optional[str] = None
+    dependencies: List[str] = None
+
+    def __post_init__(self):
+        if self.dependencies is None:
+            self.dependencies = []
+
+@dataclass
+class PluginResource:
+    name: str
+    type: str
+    description: str
+    schema: Optional[Dict[str, Any]] = None
+
+class Plugin(ABC):
+    def __init__(self):
+        self.metadata: PluginMetadata = self.get_metadata()
+
+    @abstractmethod
+    def get_metadata(self) -> PluginMetadata:
+        pass
+
+    def get_tools(self):
+        return []
+
+    def get_commands(self):
+        return {}
+
+    def initialize(self):
+        pass
+
+    def cleanup(self):
+        pass
+
+    def get_config_schema(self):
+        return {}
+
+    def validate_config(self, config):
+        return True
+
+    def get_resources(self):
+        return []

janito/plugins/builtin.py

@@ -7,7 +7,7 @@ with janito and available by default without requiring external installation.
 
 import importlib
 from typing import Dict, List, Optional, Type
-from janito.plugin_system.base import Plugin
+from .base import Plugin
 
 
 class BuiltinPluginRegistry:

janito/plugins/core/filemanager/tools/copy_file.py

@@ -13,12 +13,36 @@ from janito.i18n import tr
 class CopyFileTool(ToolBase):
     """
     Copy one or more files to a target directory, or copy a single file to a new file.
-    Args:
+    
+    Parameters:
         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.
+        content (str): File content to write or process
+        recursive (bool): Whether to process directories recursively
+        from_line (int): Starting line number for file reading
+        to_line (int): Ending line number for file reading
+        search_text (str): Text to search for in files
+        replacement_text (str): Text to replace search matches with
+        use_regex (bool): Whether to treat search as regex pattern
+        case_sensitive (bool): Whether search should be case sensitive
+        max_depth (int): Maximum directory depth to search
+        include_gitignored (bool): Whether to include .gitignored files
+        timeout (int): Timeout in seconds for operations
+        require_confirmation (bool): Whether to require user confirmation
+        data (dict): Chart data for visualization tools
+        title (str): Chart title
+        width (int): Chart width in pixels
+        height (int): Chart height in pixels
+        query (str): Search query for text search
+        paths (str): Directory or file paths to search in
+        src_path (str): Source path for move operations
+        dest_path (str): Destination path for move operations
+        code (str): Python code to execute
+        pattern (str): File pattern to match (e.g., '*.py')
+    
     Returns:
         str: Status string for each copy operation.
     """

janito/plugins/core/filemanager/tools/create_directory.py

@@ -12,8 +12,35 @@ from janito.tools.path_utils import expand_path
 class CreateDirectoryTool(ToolBase):
     """
     Create a new directory at the specified path.
-    Args:
+    
+    Parameters:
         path (str): Path for the new directory.
+        content (str): File content to write or process
+        overwrite (bool): Whether to overwrite existing files (default: False)
+        sources (str): Source file(s) to copy from
+        target (str): Destination path for copy operations
+        recursive (bool): Whether to process directories recursively
+        from_line (int): Starting line number for file reading
+        to_line (int): Ending line number for file reading
+        search_text (str): Text to search for in files
+        replacement_text (str): Text to replace search matches with
+        use_regex (bool): Whether to treat search as regex pattern
+        case_sensitive (bool): Whether search should be case sensitive
+        max_depth (int): Maximum directory depth to search
+        include_gitignored (bool): Whether to include .gitignored files
+        timeout (int): Timeout in seconds for operations
+        require_confirmation (bool): Whether to require user confirmation
+        data (dict): Chart data for visualization tools
+        title (str): Chart title
+        width (int): Chart width in pixels
+        height (int): Chart height in pixels
+        query (str): Search query for text search
+        paths (str): Directory or file paths to search in
+        src_path (str): Source path for move operations
+        dest_path (str): Destination path for move operations
+        code (str): Python code to execute
+        pattern (str): File pattern to match (e.g., '*.py')
+    
     Returns:
         str: Status message indicating the result. Example:
             - "5c5 Successfully created the directory at ..."

janito/plugins/core/filemanager/tools/create_file.py

@@ -16,10 +16,34 @@ class CreateFileTool(ToolBase):
     """
     Create a new file with the given content.
 
-    Args:
+    Parameters:
         path (str): Path to the file to create.
         content (str): Content to write to the file.
         overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
+        sources (str): Source file(s) to copy from
+        target (str): Destination path for copy operations
+        recursive (bool): Whether to process directories recursively
+        from_line (int): Starting line number for file reading
+        to_line (int): Ending line number for file reading
+        search_text (str): Text to search for in files
+        replacement_text (str): Text to replace search matches with
+        use_regex (bool): Whether to treat search as regex pattern
+        case_sensitive (bool): Whether search should be case sensitive
+        max_depth (int): Maximum directory depth to search
+        include_gitignored (bool): Whether to include .gitignored files
+        timeout (int): Timeout in seconds for operations
+        require_confirmation (bool): Whether to require user confirmation
+        data (dict): Chart data for visualization tools
+        title (str): Chart title
+        width (int): Chart width in pixels
+        height (int): Chart height in pixels
+        query (str): Search query for text search
+        paths (str): Directory or file paths to search in
+        src_path (str): Source path for move operations
+        dest_path (str): Destination path for move operations
+        code (str): Python code to execute
+        pattern (str): File pattern to match (e.g., '*.py')
+
     Returns:
         str: Status message indicating the result. Example:
             - "✅ Successfully created the file at ..."
@@ -27,13 +51,13 @@ class CreateFileTool(ToolBase):
     Note: Syntax validation is automatically performed after this operation.
 
     Security: This tool includes loop protection to prevent excessive file creation operations.
-    Protection: Prevents repeated create calls for the same file path within a short window (1 allowed per 10 seconds).
+    Maximum 5 calls per 10 seconds for the same file path.
     """
 
     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/core/filemanager/tools/delete_text_in_file.py

@@ -15,6 +15,7 @@ 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/core/imagedisplay/plugin.py

@@ -4,7 +4,7 @@ Image Display Plugin implementation.
 
 from typing import Dict, Any, List, Type
 
-from janito.plugin_system.base import Plugin, PluginMetadata
+from ...base import Plugin, PluginMetadata
 from janito.tools.tool_base import ToolBase
 from .tools.show_image import ShowImageTool
 from .tools.show_image_grid import ShowImageGridTool

janito/plugins/core_loader.py

@@ -0,0 +1,144 @@
+"""
+Fixed core plugin loader.
+
+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 .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:
+                # 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"
+        )
+        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
+
+        # 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.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__)
 
@@ -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 .base import PluginMetadata
 
             # Create a dynamic plugin class
             class PackagePlugin(Plugin):

janito/plugins/example_plugin.py

@@ -2,7 +2,7 @@
 Example plugin demonstrating the plugin system.
 """
 
-from janito.plugin_system.base import Plugin, PluginMetadata, PluginResource
+from .base import Plugin, PluginMetadata, PluginResource
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from typing import Dict, Any
 

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/plugins_backup_20250825_070018/__init__.py

@@ -0,0 +1,36 @@
+"""
+Plugin System for Development Tools
+
+This package organizes all available tools into logical plugin groups
+for easier discovery and usage.
+"""
+
+__version__ = "1.0.0"
+__author__ = "Development Assistant"
+
+from .core import filemanager, codeanalyzer, system, imagedisplay
+from .web import webtools
+from .dev import pythondev, visualization
+from .ui import userinterface
+
+# Plugin registry
+PLUGINS = {
+    "core.filemanager": filemanager,
+    "core.codeanalyzer": codeanalyzer,
+    "core.system": system,
+    "core.imagedisplay": imagedisplay,
+    "web.webtools": webtools,
+    "dev.pythondev": pythondev,
+    "dev.visualization": visualization,
+    "ui.userinterface": userinterface,
+}
+
+
+def list_plugins():
+    """Return all available plugins"""
+    return list(PLUGINS.keys())
+
+
+def get_plugin(name):
+    """Get a specific plugin by name"""
+    return PLUGINS.get(name)