janito 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

janito/cli/cli_commands/list_tools.py

@@ -1,53 +1,53 @@
-"""
-CLI Command: List available tools
-"""
-
-
-def handle_list_tools(args=None):
-    from janito.tools.adapters.local.adapter import LocalToolsAdapter
-    import janito.tools  # Ensure all tools are registered
-
-    registry = janito.tools.get_local_tools_adapter()
-    tools = registry.list_tools()
-    if tools:
-        from rich.table import Table
-        from rich.console import Console
-        console = Console()
-        # Get tool instances to check provides_execution and get info
-        tool_instances = {t.tool_name: t for t in registry.get_tools()}
-        normal_tools = []
-        exec_tools = []
-        for tool in tools:
-            inst = tool_instances.get(tool, None)
-            # Extract parameter names from run signature
-            param_names = []
-            if inst and hasattr(inst, "run"):
-                import inspect
-                sig = inspect.signature(inst.run)
-                param_names = [p for p in sig.parameters if p != "self"]
-            info = {
-                "name": tool,
-                "params": ", ".join(param_names),
-            }
-            if getattr(inst, "provides_execution", False):
-                exec_tools.append(info)
-            else:
-                normal_tools.append(info)
-        table = Table(title="Registered tools", show_header=True, header_style="bold", show_lines=False, box=None)
-        table.add_column("Name", style="cyan", no_wrap=True)
-        table.add_column("Parameters", style="yellow")
-        for info in normal_tools:
-            table.add_row(info["name"], info["params"] or "-")
-        console.print(table)
-        if exec_tools:
-            exec_table = Table(title="Execution tools (only available with -x)", show_header=True, header_style="bold", show_lines=False, box=None)
-            exec_table.add_column("Name", style="cyan", no_wrap=True)
-            exec_table.add_column("Parameters", style="yellow")
-            for info in exec_tools:
-                exec_table.add_row(info["name"], info["params"] or "-")
-            console.print(exec_table)
-    else:
-        print("No tools registered.")
-    import sys
-
-    sys.exit(0)
+"""
+CLI Command: List available tools
+"""
+
+
+def handle_list_tools(args=None):
+    from janito.tools.adapters.local.adapter import LocalToolsAdapter
+    import janito.tools  # Ensure all tools are registered
+
+    registry = janito.tools.get_local_tools_adapter()
+    tools = registry.list_tools()
+    if tools:
+        from rich.table import Table
+        from rich.console import Console
+        console = Console()
+        # Get tool instances to check provides_execution and get info
+        tool_instances = {t.tool_name: t for t in registry.get_tools()}
+        normal_tools = []
+        exec_tools = []
+        for tool in tools:
+            inst = tool_instances.get(tool, None)
+            # Extract parameter names from run signature
+            param_names = []
+            if inst and hasattr(inst, "run"):
+                import inspect
+                sig = inspect.signature(inst.run)
+                param_names = [p for p in sig.parameters if p != "self"]
+            info = {
+                "name": tool,
+                "params": ", ".join(param_names),
+            }
+            if getattr(inst, "provides_execution", False):
+                exec_tools.append(info)
+            else:
+                normal_tools.append(info)
+        table = Table(title="Registered tools", show_header=True, header_style="bold", show_lines=False, box=None)
+        table.add_column("Name", style="cyan", no_wrap=True)
+        table.add_column("Parameters", style="yellow")
+        for info in normal_tools:
+            table.add_row(info["name"], info["params"] or "-")
+        console.print(table)
+        if exec_tools:
+            exec_table = Table(title="Execution tools (only available with -x)", show_header=True, header_style="bold", show_lines=False, box=None)
+            exec_table.add_column("Name", style="cyan", no_wrap=True)
+            exec_table.add_column("Parameters", style="yellow")
+            for info in exec_tools:
+                exec_table.add_row(info["name"], info["params"] or "-")
+            console.print(exec_table)
+    else:
+        print("No tools registered.")
+    import sys
+
+    sys.exit(0)

janito/cli/cli_commands/model_selection.py

