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

janito/plugins/core_adapter.py

@@ -0,0 +1,131 @@
+"""
+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.plugin_system.base import Plugin, PluginMetadata
+from typing import List, Type
+from janito.tools.tool_base import ToolBase, ToolPermissions
+
+
+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 _create_tool_class(self, func):
+        """Create a ToolBase class from a function."""
+        resolved_tool_name = getattr(func, "tool_name", func.__name__)
+        
+        # Create a proper tool class with explicit parameters and documentation
+        import inspect
+        from typing import get_type_hints
+        
+        func_sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+        
+        # Build parameter definitions for the run method
+        param_defs = []
+        param_docs = []
+        for name, param in func_sig.parameters.items():
+            type_hint = type_hints.get(name, str)
+            if param.default == inspect.Parameter.empty:
+                param_defs.append(f"{name}: {type_hint.__name__}")
+            else:
+                param_defs.append(f"{name}: {type_hint.__name__} = {repr(param.default)}")
+            
+            # Add parameter documentation
+            param_docs.append(f"    {name}: {type_hint.__name__} - Parameter {name}")
+        
+        # Get function docstring or create one
+        func_doc = func.__doc__ or f"Execute {resolved_tool_name} tool"
+        
+        # Create the tool class with proper signature and documentation
+        exec_globals = {
+            'ToolBase': ToolBase,
+            'ToolPermissions': ToolPermissions,
+            'func': func,
+            'inspect': inspect,
+            'str': str,
+            'List': list,
+            'Dict': dict,
+            'Optional': type(None),
+        }
+        
+        param_docs_str = '\n'.join(param_docs)
+        
+        class_def = f'''
+class DynamicTool(ToolBase):
+    """
+    {func_doc}
+    
+    Parameters:
+{param_docs_str}
+    
+    Returns:
+        str: Execution result
+    """
+    tool_name = "{resolved_tool_name}"
+    permissions = ToolPermissions(read=True, write=True, execute=True)
+    
+    def __init__(self):
+        super().__init__()
+    
+    def run(self, {', '.join(param_defs)}) -> str:
+        kwargs = locals()
+        sig = inspect.signature(func)
+        
+        # Filter kwargs to only include parameters the function accepts
+        filtered_kwargs = {{}}
+        for name, param in sig.parameters.items():
+            if name in kwargs and kwargs[name] is not None:
+                filtered_kwargs[name] = kwargs[name]
+        
+        result = func(**filtered_kwargs)
+        return str(result) if result is not None else ""
+'''
+        
+        exec(class_def, exec_globals)
+        return exec_globals['DynamicTool']
+        
+        return DynamicTool
+
+    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 = self._create_tool_class(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/discovery.py

@@ -31,9 +31,9 @@ from pathlib import Path
 from typing import Optional, List
 import logging
 
-from .base import Plugin
+from janito.plugin_system.base import Plugin
 from .builtin import load_builtin_plugin, BuiltinPluginRegistry
-from .core_loader import load_core_plugin
+from janito.plugin_system.core_loader import load_core_plugin
 
 logger = logging.getLogger(__name__)
 
@@ -157,7 +157,7 @@ def _load_plugin_from_file(
 
         # Check for package-based plugin with __plugin_name__ metadata
         if hasattr(module, "__plugin_name__"):
-            from .base import PluginMetadata
+            from janito.plugin_system.base import PluginMetadata
 
             # Create a dynamic plugin class
             class PackagePlugin(Plugin):

janito/{plugins_backup_20250825_070018 → 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,20 +30,25 @@ 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/example_plugin.py

@@ -2,7 +2,7 @@
 Example plugin demonstrating the plugin system.
 """
 
-from .base import Plugin, PluginMetadata, PluginResource
+from janito.plugin_system.base import Plugin, PluginMetadata, PluginResource
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from typing import Dict, Any
 

janito/plugins/manager.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from typing import Dict, List, Optional, Any
 import logging
 
-from .base import Plugin, PluginMetadata
+from janito.plugin_system.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/{plugins_backup_20250825_070018 → plugins}/tools/core_tools_plugin.py

@@ -6,16 +6,6 @@ from functools import wraps
 from typing import Type
 from janito.plugin_system.base import Plugin, PluginMetadata
 
-# Registry for core tools
-_core_tools_registry = []
-
-
-def register_core_tool(cls: Type):
-    """Decorator to register a core tool."""
-    _core_tools_registry.append(cls)
-    return cls
-
-
 from .ask_user import AskUser
 from .copy_file import CopyFile
 from .create_directory import CreateDirectory
@@ -44,6 +34,15 @@ from .get_file_outline.core import GetFileOutline
 from .search_text.core import SearchText
 from .decorators import get_core_tools
 
+# Registry for core tools
+_core_tools_registry = []
+
+
+def register_core_tool(cls: Type):
+    """Decorator to register a core tool."""
+    _core_tools_registry.append(cls)
+    return cls
+
 
 class CoreToolsPlugin(Plugin):
     """Core tools plugin providing essential janito functionality."""

janito/{plugins_backup_20250825_070018 → plugins}/tools/create_file.py

@@ -55,7 +55,7 @@ class CreateFile(ToolBase):
         or file exists (when overwrite=False).
 
     Security Features:
-        - Loop protection: Maximum 5 calls per 10 seconds for the same file path
+        - Loop protection: Prevents repeated create calls for the same file path within a short window (1 allowed per 10 seconds)
         - 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=5, time_window=10.0, key_field="path")
+    @protect_against_loops(max_calls=1, time_window=3600.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_backup_20250825_070018 → plugins}/tools/delete_text_in_file.py

