janito 2.14.0__py3-none-any.whl → 2.16.0__py3-none-any.whl

janito/cli/chat_mode/session.py

@@ -115,9 +115,15 @@ class ChatSession:
     def _select_profile_and_role(self, args, role):
         profile = getattr(args, "profile", None) if args is not None else None
         role_arg = getattr(args, "role", None) if args is not None else None
+        python_profile = getattr(args, "python", False) if args is not None else False
         profile_system_prompt = None
         no_tools_mode = False
-        if profile is None and role_arg is None:
+
+        # Handle --python flag
+        if python_profile and profile is None and role_arg is None:
+            profile = "Developer with Python Tools"
+
+        if profile is None and role_arg is None and not python_profile:
             try:
                 from janito.cli.chat_mode.session_profile_select import select_profile
 
@@ -277,6 +283,41 @@ class ChatSession:
                 else None
             )
             start_time = time.time()
+
+            # Print rule line with model info before processing prompt
+            model_name = (
+                self.agent.get_model_name()
+                if hasattr(self.agent, "get_model_name")
+                else "Unknown"
+            )
+            provider_name = (
+                self.agent.get_provider_name()
+                if hasattr(self.agent, "get_provider_name")
+                else "Unknown"
+            )
+
+            # Get backend hostname if available
+            backend_hostname = "Unknown"
+            if hasattr(self.agent, "driver") and self.agent.driver:
+                if hasattr(self.agent.driver, "config") and hasattr(
+                    self.agent.driver.config, "base_url"
+                ):
+                    base_url = self.agent.driver.config.base_url
+                    if base_url:
+                        try:
+                            from urllib.parse import urlparse
+
+                            parsed = urlparse(base_url)
+                            backend_hostname = parsed.netloc
+                        except Exception:
+                            backend_hostname = base_url
+
+            self.console.print(
+                Rule(
+                    f"[bold blue]Model: {model_name} ({provider_name}) | Backend: {backend_hostname}[/bold blue]"
+                )
+            )
+
             self._prompt_handler.run_prompt(cmd_input)
             end_time = time.time()
             elapsed = end_time - start_time

janito/cli/cli_commands/list_drivers.py

@@ -13,125 +13,149 @@ from rich.text import Text
 console = Console()
 
 
