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

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)

janito/plugins_backup_20250825_070018/builtin.py

@@ -0,0 +1,102 @@
+"""
+Builtin plugin system for janito-packaged plugins.
+
+This module provides the infrastructure for plugins that are bundled
+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
+
+
+class BuiltinPluginRegistry:
+    """Registry for builtin plugins that come packaged with janito."""
+
+    _plugins: Dict[str, Type[Plugin]] = {}
+
+    @classmethod
+    def register(cls, name: str, plugin_class: Type[Plugin]) -> None:
+        """Register a builtin plugin."""
+        cls._plugins[name] = plugin_class
+
+    @classmethod
+    def get_plugin_class(cls, name: str) -> Optional[Type[Plugin]]:
+        """Get the plugin class for a builtin plugin."""
+        return cls._plugins.get(name)
+
+    @classmethod
+    def list_builtin_plugins(cls) -> List[str]:
+        """List all registered builtin plugins."""
+        return list(cls._plugins.keys())
+
+    @classmethod
+    def is_builtin(cls, name: str) -> bool:
+        """Check if a plugin is builtin."""
+        return name in cls._plugins
+
+
+def register_builtin_plugin(name: str):
+    """Decorator to register a plugin as builtin."""
+
+    def decorator(plugin_class: Type[Plugin]) -> Type[Plugin]:
+        BuiltinPluginRegistry.register(name, plugin_class)
+        return plugin_class
+
+    return decorator
+
+
+def load_builtin_plugin(name: str) -> Optional[Plugin]:
+    """Load a builtin plugin by name."""
+    plugin_class = BuiltinPluginRegistry.get_plugin_class(name)
+    if plugin_class:
+        return plugin_class()
+    return None
+
+
+# Auto-register janito-coder plugins as builtin
+try:
+    from janito_coder.plugins import (
+        GitAnalyzerPlugin,
+        CodeNavigatorPlugin,
+        DependencyAnalyzerPlugin,
+        CodeFormatterPlugin,
+        TestRunnerPlugin,
+        LinterPlugin,
+        DebuggerPlugin,
+        PerformanceProfilerPlugin,
+        SecurityScannerPlugin,
+        DocumentationGeneratorPlugin,
+    )
+
+    # Register all janito-coder plugins as builtin
+    BuiltinPluginRegistry.register("git_analyzer", GitAnalyzerPlugin)
+    BuiltinPluginRegistry.register("code_navigator", CodeNavigatorPlugin)
+    BuiltinPluginRegistry.register("dependency_analyzer", DependencyAnalyzerPlugin)
+    BuiltinPluginRegistry.register("code_formatter", CodeFormatterPlugin)
+    BuiltinPluginRegistry.register("test_runner", TestRunnerPlugin)
+    BuiltinPluginRegistry.register("linter", LinterPlugin)
+    BuiltinPluginRegistry.register("debugger", DebuggerPlugin)
+    BuiltinPluginRegistry.register("performance_profiler", PerformanceProfilerPlugin)
+    BuiltinPluginRegistry.register("security_scanner", SecurityScannerPlugin)
+    BuiltinPluginRegistry.register(
+        "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_backup_20250825_070018/config.py

@@ -0,0 +1,84 @@
+"""
+Configuration management for plugins using user directory.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+
+def get_user_config_dir() -> Path:
+    """Get the user configuration directory."""
+    return Path.home() / ".janito"
+
+
+def get_plugins_config_path() -> Path:
+    """Get the path to the plugins configuration file."""
+    return get_user_config_dir() / "plugins.json"
+
+
+def load_plugins_config() -> Dict[str, Any]:
+    """
+    Load plugins configuration from user directory.
+
+    Returns:
+        Dict containing plugins configuration
+    """
+    config_path = get_plugins_config_path()
+
+    if not config_path.exists():
+        # Create default config if it doesn't exist
+        default_config = {
+            "plugins": {
+                "paths": [str(Path.home() / ".janito" / "plugins"), "./plugins"],
+                "load": {},
+            }
+        }
+
+        # Ensure directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Save default config
+        with open(config_path, "w") as f:
+            json.dump(default_config, f, indent=2)
+
+        return default_config
+
+    try:
+        with open(config_path, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError) as e:
+        print(f"Warning: Failed to load plugins config from {config_path}: {e}")
+        return {"plugins": {"paths": [], "load": {}}}
+
+
+def save_plugins_config(config: Dict[str, Any]) -> bool:
+    """
+    Save plugins configuration to user directory.
+
+    Args:
+        config: Configuration dict to save
+
+    Returns:
+        True if saved successfully
+    """
+    config_path = get_plugins_config_path()
+
+    try:
+        # Ensure directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+        return True
+    except IOError as e:
+        print(f"Error: Failed to save plugins config to {config_path}: {e}")
+        return False
+
+
+def get_user_plugins_dir() -> Path:
+    """Get the user plugins directory."""
+    plugins_dir = get_user_config_dir() / "plugins"
+    plugins_dir.mkdir(parents=True, exist_ok=True)
+    return plugins_dir

