janito 1.10.0__py3-none-any.whl → 1.11.1__py3-none-any.whl

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)

janito/shell/main.py

@@ -158,6 +158,50 @@ def handle_prompt_loop(
     save_conversation_history(conversation_history, session_id)
 
 
+def handle_keyboard_interrupt(conversation_history, message_handler):
+    removed_count = 0
+    while (
+        conversation_history.last_message()
+        and conversation_history.last_message().get("role") != "assistant"
+    ):
+        conversation_history.remove_last_message()
+        removed_count += 1
+    # Remove the assistant message itself, if present
+    if (
+        conversation_history.last_message()
+        and conversation_history.last_message().get("role") == "assistant"
+    ):
+        conversation_history.remove_last_message()
+        removed_count += 1
+    message_handler.handle_message(
+        {
+            "type": "info",
+            "message": f"\nLast turn cleared due to interruption. Returning to prompt. (removed {removed_count} last msgs)\n",
+        }
+    )
+
+
+def handle_chat_error(message_handler, error_type, error):
+    if error_type == "ProviderError":
+        message_handler.handle_message(
+            {"type": "error", "message": f"Provider error: {error}"}
+        )
+    elif error_type == "EmptyResponseError":
+        message_handler.handle_message({"type": "error", "message": f"Error: {error}"})
+    elif error_type == "ApiError":
+        message_handler.handle_message({"type": "error", "message": str(error)})
+    elif error_type == "Exception":
+        import traceback
+
+        tb = traceback.format_exc()
+        message_handler.handle_message(
+            {
+                "type": "error",
+                "message": f"Unexpected error: {error}\n{tb}\nReturning to prompt.",
+            }
+        )
+
+
 def handle_chat(shell_state, profile_manager, agent, max_rounds, session_id):
     conversation_history = shell_state.conversation_history
     message_handler = RichMessageHandler()
@@ -171,20 +215,19 @@ def handle_chat(shell_state, profile_manager, agent, max_rounds, session_id):
             spinner=True,
         )
     except KeyboardInterrupt:
-        message_handler.handle_message(
-            {"type": "info", "message": "Request interrupted. Returning to prompt."}
-        )
+        handle_keyboard_interrupt(conversation_history, message_handler)
         return
     except ProviderError as e:
-        message_handler.handle_message(
-            {"type": "error", "message": f"Provider error: {e}"}
-        )
+        handle_chat_error(message_handler, "ProviderError", e)
         return
     except EmptyResponseError as e:
-        message_handler.handle_message({"type": "error", "message": f"Error: {e}"})
+        handle_chat_error(message_handler, "EmptyResponseError", e)
         return
     except ApiError as e:
-        message_handler.handle_message({"type": "error", "message": str(e)})
+        handle_chat_error(message_handler, "ApiError", e)
+        return
+    except Exception as e:
+        handle_chat_error(message_handler, "Exception", e)
         return
     shell_state.last_elapsed = time.time() - start_time
     usage = response.get("usage")

janito/shell/session/config.py

