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

janito/cli/chat_mode/toolbar.py

@@ -3,6 +3,7 @@ from janito.performance_collector import PerformanceCollector
 from janito.cli.config import config
 from janito import __version__ as VERSION
 
+
 def format_tokens(n, tag=None):
     if n is None:
         return "?"
@@ -14,15 +15,20 @@ def format_tokens(n, tag=None):
         val = f"{n/1000000:.1f}M"
     return f"<{tag}>{val}</{tag}>" if tag else val
 
+
 def assemble_first_line(provider_name, model_name, role, agent=None):
     return f" Janito {VERSION} | Provider: <provider>{provider_name}</provider> | Model: <model>{model_name}</model> | Role: <role>{role}</role>"
 
+
 def assemble_bindings_line(width, permissions=None):
     def color_state(state):
-        return 'on ' if state == "on" else 'off'
+        return "on " if state == "on" else "off"
+
     read_state = color_state("on" if getattr(permissions, "read", False) else "off")
     write_state = color_state("on" if getattr(permissions, "write", False) else "off")
-    execute_state = color_state("on" if getattr(permissions, "execute", False) else "off")
+    execute_state = color_state(
+        "on" if getattr(permissions, "execute", False) else "off"
+    )
     return (
         f" <key-label>CTRL-C</key-label>: Interrupt/Exit | "
         f"<key-label>F2</key-label>: /restart | "
@@ -30,6 +36,7 @@ def assemble_bindings_line(width, permissions=None):
         f"<key-label>F12</key-label>: Do It "
     )
 
+
 def _get_status(shell_state):
     _support = getattr(shell_state, "_support", False)
     _status = getattr(shell_state, "_status", None)
@@ -37,47 +44,46 @@ def _get_status(shell_state):
         return None
     if _status == "starting" or _status is None:
         return _status
-    live_status = getattr(shell_state, "_live_status", None)
-    if live_status is not None:
-        return live_status
+
     return _status
 
+
 def _get_agent_info(agent):
-    provider_name = agent.get_provider_name() if hasattr(agent, "get_provider_name") else "?"
+    provider_name = (
+        agent.get_provider_name() if hasattr(agent, "get_provider_name") else "?"
+    )
     model_name = agent.get_model_name() if hasattr(agent, "get_model_name") else "?"
-    role = agent.template_vars.get("role", "?") if hasattr(agent, "template_vars") else "?"
+    role = (
+        agent.template_vars.get("role", "?") if hasattr(agent, "template_vars") else "?"
+    )
     return provider_name, model_name, role
 
+
 def _get_permissions():
     try:
         from janito.tools.permissions import get_global_allowed_permissions
+
         return get_global_allowed_permissions()
     except Exception:
         return None
 
-def _get_termweb_status_line(this__status, _port):
-    if this__status == "online" and _port:
-        return "\n<> Termweb </>Online"
-    elif this__status == "starting":
-        return "\n<> Termweb </>Starting"
-    elif this__status == "offline":
-        return "\n<> Termweb </>Offline"
-    return ""
 
 def get_toolbar_func(perf: PerformanceCollector, msg_count: int, shell_state):
     from prompt_toolkit.application.current import get_app
+
     def get_toolbar():
         width = get_app().output.get_size().columns
         agent = getattr(shell_state, "agent", None)
         this__status = _get_status(shell_state)
-        provider_name, model_name, role = _get_agent_info(agent) if agent is not None else ("?", "?", "?")
+        provider_name, model_name, role = (
+            _get_agent_info(agent) if agent is not None else ("?", "?", "?")
+        )
         usage = perf.get_last_request_usage()
         first_line = assemble_first_line(provider_name, model_name, role, agent=agent)
         permissions = _get_permissions()
         bindings_line = assemble_bindings_line(width, permissions)
         toolbar_text = first_line + "\n" + bindings_line
-        _port = getattr(shell_state, "_port", None)
-        toolbar_text += _get_termweb_status_line(this__status, _port)
+
         return HTML(toolbar_text)
-    return get_toolbar
 
+    return get_toolbar

janito/cli/cli_commands/list_config.py

