code-puppy 0.0.781__tar.gz → 0.0.783__tar.gz

{code_puppy-0.0.781 → code_puppy-0.0.783}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.781
+Version: 0.0.783
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -20,7 +20,7 @@ Requires-Dist: anthropic<1,>=0.108.0
 Requires-Dist: anyio>=4.7.0
 Requires-Dist: azure-identity>=1.15.0
 Requires-Dist: boto3>=1.43.9
-Requires-Dist: code-puppy-core-plugins>=0.0.12
+Requires-Dist: code-puppy-core-plugins>=0.0.26
 Requires-Dist: httpx[http2]>=0.24.1
 Requires-Dist: json-repair>=0.46.2
 Requires-Dist: keyring>=24.0.0
@@ -30,7 +30,6 @@ Requires-Dist: openai>=2.45.0
 Requires-Dist: packaging>=24.0
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: playwright>=1.40.0; sys_platform != 'android'
-Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic-ai-harness==0.23.0
 Requires-Dist: pydantic-ai-slim[anthropic,mcp,openai]==2.31.0
 Requires-Dist: pydantic>=2.4.0
@@ -40,7 +39,7 @@ Requires-Dist: rapidfuzz>=3.13.0
 Requires-Dist: requests>=2.28.0
 Requires-Dist: rich>=13.4.2
 Requires-Dist: ripgrep==14.1.0; sys_platform != 'android'
-Requires-Dist: termflow-md>=0.8.0
+Requires-Dist: termflow-md>=0.9.0
 Requires-Dist: typer>=0.12.0
 Provides-Extra: bedrock
 Requires-Dist: boto3>=1.35.0; extra == 'bedrock'

{code_puppy-0.0.781 → code_puppy-0.0.783}/code_puppy/cli_runner.py

@@ -371,7 +371,7 @@ async def main():
     )
 
     if disable_windows_ctrl_c():
-        # Keep the clamp sticky across terminal resets / prompt_toolkit mode restores.
+        # Keep the clamp sticky across terminal resets / console mode restores.
         set_keep_ctrl_c_disabled(True)
 
     # Load API keys from puppy.cfg into environment variables
@@ -618,7 +618,7 @@ async def main():
 def _use_persistent_prompt() -> bool:
     """Should the REPL use the persistent bottom-bar prompt (Phase A)?
 
-    False (→ classic prompt_toolkit path) when:
+    False (-> classic plain-input path) when:
       * rollback flag: env CODE_PUPPY_CLASSIC_PROMPT=1 or config
         ``classic_prompt`` truthy — protects the eyeball-testing period;
       * CODE_PUPPY_NO_TUI=1 (tests / pexpect harnesses);
@@ -666,7 +666,7 @@ def _persistent_prompt_parts() -> tuple:
     in-band escapes, so colors can't ride inside the string itself).
     """
     try:
-        from code_puppy.command_line.prompt_toolkit_completion import (
+        from code_puppy.command_line.completers import (
             PROMPT_STYLES,
             get_prompt_with_active_model,
         )
@@ -820,35 +820,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
             emit_error(t("cli.initial_command.error", error=str(e)))
 
-    # Check if prompt_toolkit is installed
-    try:
-        from code_puppy.command_line.prompt_toolkit_completion import (
-            get_input_with_combined_completion,
-            get_prompt_with_active_model,
-        )
-    except ImportError:
-        from code_puppy.messaging import emit_warning
-
-        emit_warning(t("cli.prompt_toolkit.installing"))
-        try:
-            import subprocess
-
-            subprocess.check_call(
-                [sys.executable, "-m", "pip", "install", "--quiet", "prompt_toolkit"]
-            )
-            from code_puppy.messaging import emit_success
-
-            emit_success(t("cli.prompt_toolkit.installed"))
-            from code_puppy.command_line.prompt_toolkit_completion import (
-                get_input_with_combined_completion,
-                get_prompt_with_active_model,
-            )
-        except Exception as e:
-            from code_puppy.messaging import emit_error, emit_warning
-
-            emit_error(t("cli.prompt_toolkit.install_error", error=e))
-            emit_warning(t("cli.prompt_toolkit.fallback"))
-
     # Autosave loading is now manual - use /autosave_load command
 
     record_terminal_session(get_current_session_name(), overwrite=False)
@@ -926,47 +897,27 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                     # doubled every line's noise. Text() so bracket-y input renders as-is.
                     emit_info(_prompt_echo_text(task))
             else:
-                # Use prompt_toolkit for enhanced input with path completion
-                try:
-                    # Windows-specific: Reset terminal state before prompting
-                    reset_windows_terminal_ansi()
-
-                    # Use the async version of get_input_with_combined_completion
-                    task = await get_input_with_combined_completion(
-                        get_prompt_with_active_model(),
-                        history_file=COMMAND_HISTORY_FILE,
-                    )
-
-                    # Windows: re-clamp raw-Ctrl+C mode after prompt_toolkit
-                    # (prompt_toolkit restores console mode on exit)
-                    try:
-                        from code_puppy.terminal_utils import ensure_ctrl_c_disabled
+                # Classic (non-TTY / rollback) prompt: plain blocking input.
+                # No completion here -- the persistent bottom-bar editor is
+                # the featured path; this branch exists for pipes, CI, and
+                # the CODE_PUPPY_CLASSIC_PROMPT escape hatch.
+                reset_windows_terminal_ansi()
+                task = input(">>> ")
+                from code_puppy.messaging.editor_history import HistoryStore
 
-                        ensure_ctrl_c_disabled()
-                    except ImportError:
-                        pass
-                except ImportError:
-                    # Fall back to basic input if prompt_toolkit is not available
-                    task = input(">>> ")
+                HistoryStore(COMMAND_HISTORY_FILE).append(task)
 
         except (KeyboardInterrupt, asyncio.CancelledError) as cancel_exc:
             # Ctrl+C: cancel input and continue. Reset terminal state on Windows
             # so it doesn't become unresponsive.
             reset_windows_terminal_full()
             from code_puppy.callbacks import on_interactive_turn_cancel
-            from code_puppy.command_line.prompt_toolkit_completion import (
-                pop_non_ctrl_c_cancel,
-            )
             from code_puppy.messaging import emit_success, emit_warning
             from code_puppy.messaging.run_ui import DOUBLE_CTRL_C_WINDOW_S
 
-            # Double Ctrl+C at the idle prompt quits like Ctrl+D. Escape and
-            # Ctrl+X raise the same KeyboardInterrupt but mark themselves, so
-            # mashing Escape can never exit; CancelledError never counts.
-            was_plain_ctrl_c = (
-                isinstance(cancel_exc, KeyboardInterrupt)
-                and not pop_non_ctrl_c_cancel()
-            )
+            # Double Ctrl+C at the idle prompt quits like Ctrl+D.
+            # CancelledError never counts.
+            was_plain_ctrl_c = isinstance(cancel_exc, KeyboardInterrupt)
             now = time.monotonic()
             if was_plain_ctrl_c and now - last_idle_ctrl_c <= DOUBLE_CTRL_C_WINDOW_S:
                 emit_success("\n" + t("cli.goodbye_ctrld"))

code_puppy-0.0.783/code_puppy/command_line/completers.py

@@ -0,0 +1,434 @@
+"""Slash-command completers and the REPL prompt prefix.
+
+Home of the completion stack (on termflow's completer protocol) and the
+prompt-prefix builder, extracted from the retired classic
+prompt_toolkit input path. The raw bottom-bar editor consumes the stack
+through :func:`build_completer_stack`.
+"""
+
+from __future__ import annotations
+
+import os
+import unicodedata
+
+from termflow.tui.completion import Completer, Completion, merge_completers
+
+from code_puppy.command_line.command_registry import get_unique_commands
+from code_puppy.command_line.completion_cache import TTLCache
+from code_puppy.command_line.utils import list_directory
+from code_puppy.config import (
+    get_config_keys,
+    get_puppy_name,
+    get_value,
+)
+
+_config_keys_cache: TTLCache[tuple[object, list[str]]] = TTLCache()
+_slash_catalog_cache: TTLCache[list[dict[str, str]]] = TTLCache()
+
+
+def _sanitize_for_encoding(text: str) -> str:
+    """Remove or replace characters that can't be safely encoded.
+
+    Handles lone surrogates (U+D800-U+DFFF, invalid in UTF-8) and other
+    problematic sequences from Windows copy-paste.
+    """
+    try:
+        text.encode("utf-8")
+        return text  # String is already valid UTF-8
+    except UnicodeEncodeError:
+        pass
+
+    try:
+        return text.encode("utf-8", errors="surrogatepass").decode(
+            "utf-8", errors="replace"
+        )
+    except (UnicodeEncodeError, UnicodeDecodeError):
+        # Last resort: filter out all non-BMP and surrogate characters
+        return "".join(
+            char
+            for char in text
+            if ord(char) < 0xD800 or (ord(char) > 0xDFFF and ord(char) < 0x10000)
+        )
+
+
+def _strip_variation_selectors(text: str) -> str:
+    """Remove variation selectors (U+FE00-FE0F) from text.
+
+    These invisible characters modify emoji rendering but cause width
+    calculation mismatches between line editors and terminal emulators.
+    """
+    return "".join(c for c in text if not (0xFE00 <= ord(c) <= 0xFE0F))
+
+
+def _normalize_emoji_spacing(text: str) -> str:
+    """Normalize emoji spacing for consistent terminal rendering.
+
+    Some emojis have East Asian Width 'N' (Neutral) which terminals render
+    inconsistently. This adds a space after such emojis to prevent
+    the following character from overlapping.
+    """
+    result = []
+    text = _strip_variation_selectors(text)
+    for char in text:
+        result.append(char)
+        # Add padding after Neutral-width emoji to prevent overlap
+        if (
+            0x1F300 <= ord(char) <= 0x1FAFF
+            and unicodedata.east_asian_width(char) == "N"
+        ):
+            result.append(" ")  # Extra space buffer
+    return "".join(result)
+
+
+# ---------------------------------------------------------------------------
+# Completers
+# ---------------------------------------------------------------------------
+
+
+class SetCompleter(Completer):
+    def __init__(self, trigger: str = "/set"):
+        self.trigger = trigger
+
+    def get_completions(self, document, complete_event):
+        cursor_position = document.cursor_position
+        text_before_cursor = document.text_before_cursor
+        stripped_text_for_trigger_check = text_before_cursor.lstrip()
+
+        # If user types just /set (no space), suggest adding a space
+        if stripped_text_for_trigger_check == self.trigger:
+            yield Completion(
+                self.trigger + " ",
+                start_position=-len(self.trigger),
+                display=self.trigger + " ",
+                display_meta="set config key",
+            )
+            return
+
+        # Require a space after /set before showing completions
+        if not stripped_text_for_trigger_check.startswith(self.trigger + " "):
+            return
+
+        # Determine the part of the text that is relevant for this completer
+        # (handles cases like "  /set foo" where the trigger isn't at index 0)
+        actual_trigger_pos = text_before_cursor.find(self.trigger)
+
+        # Extract the input after /set and space (up to cursor)
+        trigger_end = actual_trigger_pos + len(self.trigger) + 1  # +1 for the space
+        text_after_trigger = text_before_cursor[trigger_end:cursor_position].lstrip()
+        start_position = -len(text_after_trigger)
+
+        # --- SPECIAL HANDLING FOR 'model' KEY ---
+        if text_after_trigger == "model":
+            # Don't return any completions -- let ModelNameCompleter handle it
+            return
+
+        # Get config keys and sort them alphabetically for consistent display.
+        # Per-model controls belong exclusively to /model_settings.
+        from code_puppy.command_line.config_apply import MODEL_SETTINGS_ONLY_KEYS
+
+        cached_getter, config_keys = _config_keys_cache.get(
+            lambda: (get_config_keys, sorted(get_config_keys()))
+        )
+        if cached_getter is not get_config_keys:
+            _config_keys_cache.clear()
+            _, config_keys = _config_keys_cache.get(
+                lambda: (get_config_keys, sorted(get_config_keys()))
+            )
+
+        for key in config_keys:
+            if key in {"model", "puppy_token"} | MODEL_SETTINGS_ONLY_KEYS:
+                continue
+            if key.startswith(text_after_trigger):
+                prev_value = get_value(key)
+                value_part = f" = {prev_value}" if prev_value is not None else " = "
+                completion_text = f"{key}{value_part}"
+
+                yield Completion(
+                    completion_text,
+                    start_position=start_position,
+                    display_meta="",
+                )
+
+
+class CDCompleter(Completer):
+    def __init__(self, trigger: str = "/cd"):
+        self.trigger = trigger
+
+    def get_completions(self, document, complete_event):
+        text_before_cursor = document.text_before_cursor
+        stripped_text = text_before_cursor.lstrip()
+
+        # Require a space after /cd before showing completions
+        if not stripped_text.startswith(self.trigger + " "):
+            return
+
+        # Extract the directory path after /cd and space (up to cursor)
+        trigger_pos = text_before_cursor.find(self.trigger)
+        trigger_end = trigger_pos + len(self.trigger) + 1  # +1 for the space
+        dir_path = text_before_cursor[trigger_end:].lstrip()
+        start_position = -(len(dir_path))
+
+        try:
+            # Treat a bare `~` as `~/` so we complete inside the home
+            # directory, not the parent containing the username folder.
+            lookup_path = "~/" if dir_path == "~" else dir_path
+            expanded_lookup = os.path.expanduser(lookup_path)
+
+            # If the typed path ends with a separator, we're completing inside
+            # that directory and should match all child names.
+            if lookup_path.endswith(os.sep):
+                part = expanded_lookup
+                name_prefix = ""
+            else:
+                part = os.path.dirname(expanded_lookup) or "."
+                name_prefix = os.path.basename(expanded_lookup)
+
+            dirs, _ = list_directory(part)
+            dirnames = [d for d in dirs if d.startswith(name_prefix)]
+
+            # Preserve user's typed style (~, relative, absolute) in emitted
+            # completion text instead of leaking expanded absolute paths.
+            if dir_path == "~":
+                typed_base = "~"
+            elif dir_path.endswith(os.sep):
+                stripped_base = dir_path.rstrip(os.sep)
+                if not stripped_base and dir_path.startswith(os.sep):
+                    typed_base = os.sep
+                else:
+                    typed_base = stripped_base
+            else:
+                typed_base = os.path.dirname(dir_path.rstrip(os.sep))
+
+            for d in dirnames:
+                suggestion = os.path.join(typed_base, d) if typed_base else d
+                suggestion = suggestion.rstrip(os.sep) + os.sep
+                yield Completion(
+                    suggestion,
+                    start_position=start_position,
+                    display=d + os.sep,
+                    display_meta="Directory",
+                )
+        except Exception:
+            # Silently ignore errors (e.g., permission issues, non-existent dir)
+            pass
+
+
+class AgentCompleter(Completer):
+    """A completer that triggers on '/agent' to show available agents."""
+
+    def __init__(self, trigger: str = "/agent", prefix: str = ""):
+        self.trigger = trigger
+        self.prefix = prefix
+
+    def get_completions(self, document, complete_event):
+        cursor_position = document.cursor_position
+        text_before_cursor = document.text_before_cursor
+        stripped_text = text_before_cursor.lstrip()
+
+        # Require a space after /agent before showing completions
+        if not stripped_text.startswith(self.trigger + " "):
+            return
+
+        # Extract the input after /agent and space (up to cursor)
+        trigger_pos = text_before_cursor.find(self.trigger)
+        trigger_end = trigger_pos + len(self.trigger) + 1  # +1 for the space
+        text_after_trigger = text_before_cursor[trigger_end:cursor_position].lstrip()
+        if self.prefix:
+            if not text_after_trigger.startswith(self.prefix):
+                return
+            text_after_trigger = text_after_trigger[len(self.prefix) :]
+        start_position = -len(text_after_trigger)
+
+        try:
+            from code_puppy.command_line.pin_command_completion import load_agent_names
+
+            agent_names = load_agent_names()
+        except Exception:
+            return
+
+        try:
+            from code_puppy.command_line.pin_command_completion import (
+                _get_agent_display_meta,
+            )
+        except ImportError:
+            _get_agent_display_meta = lambda x: "default"  # noqa: E731
+
+        for agent_name in agent_names:
+            if agent_name.lower().startswith(text_after_trigger.lower()):
+                yield Completion(
+                    agent_name,
+                    start_position=start_position,
+                    display=agent_name,
+                    display_meta=_get_agent_display_meta(agent_name),
+                )
+
+
+def _read_slash_catalog() -> list[dict[str, str]]:
+    """Load registered and plugin command help without filtering or reordering."""
+    catalog = []
+    for cmd in get_unique_commands():
+        catalog.append(
+            {"text": cmd.name, "display": f"/{cmd.name}", "meta": cmd.description}
+        )
+        catalog.extend(
+            {
+                "text": alias,
+                "display": f"/{alias} (alias for /{cmd.name})",
+                "meta": cmd.description,
+            }
+            for alias in cmd.aliases
+        )
+    try:
+        from code_puppy import callbacks, plugins
+
+        plugins.load_plugin_callbacks()
+        for result in callbacks.on_custom_command_help():
+            items = result if isinstance(result, list) else [result]
+            for item in items:
+                if isinstance(item, tuple) and len(item) == 2:
+                    name, description = map(str, item)
+                    catalog.append(
+                        {"text": name, "display": f"/{name}", "meta": description}
+                    )
+    except Exception:
+        pass
+    return catalog
+
+
+class SlashCompleter(Completer):
+    """Completes '/' at the beginning of the line with all slash commands."""
+
+    def get_completions(self, document, complete_event):
+        text_before_cursor = document.text_before_cursor
+        stripped_text = text_before_cursor.lstrip()
+
+        # Only trigger if '/' is the first non-whitespace character
+        if not stripped_text.startswith("/"):
+            return
+
+        # A bare slash intentionally yields every command so the menu
+        # appears immediately while typing.
+        partial = stripped_text[1:]
+        start_position = -len(partial)
+
+        try:
+            catalog = _slash_catalog_cache.get(_read_slash_catalog)
+        except Exception:
+            return
+        partial_lower = partial.lower()
+        all_completions = [
+            item for item in catalog if item["text"].lower().startswith(partial_lower)
+        ]
+        all_completions.sort(key=lambda item: item["text"].lower())
+
+        # Strip variation selectors (U+FE00-FE0F) from display strings: they
+        # cause width mismatches -> phantom spaces (e.g. in the /judges menu).
+        for completion in all_completions:
+            yield Completion(
+                completion["text"],
+                start_position=start_position,
+                display=_strip_variation_selectors(completion["display"]),
+                display_meta=_strip_variation_selectors(completion["meta"]),
+            )
+
+
+def build_completer_stack() -> Completer:
+    """The full REPL completer stack (single source of truth)."""
+    from code_puppy.callbacks import get_completion_providers
+    from code_puppy.command_line.file_path_completion import FilePathCompleter
+    from code_puppy.command_line.load_context_completion import LoadContextCompleter
+    from code_puppy.command_line.mcp_completion import MCPCompleter
+    from code_puppy.command_line.model_picker_completion import ModelNameCompleter
+    from code_puppy.command_line.pin_command_completion import (
+        PinCompleter,
+        UnpinCompleter,
+    )
+    from code_puppy.command_line.skills_completion import SkillsCompleter
+
+    return merge_completers(
+        [
+            FilePathCompleter(symbol="@"),
+            ModelNameCompleter(trigger="/model"),
+            ModelNameCompleter(trigger="/m"),
+            CDCompleter(trigger="/cd"),
+            SetCompleter(trigger="/set"),
+            LoadContextCompleter(trigger="/load_context"),
+            PinCompleter(trigger="/pin_model"),
+            UnpinCompleter(trigger="/unpin"),
+            AgentCompleter(trigger="/agent"),
+            AgentCompleter(trigger="/a"),
+            AgentCompleter(trigger="/switch-agent"),
+            AgentCompleter(trigger="/sa"),
+            AgentCompleter(trigger="/fork", prefix="@"),
+            ModelNameCompleter(trigger="/fork", prefix="@"),
+            MCPCompleter(trigger="/mcp"),
+            SkillsCompleter(trigger="/skills"),
+            *get_completion_providers(),
+            SlashCompleter(),
+        ]
+    )
+
+
+# ---------------------------------------------------------------------------
+# Prompt prefix
+# ---------------------------------------------------------------------------
+
+# REPL prompt palette (source of truth -- the bottom-bar prompt converts
+# these to raw SGR via messaging.prompt_prefix_style). IMPORTANT: use
+# `ansi*` names -- bare names resolve to truecolor hex and IGNORE the terminal
+# palette, so /theme's OSC remap couldn't restyle the prompt.
+PROMPT_STYLES = {
+    "puppy": "bold ansimagenta",
+    "agent": "bold ansiblue",
+    "model": "bold ansicyan",
+    "cwd": "bold ansigreen",
+    "arrow": "bold ansiyellow",
+}
+
+
+def get_prompt_with_active_model(base: str = ">>> ") -> list:
+    """Styled prompt fragments: puppy [agent] [model] (cwd) >>>.
+
+    Returns a plain list of ``(style, text)`` tuples (the FormattedText
+    shape without the class) for ``flatten_prompt_fragments``.
+    """
+    from code_puppy.agents.agent_manager import get_current_agent
+    from code_puppy.command_line.model_picker_completion import get_active_model
+
+    puppy = get_puppy_name()
+    # When nothing is configured this is None - surface that explicitly as
+    # [None] so the user immediately sees they need to /add_model.
+    global_model = get_active_model()
+
+    current_agent = get_current_agent()
+    agent_display = current_agent.display_name if current_agent else "code-puppy"
+
+    agent_model = None
+    if current_agent and hasattr(current_agent, "get_model_name"):
+        agent_model = current_agent.get_model_name()
+
+    if agent_model and agent_model != global_model:
+        model_display = f"[{global_model} \u2192 {agent_model}]"
+    elif agent_model:
+        model_display = f"[{agent_model}]"
+    else:
+        # global_model may be None -> renders as [None].
+        model_display = f"[{global_model}]"
+
+    cwd = os.getcwd()
+    home = os.path.expanduser("~")
+    if cwd.startswith(home):
+        cwd_display = "~" + cwd[len(home) :]
+    else:
+        cwd_display = cwd
+    return [
+        ("class:puppy class:tui.header", f"{puppy}"),
+        ("", " "),
+        (
+            "class:agent class:tui.label",
+            f"[{_normalize_emoji_spacing(agent_display)}] ",
+        ),
+        ("class:model class:tui.title", model_display + " "),
+        ("class:cwd class:tui.muted", "(" + str(cwd_display) + ") "),
+        ("class:arrow class:tui.help-key", str(base)),
+    ]

{code_puppy-0.0.781 → code_puppy-0.0.783}/code_puppy/command_line/file_path_completion.py

@@ -20,8 +20,7 @@ import glob
 import os
 from typing import Iterable, List, Tuple
 
-from prompt_toolkit.completion import Completer, Completion
-from prompt_toolkit.document import Document
+from termflow.tui.completion import Completer, Completion, Document
 
 from code_puppy.command_line import file_index
 

{code_puppy-0.0.781 → code_puppy-0.0.783}/code_puppy/command_line/load_context_completion.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from prompt_toolkit.completion import Completer, Completion
+from termflow.tui.completion import Completer, Completion
 
 from code_puppy.config import CONFIG_DIR
 

{code_puppy-0.0.781 → code_puppy-0.0.783}/code_puppy/command_line/mcp/custom_server_form.py

@@ -294,14 +294,10 @@ def build_form_menu(form: CustomServerForm, initial_index: int = 0, **overrides)
 
     json_status = "valid" if form._validate_json() else "INVALID"
     items = [
-        MenuItem(
-            f"Server Name: {form.server_name or '(not set)'}", value=_FIELD_NAME
-        ),
+        MenuItem(f"Server Name: {form.server_name or '(not set)'}", value=_FIELD_NAME),
         MenuItem(f"Server Type: {form._get_current_type()}", value=_FIELD_TYPE),
         MenuItem(f"JSON Configuration ({json_status})", value=_FIELD_JSON),
-        MenuItem(
-            f"Load example for {form._get_current_type()}", value=_ACTION_EXAMPLE
-        ),
+        MenuItem(f"Load example for {form._get_current_type()}", value=_ACTION_EXAMPLE),
         MenuItem("Save & Install", value=_ACTION_SAVE),
         MenuItem("Cancel", value=_ACTION_CANCEL),
     ]
@@ -414,7 +410,11 @@ def run_json_fallback_editor(form: CustomServerForm, **overrides) -> None:
             return f"Invalid JSON: {e.msg}"
         return None
 
-    compact = json.dumps(json.loads(form.json_config)) if _parses(form.json_config) else form.json_config
+    compact = (
+        json.dumps(json.loads(form.json_config))
+        if _parses(form.json_config)
+        else form.json_config
+    )
     builder = (
         TextInputBuilder("JSON Configuration (single line)")
         .prompt("JSON: ")
@@ -456,7 +456,14 @@ def run_form_flow(
 ) -> bool:
     """The field-edit loop. True when a server was installed."""
     cursor = 0
-    field_order = [_FIELD_NAME, _FIELD_TYPE, _FIELD_JSON, _ACTION_EXAMPLE, _ACTION_SAVE, _ACTION_CANCEL]
+    field_order = [
+        _FIELD_NAME,
+        _FIELD_TYPE,
+        _FIELD_JSON,
+        _ACTION_EXAMPLE,
+        _ACTION_SAVE,
+        _ACTION_CANCEL,
+    ]
     while True:
         result = menu_factory(form, initial_index=cursor).run()
         if result.cancelled or result.item is None: