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

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

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

{create_leafmesh-2.6.2 → 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.2"
+__version__ = "2.6.4"

{create_leafmesh-2.6.2 → create_leafmesh-2.6.4}/create_leafmesh/cli.py

@@ -196,150 +196,6 @@ def _grouped_templates() -> list[tuple[str, list[dict]]]:
     return display
 
 
-def _interactive_search(questionary, style) -> str | None:
-    """State 1 → state 2 bridge inside the TUI picker.
-
-    Prompt for keywords, run the fuzzy search, and — if anything matches —
-    auto-switch to a template-level selection (state 2). Returns a chosen
-    slug, or None to return to the category view (state 1).
-    """
-    ready = list_templates(include_planned=False)
-    query = questionary.text(
-        "Search templates (keywords — spelling needn't be exact):",
-        style=style,
-    ).ask()
-    if not query or not query.strip():
-        return None
-    query = query.strip()
-
-    matches = search_templates(ready, query)
-    if not matches:
-        print(f"\n  No templates matched '{query}'. "
-              f"Try a broader term (e.g. 'sales', 'finance', 'support').\n")
-        return None
-
-    # Auto-switch to state 2 — show the matching templates directly.
-    name_w = max((len(t.get("short_name", t["slug"])) for t, _ in matches),
-                 default=12) + 2
-    tpl_choices = []
-    for t, _score in matches:
-        short = t.get("short_name", t["slug"])
-        one = t.get("one_line", "")
-        tpl_choices.append(questionary.Choice(
-            title=f"{short.ljust(name_w)} — {one}", value=t["slug"]))
-    tpl_choices.append(questionary.Separator())
-    tpl_choices.append(questionary.Choice(title="← Back / new search",
-                                          value="__back__"))
-
-    chosen = questionary.select(
-        f"Matches for '{query}':",
-        choices=tpl_choices,
-        style=style,
-        instruction="(↑/↓ to move, Enter to select)",
-        use_indicator=True,
-    ).ask()
-
-    if chosen is None or chosen == "__back__":
-        return None
-    return chosen
-
-
-def _prompt_template_choice_interactive() -> str:
-    """Arrow-key TUI picker — cascading category → template selection.
-
-    Uses `questionary` for arrow-key navigation. Two stages:
-      1. Pick a business category
-      2. Pick a template within that category (with 'Back' option)
-
-    Loops until a template is chosen or user cancels.
-    """
-    import questionary
-    from questionary import Style
-
-    style = Style([
-        ("qmark",       "fg:#00d7ff bold"),
-        ("question",    "bold"),
-        ("answer",      "fg:#5fff5f bold"),
-        ("pointer",     "fg:#00d7ff bold"),
-        ("highlighted", "fg:#00d7ff bold"),
-        ("selected",    "fg:#5fff5f"),
-        ("separator",   "fg:#6c6c6c"),
-        ("instruction", "fg:#6c6c6c"),
-    ])
-
-    display = _grouped_templates()
-    if not display:
-        print("  No templates available. Reinstall create-leafmesh.")
-        sys.exit(2)
-
-    cat_to_items = dict(display)
-
-    while True:
-        # ── Step 1: pick a category ──────────────────────────────────
-        cat_choices = []
-        for cat, items in display:
-            n = len(items)
-            label = f"{cat}  ({n} template{'s' if n != 1 else ''})"
-            cat_choices.append(questionary.Choice(title=label, value=cat))
-        cat_choices.append(questionary.Separator())
-        cat_choices.append(questionary.Choice(title="Search by keyword…",
-                                              value="__search__"))
-        # NOTE: `value=None` causes questionary to fall back to the title
-        # string (treats None as "unset"), which then crashes our
-        # cat_to_items lookup with KeyError: 'Quit'. Use an explicit
-        # sentinel string instead.
-        cat_choices.append(questionary.Choice(title="Quit", value="__quit__"))
-
-        chosen_cat = questionary.select(
-            "Choose a business area:",
-            choices=cat_choices,
-            style=style,
-            instruction="(↑/↓ to move, Enter to select)",
-            use_indicator=True,
-        ).ask()
-
-        if chosen_cat is None or chosen_cat == "__quit__":
-            print("\n  Cancelled.\n")
-            sys.exit(0)
-
-        if chosen_cat == "__search__":
-            slug = _interactive_search(questionary, style)
-            if slug:
-                return slug
-            continue  # no match / backed out → back to the category view
-
-        # ── Step 2: pick a template in that category ─────────────────
-        items = cat_to_items[chosen_cat]
-        # Pad short_names so the one-liner column aligns nicely.
-        name_w = max((len(t.get("short_name", t["slug"])) for t in items), default=12) + 2
-
-        tpl_choices = []
-        for t in items:
-            short = t.get("short_name", t["slug"])
-            one = t.get("one_line", "")
-            label = f"{short.ljust(name_w)} — {one}"
-            tpl_choices.append(questionary.Choice(title=label, value=t["slug"]))
-        tpl_choices.append(questionary.Separator())
-        tpl_choices.append(questionary.Choice(title="← Back to categories",
-                                              value="__back__"))
-        tpl_choices.append(questionary.Choice(title="Quit", value="__quit__"))
-
-        chosen = questionary.select(
-            f"Template in {chosen_cat}:",
-            choices=tpl_choices,
-            style=style,
-            instruction="(↑/↓ to move, Enter to select)",
-            use_indicator=True,
-        ).ask()
-
-        if chosen is None or chosen == "__quit__":
-            print("\n  Cancelled.\n")
-            sys.exit(0)
-        if chosen == "__back__":
-            continue
-        return chosen
-
-
 def _prompt_template_choice_fallback() -> str:
     """Numbered-list fallback for non-TTY terminals (CI, piped input)."""
     display = _grouped_templates()
@@ -423,18 +279,25 @@ def _prompt_template_choice_fallback() -> str:
 def prompt_template_choice() -> str:
     """Pick the right picker for the environment.
 
-    On a real terminal: arrow-key cascading TUI (category → template).
-    On CI / piped input / dumb terminals: numbered-list fallback.
+    On a real terminal: the full-screen Discover browser (live type-to-search,
+    ↑/↓ to move, Enter for a detail/confirm screen).
+    On CI / piped input / dumb terminals (or if prompt_toolkit is missing):
+    the numbered-list fallback (which has its own `/keywords` search).
     """
     is_tty = sys.stdin.isatty() and sys.stdout.isatty()
     if is_tty:
         try:
-            return _prompt_template_choice_interactive()
+            from create_leafmesh.discover import discover_templates
+            slug = discover_templates(list_templates(include_planned=False))
+            if slug is None:
+                print("\n  Cancelled.\n")
+                sys.exit(0)
+            return slug
         except KeyboardInterrupt:
             print("\n\n  Cancelled.\n")
             sys.exit(0)
         except ImportError:
-            # questionary missing → fall through to text picker
+            # prompt_toolkit unavailable → fall through to text picker
             pass
     return _prompt_template_choice_fallback()
 

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.2 → create_leafmesh-2.6.4}/create_leafmesh/search.py