@@ -15,7 +15,6 @@ class DeleteTextInFile(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/providers/__init__.py

@@ -10,3 +10,4 @@ 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/together/__init__.py

@@ -0,0 +1 @@
+# Together AI provider for Janito

janito/providers/together/model_info.py

@@ -0,0 +1,69 @@
+"""
+Model specifications for Together AI provider.
+"""
+
+MODEL_SPECS = {
+    "allenai/OLMo-2-0325-32B-Instruct": {
+        "max_tokens": 32768,
+        "max_input_tokens": 32768,
+        "max_output_tokens": 32768,
+        "description": "OLMo 2 32B Instruct - Fully open language model from AllenAI",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "allenai/OLMo-2-1124-7B-Instruct": {
+        "max_tokens": 32768,
+        "max_input_tokens": 32768,
+        "max_output_tokens": 32768,
+        "description": "OLMo 2 7B Instruct - Fully open language model from AllenAI",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "allenai/OLMo-2-0425-1B": {
+        "max_tokens": 32768,
+        "max_input_tokens": 32768,
+        "max_output_tokens": 32768,
+        "description": "OLMo 2 1B - Fully open language model from AllenAI",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo": {
+        "max_tokens": 8192,
+        "max_input_tokens": 128000,
+        "max_output_tokens": 8192,
+        "description": "Llama 3.1 8B Instruct Turbo",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": {
+        "max_tokens": 8192,
+        "max_input_tokens": 128000,
+        "max_output_tokens": 8192,
+        "description": "Llama 3.1 70B Instruct Turbo",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "mistralai/Mixtral-8x7B-Instruct-v0.1": {
+        "max_tokens": 32768,
+        "max_input_tokens": 32768,
+        "max_output_tokens": 32768,
+        "description": "Mixtral 8x7B Instruct",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+    "deepseek-ai/deepseek-llm-67b-chat": {
+        "max_tokens": 4096,
+        "max_input_tokens": 4096,
+        "max_output_tokens": 4096,
+        "description": "DeepSeek LLM 67B Chat",
+        "supports_tools": True,
+        "supports_system_prompt": True,
+        "supports_streaming": True,
+    },
+}

janito/providers/together/provider.py

@@ -0,0 +1,108 @@
+from janito.llm.provider import LLMProvider
+from janito.llm.model import LLMModelInfo
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from queue import Queue
+
+available = OpenAIModelDriver.available
+unavailable_reason = OpenAIModelDriver.unavailable_reason
+
+
+class TogetherProvider(LLMProvider):
+    name = 'together'
+    NAME = 'together'
+    MAINTAINER = 'Janito Team'
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = 'allenai/OLMo-2-0325-32B-Instruct'
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        self._tools_adapter = get_local_tools_adapter()
+        self._driver = None
+
+        if not self.available:
+            return
+
+        self._initialize_config(auth_manager, config)
+        self._setup_model_config()
+
+    def _initialize_config(self, auth_manager, config):
+        self.auth_manager = auth_manager or LLMAuthManager()
+        self._api_key = self.auth_manager.get_credentials(type(self).NAME)
+        if not self._api_key:
+            from janito.llm.auth_utils import handle_missing_api_key
+            handle_missing_api_key(self.name, 'TOGETHER_API_KEY')
+
+        self._driver_config = config or LLMDriverConfig(model=None)
+        if not self._driver_config.model:
+            self._driver_config.model = self.DEFAULT_MODEL
+        if not self._driver_config.api_key:
+            self._driver_config.api_key = self._api_key
+
+        self._driver_config.base_url = 'https://api.together.xyz/v1'
+
+    def _setup_model_config(self):
+        model_name = self._driver_config.model
+        model_spec = self.MODEL_SPECS.get(model_name)
+
+        if hasattr(self._driver_config, 'max_tokens'):
+            self._driver_config.max_tokens = None
+        if hasattr(self._driver_config, 'max_completion_tokens'):
+            self._driver_config.max_completion_tokens = None
+
+        if model_spec:
+            max_tokens = getattr(model_spec, 'max_tokens', None)
+            if max_tokens and max_tokens != 'N/A':
+                self._driver_config.max_tokens = int(max_tokens)
+
+        self.fill_missing_device_info(self._driver_config)
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f'TogetherProvider unavailable: {self.unavailable_reason}')
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_driver(self):
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.NAME
+        )
+        driver.config = self._driver_config
+        return driver
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        raise NotImplementedError(
+            'create_agent must be constructed via new factory using input/output queues and config.'
+        )
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @property
+    def driver_config(self):
+        return self._driver_config
+
+    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(TogetherProvider.NAME, TogetherProvider)
+

janito/tools/base.py

@@ -1,35 +1,5 @@
 class BaseTool:
-    """
-    Base class for all tools.
-    
-    Parameters:
-        path (str): Target file path for file operations
-        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')
-    """
+    """Base class for all tools."""
 
     tool_name: str = ""
 

janito/tools/cli_initializer.py

@@ -17,7 +17,7 @@ def initialize_cli_tools():
     """Initialize tools for CLI usage, avoiding circular imports."""
     try:
         from janito.tools.adapters.local.adapter import LocalToolsAdapter
-        from janito.plugins.core_loader import load_core_plugin
+        from janito.plugin_system.core_loader_fixed import load_core_plugin
         from janito.tools.permissions import set_global_allowed_permissions
         from janito.tools.tool_base import ToolPermissions
 

janito/tools/initialize.py

@@ -9,7 +9,7 @@ import sys
 from pathlib import Path
 from typing import List, Optional
 
-from janito.plugins.core_loader import load_core_plugin
+from janito.plugin_system.core_loader_fixed import load_core_plugin
 from janito.tools.adapters.local.adapter import LocalToolsAdapter