janito 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

janito/cli/cli_main.py

@@ -1,4 +1,5 @@
 import sys
+from janito.agent.llm_conversation_history import LLMConversationHistory
 import socket
 from janito.agent.profile_manager import AgentProfileManager
 from janito.agent.runtime_config import unified_config, runtime_config
@@ -17,19 +18,11 @@ def is_port_free(port):
         return s.connect_ex(("localhost", port)) != 0
 
 
-def run_cli(args):
-    if args.version:
-        print(f"janito version {__version__}")
-        sys.exit(0)
-
-    # Set vanilla mode if -V/--vanilla is passed
+def normalize_args(args):
     if getattr(args, "vanilla", False):
         runtime_config.set("vanilla_mode", True)
-
-    # Set no_tools_tracking if --ntt is passed
     if getattr(args, "ntt", False):
         runtime_config.set("no_tools_tracking", True)
-    # Normalize all verbose flags into runtime_config
     for flag in [
         "verbose_http",
         "verbose_http_raw",
@@ -37,58 +30,49 @@ def run_cli(args):
         "verbose_reason",
         "verbose_tools",
         "verbose_events",
-        "verbose_stream",
+        "verbose_messages",
     ]:
         if hasattr(args, flag):
             runtime_config.set(flag, getattr(args, flag, False))
-
-    role = args.role or unified_config.get("role", "software engineer")
-    if args.role:
-        runtime_config.set("role", args.role)
+    if getattr(args, "trust_tools", False):
+        runtime_config.set("trust_tools", True)
     if getattr(args, "model", None):
         runtime_config.set("model", args.model)
     if getattr(args, "max_tools", None) is not None:
         runtime_config.set("max_tools", args.max_tools)
