janito 1.6.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

janito/cli/arg_parser.py

@@ -2,12 +2,21 @@ 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"
     )
     parser.add_argument(
         "prompt", type=str, nargs="?", help="Prompt to send to the model"
     )
+    parser.add_argument(
+        "--lang",
+        type=str,
+        default=None,
+        help="Language for interface messages (e.g., en, pt). Overrides config if set.",
+    )
 
     parser.add_argument(
         "--max-tokens",
@@ -23,6 +32,7 @@ def create_parser():
     )
     parser.add_argument(
         "--model",
+        "-m",
         type=str,
         default=None,
         help="Model name to use for this session (overrides config, does not persist)",
@@ -77,11 +87,21 @@ def create_parser():
         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",
@@ -169,10 +189,10 @@ def create_parser():
         help="Suppress all tool output (trusted tools mode: only shows output file locations)",
     )
     parser.add_argument(
-        "--style",
+        "--profile",
         type=str,
         default=None,
-        help="Interaction style for system prompt template (e.g., default, technical)",
+        help="Agent Profile name (only 'base' is supported)",
     )
     parser.add_argument(
         "--stream",
@@ -185,8 +205,20 @@ def create_parser():
         help="Print raw chunks as they are fetched from OpenAI (for debugging)",
     )
     parser.add_argument(
-        "--scan",
+        "--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="Scan the project to auto-detect relevant tech/skills and save to .janito/tech.txt (no chat)",
+        help="Exibe informações básicas do programa e sai (útil para execução única em shell)",
     )
     return parser

janito/cli/config_commands.py

@@ -175,7 +175,7 @@ def handle_config_commands(args):
                         Path(__file__).parent
                         / "agent"
                         / "templates"
-                        / "system_prompt_template.j2"
+                        / "system_prompt_template_default.j2"
                     )
                     print(
                         f"{key} = (default template path: {home_shorten(str(template_path))})"

janito/cli/logging_setup.py

@@ -2,8 +2,13 @@ import os
 import logging
 
 
+from janito.agent.runtime_config import runtime_config
+
+
 def setup_verbose_logging(args):
-    if args.verbose_http or args.verbose_http_raw:
+    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()
@@ -12,7 +17,7 @@ def setup_verbose_logging(args):
         )
         httpx_logger.addHandler(handler)
 
-    if args.verbose_http_raw:
+    if runtime_config.get("verbose_http_raw", False):
         os.environ["HTTPX_LOG_LEVEL"] = "trace"
 
         httpcore_logger = logging.getLogger("httpcore")

janito/cli/main.py

@@ -3,10 +3,12 @@
 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 import run_cli
+from janito.cli.runner.cli_main import run_cli
+from janito.agent.runtime_config import unified_config
 
 # Ensure all tools are registered at startup
 import janito.agent.tools  # noqa: F401
+from janito.i18n import tr
 
 
 def main():
@@ -14,6 +16,8 @@ def main():
     import sys
 
     from janito.agent.config import local_config, global_config
+    import janito.i18n as i18n
+    from janito.agent.runtime_config import runtime_config
 
     local_config.load()
     global_config.load()
@@ -21,16 +25,106 @@ def main():
     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)
+
     from janito.agent.config import CONFIG_OPTIONS
     from janito.agent.config_defaults import CONFIG_DEFAULTS
 
     if getattr(args, "help_config", False):
-        print("Available configuration options:\n")
+        print(tr("Available configuration options:\n"))
         for key, desc in CONFIG_OPTIONS.items():
             default = CONFIG_DEFAULTS.get(key, None)
-            print(f"{key:15} {desc} (default: {default})")
+            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"
+        )
+        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)
+
+    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
+            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)
 
+    # ... resto do main ...
     handle_config_commands(args)
     setup_verbose_logging(args)
     if getattr(args, "web", False):

janito/cli/runner/__init__.py

@@ -1,2 +0,0 @@
-from .cli_main import run_cli
-from .formatting import format_tokens

janito/cli/runner/_termweb_log_utils.py

@@ -0,0 +1,17 @@
+def print_termweb_logs(stdout_path, stderr_path, console):
+    try:
+        with open(stdout_path, encoding="utf-8") as f:
+            stdout_content = f.read().strip()
+    except Exception:
+        stdout_content = None
+    try:
+        with open(stderr_path, encoding="utf-8") as f:
+            stderr_content = f.read().strip()
+    except Exception:
+        stderr_content = None
+    if stdout_content:
+        console.print("[yellow][termweb][stdout] Output:\n" + stdout_content)
+    if stderr_content:
+        console.print("[red][termweb][stderr] Errors:\n" + stderr_content)
+    if not stdout_content and not stderr_content:
+        console.print("[termweb] No output or errors captured in logs.")

janito/cli/runner/cli_main.py

@@ -1,142 +1,167 @@
 import sys
-import os
-from rich.console import Console
+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 .formatting import format_tokens
-from .scan import scan_project
-from .config import get_system_prompt_template
 from janito.agent.conversation_exceptions import (
     MaxRoundsExceededError,
     EmptyResponseError,
     ProviderError,
 )
 
+
+def is_port_free(port):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(("localhost", port)) != 0
+
+
 def run_cli(args):
     if args.version:
         print(f"janito version {__version__}")
         sys.exit(0)
 
-    # --scan: auto-detect tech/skills and save to .janito/tech.txt
-    if getattr(args, "scan", False):
-        scan_project()
-        sys.exit(0)
+    # Set vanilla mode if -V/--vanilla is passed
+    if getattr(args, "vanilla", False):
+        runtime_config.set("vanilla_mode", True)
 
-    # Check for .janito/tech.txt and print a tip if missing
-    tech_txt_path = os.path.join(".janito", "tech.txt")
-    if not os.path.exists(tech_txt_path):
-        print("⚠️  No tech.txt found in .janito.")
-        print(
-            "💡 Tip: Run with --scan first to auto-detect project tech/skills and improve results."
-        )
+    # Normalize all verbose flags into runtime_config
+    for flag in [
+        "verbose_http",
+        "verbose_http_raw",
+        "verbose_response",
+        "verbose_reason",
+        "verbose_tools",
+        "verbose_events",
+        "verbose_stream",
+    ]:
+        if hasattr(args, flag):
+            runtime_config.set(flag, getattr(args, flag, False))
 
     role = args.role or unified_config.get("role", "software engineer")
-
-    # Ensure runtime_config is updated so chat shell sees the role
     if args.role:
         runtime_config.set("role", args.role)
-
-    # Set runtime_config['model'] if --model is provided (highest priority, session only)
     if getattr(args, "model", None):
         runtime_config.set("model", args.model)
-
-    # Set runtime_config['max_tools'] if --max-tools is provided
     if getattr(args, "max_tools", None) is not None:
         runtime_config.set("max_tools", args.max_tools)
-
-    # Set trust-tools mode if enabled
     if getattr(args, "trust_tools", False):
         runtime_config.set("trust_tools", True)
-
-    # Get system prompt template (instructions/config logic)
-    system_prompt_template = get_system_prompt_template(args, role)
-
-    if args.show_system:
-        api_key = get_api_key()
-        model = unified_config.get("model")
-        print("Model:", model)
-        print("Parameters: {}")
-        print(
-            "System Prompt Template:",
-            system_prompt_template or "(default system prompt template not provided)",
-        )
-        sys.exit(0)
-
-    api_key = get_api_key()
-    model = unified_config.get("model")
-    base_url = unified_config.get("base_url", "https://openrouter.ai/api/v1")
-    azure_openai_api_version = unified_config.get(
-        "azure_openai_api_version", "2023-05-15"
-    )
-    # Handle vanilla mode
-    vanilla_mode = getattr(args, "vanilla", False)
-    if vanilla_mode:
-        runtime_config.set("vanilla_mode", True)
-        system_prompt_template = None
-        runtime_config.set("system_prompt_template", None)
-        if args.temperature is None:
-            runtime_config.set("temperature", None)
-    else:
-        runtime_config.set("vanilla_mode", False)
-
-    interaction_style = getattr(args, "style", None) or unified_config.get(
-        "interaction_style", "default"
-    )
-
     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(
-        api_key=api_key,
-        model=model,
+        api_key=get_api_key(),
+        model=unified_config.get("model"),
         role=role,
-        interaction_style=interaction_style,
+        profile_name=profile,
         interaction_mode=interaction_mode,
         verbose_tools=args.verbose_tools,
-        base_url=base_url,
-        azure_openai_api_version=azure_openai_api_version,
+        base_url=unified_config.get("base_url", "https://openrouter.ai/api/v1"),
+        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 not getattr(args, "prompt", None):
-        from janito.cli_chat_shell.chat_loop import start_chat_shell
-
-        start_chat_shell(
-            profile_manager, continue_session=getattr(args, "continue_session", False)
+    if getattr(args, "verbose_reason", False):
+        runtime_config.set("verbose_reason", True)
+
+    # --- Liteweb integration ---
+    termweb_proc = None
+    selected_port = None
+    if (
+        not getattr(args, "no_termweb", False)
+        and interaction_mode == "chat"
+        and not runtime_config.get("vanilla_mode", False)
+    ):
+        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:
+                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):
+                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
         )
-        sys.exit(0)
+        # Store last running port in .janito/config.json if started
+        if started:
+            from janito.agent.config import local_config
 
-    prompt = args.prompt
-    console = Console()
-    from janito.agent.rich_message_handler import RichMessageHandler
+            local_config.set("termweb_last_running_port", selected_port)
+            local_config.save()
 
-    message_handler = RichMessageHandler()
-    messages = []
-    if profile_manager.system_prompt_template:
-        messages.append(
-            {"role": "system", "content": profile_manager.system_prompt_template}
-        )
-    messages.append({"role": "user", "content": prompt})
+    # --- End termweb integration ---
     try:
+        if not getattr(args, "prompt", None):
+            from janito.cli_chat_shell.chat_loop import start_chat_shell
+
+            start_chat_shell(
+                profile_manager,
+                continue_session=getattr(args, "continue_session", False),
+                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
+                ),
+            )
+            sys.exit(0)
+        # --- Prompt mode ---
+        prompt = args.prompt
+        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})
         try:
-            max_rounds = runtime_config.get("max_rounds", 50)
-            profile_manager.agent.handle_conversation(
+            max_rounds = 50
+            profile_manager.agent.chat(
                 messages,
                 message_handler=message_handler,
                 spinner=True,
                 max_rounds=max_rounds,
-                verbose_response=getattr(args, "verbose_response", False),
-                verbose_events=getattr(args, "verbose_events", False),
                 stream=getattr(args, "stream", False),
-                verbose_stream=getattr(args, "verbose_stream", False),
             )
         except MaxRoundsExceededError:
             console.print("[red]Max conversation rounds exceeded.[/red]")
@@ -145,4 +170,11 @@ def run_cli(args):
         except EmptyResponseError as e:
             console.print(f"[red]Error:[/red] {e}")
     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/runner/config.py

@@ -1,8 +1,8 @@
-import os
 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):
@@ -22,12 +22,14 @@ def get_system_prompt_template(args, role):
                 api_key=get_api_key(),
                 model=unified_config.get("model"),
                 role=role,
-                interaction_style=unified_config.get("interaction_style", "default"),
+                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", 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.render_prompt()
+            system_prompt_template = profile_manager.system_prompt_template
     return system_prompt_template

janito/cli/termweb_starter.py

@@ -0,0 +1,73 @@
+import sys
+import subprocess
+import tempfile
+import time
+import http.client
+import os
+from rich.console import Console
+from janito.cli.runner._termweb_log_utils import print_termweb_logs
+from janito.i18n import tr
+
+
+def wait_for_termweb(port, timeout=3.0):
+    """Polls the Bottle app root endpoint until it responds or timeout (seconds) is reached."""
+    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 == 200:
+                return True
+        except Exception:
+            pass
+        time.sleep(0.1)
+    return False
+
+
+def start_termweb(selected_port):
+    """
+    Start the termweb server on the given port, with rich spinner and logging.
+    Returns (termweb_proc, started: bool)
+    """
+    console = Console()
+    with console.status("[cyan]Starting web server...", spinner="dots"):
+        # Step 1: Try source path
+        app_py_path = os.path.join(os.path.dirname(__file__), "..", "termweb", "app.py")
+        app_py_path = os.path.abspath(app_py_path)
+        if not os.path.isfile(app_py_path):
+            # Step 2: Try installed package
+            try:
+                import janito_termweb
+
+                app_py_path = janito_termweb.__file__.replace("__init__.py", "app.py")
+            except ImportError:
+                console.print("[red]Could not find termweb app.py![/red]")
+                return None, False, None, None
+        termweb_stdout = tempfile.NamedTemporaryFile(
+            delete=False, mode="w+", encoding="utf-8"
+        )
+        termweb_stderr = tempfile.NamedTemporaryFile(
+            delete=False, mode="w+", encoding="utf-8"
+        )
+        termweb_proc = subprocess.Popen(
+            [sys.executable, app_py_path, "--port", str(selected_port)],
+            stdout=termweb_stdout,
+            stderr=termweb_stderr,
+        )
+        if wait_for_termweb(selected_port, timeout=3.0):
+            console.print(
+                tr(
+                    "TermWeb started... Available at http://localhost:{selected_port}",
+                    selected_port=selected_port,
+                )
+            )
+            return termweb_proc, True, termweb_stdout.name, termweb_stderr.name
+        else:
+            termweb_proc.terminate()
+            termweb_proc.wait()
+            console.print(
+                f"[red]Failed to start TermWeb on port {selected_port}. Check logs for details.[/red]"
+            )
+            print_termweb_logs(termweb_stdout.name, termweb_stderr.name)
+            return None, False, termweb_stdout.name, termweb_stderr.name