janito 2.22.0__py3-none-any.whl → 2.24.0__py3-none-any.whl

janito/cli/core/getters.py

@@ -10,6 +10,7 @@ from janito.cli.cli_commands.list_config import handle_list_config
 from janito.cli.cli_commands.list_drivers import handle_list_drivers
 from janito.regions.cli import handle_region_info
 from janito.cli.cli_commands.list_providers_region import handle_list_providers_region
+from janito.cli.cli_commands.list_plugins import handle_list_plugins
 from functools import partial
 from janito.provider_registry import ProviderRegistry
 
@@ -23,6 +24,8 @@ GETTER_KEYS = [
     "list_drivers",
     "region_info",
     "list_providers_region",
+    "list_plugins",
+    "list_plugins_available",
 ]
 
 
@@ -51,6 +54,7 @@ def handle_getter(args, config_mgr=None):
         "list_drivers": partial(handle_list_drivers, args),
         "region_info": partial(handle_region_info, args),
         "list_providers_region": partial(handle_list_providers_region, args),
+        "list_plugins": partial(handle_list_plugins, args),
     }
     for arg in GETTER_KEYS:
         if getattr(args, arg, False) and arg in GETTER_DISPATCH:

janito/cli/core/runner.py

@@ -144,13 +144,18 @@ def handle_runner(
 
     load_disabled_tools_from_config()
 
-    unrestricted_paths = getattr(args, "unrestricted_paths", False)
+    unrestricted = getattr(args, "unrestricted", False)
     adapter = janito.tools.get_local_tools_adapter(
         workdir=getattr(args, "workdir", None)
     )
-    if unrestricted_paths:
+    if unrestricted:
         # Patch: disable path security enforcement for this adapter instance
         setattr(adapter, "unrestricted_paths", True)
+        
+        # Also disable URL whitelist restrictions in unrestricted mode
+        from janito.tools.url_whitelist import get_url_whitelist_manager
+        whitelist_manager = get_url_whitelist_manager()
+        whitelist_manager.set_unrestricted_mode(True)
 
     # Print allowed permissions in verbose mode
     if getattr(args, "verbose", False):

janito/cli/core/setters.py

@@ -69,8 +69,17 @@ def _dispatch_set_key(key, value):
         global_config.file_set("disabled_tools", value)
         print(f"Disabled tools set to '{value}'")
         return True
+    if key == "allowed_sites":
+        from janito.tools.url_whitelist import get_url_whitelist_manager
+        
+        sites = [site.strip() for site in value.split(',') if site.strip()]
+        whitelist_manager = get_url_whitelist_manager()
+        whitelist_manager.set_allowed_sites(sites)
+        global_config.file_set("allowed_sites", value)
+        print(f"Allowed sites set to: {', '.join(sites)}")
+        return True
     print(
-        f"Error: Unknown config key '{key}'. Supported: provider, model, max_tokens, base_url, azure_deployment_name, tool_permissions, disabled_tools"
+        f"Error: Unknown config key '{key}'. Supported: provider, model, max_tokens, base_url, azure_deployment_name, tool_permissions, disabled_tools, allowed_sites"
     )
     return True
 

janito/cli/main_cli.py

@@ -13,12 +13,13 @@ from janito.cli.core.event_logger import (
     inject_debug_event_bus_if_needed,
 )
 
+
 definition = [
     (
-        ["-u", "--unrestricted-paths"],
+        ["-u", "--unrestricted"],
         {
             "action": "store_true",
-            "help": "Disable path security: allow tool arguments to use any file/directory path (DANGEROUS)",
+            "help": "Unrestricted mode: disable path security and URL whitelist restrictions (DANGEROUS)",
         },
     ),
     (
@@ -43,6 +44,13 @@ definition = [
             "help": "Start with the Python developer profile (equivalent to --profile 'Developer with Python Tools')",
         },
     ),
+    (
+        ["--market"],
+        {
+            "action": "store_true",
+            "help": "Start with the Market Analyst profile (equivalent to --profile 'Market Analyst')",
+        },
+    ),
     (
         ["--role"],
         {
@@ -149,6 +157,7 @@ definition = [
             "help": "List all providers with their regional API information",
         },
     ),
+
     (
         ["-l", "--list-models"],
         {"action": "store_true", "help": "List all supported models"},
@@ -213,6 +222,14 @@ definition = [
             "help": "Use custom configuration file ~/.janito/configs/NAME.json instead of default config.json",
         },
     ),
+    (
+        ["--list-plugins"],
+        {"action": "store_true", "help": "List all loaded plugins"},
+    ),
+    (
+        ["--list-plugins-available"],
+        {"action": "store_true", "help": "List all available plugins"},
+    ),
 ]
 
 MODIFIER_KEYS = [
@@ -221,6 +238,7 @@ MODIFIER_KEYS = [
     "role",
     "profile",
     "python",
+    "market",
     "system",
     "temperature",
     "verbose",
@@ -323,6 +341,8 @@ class JanitoCLI:
 
                 argkwargs["version"] = f"Janito {janito_version}"
             self.parser.add_argument(*argnames, **argkwargs)
+        
+
 
     def _set_all_arg_defaults(self):
         # Gather all possible keys from definition, MODIFIER_KEYS, SETTER_KEYS, GETTER_KEYS
@@ -370,7 +390,7 @@ class JanitoCLI:
         if run_mode == RunMode.SET:
             if self._run_set_mode():
                 return
-        # Special handling: provider is not required for list_providers, list_tools, show_config, list_drivers
+        # Special handling: provider is not required for list commands
         if run_mode == RunMode.GET and (
             self.args.list_providers
             or self.args.list_tools
@@ -378,6 +398,8 @@ class JanitoCLI:
             or self.args.show_config
             or self.args.list_config
             or self.args.list_drivers
+            or self.args.list_plugins
+            or self.args.list_plugins_available
             or self.args.ping
         ):
             self._maybe_print_verbose_provider_model()

janito/cli/single_shot_mode/handler.py

@@ -24,10 +24,12 @@ class PromptHandler:
         self.llm_driver_config = llm_driver_config
         self.role = role
         # Instantiate agent together with prompt handler using the shared helper
-        # Handle --python flag for single shot mode
+        # Handle --python and --market flags for single shot mode
         profile = getattr(args, "profile", None)
         if profile is None and getattr(args, "python", False):
             profile = "Developer with Python Tools"
+        if profile is None and getattr(args, "market", False):
+            profile = "Market Analyst"
 
         self.agent, self.generic_handler = setup_agent_and_prompt_handler(
             args=args,

janito/config_manager.py

@@ -55,6 +55,16 @@ class ConfigManager:
             except Exception as e:
                 print(f"Warning: Failed to apply tool_permissions from config: {e}")
 
+        # Load plugins from config
+        plugins_config = self.file_config.get("plugins", {})
+        if plugins_config:
+            try:
+                from janito.plugins.manager import PluginManager
+                plugin_manager = PluginManager()
+                plugin_manager.load_plugins_from_config({"plugins": plugins_config})
+            except Exception as e:
+                print(f"Warning: Failed to load plugins from config: {e}")
+
         # Load disabled tools from config - skip during startup to avoid circular imports
         # This will be handled by the CLI when needed
 

janito/plugins/__init__.py

@@ -0,0 +1,17 @@
+"""
+Plugin system for janito.
+
+This package provides a flexible plugin system that allows extending
+janito's functionality with custom tools, commands, and features.
+"""
+
+from .manager import PluginManager
+from .base import Plugin, PluginMetadata
+from .discovery import discover_plugins
+
+__all__ = [
+    "PluginManager",
+    "Plugin",
+    "PluginMetadata", 
+    "discover_plugins",
+]

janito/plugins/base.py

@@ -0,0 +1,93 @@
+"""
+Base classes for janito plugins.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Dict, Any, List, Optional, Type
+from janito.tools.tool_base import ToolBase
+
+
+@dataclass
+class PluginMetadata:
+    """Metadata describing a plugin."""
+    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 = []
+
+
+class Plugin(ABC):
+    """
+    Base class for all janito plugins.
+    
+    Plugins can provide tools, commands, or other functionality.
+    """
+    
+    def __init__(self):
+        self.metadata: PluginMetadata = self.get_metadata()
+    
+    @abstractmethod
+    def get_metadata(self) -> PluginMetadata:
+        """Return metadata describing this plugin."""
+        pass
+    
+    def get_tools(self) -> List[Type[ToolBase]]:
+        """
+        Return a list of tool classes provided by this plugin.
+        
+        Returns:
+            List of ToolBase subclasses that should be registered
+        """
+        return []
+    
+    def get_commands(self) -> Dict[str, Any]:
+        """
+        Return a dictionary of CLI commands provided by this plugin.
+        
+        Returns:
+            Dict mapping command names to command handlers
+        """
+        return {}
+    
+    def initialize(self) -> None:
+        """
+        Called when the plugin is loaded.
+        Override to perform any initialization needed.
+        """
+        pass
+    
+    def cleanup(self) -> None:
+        """
+        Called when the plugin is unloaded.
+        Override to perform any cleanup needed.
+        """
+        pass
+    
+    def get_config_schema(self) -> Dict[str, Any]:
+        """
+        Return JSON schema for plugin configuration.
+        
+        Returns:
+            JSON schema dict describing configuration options
+        """
+        return {}
+    
+    def validate_config(self, config: Dict[str, Any]) -> bool:
+        """
+        Validate plugin configuration.
+        
+        Args:
+            config: Configuration dict to validate
+            
+        Returns:
+            True if configuration is valid
+        """
+        return True

janito/plugins/discovery.py

@@ -0,0 +1,160 @@
+"""
+Plugin discovery utilities.
+"""
+
+import os
+import sys
+import importlib
+import importlib.util
+from pathlib import Path
+from typing import Optional, List
+import logging
+
+from .base import Plugin
+
+logger = logging.getLogger(__name__)
+
+
+def discover_plugins(plugin_name: str, search_paths: List[Path] = None) -> Optional[Plugin]:
+    """
+    Discover and load a plugin by name.
+    
+    Args:
+        plugin_name: Name of the plugin to discover
+        search_paths: List of directories to search for plugins
+        
+    Returns:
+        Plugin instance if found, None otherwise
+    """
+    if search_paths is None:
+        search_paths = []
+    
+    # Add default search paths
+    default_paths = [
+        Path.cwd() / "plugins",
+        Path.home() / ".janito" / "plugins",
+        Path(sys.prefix) / "share" / "janito" / "plugins",
+    ]
+    
+    all_paths = search_paths + default_paths
+    
+    # Try to find plugin in search paths
+    for base_path in all_paths:
+        plugin_path = base_path / plugin_name
+        if plugin_path.exists():
+            return _load_plugin_from_directory(plugin_path)
+        
+        # Try as Python module
+        module_path = base_path / f"{plugin_name}.py"
+        if module_path.exists():
+            return _load_plugin_from_file(module_path)
+    
+    # Try importing as installed package
+    try:
+        return _load_plugin_from_package(plugin_name)
+    except ImportError:
+        pass
+    
+    return None
+
+
+def _load_plugin_from_directory(plugin_path: Path) -> Optional[Plugin]:
+    """Load a plugin from a directory."""
+    try:
+        # Look for __init__.py or plugin.py
+        init_file = plugin_path / "__init__.py"
+        plugin_file = plugin_path / "plugin.py"
+        
+        if init_file.exists():
+            return _load_plugin_from_file(init_file, plugin_name=plugin_path.name)
+        elif plugin_file.exists():
+            return _load_plugin_from_file(plugin_file, plugin_name=plugin_path.name)
+        
+    except Exception as e:
+        logger.error(f"Failed to load plugin from directory {plugin_path}: {e}")
+    
+    return None
+
+
+def _load_plugin_from_file(file_path: Path, plugin_name: str = None) -> Optional[Plugin]:
+    """Load a plugin from a Python file."""
+    try:
+        if plugin_name is None:
+            plugin_name = file_path.stem
+        
+        spec = importlib.util.spec_from_file_location(plugin_name, file_path)
+        if spec is None or spec.loader is None:
+            return None
+        
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        
+        # Look for Plugin class
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            if (isinstance(attr, type) and 
+                issubclass(attr, Plugin) and 
+                attr != Plugin):
+                return attr()
+        
+    except Exception as e:
+        logger.error(f"Failed to load plugin from file {file_path}: {e}")
+    
+    return None
+
+
+def _load_plugin_from_package(package_name: str) -> Optional[Plugin]:
+    """Load a plugin from an installed package."""
+    try:
+        module = importlib.import_module(package_name)
+        
+        # Look for Plugin class
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            if (isinstance(attr, type) and 
+                issubclass(attr, Plugin) and 
+                attr != Plugin):
+                return attr()
+        
+    except ImportError as e:
+        logger.debug(f"Could not import package {package_name}: {e}")
+    
+    return None
+
+
+def list_available_plugins(search_paths: List[Path] = None) -> List[str]:
+    """
+    List all available plugins in search paths.
+    
+    Args:
+        search_paths: List of directories to search for plugins
+        
+    Returns:
+        List of plugin names found
+    """
+    if search_paths is None:
+        search_paths = []
+    
+    # Add default search paths
+    default_paths = [
+        Path.cwd() / "plugins",
+        Path.home() / ".janito" / "plugins", 
+        Path(sys.prefix) / "share" / "janito" / "plugins",
+    ]
+    
+    all_paths = search_paths + default_paths
+    plugins = []
+    
+    for base_path in all_paths:
+        if not base_path.exists():
+            continue
+            
+        # Look for directories with __init__.py or plugin.py
+        for item in base_path.iterdir():
+            if item.is_dir():
+                if (item / "__init__.py").exists() or (item / "plugin.py").exists():
+                    plugins.append(item.name)
+            elif item.suffix == '.py' and item.stem != '__init__':
+                plugins.append(item.stem)
+    
+    return sorted(set(plugins))

janito/plugins/manager.py

@@ -0,0 +1,185 @@
+"""
+Plugin manager for loading and managing plugins.
+"""
+
+import os
+import sys
+import importlib
+import importlib.util
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import logging
+
+from .base import Plugin, PluginMetadata
+from .discovery import discover_plugins
+from janito.tools.adapters.local import LocalToolsAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class PluginManager:
+    """
+    Manages plugin loading, registration, and lifecycle.
+    """
+    
+    def __init__(self, tools_adapter: Optional[LocalToolsAdapter] = None):
+        self.tools_adapter = tools_adapter or LocalToolsAdapter()
+        self.plugins: Dict[str, Plugin] = {}
+        self.plugin_configs: Dict[str, Dict[str, Any]] = {}
+        self.plugin_paths: List[Path] = []
+        
+    def add_plugin_path(self, path: str) -> None:
+        """Add a directory to search for plugins."""
+        plugin_path = Path(path)
+        if plugin_path.exists() and plugin_path.is_dir():
+            self.plugin_paths.append(plugin_path)
+            if str(plugin_path) not in sys.path:
+                sys.path.insert(0, str(plugin_path))
+    
+    def load_plugin(self, plugin_name: str, config: Optional[Dict[str, Any]] = None) -> bool:
+        """
+        Load a plugin by name.
+        
+        Args:
+            plugin_name: Name of the plugin to load
+            config: Optional configuration for the plugin
+            
+        Returns:
+            True if plugin loaded successfully
+        """
+        try:
+            if plugin_name in self.plugins:
+                logger.warning(f"Plugin {plugin_name} already loaded")
+                return True
+                
+            plugin = discover_plugins(plugin_name, self.plugin_paths)
+            if not plugin:
+                logger.error(f"Plugin {plugin_name} not found")
+                return False
+            
+            # Store config
+            if config:
+                self.plugin_configs[plugin_name] = config
+            
+            # Validate config if provided
+            if config and hasattr(plugin, 'validate_config'):
+                if not plugin.validate_config(config):
+                    logger.error(f"Invalid configuration for plugin {plugin_name}")
+                    return False
+            
+            # Initialize plugin
+            plugin.initialize()
+            
+            # Register tools
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                self.tools_adapter.register_tool(tool_class)
+            
+            # Store plugin
+            self.plugins[plugin_name] = plugin
+            
+            logger.info(f"Successfully loaded plugin: {plugin_name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to load plugin {plugin_name}: {e}")
+            return False
+    
+    def unload_plugin(self, plugin_name: str) -> bool:
+        """
+        Unload a plugin.
+        
+        Args:
+            plugin_name: Name of the plugin to unload
+            
+        Returns:
+            True if plugin unloaded successfully
+        """
+        try:
+            if plugin_name not in self.plugins:
+                logger.warning(f"Plugin {plugin_name} not loaded")
+                return False
+            
+            plugin = self.plugins[plugin_name]
+            
+            # Unregister tools
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                tool_name = getattr(tool_class(), 'tool_name', None)
+                if tool_name:
+                    self.tools_adapter.unregister_tool(tool_name)
+            
+            # Cleanup plugin
+            plugin.cleanup()
+            
+            # Remove from registry
+            del self.plugins[plugin_name]
+            if plugin_name in self.plugin_configs:
+                del self.plugin_configs[plugin_name]
+            
+            logger.info(f"Successfully unloaded plugin: {plugin_name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to unload plugin {plugin_name}: {e}")
+            return False
+    
+    def list_plugins(self) -> List[str]:
+        """Return list of loaded plugin names."""
+        return list(self.plugins.keys())
+    
+    def get_plugin(self, plugin_name: str) -> Optional[Plugin]:
+        """Get a loaded plugin by name."""
+        return self.plugins.get(plugin_name)
+    
+    def get_plugin_metadata(self, plugin_name: str) -> Optional[PluginMetadata]:
+        """Get metadata for a loaded plugin."""
+        plugin = self.plugins.get(plugin_name)
+        return plugin.metadata if plugin else None
+    
+    def load_plugins_from_config(self, config: Dict[str, Any]) -> None:
+        """
+        Load plugins from configuration.
+        
+        Args:
+            config: Configuration dict with plugin settings
+        """
+        plugins_config = config.get('plugins', {})
+        
+        # Add plugin paths
+        for path in plugins_config.get('paths', []):
+            self.add_plugin_path(path)
+        
+        # Load plugins
+        for plugin_name, plugin_config in plugins_config.get('load', {}).items():
+            if isinstance(plugin_config, bool):
+                if plugin_config:
+                    self.load_plugin(plugin_name)
+            else:
+                self.load_plugin(plugin_name, plugin_config)
+    
+    def reload_plugin(self, plugin_name: str) -> bool:
+        """
+        Reload a plugin.
+        
+        Args:
+            plugin_name: Name of the plugin to reload
+            
+        Returns:
+            True if plugin reloaded successfully
+        """
+        config = self.plugin_configs.get(plugin_name)
+        self.unload_plugin(plugin_name)
+        return self.load_plugin(plugin_name, config)
+    
+    def get_loaded_plugins_info(self) -> Dict[str, Dict[str, Any]]:
+        """Get information about all loaded plugins."""
+        info = {}
+        for name, plugin in self.plugins.items():
+            info[name] = {
+                'metadata': plugin.metadata,
+                'tools': [tool.__name__ for tool in plugin.get_tools()],
+                'commands': list(plugin.get_commands().keys()),
+                'config': self.plugin_configs.get(name, {})
+            }
+        return info

janito/tools/adapters/local/__init__.py

@@ -23,6 +23,7 @@ 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 janito.tools.tool_base import ToolPermissions
 import os
@@ -61,6 +62,7 @@ for tool_class in [
     SearchOutlineTool,
     SearchTextTool,
     ValidateFileSyntaxTool,
+    ReadChartTool,
 ]:
     local_tools_adapter.register_tool(tool_class)