-    if getattr(args, "trust_tools", False):
-        runtime_config.set("trust_tools", True)
-    if not getattr(args, "prompt", None):
-        interaction_mode = "chat"
-    else:
-        interaction_mode = "prompt"
-    profile = "base"
-    # PATCH: Pass lang from args or runtime_config to AgentProfileManager
-    lang = getattr(args, "lang", None) or runtime_config.get("lang", "en")
-    profile_manager = AgentProfileManager(
+    if getattr(args, "verbose_reason", False):
+        runtime_config.set("verbose_reason", True)
+    if getattr(args, "max_tokens", None) is not None:
+        runtime_config.set("max_tokens", args.max_tokens)
+
+
+def setup_profile_manager(args, role, interaction_mode, profile, lang):
+    return AgentProfileManager(
         api_key=get_api_key(),
         model=unified_config.get("model"),
         role=role,
         profile_name=profile,
         interaction_mode=interaction_mode,
         verbose_tools=args.verbose_tools,
-        base_url=unified_config.get("base_url", "https://openrouter.ai/api/v1"),
+        base_url=unified_config.get("base_url", ""),
         azure_openai_api_version=unified_config.get(
             "azure_openai_api_version", "2023-05-15"
         ),
         use_azure_openai=unified_config.get("use_azure_openai", False),
         lang=lang,
     )
-    profile_manager.refresh_prompt()
-    if getattr(args, "show_system", False):
-        print(profile_manager.render_prompt())
-        sys.exit(0)
-    if args.max_tokens is not None:
-        runtime_config.set("max_tokens", args.max_tokens)
-    if getattr(args, "verbose_reason", False):
-        runtime_config.set("verbose_reason", True)
 
-    # --- termweb integration ---
+
+def handle_termweb(args, interaction_mode):
     termweb_proc = None
     selected_port = None
+    termweb_stdout_path = None
+    termweb_stderr_path = None
     if (
         not getattr(args, "no_termweb", False)
         and interaction_mode == "chat"
         and not runtime_config.get("vanilla_mode", False)
-        and not getattr(args, "input_arg", None)  # Prevent termweb in one-shot mode
+        and not getattr(args, "input_arg", None)
     ):
         default_port = 8088
         max_port = 8100
@@ -122,54 +106,131 @@ def run_cli(args):
         termweb_proc, started, termweb_stdout_path, termweb_stderr_path = start_termweb(
             selected_port
         )
-        # Store last running port in .janito/config.json if started
         if started:
             from janito.agent.config import local_config
 
             local_config.set("termweb_last_running_port", selected_port)
             local_config.save()
+    return termweb_proc, termweb_stdout_path, termweb_stderr_path
+
+
+def handle_continue_session(args):
+    continue_session = False
+    session_id = None
+    if getattr(args, "input_arg", None) or getattr(args, "continue_session", False):
+        _cont = getattr(args, "continue_session", False)
+        if _cont:
+            continue_session = True
+            session_id = getattr(args, "input_arg", None)
+            if session_id is None:
+                import os
+                import glob
+
+                chat_hist_dir = (
+                    os.path.join(os.path.expanduser("~"), ".janito", "chat_history")
+                    if not os.path.isabs(".janito")
+                    else os.path.join(".janito", "chat_history")
+                )
+                if not os.path.exists(chat_hist_dir):
+                    session_id = None
+                else:
+                    files = glob.glob(os.path.join(chat_hist_dir, "*.json"))
+                    if files:
+                        latest = max(files, key=os.path.getmtime)
+                        session_id = os.path.splitext(os.path.basename(latest))[0]
+                    else:
+                        session_id = None
+        else:
+            continue_session = False
+            session_id = None
+    return continue_session, session_id
+
+
+def handle_prompt_mode(args, profile_manager):
+    prompt = getattr(args, "input_arg", None)
+    from rich.console import Console
+    from janito.agent.rich_message_handler import RichMessageHandler
+
+    console = Console()
+    message_handler = RichMessageHandler()
+    messages = []
+    system_prompt_override = runtime_config.get("system_prompt_template")
+    if system_prompt_override:
+        if not runtime_config.get("vanilla_mode", False) or getattr(
+            args, "system", None
+        ):
+            messages.append({"role": "system", "content": system_prompt_override})
+    elif profile_manager.system_prompt_template and not runtime_config.get(
+        "vanilla_mode", False
+    ):
+        messages.append(
+            {"role": "system", "content": profile_manager.system_prompt_template}
+        )
+    messages.append({"role": "user", "content": prompt})
+    import time
+
+    info_start_time = None
+    if getattr(args, "info", False):
+        info_start_time = time.time()
+    try:
+        max_rounds = 100
+        result = profile_manager.agent.chat(
+            LLMConversationHistory(messages),
+            message_handler=message_handler,
+            spinner=True,
+            max_rounds=max_rounds,
+            tool_user=getattr(args, "tool_user", False),
+        )
+        if (
+            getattr(args, "info", False)
+            and info_start_time is not None
+            and result is not None
+        ):
+            usage_info = result.get("usage")
+            total_tokens = usage_info.get("total_tokens") if usage_info else None
+            prompt_tokens = usage_info.get("prompt_tokens") if usage_info else None
+            completion_tokens = (
+                usage_info.get("completion_tokens") if usage_info else None
+            )
+            elapsed = time.time() - info_start_time
+            console.print(
+                f"[bold green]Total tokens:[/] [yellow]{total_tokens}[/yellow] [bold green]| Input:[/] [cyan]{prompt_tokens}[/cyan] [bold green]| Output:[/] [magenta]{completion_tokens}[/magenta] [bold green]| Elapsed:[/] [yellow]{elapsed:.2f}s[/yellow]",
+                style="dim",
+            )
+    except MaxRoundsExceededError:
+        console.print("[red]Max conversation rounds exceeded.[/red]")
+    except ProviderError as e:
+        console.print(f"[red]Provider error:[/red] {e}")
+    except EmptyResponseError as e:
+        console.print(f"[red]Error:[/red] {e}")
+
 
-    # --- End termweb integration ---
+def run_cli(args):
+    if args.version:
+        print(f"janito version {__version__}")
+        sys.exit(0)
+    normalize_args(args)
+    role = args.role or unified_config.get("role", "software engineer")
+    if args.role:
+        runtime_config.set("role", args.role)
+    interaction_mode = "chat" if not getattr(args, "prompt", None) else "prompt"
+    profile = "base"
+    lang = getattr(args, "lang", None) or runtime_config.get("lang", "en")
+    profile_manager = setup_profile_manager(args, role, interaction_mode, profile, lang)
+    profile_manager.refresh_prompt()
+    if getattr(args, "show_system", False):
+        print(profile_manager.render_prompt())
+        sys.exit(0)
+    termweb_proc, termweb_stdout_path, termweb_stderr_path = handle_termweb(
+        args, interaction_mode
+    )
     try:
-        livereload_stdout_path = None
-        livereload_stderr_path = None
-        continue_session = False
-        session_id = None
+        continue_session, session_id = handle_continue_session(args)
         if getattr(args, "input_arg", None):
             from janito.cli.one_shot import run_oneshot_mode
 
             run_oneshot_mode(args, profile_manager, runtime_config)
             return
-        if not getattr(args, "input_arg", None) or getattr(
-            args, "continue_session", False
-        ):
-            # Determine continue_session and session_id
-            _cont = getattr(args, "continue_session", False)
-            if _cont:
-                continue_session = True
-                session_id = getattr(args, "input_arg", None)
-                if session_id is None:
-                    # Find the most recent session id from .janito/chat_history/*.json
-                    import os
-                    import glob
-
-                    chat_hist_dir = (
-                        os.path.join(os.path.expanduser("~"), ".janito", "chat_history")
-                        if not os.path.isabs(".janito")
-                        else os.path.join(".janito", "chat_history")
-                    )
-                    if not os.path.exists(chat_hist_dir):
-                        session_id = None
-                    else:
-                        files = glob.glob(os.path.join(chat_hist_dir, "*.json"))
-                        if files:
-                            latest = max(files, key=os.path.getmtime)
-                            session_id = os.path.splitext(os.path.basename(latest))[0]
-                        else:
-                            session_id = None
-            else:
-                continue_session = False
-                session_id = None
         import time
 
         info_start_time = None
@@ -179,18 +240,10 @@ def run_cli(args):
             profile_manager,
             continue_session=continue_session,
             session_id=session_id,
-            termweb_stdout_path=(
-                termweb_stdout_path if "termweb_stdout_path" in locals() else None
-            ),
-            termweb_stderr_path=(
-                termweb_stderr_path if "termweb_stderr_path" in locals() else None
-            ),
-            livereload_stdout_path=(
-                livereload_stdout_path if "livereload_stdout_path" in locals() else None
-            ),
-            livereload_stderr_path=(
-                livereload_stderr_path if "livereload_stderr_path" in locals() else None
-            ),
+            termweb_stdout_path=termweb_stdout_path,
+            termweb_stderr_path=termweb_stderr_path,
+            livereload_stdout_path=None,
+            livereload_stderr_path=None,
         )
         if (
             getattr(args, "info", False)
@@ -200,75 +253,12 @@ def run_cli(args):
             elapsed = time.time() - info_start_time
             from rich.console import Console
 
-            console = Console()
             total_tokens = usage_info.get("total_tokens")
+            console = Console()
             console.print(
                 f"[bold green]Total tokens used:[/] [yellow]{total_tokens}[/yellow] [bold green]| Elapsed time:[/] [yellow]{elapsed:.2f}s[/yellow]"
             )
         sys.exit(0)
-        # --- Prompt mode ---
-        prompt = getattr(args, "input_arg", None)
-        from rich.console import Console
-        from janito.agent.rich_message_handler import RichMessageHandler
-
-        console = Console()
-        message_handler = RichMessageHandler()
-        messages = []
-        system_prompt_override = runtime_config.get("system_prompt_template")
-        if system_prompt_override:
-            # Só adiciona system prompt se NÃO for vanilla, ou se foi explicitamente passado via --system
-            if not runtime_config.get("vanilla_mode", False) or getattr(
-                args, "system", None
-            ):
-                messages.append({"role": "system", "content": system_prompt_override})
-        elif profile_manager.system_prompt_template and not runtime_config.get(
-            "vanilla_mode", False
-        ):
-            messages.append(
-                {"role": "system", "content": profile_manager.system_prompt_template}
-            )
-        messages.append({"role": "user", "content": prompt})
-        import time
-
-        info_start_time = None
-        if getattr(args, "info", False):
-            info_start_time = time.time()
-        try:
-            max_rounds = 100
-            from janito.agent.conversation_history import ConversationHistory
-
-            result = profile_manager.agent.chat(
-                ConversationHistory(messages),
-                message_handler=message_handler,
-                spinner=True,
-                max_rounds=max_rounds,
-                stream=getattr(args, "stream", False),
-            )
-            if (
-                getattr(args, "info", False)
-                and info_start_time is not None
-                and result is not None
-            ):
-                usage_info = result.get("usage")
-                total_tokens = usage_info.get("total_tokens") if usage_info else None
-                prompt_tokens = usage_info.get("prompt_tokens") if usage_info else None
-                completion_tokens = (
-                    usage_info.get("completion_tokens") if usage_info else None
-                )
-                elapsed = time.time() - info_start_time
-                from rich.console import Console
-
-                console = Console()
-                console.print(
-                    f"[bold green]Total tokens:[/] [yellow]{total_tokens}[/yellow] [bold green]| Input:[/] [cyan]{prompt_tokens}[/cyan] [bold green]| Output:[/] [magenta]{completion_tokens}[/magenta] [bold green]| Elapsed:[/] [yellow]{elapsed:.2f}s[/yellow]",
-                    style="dim",
-                )
-        except MaxRoundsExceededError:
-            console.print("[red]Max conversation rounds exceeded.[/red]")
-        except ProviderError as e:
-            console.print(f"[red]Provider error:[/red] {e}")
-        except EmptyResponseError as e:
-            console.print(f"[red]Error:[/red] {e}")
     except KeyboardInterrupt:
         from rich.console import Console
 

janito/cli/config_commands.py

@@ -4,12 +4,11 @@ from janito.agent.runtime_config import unified_config, runtime_config
 from janito.agent.config_defaults import CONFIG_DEFAULTS
 from rich import print
 from ._utils import home_shorten
+import os
+from pathlib import Path
 
 
-def handle_config_commands(args):
-    """Handle --set-local-config, --set-global-config, --show-config. Exit if any are used."""
-    did_something = False
-
+def handle_run_config(args):
     if args.run_config:
         for run_item in args.run_config:
             try:
@@ -24,6 +23,11 @@ def handle_config_commands(args):
                 )
                 sys.exit(1)
             runtime_config.set(key, val.strip())
