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

janito/cli_chat_shell/ui.py

@@ -2,55 +2,29 @@ from prompt_toolkit import PromptSession
 from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.styles import Style
+from prompt_toolkit.key_binding import KeyBindings
 from janito.agent.runtime_config import runtime_config
-from .session_manager import last_conversation_exists
+from janito.i18n import tr
 
 
 def print_summary(console, data, continue_session):
     if not data:
         return
-    msgs = data.get("messages", [])
-    last_user = next(
-        (m["content"] for m in reversed(msgs) if m.get("role") == "user"), None
-    )
-    last_assistant = next(
-        (m["content"] for m in reversed(msgs) if m.get("role") == "assistant"), None
-    )
-    usage = data.get("last_usage_info", {})
     console.print("[bold cyan]Last saved conversation:[/bold cyan]")
-    console.print(f"Messages: {len(msgs)}")
-    if last_user:
-        console.print(
-            f"Last user: [italic]{last_user[:100]}{'...' if len(last_user)>100 else ''}[/italic]"
-        )
-    if last_assistant:
-        console.print(
-            f"Last assistant: [italic]{last_assistant[:100]}{'...' if len(last_assistant)>100 else ''}[/italic]"
-        )
-    if usage:
-        ptok = usage.get("prompt_tokens")
-        ctok = usage.get("completion_tokens")
-        tot = (ptok or 0) + (ctok or 0)
-        console.print(f"Tokens - Prompt: {ptok}, Completion: {ctok}, Total: {tot}")
-    # Only print /continue suggestion if a last conversation exists
-    if not continue_session and last_conversation_exists():
-        console.print(
-            "[bold yellow]Type /continue to restore the last saved conversation.[/bold yellow]"
-        )
 
 
 def print_welcome(console, version=None, continued=False):
     version_str = f" (v{version})" if version else ""
-    vanilla_mode = runtime_config.get("vanilla_mode", False)
-    if vanilla_mode:
+    if runtime_config.get("vanilla_mode", False):
         console.print(
-            f"[bold magenta]Welcome to Janito{version_str} in [white on magenta]VANILLA MODE[/white on magenta]! Tools, system prompt, and temperature are disabled unless overridden.[/bold magenta]\n[cyan]Quick action: Press F12 to continue. Double-check the suggested action first. 😊[/cyan]"
+            f"[bold magenta]{tr('Welcome to Janito{version_str} in [white on magenta]VANILLA MODE[/white on magenta]! Tools, system prompt, and temperature are disabled unless overridden.', version_str=version_str)}[/bold magenta]\n"
+            f"[cyan]{tr('F12 = Quick Action (follows the recommended action)')}[/cyan]"
         )
     else:
         console.print(
-            f"[bold green]Welcome to Janito{version_str}! Entering chat mode. Type /exit to exit.[/bold green]\n[cyan]Quick action: Press F12 to continue. Double-check the suggested action first. 😊[/cyan]"
+            f"[bold green]{tr('Welcome to Janito{version_str}! Entering chat mode. Type /exit to exit.', version_str=version_str)}[/bold green]\n"
+            f"[cyan]{tr('F12 = Quick Action (follows the recommended action)')}[/cyan]"
         )
-    # Only print /continue suggestion if a last conversation exists
 
 
 def get_toolbar_func(
@@ -60,113 +34,156 @@ def get_toolbar_func(
     model_name=None,
     role_ref=None,
     style_ref=None,
+    version=None,
 ):
-    def format_tokens(n):
+    from prompt_toolkit.application.current import get_app
+
+    def format_tokens(n, tag=None):
         if n is None:
             return "?"
-        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)
+        if n < 1000:
+            val = str(n)
+        elif n < 1000000:
+            val = f"{n/1000:.1f}k"
+        else:
+            val = f"{n/1000000:.1f}M"
+        return f"<{tag}>{val}</{tag}>" if tag else val
 
     def get_toolbar():
