janito 1.14.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

janito/cli/chat_mode/shell/commands/termweb_log.py

@@ -0,0 +1,92 @@
+import http.client
+from rich.console import Console
+from janito.cli.config import config
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+
+class TermwebLogTailShellHandler(ShellCmdHandler):
+    help_text = "Show the last lines of the latest termweb logs"
+
+    def run(self):
+        lines = 20
+        args = self.after_cmd_line.strip().split()
+        if args and args[0].isdigit():
+            lines = int(args[0])
+        stdout_path = self.shell_state.termweb_stdout_path if self.shell_state else None
+        stderr_path = self.shell_state.termweb_stderr_path if self.shell_state else None
+        status = getattr(self.shell_state, "termweb_status", None)
+        live_status = getattr(self.shell_state, "termweb_live_status", None)
+        status_checked = getattr(self.shell_state, "termweb_live_checked_time", None)
+        shared_console.print(
+            f"[bold cyan][termweb] Current run status: {status} | Last health check: {live_status} at {status_checked}"
+        )
+        if not stdout_path and not stderr_path:
+            shared_console.print(
+                "[yellow][termweb] No termweb log files found for this session.[/yellow]"
+            )
+            return
+        stdout_lines = stderr_lines = None
+        if stdout_path:
+            try:
+                with open(stdout_path, encoding="utf-8") as f:
+                    stdout_lines = f.readlines()[-lines:]
+                if stdout_lines:
+                    shared_console.print(
+                        f"[yellow][termweb][stdout] Tail of {stdout_path}:\n"
+                        + "".join(stdout_lines)
+                    )
+            except Exception:
+                pass
+        if stderr_path:
+            try:
+                with open(stderr_path, encoding="utf-8") as f:
+                    stderr_lines = f.readlines()[-lines:]
+                if stderr_lines:
+                    shared_console.print(
+                        f"[red][termweb][stderr] Tail of {stderr_path}:\n"
+                        + "".join(stderr_lines)
+                    )
+            except Exception:
+                pass
+        if (not stdout_path or not stdout_lines) and (
+            not stderr_path or not stderr_lines
+        ):
+            shared_console.print("[termweb] No output or errors captured in logs.")
+
+
+def handle_termweb_status(*args, shell_state=None, **kwargs):
+    if shell_state is None:
+        console.print(
+            "[red]No shell state available. Cannot determine termweb status.[/red]"
+        )
+        return
+    from janito.cli.config import get_termweb_port
+
+    port = get_termweb_port()
+    port_source = "config"
+    pid = getattr(shell_state, "termweb_pid", None)
+    stdout_path = getattr(shell_state, "termweb_stdout_path", None)
+    stderr_path = getattr(shell_state, "termweb_stderr_path", None)
+    running = False
+    if port and hasattr(shell_state, "termweb_live_status"):
+        running = shell_state.termweb_live_status == "online"
+    console.print("[bold cyan]TermWeb Server Status:[/bold cyan]")
+    console.print(f"  Running: {'[green]Yes[/green]' if running else '[red]No[/red]'}")
+    if pid:
+        console.print(f"  PID: {pid}")
+    if port:
+        console.print(f"  Port: {port} (from {port_source})")
+        url = f"http://localhost:{port}/"
+        console.print(f"  URL: [underline blue]{url}[/underline blue]")
+    else:
+        console.print("  [yellow]No port configured in config.[/yellow]")
+    if stdout_path:
+        console.print(f"  Stdout log: {stdout_path}")
+    if stderr_path:
+        console.print(f"  Stderr log: {stderr_path}")
+
+
+handle_termweb_status.help_text = (
+    "Show status information about the running termweb server"
+)

janito/cli/chat_mode/shell/commands/tools.py

@@ -0,0 +1,32 @@
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+class ToolsShellHandler(ShellCmdHandler):
+    help_text = "List available tools"
+
+    def run(self):
+        try:
+            import janito.tools  # Ensure all tools are registered
+            registry = janito.tools.get_local_tools_adapter()
+            tools = registry.list_tools()
+            shared_console.print("Registered tools:" if tools else "No tools registered.")
+            for tool in tools:
+                shared_console.print(f"- {tool}")
+
+            # Check for execution tools
+            # We assume shell_state.allow_execution is set if -x is used
+            allow_execution = False
+            if hasattr(self, 'shell_state') and self.shell_state is not None:
+                allow_execution = getattr(self.shell_state, 'allow_execution', False)
+
+            # Find all possible execution tools (by convention: provides_execution = True)
+            exec_tools = []
+            for tool_instance in registry.get_tools():
+                if getattr(tool_instance, 'provides_execution', False):
+                    exec_tools.append(tool_instance.tool_name)
+
+            if not allow_execution and exec_tools:
+                shared_console.print("[yellow]⚠️  Warning: Execution tools (e.g., commands, code execution) are disabled. Use -x to enable them.[/yellow]")
+
+        except Exception as e:
+            shared_console.print(f"[red]Error loading tools: {e}[/red]")

janito/{shell → cli/chat_mode/shell}/commands/utility.py

