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

janito/plugin_system/core_loader_fixed.py

@@ -0,0 +1,149 @@
+"""
+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.plugin_system.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 janito.plugins.core.imagedisplay.plugin import ImageDisplayPlugin
+
+                return 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)
+
+        # Add module to sys.modules to prevent circular imports
+        sys.modules[plugin_name] = module
+
+        try:
+            # Read and execute the module content
+            with open(plugin_path, "r", encoding="utf-8") as f:
+                code = f.read()
+
+            # Execute in module's namespace
+            exec(code, module.__dict__)
+
+            # Get plugin info
+            name = module.__dict__.get("__plugin_name__", plugin_name)
+            description = module.__dict__.get(
+                "__plugin_description__", f"Core plugin: {plugin_name}"
+            )
+            tools = module.__dict__.get("__plugin_tools__", [])
+
+            if not tools:
+                return None
+
+            # Ensure all tools have tool_name attribute
+            for tool in tools:
+                if tool is not None and not hasattr(tool, "tool_name"):
+                    tool.tool_name = tool.__name__
+
+            # Create plugin
+            plugin = CorePlugin(name, description, tools)
+            plugin.initialize()
+            return plugin
+        finally:
+            # Clean up sys.modules
+            if plugin_name in sys.modules:
+                del sys.modules[plugin_name]
+
+    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/__init__.py

@@ -1,17 +1,36 @@
 """
-Plugin system for janito.
+Plugin System for Development Tools
 
-This package provides a flexible plugin system that allows extending
-janito's functionality with custom tools, commands, and features.
+This package organizes all available tools into logical plugin groups
+for easier discovery and usage.
 """
 
-from .manager import PluginManager
-from .base import Plugin, PluginMetadata
-from .discovery import discover_plugins
+__version__ = "1.0.0"
+__author__ = "Development Assistant"
 
-__all__ = [
-    "PluginManager",
-    "Plugin",
-    "PluginMetadata",
-    "discover_plugins",
-]
+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)

janito/plugins/auto_loader_fixed.py

@@ -9,12 +9,12 @@ import os
 from pathlib import Path
 from typing import List
 from janito.plugins.manager import PluginManager
-from janito.plugins.core_loader_fixed import load_core_plugin, get_core_plugins
+from janito.plugin_system.core_loader_fixed import load_core_plugin, get_core_plugins
 
 # List of core plugins that should be enabled by default
 CORE_PLUGINS = [
     "core.filemanager",
-    "core.codeanalyzer", 
+    "core.codeanalyzer",
     "core.system",
     "core.imagedisplay",
     "dev.pythondev",
@@ -27,18 +27,18 @@ CORE_PLUGINS = [
 def load_core_plugins(pm: PluginManager = None) -> List[str]:
     """
     Load all core plugins.
-    
+
     Args:
         pm: PluginManager instance. If None, creates a new one.
-        
+
     Returns:
         List of successfully loaded plugin names
     """
     if pm is None:
         pm = PluginManager()
-    
+
     loaded = []
-    
+
     # Load core plugins
     for plugin_name in CORE_PLUGINS:
         try:
@@ -49,14 +49,14 @@ def load_core_plugins(pm: PluginManager = None) -> List[str]:
                 loaded.append(plugin_name)
         except Exception as e:
             print(f"Warning: Failed to load core plugin {plugin_name}: {e}")
-    
+
     return loaded
 
 
 def get_loaded_core_plugins() -> List[str]:
     """
     Get list of currently loaded core plugins.
-    
+
     Returns:
         List of loaded core plugin names
     """
@@ -68,10 +68,10 @@ def get_loaded_core_plugins() -> List[str]:
 def is_core_plugin(plugin_name: str) -> bool:
     """
     Check if a plugin is a core plugin.
-    
+
     Args:
         plugin_name: Name of the plugin to check
