janito 3.5.1__py3-none-any.whl → 3.7.0__py3-none-any.whl

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

janito/plugins/core_loader_fixed.py

@@ -0,0 +1,125 @@
+"""
+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.plugins.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 plugins.core.imagedisplay.plugin import ImageDisplayPlugin
+                return ImageDisplayPlugin()
+            except ImportError:
+                # If import fails, return None - don't return True
+                return None
+        
+        # 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",
+    ]
+    
+    # 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__)
 
@@ -75,13 +75,13 @@ def discover_plugins(
         parts = plugin_name.split(".")
         if len(parts) == 2:
             package_name, submodule_name = parts
-
+            
             # Handle core plugins with dedicated loader
             if plugin_name.startswith(("core.", "dev.", "ui.", "web.")):
                 plugin = load_core_plugin(plugin_name)
                 if plugin:
                     return plugin
-
+                    
             for base_path in all_paths:
                 package_path = base_path / package_name / submodule_name / "__init__.py"
                 if package_path.exists():
@@ -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 janito.plugins.base import PluginMetadata
 
             # Create a dynamic plugin class
             class PackagePlugin(Plugin):

janito/plugins/discovery_core.py

@@ -17,11 +17,11 @@ from .core_adapter import CorePluginAdapter
 def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
     """
     Load a core plugin from a package directory.
-
+    
     Args:
         package_path: Path to the __init__.py file
         plugin_name: Full plugin name (e.g., core.filemanager)
-
+        
     Returns:
         Plugin instance if loaded successfully
     """
@@ -30,25 +30,20 @@ def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
         spec = importlib.util.spec_from_file_location(plugin_name, package_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 metadata
         plugin_name_attr = getattr(module, "__plugin_name__", plugin_name)
-        description = getattr(
-            module, "__plugin_description__", f"Core plugin: {plugin_name}"
-        )
-
+        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
+        
         # Create and return the core plugin adapter
         plugin = CorePluginAdapter(plugin_name_attr, description, module)
         plugin.initialize()  # Initialize to set up tools
         return plugin
-
+        
     except Exception as e:
         import logging
-
-        logging.getLogger(__name__).error(
-            f"Failed to load core plugin {plugin_name}: {e}"
-        )
-        return None
+        logging.getLogger(__name__).error(f"Failed to load core plugin {plugin_name}: {e}")
+        return None

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/providers/__init__.py

@@ -10,4 +10,3 @@ import janito.providers.zai.provider
 import janito.providers.cerebras.provider
 import janito.providers.mistral.provider
 import janito.providers.ibm.provider
-import janito.providers.together.provider

janito/providers/moonshot/model_info.py

@@ -1,6 +1,17 @@
 from janito.llm.model import LLMModelInfo
 
 MOONSHOT_MODEL_SPECS = {
+    "kimi-k2-0905-preview": LLMModelInfo(
+        name="kimi-k2-0905-preview",
+        context=256000,
+        max_input=200000,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="moonshot",
+        driver="OpenAIModelDriver",
+    ),
     "kimi-k2-0711-preview": LLMModelInfo(
         name="kimi-k2-0711-preview",
         context=128000,

janito/tools/__init__.py

@@ -1,6 +1,6 @@
-from janito.tools.adapters.local import LocalToolsAdapter
-from janito.tools.adapters.local.adapter import (
-    LocalToolsAdapter as _internal_local_tools_adapter,
+from janito.tools.adapters.local import (
+    local_tools_adapter as _internal_local_tools_adapter,
+    LocalToolsAdapter,
 )
 
 
@@ -11,10 +11,8 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     if workdir is not None and not os.path.exists(workdir):
         os.makedirs(workdir, exist_ok=True)
     # Permissions are now managed globally; ignore allowed_permissions argument except for backward compatibility
-    # Create and initialize adapter
-    from janito.tools.initialize import initialize_tools
-
-    registry = initialize_tools(LocalToolsAdapter(workdir=workdir))
+    # Reuse the singleton adapter defined in janito.tools.adapters.local to maintain tool registrations
+    registry = _internal_local_tools_adapter
     # Change workdir if requested
     if workdir is not None:
         try:
@@ -29,32 +27,10 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     return registry
 
 
-# Initialize the global adapter - defer import to avoid circular dependencies
-local_tools_adapter = None
-
-
-def get_local_tools_adapter(workdir=None, allowed_permissions=None):
-    """Get the global tools adapter, initializing on first use."""
-    global local_tools_adapter
-    if local_tools_adapter is None:
-        from janito.tools.initialize import initialize_tools
-
-        adapter = LocalToolsAdapter(workdir=workdir)
-        local_tools_adapter = initialize_tools(adapter)
-
-    # Handle workdir if provided
-    if workdir is not None and local_tools_adapter is not None:
-        import os
-
-        if not os.path.exists(workdir):
-            os.makedirs(workdir, exist_ok=True)
-        os.chdir(workdir)
-        local_tools_adapter.workdir = workdir
-
-    return local_tools_adapter
-
+local_tools_adapter = _internal_local_tools_adapter
 
 __all__ = [
     "LocalToolsAdapter",
     "get_local_tools_adapter",
+    "local_tools_adapter",
 ]

janito/tools/adapters/__init__.py

@@ -1,6 +1 @@
-"""
-Tools providers package: for plug-and-play tool collections, integrations, and adapters.
-
-This package contains the core adapter infrastructure for managing tools,
-while the actual tool implementations have been moved to the plugins system.
-"""
+# Tools providers package: for plug-and-play tool collections, integrations, and adapters.

janito/tools/adapters/local/__init__.py

@@ -1,10 +1,73 @@
-"""
-Local tools adapter for janito.
+from .adapter import LocalToolsAdapter
 