+        return True
+    return False
+
+
+def handle_set_local_config(args):
     if args.set_local_config:
         try:
             key, val = args.set_local_config.split("=", 1)
@@ -40,8 +44,11 @@ def handle_config_commands(args):
         local_config.save()
         runtime_config.set(key, val.strip())
         print(f"Local config updated: {key} = {val.strip()}")
-        did_something = True
+        return True
+    return False
+
 
+def handle_set_global_config(args):
     if args.set_global_config:
         try:
             key, val = args.set_global_config.split("=", 1)
@@ -65,129 +72,111 @@ def handle_config_commands(args):
                 del global_config._data[key]
             runtime_config.set("template", template_dict)
             print(f"Global config updated: template.{subkey} = {val.strip()}")
-            did_something = True
+            return True
         else:
             global_config.set(key, val.strip())
             global_config.save()
             runtime_config.set(key, val.strip())
             print(f"Global config updated: {key} = {val.strip()}")
-            did_something = True
+            return True
+    return False
 
+
+def handle_set_api_key(args):
     if args.set_api_key:
-        # Merge: load full config, update api_key, save all
         existing = dict(global_config.all())
         existing["api_key"] = args.set_api_key.strip()
         global_config._data = existing
         global_config.save()
         runtime_config.set("api_key", args.set_api_key.strip())
         print("Global API key saved.")