@@ -1,50 +1,50 @@
-"""
-CLI Command: Validate and set the model provider selection
-"""
-
-from janito.cli.config import config
-
-_provider_instance = None
-
-
-def get_provider_instance():
-    global _provider_instance
-    if _provider_instance is None:
-        _provider_instance = setup_provider()
-    return _provider_instance
-
-
-def handle_model_selection(args):
-    if getattr(args, "model", None):
-        provider_instance = get_provider_instance()
-        provider_name = getattr(provider_instance, "name", None)
-        if not provider_name:
-            print(
-                "Error: Provider must be specified with --provider or set as default before selecting a model."
-            )
-            import sys
-
-            sys.exit(1)
-        if not validate_model_for_provider(provider_name, args.model):
-            sys.exit(1)
-        config.runtime_set("model", args.model)
-
-
-def validate_model_for_provider(provider_name, model_name):
-    try:
-        provider_instance = get_provider_instance()
-        info_dict = provider_instance.get_model_info()
-        available_names = [
-            m["name"] for m in info_dict.values() if isinstance(m, dict) and "name" in m
-        ]
-        if model_name in available_names:
-            return True
-        else:
-            print(
-                f"Error: Model '{model_name}' is not available for provider '{provider_name}'."
-            )
-            print(f"Available models: {', '.join(available_names)}")
-            return False
-    except Exception as e:
-        print(f"Error validating model for provider '{provider_name}': {e}")
-        return False
+"""
+CLI Command: Validate and set the model provider selection
+"""
+
+from janito.cli.config import config
+
+_provider_instance = None
+
+
+def get_provider_instance():
+    global _provider_instance
+    if _provider_instance is None:
+        _provider_instance = setup_provider()
+    return _provider_instance
+
+
+def handle_model_selection(args):
+    if getattr(args, "model", None):
+        provider_instance = get_provider_instance()
+        provider_name = getattr(provider_instance, "name", None)
+        if not provider_name:
+            print(
+                "Error: Provider must be specified with --provider or set as default before selecting a model."
+            )
+            import sys
+
+            sys.exit(1)
+        if not validate_model_for_provider(provider_name, args.model):
+            sys.exit(1)
+        config.runtime_set("model", args.model)
+
+
+def validate_model_for_provider(provider_name, model_name):
+    try:
+        provider_instance = get_provider_instance()
+        info_dict = provider_instance.get_model_info()
+        available_names = [
+            m["name"] for m in info_dict.values() if isinstance(m, dict) and "name" in m
+        ]
+        if model_name in available_names:
+            return True
+        else:
+            print(
+                f"Error: Model '{model_name}' is not available for provider '{provider_name}'."
+            )
+            print(f"Available models: {', '.join(available_names)}")
+            return False
+    except Exception as e:
+        print(f"Error validating model for provider '{provider_name}': {e}")
+        return False

janito/cli/cli_commands/model_utils.py

@@ -34,8 +34,19 @@ def _print_models_table(models, provider_name):
         row = [str(m.get("name", ""))]
         row.extend(_build_model_row(m, headers, num_fields))
         table.add_row(*row)
-    console = Console()
-    console.print(table)
+    import sys
+    if sys.stdout.isatty():
+        from rich.console import Console
+        Console().print(table)
+    else:
+        # ASCII-friendly fallback table when output is redirected
+        print(f"Supported models for provider '{provider_name}'")
+        headers_fallback = [h for h in display_headers]
+        print(' | '.join(headers_fallback))
+        for m in models:
+            row = [str(m.get('name', ''))]
+            row.extend(_build_model_row(m, headers, num_fields))
+            print(' | '.join(row))
 
 
 def _add_table_columns(table, display_headers):

janito/cli/cli_commands/set_api_key.py

@@ -1,19 +1,19 @@
-"""
-CLI Command: Set API key for the current or selected provider
-"""
-
-from janito.provider_config import set_api_key
-from janito.llm.auth import LLMAuthManager
-
-
-def handle_set_api_key(args):
-    api_key = getattr(args, "set_api_key", None)
-    provider = getattr(args, "provider", None)
-    if not provider:
-        print("Error: --set-api-key requires -p/--provider to be specified.")
-        return
-    set_api_key(provider, api_key)
-    auth_manager = LLMAuthManager()
-    print(
-        f"API key set for provider '{provider}'. Auth file updated: {auth_manager._auth_file}"
-    )
+"""
+CLI Command: Set API key for the current or selected provider
+"""
+
+from janito.provider_config import set_api_key
+from janito.llm.auth import LLMAuthManager
+
+
+def handle_set_api_key(args):
+    api_key = getattr(args, "set_api_key", None)
+    provider = getattr(args, "provider", None)
+    if not provider:
+        print("Error: --set-api-key requires -p/--provider to be specified.")
+        return
+    set_api_key(provider, api_key)
+    auth_manager = LLMAuthManager()
+    print(
+        f"API key set for provider '{provider}'. Auth file updated: {auth_manager._auth_file}"
+    )

janito/cli/cli_commands/show_config.py