-        left = f" Messages:  <msg_count>{len(messages_ref())}</msg_count>"
-        usage = last_usage_info_ref()
-        last_elapsed = last_elapsed_ref()
-        if usage:
-            prompt_tokens = usage.get("prompt_tokens")
-            completion_tokens = usage.get("completion_tokens")
-            total_tokens = (prompt_tokens or 0) + (completion_tokens or 0)
-            speed = None
-            if last_elapsed and last_elapsed > 0:
-                speed = total_tokens / last_elapsed
-            left += (
-                f" | Tokens: In=<tokens_in>{format_tokens(prompt_tokens)}</tokens_in> / "
-                f"Out=<tokens_out>{format_tokens(completion_tokens)}</tokens_out> / "
-                f"Total=<tokens_total>{format_tokens(total_tokens)}</tokens_total>"
-            )
-            if speed is not None:
-                left += f", speed=<speed>{speed:.1f}</speed> tokens/sec"
-
-        from prompt_toolkit.application import get_app
-
         width = get_app().output.get_size().columns
-        model_part = f" Model:  <model>{model_name}</model>" if model_name else ""
+        model_part = (
+            f" {tr('Model')}: <model>{model_name}</model>" if model_name else ""
+        )
         role_part = ""
         vanilla_mode = runtime_config.get("vanilla_mode", False)
         if role_ref and not vanilla_mode:
             role = role_ref()
             if role:
-                role_part = f"Role: <b>{role}</b>"
+                role_part = f"{tr('Role')}: <role>{role}</role>"
+
         style_part = ""
         if style_ref:
             style = style_ref()
             if style:
-                style_part = f"Style: <b>{style}</b>"
+                style_part = f"{tr('Style')}: <b>{style}</b>"
+        usage = last_usage_info_ref()
+        prompt_tokens = usage.get("prompt_tokens") if usage else None
+        completion_tokens = usage.get("completion_tokens") if usage else None
+        total_tokens = usage.get("total_tokens") if usage else None
         first_line_parts = []
         if model_part:
             first_line_parts.append(model_part)
+
         if role_part:
             first_line_parts.append(role_part)
         if style_part:
             first_line_parts.append(style_part)
         first_line = " | ".join(first_line_parts)
-        help_part = "<b>/help</b> for help | <b>F12</b>: proceed"
-        total_len = len(left) + len(help_part) + 3  # separators and spaces
+        left = f" {tr('Messages')}: <msg_count>{len(messages_ref())}</msg_count>"
+        tokens_part = ""
+        if (
+            prompt_tokens is not None
+            or completion_tokens is not None
+            or total_tokens is not None
+        ):
+            tokens_part = (
+                f" | {tr('Tokens')} - {tr('Prompt')}: {format_tokens(prompt_tokens, 'tokens_in')}, "
+                f"{tr('Completion')}: {format_tokens(completion_tokens, 'tokens_out')}, "
+                f"{tr('Total')}: {format_tokens(total_tokens, 'tokens_total')}"
+            )
+        # Move /help and /start tips to key bindings/info line
+        # Compose second/status line (no help_part)
+        second_line = f"{left}{tokens_part}"
+        total_len = len(left) + len(tokens_part)
         if first_line:
             total_len += len(first_line) + 3
         if total_len < width:
             padding = " " * (width - total_len)
-            second_line = f"{left}{padding} | {help_part}"
-        else:
-            second_line = f"{left} | {help_part}"
+            second_line = f"{left}{tokens_part}{padding}"
+        # Add key bindings info as an extra line, now including /help and /start
+        bindings_line = (
+            f"<b> F12</b>: {tr('Quick Action')} | "
+            f"<b>Ctrl-Y</b>: {tr('Yes')} | "
+            f"<b>Ctrl-N</b>: {tr('No')} | "
+            f"<b>/help</b>: {tr('Help')} | "
+            f"<b>/start</b>: {tr('New Task')}"
+        )
         if first_line:
-            toolbar_text = first_line + "\n" + second_line
+            toolbar_text = first_line + "\n" + second_line + "\n" + bindings_line
         else:
-            toolbar_text = second_line
+            toolbar_text = second_line + "\n" + bindings_line
         return HTML(toolbar_text)
 
     return get_toolbar
 
 