@@ -0,0 +1,31 @@
+from rich.console import Console
+from pathlib import Path
+import os
+
+
+def handle_list_config(args=None):
+    console = Console()
+    home = Path.home()
+    default_config = home / ".janito" / "config.json"
+    custom_dir = home / ".janito" / "configs"
+    console.print("[bold green]Janito configuration files:[/bold green]")
+    if default_config.exists():
+        console.print(f"[bold yellow]Default config:[/bold yellow] {default_config}")
+    else:
+        console.print(
+            f"[bold yellow]Default config:[/bold yellow] {default_config} [red](not found)"
+        )
+    if custom_dir.exists() and custom_dir.is_dir():
+        files = sorted(
+            f for f in custom_dir.iterdir() if f.is_file() and f.suffix == ".json"
+        )
+        if files:
+            console.print("[bold yellow]Custom configs:[/bold yellow]")
+            for f in files:
+                console.print(f"  - {f}")
+        else:
+            console.print("[bold yellow]Custom configs:[/bold yellow] (none found)")
+    else:
+        console.print(
+            f"[bold yellow]Custom configs:[/bold yellow] {custom_dir} [red](directory not found)"
+        )

janito/cli/cli_commands/list_models.py

@@ -32,4 +32,4 @@ def handle_list_models(args, provider_instance):
                 print(f"- {m}")
     except Exception as e:
         print(f"Error listing models for provider '{provider_name}': {e}")
-    sys.exit(0)
+    return

janito/cli/cli_commands/list_profiles.py

@@ -0,0 +1,79 @@
+"""
+CLI Command: List available system prompt profiles (default and user-specific)
+"""
+
+from pathlib import Path
+import importlib.resources as resources
+from rich.console import Console
+from rich.table import Table
+
+
+_PREFIX = "system_prompt_template_"
+_SUFFIX = ".txt.j2"
+
+
+def _extract_profile_name(filename: str) -> str:
+    """Return the human-readable profile name from template file name."""
+    # Remove prefix & suffix and convert underscores back to spaces
+    if filename.startswith(_PREFIX):
+        filename = filename[len(_PREFIX) :]
+    if filename.endswith(_SUFFIX):
+        filename = filename[: -len(_SUFFIX)]
+    return filename.replace("_", " ")
+
+
+def _gather_default_profiles():
+    """Return list of built-in profile names bundled with janito."""
+    profiles = []
+    try:
+        package_files = resources.files("janito.agent.templates.profiles")
+        for path in package_files.iterdir():
+            name = path.name
+            if name.startswith(_PREFIX) and name.endswith(_SUFFIX):
+                profiles.append(_extract_profile_name(name))
+    except Exception:
+        # If for some reason the resources are not available fall back to empty list
+        pass
+    return sorted(profiles, key=str.lower)
+
+
+def _gather_user_profiles():
+    """Return list of user-defined profile names from ~/.janito/profiles directory."""
+    user_dir = Path.home() / ".janito" / "profiles"
+    profiles = []
+    if user_dir.exists() and user_dir.is_dir():
+        for path in user_dir.iterdir():
+            if (
+                path.is_file()
+                and path.name.startswith(_PREFIX)
+                and path.name.endswith(_SUFFIX)
+            ):
+                profiles.append(_extract_profile_name(path.name))
+    return sorted(profiles, key=str.lower)
+
+
+def _print_profiles_table(default_profiles, user_profiles):
+    console = Console()
+    table = Table(title="Available System Prompt Profiles", box=None, show_lines=False)
+    table.add_column("Profile Name", style="cyan", no_wrap=False)
+    table.add_column("Source", style="magenta", no_wrap=True)
+
+    for p in default_profiles:
+        table.add_row(p, "default")
+    for p in user_profiles:
+        table.add_row(p, "user")
+
+    console.print(table)
+
+
+def handle_list_profiles(args=None):
+    """Entry point for the --list-profiles CLI flag."""
+    default_profiles = _gather_default_profiles()
+    user_profiles = _gather_user_profiles()
+
+    if not default_profiles and not user_profiles:
+        print("No profiles found.")
+        return
+
+    _print_profiles_table(default_profiles, user_profiles)
+    return

janito/cli/cli_commands/list_providers.py

@@ -7,3 +7,4 @@ from janito.provider_registry import list_providers
 
 def handle_list_providers(args=None):
     list_providers()
+    return

janito/cli/cli_commands/list_tools.py