@@ -1,51 +1,51 @@
-from rich.console import Console
-from rich.pretty import Pretty
-
-from janito.config import config
-from janito.cli.config import CONFIG_OPTIONS
-
-
-def resolve_effective_model(provider_name):
-    # Try provider-specific model, then global model, then provider default
-    provider_cfg = config.get_provider_config(provider_name)
-    model = provider_cfg.get("model") if provider_cfg else None
-    if not model:
-        model = config.get("model")
-    if not model:
-        try:
-            from janito.provider_registry import ProviderRegistry
-
-            provider_class = ProviderRegistry().get_provider(provider_name)
-            model = getattr(provider_class, "DEFAULT_MODEL", None)
-        except Exception:
-            model = None
-    return model
-
-
-def handle_show_config(args):
-    console = Console()
-    provider = config.get("provider")
-    model = config.get("model")
-    # Show all providers with their effective model
-    from janito.provider_registry import ProviderRegistry
-
-    provider_names = []
-    try:
-        provider_names = ProviderRegistry()._get_provider_names()
-    except Exception:
-        pass
-    console.print("[bold green]Current configuration:[/bold green]")
-    console.print(f"[bold yellow]Current provider:[/bold yellow] {provider!r}\n")
-    if model is not None:
-        console.print(f"[bold yellow]Global model:[/bold yellow] {model!r}\n")
-    if provider_names:
-        console.print("[bold cyan]Provider specific default models:[/bold cyan]")
-        for pname in provider_names:
-            eff_model = resolve_effective_model(pname)
-            prov_cfg = config.get_provider_config(pname)
-            prov_model = prov_cfg.get("model") if prov_cfg else None
-            extra = f" (override)" if prov_model else ""
-            sel = "[default]" if pname == provider else ""
-            console.print(
-                f"  [bold]{pname}[/bold]{' '+sel if sel else ''}: model = [magenta]{eff_model}[/magenta]{extra}"
-            )
+from rich.console import Console
+from rich.pretty import Pretty
+
+from janito.config import config
+from janito.cli.config import CONFIG_OPTIONS
+
+
+def resolve_effective_model(provider_name):
+    # Try provider-specific model, then global model, then provider default
+    provider_cfg = config.get_provider_config(provider_name)
+    model = provider_cfg.get("model") if provider_cfg else None
+    if not model:
+        model = config.get("model")
+    if not model:
+        try:
+            from janito.provider_registry import ProviderRegistry
+
+            provider_class = ProviderRegistry().get_provider(provider_name)
+            model = getattr(provider_class, "DEFAULT_MODEL", None)
+        except Exception:
+            model = None
+    return model
+
+
+def handle_show_config(args):
+    console = Console()
+    provider = config.get("provider")
+    model = config.get("model")
+    # Show all providers with their effective model
+    from janito.provider_registry import ProviderRegistry
+
+    provider_names = []
+    try:
+        provider_names = ProviderRegistry()._get_provider_names()
+    except Exception:
+        pass
+    console.print("[bold green]Current configuration:[/bold green]")
+    console.print(f"[bold yellow]Current provider:[/bold yellow] {provider!r}\n")
+    if model is not None:
+        console.print(f"[bold yellow]Global model:[/bold yellow] {model!r}\n")
+    if provider_names:
+        console.print("[bold cyan]Provider specific default models:[/bold cyan]")
+        for pname in provider_names:
+            eff_model = resolve_effective_model(pname)
+            prov_cfg = config.get_provider_config(pname)
+            prov_model = prov_cfg.get("model") if prov_cfg else None
+            extra = f" (override)" if prov_model else ""
+            sel = "[default]" if pname == provider else ""
+            console.print(
+                f"  [bold]{pname}[/bold]{' '+sel if sel else ''}: model = [magenta]{eff_model}[/magenta]{extra}"
+            )

janito/cli/cli_commands/show_system_prompt.py