@@ -12,90 +12,98 @@ def handle_config_shell(console, *args, **kwargs):
     /config reset global
     """
     if not args or args[0] not in ("show", "set", "reset"):
-        console.print(
-            "[bold red]Usage:[/bold red] /config show | /config set local|global key=value | /config reset local|global"
-        )
+        _print_usage(console)
         return
-
     if args[0] == "show":
-        # Show config, unified with CLI
-        from janito.cli._print_config import print_full_config
-
-        print_full_config(
-            local_config,
-            global_config,
-            unified_config,
-            CONFIG_DEFAULTS,
-            console=console,
-        )
+        _show_config(console)
         return
-
     if args[0] == "reset":
-        if len(args) < 2 or args[1] not in ("local", "global"):
-            console.print("[bold red]Usage:[/bold red] /config reset local|global")
-            return
-        import os
-        from pathlib import Path
+        _reset_config(console, args)
+        return
+    if args[0] == "set":
+        _set_config(console, args)
+        return
 
-        scope = args[1]
-        if scope == "local":
-            local_path = Path(".janito/config.json")
-            if local_path.exists():
-                os.remove(local_path)
-                console.print(f"[green]Removed local config file:[/green] {local_path}")
-            else:
-                console.print(
-                    f"[yellow]Local config file does not exist:[/yellow] {local_path}"
-                )
-        elif scope == "global":
-            global_path = Path.home() / ".janito/config.json"
-            if global_path.exists():
-                os.remove(global_path)
-                console.print(
-                    f"[green]Removed global config file:[/green] {global_path}"
-                )
-            else:
-                console.print(
-                    f"[yellow]Global config file does not exist:[/yellow] {global_path}"
-                )
-        console.print(
-            "[bold yellow]Please use /restart for changes to take full effect.[/bold yellow]"
-        )
+
+def _print_usage(console):
+    console.print(
+        "[bold red]Usage:[/bold red] /config show | /config set local|global key=value | /config reset local|global"
+    )
+
+
+def _show_config(console):
+    from janito.cli._print_config import print_full_config
+
+    print_full_config(
+        local_config,
+        global_config,
+        unified_config,
+        CONFIG_DEFAULTS,
+        console=console,
+    )
+
+
+def _reset_config(console, args):
+    if len(args) < 2 or args[1] not in ("local", "global"):
+        console.print("[bold red]Usage:[/bold red] /config reset local|global")
         return
+    import os
+    from pathlib import Path
 
-    if args[0] == "set":
-        if len(args) < 3 or args[1] not in ("local", "global"):
-            console.print(
-                "[bold red]Usage:[/bold red] /config set local|global key=value"
-            )
-            return
-        scope = args[1]
-        try:
-            key, val = args[2].split("=", 1)
-        except ValueError:
-            console.print("[bold red]Invalid format, expected key=val[/bold red]")
-            return
-        key = key.strip()
-        if key not in CONFIG_OPTIONS and not key.startswith("template."):
-            console.print(
-                f"[bold red]Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}"
-            )
-            return
-        val = val.strip()
-        if scope == "local":
-            local_config.set(key, val)
-            local_config.save()
-            runtime_config.set(key, val)
-            console.print(f"[green]Local config updated:[/green] {key} = {val}")
+    scope = args[1]
+    if scope == "local":
+        local_path = Path(".janito/config.json")
+        if local_path.exists():
+            os.remove(local_path)
+            console.print(f"[green]Removed local config file:[/green] {local_path}")
+        else:
             console.print(
-                "[bold yellow]Please use /restart for changes to take full effect.[/bold yellow]"
+                f"[yellow]Local config file does not exist:[/yellow] {local_path}"
             )
-        elif scope == "global":
-            global_config.set(key, val)
-            global_config.save()
-            runtime_config.set(key, val)
-            console.print(f"[green]Global config updated:[/green] {key} = {val}")
+    elif scope == "global":
+        global_path = Path.home() / ".janito/config.json"
+        if global_path.exists():
+            os.remove(global_path)
+            console.print(f"[green]Removed global config file:[/green] {global_path}")
+        else:
             console.print(
-                "[bold yellow]Please use /restart for changes to take full effect.[/bold yellow]"
+                f"[yellow]Global config file does not exist:[/yellow] {global_path}"
             )
+    console.print(
+        "[bold yellow]Please use /restart for changes to take full effect.[/bold yellow]"
+    )
+
+
+def _set_config(console, args):
+    if len(args) < 3 or args[1] not in ("local", "global"):
+        console.print("[bold red]Usage:[/bold red] /config set local|global key=value")
         return
+    scope = args[1]
+    try:
+        key, val = args[2].split("=", 1)
+    except ValueError:
+        console.print("[bold red]Invalid format, expected key=val[/bold red]")
+        return
+    key = key.strip()
+    if key not in CONFIG_OPTIONS and not key.startswith("template."):
+        console.print(
+            f"[bold red]Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}"
+        )
+        return
+    val = val.strip()
+    if scope == "local":
+        local_config.set(key, val)
+        local_config.save()
+        runtime_config.set(key, val)
+        console.print(f"[green]Local config updated:[/green] {key} = {val}")
+        console.print(
+            "[bold yellow]Please use /restart for changes to take full effect.[/bold yellow]"
+        )
+    elif scope == "global":
+        global_config.set(key, val)
+        global_config.save()
+        runtime_config.set(key, val)
+        console.print(f"[green]Global config updated:[/green] {key} = {val}")
+        console.print(
+            "[bold yellow]Please use /restart for changes to take full effect.[/bold yellow]"
+        )