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

create_leafmesh-2.6.3/MANIFEST.in

@@ -0,0 +1,11 @@
+# Source-distribution hygiene. The wheel is governed by
+# [tool.setuptools.exclude-package-data] in pyproject.toml; this file does the
+# same for the sdist so runtime cruft (stray logs, scratch data/out dirs,
+# bytecode caches) can never be shipped, regardless of working-tree state.
+global-exclude *.log
+global-exclude *.pyc
+prune create_leafmesh/templates/**/logs
+prune create_leafmesh/templates/**/data
+prune create_leafmesh/templates/**/out
+prune create_leafmesh/templates/**/__pycache__
+prune create_leafmesh/templates/**/.pytest_cache

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

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

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

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

{create_leafmesh-2.6.1 → create_leafmesh-2.6.3}/create_leafmesh/cli.py

@@ -12,6 +12,7 @@ from create_leafmesh.create import (
     get_template_prompts,
     list_templates,
 )
+from create_leafmesh.search import search_templates
 
 # ---------------------------------------------------------------------------
 # ANSI helpers (graceful fallback on terminals that don't support color)
@@ -155,7 +156,8 @@ def print_template_list(include_planned: bool = True) -> None:
             print(f"  {_c(_DIM, slug):<35s} {_c(_DIM, short)}")
         print()
 
-    print(_c(_DIM, "  Use: create-leafmesh <project_name> --template <slug>"))
+    print(_c(_DIM, "  Use:    create-leafmesh <project_name> --template <slug>"))
+    print(_c(_DIM, "  Search: create-leafmesh --search \"<keywords>\""))
     print()
 
 
@@ -194,94 +196,6 @@ def _grouped_templates() -> list[tuple[str, list[dict]]]:
     return display
 
 
-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())
-        # 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)
-
-        # ── 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()
@@ -319,40 +233,71 @@ def _prompt_template_choice_fallback() -> str:
             )
             n += 1
     print()
-    print(_c(_DIM, f"  Type 1–{len(ready)}, a slug, or 'q' to quit."))
+    print(_c(_DIM, f"  Type 1–{len(ready)}, a slug, '/keywords' to search, "
+                   f"or 'q' to quit."))
     while True:
         try:
-            raw = input("  > ").strip().lower()
+            raw = input("  > ").strip()
         except EOFError:
             print()
             sys.exit(0)
         if not raw:
             continue
-        if raw in ("q", "quit", "exit"):
+        low = raw.lower()
+        if low in ("q", "quit", "exit"):
             print("\n  Cancelled.\n")
             sys.exit(0)
-        if raw in valid_indexes:
-            return valid_indexes[raw]
-        if raw in valid_slugs:
-            return raw
-        print(f"  Invalid choice. Type 1–{len(ready)}, a slug, or 'q'.")
+        # Search: '/keywords' or 's keywords'  → auto-switch to matches (state 2)
+        if raw.startswith("/") or low.startswith("s ") or low.startswith("search "):
+            query = (raw[1:] if raw.startswith("/")
+                     else raw.split(None, 1)[1] if " " in raw else "")
+            query = query.strip()
+            if not query:
+                print("  Type '/' followed by keywords, e.g. '/cold email'.")
+                continue
+            matches = search_templates(ready, query)
+            if not matches:
+                print(f"  No matches for '{query}'. Try a broader term.")
+                continue
+            print()
+            print(f"  Matches for '{query}':")
+            for t, _score in matches:
+                short = t.get("short_name", t["slug"])
+                print(f"    {_c(_BOLD, short.ljust(name_w))}"
+                      f"{_c(_DIM, t.get('one_line', ''))}")
+                print(f"      {_c(_DIM, 'slug: ' + t['slug'])}")
+            print(_c(_DIM, "  → type the slug above to use one."))
+            continue
+        if low in valid_indexes:
+            return valid_indexes[low]
+        if low in valid_slugs:
+            return low
+        print(f"  Invalid choice. Type 1–{len(ready)}, a slug, "
+              f"'/keywords' to search, or 'q'.")
 
 
 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()
 
@@ -499,6 +444,56 @@ def _print_template_describe(slug: str) -> int:
     return 0
 
 
+def _run_search(query: str) -> int:
+    """`--search` — fuzzy keyword search that lands straight on templates.
+
+    This is the non-interactive expression of the two-state model: rather than
+    show business areas (state 1), a search jumps directly to the matching
+    template(s) (state 2), ready to scaffold.
+    """
+    query = (query or "").strip()
+    if not query:
+        print("\n  Provide search keywords, e.g. "
+              "create-leafmesh --search 'cold email'\n")
+        return 2
+
+    # Search ready templates first; only widen to planned ones if nothing hits.
+    ready = list_templates(include_planned=False)
+    matches = search_templates(ready, query)
+    if not matches:
+        matches = search_templates(list_templates(include_planned=True), query)
+
+    if not matches:
+        print(f"\n  No templates matched {_c(_BOLD, query)}.")
+        print(f"  Run {_c(_BOLD, 'create-leafmesh --list')} to browse all "
+              f"templates,")
+        print(f"  or try a broader term (e.g. 'sales', 'finance', 'support').\n")
+        return 1
+
+    print()
+    print(_c(_BOLD, f"  Search results for '{query}':"))
+    print()
+    name_w = max((len(t.get("short_name", t["slug"])) for t, _ in matches),
+                 default=12) + 2
+    for t, _score in matches:
+        short = t.get("short_name", t["slug"])
+        one = t.get("one_line", "")
+        status = t.get("status", "ready")
+        tag = "" if status == "ready" else _c(_DIM, f"  ({status})")
+        print(f"  {_c(_BOLD, short.ljust(name_w))}{_c(_DIM, '· ' + t['slug'])}{tag}")
+        if one:
+            print(f"  {_c(_DIM, '  ' + one)}")
+        print()
+
+    top = matches[0][0]
+    print(_c(_DIM, "  Scaffold the top match:"))
+    print(f"    create-leafmesh <project_name> --template "
+          f"{_c(_BOLD, top['slug'])}")
+    print(_c(_DIM, f"  Details:  create-leafmesh --describe {top['slug']}"))
+    print()
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="create-leafmesh",
@@ -508,6 +503,7 @@ examples:
   create-leafmesh my-project --template incident-triage    Create with explicit template
   create-leafmesh my-project                               Interactive picker
   create-leafmesh --list                                   Show available templates
+  create-leafmesh --search "cold email"                    Find a template by keyword
   create-leafmesh --describe payment-authorization         Show template details
         """,
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -525,6 +521,11 @@ examples:
         "--list", dest="list_templates", action="store_true",
         help="List available templates and exit",
     )
+    parser.add_argument(
+        "--search", default=None, metavar="QUERY",
+        help="Search templates by keyword (fuzzy; spelling needn't be exact) "
+             "and show matches",
+    )
     parser.add_argument(
         "--describe", default=None, metavar="SLUG",
         help="Show details for one template and exit",
@@ -536,6 +537,8 @@ examples:
     if args.list_templates:
         print_template_list()
         return 0
+    if args.search:
+        return _run_search(args.search)
     if args.describe:
         return _print_template_describe(args.describe)
 

create_leafmesh-2.6.3/create_leafmesh/discover.py

@@ -0,0 +1,269 @@
+"""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"]