@@ -1,62 +1,62 @@
-"""
-CLI Command: Show the resolved system prompt for the main agent (single-shot mode)
-"""
-
-from janito.cli.core.runner import prepare_llm_driver_config
-from janito.platform_discovery import PlatformDiscovery
-from pathlib import Path
-from jinja2 import Template
-import importlib.resources
-
-
-def handle_show_system_prompt(args):
-    # Collect modifiers as in JanitoCLI
-    from janito.cli.main_cli import MODIFIER_KEYS
-
-    modifiers = {
-        k: getattr(args, k) for k in MODIFIER_KEYS if getattr(args, k, None) is not None
-    }
-    provider, llm_driver_config, agent_role = prepare_llm_driver_config(args, modifiers)
-    if provider is None or llm_driver_config is None:
-        print("Error: Could not resolve provider or LLM driver config.")
-        return
-
-    # Prepare context for Jinja2 rendering
-    context = {}
-    context["role"] = agent_role or "software developer"
-    pd = PlatformDiscovery()
-    context["platform"] = pd.get_platform_name()
-    context["python_version"] = pd.get_python_version()
-    context["shell_info"] = pd.detect_shell()
-
-    # Locate and load the system prompt template
-    templates_dir = (
-        Path(__file__).parent.parent.parent / "agent" / "templates" / "profiles"
-    )
-    template_path = templates_dir / "system_prompt_template_main.txt.j2"
-    template_content = None
-    if template_path.exists():
-        with open(template_path, "r", encoding="utf-8") as file:
-            template_content = file.read()
-    else:
-        # Try package import fallback
-        try:
-            with importlib.resources.files("janito.agent.templates.profiles").joinpath(
-                "system_prompt_template_main.txt.j2"
-            ).open("r", encoding="utf-8") as file:
-                template_content = file.read()
-        except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            print(
-                f"[janito] Could not find system_prompt_template_main.txt.j2 in {template_path} nor in janito.agent.templates.profiles package."
-            )
-            print("No system prompt is set or resolved for this configuration.")
-            return
-
-    template = Template(template_content)
-    system_prompt = template.render(**context)
-
-    print("\n--- System Prompt (resolved) ---\n")
-    print(system_prompt)
-    print("\n-------------------------------\n")
-    if agent_role:
-        print(f"[Role: {agent_role}]")
+"""
+CLI Command: Show the resolved system prompt for the main agent (single-shot mode)
+"""
+
+from janito.cli.core.runner import prepare_llm_driver_config
+from janito.platform_discovery import PlatformDiscovery
+from pathlib import Path
+from jinja2 import Template
+import importlib.resources
+
+
+def handle_show_system_prompt(args):
+    # Collect modifiers as in JanitoCLI
+    from janito.cli.main_cli import MODIFIER_KEYS
+
+    modifiers = {
+        k: getattr(args, k) for k in MODIFIER_KEYS if getattr(args, k, None) is not None
+    }
+    provider, llm_driver_config, agent_role = prepare_llm_driver_config(args, modifiers)
+    if provider is None or llm_driver_config is None:
+        print("Error: Could not resolve provider or LLM driver config.")
+        return
+
+    # Prepare context for Jinja2 rendering
+    context = {}
+    context["role"] = agent_role or "software developer"
+    pd = PlatformDiscovery()
+    context["platform"] = pd.get_platform_name()
+    context["python_version"] = pd.get_python_version()
+    context["shell_info"] = pd.detect_shell()
+
+    # Locate and load the system prompt template
+    templates_dir = (
+        Path(__file__).parent.parent.parent / "agent" / "templates" / "profiles"
+    )
+    template_path = templates_dir / "system_prompt_template_main.txt.j2"
+    template_content = None
+    if template_path.exists():
+        with open(template_path, "r", encoding="utf-8") as file:
+            template_content = file.read()
+    else:
+        # Try package import fallback
+        try:
+            with importlib.resources.files("janito.agent.templates.profiles").joinpath(
+                "system_prompt_template_main.txt.j2"
+            ).open("r", encoding="utf-8") as file:
+                template_content = file.read()
+        except (FileNotFoundError, ModuleNotFoundError, AttributeError):
+            print(
+                f"[janito] Could not find system_prompt_template_main.txt.j2 in {template_path} nor in janito.agent.templates.profiles package."
+            )
+            print("No system prompt is set or resolved for this configuration.")
+            return
+
+    template = Template(template_content)
+    system_prompt = template.render(**context)
+
+    print("\n--- System Prompt (resolved) ---\n")
+    print(system_prompt)
+    print("\n-------------------------------\n")
+    if agent_role:
+        print(f"[Role: {agent_role}]")

janito/cli/config.py

