janito 2.7.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

janito/cli/core/setters.py

@@ -27,25 +27,24 @@ def handle_set(args, config_mgr=None):
         print(f"Error parsing --set value: {e}")
         return True
 
+
 def _validate_set_arg_format(set_arg):
     if "=" not in set_arg:
-        print(
-            "Error: --set requires KEY=VALUE (e.g., --set provider=provider_name)."
-        )
+        print("Error: --set requires KEY=VALUE (e.g., --set provider=provider_name).")
         return False
     return True
 
+
 def _parse_set_arg(set_arg):
     key, value = set_arg.split("=", 1)
     return key.strip(), value.strip()
 
+
 def _dispatch_set_key(key, value):
     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":
@@ -54,18 +53,24 @@ def _dispatch_set_key(key, value):
         global_config.file_set("azure_deployment_name", value)
         print(f"Azure deployment name set to '{value}'.")
         return True
-    if ".max_tokens" in key or ".base_url" in key:
-        return _handle_set_provider_level_setting(key, value)
     if key == "tool_permissions":
         from janito.tools.permissions_parse import parse_permissions_string
         from janito.tools.permissions import set_global_allowed_permissions
+
         perms = parse_permissions_string(value)
         global_config.file_set("tool_permissions", value)
         set_global_allowed_permissions(perms)
         print(f"Tool permissions set to '{value}' (parsed: {perms})")
         return True
+    if key == "disabled_tools":
+        from janito.tools.disabled_tools import set_disabled_tools
+
+        set_disabled_tools(value)
+        global_config.file_set("disabled_tools", value)
+        print(f"Disabled tools set to '{value}'")
+        return True
     print(
-        f"Error: Unknown config key '{key}'. Supported: provider, model, <provider>.model, max_tokens, base_url, azure_deployment_name, <provider>.max_tokens, <provider>.base_url, <provider>.<model>.max_tokens, <provider>.<model>.base_url, tool_permissions"
+        f"Error: Unknown config key '{key}'. Supported: provider, model, max_tokens, base_url, azure_deployment_name, tool_permissions, disabled_tools"
     )
     return True
 
@@ -87,48 +92,6 @@ def _handle_set_base_url(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)
@@ -144,32 +107,6 @@ def _handle_set_config_provider(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")

janito/cli/main_cli.py

@@ -21,7 +21,6 @@ definition = [
             "help": "Disable path security: allow tool arguments to use any file/directory path (DANGEROUS)",
         },
     ),
