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

janito/cli/cli_main.py

@@ -0,0 +1,270 @@
+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 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)
+    for flag in [
+        "verbose_http",
+        "verbose_http_raw",
+        "verbose_response",
+        "verbose_reason",
+        "verbose_tools",
+        "verbose_events",
+        "verbose_messages",
+    ]:
+        if hasattr(args, flag):
+            runtime_config.set(flag, getattr(args, flag, False))
+    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, "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", ""),
+        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()

janito/cli/livereload_starter.py

@@ -0,0 +1,60 @@
+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/main.py

@@ -3,133 +3,200 @@
 from janito.cli.arg_parser import create_parser
 from janito.cli.config_commands import handle_config_commands
 from janito.cli.logging_setup import setup_verbose_logging
-from janito.cli.runner.cli_main import run_cli
+from janito.cli.cli_main import run_cli
 from janito.agent.runtime_config import unified_config
+from janito.cli.livereload_starter import start_livereload
 
 # Ensure all tools are registered at startup
 import janito.agent.tools  # noqa: F401
 from janito.i18n import tr
 
 
-def main():
-    """Unified entry point for the Janito CLI and web server."""
-    import sys
-
-    from janito.agent.config import local_config, global_config
+def handle_list_sessions(args):
+    import os
+    import glob
+
+    n = args.list if args.list is not None else 10
+    history_dir = os.path.join(os.path.expanduser(".janito"), "chat_history")
+    if not os.path.exists(history_dir):
+        print("No session history found.")
+        return True
+    files = glob.glob(os.path.join(history_dir, "*.json"))
+    files = sorted(files, key=os.path.getmtime, reverse=True)
+    print(f"Last {n} sessions:")
+    for f in files[:n]:
+        session_id = os.path.splitext(os.path.basename(f))[0]
+        print(session_id)
+    return True
+
+
+def handle_view_session(args):
+    import os
+    import json
+
+    history_dir = os.path.join(os.path.expanduser(".janito"), "chat_history")
+    session_file = os.path.join(history_dir, f"{args.view}.json")
+    if not os.path.exists(session_file):
+        print(f"Session '{args.view}' not found.")
+        return 1
+    with open(session_file, "r", encoding="utf-8") as f:
+        try:
+            messages = json.load(f)
+        except Exception as e:
+            print(f"Failed to load session: {e}")
+            return 1
+    print(f"Conversation history for session '{args.view}':\n")
+    for i, msg in enumerate(messages, 1):
+        role = msg.get("role", "?")
+        content = msg.get("content", "")
+        print(f"[{i}] {role}: {content}\n")
+    return 0
+
+
+def handle_lang_selection(args):
     import janito.i18n as i18n
     from janito.agent.runtime_config import runtime_config
 
-    local_config.load()
-    global_config.load()
-
-    parser = create_parser()
-    args = parser.parse_args()
-
-    # Seleção de idioma: prioridade --lang > config.json > padrão
     lang = getattr(args, "lang", None) or unified_config.get("lang", None) or "en"
     runtime_config.set("lang", lang)
     i18n.set_locale(lang)
 
+
+def handle_help_config(args):
     from janito.agent.config import CONFIG_OPTIONS
     from janito.agent.config_defaults import CONFIG_DEFAULTS
 
