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

janito/cli/chat_mode/bindings.py

@@ -35,30 +35,4 @@ class KeyBindingsFactory:
             buf.text = "Do It"
             buf.validate_and_handle()
 
-        @bindings.add("enter", eager=True)
-        def _(event):
-            """Handle Enter key to interrupt current request."""
-            import threading
-            
-            # Get the current session context
-            from prompt_toolkit.application import get_app
-            app = get_app()
-            
-            # Use global cancellation manager for robust cancellation
-            from janito.llm.cancellation_manager import get_cancellation_manager
-            cancel_manager = get_cancellation_manager()
-            
-            cancelled = cancel_manager.cancel_current_request()
-            if cancelled:
-                # Provide user feedback
-                from rich.console import Console
-                console = Console()
-                console.print("[red]Request cancelled by Enter key[/red]")
-                
-                # Prevent the Enter key from being processed as input
-                event.app.output.flush()
-                return
-            
-            # If no active request to cancel, let normal Enter behavior proceed
-
         return bindings

janito/cli/chat_mode/session.py

@@ -283,13 +283,7 @@ class ChatSession:
                 )
             )
 
-            try:
-                self._prompt_handler.run_prompt(cmd_input)
-            finally:
-                # Ensure cancellation manager is cleared
-                cancel_manager = get_cancellation_manager()
-                cancel_manager.clear_current_request()
-                
+            self._prompt_handler.run_prompt(cmd_input)
             end_time = time.time()
             elapsed = end_time - start_time
             self.msg_count += 1

janito/cli/cli_commands/list_plugins.py

@@ -8,11 +8,8 @@ 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 janito.plugins.manager import PluginManager
+from janito.plugins.core_loader import get_core_plugins
 from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
@@ -55,7 +52,7 @@ def _list_available_plugins():
         console.print(table)
 
         # Show core plugins
-        from janito.plugin_system.core_loader_fixed import get_core_plugins
+        from janito.plugins.core_loader import get_core_plugins
 
         core_plugins = get_core_plugins()
         core_table = Table(title="Core Plugins (Enabled by Default)")
@@ -98,10 +95,8 @@ def _print_external_plugins(available, builtin_plugins):
 
 def _list_plugin_resources():
     """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()
+    manager = PluginManager()
     all_resources = manager.list_all_resources()
 
     if all_resources:
@@ -174,10 +169,8 @@ def _print_resources_by_type(resources):
 
 def _list_loaded_plugins():
     """List loaded plugins using rich formatting."""
-    from janito.plugins.auto_loader_fixed import get_plugin_manager
-
     console = Console()
-    manager = get_plugin_manager()
+    manager = PluginManager()
     loaded = manager.list_plugins()
 
     if loaded:
@@ -192,7 +185,9 @@ def _list_loaded_plugins():
         other_plugins = []
 
         for plugin_name in loaded:
-            if is_core_plugin(plugin_name):
+            from janito.plugins.core_loader import get_core_plugins
+            core_plugin_list = get_core_plugins()
+            if plugin_name in core_plugin_list:
                 core_plugins.append(plugin_name)
             else:
                 other_plugins.append(plugin_name)

janito/cli/prompt_core.py

@@ -207,25 +207,15 @@ class PromptHandler:
         """
         try:
             self._print_verbose_debug("Calling agent.chat()...")
-            
-            # Use global cancellation manager
-            from janito.llm.cancellation_manager import get_cancellation_manager
-            cancel_manager = get_cancellation_manager()
-            driver_cancel_event = cancel_manager.start_new_request()
-            
-            try:
-                final_event = self.agent.chat(prompt=user_prompt)
-                if hasattr(self.agent, "set_latest_event"):
-                    self.agent.set_latest_event(final_event)
-                self.agent.last_event = final_event
-                self._print_verbose_debug(f"agent.chat() returned: {final_event}")
-                self._print_verbose_final_event(final_event)
-                if on_event and final_event is not None:
-                    on_event(final_event)
-                    global_event_bus.publish(final_event)
-            finally:
-                cancel_manager.clear_current_request()
-                
+            final_event = self.agent.chat(prompt=user_prompt)
+            if hasattr(self.agent, "set_latest_event"):
+                self.agent.set_latest_event(final_event)
+            self.agent.last_event = final_event
+            self._print_verbose_debug(f"agent.chat() returned: {final_event}")
+            self._print_verbose_final_event(final_event)
+            if on_event and final_event is not None:
+                on_event(final_event)
+                global_event_bus.publish(final_event)
         except KeyboardInterrupt:
             # Capture user interrupt / cancellation
             self.console.print("[red]Interrupted by the user.[/red]")

janito/llm/agent.py

@@ -318,36 +318,23 @@ class LLMAgent:
         loop_count = 1
         import threading
 
