janito 3.6.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,19 +1,19 @@
 from janito.llm.model import LLMModelInfo
 
 MOONSHOT_MODEL_SPECS = {
-    "kimi-k2-0905": LLMModelInfo(
-        name="kimi-k2-0905",
+    "kimi-k2-0905-preview": LLMModelInfo(
+        name="kimi-k2-0905-preview",
         context=256000,
         max_input=200000,
         max_cot="N/A",
-        max_response=8192,
+        max_response=4096,
         thinking_supported=False,
         default_temp=0.2,
         open="moonshot",
         driver="OpenAIModelDriver",
     ),
-    "kimi-k2-turbo-preview": LLMModelInfo(
-        name="kimi-k2-turbo-preview",
+    "kimi-k2-0711-preview": LLMModelInfo(
+        name="kimi-k2-0711-preview",
         context=128000,
         max_input=100000,
         max_cot="N/A",
@@ -23,8 +23,8 @@ MOONSHOT_MODEL_SPECS = {
         open="moonshot",
         driver="OpenAIModelDriver",
     ),
-    "kimi-k2-0711-preview": LLMModelInfo(
-        name="kimi-k2-0711-preview",
+    "kimi-k2-turbo-preview": LLMModelInfo(
+        name="kimi-k2-turbo-preview",
         context=128000,
         max_input=100000,
         max_cot="N/A",

janito/providers/moonshot/provider.py

@@ -12,7 +12,7 @@ class MoonshotProvider(LLMProvider):
     NAME = "moonshot"
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MOONSHOT_MODEL_SPECS
-    DEFAULT_MODEL = "kimi-k2-0905"
+    DEFAULT_MODEL = "kimi-k2-turbo-preview"
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None

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,42 +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 _initialize_global_adapter():
-    """Initialize the global tools adapter."""
-    global local_tools_adapter
-    if local_tools_adapter is None:
-        from janito.tools.cli_initializer import get_cli_tools_adapter
-        # Try CLI initialization first
-        local_tools_adapter = get_cli_tools_adapter()
-        if local_tools_adapter is None:
-            # Fallback to regular initialization
-            from janito.tools.initialize import initialize_tools
-            local_tools_adapter = initialize_tools(LocalToolsAdapter())
-
-
-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:
-        _initialize_global_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/core → tools/adapters/local}/ask_user.py

@@ -1,5 +1,5 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
-from .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/tools/adapters/local/copy_file.py

@@ -0,0 +1,87 @@
+import os
+from janito.tools.path_utils import expand_path
+import shutil
+from typing import List, Union
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.tools.tool_utils import display_path
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_local_tool
+class CopyFileTool(ToolBase):
+    """
+    Copy one or more files to a target directory, or copy a single file to a new file.
+    Args:
+        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.
+    Returns:
+        str: Status string for each copy operation.
+    """
+
+    permissions = ToolPermissions(read=True, write=True)
+    tool_name = "copy_file"
+
+    def run(self, sources: str, target: str, overwrite: bool = False) -> str:
+        source_list = [expand_path(src) for src in sources.split() if src]
+        target = expand_path(target)
+        messages = []
+        if len(source_list) > 1:
+            if not os.path.isdir(target):
+                return tr(
+                    "❗ Target must be an existing directory when copying multiple files: '{target}'",
+                    target=display_path(target),
+                )
+            for src in source_list:
+                if not os.path.isfile(src):
+                    messages.append(
+                        tr(
+                            "❗ Source file does not exist: '{src}'",
+                            src=display_path(src),
+                        )
+                    )
+                    continue
+                dst = os.path.join(target, os.path.basename(src))
+                messages.append(self._copy_one(src, dst, overwrite=overwrite))
+        else:
+            src = source_list[0]
+            if os.path.isdir(target):
+                dst = os.path.join(target, os.path.basename(src))
+            else:
+                dst = target
+            messages.append(self._copy_one(src, dst, overwrite=overwrite))
+        return "\n".join(messages)
+
+    def _copy_one(self, src, dst, overwrite=False) -> str:
+        disp_src = display_path(src)
+        disp_dst = display_path(dst)
+        if not os.path.isfile(src):
+            return tr("❗ Source file does not exist: '{src}'", src=disp_src)
+        if os.path.exists(dst) and not overwrite:
+            return tr(
+                "❗ Target already exists: '{dst}'. Set overwrite=True to replace.",
+                dst=disp_dst,
+            )
+        try:
+            os.makedirs(os.path.dirname(dst), exist_ok=True)
+            shutil.copy2(src, dst)
+            note = (
+                "\n⚠️ Overwrote existing file. (recommended only after reading the file to be overwritten)"
+                if (os.path.exists(dst) and overwrite)
+                else ""
+            )
+            self.report_success(
+                tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst)
+            )
+            return tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst) + note
+        except Exception as e:
+            return tr(
+                "❗ Copy failed from '{src}' to '{dst}': {err}",
+                src=disp_src,
+                dst=disp_dst,
+                err=str(e),
+            )