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

janito/cli/config_commands.py

@@ -1,211 +0,0 @@
-import sys
-from janito.agent.config import local_config, global_config, CONFIG_OPTIONS
-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_run_config(args):
-    if args.run_config:
-        for run_item in args.run_config:
-            try:
-                key, val = run_item.split("=", 1)
-            except ValueError:
-                print("Invalid format for --run-config, expected key=val")
-                sys.exit(1)
-            key = key.strip()
-            if key not in CONFIG_OPTIONS:
-                print(
-                    f"Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}"
-                )
-                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)
-        except ValueError:
-            print("Invalid format for --set-local-config, expected key=val")
-            sys.exit(1)
-        key = key.strip()
-        if key not in CONFIG_OPTIONS:
-            print(
-                f"Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}"
-            )
-            sys.exit(1)
-        local_config.set(key, val.strip())
-        local_config.save()
-        runtime_config.set(key, val.strip())
-        print(f"Local config updated: {key} = {val.strip()}")
-        return True
-    return False
-
-
-def handle_set_global_config(args):
-    if args.set_global_config:
-        try:
-            key, val = args.set_global_config.split("=", 1)
-        except ValueError:
-            print("Invalid format for --set-global-config, expected key=val")
-            sys.exit(1)
-        key = key.strip()
-        if key not in CONFIG_OPTIONS and not key.startswith("template."):
-            print(
-                f"Invalid config key: '{key}'. Supported keys are: {', '.join(CONFIG_OPTIONS.keys())}"
-            )
-            sys.exit(1)
-        if key.startswith("template."):
-            subkey = key[len("template.") :]
-            template_dict = global_config.get("template", {})
-            template_dict[subkey] = val.strip()
-            global_config.set("template", template_dict)
-            global_config.save()
-            # Remove legacy flat key if present
-            if key in global_config._data:
-                del global_config._data[key]
-            runtime_config.set("template", template_dict)
-            print(f"Global config updated: template.{subkey} = {val.strip()}")
-            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()}")
-            return True
-    return False
-
-
-def handle_set_api_key(args):
-    if args.set_api_key:
-        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.")
-        return True
-    return False
-
-
-def handle_show_config(args):
-    if args.show_config:
-        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
-
-
-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 "***"
-
-
-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():
-            os.remove(local_path)
-            print(f"Removed local config file: {local_path}")
-        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():
-            os.remove(global_path)
-            print(f"Removed global config file: {global_path}")
-        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/cli/config_runner.py

@@ -1,35 +0,0 @@
-from janito.agent.profile_manager import AgentProfileManager
-from janito.agent.runtime_config import unified_config, runtime_config
-from janito.agent.config import get_api_key
-
-
-def get_system_prompt_template(args, role):
-    system_prompt_template = None
-    if getattr(args, "system_prompt_template_file", None):
-        with open(args.system_prompt_template_file, "r", encoding="utf-8") as f:
-            system_prompt_template = f.read()
-        runtime_config.set(
-            "system_prompt_template_file", args.system_prompt_template_file
-        )
-    else:
-        system_prompt_template = getattr(
-            args, "system_prompt_template", None
-        ) or unified_config.get("system_prompt_template")
-        if getattr(args, "system_prompt_template", None):
-            runtime_config.set("system_prompt_template", system_prompt_template)
-        if system_prompt_template is None:
-            profile_manager = AgentProfileManager(
-                api_key=get_api_key(),
-                model=unified_config.get("model"),
-                role=role,
-                profile_name="base",
-                interaction_mode=unified_config.get("interaction_mode", "prompt"),
-                verbose_tools=unified_config.get("verbose_tools", False),
-                base_url=unified_config.get("base_url", None),
-                azure_openai_api_version=unified_config.get(
-                    "azure_openai_api_version", "2023-05-15"
-                ),
-                use_azure_openai=unified_config.get("use_azure_openai", False),
-            )
-            system_prompt_template = profile_manager.system_prompt_template
-    return system_prompt_template

janito/cli/formatting_runner.py

@@ -1,12 +0,0 @@
-def format_tokens(n):
-    if n is None:
-        return "?"
-    try:
-        n = int(n)
-    except (TypeError, ValueError):
-        return str(n)
-    if n >= 1_000_000:
-        return f"{n/1_000_000:.1f}m"
-    if n >= 1_000:
-        return f"{n/1_000:.1f}k"
-    return str(n)

janito/cli/livereload_starter.py

@@ -1,60 +0,0 @@
-import sys
-import subprocess
-import tempfile
-import time
-import http.client
-import os
-from rich.console import Console
-
-
-def wait_for_livereload(port, timeout=3.0):
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        try:
-            conn = http.client.HTTPConnection("localhost", port, timeout=0.5)
-            conn.request("GET", "/")
-            resp = conn.getresponse()
-            if resp.status in (200, 404):
-                return True
-        except Exception:
-            pass
-        time.sleep(0.1)
-    return False
-
-
-def start_livereload(selected_port):
-    console = Console()
-    with console.status("[cyan]Starting live reload server...", spinner="dots"):
-        app_py_path = os.path.join(
-            os.path.dirname(__file__), "..", "livereload", "app.py"
-        )
-        app_py_path = os.path.abspath(app_py_path)
-        if not os.path.isfile(app_py_path):
-            console.print("[red]Could not find livereload app.py![/red]")
-            return None, False, None, None
-        livereload_stdout = tempfile.NamedTemporaryFile(
-            delete=False, mode="w+", encoding="utf-8"
-        )
-        livereload_stderr = tempfile.NamedTemporaryFile(
-            delete=False, mode="w+", encoding="utf-8"
-        )
-        livereload_proc = subprocess.Popen(
-            [sys.executable, app_py_path, "--port", str(selected_port)],
-            stdout=livereload_stdout,
-            stderr=livereload_stderr,
-        )
-        if wait_for_livereload(selected_port, timeout=3.0):
-            console.print(
-                f"LiveReload started... Available at http://localhost:{selected_port}"
-            )
-            return livereload_proc, True, livereload_stdout.name, livereload_stderr.name
-        else:
-            livereload_proc.terminate()
-            livereload_proc.wait()
-            from janito.cli._livereload_log_utils import print_livereload_logs
-
-            console.print(
-                f"[red]Failed to start LiveReload on port {selected_port}. Check logs for details.[/red]"
-            )
-            print_livereload_logs(livereload_stdout.name, livereload_stderr.name)
-            return None, False, livereload_stdout.name, livereload_stderr.name

janito/cli/logging_setup.py

@@ -1,38 +0,0 @@
-import os
-import logging
-
-
-from janito.agent.runtime_config import runtime_config
-
-
-def setup_verbose_logging(args):
-    if runtime_config.get("verbose_http", False) or runtime_config.get(
-        "verbose_http_raw", False
-    ):
-        httpx_logger = logging.getLogger("httpx")
-        httpx_logger.setLevel(logging.DEBUG)
-        handler = logging.StreamHandler()
-        handler.setFormatter(
-            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-        )
-        httpx_logger.addHandler(handler)
-
-    if runtime_config.get("verbose_http_raw", False):
-        os.environ["HTTPX_LOG_LEVEL"] = "trace"
-
-        httpcore_logger = logging.getLogger("httpcore")
-        httpcore_logger.setLevel(logging.DEBUG)
-        handler_core = logging.StreamHandler()
-        handler_core.setFormatter(
-            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-        )
-        httpcore_logger.addHandler(handler_core)
-
-        # Re-add handler to httpx logger in case
-        httpx_logger = logging.getLogger("httpx")
-        httpx_logger.setLevel(logging.DEBUG)
-        handler = logging.StreamHandler()
-        handler.setFormatter(
-            logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-        )
-        httpx_logger.addHandler(handler)

janito/cli/one_shot.py

@@ -1,80 +0,0 @@
-from janito.agent.conversation_exceptions import (
-    MaxRoundsExceededError,
-    ProviderError,
-    EmptyResponseError,
-)
-from janito.agent.api_exceptions import ApiError
-from janito.agent.llm_conversation_history import LLMConversationHistory
-
-
-def prepare_messages(args, profile_manager, runtime_config):
-    prompt = getattr(args, "input_arg", None)
-    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})
-    return messages
-
-
-def print_usage_info(args, info_start_time, result, console):
-    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",
-        )
-
-
-def run_oneshot_mode(args, profile_manager, runtime_config):
-    from rich.console import Console
-    from janito.agent.rich_message_handler import RichMessageHandler
-    import time
-
-    console = Console()
-    message_handler = RichMessageHandler()
-    messages = prepare_messages(args, profile_manager, runtime_config)
-    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,
-        )
-        print_usage_info(args, info_start_time, result, console)
-    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 ApiError as e:
-        if "maximum context length" in str(e):
-            console.print(
-                f"[red]Error:[/red] {e}\n[bold yellow]Tip:[/] Try using [green]--max-tokens[/green] with a lower value."
-            )
-        else:
-            console.print(f"[red]API error:[/red] {e}")
-    except Exception:
-        raise

janito/livereload/app.py

@@ -1,25 +0,0 @@
-import sys
-import os
-from livereload import Server
-
-
-def main():
-    port = 35729  # Default livereload port
-    if "--port" in sys.argv:
-        idx = sys.argv.index("--port")
-        if idx + 1 < len(sys.argv):
-            try:
-                port = int(sys.argv[idx + 1])
-            except ValueError:
-                pass
-    watch_dir = os.path.abspath(os.getcwd())
-    server = Server()
-    server.watch(watch_dir, delay=1)
-    print(
-        f"Starting livereload server on http://localhost:{port}, watching {watch_dir}"
-    )
-    server.serve(root=watch_dir, port=port, open_url_delay=None)
-
-
-if __name__ == "__main__":
-    main()

janito/rich_utils.py

@@ -1,59 +0,0 @@
-"""
-Utilities for working with the Rich library.
-"""
-
-from rich.console import Console
-from typing import Optional
-
-
-class RichPrinter:
-    """
-    Utility class for printing styled messages using the Rich library.
-
-    Args:
-        console (Optional[Console]): An optional Rich Console instance. If not provided, a default Console will be created.
-
-    Methods:
-        print_info(message: str)
-            Print an informational message in cyan (no newline at end).
-
-        print_error(message: str)
-            Print an error message in bold red.
-
-        print_warning(message: str)
-            Print a warning message in bold yellow.
-
-        print_magenta(message: str)
-            Print a message in magenta.
-    """
-
-    def __init__(self, console: Optional[Console] = None):
-        self.console = console or Console()
-
-    def print_info(self, message: str):
-        self.console.print(message, style="cyan", end="")
-
-    def print_error(self, message: str):
-        self.console.print(message, style="bold red", end="\n")
-
-    def print_warning(self, message: str):
-        self.console.print(message, style="bold yellow", end="\n")
-
-    def print_magenta(self, message: str):
-        self.console.print(message, style="magenta", end="\n")
-
-    def print_colored_message(self, message: str, color_index: int = 0):
-        """
-        Print a message with a cycling background color for verbose-messages.
-        """
-        bg_colors = [
-            "on blue",
-            "on green",
-            "on magenta",
-            "on cyan",
-            "on yellow",
-            "on red",
-            "on bright_black",
-        ]
-        style = f"bold white {bg_colors[color_index % len(bg_colors)]}"
-        self.console.print(message, style=style, end="\n")

janito/shell/commands/__init__.py

@@ -1,61 +0,0 @@
-from .session import handle_history
-from .prompt import handle_prompt, handle_role
-from .session_control import handle_exit
-from .conversation_restart import handle_restart
-from .utility import handle_help, handle_clear, handle_multi
-from .tools import handle_tools
-from .termweb_log import handle_termweb_log_tail, handle_termweb_status
-from .livelogs import handle_livelogs
-from .edit import handle_edit
-from .history_view import handle_view
-from janito.shell.session.config import handle_config_shell
-from .verbose import handle_verbose
-from .lang import handle_lang
-from janito.agent.runtime_config import runtime_config
-from .track import handle_track
-
-COMMAND_HANDLERS = {
-    "/termweb-logs": handle_termweb_log_tail,
-    "/livelogs": handle_livelogs,
-    "/termweb-status": handle_termweb_status,
-    "/edit": handle_edit,
-    "/history": handle_history,
-    "/exit": handle_exit,
-    "exit": handle_exit,
-    "/restart": handle_restart,
-    "/start": handle_restart,
-    "/help": handle_help,
-    "/multi": handle_multi,
-    "/prompt": handle_prompt,
-    "/tools": handle_tools,
-    "/verbose": handle_verbose,
-}
-
-if not runtime_config.get("vanilla_mode", False):
-    COMMAND_HANDLERS["/role"] = handle_role
-
-COMMAND_HANDLERS["/lang"] = handle_lang
-COMMAND_HANDLERS["/track"] = handle_track
-
-COMMAND_HANDLERS.update(
-    {
-        "/clear": handle_clear,
-        "/restart": handle_restart,
-        "/config": handle_config_shell,
-        "/view": handle_view,
-    }
-)
-
-
-def handle_command(command, console, shell_state=None):
-    parts = command.strip().split()
-    cmd = parts[0]
-    args = parts[1:]
-    handler = COMMAND_HANDLERS.get(cmd)
-    if handler:
-        # Pass shell_state and args as keyword arguments for handlers that expect them
-        return handler(console, args=args, shell_state=shell_state)
-    console.print(
-        f"[bold red]Invalid command: {cmd}. Type /help for a list of commands.[/bold red]"
-    )
-    return None

janito/shell/commands/config.py

@@ -1,22 +0,0 @@
-def handle_reload(console, *args, **kwargs):
-    from janito.shell.prompt.load_prompt import load_prompt
-
-    agent = kwargs.get("agent")
-    state = kwargs.get("state")
-    filename = args[0] if args else None
-    try:
-        prompt_text = load_prompt(filename)
-        if hasattr(agent, "system_prompt_template"):
-            agent.system_prompt_template = prompt_text
-        # Update the first system message in the conversation if present
-        history = state.get("history") if state else None
-        if history:
-            for msg in history:
-                if msg.get("role") == "system":
-                    msg["content"] = prompt_text
-                    break
-        console.print(
-            f"[bold green]System prompt reloaded from {'default file' if not filename else filename}![/bold green]"
-        )
-    except Exception as e:
-        console.print(f"[bold red]Failed to reload system prompt:[/bold red] {e}")

janito/shell/commands/edit.py

@@ -1,24 +0,0 @@
-import os
-import webbrowser
-from janito.agent.runtime_config import runtime_config
-
-
-def handle_edit(console, args=None, shell_state=None, **kwargs):
-    if not args or len(args) < 1:
-        console.print("[red]Usage: /edit <filename>[/red]")
-        return
-    filename = args[0]
-    if not os.path.isfile(filename):
-        console.print(f"[red]File not found:[/red] {filename}")
-        return
-    port = getattr(shell_state, "termweb_port", None) or runtime_config.get(
-        "termweb_port", 8080
-    )
-    url = f"http://localhost:{port}/?path={filename}"
-    console.print(
-        f"[green]Opening in browser:[/green] [underline blue]{url}[/underline blue]"
-    )
-    webbrowser.open(url)
-
-
-handle_edit.help_text = "Open a file in the browser-based editor"

janito/shell/commands/history_view.py

@@ -1,18 +0,0 @@
-def handle_view(console, args=None, shell_state=None, **kwargs):
-    messages = shell_state.conversation_history.get_messages()
-    if not messages:
-        console.print("[yellow]Conversation history is empty.[/yellow]")
-        return
-    for i, msg in enumerate(messages, 1):
-        role = msg.get("role", "?")
-        content = msg.get("content", "")
-        tool_calls = msg.get("tool_calls")
-        tool_call_id = msg.get("tool_call_id")
-        console.print(f"[bold]{i}. {role}:[/bold] {content}")
-        if tool_calls:
-            console.print(f"   [cyan]tool_calls:[/cyan] {tool_calls}")
-        if tool_call_id:
-            console.print(f"   [magenta]tool_call_id:[/magenta] {tool_call_id}")
-
-
-handle_view.help_text = "Print the current LLM conversation history"

janito/shell/commands/lang.py

@@ -1,19 +0,0 @@
-from janito.agent.runtime_config import runtime_config
-import janito.i18n as i18n
-
-
-def handle_lang(console, args=None, **kwargs):
-    if not args or len(args) == 0:
-        console.print(
-            "[bold yellow]Uso: /lang [código_idioma] (ex: pt, en, es)[/bold yellow]"
-        )
-        return
-    lang_code = args[0]
-    runtime_config.set("lang", lang_code)
-    i18n.set_locale(lang_code)
-    console.print(
-        f"[bold green]Idioma alterado para:[/bold green] [cyan]{lang_code}[/cyan]"
-    )
-
-
-handle_lang.help_text = "Change the interface language (e.g., /lang en)"