-        # Use global cancellation manager
-        from janito.llm.cancellation_manager import get_cancellation_manager
-        cancel_manager = get_cancellation_manager()
-        driver_cancel_event = cancel_manager.start_new_request()
-        
-        # Store cancellation event on agent for external access
-        self.cancel_event = driver_cancel_event
-        
-        try:
-            while True:
-                self._print_verbose_chat_loop(loop_count)
-                driver_input = self._prepare_driver_input(config, cancel_event=driver_cancel_event)
-                self.input_queue.put(driver_input)
-                try:
-                    result, added_tool_results = self._process_next_response()
-                except KeyboardInterrupt:
-                    cancel_manager.cancel_current_request()
-                    raise
-                if getattr(self, "verbose_agent", False):
-                    print(
-                        f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}"
-                    )
-                if self._should_exit_chat_loop(result, added_tool_results):
-                    return result
-                loop_count += 1
-        finally:
-            cancel_manager.clear_current_request()
-            # Clean up cancellation event
-            if hasattr(self, 'cancel_event'):
-                delattr(self, 'cancel_event')
+        cancel_event = threading.Event()
+        while True:
+            self._print_verbose_chat_loop(loop_count)
+            driver_input = self._prepare_driver_input(config, cancel_event=cancel_event)
+            self.input_queue.put(driver_input)
+            try:
+                result, added_tool_results = self._process_next_response()
+            except KeyboardInterrupt:
+                cancel_event.set()
+                raise
+            if getattr(self, "verbose_agent", False):
+                print(
+                    f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}"
+                )
+            if self._should_exit_chat_loop(result, added_tool_results):
+                return result
+            loop_count += 1
 
     def _clear_driver_queues(self):
         if hasattr(self, "driver") and self.driver:

janito/llm/driver.py

@@ -252,10 +252,3 @@ class LLMDriver(ABC):
     def _get_message_from_result(self, result):
         """Extract the message object from the provider result. Subclasses must implement this."""
         raise NotImplementedError("Subclasses must implement _get_message_from_result.")
-
-    def cancel_current_request(self):
-        """Cancel the current request being processed."""
-        # Use global cancellation manager to cancel the current request
-        from janito.llm.cancellation_manager import get_cancellation_manager
-        cancel_manager = get_cancellation_manager()
-        cancel_manager.cancel_current_request()

janito/plugins/__init__.py

@@ -1,36 +1,28 @@
 """
-Plugin System for Development Tools
+Unified Plugin System for Janito
 
-This package organizes all available tools into logical plugin groups
-for easier discovery and usage.
+This package provides a clean, unified plugin architecture for janito.
 """
 
 __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)
+# Import core components
+from .base import Plugin, PluginMetadata, PluginResource
+from .manager import PluginManager
+from .discovery import discover_plugins, list_available_plugins
+from .config import load_plugins_config, save_plugins_config
+from .builtin import BuiltinPluginRegistry, load_builtin_plugin
+
+__all__ = [
+    "Plugin",
+    "PluginMetadata", 
+    "PluginResource",
+    "PluginManager",
+    "discover_plugins",
+    "list_available_plugins",
+    "load_plugins_config",
+    "save_plugins_config",
+    "BuiltinPluginRegistry",
+    "load_builtin_plugin",
+]

janito/plugins/__main__.py

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

@@ -0,0 +1,57 @@
+"""
+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/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.plugin_system.base import Plugin
+from .base import Plugin
 
 
 class BuiltinPluginRegistry:

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

@@ -13,12 +13,36 @@ from janito.i18n import tr
 class CopyFileTool(ToolBase):
     """
     Copy one or more files to a target directory, or copy a single file to a new file.
-    Args:
+    
+    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.
     """

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

@@ -12,8 +12,35 @@ from janito.tools.path_utils import expand_path
 class CreateDirectoryTool(ToolBase):
     """
     Create a new directory at the specified path.
-    Args:
+    
+    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 ..."

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

@@ -16,10 +16,34 @@ class CreateFileTool(ToolBase):
     """
     Create a new file with the given content.
 
-    Args:
+    Parameters:
         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.
+        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:
             - "✅ Successfully created the file at ..."

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

@@ -15,6 +15,7 @@ class DeleteTextInFileTool(ToolBase):
         path (str): Path to the file to modify.
         start_marker (str): The starting delimiter string.
         end_marker (str): The ending delimiter string.
+        backup (bool, optional): Deprecated. No backups are created anymore and this flag is ignored. Defaults to False.
 
     Returns:
         str: Status message indicating the result.

janito/plugins/core/imagedisplay/plugin.py

@@ -4,7 +4,7 @@ Image Display Plugin implementation.
 
 from typing import Dict, Any, List, Type
 
-from janito.plugin_system.base import Plugin, PluginMetadata
+from ...base import Plugin, PluginMetadata
 from janito.tools.tool_base import ToolBase
 from .tools.show_image import ShowImageTool
 from .tools.show_image_grid import ShowImageGridTool