@@ -3,8 +3,9 @@ from janito.config import config
 CONFIG_OPTIONS = {
     "api_key": "API key for OpenAI-compatible service (required)",  # pragma: allowlist secret
     "trust": "Trust mode: suppress all console output (bool, default: False)",
-    "model": "Model name to use (e.g., 'gpt-4.1', 'gpt-4o', 'gpt-4-turbo', 'o3-mini', 'o4-mini')",
+    "model": "Model name to use (e.g., 'gpt-4.1', 'gpt-4o', 'gpt-4-turbo', 'o3-mini', 'o4-mini', 'gemini-2.5-flash')",
     "base_url": "API base URL (OpenAI-compatible endpoint)",
+    "azure_deployment_name": "Azure OpenAI deployment name (for Azure endpoints)",
     "role": "Role description for the Agent Profile (e.g., 'software engineer')",
     "temperature": "Sampling temperature (float, e.g., 0.0 - 2.0)",
     "max_tokens": "Maximum tokens for model response (int)",

janito/cli/core/__init__.py

@@ -1,4 +1,4 @@
-"""
-Core logic, handler classes, and utilities for the main Janito CLI orchestration and sub-command processing.
-Contains modules for setters, getters, event logger, and runner pipelines.
-"""
+"""
+Core logic, handler classes, and utilities for the main Janito CLI orchestration and sub-command processing.
+Contains modules for setters, getters, event logger, and runner pipelines.
+"""

janito/cli/core/event_logger.py

@@ -1,59 +1,59 @@
-"""Stub implementation of EventLogger for the CLI event logging system."""
-
-
-class EventLogger:
-    def __init__(self, debug=False):
-        self.debug = debug
-
-    def subscribe(self, event_name, callback):
-        if self.debug:
-            pass  # Add debug subscribe output if needed
-        # No real subscription logic
-
-    def submit(self, event_name, payload=None):
-        if self.debug:
-            pass  # Add debug submit output if needed
-        # No real submission logic
-
-
-def setup_event_logger(args):
-    debug = getattr(args, "event_debug", False)
-    event_logger = EventLogger(debug=debug)
-    print("[EventLog] Event logger is now active (stub implementation)")
-    return event_logger
-
-
-def setup_event_logger_if_needed(args):
-    if getattr(args, "event_log", False):
-        print("[EventLog] Setting up event logger with system bus...")
-        event_logger = setup_event_logger(args)
-        from janito.event_bus import event_bus
-
-        def event_logger_handler(event):
-            from janito.cli.console import shared_console
-            from rich.pretty import Pretty
-            from datetime import datetime
-
-            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            shared_console.print(
-                f"[EventLog] [dim]{timestamp}[/] [bold green]{event.__class__.__name__}[/] | [cyan]{getattr(event, 'category', '')}[/]"
-            )
-            shared_console.print(Pretty(event, expand_all=True))
-            shared_console.file.flush()
-
-        from janito.event_bus.event import Event
-
-        event_bus.subscribe(Event, event_logger_handler)
-
-
-def inject_debug_event_bus_if_needed(args):
-    if getattr(args, "event_debug", False):
-        from janito.event_bus import event_bus
-
-        orig_publish = event_bus.publish
-
-        def debug_publish(event):
-            # You can enrich here if needed
-            return orig_publish(event)
-
-        event_bus.publish = debug_publish
+"""Stub implementation of EventLogger for the CLI event logging system."""
+
+
+class EventLogger:
+    def __init__(self, debug=False):
+        self.debug = debug
+
+    def subscribe(self, event_name, callback):
+        if self.debug:
+            pass  # Add debug subscribe output if needed
+        # No real subscription logic
+
+    def submit(self, event_name, payload=None):
+        if self.debug:
+            pass  # Add debug submit output if needed
+        # No real submission logic
+
+
+def setup_event_logger(args):
+    debug = getattr(args, "event_debug", False)
+    event_logger = EventLogger(debug=debug)
+    print("[EventLog] Event logger is now active (stub implementation)")
+    return event_logger
+
+
+def setup_event_logger_if_needed(args):
+    if getattr(args, "event_log", False):
+        print("[EventLog] Setting up event logger with system bus...")
+        event_logger = setup_event_logger(args)
+        from janito.event_bus import event_bus
+
+        def event_logger_handler(event):
+            from janito.cli.console import shared_console
+            from rich.pretty import Pretty
+            from datetime import datetime
+
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            shared_console.print(
+                f"[EventLog] [dim]{timestamp}[/] [bold green]{event.__class__.__name__}[/] | [cyan]{getattr(event, 'category', '')}[/]"
+            )
+            shared_console.print(Pretty(event, expand_all=True))
+            shared_console.file.flush()
+
+        from janito.event_bus.event import Event
+
+        event_bus.subscribe(Event, event_logger_handler)
+
+
+def inject_debug_event_bus_if_needed(args):
+    if getattr(args, "event_debug", False):
+        from janito.event_bus import event_bus
+
+        orig_publish = event_bus.publish
+
+        def debug_publish(event):
+            # You can enrich here if needed
+            return orig_publish(event)
+
+        event_bus.publish = debug_publish