@@ -139,6 +139,55 @@ def score_template(t: dict[str, Any], query: str) -> float:
     return score
 
 
+def browser_filter(
+    templates: list[dict[str, Any]],
+    query: str,
+) -> list[dict[str, Any]]:
+    """Lenient, responsive filter for the live Discover browser.
+
+    Unlike `search_templates` (which thresholds for "best answer" intent),
+    this is for incremental typing: an empty query returns everything in the
+    given display order, and a partial query surfaces anything whose text
+    contains the typed tokens as substrings — so "proc" immediately reveals
+    procurement-ops — ranked by relevance (fuzzy still helps with typos).
+    """
+    q = (query or "").strip().lower()
+    if not q:
+        return list(templates)
+
+    q_tokens = _tokens(q)
+    q_compact = q.replace(" ", "")
+    ranked: list[tuple[dict[str, Any], int, float, str]] = []
+    for t in templates:
+        primary_text, secondary_text, _ = _corpus(t)
+        hay = primary_text + " " + secondary_text
+        # Substring inclusion: every typed token appears somewhere.
+        substr = all(tok in hay for tok in q_tokens) if q_tokens else False
+        s = score_template(t, q)
+        if not (substr or s > 0):
+            continue
+        # Tier the result so live typing feels right. A name prefix (the query
+        # starts the slug or a name word) is the strongest signal, then a
+        # keyword/synonym prefix, then a mid-word substring, then a fuzzy-only
+        # (typo) hit. Within a tier, higher relevance score first.
+        slug = t.get("slug", "")
+        name_text = f"{slug} {t.get('short_name', '')} {t.get('full_name', '')}"
+        name_prefix = (slug.startswith(q_compact)
+                       or any(tok.startswith(q) for tok in _tokens(name_text)))
+        kw_prefix = any(tok.startswith(q) for tok in _tokens(primary_text))
+        if name_prefix:
+            tier = 0
+        elif kw_prefix:
+            tier = 1
+        elif substr:
+            tier = 2
+        else:
+            tier = 3
+        ranked.append((t, tier, s, slug))
+    ranked.sort(key=lambda r: (r[1], -r[2], r[3]))
+    return [t for t, _tier, _s, _slug in ranked]
+
+
 def search_templates(
     templates: list[dict[str, Any]],
     query: str,

{create_leafmesh-2.6.2 → 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.2
+Version: 2.6.4
 Summary: Project scaffolding + cloud-deploy tool for LeafMesh
 License-Expression: MIT
 Requires-Python: >=3.10

{create_leafmesh-2.6.2 → create_leafmesh-2.6.4}/create_leafmesh.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ create_leafmesh/__init__.py
 create_leafmesh/cli.py
 create_leafmesh/create.py
 create_leafmesh/deploy.py
+create_leafmesh/discover.py
 create_leafmesh/search.py
 create_leafmesh.egg-info/PKG-INFO
 create_leafmesh.egg-info/SOURCES.txt
@@ -707,4 +708,5 @@ create_leafmesh/templates/warehouse-supply-chain/tests/__init__.py
 create_leafmesh/templates/warehouse-supply-chain/tests/conftest.py
 create_leafmesh/templates/warehouse-supply-chain/tests/test_agent_logic.py
 create_leafmesh/templates/warehouse-supply-chain/tests/test_config_shape.py
+tests/test_discover.py
 tests/test_search.py

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

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