-    if getattr(args, "help_config", False):
-        print(tr("Available configuration options:\n"))
-        for key, desc in CONFIG_OPTIONS.items():
-            default = CONFIG_DEFAULTS.get(key, None)
-            print(
-                tr(
-                    "{key:15} {desc} (default: {default})",
-                    key=key,
-                    desc=desc,
-                    default=default,
-                )
+    print(tr("Available configuration options:\n"))
+    for key, desc in CONFIG_OPTIONS.items():
+        default = CONFIG_DEFAULTS.get(key, None)
+        print(
+            tr(
+                "{key:15} {desc} (default: {default})",
+                key=key,
+                desc=desc,
+                default=default,
             )
-        sys.exit(0)
+        )
 
-    if getattr(args, "list_tools", False):
-        from janito.agent.tool_registry import get_tool_schemas
-        from rich.console import Console
-        from rich.table import Table
 
-        console = Console()
-        table = Table(
-            title="Ferramentas Registradas", show_lines=True, style="bold magenta"
+def handle_list_tools(args):
+    from janito.agent.tool_registry import get_tool_schemas
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console()
+    table = Table(
+        title="Ferramentas Registradas", show_lines=True, style="bold magenta"
+    )
+    table.add_column("Gnome", style="cyan", no_wrap=True)
+    table.add_column("Descrição", style="green")
+    table.add_column("Parâmetros", style="yellow")
+    for schema in get_tool_schemas():
+        fn = schema["function"]
+        params = "\n".join(
+            [
+                f"[bold]{k}[/]: {v['type']}"
+                for k, v in fn["parameters"].get("properties", {}).items()
+            ]
         )
-        table.add_column("Gnome", style="cyan", no_wrap=True)
-        table.add_column("Descrição", style="green")
-        table.add_column("Parâmetros", style="yellow")
-        for schema in get_tool_schemas():
-            fn = schema["function"]
-            params = "\n".join(
-                [
-                    f"[bold]{k}[/]: {v['type']}"
-                    for k, v in fn["parameters"].get("properties", {}).items()
-                ]
-            )
-            table.add_row(f"[b]{fn['name']}[/b]", fn["description"], params or "-")
-        console.print(table)
-        sys.exit(0)
+        table.add_row(f"[b]{fn['name']}[/b]", fn["description"], params or "-")
+    console.print(table)
 
-    if getattr(args, "info", False):
-        # (mantém bloco info)
-
-        print("Janito - Agente CLI de automação")
-        print(f"Modelo: {unified_config.get('model')}")
-        print(f"Temperatura: {unified_config.get('temperature')}")
-        print(f"Max tokens: {unified_config.get('max_tokens')}")
-        # System prompt real via AgentProfileManager
-        # Prioridade: --system-file > --system > AgentProfileManager
-        from janito.agent.runtime_config import runtime_config
-
-        system_prompt_val = None
-        origem = None
-        if getattr(args, "system_file", None):
-            try:
-                with open(args.system_file, "r", encoding="utf-8") as f:
-                    system_prompt_val = f.read().strip()
-                runtime_config.set("system_prompt_template", system_prompt_val)
-                origem = "--system-file"
-            except Exception as e:
-                print(f"System prompt: (error reading system-file: {e})")
-        elif getattr(args, "system", None):
-            system_prompt_val = args.system
+
+def handle_info(args):
+    from janito import __version__
+    from rich.console import Console
+    from rich.text import Text
+    from janito.agent.runtime_config import runtime_config
+
+    model = unified_config.get("model")
+    temperature = unified_config.get("temperature")
+    max_tokens = unified_config.get("max_tokens")
+    system_prompt_val = None
+    if getattr(args, "system_file", None):
+        try:
+            with open(args.system_file, "r", encoding="utf-8") as f:
+                system_prompt_val = f.read().strip()
             runtime_config.set("system_prompt_template", system_prompt_val)
-            origem = "--system"
-        else:
-            system_prompt_val = runtime_config.get("system_prompt_template")
-            if system_prompt_val:
-                origem = "runtime_config"
-        if system_prompt_val:
-            print(f"System prompt ({origem or 'runtime_config'}): {system_prompt_val}")
-        else:
-            try:
-                from janito.agent.profile_manager import AgentProfileManager
-                from janito.agent.config import get_api_key
-
-                role = args.role or unified_config.get("role", "software engineer")
-                interaction_mode = (
-                    "chat" if not getattr(args, "prompt", None) else "prompt"
-                )
-                profile = "base"
-                profile_manager = AgentProfileManager(
-                    api_key=get_api_key(),
-                    model=unified_config.get("model"),
-                )
-                system_prompt_val = profile_manager.get_system_prompt(
-                    role, interaction_mode, profile
-                )
-                print(f"System prompt (profile_manager): {system_prompt_val}")
-            except Exception as e:
-                print(f"System prompt: (error obtaining from profile_manager: {e})")
-        sys.exit(0)
+        except Exception as e:
+            system_prompt_val = f"(error reading system-file: {e})"
+    elif getattr(args, "system", None):
+        system_prompt_val = args.system
+        runtime_config.set("system_prompt_template", system_prompt_val)
+    else:
+        system_prompt_val = runtime_config.get("system_prompt_template")
+    if not system_prompt_val:
+        try:
+            from janito.agent.profile_manager import AgentProfileManager
+            from janito.agent.config import get_api_key
+
+            role = args.role or unified_config.get("role", "software engineer")
+            interaction_mode = "chat" if not getattr(args, "prompt", None) else "prompt"
+            profile = "base"
+            profile_manager = AgentProfileManager(
+                api_key=get_api_key(),
+                model=unified_config.get("model"),
+            )
+            system_prompt_val = profile_manager.get_system_prompt(
+                role, interaction_mode, profile
+            )
+        except Exception as e:
+            system_prompt_val = f"(error: {e})"
+    console = Console()
+    info_text = Text()
+    info_text.append(f"Janito v{__version__}", style="bold cyan")
+    info_text.append(" | model: ", style="white")
+    info_text.append(str(model), style="green")
+    info_text.append(" | temp: ", style="white")
+    info_text.append(str(temperature), style="yellow")
+    info_text.append(" | max_tokens: ", style="white")
+    info_text.append(str(max_tokens), style="magenta")
+    info_text.append(" | system: ", style="white")
+    info_text.append(str(system_prompt_val), style="bold blue")
+    console.print(info_text, style="dim")
+
+
+def main():
+    """Unified entry point for the Janito CLI and web server."""
+    import sys
+    from janito.agent.config import local_config, global_config
 
-    # ... resto do main ...
+    local_config.load()
+    global_config.load()
+    parser = create_parser()
+    args = parser.parse_args()
+    # Handle --list [n] before anything else
+    if getattr(args, "list", None) is not None:
+        if handle_list_sessions(args):
+            sys.exit(0)
+    # Handle --view <id> to print conversation history
+    if getattr(args, "view", None) is not None:
+        sys.exit(handle_view_session(args))
+    handle_lang_selection(args)
+    if getattr(args, "help_config", False):
+        handle_help_config(args)
+        sys.exit(0)
+    if getattr(args, "list_tools", False):
+        handle_list_tools(args)
+        sys.exit(0)
+    if getattr(args, "info", False):
+        handle_info(args)
     handle_config_commands(args)
     setup_verbose_logging(args)
     if getattr(args, "web", False):
-        import subprocess  # Only needed if launching web
+        import subprocess
 
         subprocess.run([sys.executable, "-m", "janito.web"])
+    elif getattr(args, "live", False):
+        port = 35729
+        livereload_proc, started, livereload_stdout_path, livereload_stderr_path = (
+            start_livereload(port)
+        )
+        try:
+            run_cli(args)
+        finally:
+            if livereload_proc:
+                livereload_proc.terminate()
+                livereload_proc.wait()
     else:
         run_cli(args)