-        
+
     Returns:
         True if it's a core plugin
     """
@@ -81,10 +81,11 @@ def is_core_plugin(plugin_name: str) -> bool:
 # Auto-load core plugins when module is imported
 _plugin_manager = None
 
+
 def get_plugin_manager() -> PluginManager:
     """Get the global plugin manager with core plugins loaded."""
     global _plugin_manager
     if _plugin_manager is None:
         _plugin_manager = PluginManager()
         load_core_plugins(_plugin_manager)
-    return _plugin_manager
+    return _plugin_manager

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.plugins.base import Plugin
+from janito.plugin_system.base import Plugin
 
 
 class BuiltinPluginRegistry:
@@ -83,6 +83,20 @@ try:
         "documentation_generator", DocumentationGeneratorPlugin
     )
 
+    # Register core tools plugin
+    from janito.plugins.tools import CoreToolsPlugin
+
+    BuiltinPluginRegistry.register("core_tools", CoreToolsPlugin)
+
 except ImportError:
     # janito-coder not available, skip registration
     pass
+
+# Register core tools plugin (always available)
+try:
+    from janito.plugins.tools import CoreToolsPlugin
+
+    BuiltinPluginRegistry.register("core_tools", CoreToolsPlugin)
+except ImportError:
+    # Should not happen, but handle gracefully
+    pass

janito/plugins/core/__init__.py

@@ -0,0 +1,7 @@
+"""
+Core Plugin Package
+
+Contains essential system and file management plugins.
+"""
+
+__all__ = ["filemanager", "codeanalyzer", "system"]

janito/plugins/core/codeanalyzer/__init__.py

@@ -0,0 +1,43 @@
+"""
+Code Analyzer Plugin
+
+Tools for understanding and searching code structure.
+"""
+
+from typing import List, Optional
+
+
+def get_file_outline(path: str) -> str:
+    """Get file structure (classes, functions, etc.)"""
+    return f"get_file_outline(path='{path}')"
+
+
+get_file_outline.tool_name = "get_file_outline"
+
+
+def search_outline(path: str) -> str:
+    """Search within file outlines"""
+    return f"search_outline(path='{path}')"
+
+
+search_outline.tool_name = "search_outline"
+
+
+def search_text(
+    paths: str,
+    query: str,
+    use_regex: bool = False,
+    case_sensitive: bool = True,
+    max_depth: Optional[int] = None,
+) -> str:
+    """Full-text search across files with regex support"""
+    return f"search_text(paths='{paths}', query='{query}', regex={use_regex})"
+
+
+search_text.tool_name = "search_text"
+
+
+# Plugin metadata
+__plugin_name__ = "core.codeanalyzer"
+__plugin_description__ = "Code analysis and structure understanding"
+__plugin_tools__ = [get_file_outline, search_outline, search_text]

janito/plugins/core/filemanager/__init__.py

@@ -0,0 +1,124 @@
+"""
+File Manager Plugin
+
+Core file and directory operations for managing project files.
+"""
+
+from typing import List, Optional
+import os
+
+
+def create_file(path: str, content: str = "", overwrite: bool = False) -> str:
+    """Create a new file with content"""
+    return f"create_file(path='{path}', content='{len(content)} chars', overwrite={overwrite})"
+
+
+create_file.tool_name = "create_file"
+
+
+def read_files(paths: List[str]) -> str:
+    """Read multiple files at once"""
+    return f"read_files(paths={paths})"
+
+
+read_files.tool_name = "read_files"
+
+
+def view_file(
+    path: str, from_line: Optional[int] = None, to_line: Optional[int] = None
+) -> str:
+    """Read specific lines or entire files"""
+    range_str = f"{from_line}-{to_line}" if from_line or to_line else "all"
+    return f"view_file(path='{path}', range='{range_str}')"
+
+
+view_file.tool_name = "view_file"
+
+
+def replace_text_in_file(
+    path: str, search_text: str, replacement_text: str, replace_all: bool = True
+) -> str:
+    """Find and replace text in files"""
+    return f"replace_text_in_file(path='{path}', search='{search_text[:20]}...', replace='{replacement_text[:20]}...')"
+
+
+replace_text_in_file.tool_name = "replace_text_in_file"
+
+
+def validate_file_syntax(path: str) -> str:
+    """Check file syntax (Python/Markdown)"""
+    return f"validate_file_syntax(path='{path}')"
+
+
+validate_file_syntax.tool_name = "validate_file_syntax"
+
+
+def create_directory(path: str) -> str:
+    """Create new directories"""
+    return f"create_directory(path='{path}')"
+
+
+create_directory.tool_name = "create_directory"
+
+
+def remove_directory(path: str, recursive: bool = False) -> str:
+    """Remove directories (recursive option)"""
+    return f"remove_directory(path='{path}', recursive={recursive})"
+
+
+remove_directory.tool_name = "remove_directory"
+
+
+def remove_file(path: str) -> str:
+    """Delete single files"""
+    return f"remove_file(path='{path}')"
+
+
+remove_file.tool_name = "remove_file"
+
+
+def copy_file(sources: str, target: str, overwrite: bool = False) -> str:
+    """Copy files or directories"""
+    return f"copy_file(sources='{sources}', target='{target}', overwrite={overwrite})"
+
+
+copy_file.tool_name = "copy_file"
+
+
+def move_file(src_path: str, dest_path: str, overwrite: bool = False) -> str:
+    """Move/rename files or directories"""
+    return f"move_file(src='{src_path}', dest='{dest_path}', overwrite={overwrite})"
+
+
+move_file.tool_name = "move_file"
+
+
+def find_files(
+    paths: str,
+    pattern: str,
+    max_depth: Optional[int] = None,
+    include_gitignored: bool = False,
+) -> str:
+    """Search for files by pattern (respects .gitignore)"""
+    return f"find_files(paths='{paths}', pattern='{pattern}', max_depth={max_depth})"
+
+
+find_files.tool_name = "find_files"
+
+
+# Plugin metadata
+__plugin_name__ = "core.filemanager"
+__plugin_description__ = "Core file and directory operations"
+__plugin_tools__ = [
+    create_file,
+    read_files,
+    view_file,
+    replace_text_in_file,
+    validate_file_syntax,
+    create_directory,
+    remove_directory,
+    remove_file,
+    copy_file,
+    move_file,
+    find_files,
+]

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

@@ -0,0 +1,87 @@
+import os
+from janito.tools.path_utils import expand_path
+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
+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
+
+
+@register_local_tool
+class CreateFileTool(ToolBase):
+    """
+    Create a new file with the given content.
+
+    Args:
+        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.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "✅ Successfully created the file at ..."
+
+    Note: Syntax validation is automatically performed after this operation.
+
+    Security: This tool includes loop protection to prevent excessive file creation operations.
+    Maximum 5 calls per 10 seconds for the same file path.
+    """
+
+    permissions = ToolPermissions(write=True)
+    tool_name = "create_file"
+
+    @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)
+        if os.path.exists(path) and not overwrite:
+            try:
+                with open(path, "r", encoding="utf-8", errors="replace") as f:
+                    existing_content = f.read()
+            except Exception as e:
+                existing_content = f"[Error reading file: {e}]"
+            return tr(
+                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
+                disp_path=disp_path,
+                existing_content=existing_content,
+            )
+        # Determine if we are overwriting an existing file
+        is_overwrite = os.path.exists(path) and overwrite
+        if is_overwrite:
+            # Overwrite branch: log only overwrite warning (no create message)
+            self.report_action(
+                tr("⚠️  Overwriting file '{disp_path}'", disp_path=disp_path),
+                ReportAction.CREATE,
+            )
+        dir_name = os.path.dirname(path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        if not is_overwrite:
+            # Create branch: log file creation message
+            self.report_action(
+                tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
+                ReportAction.CREATE,
+            )
+        with open(path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(content)
+        new_lines = content.count("\n") + 1 if content else 0
+        self.report_success(
+            tr("✅ {new_lines} lines", new_lines=new_lines), ReportAction.CREATE
+        )
+        # Perform syntax validation and append result
+        validation_result = validate_file_syntax(path)
+        if is_overwrite:
+            # Overwrite branch: return minimal overwrite info to user
+            return (
+                tr("✅ {new_lines} lines", new_lines=new_lines)
+                + f"\n{validation_result}"
+            )
+        else:
+            # Create branch: return detailed create success to user
+            return (
+                tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
+                + f"\n{validation_result}"
+            )