create-leafmesh 2.6.3__tar.gz → 2.6.4__tar.gz

{create_leafmesh-2.6.3 → create_leafmesh-2.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-leafmesh
-Version: 2.6.3
+Version: 2.6.4
 Summary: Project scaffolding + cloud-deploy tool for LeafMesh
 License-Expression: MIT
 Requires-Python: >=3.10

{create_leafmesh-2.6.3 → create_leafmesh-2.6.4}/create_leafmesh/__init__.py

@@ -1,3 +1,3 @@
 """create-leafmesh — Project scaffolding + cloud-deploy tool for LeafMesh."""
 
-__version__ = "2.6.3"
+__version__ = "2.6.4"

create_leafmesh-2.6.4/create_leafmesh/discover.py

@@ -0,0 +1,336 @@
+"""Full-screen, live type-to-search template browser (the "Discover" UI).
+
+Layout (top → bottom):
+
+    ┌ search N teams (across all tabs) ─────────────────┐
+    │ ⌕ <live query>                                    │   ← bordered box
+    └───────────────────────────────────────────────────┘
+     All · Start here · Sales & GTM · Engineering · …        ← business-function tabs
+    ───────────────────────────────────────────────────────
+     ❯ procurement-ops   Production & supply   12 agents      ← list (full-row
+         Order → inventory → supplier sourcing → PO             highlight on ❯)
+    ───────────────────────────────────────────────────────
+     Type to search · ←/→ tabs · ↑/↓ move · Enter view · Esc
+
+Two navigation modes that don't fight each other:
+  * ←/→ switch the active **tab** (a business function) and browse just that
+    category. Tabs are for browsing.
+  * Typing **searches across ALL tabs** — the active tab is suspended while a
+    query is present, and restored when you clear it. Search is global.
+
+Pressing Enter opens a detail screen with a confirm-to-scaffold step.
+
+Built on prompt_toolkit (ships via `questionary` — no new dependency). The
+caller (cli.py) falls back to the numbered picker when there's no TTY.
+
+Public entry point: `discover_templates(templates) -> str | None`.
+"""
+
+from __future__ import annotations
+
+import textwrap
+from typing import Any
+
+from create_leafmesh.search import browser_filter
+
+_ALL_TAB = "All"
+
+
+def _ordered_categories(templates: list[dict[str, Any]]) -> list[str]:
+    """Distinct categories in registry (display) order."""
+    cats: list[str] = []
+    for t in templates:
+        c = t.get("category") or "Other"
+        if c not in cats:
+            cats.append(c)
+    return cats
+
+
+def discover_templates(
+    templates: list[dict[str, Any]],
+    *,
+    _input=None,
+    _output=None,
+) -> str | None:
+    """Run the full-screen Discover browser. Returns a slug or None.
+
+    Raises ImportError if prompt_toolkit isn't importable, so the caller can
+    fall back to the numbered picker.
+
+    `_input` / `_output` are test seams: pass a prompt_toolkit pipe input and
+    a DummyOutput to drive the browser headlessly.
+    """
+    from prompt_toolkit.application import Application, get_app
+    from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.data_structures import Point
+    from prompt_toolkit.document import Document
+    from prompt_toolkit.filters import Condition
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.layout import Layout
+    from prompt_toolkit.layout.containers import HSplit, VSplit, Window
+    from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+    from prompt_toolkit.layout.dimension import Dimension
+    from prompt_toolkit.styles import Style
+    from prompt_toolkit.widgets import Frame
+
+    total = len(templates)
+    tabs = [_ALL_TAB] + _ordered_categories(templates)
+
+    state = {
+        "tab": 0,                       # index into `tabs`
+        "filtered": list(templates),
+        "sel": 0,
+        "mode": "list",                 # "list" | "detail"
+        "result": None,
+    }
+
+    search = Buffer(multiline=False)
+
+    def _recompute() -> None:
+        q = search.text.strip()
+        if q:
+            # Global: search spans every tab, ignoring the active one.
+            state["filtered"] = browser_filter(templates, q)
+        else:
+            tab = tabs[state["tab"]]
+            if tab == _ALL_TAB:
+                state["filtered"] = list(templates)
+            else:
+                state["filtered"] = [
+                    t for t in templates if (t.get("category") or "Other") == tab
+                ]
+        state["sel"] = 0
+
+    search.on_text_changed += lambda _b: _recompute()
+
+    is_list = Condition(lambda: state["mode"] == "list")
+    is_detail = Condition(lambda: state["mode"] == "detail")
+
+    def _current() -> dict[str, Any] | None:
+        f = state["filtered"]
+        if not f:
+            return None
+        return f[min(state["sel"], len(f) - 1)]
+
+    def _cols() -> int:
+        try:
+            return get_app().output.get_size().columns or 80
+        except Exception:
+            return 80
+
+    def _set_tab(i: int) -> None:
+        state["tab"] = i % len(tabs)
+        # Switching tab is a browse action → drop any active query.
+        if search.text:
+            search.document = Document("")   # fires on_text_changed → _recompute
+        else:
+            _recompute()
+
+    # ── Tab bar ──────────────────────────────────────────────────────
+    def tabbar_text():
+        searching = bool(search.text.strip())
+        out: list[tuple[str, str]] = [("class:dim", "  ")]
+        for i, name in enumerate(tabs):
+            active = (i == state["tab"]) and not searching
+            out.append(("class:tab-active" if active else "class:tab", f" {name} "))
+            if i != len(tabs) - 1:
+                out.append(("class:dim", "·"))
+        if searching:
+            out.append(("class:hint", "    ⌕ searching all tabs"))
+        return out
+
+    # ── List body ────────────────────────────────────────────────────
+    def _list_text():
+        f = state["filtered"]
+        if not f:
+            return [("class:dim",
+                     "\n  No matches — try fewer letters, or ←/→ to pick a tab.\n")]
+        w = _cols()
+        sel = min(state["sel"], len(f) - 1)
+        slug_w = min(max((len(t["slug"]) for t in f), default=18) + 2, 28)
+        out: list[tuple[str, str]] = []
+        for i, t in enumerate(f):
+            selected = (i == sel)
+            ptr = "❯ " if selected else "  "
+            slug = t["slug"]
+            cat = t.get("category", "")
+            agents = f"{t['agent_count']} agents" if t.get("agent_count") else ""
+            left = f"  {ptr}{slug.ljust(slug_w)}{cat}"
+            gap = max(2, w - len(left) - len(agents) - 1)
+            line1 = f"{left}{' ' * gap}{agents}"
+            if selected:
+                out.append(("class:sel", line1.ljust(w) + "\n"))
+            else:
+                out.append(("class:row", line1 + "\n"))
+            one = t.get("one_line", "")
+            cap = max(20, w - 8)
+            if len(one) > cap:
+                one = one[:cap - 1] + "…"
+            out.append(("class:seldim" if selected else "class:dim",
+                        f"      {one}\n"))
+        return out
+
+    def _detail_text():
+        t = _current()
+        if t is None:
+            return [("", "")]
+        out: list[tuple[str, str]] = []
+        out.append(("class:title", f"\n  {t.get('full_name', t['slug'])}\n"))
+        out.append(("class:dim", f"  {t['slug']}\n\n"))
+        meta = []
+        if t.get("agent_count"):
+            meta.append(f"{t['agent_count']} agents")
+        if t.get("cron_count") not in (None, "", "0", 0):
+            meta.append(f"{t['cron_count']} cron")
+        if t.get("complexity"):
+            meta.append(f"complexity: {t['complexity']}")
+        if meta:
+            out.append(("class:meta", "  " + "  ·  ".join(meta) + "\n\n"))
+        desc = " ".join((t.get("description", "") or "").split())
+        for line in textwrap.wrap(desc, width=72) or [""]:
+            out.append(("class:row", f"  {line}\n"))
+        if t.get("trust_lead"):
+            trust = " ".join(t["trust_lead"].split())
+            wrapped = textwrap.wrap(trust, width=62) or [""]
+            out.append(("class:dim", "\n  Gates: " + wrapped[0]))
+            for line in wrapped[1:]:
+                out.append(("class:dim", f"\n         {line}"))
+            out.append(("", "\n"))
+        return out
+
+    def body_text():
+        return _detail_text() if state["mode"] == "detail" else _list_text()
+
+    def body_cursor():
+        # Put the (invisible) cursor on the selected row so the Window
+        # auto-scrolls to keep the selection visible in long lists.
+        if state["mode"] == "list":
+            return Point(x=0, y=state["sel"] * 2)
+        return Point(x=0, y=0)
+
+    # ── Footer ───────────────────────────────────────────────────────
+    def footer_text():
+        if state["mode"] == "detail":
+            return [("class:foot", "  Enter "), ("class:dim", "scaffold    "),
+                    ("class:foot", "Esc "), ("class:dim", "back")]
+        return [("class:dim", "  Type to search · "),
+                ("class:foot", "←/→ "), ("class:dim", "tabs · "),
+                ("class:foot", "↑/↓ "), ("class:dim", "move · "),
+                ("class:foot", "Enter "), ("class:dim", "view · "),
+                ("class:foot", "Esc "), ("class:dim", "quit")]
+
+    # ── Bordered search box ──────────────────────────────────────────
+    search_win = Window(BufferControl(buffer=search), height=1)
+    search_box = Frame(
+        VSplit([
+            Window(FormattedTextControl(lambda: [("class:prompt", "⌕ ")]),
+                   width=2, height=1),
+            search_win,
+        ]),
+        title=f"search {total} teams (across all tabs)",
+    )
+
+    body = Window(
+        content=FormattedTextControl(body_text, get_cursor_position=body_cursor),
+        wrap_lines=False,
+    )
+
+    root = HSplit([
+        search_box,
+        Window(FormattedTextControl(tabbar_text), height=Dimension(min=1, max=2),
+               wrap_lines=True),
+        Window(height=1, char="─", style="class:rule"),
+        body,
+        Window(FormattedTextControl(footer_text), height=1),
+    ])
+
+    # ── Key bindings ─────────────────────────────────────────────────
+    kb = KeyBindings()
+
+    @kb.add("up", filter=is_list, eager=True)
+    @kb.add("c-p", filter=is_list, eager=True)
+    def _up(event):
+        if state["filtered"]:
+            state["sel"] = (state["sel"] - 1) % len(state["filtered"])
+
+    @kb.add("down", filter=is_list, eager=True)
+    @kb.add("c-n", filter=is_list, eager=True)
+    def _down(event):
+        if state["filtered"]:
+            state["sel"] = (state["sel"] + 1) % len(state["filtered"])
+
+    @kb.add("right", filter=is_list, eager=True)
+    @kb.add("s-tab", filter=is_list, eager=True)
+    def _tab_next(event):
+        _set_tab(state["tab"] + 1)
+
+    @kb.add("left", filter=is_list, eager=True)
+    def _tab_prev(event):
+        _set_tab(state["tab"] - 1)
+
+    @kb.add("enter", filter=is_list, eager=True)
+    def _enter_list(event):
+        if _current() is not None:
+            state["mode"] = "detail"
+
+    @kb.add("enter", filter=is_detail, eager=True)
+    def _enter_detail(event):
+        t = _current()
+        if t is not None:
+            state["result"] = t["slug"]
+            event.app.exit()
+
+    @kb.add("escape", filter=is_detail, eager=True)
+    def _esc_detail(event):
+        state["mode"] = "list"
+
+    @kb.add("escape", filter=is_list, eager=True)
+    def _esc_list(event):
+        state["result"] = None
+        event.app.exit()
+
+    # In detail mode, swallow other keys so typing doesn't edit the query.
+    @kb.add("<any>", filter=is_detail, eager=True)
+    def _swallow(event):
+        pass
+
+    @kb.add("c-c")
+    @kb.add("c-q")
+    def _cancel(event):
+        state["result"] = None
+        event.app.exit()
+
+    style = Style([
+        ("frame.border", "fg:#3a3a3a"),
+        ("frame.label",  "fg:#6c6c6c"),
+        ("prompt",       "fg:#00d7ff bold"),
+        ("rule",         "fg:#3a3a3a"),
+        ("title",        "bold"),
+        ("dim",          "fg:#6c6c6c"),
+        ("hint",         "fg:#5fafff"),
+        ("row",          ""),
+        ("tab",          "fg:#9e9e9e"),
+        ("tab-active",   "bg:#00d7ff fg:#000000 bold"),
+        ("sel",          "bg:#00d7ff fg:#000000 bold"),
+        ("seldim",       "fg:#5fafff"),
+        ("meta",         "fg:#5fafff"),
+        ("foot",         "fg:#5fff5f bold"),
+    ])
+
+    app_kwargs = {}
+    if _input is not None:
+        app_kwargs["input"] = _input
+    if _output is not None:
+        app_kwargs["output"] = _output
+
+    app = Application(
+        layout=Layout(root, focused_element=search_win),
+        key_bindings=kb,
+        style=style,
+        full_screen=True,
+        mouse_support=False,
+        **app_kwargs,
+    )
+    _recompute()
+    app.run()
+    return state["result"]

{create_leafmesh-2.6.3 → create_leafmesh-2.6.4}/create_leafmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-leafmesh
-Version: 2.6.3
+Version: 2.6.4
 Summary: Project scaffolding + cloud-deploy tool for LeafMesh
 License-Expression: MIT
 Requires-Python: >=3.10

{create_leafmesh-2.6.3 → create_leafmesh-2.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "create-leafmesh"
-version = "2.6.3"
+version = "2.6.4"
 description = "Project scaffolding + cloud-deploy tool for LeafMesh"
 readme = "README.md"
 requires-python = ">=3.10"

{create_leafmesh-2.6.3 → create_leafmesh-2.6.4}/tests/test_discover.py

@@ -64,3 +64,33 @@ def test_ctrl_c_cancels():
 
 def test_no_match_then_cancel():
     assert _run("zzzznope\x03") is None
+
+
+# ── Tabs (business functions) + global search ──
+
+_RIGHT = "\x1b[C"
+_LEFT = "\x1b[D"
+
+
+def test_right_switches_to_start_here_tab():
+    # tabs = [All, Start here, ...]; one Right -> 'Start here' -> only starter
+    assert _run(_RIGHT + "\r\r") == "starter"
+
+
+def test_search_overrides_active_tab():
+    # On the 'Start here' tab, typing still searches ALL tabs (global).
+    assert _run(_RIGHT + "proc\r\r") == "procurement-ops"
+
+
+def test_left_wraps_to_last_tab():
+    # From 'All', Left wraps to the last category (Production & supply),
+    # whose first template is production-planning.
+    assert _run(_LEFT + "\r\r") == "production-planning"
+
+
+def test_tabs_include_all_plus_categories():
+    from create_leafmesh.create import list_templates as _lt
+    from create_leafmesh.discover import _ordered_categories
+    cats = _ordered_categories(_lt(include_planned=False))
+    assert cats[0] == "Start here"
+    assert "Production & supply" in cats

create_leafmesh-2.6.3/create_leafmesh/discover.py

@@ -1,269 +0,0 @@
-"""Full-screen, live type-to-search template browser (the "Discover" UI).
-
-Modelled on Claude Code's `/plugin` Discover screen: a search box at the top
-that filters as you type, a scrollable list of templates below (name ·
-category, with a one-line summary), and a footer of key hints. Pressing Enter
-on a row opens a detail screen with a confirm-to-scaffold step.
-
-Built on prompt_toolkit, which ships as a dependency of `questionary` — so
-this adds no new requirement. Falls back (in cli.py) to the numbered-list
-picker when there's no TTY or prompt_toolkit is unavailable.
-
-Public entry point: `discover_templates(templates) -> str | None`
-    returns the chosen template slug, or None if the user cancelled.
-"""
-
-from __future__ import annotations
-
-import textwrap
-from typing import Any
-
-from create_leafmesh.search import browser_filter
-
-
-def discover_templates(
-    templates: list[dict[str, Any]],
-    *,
-    _input=None,
-    _output=None,
-) -> str | None:
-    """Run the full-screen Discover browser. Returns a slug or None.
-
-    Raises ImportError if prompt_toolkit isn't importable, so the caller can
-    fall back to the numbered picker.
-
-    `_input` / `_output` are test seams: pass a prompt_toolkit pipe input and
-    a DummyOutput to drive the browser headlessly.
-    """
-    from prompt_toolkit.application import Application
-    from prompt_toolkit.buffer import Buffer
-    from prompt_toolkit.filters import Condition
-    from prompt_toolkit.key_binding import KeyBindings
-    from prompt_toolkit.layout import Layout
-    from prompt_toolkit.layout.containers import HSplit, VSplit, Window
-    from prompt_toolkit.layout.controls import (
-        BufferControl,
-        FormattedTextControl,
-    )
-    from prompt_toolkit.layout.dimension import Dimension
-    from prompt_toolkit.styles import Style
-
-    total = len(templates)
-
-    # ── Mutable UI state ─────────────────────────────────────────────
-    state = {
-        "filtered": list(templates),  # current visible templates
-        "sel": 0,                     # selected index into filtered
-        "offset": 0,                  # scroll offset (top visible item)
-        "mode": "list",               # "list" | "detail"
-        "result": None,               # chosen slug on exit
-    }
-
-    search = Buffer(multiline=False)
-
-    def _refilter(_buf=None) -> None:
-        state["filtered"] = browser_filter(templates, search.text)
-        state["sel"] = 0
-        state["offset"] = 0
-
-    search.on_text_changed += _refilter
-
-    is_list = Condition(lambda: state["mode"] == "list")
-    is_detail = Condition(lambda: state["mode"] == "detail")
-
-    def _current() -> dict[str, Any] | None:
-        f = state["filtered"]
-        if not f:
-            return None
-        return f[min(state["sel"], len(f) - 1)]
-
-    def _visible_rows() -> int:
-        """How many templates fit, given the terminal height (2 lines each)."""
-        from prompt_toolkit.application import get_app
-        try:
-            h = get_app().output.get_size().rows
-        except Exception:
-            h = 24
-        # header + spacer + search + spacer + footer ≈ 6 chrome lines
-        return max(3, (h - 6) // 2)
-
-    # ── Header ───────────────────────────────────────────────────────
-    def header_text():
-        n = len(state["filtered"])
-        count = f"{n}/{total}" if n != total else f"{total}"
-        return [("class:title", f"  Discover templates "),
-                ("class:dim", f"({count})")]
-
-    # ── List / detail body ───────────────────────────────────────────
-    def body_text():
-        if state["mode"] == "detail":
-            return _detail_text()
-        return _list_text()
-
-    def _list_text():
-        f = state["filtered"]
-        if not f:
-            return [("class:dim", "\n  No templates match — try fewer letters.\n")]
-
-        vis = _visible_rows()
-        sel = min(state["sel"], len(f) - 1)
-        off = state["offset"]
-        if sel < off:
-            off = sel
-        elif sel >= off + vis:
-            off = sel - vis + 1
-        state["offset"] = off
-
-        out: list[tuple[str, str]] = []
-        window = f[off:off + vis]
-        slug_w = max((len(t["slug"]) for t in window), default=16) + 2
-        for i, t in enumerate(window, start=off):
-            selected = (i == sel)
-            ptr = "❯ " if selected else "  "
-            row_style = "class:sel" if selected else "class:row"
-            slug = t["slug"].ljust(slug_w)
-            cat = t.get("category", "")
-            out.append((row_style, f"  {ptr}{slug}"))
-            out.append(("class:sel-cat" if selected else "class:cat", f"{cat}\n"))
-            one = t.get("one_line", "")
-            if len(one) > 70:
-                one = one[:67] + "…"
-            out.append(("class:dim", f"      {one}\n"))
-        if off + vis < len(f):
-            out.append(("class:dim", "  ↓ more below\n"))
-        return out
-
-    def _detail_text():
-        t = _current()
-        if t is None:
-            return [("", "")]
-        out: list[tuple[str, str]] = []
-        out.append(("class:title", f"\n  {t.get('full_name', t['slug'])}\n"))
-        out.append(("class:dim", f"  {t['slug']}\n\n"))
-        meta = []
-        if t.get("agent_count"):
-            meta.append(f"{t['agent_count']} agents")
-        if t.get("cron_count") not in (None, "", "0", 0):
-            meta.append(f"{t['cron_count']} cron")
-        if t.get("complexity"):
-            meta.append(f"complexity: {t['complexity']}")
-        if meta:
-            out.append(("class:meta", "  " + "  ·  ".join(meta) + "\n\n"))
-        desc = " ".join((t.get("description", "") or "").split())
-        for line in textwrap.wrap(desc, width=72) or [""]:
-            out.append(("class:row", f"  {line}\n"))
-        if t.get("trust_lead"):
-            out.append(("class:dim", "\n  Gates: "))
-            trust = " ".join(t["trust_lead"].split())
-            wrapped = textwrap.wrap(trust, width=64) or [""]
-            out.append(("class:dim", wrapped[0]))
-            for line in wrapped[1:]:
-                out.append(("class:dim", f"\n         {line}"))
-            out.append(("", "\n"))
-        return out
-
-    # ── Footer ───────────────────────────────────────────────────────
-    def footer_text():
-        if state["mode"] == "detail":
-            return [("class:foot", "  Enter "), ("class:dim", "scaffold   "),
-                    ("class:foot", "Esc "), ("class:dim", "back")]
-        return [("class:dim", "  Type to search · "),
-                ("class:foot", "↑/↓ "), ("class:dim", "move · "),
-                ("class:foot", "Enter "), ("class:dim", "view · "),
-                ("class:foot", "Esc "), ("class:dim", "cancel")]
-
-    # ── Search box (label + live buffer), shown only in list mode ─────
-    search_line = VSplit([
-        Window(FormattedTextControl(lambda: [("class:prompt", "  ⌕ ")]),
-               width=5, height=1),
-        Window(BufferControl(buffer=search), height=1),
-    ])
-
-    body = Window(content=FormattedTextControl(body_text), wrap_lines=True,
-                  height=Dimension(min=3))
-
-    root = HSplit([
-        Window(FormattedTextControl(header_text), height=1),
-        Window(height=1, char=" "),   # spacer
-        search_line,
-        Window(height=1, char=" "),   # spacer
-        body,
-        Window(FormattedTextControl(footer_text), height=1),
-    ])
-
-    # ── Key bindings ─────────────────────────────────────────────────
-    kb = KeyBindings()
-
-    @kb.add("up", filter=is_list, eager=True)
-    @kb.add("c-p", filter=is_list, eager=True)
-    def _up(event):
-        if state["filtered"]:
-            state["sel"] = (state["sel"] - 1) % len(state["filtered"])
-
-    @kb.add("down", filter=is_list, eager=True)
-    @kb.add("c-n", filter=is_list, eager=True)
-    def _down(event):
-        if state["filtered"]:
-            state["sel"] = (state["sel"] + 1) % len(state["filtered"])
-
-    @kb.add("enter", filter=is_list, eager=True)
-    def _enter_list(event):
-        if _current() is not None:
-            state["mode"] = "detail"
-
-    @kb.add("enter", filter=is_detail, eager=True)
-    def _enter_detail(event):
-        t = _current()
-        if t is not None:
-            state["result"] = t["slug"]
-            event.app.exit()
-
-    @kb.add("escape", filter=is_detail, eager=True)
-    def _esc_detail(event):
-        state["mode"] = "list"
-
-    @kb.add("escape", filter=is_list, eager=True)
-    def _esc_list(event):
-        state["result"] = None
-        event.app.exit()
-
-    # In detail mode, swallow any other key so typing doesn't edit the query.
-    @kb.add("<any>", filter=is_detail, eager=True)
-    def _swallow(event):
-        pass
-
-    @kb.add("c-c")
-    @kb.add("c-q")
-    def _cancel(event):
-        state["result"] = None
-        event.app.exit()
-
-    style = Style([
-        ("title",   "bold"),
-        ("dim",     "fg:#6c6c6c"),
-        ("prompt",  "fg:#00d7ff bold"),
-        ("row",     ""),
-        ("cat",     "fg:#6c6c6c"),
-        ("sel",     "fg:#00d7ff bold"),
-        ("sel-cat", "fg:#00d7ff"),
-        ("meta",    "fg:#5fafff"),
-        ("foot",    "fg:#5fff5f bold"),
-    ])
-
-    app_kwargs = {}
-    if _input is not None:
-        app_kwargs["input"] = _input
-    if _output is not None:
-        app_kwargs["output"] = _output
-
-    app = Application(
-        layout=Layout(root, focused_element=search_line),
-        key_bindings=kb,
-        style=style,
-        full_screen=True,
-        mouse_support=False,
-        **app_kwargs,
-    )
-    _refilter()
-    app.run()
-    return state["result"]