-
     (
         ["--profile"],
         {
@@ -99,6 +98,14 @@ definition = [
     (["--version"], {"action": "version", "version": None}),
     (["--list-tools"], {"action": "store_true", "help": "List all registered tools"}),
     (["--show-config"], {"action": "store_true", "help": "Show the current config"}),
+    (
+        ["--list-config"],
+        {"action": "store_true", "help": "List all configuration files"},
+    ),
+    (
+        ["--list-profiles"],
+        {"action": "store_true", "help": "List available system prompt profiles"},
+    ),
     (
         ["--list-providers"],
         {"action": "store_true", "help": "List supported LLM providers"},
@@ -114,7 +121,7 @@ definition = [
             "help": "Set API key for the provider (requires -p PROVIDER)",
         },
     ),
-    (["--set"], {"metavar": "[PROVIDER_NAME.]KEY=VALUE", "help": "Set a config key"}),
+    (["--set"], {"metavar": "KEY=VALUE", "help": "Set a config key"}),
     (["-s", "--system"], {"metavar": "SYSTEM_PROMPT", "help": "Set a system prompt"}),
     (
         ["-S", "--show-system"],
@@ -141,22 +148,7 @@ definition = [
         },
     ),
     (
-        ["--web"],
-        {
-            "action": "store_true",
-            "default": False,
-            "help": "Enable the builtin lightweight web file viewer for terminal links (disabled by default)",
-        },
-    ),
-    (
-        ["---port"],
-        {
-            "type": int,
-            "default": 8088,
-            "help": "Port for the  server (default: 8088)",
-        },
-    ),
-    (["--effort"],
+        ["--effort"],
         {
             "choices": ["low", "medium", "high", "none"],
             "default": None,
@@ -175,6 +167,13 @@ definition = [
             "help": "Print debug info on event subscribe/submit methods",
         },
     ),
+    (
+        ["-c", "--config"],
+        {
+            "metavar": "NAME",
+            "help": "Use custom configuration file ~/.janito/configs/NAME.json instead of default config.json",
+        },
+    ),
 ]
 
 MODIFIER_KEYS = [
@@ -184,11 +183,8 @@ MODIFIER_KEYS = [
     "profile",
     "system",
     "temperature",
-
     "verbose",
     "raw",
-    "web",
-    "_port",
     "verbose_api",
     "verbose_tools",
     "exec",
@@ -196,7 +192,14 @@ MODIFIER_KEYS = [
     "write",
 ]
 SETTER_KEYS = ["set", "set_provider", "set_api_key", "unset"]
-GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
+GETTER_KEYS = [
+    "show_config",
+    "list_providers",
+    "list_profiles",
+    "list_models",
+    "list_tools",
+    "list_config",
+]
 
 
 class RunMode(enum.Enum):
@@ -217,14 +220,38 @@ class JanitoCLI:
         self._define_args()
         self.args = self.parser.parse_args()
         self._set_all_arg_defaults()
+        # Support custom config file via -c/--config
+        if getattr(self.args, "config", None):
+            from janito import config as global_config
+            from janito.config_manager import ConfigManager
+            import sys
+            import importlib
+
+            config_name = self.args.config
+            # Re-initialize the global config singleton
+            new_config = ConfigManager(config_name=config_name)
+            # Ensure the config path is updated when the singleton already existed
+            from pathlib import Path
+
+            new_config.config_path = (
+                Path.home() / ".janito" / "configs" / f"{config_name}.json"
+            )
+            # Reload config from the selected file
+            new_config._load_file_config()
+            # Patch the global singleton reference
+            import janito.config as config_module
+
+            config_module.config = new_config
+            sys.modules["janito.config"].config = new_config
         # Support reading prompt from stdin if no user_prompt is given
         import sys
+
         if not sys.stdin.isatty():
             stdin_input = sys.stdin.read().strip()
             if stdin_input:
                 if self.args.user_prompt and len(self.args.user_prompt) > 0:
                     # Prefix the prompt argument to the stdin input
-                    combined = ' '.join(self.args.user_prompt) + ' ' + stdin_input
+                    combined = " ".join(self.args.user_prompt) + " " + stdin_input
                     self.args.user_prompt = [combined]
                 else:
                     self.args.user_prompt = [stdin_input]
@@ -289,13 +316,19 @@ class JanitoCLI:
                 return
         # Special handling: provider is not required for list_providers, list_tools, show_config
         if run_mode == RunMode.GET and (
-            self.args.list_providers or self.args.list_tools or self.args.show_config
+            self.args.list_providers
+            or self.args.list_tools
+            or self.args.list_profiles
+            or self.args.show_config
+            or self.args.list_config
         ):
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)
             return
         # If running in single shot mode and --profile is not provided, default to 'developer' profile
-        if get_prompt_mode(self.args) == "single_shot" and not getattr(self.args, "profile", None):
+        if get_prompt_mode(self.args) == "single_shot" and not getattr(
+            self.args, "profile", None
+        ):
             self.args.profile = "developer"
         provider = self._get_provider_or_default()
         if provider is None:
@@ -316,14 +349,14 @@ class JanitoCLI:
         if run_mode == RunMode.RUN:
             self._maybe_print_verbose_run_mode()
             # DEBUG: Print exec_enabled propagation at main_cli
-            
+
             handle_runner(
                 self.args,
                 provider,
                 llm_driver_config,
                 agent_role,
                 verbose_tools=self.args.verbose_tools,
-                            )
+            )
         elif run_mode == RunMode.GET:
             handle_getter(self.args)
 

janito/cli/prompt_core.py

@@ -8,7 +8,12 @@ from janito.performance_collector import PerformanceCollector
 from rich.status import Status
 from rich.console import Console
 from typing import Any, Optional, Callable
-from janito.driver_events import RequestStarted, RequestFinished, RequestStatus, RateLimitRetry
+from janito.driver_events import (
+    RequestStarted,
+    RequestFinished,
+    RequestStatus,
+    RateLimitRetry,
+)
 from janito.tools.tool_events import ToolCallError
 import threading
 from janito.cli.verbose_output import print_verbose_header
@@ -56,7 +61,10 @@ class PromptHandler:
         if isinstance(inner_event, RequestFinished):
             if getattr(inner_event, "status", None) == "error":
                 return self._handle_request_finished_error(inner_event, status)
-            if getattr(inner_event, "status", None) in (RequestStatus.EMPTY_RESPONSE, RequestStatus.TIMEOUT):
+            if getattr(inner_event, "status", None) in (
+                RequestStatus.EMPTY_RESPONSE,
+                RequestStatus.TIMEOUT,
+            ):
                 return self._handle_empty_or_timeout(inner_event, status)
             status.update("[bold green]Received response![bold green]")
             return "break"
@@ -78,7 +86,9 @@ class PromptHandler:
         return None
 
     def _handle_rate_limit_retry(self, inner_event, status):
-        status.update(f"[yellow]Rate limited. Waiting {inner_event.retry_delay:.0f}s before retry (attempt {inner_event.attempt}).[yellow]")
+        status.update(
+            f"[yellow]Rate limited. Waiting {inner_event.retry_delay:.0f}s before retry (attempt {inner_event.attempt}).[yellow]"
+        )
         return None
 
     def _handle_request_finished_error(self, inner_event, status):
@@ -89,9 +99,7 @@ class PromptHandler:
             "Status 429" in error_msg
             and "Service tier capacity exceeded for this model" in error_msg
         ):
-            status.update(
-                "[yellow]Service tier capacity exceeded, retrying...[yellow]"
-            )
+            status.update("[yellow]Service tier capacity exceeded, retrying...[yellow]")
             return "break"
         status.update(f"[bold red]Error: {error_msg}[bold red]")
         self.console.print(f"[red]Error: {error_msg}[red]")
@@ -99,18 +107,12 @@ class PromptHandler:
 
     def _handle_tool_call_error(self, inner_event, status):
         error_msg = (
-            inner_event.error
-            if hasattr(inner_event, "error")
-            else "Unknown tool error"
+            inner_event.error if hasattr(inner_event, "error") else "Unknown tool error"
         )
         tool_name = (
-            inner_event.tool_name
-            if hasattr(inner_event, "tool_name")
-            else "unknown"
-        )
-        status.update(
-            f"[bold red]Tool Error in '{tool_name}': {error_msg}[bold red]"
+            inner_event.tool_name if hasattr(inner_event, "tool_name") else "unknown"
         )
+        status.update(f"[bold red]Tool Error in '{tool_name}': {error_msg}[bold red]")
         self.console.print(f"[red]Tool Error in '{tool_name}': {error_msg}[red]")
         return "break"
 
@@ -118,9 +120,7 @@ class PromptHandler:
         details = getattr(inner_event, "details", None) or {}
         block_reason = details.get("block_reason")
         block_msg = details.get("block_reason_message")
-        msg = details.get(
-            "message", "LLM returned an empty or incomplete response."
-        )
+        msg = details.get("message", "LLM returned an empty or incomplete response.")
         driver_name = getattr(inner_event, "driver_name", "unknown driver")
         if block_reason or block_msg:
             status.update(
@@ -221,6 +221,7 @@ class PromptHandler:
             self.console.print("[red]Interrupted by the user.[/red]")
             try:
                 from janito.driver_events import RequestFinished, RequestStatus
+
                 # Record a synthetic "cancelled" final event so that downstream
                 # handlers (e.g. single_shot_mode.handler._post_prompt_actions)
                 # can reliably detect that the prompt was interrupted by the

janito/cli/prompt_setup.py

@@ -4,6 +4,7 @@ both single–shot and chat modes can reuse.  Having one central place avoids th
 code duplication that previously existed in `chat_mode.session.ChatSession` and
 `single_shot_mode.handler.PromptHandler`.
 """
+
 from __future__ import annotations
 
 from janito.agent.setup_agent import create_configured_agent
@@ -21,7 +22,6 @@ def setup_agent_and_prompt_handler(
     role: Optional[str] = None,
     verbose_tools: bool = False,
     verbose_agent: bool = False,
-    
     allowed_permissions: Optional[list[str]] = None,
     profile: Optional[str] = None,
     profile_system_prompt: Optional[str] = None,
@@ -34,16 +34,19 @@ def setup_agent_and_prompt_handler(
     across *single-shot* and *chat* modes – both of which need an agent plus a
     prompt handler that points to that agent.
     """
+    no_tools_mode = False
+    if hasattr(args, 'no_tools_mode'):
+        no_tools_mode = getattr(args, 'no_tools_mode', False)
     agent = create_configured_agent(
         provider_instance=provider_instance,
         llm_driver_config=llm_driver_config,
         role=role,
         verbose_tools=verbose_tools,
         verbose_agent=verbose_agent,
-        
         allowed_permissions=allowed_permissions,
         profile=profile,
         profile_system_prompt=profile_system_prompt,
+        no_tools_mode=no_tools_mode,
     )
 
     prompt_handler = GenericPromptHandler(
@@ -53,4 +56,4 @@ def setup_agent_and_prompt_handler(
     )
     prompt_handler.agent = agent
 
-    return agent, prompt_handler
+    return agent, prompt_handler

janito/cli/rich_terminal_reporter.py

@@ -12,6 +12,7 @@ from janito.llm import message_parts
 
 import sys
 
+
 class RichTerminalReporter(EventHandlerBase):
     """
     Handles UI rendering for janito events using Rich.
@@ -31,6 +32,7 @@ class RichTerminalReporter(EventHandlerBase):
         import janito.report_events as report_events
 
         import janito.tools.tool_events as tool_events
+
         super().__init__(driver_events, report_events, tool_events)
         self._waiting_printed = False
 
@@ -53,7 +55,9 @@ class RichTerminalReporter(EventHandlerBase):
             model = getattr(event, "model_name", None)
         if not model:
             model = "?"
-        self.console.print(f"[bold cyan]Waiting for {provider} (model: {model})...[/bold cyan]", end="")
+        self.console.print(
+            f"[bold cyan]Waiting for {provider} (model: {model})...[/bold cyan]", end=""
+        )
 
     def on_ResponseReceived(self, event):
         parts = event.parts if hasattr(event, "parts") else None
@@ -70,7 +74,7 @@ class RichTerminalReporter(EventHandlerBase):
         """
         Clears the entire current line in the terminal and returns the cursor to column 1.
         """
-        sys.stdout.write('\033[2K\r')
+        sys.stdout.write("\033[2K\r")
         sys.stdout.flush()
 
     def on_RequestFinished(self, event):
@@ -118,9 +122,15 @@ class RichTerminalReporter(EventHandlerBase):
         action = getattr(event, "action", None)
         tool = getattr(event, "tool", None)
         context = getattr(event, "context", None)
-        if subtype == ReportSubtype.ERROR and msg and "[SECURITY] Path access denied" in msg:
+        if (
+            subtype == ReportSubtype.ERROR
+            and msg
+            and "[SECURITY] Path access denied" in msg
+        ):
             # Highlight security errors with a distinct style
-            self.console.print(Panel(f"{msg}", title="[red]SECURITY VIOLATION[/red]", style="bold red"))
+            self.console.print(
+                Panel(f"{msg}", title="[red]SECURITY VIOLATION[/red]", style="bold red")
+            )
             self.console.file.flush()
             return
 
@@ -135,7 +145,11 @@ class RichTerminalReporter(EventHandlerBase):
                 getattr(ReportAction, "WRITE", None),
                 getattr(ReportAction, "DELETE", None),
             )
-            style = "orange1" if getattr(event, "action", None) in modification_actions else "cyan"
+            style = (
+                "orange1"
+                if getattr(event, "action", None) in modification_actions
+                else "cyan"
+            )
             self.console.print(Text(msg, style=style), end="")
             self.console.file.flush()
         elif subtype in (

janito/cli/single_shot_mode/handler.py

@@ -11,12 +11,19 @@ import time
 
 
 class PromptHandler:
-    def __init__(self, args, provider_instance, llm_driver_config, role=None,  allowed_permissions=None):
+    def __init__(
+        self,
+        args,
+        provider_instance,
+        llm_driver_config,
+        role=None,
+        allowed_permissions=None,
+    ):
         self.args = args
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
         self.role = role
-                # Instantiate agent together with prompt handler using the shared helper
+        # Instantiate agent together with prompt handler using the shared helper
         self.agent, self.generic_handler = setup_agent_and_prompt_handler(
             args=args,
             provider_instance=provider_instance,
@@ -24,7 +31,6 @@ class PromptHandler:
             role=role,
             verbose_tools=getattr(args, "verbose_tools", False),
             verbose_agent=getattr(args, "verbose_agent", False),
-            
             allowed_permissions=allowed_permissions,
             profile=getattr(args, "profile", None),
         )
@@ -43,6 +49,7 @@ class PromptHandler:
                 "[yellow]Warning: Some characters in your input were not valid UTF-8 and have been replaced.[/yellow]"
             )
         import time
+
         try:
             start_time = time.time()
             self.generic_handler.handle_prompt(
@@ -67,13 +74,15 @@ class PromptHandler:
         import sys
         from janito.formatting_token import print_token_message_summary
         from janito.perf_singleton import performance_collector
+
         usage = performance_collector.get_last_request_usage()
         # If running in stdin mode, do not print token usage
         if sys.stdin.isatty():
-            print_token_message_summary(shared_console, msg_count=1, usage=usage, elapsed=elapsed)
+            print_token_message_summary(
+                shared_console, msg_count=1, usage=usage, elapsed=elapsed
+            )
         self._cleanup_driver_and_console()
 
-
     def _cleanup_driver_and_console(self):
         if hasattr(self.agent, "join_driver"):
             if (

janito/cli/verbose_output.py

@@ -19,7 +19,11 @@ def print_verbose_header(agent, args):
         parts = [
             f"Janito {VERSION}",
             f"Provider: {agent.llm_provider.__class__.__name__}",
-            (f"Model: {agent.llm_provider.driver_config.extra.get('azure_deployment_name', agent.llm_provider.driver_config.model)}{role_part}" if agent.llm_provider.__class__.__name__ == 'AzureOpenAIProvider' else f"Model: {getattr(agent.llm_provider.driver_config, 'model', '-')}{role_part}"),
+            (
+                f"Model: {agent.llm_provider.driver_config.extra.get('azure_deployment_name', agent.llm_provider.driver_config.model)}{role_part}"
+                if agent.llm_provider.__class__.__name__ == "AzureOpenAIProvider"
+                else f"Model: {getattr(agent.llm_provider.driver_config, 'model', '-')}{role_part}"
+            ),
             f"Driver: {agent.llm_provider.__class__.__module__.split('.')[-2] if len(agent.llm_provider.__class__.__module__.split('.')) > 1 else agent.llm_provider.__class__.__name__}",
         ]
         if hasattr(args, "think") and args.think:

janito/config.py

@@ -2,4 +2,5 @@
 from janito.config_manager import ConfigManager
 
 # Only one global instance! Used by CLI, provider_config, others:
+# If you want to use a custom config, re-initialize this singleton with config_name or config_path before use.
 config = ConfigManager(config_path=None)

janito/config_manager.py

@@ -20,13 +20,22 @@ class ConfigManager:
                 cls._instance = super(ConfigManager, cls).__new__(cls)
         return cls._instance
 
-    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
+    def __init__(
+        self, config_path=None, defaults=None, runtime_overrides=None, config_name=None
+    ):
         # Lazy single-init
         if hasattr(self, "_initialized") and self._initialized:
             return
         self._initialized = True
 
-        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
+        if config_name:
+            self.config_path = (
+                Path.home() / ".janito" / "configs" / f"{config_name}.json"
+            )
+        else:
+            self.config_path = Path(
+                config_path or Path.home() / ".janito" / "config.json"
+            )
         self.defaults = dict(defaults) if defaults else {}
         self.file_config = {}
         self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
@@ -40,11 +49,15 @@ class ConfigManager:
             try:
                 from janito.tools.permissions_parse import parse_permissions_string
                 from janito.tools.permissions import set_global_allowed_permissions
+
                 perms = parse_permissions_string(perm_str)
                 set_global_allowed_permissions(perms)
             except Exception as e:
                 print(f"Warning: Failed to apply tool_permissions from config: {e}")
 
+        # Load disabled tools from config - skip during startup to avoid circular imports
+        # This will be handled by the CLI when needed
+
     def _load_file_config(self):
         if self.config_path.exists():
             with open(self.config_path, "r", encoding="utf-8") as f: