create-leafmesh 2.1.1__tar.gz → 2.2.3__tar.gz

{create_leafmesh-2.1.1 → create_leafmesh-2.2.3}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: create-leafmesh
-Version: 2.1.1
+Version: 2.2.3
 Summary: Project scaffolding tool for LeafMesh
 License-Expression: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: questionary<3,>=2.0
 
 # create-leafmesh
 

{create_leafmesh-2.1.1 → create_leafmesh-2.2.3}/create_leafmesh/__init__.py

@@ -1,3 +1,3 @@
 """create-leafmesh — Project scaffolding tool for LeafMesh."""
 
-__version__ = "2.1.1"
+__version__ = "2.2.3"

create_leafmesh-2.2.3/create_leafmesh/cli.py

@@ -0,0 +1,555 @@
+"""CLI entry point for create-leafmesh."""
+
+import argparse
+import re
+import sys
+import time
+
+from create_leafmesh import __version__
+from create_leafmesh.create import (
+    create_project,
+    get_template,
+    get_template_prompts,
+    list_templates,
+)
+
+# ---------------------------------------------------------------------------
+# ANSI helpers (graceful fallback on terminals that don't support color)
+# ---------------------------------------------------------------------------
+_CYAN   = "\033[36m"
+_GREEN  = "\033[32m"
+_WHITE  = "\033[97m"
+_DIM    = "\033[2m"
+_BOLD   = "\033[1m"
+_RESET  = "\033[0m"
+
+def _c(code: str, text: str) -> str:
+    """Wrap text in an ANSI code, reset after."""
+    return f"{code}{text}{_RESET}"
+
+
+# ---------------------------------------------------------------------------
+# ASCII art — block letters for LEAFMESH
+# ---------------------------------------------------------------------------
+BANNER = r"""
+  ██╗     ███████╗ █████╗ ███████╗███╗   ███╗███████╗███████╗██╗  ██╗
+  ██║     ██╔════╝██╔══██╗██╔════╝████╗ ████║██╔════╝██╔════╝██║  ██║
+  ██║     █████╗  ███████║█████╗  ██╔████╔██║█████╗  ███████╗███████║
+  ██║     ██╔══╝  ██╔══██║██╔══╝  ██║╚██╔╝██║██╔══╝  ╚════██║██╔══██║
+  ███████╗███████╗██║  ██║██║     ██║ ╚═╝ ██║███████╗███████║██║  ██║
+  ╚══════╝╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝     ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝
+"""
+
+def print_banner(version: str) -> None:
+    print()
+    print(_c(_CYAN, BANNER), end="")
+    pad = " " * 2
+    print(f"{pad}  create-leafmesh {_c(_DIM, 'v' + version)}   "
+          f"{_c(_DIM, 'Agent mesh scaffolding tool')}")
+    print(f"{pad}  " + "-" * 55)
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Step progress printer
+# ---------------------------------------------------------------------------
+def step(n: int, total: int, label: str, done: bool = False) -> None:
+    status = _c(_GREEN, "[ OK ]") if done else _c(_DIM, "[    ]")
+    print(f"  {status}  [{n}/{total}]  {label}")
+
+
+def step_done(n: int, total: int, label: str) -> None:
+    print(f"\033[1A\r  {_c(_GREEN, '[ OK ]')}  [{n}/{total}]  {label}")
+
+
+# ---------------------------------------------------------------------------
+# Next-steps box
+# ---------------------------------------------------------------------------
+def print_success_box(project_name: str, template_slug: str, missing_keys: list[str]) -> None:
+    w = 58
+
+    def row(text: str = "") -> str:
+        return f"  |  {text:<{w - 4}}|"
+
+    def div() -> str:
+        return "  +" + "-" * (w - 2) + "+"
+
+    def header(text: str) -> str:
+        return "  |  " + _c(_GREEN, _c(_BOLD, f"{text:<{w - 4}}")) + "|"
+
+    print()
+    print(div())
+    print(header(f"Project ready: {project_name}"))
+    print(div())
+    print(row())
+    print(row(f"  template:  {template_slug}"))
+    print(row())
+    print(row(f"  cd {project_name}"))
+    print(row(f"  pip install -r requirements.txt"))
+    if missing_keys:
+        print(row())
+        print(row(f"  # Add to .env before starting:"))
+        for k in missing_keys:
+            print(row(f"  #   {k}=<your-key>"))
+    print(row())
+    print(row(f"  See README.md for the run instructions"))
+    print(row(f"  specific to this template."))
+    print(row())
+    print(div())
+    print(row(f"  Docs:      https://leafcraft.ai/docs"))
+    print(div())
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Validation / prompts
+# ---------------------------------------------------------------------------
+def validate_project_name(name: str) -> str:
+    if not re.match(r"^[a-zA-Z][a-zA-Z0-9_-]*$", name):
+        raise argparse.ArgumentTypeError(
+            f"Invalid project name '{name}'. "
+            "Must start with a letter and contain only alphanumeric characters, "
+            "hyphens, or underscores."
+        )
+    return name
+
+
+def prompt_project_name() -> str:
+    while True:
+        name = input("  Project name: ").strip()
+        if not name:
+            print("  Name cannot be empty.")
+            continue
+        if not re.match(r"^[a-zA-Z][a-zA-Z0-9_-]*$", name):
+            print("  Must start with a letter, letters/numbers/hyphens/underscores only.")
+            continue
+        return name
+
+
+# ---------------------------------------------------------------------------
+# Template selection
+# ---------------------------------------------------------------------------
+def print_template_list(include_planned: bool = True) -> None:
+    """Print the available templates (--list output)."""
+    ready = list_templates(include_planned=False)
+    planned = [t for t in list_templates(include_planned=True)
+               if t.get("status") != "ready"] if include_planned else []
+
+    print()
+    print(_c(_BOLD, "  Available templates:"))
+    print()
+    for t in ready:
+        slug = t["slug"]
+        short = t.get("short_name", "")
+        one_line = t.get("one_line", "")
+        print(f"  {_c(_BOLD, slug):<35s}")
+        print(f"  {_c(_DIM, '  ' + short)}")
+        print(f"  {_c(_DIM, '  ' + one_line)}")
+        print()
+
+    if planned:
+        print(_c(_DIM, "  Planned (not yet available):"))
+        for t in planned:
+            slug = t["slug"]
+            short = t.get("short_name", "")
+            print(f"  {_c(_DIM, slug):<35s} {_c(_DIM, short)}")
+        print()
+
+    print(_c(_DIM, "  Use: create-leafmesh <project_name> --template <slug>"))
+    print()
+
+
+# Display order for the grouped picker — first group at top, last at bottom.
+# Templates without a recognised `category` fall into "Other" at the end.
+_CATEGORY_ORDER = (
+    "Finance & back-office",
+    "Customer & growth",
+    "Engineering & platform",
+    "People operations",
+    "Services & delivery",
+    "Production & supply",
+)
+
+
+def _grouped_templates() -> list[tuple[str, list[dict]]]:
+    """Return [(category, [template, …]), …] in display order."""
+    ready = list_templates(include_planned=False)
+    grouped: dict[str, list[dict]] = {}
+    for t in ready:
+        cat = t.get("category") or "Other"
+        grouped.setdefault(cat, []).append(t)
+
+    display: list[tuple[str, list[dict]]] = []
+    seen: set[str] = set()
+    for cat in _CATEGORY_ORDER:
+        if cat in grouped:
+            display.append((cat, grouped[cat]))
+            seen.add(cat)
+    for cat, items in grouped.items():
+        if cat not in seen and cat != "Other":
+            display.append((cat, items))
+            seen.add(cat)
+    if "Other" in grouped:
+        display.append(("Other", grouped["Other"]))
+    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())
+        cat_choices.append(questionary.Choice(title="Quit", value=None))
+
+        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:
+            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=None))
+
+        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:
+            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()
+    ready = [t for _, items in display for t in items]
+    if not ready:
+        print("  No templates available. Reinstall create-leafmesh.")
+        sys.exit(2)
+
+    valid_slugs = {t["slug"]: t["slug"] for t in ready}
+    valid_indexes: dict[str, str] = {}
+    idx = 1
+    for _cat, items in display:
+        for t in items:
+            valid_indexes[str(idx)] = t["slug"]
+            idx += 1
+
+    sep_w = 60
+    print()
+    print("  " + "─" * sep_w)
+    print(f"  {'Choose a template':^{sep_w}}")
+    print("  " + "─" * sep_w)
+    longest = max(len(t.get("short_name", t["slug"])) for t in ready)
+    name_w = max(longest + 2, 22)
+    n = 1
+    for cat, items in display:
+        print()
+        print(f"  {_c(_BOLD, cat.upper())}")
+        for t in items:
+            short = t.get("short_name", t["slug"])
+            one = t.get("one_line", "")
+            print(
+                f"    {_c(_BOLD, str(n).rjust(2))})  "
+                f"{_c(_BOLD, short.ljust(name_w))}"
+                f"{_c(_DIM, one)}"
+            )
+            n += 1
+    print()
+    print(_c(_DIM, f"  Type 1–{len(ready)}, a slug, or 'q' to quit."))
+    while True:
+        try:
+            raw = input("  > ").strip().lower()
+        except EOFError:
+            print()
+            sys.exit(0)
+        if not raw:
+            continue
+        if raw 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'.")
+
+
+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.
+    """
+    is_tty = sys.stdin.isatty() and sys.stdout.isatty()
+    if is_tty:
+        try:
+            return _prompt_template_choice_interactive()
+        except KeyboardInterrupt:
+            print("\n\n  Cancelled.\n")
+            sys.exit(0)
+        except ImportError:
+            # questionary missing → fall through to text picker
+            pass
+    return _prompt_template_choice_fallback()
+
+
+def prompt_env_vars(prompts: list[dict]) -> dict:
+    """Ask the user for each env var the template declares.
+
+    `prompts` is the list from `get_template_prompts(slug)` — each entry has
+    `key`, `label`, `signup_url`, `required`, `note`. Empty input skips a
+    field (the BRD calls this "Never block, always document").
+    """
+    w = 55
+    print()
+    print("  " + "-" * w)
+    print(f"  {'Environment setup':^{w}}")
+    print(f"  {'(press Enter to skip any field)':^{w}}")
+    print("  " + "-" * w)
+    print()
+
+    env_vars: dict = {}
+
+    for p in prompts:
+        label = p["label"]
+        signup = p.get("signup_url", "")
+        required = p.get("required", False)
+        note = p.get("note", "")
+        tag = "required" if required else "optional"
+
+        # Inline single-line prompt: note + signup on dim lines above,
+        # then `Label (required): ` with the cursor on the same line.
+        if note:
+            print(f"  {_c(_DIM, note)}")
+        if signup:
+            print(f"  {_c(_DIM, 'Sign up: ' + signup)}")
+        prompt_text = f"  {label} {_c(_DIM, '(' + tag + ')')}: "
+        try:
+            val = input(prompt_text).strip()
+        except EOFError:
+            val = ""
+        if val:
+            env_vars[p["key"]] = val
+        print()
+
+    return env_vars
+
+
+# ---------------------------------------------------------------------------
+# Main create flow
+# ---------------------------------------------------------------------------
+def _run_create(
+    project_name: str | None,
+    output_dir: str,
+    no_git: bool,
+    template_slug: str | None,
+) -> int:
+    print_banner(__version__)
+
+    if project_name is None:
+        project_name = prompt_project_name()
+        print()
+    else:
+        try:
+            project_name = validate_project_name(project_name)
+        except argparse.ArgumentTypeError as e:
+            print(f"  Error: {e}")
+            return 1
+
+    # Resolve the template — flag wins; otherwise interactive picker.
+    if template_slug is None:
+        template_slug = prompt_template_choice()
+        print(f"  Selected: {_c(_BOLD, template_slug)}")
+        print()
+    else:
+        # Validate the slug
+        t = get_template(template_slug)
+        if t is None:
+            valid = ", ".join(x["slug"] for x in list_templates())
+            print(f"\n  Error: Unknown template '{template_slug}'.")
+            print(f"  Available: {valid}")
+            print(f"  Run 'create-leafmesh --list' for descriptions.\n")
+            return 2
+        if t.get("status") != "ready":
+            print(f"\n  Error: Template '{template_slug}' is "
+                  f"{t.get('status', 'unknown')}, not ready.\n")
+            return 2
+
+    # Per-template env-var prompts — each template declares its own keys.
+    prompts = get_template_prompts(template_slug)
+    env_vars = prompt_env_vars(prompts)
+
+    # Hand off to create_project, passing our step-printer so it can report progress
+    print(f"  Creating {_c(_BOLD, project_name + '/')} from template "
+          f"{_c(_BOLD, template_slug)}")
+    print()
+
+    result = create_project(
+        project_name,
+        output_dir,
+        template_slug=template_slug,
+        init_git=not no_git,
+        env_vars=env_vars,
+        step_fn=step,
+        step_done_fn=step_done,
+    )
+
+    if result != 0:
+        return result
+
+    # Success box — flag any *required* template key the user skipped.
+    missing = [p["key"] for p in prompts if p.get("required") and p["key"] not in env_vars]
+    print_success_box(project_name, template_slug, missing)
+
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+def _print_template_describe(slug: str) -> int:
+    """Print the full registry entry for a single template."""
+    t = get_template(slug)
+    if t is None:
+        valid = ", ".join(x["slug"] for x in list_templates(include_planned=True))
+        print(f"\n  Error: Unknown template '{slug}'.")
+        print(f"  Available: {valid}\n")
+        return 2
+
+    print()
+    print(_c(_BOLD, f"  {t.get('full_name', t['slug'])}"))
+    print(f"  {_c(_DIM, 'slug:        ' + t['slug'])}")
+    print(f"  {_c(_DIM, 'status:      ' + t.get('status', '?'))}")
+    if t.get("one_line"):
+        print(f"  {_c(_DIM, 'summary:     ' + t['one_line'])}")
+    if t.get("complexity"):
+        print(f"  {_c(_DIM, 'complexity:  ' + t['complexity'])}")
+    if t.get("trust_lead"):
+        print(f"  {_c(_DIM, 'trust:       ' + t['trust_lead'])}")
+    if t.get("agent_count"):
+        print(f"  {_c(_DIM, 'agents:      ' + str(t['agent_count']))}")
+    if t.get("description"):
+        print()
+        print(f"  {t['description']}")
+    print()
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="create-leafmesh",
+        description="Project scaffolding tool for LeafMesh",
+        epilog="""
+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 --describe payment-authorization         Show template details
+        """,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version=f"create-leafmesh {__version__}")
+    parser.add_argument("project_name", nargs="?", default=None, help="Project name")
+    parser.add_argument("-o", "--output-dir", default=".", help="Output directory (default: current)")
+    parser.add_argument("--no-git", action="store_true", help="Skip git init")
+    parser.add_argument(
+        "-t", "--template", default=None, metavar="SLUG",
+        help="Template slug (e.g. incident-triage, payment-authorization). "
+             "Run --list to see all options.",
+    )
+    parser.add_argument(
+        "--list", dest="list_templates", action="store_true",
+        help="List available templates and exit",
+    )
+    parser.add_argument(
+        "--describe", default=None, metavar="SLUG",
+        help="Show details for one template and exit",
+    )
+
+    args = parser.parse_args(argv)
+
+    # Informational flags — short-circuit before any prompting.
+    if args.list_templates:
+        print_template_list()
+        return 0
+    if args.describe:
+        return _print_template_describe(args.describe)
+
+    try:
+        return _run_create(
+            args.project_name,
+            args.output_dir,
+            args.no_git,
+            args.template,
+        )
+    except KeyboardInterrupt:
+        print("\n\n  Cancelled.\n")
+        return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except KeyboardInterrupt:
+        print("\n\n  Cancelled.\n")
+        sys.exit(0)