-This package provides the LocalToolsAdapter class which manages tool registration
-and execution for local, in-process tools.
-"""
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .read_files import ReadFilesTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .open_html_in_browser import OpenHtmlInBrowserTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+from .read_chart import ReadChartTool
+from .show_image import ShowImageTool
+from .show_image_grid import ShowImageGridTool
 
-from .adapter import LocalToolsAdapter
+from janito.tools.tool_base import ToolPermissions
+import os
+from janito.tools.permissions import get_global_allowed_permissions
+
+# Singleton tools adapter with all standard tools registered
+local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+
+
+def get_local_tools_adapter(workdir=None):
+    return LocalToolsAdapter(workdir=workdir or os.getcwd())
+
+
+# Register tools
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    ReadFilesTool,
+    MoveFileTool,
+    OpenUrlTool,
+    OpenHtmlInBrowserTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+    ReadChartTool,
+    ShowImageTool,
+    ShowImageGridTool,
+]:
+    local_tools_adapter.register_tool(tool_class)
 
-__all__ = ["LocalToolsAdapter"]
+# DEBUG: Print registered tools at startup

janito/{plugins/tools → tools/adapters/local}/ask_user.py

@@ -1,5 +1,5 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.plugins.tools.decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 from rich import print as rich_print
@@ -16,8 +16,8 @@ from prompt_toolkit.styles import Style
 toolbar_style = Style.from_dict({"bottom-toolbar": "fg:yellow bg:darkred"})
 
 
-@register_core_tool
-class AskUser(ToolBase):
+@register_local_tool
+class AskUserTool(ToolBase):
     """
     Prompts the user for clarification or input with a question.
 

janito/{plugins/tools → tools/adapters/local}/create_file.py

@@ -1,6 +1,6 @@
 import os
 from janito.tools.path_utils import expand_path
-from janito.plugins.tools.decorators import register_core_tool
+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
@@ -8,11 +8,11 @@ from janito.report_events import ReportAction
 from janito.i18n import tr
 from janito.tools.loop_protection_decorator import protect_against_loops
 
-from janito.plugins.tools.validate_file_syntax.core import validate_file_syntax
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
 
 
-@register_core_tool
-class CreateFile(ToolBase):
+@register_local_tool
+class CreateFileTool(ToolBase):
     """
     Create a new file with specified content at the given path.
 
@@ -55,7 +55,7 @@ class CreateFile(ToolBase):
         or file exists (when overwrite=False).
 
     Security Features:
-        - Loop protection: Prevents repeated create calls for the same file path within a short window (1 allowed per 10 seconds)
+        - Loop protection: Maximum 5 calls per 10 seconds for the same file path
         - Path traversal prevention: Validates and sanitizes file paths
         - Permission checking: Respects file system permissions
         - Atomic writes: Prevents partial file creation on errors
@@ -84,7 +84,7 @@ class CreateFile(ToolBase):
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 
-    @protect_against_loops(max_calls=1, time_window=3600.0, key_field="path")
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
     def run(self, path: str, content: str, overwrite: bool = False) -> str:
         path = expand_path(path)
         disp_path = display_path(path)

janito/{plugins/tools → tools/adapters/local}/fetch_url.py

@@ -5,7 +5,7 @@ import json
 from pathlib import Path
 from bs4 import BeautifulSoup
 from typing import Dict, Any, Optional
-from janito.plugins.tools.decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
@@ -13,8 +13,8 @@ from janito.tools.tool_utils import pluralize
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 
-@register_core_tool
-class FetchUrl(ToolBase):
+@register_local_tool
+class FetchUrlTool(ToolBase):
     """
     Fetch the content of a web page and extract its text.
 

janito/{plugins/tools → tools/adapters/local}/python_code_run.py

@@ -5,12 +5,12 @@ import tempfile
 import threading
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from janito.plugins.tools.decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 
 
-@register_core_tool
-class PythonCodeRun(ToolBase):
+@register_local_tool
+class PythonCodeRunTool(ToolBase):
     """
     Tool to execute Python code by passing it to the interpreter via standard input (stdin).
 
@@ -93,9 +93,6 @@ class PythonCodeRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
-                # Check for cancellation
-                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
-                    break
                 file_obj.write(line)
                 file_obj.flush()
                 report_func(line.rstrip("\r\n"))
@@ -104,11 +101,6 @@ class PythonCodeRun(ToolBase):
                 else:
                     stderr_lines += 1
 
-        # Set up cancellation event
-        from janito.llm.cancellation_manager import get_cancellation_manager
-        cancel_manager = get_cancellation_manager()
-        self._cancel_event = cancel_manager.get_current_cancel_event()
-        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -119,18 +111,10 @@ class PythonCodeRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        
-        try:
-            process.stdin.write(code)
-            process.stdin.close()
-            stdout_thread.join()
-            stderr_thread.join()
-        except Exception as e:
-            # Handle cancellation or other errors
-            if self._cancel_event and self._cancel_event.is_set():
-                process.kill()
-                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
-            raise
+        process.stdin.write(code)
+        process.stdin.close()
+        stdout_thread.join()
+        stderr_thread.join()
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):