@@ -3,21 +3,29 @@ CLI Command: List available tools
 """
 
 
-def _group_tools_by_permission(tools, tool_instances):
+def _group_tools_by_permission(tools, tool_instances, disabled_tools):
     read_only_tools = []
     write_only_tools = []
     read_write_tools = []
     exec_tools = []
     import inspect
+
     for tool in tools:
+        # Skip disabled tools entirely
+        if tool in disabled_tools:
+            continue
+
         inst = tool_instances.get(tool, None)
         param_names = []
         if inst and hasattr(inst, "run"):
             sig = inspect.signature(inst.run)
             param_names = [p for p in sig.parameters if p != "self"]
+
         info = {
             "name": tool,
             "params": ", ".join(param_names),
+            "tool_name": tool,
+            "disabled": False,
         }
         perms = getattr(inst, "permissions", None)
         if perms and perms.execute:
@@ -30,33 +38,54 @@ def _group_tools_by_permission(tools, tool_instances):
             write_only_tools.append(info)
     return read_only_tools, write_only_tools, read_write_tools, exec_tools
 
+
 def _print_tools_table(console, title, tools_info):
     from rich.table import Table
-    table = Table(title=title, show_header=True, header_style="bold", show_lines=False, box=None)
+
+    table = Table(
+        title=title, 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 tools_info:
         table.add_row(info["name"], info["params"] or "-")
     console.print(table)
 
+
 def handle_list_tools(args=None):
     from janito.tools.adapters.local.adapter import LocalToolsAdapter
     import janito.tools  # Ensure all tools are registered
     from janito.tools.tool_base import ToolPermissions
+
     read = getattr(args, "read", False) if args else False
     write = getattr(args, "write", False) if args else False
     execute = getattr(args, "exec", False) if args else False
     if not (read or write or execute):
         read = write = execute = True
     from janito.tools.permissions import set_global_allowed_permissions
-    set_global_allowed_permissions(ToolPermissions(read=read, write=write, execute=execute))
-    registry = janito.tools.get_local_tools_adapter()
+
+    set_global_allowed_permissions(
+        ToolPermissions(read=read, write=write, execute=execute)
+    )
+    # Load disabled tools from config
+    from janito.tools.disabled_tools import DisabledToolsState
+    from janito.config import config
+
+    disabled_str = config.get("disabled_tools", "")
+    if disabled_str:
+        DisabledToolsState.set_disabled_tools(disabled_str)
+    disabled_tools = DisabledToolsState.get_disabled_tools()
+
+    registry = janito.tools.local_tools_adapter
     tools = registry.list_tools()
     if tools:
         from rich.console import Console
+
         console = Console()
         tool_instances = {t.tool_name: t for t in registry.get_tools()}
-        read_only_tools, write_only_tools, read_write_tools, exec_tools = _group_tools_by_permission(tools, tool_instances)
+        read_only_tools, write_only_tools, read_write_tools, exec_tools = (
+            _group_tools_by_permission(tools, tool_instances, disabled_tools)
+        )
         if read_only_tools:
             _print_tools_table(console, "Read-only tools (-r)", read_only_tools)
         if write_only_tools:
@@ -67,5 +96,4 @@ def handle_list_tools(args=None):
             _print_tools_table(console, "Execution tools (-x)", exec_tools)
     else:
         print("No tools registered.")
-    import sys
-    sys.exit(0)
+    return

janito/cli/cli_commands/model_utils.py

@@ -35,18 +35,20 @@ def _print_models_table(models, provider_name):
         row.extend(_build_model_row(m, headers, num_fields))
         table.add_row(*row)
     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))
+        print(" | ".join(headers_fallback))
         for m in models:
-            row = [str(m.get('name', ''))]
+            row = [str(m.get("name", ""))]
             row.extend(_build_model_row(m, headers, num_fields))
-            print(' | '.join(row))
+            print(" | ".join(row))
 
 
 def _add_table_columns(table, display_headers):

janito/cli/cli_commands/show_config.py

@@ -34,18 +34,23 @@ def handle_show_config(args):
         provider_names = ProviderRegistry()._get_provider_names()
     except Exception:
         pass
+    from janito.provider_config import get_config_path
+
+    config_path = get_config_path()
     console.print("[bold green]Current configuration:[/bold green]")
+    console.print(f"[bold yellow]Config file:[/bold yellow] {config_path}")
     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}"
-            )
+
+    # Show disabled tools
+    from janito.tools.disabled_tools import load_disabled_tools_from_config
+
+    disabled_tools = load_disabled_tools_from_config()
+    if disabled_tools:
+        console.print(
+            f"\n[bold red]Disabled tools:[/bold red] {', '.join(sorted(disabled_tools))}"
+        )
+    else:
+        console.print("\n[bold green]No tools are disabled[/bold green]")
+    return

janito/cli/cli_commands/show_system_prompt.py

@@ -14,6 +14,7 @@ import re
 
 def _compute_permission_string(args):
     from janito.tools.tool_base import ToolPermissions
+
     read = getattr(args, "read", False)
     write = getattr(args, "write", False)
     execute = getattr(args, "exec", False)
@@ -33,7 +34,7 @@ def _prepare_context(args, agent_role, allowed_permissions):
     context["role"] = agent_role or "developer"
     context["profile"] = getattr(args, "profile", None)
     context["allowed_permissions"] = allowed_permissions
-    if allowed_permissions and 'x' in allowed_permissions:
+    if allowed_permissions and "x" in allowed_permissions:
         pd = PlatformDiscovery()
         context["platform"] = pd.get_platform_name()
         context["python_version"] = pd.get_python_version()
@@ -43,7 +44,8 @@ def _prepare_context(args, agent_role, allowed_permissions):
 
 def _load_template(profile, templates_dir):
     if profile:
-        template_filename = f"system_prompt_template_{profile}.txt.j2"
+        sanitized_profile = re.sub(r"\\s+", "_", profile.strip())
+        template_filename = f"system_prompt_template_{sanitized_profile}.txt.j2"
         template_path = templates_dir / template_filename
     else:
         return None, None
@@ -65,8 +67,13 @@ def _load_template(profile, templates_dir):
 def _print_debug_info(debug_flag, template_filename, allowed_permissions, context):
     if debug_flag:
         from rich import print as rich_print
-        rich_print(f"[bold magenta][DEBUG][/bold magenta] Rendering system prompt template '[cyan]{template_filename}[/cyan]' with allowed_permissions: [yellow]{allowed_permissions}[/yellow]")
-        rich_print(f"[bold magenta][DEBUG][/bold magenta] Template context: [green]{context}[/green]")
+
+        rich_print(
+            f"[bold magenta][DEBUG][/bold magenta] Rendering system prompt template '[cyan]{template_filename}[/cyan]' with allowed_permissions: [yellow]{allowed_permissions}[/yellow]"
+        )
+        rich_print(
+            f"[bold magenta][DEBUG][/bold magenta] Template context: [green]{context}[/green]"
+        )
 
 
 def handle_show_system_prompt(args):
@@ -85,9 +92,12 @@ def handle_show_system_prompt(args):
 
     # Debug flag detection
     import sys
+
     debug_flag = False
     try:
-        debug_flag = (hasattr(sys, 'argv') and ('--debug' in sys.argv or '--verbose' in sys.argv or '-v' in sys.argv))
+        debug_flag = hasattr(sys, "argv") and (
+            "--debug" in sys.argv or "--verbose" in sys.argv or "-v" in sys.argv
+        )
     except Exception:
         pass
 
@@ -96,8 +106,10 @@ def handle_show_system_prompt(args):
     )
     profile = getattr(args, "profile", None)
     if not profile:
-        print("[janito] No profile specified. The main agent runs without a system prompt template.\n"
-              "Use --profile PROFILE to view a profile-specific system prompt.")
+        print(
+            "[janito] No profile specified. The main agent runs without a system prompt template.\n"
+            "Use --profile PROFILE to view a profile-specific system prompt."
+        )
         return
 
     template_filename, template_content = _load_template(profile, templates_dir)
@@ -117,9 +129,11 @@ def handle_show_system_prompt(args):
 
     template = Template(template_content)
     system_prompt = template.render(**context)
-    system_prompt = re.sub(r'\n{3,}', '\n\n', system_prompt)
+    system_prompt = re.sub(r"\n{3,}", "\n\n", system_prompt)
 
-    print(f"\n--- System Prompt (resolved, profile: {getattr(args, 'profile', 'main')}) ---\n")
+    print(
+        f"\n--- System Prompt (resolved, profile: {getattr(args, 'profile', 'main')}) ---\n"
+    )
     print(system_prompt)
     print("\n-------------------------------\n")
     if agent_role:

janito/cli/config.py

@@ -12,16 +12,3 @@ CONFIG_OPTIONS = {
     "template": "Template context dictionary for Agent Profile prompt rendering (nested)",
     "profile": "Agent Profile name (only 'base' is supported)",
 }
-
-
-
-def get__port():
-    port = config.get("_port")
-    try:
-        return int(port)
-    except Exception:
-        pass
-
-
-def set__port(port):
-    config.file_set("_port", int(port))

janito/cli/core/getters.py

@@ -1,14 +1,23 @@
 """Handlers for get-type CLI commands (show_config, list_providers, models, tools)."""
+
 import sys
 
 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 janito.cli.cli_commands.list_config import handle_list_config
 from functools import partial
 from janito.provider_registry import ProviderRegistry
 
-GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
+GETTER_KEYS = [
+    "show_config",
+    "list_providers",
+    "list_profiles",
+    "list_models",
+    "list_tools",
+    "list_config",
+]
 
 
 def handle_getter(args, config_mgr=None):
@@ -17,16 +26,22 @@ def handle_getter(args, config_mgr=None):
         provider = getattr(args, "provider", None)
         if not provider:
             import sys
+
             print(
                 "Error: No provider selected. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
             )
             sys.exit(1)
         provider_instance = ProviderRegistry().get_instance(provider)
+    # Lazy import to avoid overhead unless needed
+    from janito.cli.cli_commands.list_profiles import handle_list_profiles
+
     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),
+        "list_profiles": partial(handle_list_profiles, args),
         "show_config": partial(handle_show_config, args),
+        "list_config": partial(handle_list_config, args),
     }
     for arg in GETTER_KEYS:
         if getattr(args, arg, False) and arg in GETTER_DISPATCH:

janito/cli/core/runner.py

@@ -77,7 +77,7 @@ def prepare_llm_driver_config(args, modifiers):
                     f"Error: Model '{model}' is not available for provider '{provider}'."
                 )
                 # Optionally, print available models if possible
-                if hasattr(provider_instance, 'get_model_info'):
+                if hasattr(provider_instance, "get_model_info"):
                     available_models = [
                         m["name"]
                         for m in provider_instance.get_model_info().values()
@@ -97,7 +97,13 @@ def prepare_llm_driver_config(args, modifiers):
     return provider, llm_driver_config, agent_role
 
 
-def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, ):
+def handle_runner(
+    args,
+    provider,
+    llm_driver_config,
+    agent_role,
+    verbose_tools=False,
+):
     """
     Main runner for CLI execution. If exec_enabled is False, disables execution/run tools.
     """
@@ -107,18 +113,29 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
     # Patch: disable execution/run tools if not enabled
     import janito.tools
     from janito.tools.tool_base import ToolPermissions
+
     read = getattr(args, "read", False)
     write = getattr(args, "write", False)
     execute = getattr(args, "exec", False)
     from janito.tools.permissions import set_global_allowed_permissions
     from janito.tools.tool_base import ToolPermissions
+
     allowed_permissions = ToolPermissions(read=read, write=write, execute=execute)
     set_global_allowed_permissions(allowed_permissions)
     # Store the default permissions for later restoration (e.g., on /restart)
     from janito.tools.permissions import set_default_allowed_permissions
+
     set_default_allowed_permissions(allowed_permissions)
+
+    # Load disabled tools from config
+    from janito.tools.disabled_tools import load_disabled_tools_from_config
+
+    load_disabled_tools_from_config()
+
     unrestricted_paths = getattr(args, "unrestricted_paths", False)
-    adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
+    adapter = janito.tools.get_local_tools_adapter(
+        workdir=getattr(args, "workdir", None)
+    )
     if unrestricted_paths:
         # Patch: disable path security enforcement for this adapter instance
         setattr(adapter, "unrestricted_paths", True)
@@ -128,7 +145,7 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
         print_verbose_info(
             "Allowed Tool Permissions",
             f"read={read}, write={write}, execute={execute}",
-            style="yellow"
+            style="yellow",
         )
 
     provider_instance = ProviderRegistry().get_instance(provider, llm_driver_config)
@@ -146,11 +163,12 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
         )
 
         # DEBUG: Print exec_enabled propagation at runner
-        
+
         handler = SingleShotPromptHandler(
-            args, provider_instance, llm_driver_config,
+            args,
+            provider_instance,
+            llm_driver_config,
             role=agent_role,
-            
             allowed_permissions=allowed_permissions,
         )
         handler.handle()
@@ -167,7 +185,6 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
             args=args,
             verbose_tools=verbose_tools,
             verbose_agent=getattr(args, "verbose_agent", False),
-            
             allowed_permissions=allowed_permissions,
         )
         session.run()