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

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/base.py

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

@@ -1,144 +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
-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_backup_20250825_070018/__init__.py

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

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

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

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

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

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

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

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

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