janito 2.31.0__py3-none-any.whl → 2.32.0__py3-none-any.whl

janito/cli/chat_mode/session.py

@@ -293,8 +293,6 @@ class ChatSession:
             print_token_message_summary(
                 self.console, self.msg_count, usage, elapsed=elapsed
             )
-            # Send terminal bell character to trigger TUI bell after printing token summary
-            print("\a", end="", flush=True)
             if final_event and hasattr(final_event, "metadata"):
                 exit_reason = (
                     final_event.metadata.get("exit_reason")

janito/cli/cli_commands/list_plugins.py

@@ -4,10 +4,15 @@ CLI command to list available and loaded plugins.
 
 import argparse
 from typing import List, Dict, Any
-from janito.plugins.discovery import list_available_plugins, discover_plugins
+from janito.plugins.discovery import list_available_plugins
 import os
 from janito.plugins.manager import PluginManager
 from janito.plugins.builtin import BuiltinPluginRegistry
+from janito.plugins.auto_loader_fixed import load_core_plugins, get_loaded_core_plugins, is_core_plugin
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
 
 
 def handle_list_plugins(args: argparse.Namespace) -> None:
@@ -22,19 +27,49 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
 
 
 def _list_available_plugins():
-    """List available plugins."""
+    """List available plugins using rich formatting."""
+    console = Console()
     available = list_available_plugins()
     builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
 
     if available or builtin_plugins:
-        print("Available plugins:")
-        _print_builtin_plugins(builtin_plugins)
-        _print_external_plugins(available, builtin_plugins)
+        # Create main table
+        table = Table(title="Available Plugins")
+        table.add_column("Plugin Name", style="cyan", no_wrap=True)
+        table.add_column("Type", style="magenta")
+        table.add_column("Status", style="green")
+
+        # Add builtin plugins
+        for plugin in builtin_plugins:
+            table.add_row(plugin, "Builtin", "📦")
+
+        # Add external plugins
+        other_plugins = [p for p in available if p not in builtin_plugins]
+        for plugin in other_plugins:
+            table.add_row(plugin, "External", "🔌")
+
+        console.print(table)
+
+        # Show core plugins
+        from janito.plugins.core_loader_fixed import get_core_plugins
+        core_plugins = get_core_plugins()
+        core_table = Table(title="Core Plugins (Enabled by Default)")
+        core_table.add_column("Plugin Name", style="cyan", no_wrap=True)
+        core_table.add_column("Status", style="yellow")
+
+        for plugin in core_plugins:
+            core_table.add_row(plugin, "✅ Available")
+
+        console.print(core_table)
     else:
-        print("No plugins found in search paths")
-        print("Search paths:")
-        print(f"  - {os.getcwd()}/plugins")
-        print(f"  - {os.path.expanduser('~')}/.janito/plugins")
+        console.print(Panel(
+            "No plugins found in search paths\n"
+            f"[dim]Search paths:[/dim]\n"
+            f"  • {os.getcwd()}/plugins\n"
+            f"  • {os.path.expanduser('~')}/.janito/plugins",
+            title="No Plugins Found",
+            style="yellow"
+        ))
 
 
 def _print_builtin_plugins(builtin_plugins):
@@ -55,18 +90,51 @@ def _print_external_plugins(available, builtin_plugins):
 
 
 def _list_plugin_resources():
-    """List all resources from loaded plugins."""
-    manager = PluginManager()
+    """List all resources from loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+    
+    console = Console()
+    manager = get_plugin_manager()
     all_resources = manager.list_all_resources()
 
     if all_resources:
-        print("Plugin Resources:")
         for plugin_name, resources in all_resources.items():
             metadata = manager.get_plugin_metadata(plugin_name)
-            print(f"\n{plugin_name} v{metadata.version if metadata else 'unknown'}:")
-            _print_resources_by_type(resources)
+            version = metadata.version if metadata else 'unknown'
+            
+            # Create panel for each plugin
+            panel_content = []
+            
+            tools = [r for r in resources if r["type"] == "tool"]
+            commands = [r for r in resources if r["type"] == "command"]
+            configs = [r for r in resources if r["type"] == "config"]
+
+            if tools:
+                panel_content.append("[bold blue]Tools:[/bold blue]")
+                for tool in tools:
+                    panel_content.append(f"  • {tool['name']}: {tool['description']}")
+
+            if commands:
+                panel_content.append("[bold green]Commands:[/bold green]")
+                for cmd in commands:
+                    panel_content.append(f"  • {cmd['name']}: {cmd['description']}")
+
+            if configs:
+                panel_content.append("[bold yellow]Configuration:[/bold yellow]")
+                for config in configs:
+                    panel_content.append(f"  • {config['name']}: {config['description']}")
+
+            console.print(Panel(
+                "\n".join(panel_content),
+                title=f"{plugin_name} v{version}",
+                style="cyan"
+            ))
     else:
-        print("No plugins loaded")
+        console.print(Panel(
+            "No plugins are currently loaded.",
+            title="No Plugin Resources",
+            style="yellow"
+        ))
 
 
 def _print_resources_by_type(resources):
@@ -92,16 +160,59 @@ def _print_resources_by_type(resources):
 
 
 def _list_loaded_plugins():
-    """List loaded plugins."""
-    manager = PluginManager()
+    """List loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+    
+    console = Console()
+    manager = get_plugin_manager()
     loaded = manager.list_plugins()
 
     if loaded:
-        print("Loaded plugins:")
+        # Create main table
+        table = Table(title="Loaded Plugins")
+        table.add_column("Plugin Name", style="cyan", no_wrap=True)
+        table.add_column("Version", style="magenta")
+        table.add_column("Description", style="green", max_width=50)
+        table.add_column("Type", style="yellow")
+
+        core_plugins = []
+        other_plugins = []
+        
         for plugin_name in loaded:
-            _print_plugin_details(manager, plugin_name)
+            if is_core_plugin(plugin_name):
+                core_plugins.append(plugin_name)
+            else:
+                other_plugins.append(plugin_name)
+        
+        # Add core plugins
+        for plugin_name in core_plugins:
+            metadata = manager.get_plugin_metadata(plugin_name)
+            if metadata:
+                table.add_row(
+                    metadata.name,
+                    metadata.version,
+                    metadata.description,
+                    "🔵 Core"
+                )
+        
+        # Add other plugins
+        for plugin_name in other_plugins:
+            metadata = manager.get_plugin_metadata(plugin_name)
+            if metadata:
+                table.add_row(
+                    metadata.name,
+                    metadata.version,
+                    metadata.description,
+                    "🔶 External"
+                )
+
+        console.print(table)
     else:
-        print("No plugins loaded")
+        console.print(Panel(
+            "No plugins are currently loaded.",
+            title="No Plugins Loaded",
+            style="yellow"
+        ))
 
 
 def _print_plugin_details(manager, plugin_name):

janito/cli/prompt_core.py

@@ -216,8 +216,6 @@ class PromptHandler:
             if on_event and final_event is not None:
                 on_event(final_event)
                 global_event_bus.publish(final_event)
-                # Terminal bell moved to token summary printing in session.py and handler.py
-                pass  # print('\a', end='', flush=True)
         except KeyboardInterrupt:
             # Capture user interrupt / cancellation
             self.console.print("[red]Interrupted by the user.[/red]")

janito/cli/rich_terminal_reporter.py

@@ -161,7 +161,7 @@ class RichTerminalReporter(EventHandlerBase):
             self.console.print(msg)
             self.console.file.flush()
         elif subtype == ReportSubtype.STDOUT:
-            self.console.print(Text(msg, style="on dark_green"))
+            self.console.print(msg)
             self.console.file.flush()
         elif subtype == ReportSubtype.STDERR:
             self.console.print(Text(msg, style="on red"))

janito/cli/single_shot_mode/handler.py

@@ -125,8 +125,6 @@ class PromptHandler:
             print_token_message_summary(
                 shared_console, msg_count=1, usage=usage, elapsed=elapsed
             )
-            # Send terminal bell character to trigger TUI bell after printing token summary
-            print("\a", end="", flush=True)
         self._cleanup_driver_and_console()
 
     def _cleanup_driver_and_console(self):

janito/plugins/auto_loader.py

@@ -0,0 +1,91 @@
+"""
+Auto-loader for core plugins.
+
+This module automatically loads core plugins when the plugin system is initialized.
+"""
+
+import os
+from pathlib import Path
+from typing import List
+from janito.plugins.manager import PluginManager
+from janito.plugins.discovery import list_available_plugins
+
+# List of core plugins that should be enabled by default
+CORE_PLUGINS = [
+    "core.filemanager",
+    "core.codeanalyzer", 
+    "core.system",
+    "core.imagedisplay",
+    "dev.pythondev",
+    "dev.visualization",
+    "ui.userinterface",
+    "web.webtools",
+]
+
+
+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()
+    
+    # Ensure plugins directory is in search path
+    plugins_dir = Path.cwd() / "plugins"
+    if plugins_dir.exists():
+        pm.add_plugin_path(str(plugins_dir))
+    
+    loaded = []
+    
+    # Load core plugins
+    for plugin_name in CORE_PLUGINS:
+        try:
+            if pm.load_plugin(plugin_name):
+                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
+    """
+    pm = PluginManager()
+    loaded = pm.list_plugins()
+    return [p for p in loaded if p in CORE_PLUGINS]
+
+
+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
+    """
+    return plugin_name in CORE_PLUGINS
+
+
+# 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

janito/plugins/auto_loader_fixed.py

@@ -0,0 +1,90 @@
+"""
+Fixed auto-loader for core plugins.
+
+This module provides a working implementation to load core plugins
+without the complex discovery mechanism.
+"""
+
+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
+
+# List of core plugins that should be enabled by default
+CORE_PLUGINS = [
+    "core.filemanager",
+    "core.codeanalyzer", 
+    "core.system",
+    "core.imagedisplay",
+    "dev.pythondev",
+    "dev.visualization",
+    "ui.userinterface",
+    "web.webtools",
+]
+
+
+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:
+            plugin = load_core_plugin(plugin_name)
+            if plugin:
+                # Manually register the plugin
+                pm.plugins[plugin_name] = plugin
+                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
+    """
+    pm = PluginManager()
+    loaded = pm.list_plugins()
+    return [p for p in loaded if p in CORE_PLUGINS]
+
+
+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
+    """
+    return plugin_name in CORE_PLUGINS
+
+
+# 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

janito/plugins/core_adapter.py

@@ -0,0 +1,53 @@
+"""
+Core plugin adapter for legacy plugin system.
+
+This module provides proper Plugin class implementations for core plugins
+that use the function-based approach instead of class-based.
+"""
+
+from janito.plugins.base import Plugin, PluginMetadata
+from typing import List, Type
+from janito.tools.tool_base import ToolBase
+from janito.tools.function_adapter import create_function_tool
+
+
+class CorePluginAdapter(Plugin):
+    """Adapter for core plugins using function-based tools."""
+    
+    def __init__(self, plugin_name: str, description: str, tools_module):
+        super().__init__()
+        self._plugin_name = plugin_name
+        self._description = description
+        self._tools_module = tools_module
+        self._tool_classes = []
+        
+        # Set the metadata attribute that Plugin expects
+        self.metadata = self.get_metadata()
+        
+    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 the plugin by creating tool classes."""
+        # Get tools from the module
+        tools = getattr(self._tools_module, "__plugin_tools__", [])
+        
+        self._tool_classes = []
+        for tool_func in tools:
+            if callable(tool_func):
+                tool_class = create_function_tool(tool_func)
+                self._tool_classes.append(tool_class)
+
+
+def create_core_plugin(plugin_name: str, description: str, tools_module) -> CorePluginAdapter:
+    """Create a core plugin adapter."""
+    return CorePluginAdapter(plugin_name, description, tools_module)

janito/plugins/core_loader.py

@@ -0,0 +1,120 @@
+"""
+Core plugin loader that properly handles function-based plugins.
+
+This module provides a simplified approach to load core plugins
+without the complex discovery mechanism.
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+from typing import Optional
+
+from janito.plugins.base import Plugin, PluginMetadata
+from janito.tools.function_adapter import create_function_tool
+from janito.tools.tool_base import ToolBase
+
+
+class CorePlugin(Plugin):
+    """Simple core plugin implementation."""
+    
+    def __init__(self, name: str, description: str, tools: list):
+        super().__init__()
+        self._plugin_name = name
+        self._description = description
+        self._tools = tools
+        self._tool_classes = []
+        
+    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:
+        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
+        
+        # Build path to plugin
+        plugin_path = Path("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
+            
+        # Create plugin
+        plugin = CorePlugin(name, description, 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",
+    ]
+    
+    available = []
+    for plugin_name in core_plugins:
+        plugin = load_core_plugin(plugin_name)
+        if plugin:
+            available.append(plugin_name)
+    
+    return available