-def get_prompt_session(get_toolbar_func, mem_history):
-    from prompt_toolkit.key_binding import KeyBindings
+def get_custom_key_bindings():
+    """
+    Returns prompt_toolkit KeyBindings for custom CLI shortcuts:
+    - F12: Cycles through quick action phrases and submits.
+    - Ctrl-Y: Inserts 'Yes' and submits (for confirmation prompts).
+    - Ctrl-N: Inserts 'No' and submits (for confirmation prompts).
+    """
+    bindings = KeyBindings()
+    _f12_instructions = ["proceed", "go ahead", "continue", "next", "okay"]
+    _f12_index = {"value": 0}
 
+    @bindings.add("f12")
+    def _(event):
+        buf = event.app.current_buffer
+        idx = _f12_index["value"]
+        buf.text = _f12_instructions[idx]
+        buf.validate_and_handle()
+        _f12_index["value"] = (idx + 1) % len(_f12_instructions)
+
+    @bindings.add("c-y")
+    def _(event):
+        buf = event.app.current_buffer
+        buf.text = "Yes"
+        buf.validate_and_handle()
+
+    @bindings.add("c-n")
+    def _(event):
+        buf = event.app.current_buffer
+        buf.text = "No"
+        buf.validate_and_handle()
+
+    return bindings
+
+
+def get_prompt_session(get_toolbar_func, mem_history):
     style = Style.from_dict(
         {
             "bottom-toolbar": "bg:#333333 #ffffff",
-            "b": "bold",
-            "prompt": "bold bg:#000080 #ffffff",
-            "model": "bold bg:#005f5f #ffffff",  # distinct background/foreground
-            "msg_count": "bg:#333333 #ffff00 bold",
+            "model": "bold bg:#005f5f #ffffff",
+            "role": "bold ansiyellow",
             "tokens_in": "ansicyan bold",
             "tokens_out": "ansigreen bold",
             "tokens_total": "ansiyellow bold",
-            "speed": "ansimagenta bold",
-            "right": "bg:#005f5f #ffffff",
-            "input": "bg:#000080 #ffffff",
-            "": "bg:#000080 #ffffff",
+            "msg_count": "bg:#333333 #ffff00 bold",
+            "b": "bold",
+            "prompt": "bg:#005f5f #ffffff",  # (legacy, not used)
+            # Style for prompt_toolkit input line:
+            #   - '': affects the actual user input area background (full line, most reliable)
+            #   - "input-field": also affects the input area in some prompt_toolkit versions
+            #   - <inputline> tag: only affects the prompt label, not the input area
+            "": "bg:#005fdd #ffffff",  # Blue background for the user input area (recommended)
+            "input-field": "bg:#005fdd #ffffff",  # Blue background for the user input area (optional)
+            "inputline": "bg:#005fdd #ffffff",  # Blue background for the prompt label (icon/text)
         }
     )
-    kb = KeyBindings()
-
-    @kb.add("f12")
-    def _(event):
-        """When F12 is pressed, send 'proceed' as input immediately."""
-        buf = event.app.current_buffer
-        buf.text = "proceed"
-        buf.validate_and_handle()
+    from .shell_command_completer import ShellCommandCompleter
 