@@ -1,17 +1,14 @@
-def handle_help(console, **kwargs):
-    from janito.shell.commands import COMMAND_HANDLERS
+def handle_help(**kwargs):
+    from janito.cli.chat_mode.shell.commands import COMMAND_HANDLERS
 
     console.print("[bold green]Available commands:[/bold green]")
     for cmd, handler in COMMAND_HANDLERS.items():
         help_text = getattr(handler, "help_text", None)
         if help_text:
             console.print(f"  {cmd} - {help_text}")
-    console.print(
-        "[bold cyan]!command[/]: Run a shell/cmd command without exiting the shell (e.g., !dir or !ls)"
-    )
 
 
-def handle_clear(console, **kwargs):
+def handle_clear(**kwargs):
     import os
 
     os.system("cls" if os.name == "nt" else "clear")
@@ -20,7 +17,7 @@ def handle_clear(console, **kwargs):
 handle_clear.help_text = "Clear the terminal screen"
 
 
-def handle_multi(console, shell_state=None, **kwargs):
+def handle_multi(shell_state=None, **kwargs):
     console.print(
         "[bold yellow]Multiline mode activated. Provide or write your text and press Esc + Enter to submit.[/bold yellow]"
     )

janito/{shell → cli/chat_mode/shell}/commands/verbose.py

@@ -1,9 +1,9 @@
-from janito.agent.runtime_config import runtime_config
+from janito.cli.config import config
 
 
-def handle_verbose(console, shell_state=None, **kwargs):
+def handle_verbose(shell_state=None, **kwargs):
     args = kwargs.get("args", [])
-    verbose = runtime_config.get("verbose", False)
+    verbose = config.get("verbose") or False
     if not args:
         status = "ON" if verbose else "OFF"
         console.print(
@@ -12,12 +12,12 @@ def handle_verbose(console, shell_state=None, **kwargs):
         return
     arg = args[0].lower()
     if arg == "on":
-        runtime_config["verbose"] = True
+        config.runtime_set("verbose", True)
         console.print(
             "[bold green]/verbose:[/bold green] Verbose mode is now [bold]ON[/bold]."
         )
     elif arg == "off":
-        runtime_config["verbose"] = False
+        config.runtime_set("verbose", False)
         console.print(
             "[bold green]/verbose:[/bold green] Verbose mode is now [bold]OFF[/bold]."
         )

janito/cli/chat_mode/shell/session/__init__.py

@@ -0,0 +1 @@
+from .history import handle_history

janito/{shell → cli/chat_mode/shell}/session/manager.py

@@ -32,6 +32,14 @@ def get_session_id():
     return _current_session_id
 
 
+def set_role(role):
+    """Set the current role."""
+    # No longer needed: from janito.cli.runtime_config import RuntimeConfig
+    rc = RuntimeConfig()
+    rc.role = role
+    rc.save()
+
+
 def load_last_summary(path=".janito/last_conversation.json"):
     if not os.path.exists(path):
         return None
@@ -81,7 +89,7 @@ def save_conversation(messages, prompts, usage_info=None, path=None):
     def usage_serializer(obj):
         if hasattr(obj, "to_dict"):
             return obj.to_dict()
-        if hasattr(obj, "__dict__"):
+        if hasattr(obj, "__dict"):
             return obj.__dict__
         return str(obj)
 

janito/cli/chat_mode/toolbar.py

@@ -0,0 +1,90 @@
+from prompt_toolkit.formatted_text import HTML
+from janito.performance_collector import PerformanceCollector
+from janito.cli.config import config
+from janito.version import __version__ as VERSION
+
+
+def format_tokens(n, tag=None):
+    if n is None:
+        return "?"
+    if n < 1000:
+        val = str(n)
+    elif n < 1000000:
+        val = f"{n/1000:.1f}k"
+    else:
+        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):
+    return (
+        f" <key-label>F1</key-label>: Restart conversation | "
+        f"<b>/help</b>: Help | "
+        f"<key-label>F12</key-label>: Do It "
+    )
+
+
+def get_toolbar_func(perf: PerformanceCollector, msg_count: int, shell_state):
+    from prompt_toolkit.application.current import get_app
+    import importlib
+
+    def get_toolbar():
+        width = get_app().output.get_size().columns
+        provider_name = "?"
+        model_name = "?"
+        role = "?"
+        agent = shell_state.agent if hasattr(shell_state, "agent") else None
+        termweb_support = getattr(shell_state, "termweb_support", False)
+        termweb_port = (
+            shell_state.termweb_port if hasattr(shell_state, "termweb_port") else None
+        )
+        termweb_status = (
+            shell_state.termweb_status
+            if hasattr(shell_state, "termweb_status")
+            else None
+        )
+        # Use cached liveness check only (set by background thread in shell_state)
+        this_termweb_status = termweb_status
+        if not termweb_support:
+            this_termweb_status = None
+        elif termweb_status == "starting" or termweb_status is None:
+            this_termweb_status = termweb_status
+        else:
+            live_status = (
+                shell_state.termweb_live_status
+                if hasattr(shell_state, "termweb_live_status")
+                else None
+            )
+            if live_status is not None:
+                this_termweb_status = live_status
+        if agent is not None:
+            # Use agent API to get provider and model name
+            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 "?"
+            )
+            if hasattr(agent, "template_vars"):
+                role = agent.template_vars.get("role", "?")
+        usage = perf.get_last_request_usage()
+        first_line = assemble_first_line(provider_name, model_name, role, agent=agent)
+
+        bindings_line = assemble_bindings_line(width)
+        toolbar_text = first_line + "\n" + bindings_line
+        # Add termweb status if available, after the F12 line
+        if this_termweb_status == "online" and termweb_port:
+            toolbar_text += f"\n<termweb> Termweb </termweb>Online<termweb> at <u>http://localhost:{termweb_port}</u></termweb>"
+        elif this_termweb_status == "starting":
+            toolbar_text += "\n<termweb> Termweb </termweb>Starting"
+        elif this_termweb_status == "offline":
+            toolbar_text += "\n<termweb> Termweb </termweb>Offline"
+        return HTML(toolbar_text)
+
+    return get_toolbar