-        did_something = True
+        return True
+    return False
+
 
+def handle_show_config(args):
     if args.show_config:
-        local_items = {}
-        global_items = {}
-
-        # Collect and group keys
-        local_keys = set(local_config.all().keys())
-        global_keys = set(global_config.all().keys())
-        if not (local_keys or global_keys):
-            print("No configuration found.")
-        else:
-            # Imports previously inside block to avoid circular import at module level
-            # Handle template as nested dict
-            for key in sorted(local_keys):
-                if key == "template":
-                    template_dict = local_config.get("template", {})
-                    if template_dict:
-                        local_items["template"] = f"({len(template_dict)} keys set)"
-                        for tkey, tval in template_dict.items():
-                            local_items[f"  template.{tkey}"] = tval
-                    continue
-                if key.startswith("template."):
-                    # Skip legacy flat keys
-                    continue
-                if key == "api_key":
-                    value = local_config.get("api_key")
-                    value = (
-                        value[:4] + "..." + value[-4:]
-                        if value and len(value) > 8
-                        else ("***" if value else None)
-                    )
-                else:
-                    value = unified_config.get(key)
-                local_items[key] = value
-            for key in sorted(global_keys - local_keys):
-                if key == "template":
-                    template_dict = global_config.get("template", {})
-                    if template_dict:
-                        global_items["template"] = f"({len(template_dict)} keys set)"
-                        for tkey, tval in template_dict.items():
-                            global_items[f"  template.{tkey}"] = tval
-                    continue
-                if key.startswith("template."):
-                    continue
-                if key == "api_key":
-                    value = global_config.get("api_key")
-                    value = (
-                        value[:4] + "..." + value[-4:]
-                        if value and len(value) > 8
-                        else ("***" if value else None)
-                    )
-                else:
-                    value = unified_config.get(key)
-                global_items[key] = value
-
-            # Mask API key
-            for cfg in (local_items, global_items):
-                if "api_key" in cfg and cfg["api_key"]:
-                    val = cfg["api_key"]
-                    cfg["api_key"] = (
-                        val[:4] + "..." + val[-4:] if len(val) > 8 else "***"
-                    )
-
-            # Print local config
-            from ._print_config import print_config_items
-
-            print_config_items(
-                local_items, color_label="[cyan]🏠 Local Configuration[/cyan]"
-            )
+        local_items = _collect_config_items(local_config, unified_config, True)
+        global_items = _collect_config_items(
+            global_config, unified_config, False, set(local_items.keys())
+        )
+        _mask_api_keys(local_items)
+        _mask_api_keys(global_items)
+        _print_config_items(local_items, global_items)
+        _print_default_items(local_items, global_items)
+        return True
+    return False
 