janito/plugins_backup_20250825_070018/core/__init__.py

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

janito/plugins_backup_20250825_070018/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_backup_20250825_070018/core/codeanalyzer/tools/get_file_outline/__init__.py

@@ -0,0 +1 @@
+# Outline tools and parsers package

janito/plugins_backup_20250825_070018/core/codeanalyzer/tools/get_file_outline/core.py

@@ -0,0 +1,122 @@
+from janito.tools.adapters.local.adapter import register_local_tool
+from .python_outline import parse_python_outline
+from .markdown_outline import parse_markdown_outline
+from janito.formatting import OutlineFormatter
+from .java_outline import parse_java_outline
+import os
+from janito.tools.path_utils import expand_path
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.tool_utils import display_path, pluralize
+from janito.i18n import tr
+
+from janito.tools.adapters.local.adapter import register_local_tool as register_tool
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_tool
+class GetFileOutlineTool(ToolBase):
+    """
+    Get an outline of a file's structure. Supports Python and Markdown files.
+
+    Args:
+        path (str): Path to the file to outline.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "get_file_outline"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str) -> str:
+        try:
+            path = expand_path(path)
+            self.report_action(
+                tr(
+                    "📄 Outline file '{disp_path}' ...",
+                    disp_path=display_path(path),
+                ),
+                ReportAction.READ,
+            )
+            ext = os.path.splitext(path)[1].lower()
+            with open(path, "r", encoding="utf-8", errors="replace") as f:
+                lines = f.readlines()
+            return self._outline_by_extension(ext, lines)
+        except Exception as e:
+            self.report_error(
+                tr("❌ Error reading file: {error}", error=e),
+                ReportAction.READ,
+            )
+            return tr("Error reading file: {error}", error=e)
+
+    def _outline_by_extension(self, ext, lines):
+        if ext == ".py":
+            outline_items = parse_python_outline(lines)
+            outline_type = "python"
+            table = OutlineFormatter.format_outline_table(outline_items)
+            self.report_success(
+                tr(
+                    "✅ Outlined {count} {item_word}",
+                    count=len(outline_items),
+                    item_word=pluralize("item", len(outline_items)),
+                ),
+                ReportAction.READ,
+            )
+            return (
+                tr(
+                    "Outline: {count} items ({outline_type})\n",
+                    count=len(outline_items),
+                    outline_type=outline_type,
+                )
+                + table
+            )
+        elif ext == ".md":
+            outline_items = parse_markdown_outline(lines)
+            outline_type = "markdown"
+            table = OutlineFormatter.format_markdown_outline_table(outline_items)
+            self.report_success(
+                tr(
+                    "✅ Outlined {count} {item_word}",
+                    count=len(outline_items),
+                    item_word=pluralize("item", len(outline_items)),
+                ),
+                ReportAction.READ,
+            )
+            return (
+                tr(
+                    "Outline: {count} items ({outline_type})\n",
+                    count=len(outline_items),
+                    outline_type=outline_type,
+                )
+                + table
+            )
+        elif ext == ".java":
+            outline_items = parse_java_outline(lines)
+            outline_type = "java"
+            table = OutlineFormatter.format_outline_table(outline_items)
+            self.report_success(
+                tr(
+                    "✅ Outlined {count} {item_word}",
+                    count=len(outline_items),
+                    item_word=pluralize("item", len(outline_items)),
+                ),
+                ReportAction.READ,
+            )
+            return (
+                tr(
+                    "Outline: {count} items ({outline_type})\n",
+                    count=len(outline_items),
+                    outline_type=outline_type,
+                )
+                + table
+            )
+        else:
+            outline_type = "default"
+            self.report_success(
+                tr("✅ Outlined {count} items", count=len(lines)),
+                ReportAction.READ,
+            )
+            return tr(
+                "Outline: {count} lines ({outline_type})\nFile has {count} lines.",
+                count=len(lines),
+                outline_type=outline_type,
+            )

janito/plugins_backup_20250825_070018/core/codeanalyzer/tools/search_text/__init__.py

@@ -0,0 +1 @@
+from .core import SearchTextTool