janito/cli/cli_commands/list_models.py

@@ -0,0 +1,35 @@
+"""
+CLI Command: List models for the specified/current provider
+"""
+
+from janito.cli.cli_commands.model_utils import _print_models_table
+import sys
+
+_provider_instance = None
+
+
+def get_provider_instance():
+    global _provider_instance
+    if _provider_instance is None:
+        _provider_instance = setup_provider()
+    return _provider_instance
+
+
+def handle_list_models(args, 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 listing models."
+        )
+        sys.exit(1)
+    try:
+        models = list(provider_instance.get_model_info().values())
+        if models and isinstance(models[0], dict):
+            _print_models_table(models, provider_name)
+        else:
+            print(f"Supported models for provider '{provider_name}':")
+            for m in models:
+                print(f"- {m}")
+    except Exception as e:
+        print(f"Error listing models for provider '{provider_name}': {e}")
+    sys.exit(0)

janito/cli/cli_commands/list_providers.py

@@ -0,0 +1,9 @@
+"""
+CLI Command: List supported LLM providers
+"""
+
+from janito.provider_registry import list_providers
+
+
+def handle_list_providers(args=None):
+    list_providers()

janito/cli/cli_commands/list_tools.py

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

janito/cli/cli_commands/model_selection.py

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

janito/cli/cli_commands/model_utils.py

@@ -0,0 +1,84 @@
+"""
+Utilities for model-related CLI output
+"""
+
+
+def _print_models_table(models, provider_name):
+    from rich.table import Table
+    from rich.console import Console
+
+    headers = [
+        "name",
+        "open",
+        "context",
+        "max_input",
+        "max_cot",
+        "max_response",
+        "thinking_supported",
+        "driver",
+    ]
+    display_headers = [
+        "Model Name",
+        "Vendor",
+        "context",
+        "max_input",
+        "max_cot",
+        "max_response",
+        "Thinking",
+        "Driver",
+    ]
+    table = Table(title=f"Supported models for provider '{provider_name}'")
+    _add_table_columns(table, display_headers)
+    num_fields = {"context", "max_input", "max_cot", "max_response"}
+    for m in models:
+        row = [str(m.get("name", ""))]
+        row.extend(_build_model_row(m, headers, num_fields))
+        table.add_row(*row)
+    console = Console()
+    console.print(table)
+
+
+def _add_table_columns(table, display_headers):
+    for i, h in enumerate(display_headers):
+        justify = "right" if i == 0 else "center"
+        table.add_column(h, style="bold", justify=justify)
+
+
+def _format_k(val):
+    try:
+        n = int(val)
+        if n >= 1000:
+            return f"{n // 1000}k"
+        return str(n)
+    except Exception:
+        return str(val)
+
+
+def _build_model_row(m, headers, num_fields):
+    def format_driver(val):
+        if isinstance(val, (list, tuple)):
+            return ", ".join(val)
+        val_str = str(val)
+        return val_str.removesuffix("ModelDriver").strip()
+
+    row = []
+    for h in headers[1:]:
+        v = m.get(h, "")
+        if h in num_fields and v not in ("", "N/A"):
+            if (
+                h in ("context", "max_input")
+                and isinstance(v, (list, tuple))
+                and len(v) == 2
+            ):
+                row.append(f"{_format_k(v[0])} / {_format_k(v[1])}")
+            else:
+                row.append(_format_k(v))
+        elif h == "open":
+            row.append("Open" if v is True or v == "Open" else "Locked")
+        elif h == "thinking_supported":
+            row.append("📖" if v is True or v == "True" else "")
+        elif h == "driver":
+            row.append(format_driver(v))
+        else:
+            row.append(str(v))
+    return row

janito/cli/cli_commands/set_api_key.py

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

janito/cli/cli_commands/show_config.py

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

janito/cli/cli_commands/show_system_prompt.py

@@ -0,0 +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}]")