-            # Print global config
-            print_config_items(
-                global_items, color_label="[yellow]🌐 Global Configuration[/yellow]"
+
+def _collect_config_items(config, unified_config, is_local, exclude_keys=None):
+    items = {}
+    keys = set(config.all().keys())
+    if exclude_keys:
+        keys = keys - set(exclude_keys)
+    for key in sorted(keys):
+        if key == "template":
+            template_dict = config.get("template", {})
+            if template_dict:
+                items["template"] = f"({len(template_dict)} keys set)"
+                for tkey, tval in template_dict.items():
+                    items[f"  template.{tkey}"] = tval
+            continue
+        if key.startswith("template."):
+            continue
+        if key == "api_key":
+            value = config.get("api_key")
+            value = (
+                value[:4] + "..." + value[-4:]
+                if value and len(value) > 8
+                else ("***" if value else None)
             )
+        else:
+            value = unified_config.get(key)
+        items[key] = value
+    return items
+
+
+def _mask_api_keys(cfg):
+    if "api_key" in cfg and cfg["api_key"]:
+        val = cfg["api_key"]
+        cfg["api_key"] = val[:4] + "..." + val[-4:] if len(val) > 8 else "***"
 
-        # Show defaults for unset keys
-        shown_keys = set(local_items.keys()) | set(global_items.keys())
-        default_items = {
-            k: v
-            for k, v in CONFIG_DEFAULTS.items()
-            if k not in shown_keys and k != "api_key"
-        }
-        if default_items:
-            print("[green]🟢 Defaults (not set in config files)[/green]")
-            for key, value in default_items.items():
-                # Special case for system_prompt: show template file if None
-                if key == "system_prompt" and value is None:
-                    from pathlib import Path
-
-                    template_path = (
-                        Path(__file__).parent
-                        / "agent"
-                        / "templates"
-                        / "system_prompt_template_default.j2"
-                    )
-                    print(
-                        f"{key} = (default template path: {home_shorten(str(template_path))})"
-                    )
-                else:
-                    print(f"{key} = {value}")
-            print()
-        did_something = True
-
-    import os
-    from pathlib import Path
 
+def _print_config_items(local_items, global_items):
+    from ._print_config import print_config_items
+
+    print_config_items(local_items, color_label="[cyan]🏠 Local Configuration[/cyan]")
+    print_config_items(
+        global_items, color_label="[yellow]🌐 Global Configuration[/yellow]"
+    )
+
+
+def _print_default_items(local_items, global_items):
+    shown_keys = set(local_items.keys()) | set(global_items.keys())
+    default_items = {
+        k: v
+        for k, v in CONFIG_DEFAULTS.items()
+        if k not in shown_keys and k != "api_key"
+    }
+    if default_items:
+        print("[green]🟢 Defaults (not set in config files)[/green]")
+        for key, value in default_items.items():
+            if key == "system_prompt" and value is None:
+                template_path = (
+                    Path(__file__).parent
+                    / "agent"
+                    / "templates"
+                    / "system_prompt_template_default.j2"
+                )
+                print(
+                    f"{key} = (default template path: {home_shorten(str(template_path))})"
+                )
+            else:
+                print(f"{key} = {value}")
+        print()
+
+
+def handle_config_reset_local(args):
     if getattr(args, "config_reset_local", False):
         local_path = Path(".janito/config.json")
         if local_path.exists():
@@ -196,6 +185,9 @@ def handle_config_commands(args):
         else:
             print(f"Local config file does not exist: {local_path}")
         sys.exit(0)
+
+
+def handle_config_reset_global(args):
     if getattr(args, "config_reset_global", False):
         global_path = Path.home() / ".janito/config.json"
         if global_path.exists():
@@ -204,5 +196,16 @@ def handle_config_commands(args):
         else:
             print(f"Global config file does not exist: {global_path}")
         sys.exit(0)
+
+
+def handle_config_commands(args):
+    did_something = False
+    did_something |= handle_run_config(args)
+    did_something |= handle_set_local_config(args)
+    did_something |= handle_set_global_config(args)
+    did_something |= handle_set_api_key(args)
+    did_something |= handle_show_config(args)
+    handle_config_reset_local(args)
+    handle_config_reset_global(args)
     if did_something:
         sys.exit(0)