+def _detect_dependencies_from_content(content, class_name):
+    """Detect dependencies from module content."""
+    dependencies = []
+
+    if "import openai" in content or "from openai" in content:
+        dependencies.append("openai")
+    if "import zai" in content or "from zai" in content:
+        dependencies.append("zai")
+    if "import anthropic" in content or "from anthropic" in content:
+        dependencies.append("anthropic")
+    if "import google" in content or "from google" in content:
+        dependencies.append("google-generativeai")
+
+    # Remove openai from zai driver dependencies
+    if "ZAIModelDriver" in class_name and "openai" in dependencies:
+        dependencies.remove("openai")
+
+    return dependencies
+
+
+def _check_dependency_status(dependencies):
+    """Check if dependencies are available."""
+    if not dependencies:
+        return ["No external dependencies"]
+
+    dep_status = []
+    for dep in dependencies:
+        try:
+            importlib.import_module(dep)
+            dep_status.append(f"✅ {dep}")
+        except ImportError:
+            dep_status.append(f"❌ {dep}")
+
+    return dep_status
+
+
+def _get_single_driver_info(module_path, class_name):
+    """Get information for a single driver."""
+    try:
+        module = importlib.import_module(module_path)
+        driver_class = getattr(module, class_name)
+
+        available = getattr(driver_class, "available", True)
+        unavailable_reason = getattr(driver_class, "unavailable_reason", None)
+
+        # Read module file to detect imports
+        module_file = Path(module.__file__)
+        with open(module_file, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        dependencies = _detect_dependencies_from_content(content, class_name)
+        dep_status = _check_dependency_status(dependencies)
+
+        return {
+            "name": class_name,
+            "available": available,
+            "reason": unavailable_reason,
+            "dependencies": dep_status,
+        }
+
+    except (ImportError, AttributeError) as e:
+        return {
+            "name": class_name,
+            "module": module_path,
+            "available": False,
+            "reason": str(e),
+            "dependencies": ["❌ Module not found"],
+        }
+
+
 def get_driver_info():
     """Get information about all available drivers."""
     drivers = []
-    
+
     # Define known driver modules
     driver_modules = [
         ("janito.drivers.openai.driver", "OpenAIModelDriver"),
         ("janito.drivers.azure_openai.driver", "AzureOpenAIModelDriver"),
         ("janito.drivers.zai.driver", "ZAIModelDriver"),
     ]
-    
+
     for module_path, class_name in driver_modules:
-        try:
-            # Import the module
-            module = importlib.import_module(module_path)
-            driver_class = getattr(module, class_name)
-            
-            # Get availability info
-            available = getattr(driver_class, 'available', True)
-            unavailable_reason = getattr(driver_class, 'unavailable_reason', None)
-            
-            # Get dependencies from module imports
-            dependencies = []
-            module_file = Path(module.__file__)
-            
-            # Read module file to detect imports
-            with open(module_file, 'r', encoding='utf-8') as f:
-                content = f.read()
-                
-            # Simple dependency detection
-            if 'import openai' in content or 'from openai' in content:
-                dependencies.append('openai')
-            if 'import zai' in content or 'from zai' in content:
-                dependencies.append('zai')
-            if 'import anthropic' in content or 'from anthropic' in content:
-                dependencies.append('anthropic')
-            if 'import google' in content or 'from google' in content:
-                dependencies.append('google-generativeai')
-            
-
-            
-            # Remove duplicates while preserving order
-            seen = set()
-            dependencies = [dep for dep in dependencies if not (dep in seen or seen.add(dep))]
-            
-            # Check if dependencies are available
-            dep_status = []
-            for dep in dependencies:
-                try:
-                    importlib.import_module(dep)
-                    dep_status.append(f"✅ {dep}")
-                except ImportError:
-                    dep_status.append(f"❌ {dep}")
-            
-            if not dependencies:
-                dep_status = ["No external dependencies"]
-            
-            drivers.append({
-                'name': class_name,
-                'available': available,
-                'reason': unavailable_reason,
-                'dependencies': dep_status
-            })
-            
-        except (ImportError, AttributeError) as e:
-            drivers.append({
-                'name': class_name,
-                'module': module_path,
-                'available': False,
-                'reason': str(e),
-                'dependencies': ["❌ Module not found"]
-            })
-    
+        driver_info = _get_single_driver_info(module_path, class_name)
+        drivers.append(driver_info)
+
     return drivers
 
 
-def handle_list_drivers(args=None):
-    """List all available LLM drivers with their status and dependencies."""
-    drivers = get_driver_info()
-    
-    if not drivers:
-        console.print("[red]No drivers found[/red]")
-        return
-    
-    # Create table
+def _create_driver_table(drivers):
+    """Create and populate the drivers table."""
     table = Table(title="Available LLM Drivers")
     table.add_column("Driver", style="cyan", no_wrap=True)
     table.add_column("Status", style="bold")
     table.add_column("Dependencies", style="yellow")
-    
+
     for driver in drivers:
-        name = driver['name']
-        
-        if driver['available']:
+        name = driver["name"]
+
+        if driver["available"]:
             status = "[green]✅ Available[/green]"
-            if driver['reason']:
+            if driver["reason"]:
                 status = f"[yellow]⚠️ Available ({driver['reason']})[/yellow]"
         else:
             status = f"[red]❌ Unavailable[/red]"
-            if driver['reason']:
+            if driver["reason"]:
                 status = f"[red]❌ {driver['reason']}[/red]"
-        
-        deps = "\n".join(driver['dependencies'])
-        
+
+        deps = "\n".join(driver["dependencies"])
         table.add_row(name, status, deps)
-    
-    console.print(table)
-    
-    # Installation help
-    # Get unique missing dependencies
-    missing_deps = set()
+
+    return table
+
+
+def _get_missing_dependencies(drivers):
+    """Get list of missing dependencies."""
+    missing_deps = []
     for driver in drivers:
-        for dep_status in driver['dependencies']:
-            if dep_status.startswith('❌'):
-                missing_deps.add(dep_status[2:].strip())
-    
+        for dep_status in driver["dependencies"]:
+            if dep_status.startswith("❌"):
+                dep_name = dep_status.split()[1]
+                if dep_name not in missing_deps:
+                    missing_deps.append(dep_name)
+    return missing_deps
+
+
+def handle_list_drivers(args=None):
+    """List all available LLM drivers with their status and dependencies."""
+    drivers = get_driver_info()
+
+    if not drivers:
+        console.print("[red]No drivers found[/red]")
+        return
+
+    table = _create_driver_table(drivers)
+    console.print(table)
+
+    # Installation help - only show for missing dependencies
+    missing_deps = _get_missing_dependencies(drivers)
     if missing_deps:
-        console.print(f"\n[dim]💡 Install missing deps: pip install {' '.join(sorted(missing_deps))}[/dim]")
+        console.print(
+            f"\n[dim]💡 Install missing deps: pip install {' '.join(missing_deps)}[/dim]"
+        )
 
 
 if __name__ == "__main__":
-    handle_list_drivers()
+    handle_list_drivers()

janito/cli/cli_commands/list_providers_region.py

@@ -0,0 +1,85 @@
+"""
+CLI Command: List providers with their regional API information
+"""
+
+import json
+from typing import Dict, List
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from janito.regions.provider_regions import PROVIDER_REGIONS, get_all_providers
+from janito.regions.geo_utils import get_region_info
+
+console = Console()
+
+
+def handle_list_providers_region(args=None):
+    """List all providers with their regional API information."""
+
+    # Get user location info
+    user_info = get_region_info()
+    user_region = user_info["major_region"]
+
+    # Get all providers
+    providers = get_all_providers()
+
+    # Create table
+    table = Table(title="LLM Providers by Region")
+    table.add_column("Provider", style="cyan", no_wrap=True)
+    table.add_column("Region", style="green")
+    table.add_column("Endpoint", style="bright_white")
+
+    for provider in sorted(providers):
+        regions = PROVIDER_REGIONS.get(provider, [])
+        if not regions:
+            table.add_row(provider, "N/A", "N/A", "N/A", "N/A")
+            continue
+
+        # Find the best region for the user
+        best_region = None
+        for region in regions:
+            if region.region_code.startswith(user_region):
+                best_region = region
+                break
+
+        # If no exact match, use first available
+        if not best_region:
+            best_region = regions[0]
+
+        # Extract 2-letter region code
+        if provider == "azure-openai":
+            region_code = "ALL"
+        else:
+            region_code = (
+                user_region
+                if any(r.region_code.startswith(user_region) for r in regions)
+                else (
+                    "APAC"
+                    if best_region.region_code == "ASIA-PACIFIC"
+                    else best_region.region_code[:2]
+                )
+            )
+
+        table.add_row(
+            provider,
+            region_code,
+            best_region.endpoint,
+        )
+
+    console.print(table)
+
+    # Show user location info
+    console.print(
+        f"\n[dim]Your location: {user_info['country_code']} ({user_region})[/dim]"
+    )
+    console.print(f"[dim]Detection source: {user_info['source']}[/dim]")
+
+    # Show region mapping info
+    console.print(
+        "\n[dim]Regions: US (United States), EU (Europe), CN (China), CH (Switzerland), APAC (Asia Pacific)[/dim]"
+    )
+
+
+if __name__ == "__main__":
+    handle_list_providers_region()

janito/cli/core/getters.py

@@ -8,6 +8,8 @@ from janito.cli.cli_commands.list_tools import handle_list_tools
 from janito.cli.cli_commands.show_config import handle_show_config
 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 functools import partial
 from janito.provider_registry import ProviderRegistry
 
@@ -19,6 +21,8 @@ GETTER_KEYS = [
     "list_tools",
     "list_config",
     "list_drivers",
+    "region_info",
+    "list_providers_region",
 ]
 
 
@@ -45,9 +49,9 @@ def handle_getter(args, config_mgr=None):
         "show_config": partial(handle_show_config, args),
         "list_config": partial(handle_list_config, args),
         "list_drivers": partial(handle_list_drivers, args),
+        "region_info": partial(handle_region_info, args),
+        "list_providers_region": partial(handle_list_providers_region, args),
     }
     for arg in GETTER_KEYS:
         if getattr(args, arg, False) and arg in GETTER_DISPATCH:
