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

janito/cli/cli_commands/list_profiles.py

@@ -19,7 +19,35 @@ def _extract_profile_name(filename: str) -> str:
         filename = filename[len(_PREFIX) :]
     if filename.endswith(_SUFFIX):
         filename = filename[: -len(_SUFFIX)]
-    return filename.replace("_", " ")
+    
+    # Convert to title case for consistent capitalization, but handle common acronyms
+    name = filename.replace("_", " ")
+    
+    # Convert to proper title case with consistent capitalization
+    name = filename.replace("_", " ")
+    
+    # Handle special cases and acronyms
+    special_cases = {
+        "python": "Python",
+        "tools": "Tools",
+        "model": "Model",
+        "context": "Context",
+        "developer": "Developer",
+        "analyst": "Analyst",
+        "conversation": "Conversation",
+        "without": "Without"
+    }
+    
+    words = name.split()
+    capitalized_words = []
+    for word in words:
+        lower_word = word.lower()
+        if lower_word in special_cases:
+            capitalized_words.append(special_cases[lower_word])
+        else:
+            capitalized_words.append(word.capitalize())
+    
+    return " ".join(capitalized_words)
 
 
 def _gather_default_profiles():

janito/cli/cli_commands/show_system_prompt.py

@@ -9,6 +9,7 @@ from janito.platform_discovery import PlatformDiscovery
 from pathlib import Path
 from jinja2 import Template
 import importlib.resources
+import importlib.resources as resources
 import re
 
 
@@ -60,7 +61,17 @@ def _load_template(profile, templates_dir):
             ).open("r", encoding="utf-8") as file:
                 template_content = file.read()
         except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            return template_filename, None
+            # Also check user profiles directory
+            from pathlib import Path
+            import os
+            user_profiles_dir = Path(os.path.expanduser("~/.janito/profiles"))
+            user_template_path = user_profiles_dir / template_filename
+            if user_template_path.exists():
+                with open(user_template_path, "r", encoding="utf-8") as file:
+                    template_content = file.read()
+            else:
+                template_content = None
+            return template_filename, template_content
     return template_filename, template_content
 
 
@@ -105,6 +116,11 @@ def handle_show_system_prompt(args):
         Path(__file__).parent.parent.parent / "agent" / "templates" / "profiles"
     )
     profile = getattr(args, "profile", None)
+    
+    # Handle --market flag mapping to Market Analyst profile
+    if profile is None and getattr(args, "market", False):
+        profile = "Market Analyst"
+    
     if not profile:
         print(
             "[janito] No profile specified. The main agent runs without a system prompt template.\n"
@@ -116,15 +132,13 @@ def handle_show_system_prompt(args):
     _print_debug_info(debug_flag, template_filename, allowed_permissions, context)
 
     if not template_content:
-        if profile:
-            raise FileNotFoundError(
-                f"[janito] Could not find profile-specific template '{template_filename}' in {templates_dir / template_filename} nor in janito.agent.templates.profiles package."
-            )
-        else:
-            print(
-                f"[janito] Could not find {template_filename} in {templates_dir / template_filename} nor in janito.agent.templates.profiles package."
-            )
-            print("No system prompt is set or resolved for this configuration.")
+        # Try to load directly from package resources as fallback
+        try:
+            template_content = resources.files("janito.agent.templates.profiles").joinpath(
+                f"system_prompt_template_{profile.lower().replace(' ', '_')}.txt.j2"
+            ).read_text(encoding="utf-8")
+        except (FileNotFoundError, ModuleNotFoundError, AttributeError):
+            print(f"[janito] Could not find profile '{profile}'. This may be a configuration issue.")
             return
 
     template = Template(template_content)

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))