-    session = PromptSession(
-        multiline=False,
-        key_bindings=kb,
-        editing_mode=EditingMode.EMACS,
+    completer = ShellCommandCompleter()
+    return PromptSession(
         bottom_toolbar=get_toolbar_func,
         style=style,
+        editing_mode=EditingMode.VI,
+        key_bindings=get_custom_key_bindings(),
         history=mem_history,
+        completer=completer,
     )
-    return session
 
 
-# ... rest of the file remains unchanged ...
+def _(text):
+    return text

janito/i18n/__init__.py

@@ -0,0 +1,35 @@
+import importlib
+import threading
+import hashlib
+
+_current_locale = "en"
+_translations = {}
+_lock = threading.Lock()
+
+
+def set_locale(locale):
+    global _current_locale, _translations
+    with _lock:
+        _current_locale = locale
+        if locale == "en":
+            _translations = {}
+        else:
+            try:
+                mod = importlib.import_module(f"janito.i18n.{locale}")
+                _translations = getattr(mod, "translations", {})
+            except ImportError:
+                _translations = {}
+
+
+def tr(msg, **kwargs):
+    """Translate message to current locale, usando hash SHA-1 da mensagem como chave."""
+    msg_hash = hashlib.sha1(msg.encode("utf-8")).hexdigest()
+    template = _translations.get(msg_hash, msg)
+    try:
+        return template.format(**kwargs)
+    except Exception:
+        return template  # fallback if formatting fails
+
+
+# Inicializa com o idioma padrão (en)
+set_locale("en")

janito/i18n/messages.py

@@ -0,0 +1,23 @@
+# Arquivo base de mensagens para i18n
+# Chave = SHA-1 da string original em inglês
+
+MESSAGES = {
+    # create_directory.py
+    "e3d8e1e5e0b3e4a2a7a5e2e1e4e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0": "Successfully created the directory at '{path}'.",
+    "f2b7e4e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1": "Cannot create directory: '{path}' already exists.",
+    "d3e2e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5": "Path '{path}' exists and is not a directory.",
+    "b1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1": "Error creating directory '{path}': {error}",
+    # create_file.py
+    "a2e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0": "File already exists at '{path}'. Use overwrite=True to overwrite.",
+    "c3e2e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5": "Created file ({lines} lines).",
+    "d4e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0": "Updated file ({lines} lines, backup at {backup_path}).",
+    # remove_file.py
+    "e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5": "File '{path}' does not exist.",
+    "f6e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0": "Path '{path}' is not a file.",
+    "a7e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1": "Successfully removed the file at '{path}'.",
+    "b8e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0": "Error removing file: {error}",
+    # replace_text_in_file.py (exemplo)
+    "c9e2e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5": "Text replaced in {file_path} (backup at {backup_path}). {details}",
+    "d0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0": "No changes made. {warning_detail}",
+    "e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1e5e0e1": "Error replacing text: {error}",
+}

janito/i18n/pt.py

@@ -0,0 +1,46 @@
+translations = {
+    "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Iniciando servidor web...",
+    "70a0d194687568a47aa617fd85036ace1e69a982": "Deseja realmente sair? (s/n): ",
+    "5c9ebcbbd7632ecb328bd52958b17158afaa32c6": "F12 = Ação Rápida (segue a ação recomendada)",
+    "e4034394acca752c021b2ab50f60da8273e3c314": "TermWeb iniciado... Disponível em http://localhost:{selected_port}",
+    "fe21121e2934234b68d19b2757532117d440c1e3": "Chave de API não encontrada. Por favor, configure 'api_key' no seu arquivo de configuração.",
+    "c9e3759b1756eba35b381ce2b72cd659e132b01f": "Olá, {name}!",
+    "ca1fee2f55baabdc2e4b0e9529c89ee024e62079": "Nenhum prompt fornecido nas mensagens",
+    "f7449d23d0c500ae2a0b31e04f92b47a4d8ae845": "max_tokens deve ser um inteiro, recebido: {resolved_max_tokens!r}",
+    "70a9ed8edb6da12e208431a31aa16ba54419b26f": "Resposta inválida/malformada do OpenAI (tentativa {attempt}/{max_retries}). Tentando novamente em {wait_time} segundos...",
+    "a873085e3b06184fb5d27e842f97b06b6190976d": "Número máximo de tentativas para resposta inválida atingido. Gerando erro.",
+    "66a34568bbe846bb1bde3619eb4d6dfa10211104": "A API não suporta o uso de ferramentas.",
+    "09b81476b75586da4116b83f8be70d77b174cec3": "Limit de taxa da API OpenAI (429) (tentativa {attempt}/{max_retries}): {e}. Tentando novamente em {wait_time} segundos...",
+    "5717a35dd2a1533fb7e15edc8c9329cb69f3410b": "Erro do servidor da API OpenAI (tentativa {attempt}/{max_retries}): {e}. Tentando novamente em {wait_time} segundos...",
+    "02e760ba15ed863176c1290ac8a9b923963103cd": "Erro do client da API OpenAI {status_code}: {e}. Não será feita nova tentativa.",
+    "2e52b0bbc8f16226b70e3e20f95c9245d2bcdb47": "Erro da API OpenAI (tentativa {attempt}/{max_retries}): {e}. Tentando novamente em {wait_time} segundos...",
+    "012cc970e039fdd79c452fc676202c814ffc76ae": "Número máximo de tentativas para erro da API OpenAI atingido. Gerando erro.",
+    "d0438e45667d31e0022b2497b5901cd4300f084b": "QueuedMessageHandler.handle_message espera um dicionário com 'type' e 'message', recebido {msg_type}: {msg!r}",
+    "9d3460187ffa19c7c8a4020157072b1087e1bd2f": "[QueuedMessageHandler] {msg_type}: {msg}",
+    "3813833343430e8afa8fce33385c5e39fb24dd60": "[QueuedMessageHandler] {msg_type}: {message}",
+    "0be9a22226e16a40797010d23a0f581542dca40e": "[ToolExecutor] {tool_name} chamado com arguments: {args}",
+    "42c68edcb25442f518b1af77c6a2ddc07461aae0": "[ToolExecutor] Motivo da chamada: {tool_call_reason}",
+    "002ff598115d84595ffeee6219cb5c03d3a1d4a6": "Pergunta",
+    "35747d13dcd91e8e8790c7f767d5ed764f541b9e": "prosseguir",
+    "33dde3a1afbc418768a69fa53168d9b0638fe1aa": "avançar",
+    "eee0bbba4ff92adbeb038a77df0466d660f15716": "continuar",
+    "edee9402d198b04ac77dcf5dc9cc3dac44573782": "próximo",
+    "8fdb7e2fa84f4faf0d9b92f466df424ec47a165b": "ok",
+    "5f8f924671cda79b5205a6bf1b776f347c4a7a07": "Opções de configuração disponíveis:\n",
+    "cef780a309cd234750764d42697882c24168ddab": "{key:15} {desc} (padrão: {default})",
+    "68c2cc7f0ceaa3e499ecb4db331feb4debbbcc23": "Modelo",
+    "c3f104d1365744b538bfde9f4adb6a6df4b80355": "Função",
+    "99a0efc6cfd85d8ff2732a6718140f822cb90472": "Estilo",
+    "f1702b4686278becffc88baabe6f4b7a8355532c": "Mensagens",
+    "c38c6c1f3a2743f8626703abb302e403d20ff81c": "Tokens",
+    "a817d7eb8e0f1dab755ab5203a082e5c3c094fce": "Prompt",
+    "2ff255684a2277f806fcebf3fe338ed27857f350": "Conclusão",
+    "b25928c69902557b0ef0a628490a3a1768d7b82f": "Total",
+    "76e63d65c883ed50df40ac3aeef0c2d6a1c4ad60": "Ação Rápida",
+    "5397e0583f14f6c88de06b1ef28f460a1fb5b0ae": "Sim",
+    "816c52fd2bdd94a63cd0944823a6c0aa9384c103": "Não",
+    "c47ae15370cfe1ed2781eedc1dc2547d12d9e972": "Ajuda",
+    "cc3dbd47e1cf9003a55d3366b3adbcd72275e525": "Nova Tarefa",
+    "efa5a8b84e1afe65c81ecfce28c398c48f19ddc2": "Bem-vindo ao Janito{version_str}! Entrando no modo de chat. Digite /exit para sair.",
+    "b314d6e1460f86e0f21abc5aceb7935a2a0667e8": "Bem-vindo ao Janito{version_str} no [white on magenta]MODO VANILLA[/white on magenta]! Ferramentas, prompt do sistema e temperatura estão desativados, a menos que sejam substituídos.",
+}

janito/rich_utils.py

@@ -1,43 +1,43 @@
-"""
-Utilities for working with the Rich library.
-"""
-
-from rich.markdown import Markdown
-from rich.text import Text
-from rich.console import Console
-
-
-def print_markdown(console: Console, message: str):
-    console.print(Markdown(message))
-
-
-def print_info(console: Console, message: str):
-    console.print(message, style="cyan", end="")
-
-
-def print_success(console: Console, message: str):
-    console.print(message, style="bold green", end="\n")
-
-
-def print_error(console: Console, message: str):
-    console.print(message, style="bold red", end="\n")
-
-
-def print_warning(console: Console, message: str):
-    console.print(message, style="bold yellow", end="\n")
-
-
-def print_magenta(console: Console, message: str):
-    console.print(message, style="magenta", end="\n")
-
-
-def print_stdout(console: Console, message: str):
-    console.print(
-        Text(message, style="on #003300", no_wrap=True, overflow=None), end=""
-    )
-
-
-def print_stderr(console: Console, message: str):
-    console.print(
-        Text(message, style="on #330000", no_wrap=True, overflow=None), end=""
-    )
+"""
+Utilities for working with the Rich library.
+"""
+
+from rich.markdown import Markdown
+from rich.text import Text
+from rich.console import Console
+
+
+def print_markdown(console: Console, message: str):
+    console.print(Markdown(message))
+
+
+def print_info(console: Console, message: str):
+    console.print(message, style="cyan", end="")
+
+
+def print_success(console: Console, message: str):
+    console.print(message, style="bold green", end="\n")
+
+
+def print_error(console: Console, message: str):
+    console.print(message, style="bold red", end="\n")
+
+
+def print_warning(console: Console, message: str):
+    console.print(message, style="bold yellow", end="\n")
+
+
+def print_magenta(console: Console, message: str):
+    console.print(message, style="magenta", end="\n")
+
+
+def print_stdout(console: Console, message: str):
+    console.print(
+        Text(message, style="on #003300", no_wrap=True, overflow=None), end=""
+    )
+
+
+def print_stderr(console: Console, message: str):
+    console.print(
+        Text(message, style="on #330000", no_wrap=True, overflow=None), end=""
+    )

janito/termweb/app.py

@@ -0,0 +1,95 @@
+from quart import Quart, send_from_directory, request, jsonify, websocket
+import os
+from janito.agent.tools.dir_walk_utils import walk_dir_with_gitignore
+
+app = Quart(__name__)
+
+BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))
+
+
+@app.route("/")
+async def index():
+    static_dir = os.path.join(os.path.dirname(__file__), "static")
+    file_path = request.args.get("path")
+    if file_path:
+        return await send_from_directory(static_dir, "editor.html")
+    return await send_from_directory(static_dir, "index.html")
+
+
+@app.route("/static/<path:filepath>")
+async def server_static(filepath):
+    static_dir = os.path.join(os.path.dirname(__file__), "static")
+    return await send_from_directory(static_dir, filepath)
+
+
+@app.route("/api/explorer/")
+async def api_explorer_root():
+    return await api_explorer(".")
+
+
+@app.route("/api/explorer/<path:path>", methods=["GET", "POST"])
+async def api_explorer(path="."):
+    abs_path = os.path.abspath(os.path.join(BASE_DIR, path))
+    # Security: Only allow files/dirs within BASE_DIR
+    if not abs_path.startswith(BASE_DIR):
+        return jsonify({"error": "Acesso negado."}), 403
+
+    if request.method == "POST":
+        # Gravação de arquivo
+        if os.path.isdir(abs_path):
+            return jsonify({"error": "Não é possível gravar em um diretório."}), 400
+        try:
+            data = await request.get_json()
+            content = data.get("content", "")
+            with open(abs_path, "w", encoding="utf-8") as f:
+                f.write(content)
+            return jsonify({"success": True})
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+    # GET: comportamento actual
+    if os.path.isdir(abs_path):
+        entries = []
+        walker = walk_dir_with_gitignore(abs_path, recursive=False)
+        for root, dirs, files in walker:
+            for entry in sorted(dirs):
+                entries.append({"name": entry, "is_dir": True})
+            for entry in sorted(files):
+                entries.append({"name": entry, "is_dir": False})
+        return jsonify({"type": "dir", "path": path, "entries": entries})
+    elif os.path.isfile(abs_path):
+        with open(abs_path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+        return jsonify({"type": "file", "path": path, "content": content})
+    else:
+        return jsonify({"error": "Não encontrado."}), 404
+
+
+# Example WebSocket endpoint
+@app.websocket("/ws")
+async def ws():
+    while True:
+        data = await websocket.receive()
+        await websocket.send(f"Echo: {data}")
+
+
+# Catch-all route for SPA navigation (excluding /static and /api)
+@app.route("/<path:catchall>")
+async def spa_catch_all(catchall):
+    static_dir = os.path.join(os.path.dirname(__file__), "static")
+    return await send_from_directory(static_dir, "index.html")
+
+
+if __name__ == "__main__":
+    import sys
+
+    port = 8088
+    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
+    print(f"Iniciando servidor web Quart em http://localhost:{port}")
+    app.run(host="localhost", port=port, debug=True)