-            GETTER_DISPATCH[arg]()
-            import sys
-            sys.exit(0)
+            return GETTER_DISPATCH[arg]()

janito/cli/main_cli.py

@@ -36,6 +36,13 @@ definition = [
             "default": None,
         },
     ),
+    (
+        ["--python"],
+        {
+            "action": "store_true",
+            "help": "Start with the Python developer profile (equivalent to --profile 'Developer with Python Tools')",
+        },
+    ),
     (
         ["--role"],
         {
@@ -119,7 +126,24 @@ definition = [
     ),
     (
         ["--list-drivers"],
-        {"action": "store_true", "help": "List available LLM drivers and their dependencies"},
+        {
+            "action": "store_true",
+            "help": "List available LLM drivers and their dependencies",
+        },
+    ),
+    (
+        ["--region-info"],
+        {
+            "action": "store_true",
+            "help": "Show current region information and location",
+        },
+    ),
+    (
+        ["--list-providers-region"],
+        {
+            "action": "store_true",
+            "help": "List all providers with their regional API information",
+        },
     ),
     (
         ["-l", "--list-models"],
@@ -192,6 +216,7 @@ MODIFIER_KEYS = [
     "model",
     "role",
     "profile",
+    "python",
     "system",
     "temperature",
     "verbose",
@@ -211,6 +236,8 @@ GETTER_KEYS = [
     "list_tools",
     "list_config",
     "list_drivers",
+    "region_info",
+    "list_providers_region",
 ]
 
 
@@ -327,7 +354,14 @@ class JanitoCLI:
             if self._run_set_mode():
                 return
         # Special handling: provider is not required for list_providers, list_tools, show_config, list_drivers
-        if run_mode == RunMode.GET:
+        if run_mode == RunMode.GET and (
+            self.args.list_providers
+            or self.args.list_tools
+            or self.args.list_profiles
+            or self.args.show_config
+            or self.args.list_config
+            or self.args.list_drivers
+        ):
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)
             return
@@ -363,7 +397,8 @@ class JanitoCLI:
                 agent_role,
                 verbose_tools=self.args.verbose_tools,
             )
-
+        elif run_mode == RunMode.GET:
+            handle_getter(self.args)
 
     def _run_set_mode(self):
         if handle_api_key_set(self.args):

janito/cli/single_shot_mode/handler.py

@@ -24,6 +24,11 @@ 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
+        profile = getattr(args, "profile", None)
+        if profile is None and getattr(args, "python", False):
+            profile = "Developer with Python Tools"
+
         self.agent, self.generic_handler = setup_agent_and_prompt_handler(
             args=args,
             provider_instance=provider_instance,
@@ -32,7 +37,7 @@ class PromptHandler:
             verbose_tools=getattr(args, "verbose_tools", False),
             verbose_agent=getattr(args, "verbose_agent", False),
             allowed_permissions=allowed_permissions,
-            profile=getattr(args, "profile", None),
+            profile=profile,
         )
 
     def handle(self) -> None:
@@ -52,6 +57,43 @@ class PromptHandler:
 
         try:
             start_time = time.time()
+
+            # Print rule line with model info before processing prompt
+            model_name = (
+                self.agent.get_model_name()
+                if hasattr(self.agent, "get_model_name")
+                else "Unknown"
+            )
+            provider_name = (
+                self.agent.get_provider_name()
+                if hasattr(self.agent, "get_provider_name")
+                else "Unknown"
+            )
+
+            # Get backend hostname if available
+            backend_hostname = "Unknown"
+            if hasattr(self.agent, "driver") and self.agent.driver:
+                if hasattr(self.agent.driver, "config") and hasattr(
+                    self.agent.driver.config, "base_url"
+                ):
+                    base_url = self.agent.driver.config.base_url
+                    if base_url:
+                        try:
+                            from urllib.parse import urlparse
+
+                            parsed = urlparse(base_url)
+                            backend_hostname = parsed.netloc
+                        except Exception:
+                            backend_hostname = base_url
+
+            from rich.rule import Rule
+
+            shared_console.print(
+                Rule(
+                    f"[bold blue]Model: {model_name} ({provider_name}) | Backend: {backend_hostname}[/bold blue]"
+                )
+            )
+
             self.generic_handler.handle_prompt(
                 sanitized,
                 args=self.args,

janito/drivers/azure_openai/driver.py

@@ -6,6 +6,16 @@ from janito.llm.driver_config import LLMDriverConfig
 
 
 class AzureOpenAIModelDriver(OpenAIModelDriver):
+    # Check if required dependencies are available
+    try:
+        from openai import AzureOpenAI
+
+        available = True
+        unavailable_reason = None
+    except ImportError as e:
+        available = False
+        unavailable_reason = f"Missing dependency: {str(e)}"
+
     def start(self, *args, **kwargs):
         # Ensure azure_deployment_name is set before starting
         config = getattr(self, "config", None)
@@ -64,11 +74,10 @@ class AzureOpenAIModelDriver(OpenAIModelDriver):
     def _instantiate_openai_client(self, config):
         try:
             if not config.api_key:
-                provider_name = getattr(self, 'provider_name', 'Azure OpenAI')
-                print(f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:")
-                print(f"  janito --set-api-key YOUR_API_KEY -p azure-openai")
-                print(f"Or set the AZURE_OPENAI_API_KEY environment variable.")
-                raise ValueError(f"API key is required for provider '{provider_name}'")
+                provider_name = getattr(self, "provider_name", "Azure OpenAI")
+                from janito.llm.auth_utils import handle_missing_api_key
+
+                handle_missing_api_key(provider_name, "AZURE_OPENAI_API_KEY")
 
             from openai import AzureOpenAI
 

janito/drivers/openai/driver.py

@@ -16,6 +16,16 @@ import openai
 
 
 class OpenAIModelDriver(LLMDriver):
+    # Check if required dependencies are available
+    try:
+        import openai
+
+        available = True
+        unavailable_reason = None
+    except ImportError as e:
+        available = False
+        unavailable_reason = f"Missing dependency: {str(e)}"
+
     def _get_message_from_result(self, result):
         """Extract the message object from the provider result (OpenAI-specific)."""
         if hasattr(result, "choices") and result.choices:
@@ -248,11 +258,12 @@ class OpenAIModelDriver(LLMDriver):
     def _instantiate_openai_client(self, config):
         try:
             if not config.api_key:
-                provider_name = getattr(self, 'provider_name', 'OpenAI-compatible')
-                print(f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:")
-                print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name.lower()}")
-                print(f"Or set the {provider_name.upper()}_API_KEY environment variable.")
-                raise ValueError(f"API key is required for provider '{provider_name}'")
+                provider_name = getattr(self, "provider_name", "OpenAI-compatible")
+                from janito.llm.auth_utils import handle_missing_api_key
+
+                handle_missing_api_key(
+                    provider_name, f"{provider_name.upper()}_API_KEY"
+                )
 
             api_key_display = str(config.api_key)
             if api_key_display and len(api_key_display) > 8: