janito 1.14.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/cli/arg_parser.py

@@ -1,272 +0,0 @@
-import argparse
-
-
-def create_parser():
-    # Adiciona --list-tools para listar ferramentas registradas
-    # (adição incremental segura)
-
-    parser = argparse.ArgumentParser(
-        description="OpenRouter API call using OpenAI Python SDK"
-    )
-    # The positional argument is interpreted as either a prompt or session_id depending on context
-    parser.add_argument(
-        "input_arg",
-        type=str,
-        nargs="?",
-        help="Prompt to send to the model, or session ID if --continue is used.",
-    )
-
-    parser.add_argument(
-        "--list",
-        nargs="?",
-        type=int,
-        const=10,
-        default=None,
-        help="List the last N sessions (default: 10) and exit.",
-    )
-    parser.add_argument(
-        "--view",
-        type=str,
-        default=None,
-        help="View the content of a conversation history by session id and exit.",
-    )
-    parser.add_argument(
-        "--set-provider-config",
-        nargs=3,
-        metavar=("NAME", "KEY", "VALUE"),
-        help="Set a provider config parameter (e.g., --set-provider-config openai api_key sk-xxx).",
-    )
-    parser.add_argument(
-        "--lang",
-        type=str,
-        default=None,
-        help="Language for interface messages (e.g., en, pt). Overrides config if set.",
-    )
-
-    parser.add_argument(
-        "--app-shell",
-        action="store_true",
-        help="Use the new prompt_toolkit Application-based chat shell (experimental)",
-    )
-    parser.add_argument(
-        "--max-tokens",
-        type=int,
-        default=None,
-        help="Maximum tokens for model response (overrides config, default: 32000)",
-    )
-    parser.add_argument(
-        "--max-tools",
-        type=int,
-        default=None,
-        help="Maximum number of tool calls allowed within a chat session (default: unlimited)",
-    )
-    parser.add_argument(
-        "--model",
-        "-m",
-        type=str,
-        default=None,
-        help="Model name to use for this session (overrides config, does not persist)",
-    )
-    parser.add_argument(
-        "--max-rounds",
-        type=int,
-        default=None,
-        help="Maximum number of agent rounds per prompt (overrides config, default: 50)",
-    )
-
-    # Mutually exclusive group for system prompt options
-    group = parser.add_mutually_exclusive_group()
-    group.add_argument(
-        "-s",
-        "--system",
-        type=str,
-        default=None,
-        help="Optional system prompt as a raw string.",
-    )
-    group.add_argument(
-        "--system-file",
-        type=str,
-        default=None,
-        help="Path to a plain text file to use as the system prompt (no template rendering, takes precedence over --system-prompt)",
-    )
-
-    parser.add_argument(
-        "-r",
-        "--role",
-        type=str,
-        default=None,
-        help="Role description for the default system prompt",
-    )
-    parser.add_argument(
-        "-t",
-        "--temperature",
-        type=float,
-        default=None,
-        help="Sampling temperature (e.g., 0.0 - 2.0)",
-    )
-    parser.add_argument(
-        "--verbose-http", action="store_true", help="Enable verbose HTTP logging"
-    )
-    parser.add_argument(
-        "--verbose-http-raw",
-        action="store_true",
-        help="Enable raw HTTP wire-level logging",
-    )
-    parser.add_argument(
-        "--verbose-response",
-        action="store_true",
-        help="Pretty print the full response object",
-    )
-    parser.add_argument(
-        "--list-tools",
-        action="store_true",
-        help="Lista todas as ferramentas registradas e sai.",
-    )
-    parser.add_argument(
-        "--show-system",
-        action="store_true",
-        help="Show model, parameters, system prompt, and tool definitions, then exit",
-    )
-    parser.add_argument(
-        "--verbose-reason",
-        action="store_true",
-        help="Print the tool call reason whenever a tool is invoked (for debugging)",
-    )
-    parser.add_argument(
-        "--verbose-tools",
-        action="store_true",
-        help="Print tool call parameters and results",
-    )
-    parser.add_argument(
-        "-n",
-        "--no-tools",
-        action="store_true",
-        default=False,
-        help="Disable tool use (default: enabled)",
-    )
-    parser.add_argument(
-        "--set-local-config",
-        type=str,
-        default=None,
-        help='Set a local config key-value pair, format "key=val"',
-    )
-    parser.add_argument(
-        "--set-global-config",
-        type=str,
-        default=None,
-        help='Set a global config key-value pair, format "key=val"',
-    )
-    parser.add_argument(
-        "--run-config",
-        type=str,
-        action="append",
-        default=None,
-        help='Set a runtime (in-memory only) config key-value pair, format "key=val". Can be repeated.',
-    )
-    parser.add_argument(
-        "--show-config",
-        action="store_true",
-        help="Show effective configuration and exit",
-    )
-    parser.add_argument(
-        "--set-api-key",
-        type=str,
-        default=None,
-        help="Set and save the API key globally",
-    )
-    parser.add_argument(
-        "--version", action="store_true", help="Show program's version number and exit"
-    )
-    parser.add_argument(
-        "--help-config",
-        action="store_true",
-        help="Show all configuration options and exit",
-    )
-    parser.add_argument(
-        "--continue-session",
-        "--continue",
-        action="store_true",
-        default=False,
-        help="Continue from a saved conversation. Uses the session ID from the positional argument if provided, otherwise resumes the most recent session.",
-    )
-    parser.add_argument(
-        "--web", action="store_true", help="Launch the Janito web server instead of CLI"
-    )
-    parser.add_argument(
-        "--live",
-        action="store_true",
-        help="Launch the Janito live reload server for web development",
-    )
-    parser.add_argument(
-        "--config-reset-local",
-        action="store_true",
-        help="Remove the local config file (~/.janito/config.json)",
-    )
-    parser.add_argument(
-        "--config-reset-global",
-        action="store_true",
-        help="Remove the global config file (~/.janito/config.json)",
-    )
-    parser.add_argument(
-        "--verbose-events",
-        action="store_true",
-        help="Print all agent events before dispatching to the message handler (for debugging)",
-    )
-    parser.add_argument(
-        "--verbose-messages",
-        action="store_true",
-        help="Print every new message added to the conversation history with a colored background.",
-    )
-    parser.add_argument(
-        "-V",
-        "--vanilla",
-        action="store_true",
-        default=False,
-        help="Vanilla mode: disables tools, system prompt, and temperature (unless -t is set)",
-    )
-    parser.add_argument(
-        "-T",
-        "--trust-tools",
-        action="store_true",
-        help="Suppress all tool output (trusted tools mode: only shows output file locations)",
-    )
-    parser.add_argument(
-        "--profile",
-        type=str,
-        default=None,
-        help="Agent Profile name (only 'base' is supported)",
-    )
-    parser.add_argument(
-        "--no-termweb",
-        action="store_true",
-        help="Disable the built-in lightweight web file viewer for terminal links (enabled by default)",
-    )
-    parser.add_argument(
-        "--termweb-port",
-        type=int,
-        default=8088,
-        help="Port for the termweb server (default: 8088)",
-    )
-    parser.add_argument(
-        "-i",
-        "--info",
-        action="store_true",
-        help="Show basic program info and exit (useful for one-shot shell execution)",
-    )
-    parser.add_argument(
-        "--ntt",
-        action="store_true",
-        help="Disable tool call reason tracking (no tools tracking)",
-    )
-    parser.add_argument(
-        "--all-out",
-        action="store_true",
-        help="Stream all output live to both the model and the screen, and do not store output in files. (use --all-out)",
-    )
-    parser.add_argument(
-        "--tool-user",
-        action="store_true",
-        default=False,
-        help="When set, tool responses will use role 'user' instead of 'tool' in the conversation history.",
-    )
-    return parser

janito/cli/cli_main.py

@@ -1,281 +0,0 @@
-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
-from janito.agent.config import get_api_key
-from janito import __version__
-from janito.agent.conversation_exceptions import (
-    MaxRoundsExceededError,
-    EmptyResponseError,
-    ProviderError,
-)
-from janito.shell.main import start_chat_shell
-
-
-def is_port_free(port):
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        return s.connect_ex(("localhost", port)) != 0
-
-
-def _set_runtime_flags(args, flags):
-    for flag in flags:
-        if hasattr(args, flag):
-            runtime_config.set(flag, getattr(args, flag, False))
-
-
-def _set_runtime_if_present(args, attr, config_key=None):
-    if getattr(args, attr, None) is not None:
-        runtime_config.set(config_key or attr, getattr(args, attr))
-
-
-def normalize_args(args):
-    if getattr(args, "vanilla", False):
-        runtime_config.set("vanilla_mode", True)
-    if getattr(args, "ntt", False):
-        runtime_config.set("no_tools_tracking", True)
-    if getattr(args, "all_out", False):
-        runtime_config.set("all_out", True)
-    _set_runtime_flags(
-        args,
-        [
-            "verbose_http",
-            "verbose_http_raw",
-            "verbose_response",
-            "verbose_reason",
-            "verbose_tools",
-            "verbose_events",
-            "verbose_messages",
-        ],
-    )
-    if getattr(args, "trust_tools", False):
-        runtime_config.set("trust_tools", True)
-    _set_runtime_if_present(args, "model")
-    _set_runtime_if_present(args, "max_tools")
-    if getattr(args, "verbose_reason", False):
-        runtime_config.set("verbose_reason", True)
-    _set_runtime_if_present(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", ""),
-        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,
-    )
-
-
-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)
-    ):
-        default_port = 8088
-        max_port = 8100
-        requested_port = args.termweb_port
-        if requested_port == default_port:
-            for port in range(default_port, max_port + 1):
-                if is_port_free(port):
-                    selected_port = port
-                    break
-            if selected_port is None:
-                from rich.console import Console
-
-                console = Console()
-                console.print(
-                    f"[red]No free port found for termweb in range {default_port}-{max_port}.[/red]"
-                )
-                sys.exit(1)
-        else:
-            if not is_port_free(requested_port):
-                from rich.console import Console
-
-                console = Console()
-                console.print(
-                    f"[red]Port {requested_port} is not available for termweb.[/red]"
-                )
-                sys.exit(1)
-            selected_port = requested_port
-        runtime_config.set("termweb_port", selected_port)
-        from janito.cli.termweb_starter import start_termweb
-
-        termweb_proc, started, termweb_stdout_path, termweb_stderr_path = start_termweb(
-            selected_port
-        )
-        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}")
-
-
-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:
-        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
-        import time
-
-        info_start_time = None
-        if getattr(args, "info", False):
-            info_start_time = time.time()
-        usage_info = start_chat_shell(
-            profile_manager,
-            continue_session=continue_session,
-            session_id=session_id,
-            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)
-            and usage_info is not None
-            and info_start_time is not None
-        ):
-            elapsed = time.time() - info_start_time
-            from rich.console import 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)
-    except KeyboardInterrupt:
-        from rich.console import Console
-
-        console = Console()
-        console.print("[yellow]Interrupted by user.[/yellow]")
-    finally:
-        if termweb_proc:
-            termweb_proc.terminate()
-            termweb_proc.wait()