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

janito/plugin_system_backup_20250825_070018/core_loader_fixed.py

@@ -1,149 +0,0 @@
-"""
-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/__main__.py

@@ -1,85 +0,0 @@
-#!/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/core/__init__.py

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

janito/plugins/core/codeanalyzer/__init__.py

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

@@ -1,124 +0,0 @@
-"""
-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/copy_file.py

@@ -1,111 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-import shutil
-from typing import List, Union
-from janito.tools.adapters.local.adapter import register_local_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_local_tool
-class CopyFileTool(ToolBase):
-    """
-    Copy one or more files to a target directory, or copy a single file to a new file.
-    
-    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.
-    """
-
-    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/core/filemanager/tools/create_directory.py

@@ -1,97 +0,0 @@
-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
-import os
-from janito.tools.path_utils import expand_path
-
-
-@register_local_tool
-class CreateDirectoryTool(ToolBase):
-    """
-    Create a new directory at the specified path.
-    
-    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 ..."
-            - "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)