janito 1.14.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/cli/config.py

@@ -0,0 +1,28 @@
+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', 'o4-mini-high')",
+    "base_url": "API base URL (OpenAI-compatible endpoint)",
+    "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)",
+    "use_azure_openai": "Whether to use Azure OpenAI client (default: False)",
+    "template": "Template context dictionary for Agent Profile prompt rendering (nested)",
+    "profile": "Agent Profile name (only 'base' is supported)",
+}
+
+DEFAULT_TERMWEB_PORT = 8088
+
+
+def get_termweb_port():
+    port = config.get("termweb_port")
+    try:
+        return int(port)
+    except Exception:
+        return DEFAULT_TERMWEB_PORT
+
+
+def set_termweb_port(port):
+    config.file_set("termweb_port", int(port))

janito/cli/console.py

@@ -0,0 +1,3 @@
+from rich.console import Console
+
+shared_console = Console()

janito/cli/core/__init__.py

@@ -0,0 +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.
+"""

janito/cli/core/event_logger.py

@@ -0,0 +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

janito/cli/core/getters.py

@@ -0,0 +1,31 @@
+"""Handlers for get-type CLI commands (show_config, list_providers, models, tools)."""
+
+from janito.cli.cli_commands.list_providers import handle_list_providers
+from janito.cli.cli_commands.list_models import handle_list_models
+from janito.cli.cli_commands.list_tools import handle_list_tools
+from janito.cli.cli_commands.show_config import handle_show_config
+from functools import partial
+from janito.provider_registry import ProviderRegistry
+
+GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
+
+
+def handle_getter(args, config_mgr=None):
+    provider_instance = None
+    if getattr(args, "list_models", False):
+        provider = getattr(args, "provider", None)
+        if not provider:
+            print(
+                "Error: No provider selected. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
+            )
+            return
+        provider_instance = ProviderRegistry().get_instance(provider)
+    GETTER_DISPATCH = {
+        "list_providers": partial(handle_list_providers, args),
+        "list_models": partial(handle_list_models, args, provider_instance),
+        "list_tools": partial(handle_list_tools, args),
+        "show_config": partial(handle_show_config, args),
+    }
+    for arg in GETTER_KEYS:
+        if getattr(args, arg, False) and arg in GETTER_DISPATCH:
+            return GETTER_DISPATCH[arg]()

janito/cli/core/runner.py

@@ -0,0 +1,141 @@
+"""Handles LLM driver config preparation and execution modes."""
+
+from janito.llm.driver_config import LLMDriverConfig
+from janito.provider_config import get_config_provider
+from janito.cli.verbose_output import print_verbose_info
+
+
+def _choose_provider(args):
+    provider = getattr(args, "provider", None)
+    if provider is None:
+        provider = get_config_provider()
+        if provider and getattr(args, "verbose", False):
+            print_verbose_info(
+                "Default provider", provider, style="magenta", align_content=True
+            )
+        elif provider is None:
+            print(
+                "Error: No provider selected and no provider found in config. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
+            )
+            return None
+    return provider
+
+
+def _populate_driver_config_data(args, modifiers, provider, model):
+    from janito.provider_config import get_effective_setting
+
+    CONFIG_LOOKUP_KEYS = ("max_tokens", "base_url")
+    driver_config_data = {"model": model}
+    if getattr(args, "verbose_api", None) is not None:
+        driver_config_data["verbose_api"] = args.verbose_api
+    for field in LLMDriverConfig.__dataclass_fields__:
+        if field in CONFIG_LOOKUP_KEYS:
+            if field in modifiers and modifiers[field] is not None:
+                driver_config_data[field] = modifiers[field]
+            else:
+                value = get_effective_setting(provider, model, field)
+                if value is not None:
+                    driver_config_data[field] = value
+        elif field in modifiers and field != "model":
+            driver_config_data[field] = modifiers[field]
+    return driver_config_data
+
+
+def prepare_llm_driver_config(args, modifiers):
+    """Prepare the LLMDriverConfig instance based on CLI *args* and *modifiers*.
+
+    This helper additionally validates that the chosen ``--model`` (or the
+    resolved model coming from config precedence) is actually available for the
+    selected provider.  If the combination is invalid an error is printed and
+    ``None`` is returned for the config so that the caller can abort execution
+    gracefully.
+    """
+    provider = _choose_provider(args)
+    if provider is None:
+        return None, None, None
+    from janito.provider_config import get_effective_model
+
+    model = getattr(args, "model", None)
+    if not model:
+        model = get_effective_model(provider)
+
+    # Validate that the chosen model is supported by the selected provider
+    if model:
+        from janito.provider_registry import ProviderRegistry
+
+        provider_instance = None
+        try:
+            provider_instance = ProviderRegistry().get_instance(provider)
+            available_models = [
+                m["name"]
+                for m in provider_instance.get_model_info().values()
+                if isinstance(m, dict) and "name" in m
+            ]
+            if model not in available_models:
+                print(
+                    f"Error: Model '{model}' is not available for provider '{provider}'."
+                )
+                print(f"Available models: {', '.join(available_models)}")
+                return provider, None, None
+        except Exception as e:
+            print(f"Error validating model for provider '{provider}': {e}")
+            return provider, None, None
+    driver_config_data = _populate_driver_config_data(args, modifiers, provider, model)
+    llm_driver_config = LLMDriverConfig(**driver_config_data)
+    if getattr(llm_driver_config, "verbose_api", None):
+        pass
+    agent_role = modifiers.get("role", "software developer")
+    return provider, llm_driver_config, agent_role
+
+
+def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, exec_enabled=False):
+    """
+    Main runner for CLI execution. If exec_enabled is False, disables execution/run tools.
+    """
+    zero_mode = getattr(args, "zero", False)
+    from janito.provider_registry import ProviderRegistry
+
+    # Patch: disable execution/run tools if not enabled
+    if not exec_enabled:
+        import janito.tools
+        adapter = janito.tools.get_local_tools_adapter()
+        if hasattr(adapter, "disable_execution_tools"):
+            adapter.disable_execution_tools()
+    else:
+        pass
+
+    provider_instance = ProviderRegistry().get_instance(provider, llm_driver_config)
+    mode = get_prompt_mode(args)
+    if getattr(args, "verbose", False):
+        print_verbose_info(
+            "Active LLMDriverConfig (after provider)", llm_driver_config, style="green"
+        )
+        print_verbose_info("Agent role", agent_role, style="green")
+    if mode == "single_shot":
+        from janito.cli.single_shot_mode.handler import (
+            PromptHandler as SingleShotPromptHandler,
+        )
+
+        handler = SingleShotPromptHandler(
+            args, provider_instance, llm_driver_config, role=agent_role
+        )
+        handler.handle()
+    else:
+        from janito.cli.chat_mode.session import ChatSession
+        from rich.console import Console
+
+        console = Console()
+        session = ChatSession(
+            console,
+            provider_instance,
+            llm_driver_config,
+            role=agent_role,
+            args=args,
+            verbose_tools=verbose_tools,
+            verbose_agent=getattr(args, "verbose_agent", False),
+        )
+        session.run()
+
+
+def get_prompt_mode(args):
+    return "single_shot" if getattr(args, "user_prompt", None) else "chat_mode"

janito/cli/core/setters.py

@@ -0,0 +1,174 @@
+"""Handlers for set-type CLI commands (provider, model, api keys, etc)."""
+
+from janito.provider_config import set_config_provider
+from janito.config import config as global_config
+from janito.provider_registry import ProviderRegistry
+from janito.cli.cli_commands.set_api_key import handle_set_api_key
+
+
+def handle_api_key_set(args):
+    if getattr(args, "set_api_key", None):
+        handle_set_api_key(args)
+        return True
+    return False
+
+
+def handle_set(args, config_mgr=None):
+    set_arg = getattr(args, "set", None)
+    if not set_arg:
+        return False
+    try:
+        if "=" not in set_arg:
+            print(
+                "Error: --set requires KEY=VALUE (e.g., --set provider=provider_name)."
+            )
+            return True
+        key, value = set_arg.split("=", 1)
+        key, value = key.strip(), value.strip()
+        key = key.replace("-", "_")
+
+        if key == "provider":
+            return _handle_set_config_provider(value)
+        if key == "model":
+            return _handle_set_global_model(value)
+        if "." in key and key.endswith(".model"):
+            return _handle_set_provider_model(key, value)
+        if key == "max_tokens":
+            return _handle_set_max_tokens(value)
+        if key == "base_url":
+            return _handle_set_base_url(value)
+        if ".max_tokens" in key or ".base_url" in key:
+            return _handle_set_provider_level_setting(key, value)
+        print(
+            f"Error: Unknown config key '{key}'. Supported: provider, model, <provider>.model, max_tokens, base_url, <provider>.max_tokens, <provider>.base_url, <provider>.<model>.max_tokens, <provider>.<model>.base_url"
+        )
+        return True
+    except Exception as e:
+        print(f"Error parsing --set value: {e}")
+        return True
+
+
+def _handle_set_max_tokens(value):
+    try:
+        ival = int(value)
+    except Exception:
+        print("Error: max_tokens must be set to an integer value.")
+        return True
+    global_config.file_set("max_tokens", ival)
+    print(f"Top-level max_tokens set to {ival}.")
+    return True
+
+
+def _handle_set_base_url(value):
+    global_config.file_set("base_url", value)
+    print(f"Top-level base_url set to {value}.")
+    return True
+
+
+def _handle_set_provider_level_setting(key, value):
+    parts = key.split(".")
+    if len(parts) == 2:
+        provider, par_key = parts
+        if par_key == "max_tokens":
+            try:
+                ival = int(value)
+            except Exception:
+                print("Error: max_tokens must be set to an integer value.")
+                return True
+            global_config.set_provider_config(provider, "max_tokens", ival)
+            print(f"max_tokens for provider '{provider}' set to {ival}.")
+            return True
+        if par_key == "base_url":
+            global_config.set_provider_config(provider, "base_url", value)
+            print(f"base_url for provider '{provider}' set to {value}.")
+            return True
+    elif len(parts) == 3:
+        provider, model, mk = parts
+        if mk == "max_tokens":
+            try:
+                ival = int(value)
+            except Exception:
+                print("Error: max_tokens must be set to an integer value.")
+                return True
+            global_config.set_provider_model_config(provider, model, "max_tokens", ival)
+            print(
+                f"max_tokens for provider '{provider}', model '{model}' set to {ival}."
+            )
+            return True
+        if mk == "base_url":
+            global_config.set_provider_model_config(provider, model, "base_url", value)
+            print(
+                f"base_url for provider '{provider}', model '{model}' set to {value}."
+            )
+            return True
+    print(
+        f"Error: Unknown config key '{key}'. Supported: provider, model, <provider>.model, max_tokens, base_url, <provider>.max_tokens, <provider>.base_url, <provider>.<model>.max_tokens, <provider>.<model>.base_url"
+    )
+    return True
+
+
+def _handle_set_config_provider(value):
+    try:
+        supported = ProviderRegistry().get_provider(value)
+    except Exception:
+        print(
+            f"Error: Provider '{value}' is not supported. Run '--list-providers' to see the supported list."
+        )
+        return True
+    from janito.provider_config import set_config_provider
+
+    set_config_provider(value)
+    print(f"Provider set to '{value}'.")
+    return True
+
+
+def _handle_set_provider_model(key, value):
+    provider_name, suffix = key.rsplit(".", 1)
+    if suffix != "model":
+        print(
+            f"Error: Only <provider>.model is supported for provider-specific model override. Not: '{key}'"
+        )
+        return True
+    try:
+        provider_cls = ProviderRegistry().get_provider(provider_name)
+        provider_instance = provider_cls()
+    except Exception:
+        print(
+            f"Error: Provider '{provider_name}' is not supported. Run '--list-providers' to see the supported list."
+        )
+        return True
+    model_info = provider_instance.get_model_info(value)
+    if not model_info:
+        print(
+            f"Error: Model '{value}' is not defined for provider '{provider_name}'. Run '-p {provider_name} -l' to see models."
+        )
+        return True
+    global_config.set_provider_config(provider_name, "model", value)
+    print(f"Default model for provider '{provider_name}' set to '{value}'.")
+    return True
+
+
+def _handle_set_global_model(value):
+    # Try to validate model choice (against current provider if possible)
+    provider_name = global_config.get("provider")
+    if provider_name:
+        try:
+            provider_cls = ProviderRegistry().get_provider(provider_name)
+            provider_instance = provider_cls()
+            model_info = provider_instance.get_model_info(value)
+            if not model_info:
+                print(
+                    f"Error: Model '{value}' is not defined for provider '{provider_name}'. Run '-p {provider_name} -l' to see models."
+                )
+                return True
+        except Exception:
+            print(
+                f"Warning: Could not validate model for provider '{provider_name}'. Setting anyway."
+            )
+    else:
+        print(
+            "Warning: No provider set. Model will be set globally, but may not be valid for any provider."
+        )
+    global_config.file_set("model", value)
+    print(f"Global default model set to '{value}'.")
+    return True

janito/cli/core/unsetters.py

@@ -0,0 +1,54 @@
+from janito.config import config as global_config
+
+
+def handle_unset(args):
+    unset_arg = getattr(args, "unset", None)
+    if not unset_arg:
+        return False
+    key = unset_arg.strip().replace("-", "_")
+    if "." in key:
+        # Provider or model-specific keys
+        parts = key.split(".")
+        if len(parts) == 2:
+            provider, subkey = parts
+            current_val = (
+                global_config.file_config.get("providers", {})
+                .get(provider, {})
+                .get(subkey)
+            )
+            if current_val is not None:
+                del global_config.file_config["providers"][provider][subkey]
+                global_config.save()
+                print(f"{key}={current_val} was removed.")
+                return True
+        elif len(parts) == 3:
+            provider, model, subkey = parts
+            model_conf = (
+                global_config.file_config.get("providers", {})
+                .get(provider, {})
+                .get("models", {})
+                .get(model, {})
+            )
+            current_val = model_conf.get(subkey)
+            if current_val is not None:
+                del global_config.file_config["providers"][provider]["models"][model][
+                    subkey
+                ]
+                global_config.save()
+                print(f"{key}={current_val} was removed.")
+                return True
+    else:
+        current_val = global_config.file_config.get(key)
+        if current_val is not None:
+            del global_config.file_config[key]
+            global_config.save()
+            print(f"{key}={current_val} was removed.")
+            return True
+    if "=" in unset_arg:
+        provided_key = unset_arg.split("=")[0].strip()
+        print(
+            f"Error: --unset expected a key, not key=value. Did you mean: --unset {provided_key}?"
+        )
+    else:
+        print(f"Error: no value set for {key} (cannot remove)")
+    return True