splent-cli 1.13.0__tar.gz → 1.14.0__tar.gz

{splent_cli-1.13.0/src/splent_cli.egg-info → splent_cli-1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.13.0
+Version: 1.14.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 Project-URL: Homepage, https://github.com/diverso-lab/splent_cli

{splent_cli-1.13.0 → splent_cli-1.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.13.0"
+version = "1.14.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

{splent_cli-1.13.0 → splent_cli-1.14.0}/src/splent_cli/cli.py

@@ -109,6 +109,9 @@ class SPLENTCLI(click.Group):
             "🧬 SPL & Variability": [
                 cmd for cmd in all_cmds if cmd.startswith(("spl:", "uvl:"))
             ],
+            "🛒 Marketplace": [
+                cmd for cmd in all_cmds if cmd.startswith("marketplace:")
+            ],
             "🧱 Database": [cmd for cmd in all_cmds if cmd.startswith("db:")],
             "💾 Cache": [cmd for cmd in all_cmds if cmd.startswith("cache:")],
             "🔍 Checks": [cmd for cmd in all_cmds if cmd.startswith("check:")],

splent_cli-1.14.0/src/splent_cli/commands/check/check_contracts.py

@@ -0,0 +1,206 @@
+"""
+check:contracts — Verify that feature contracts and SPL UVL models agree.
+
+The dependency truth must not be split: a feature's requires.features (in
+[tool.splent.contract]) and the SPL's UVL implications (A => B) describe
+the same reality from two sides. This check reports:
+
+  - contract dependencies with no matching UVL constraint (ERROR: the SPL
+    would let a product select A without B and break at runtime), and
+  - UVL implications not backed by any contract (WARNING: the dependency
+    is invisible to feature:install and the marketplace).
+"""
+
+from pathlib import Path
+
+import click
+import tomllib
+
+from splent_cli.services import context, marketplace
+
+
+def _snapshot_version_key(pyproject_path: Path) -> tuple:
+    """Semver sort key for a cache snapshot dir like splent_feature_x@v1.10.0."""
+    import re
+
+    _, _, version = pyproject_path.parent.name.partition("@")
+    m = re.match(r"v?(\d+)\.(\d+)\.(\d+)", version)
+    if not m:
+        return (-1, -1, -1)
+    return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+
+
+def _local_contract_requires(workspace: str, package: str) -> list[str] | None:
+    """requires.features of a feature found locally (workspace root, else the
+    newest cache snapshot by semver). None when not available locally."""
+    candidates = [Path(workspace) / package / "pyproject.toml"]
+    cache = Path(workspace) / ".splent_cache" / "features"
+    if cache.is_dir():
+        candidates.extend(
+            sorted(
+                cache.glob(f"*/{package}@*/pyproject.toml"),
+                key=_snapshot_version_key,
+                reverse=True,
+            )
+        )
+
+    for path in candidates:
+        if not path.is_file():
+            continue
+        try:
+            data = tomllib.loads(path.read_text())
+        except (OSError, tomllib.TOMLDecodeError):
+            continue
+        requires = (
+            data.get("tool", {})
+            .get("splent", {})
+            .get("contract", {})
+            .get("requires", {})
+        )
+        return {
+            "features": requires.get("features", []),
+            "optional": requires.get("features_optional", []),
+        }
+    return None
+
+
+@click.command(
+    "check:contracts",
+    short_help="Check that feature contracts and SPL UVL constraints agree.",
+)
+@click.option("--spl", "spl_name", default=None, help="Check a single SPL.")
+def check_contracts(spl_name):
+    """
+    Cross-check requires.features in every contract against the UVL
+    constraints of each SPL in splent_catalog.
+
+    \b
+    Examples:
+      splent check:contracts
+      splent check:contracts --spl cms_spl
+    """
+    workspace = str(context.workspace())
+    catalog = Path(workspace) / "splent_catalog"
+
+    if spl_name:
+        spl_dirs = [catalog / spl_name]
+        if not spl_dirs[0].is_dir():
+            click.secho(f"❌ SPL not found: {spl_dirs[0]}", fg="red")
+            raise SystemExit(1)
+    else:
+        spl_dirs = sorted(d for d in catalog.glob("*") if (d / "metadata.toml").is_file())
+
+    if not spl_dirs:
+        click.secho("❌ No SPLs found in splent_catalog.", fg="red")
+        raise SystemExit(1)
+
+    total_errors = 0
+    total_warnings = 0
+
+    for spl_dir in spl_dirs:
+        spl_errors = 0
+        spl_warnings = 0
+        uvl_path = spl_dir / f"{spl_dir.name}.uvl"
+        click.echo()
+        click.echo(click.style(f"  check:contracts — {spl_dir.name}", bold=True))
+        click.echo(click.style(f"  {'─' * 60}", fg="bright_black"))
+
+        if not uvl_path.is_file():
+            click.secho(
+                f"  ⚠  UVL not on disk ({uvl_path.name}) — run: splent spl:fetch "
+                f"{spl_dir.name}",
+                fg="yellow",
+            )
+            total_warnings += 1
+            continue
+
+        model = marketplace.parse_uvl_structure(uvl_path.read_text())
+        shorts = model["features"]  # short -> {package, org, ...}
+        implications = {(a, b) for a, b in model["constraints"]}
+
+        contracts: dict[str, list[str] | None] = {}
+        for short, meta in shorts.items():
+            contracts[short] = _local_contract_requires(workspace, meta["package"])
+
+        missing_local = sorted(s for s, req in contracts.items() if req is None)
+
+        # 1. Contract deps that the UVL does not enforce.
+        for short, req in sorted(contracts.items()):
+            for dep in (req or {}).get("features", []):
+                if dep not in shorts:
+                    # Dependency on a feature outside this SPL: the SPL simply
+                    # cannot offer this feature safely without it.
+                    click.secho(
+                        f"  ✗ {short} requires '{dep}' (contract), but '{dep}' "
+                        f"is not a feature of {spl_dir.name}",
+                        fg="red",
+                    )
+                    spl_errors += 1
+                elif (short, dep) not in implications:
+                    click.secho(
+                        f"  ✗ {short} requires '{dep}' (contract), but the UVL "
+                        f"has no '{short} => {dep}' constraint",
+                        fg="red",
+                    )
+                    click.echo(
+                        click.style(
+                            f"      fix: add '{short} => {dep}' to the UVL "
+                            f"constraints (splent spl:add-constraints "
+                            f"{spl_dir.name} is interactive)",
+                            fg="bright_black",
+                        )
+                    )
+                    spl_errors += 1
+
+        # 2. UVL implications with no contract behind them.
+        for a, b in sorted(implications):
+            req = contracts.get(a)
+            if a not in shorts or b not in shorts:
+                continue  # constraint over infra features (redis, nginx…)
+            if req is None:
+                continue  # feature not local — cannot verify
+            if b in req["optional"]:
+                continue  # SPL hardening a soft (graceful) dependency — fine
+            if b not in req["features"]:
+                click.secho(
+                    f"  ⚠  UVL says '{a} => {b}' but {a}'s contract does not "
+                    f"require '{b}'",
+                    fg="yellow",
+                )
+                click.echo(
+                    click.style(
+                        f"      fix: add \"{b}\" to requires.features_manual in "
+                        f"{shorts[a]['package']}/pyproject.toml (preserved on "
+                        "regeneration), or confirm it is SPL-level policy",
+                        fg="bright_black",
+                    )
+                )
+                spl_warnings += 1
+
+        if missing_local:
+            click.echo(
+                click.style(
+                    f"  ℹ  not local (skipped): {', '.join(missing_local)}",
+                    fg="bright_black",
+                )
+            )
+
+        if not spl_errors and not spl_warnings:
+            click.secho("  ✅ Contracts and UVL agree.", fg="green")
+        total_errors += spl_errors
+        total_warnings += spl_warnings
+
+    click.echo()
+    if total_errors or total_warnings:
+        click.echo(
+            click.style(
+                f"  {total_errors} error(s), {total_warnings} warning(s).",
+                bold=True,
+            )
+        )
+        click.echo()
+    if total_errors:
+        raise SystemExit(1)
+
+
+cli_command = check_contracts

{splent_cli-1.13.0 → splent_cli-1.14.0}/src/splent_cli/commands/feature/feature_clean.py

@@ -12,20 +12,16 @@ from pathlib import Path
 import click
 
 from splent_cli.services import context
+from splent_cli.utils.archetype import (  # noqa: F401  (re-exported for callers)
+    ARCHETYPES,
+    ARCHETYPE_LABELS,
+    detect_archetype as _detect_archetype,
+)
 from splent_cli.utils.feature_utils import normalize_namespace
 
 
 DEFAULT_NAMESPACE = os.getenv("SPLENT_DEFAULT_NAMESPACE", "splent_io")
 
-ARCHETYPES = ("full", "light", "config", "service")
-
-ARCHETYPE_LABELS = {
-    "full": "Complete domain feature (models, routes, services, templates, migrations)",
-    "light": "Lightweight UI feature (routes, hooks, templates)",
-    "config": "Infrastructure feature (config.py only)",
-    "service": "Backend service (services, config, commands, signals)",
-}
-
 # Files that are ALWAYS kept regardless of archetype
 PROTECTED = {"__init__.py"}
 
@@ -115,32 +111,6 @@ def _is_stub_dir(dirpath, dirname):
     return False
 
 
-# ── Archetype detection ──────────────────────────────────────────────
-
-
-def _detect_archetype(src_dir):
-    """Detect the real archetype from source file contents."""
-    models = _read(os.path.join(src_dir, "models.py"))
-    routes = _read(os.path.join(src_dir, "routes.py"))
-    services = _read(os.path.join(src_dir, "services.py"))
-
-    has_models = models and re.search(r"db\.Column", models)
-    has_routes = routes and re.search(r"@\w+\.route\s*\(", routes)
-    has_services = services and re.search(
-        r"def\s+(?!__)\w+\s*\(.*\):\s*\n\s+(?!pass\b|\.\.\.|\s*#)",
-        services,
-        re.MULTILINE,
-    )
-
-    if has_models:
-        return "full"
-    if has_routes:
-        return "light"
-    if has_services:
-        return "service"
-    return "config"
-
-
 # ── Expected files per archetype ─────────────────────────────────────
 
 

{splent_cli-1.13.0 → splent_cli-1.14.0}/src/splent_cli/commands/feature/feature_clone.py

@@ -1,9 +1,8 @@
 import os
 import re
 import shutil
-import requests
 import click
-from splent_cli.services import context
+from splent_cli.services import context, registry
 from splent_cli.utils.cache_utils import make_feature_readonly
 from splent_cli.utils.feature_utils import normalize_namespace
 from splent_cli.utils.proc import require_tool
@@ -17,38 +16,6 @@ DEFAULT_NAMESPACE = os.getenv("SPLENT_DEFAULT_NAMESPACE", "splent_io")
 # =====================================================================
 
 
-def _get_latest_tag(namespace, repo) -> str | None:
-    """Fetch the highest semver tag from GitHub. Returns None if unreachable or no tags."""
-    api_url = f"https://api.github.com/repos/{namespace}/{repo}/tags?per_page=100"
-    # Authenticate when a token is present so version resolution also works for
-    # PRIVATE feature repos (an unauthenticated call 404s on those) and to raise
-    # the API rate limit.
-    headers = {}
-    token = os.getenv("GITHUB_TOKEN")
-    if token:
-        headers["Authorization"] = f"Bearer {token}"
-    try:
-        r = requests.get(api_url, headers=headers, timeout=5)
-        r.raise_for_status()
-        tags = r.json()
-        if not tags:
-            return None
-        versions = []
-        for tag in tags:
-            name = tag.get("name", "")
-            m = re.match(r"v?(\d+)\.(\d+)\.(\d+)", name)
-            if m:
-                versions.append(
-                    (int(m.group(1)), int(m.group(2)), int(m.group(3)), name)
-                )
-        if not versions:
-            return tags[0]["name"]
-        versions.sort(reverse=True)
-        return versions[0][3]
-    except (requests.RequestException, KeyError, IndexError, ValueError):
-        return None
-
-
 def _parse_full_name(full_name: str):
     """
     full_name = <namespace>/<repo>[@version]
@@ -104,7 +71,7 @@ def feature_clone(full_name):
         click.echo(
             f"🔍 No version provided → fetching latest tag for {namespace}/{repo}..."
         )
-        version = _get_latest_tag(namespace, repo)
+        version = registry.latest_semver_tag(namespace, repo)
         if not version:
             click.secho(
                 f"❌ Could not fetch tags for {namespace}/{repo}. Is the repo reachable and does it have tags?",

{splent_cli-1.13.0 → splent_cli-1.14.0}/src/splent_cli/commands/feature/feature_contract.py

@@ -90,6 +90,9 @@ def _read_current_contract(pyproject_path: Path) -> dict:
     raw = data.get("tool", {}).get("splent", {}).get("contract", {})
     ext = raw.get("extensible", {})
     return {
+        "archetype": raw.get("archetype"),
+        "category": raw.get("category"),
+        "tags": raw.get("tags", []),
         "routes": raw.get("provides", {}).get("routes", []),
         "blueprints": raw.get("provides", {}).get("blueprints", []),
         "models": raw.get("provides", {}).get("models", []),
@@ -100,6 +103,12 @@ def _read_current_contract(pyproject_path: Path) -> dict:
         "translations": raw.get("provides", {}).get("translations", []),
         "docker": raw.get("provides", {}).get("docker", []),
         "requires_features": raw.get("requires", {}).get("features", []),
+        "requires_features_manual": raw.get("requires", {}).get(
+            "features_manual", []
+        ),
+        "requires_features_optional": raw.get("requires", {}).get(
+            "features_optional", []
+        ),
         "env_vars": raw.get("requires", {}).get("env_vars", []),
         "requires_signals": raw.get("requires", {}).get("signals", []),
         "extensible_services": ext.get("services", []),
@@ -135,6 +144,10 @@ def _print_contract(contract: dict, feature_name: str) -> None:
         return "[" + ", ".join(f'"{i}"' for i in items) + "]"
 
     click.echo()
+    if contract.get("archetype"):
+        click.echo(click.style("  [tool.splent.contract]", fg="bright_black"))
+        click.echo(f"  archetype  = \"{contract['archetype']}\"")
+        click.echo()
     click.echo(click.style("  [tool.splent.contract.provides]", fg="bright_black"))
     click.echo(f"  routes     = {_fmt(contract['routes'])}")
     click.echo(f"  blueprints = {_fmt(contract['blueprints'])}")
@@ -148,6 +161,9 @@ def _print_contract(contract: dict, feature_name: str) -> None:
     click.echo()
     click.echo(click.style("  [tool.splent.contract.requires]", fg="bright_black"))
     click.echo(f"  features   = {_fmt(contract['requires_features'])}")
+    click.echo(
+        f"  features_optional = {_fmt(contract.get('requires_features_optional', []))}"
+    )
     click.echo(f"  env_vars   = {_fmt(contract['env_vars'])}")
     click.echo(f"  signals    = {_fmt(contract.get('requires_signals', []))}")
     click.echo()
@@ -190,6 +206,7 @@ def _print_diff(current: dict, inferred: dict) -> bool:
         ("services", "services"),
         ("docker", "docker"),
         ("requires_features", "requires.features"),
+        ("requires_features_optional", "requires.features_optional"),
         ("env_vars", "requires.env_vars"),
         ("signals", "provides.signals"),
         ("translations", "provides.translations"),
@@ -205,6 +222,17 @@ def _print_diff(current: dict, inferred: dict) -> bool:
     ]
 
     diff_lines = []
+
+    # archetype is a scalar, not a list — compare it directly
+    old_arch = current.get("archetype")
+    new_arch = inferred.get("archetype")
+    if new_arch and old_arch != new_arch:
+        if old_arch:
+            diff_lines.append(
+                click.style(f"    - archetype: {old_arch}", fg="red")
+            )
+        diff_lines.append(click.style(f"    + archetype: {new_arch}", fg="green"))
+
     for key, label in FIELDS:
         diff_lines.extend(
             _diff_field(label, current.get(key, []), inferred.get(key, []))
@@ -268,6 +296,22 @@ def feature_contract(feature_ref, write):
     click.echo("  🔍 Scanning source code…")
     inferred = infer_contract(str(cache_path), ns, name)
 
+    # Deps declared in requires.features_manual are preserved by
+    # write_contract; merge them here too so the dry-run diff shows exactly
+    # what --write would produce (including real drops of stale inferred deps).
+    current = _read_current_contract(pyproject_path)
+    manual = sorted(set(current.get("requires_features_manual", [])))
+    if manual:
+        inferred["requires_features"] = sorted(
+            set(inferred["requires_features"]) | set(manual)
+        )
+        click.echo(
+            click.style(
+                "  Preserving requires.features_manual: ", fg="bright_black"
+            )
+            + ", ".join(manual)
+        )
+
     # Show inferred contract
     click.echo(click.style("  Inferred contract:", bold=True))
     _print_contract(inferred, name)
@@ -280,7 +324,6 @@ def feature_contract(feature_ref, write):
     inferred["docker_networks"] = dc.get("networks", [])
 
     # Compare with current
-    current = _read_current_contract(pyproject_path)
     has_changes = _print_diff(current, inferred)
 
     if not has_changes:

splent_cli-1.14.0/src/splent_cli/commands/feature/feature_info.py

@@ -0,0 +1,214 @@
+"""
+feature:info — Show a feature's contract card without cloning anything.
+
+Data comes from the marketplace index (built with `marketplace:index` or
+fetched from SPLENT_INDEX_URL). When no index is available, falls back to
+reading the feature's pyproject.toml straight from GitHub at its latest
+released tag — always the real contract, never a hand-maintained copy.
+"""
+
+import json
+import os
+import tomllib
+
+import click
+
+from splent_cli.services import context, marketplace, registry
+from splent_cli.utils.feature_utils import (
+    get_normalize_feature_name_in_splent_format,
+    load_product_features,
+)
+
+
+def _fetch_live_entry(org: str, repo: str, token: str | None) -> dict | None:
+    """Build an index-shaped entry for one feature straight from GitHub."""
+    version = registry.latest_semver_tag(org, repo, token)
+    if not version:
+        return None
+    text = registry.fetch_file(org, repo, "pyproject.toml", ref=version, token=token)
+    if text is None:
+        return None
+    try:
+        return marketplace.feature_entry_from_pyproject(
+            text, org=org, repo=repo, source="github", version=version
+        )
+    except tomllib.TOMLDecodeError:
+        return None
+
+
+def _product_feature_shorts() -> set[str]:
+    """Short names of the features in the active product ('' set when detached)."""
+    product = context.active_app()
+    if not product:
+        return set()
+    try:
+        entries = load_product_features(
+            os.path.join(str(context.workspace()), product), os.getenv("SPLENT_ENV")
+        )
+    except (FileNotFoundError, SystemExit):
+        return set()
+    return {
+        e.split("@")[0].split("/")[-1].removeprefix("splent_feature_")
+        for e in entries
+    }
+
+
+def _print_list(label: str, items: list, color: str | None = None) -> None:
+    if not items:
+        return
+    click.echo(f"  {label:<14}" + click.style(", ".join(items), fg=color))
+
+
+@click.command(
+    "feature:info",
+    short_help="Show a feature's contract, dependencies and usage without cloning it.",
+)
+@click.argument("feature_ref")
+@click.option("--refresh", is_flag=True, help="Re-fetch the index from SPLENT_INDEX_URL.")
+@click.option("--json", "as_json", is_flag=True, help="Print the raw entry as JSON.")
+def feature_info(feature_ref, refresh, as_json):
+    """
+    Show everything the marketplace knows about a feature.
+
+    \b
+    Examples:
+      splent feature:info auth
+      splent feature:info splent-io/splent_feature_events
+      splent feature:info media --json
+    """
+    workspace = str(context.workspace())
+    token = registry.github_token()
+
+    index, origin = marketplace.resolve_index(workspace, refresh=refresh)
+
+    entry = None
+    if index:
+        entry = marketplace.find_feature(index, feature_ref)
+
+    if entry is None:
+        # Live fallback: one feature, straight from GitHub.
+        if "/" in feature_ref:
+            org, _, repo = feature_ref.partition("/")
+        else:
+            org = os.getenv("SPLENT_DEFAULT_ORG", "splent-io")
+            repo = feature_ref
+        repo = get_normalize_feature_name_in_splent_format(repo.split("@")[0])
+        entry = _fetch_live_entry(org, repo, token)
+        origin = "github (live)"
+
+    if entry is None:
+        click.secho(f"❌ Feature '{feature_ref}' not found.", fg="red")
+        click.secho(
+            "   Build an index with: splent marketplace:index "
+            "(or check the name/org and your network).",
+            fg="yellow",
+        )
+        raise SystemExit(1)
+
+    if as_json:
+        click.echo(json.dumps(entry, indent=2, ensure_ascii=False))
+        return
+
+    installed = _product_feature_shorts()
+    provides = entry.get("provides", {})
+    requires = entry.get("requires", {})
+
+    click.echo()
+    header = f"  {entry['id']}"
+    if entry.get("version"):
+        header += click.style(f"  {entry['version']}", fg="green")
+    if entry.get("archetype"):
+        header += click.style(f"  [{entry['archetype']}]", fg="cyan")
+    if entry["short"] in installed:
+        header += click.style("  ● installed", fg="green")
+    click.echo(click.style(header, bold=True))
+    click.echo(click.style(f"  {'─' * 60}", fg="bright_black"))
+
+    if entry.get("description"):
+        click.echo(f"  {entry['description']}")
+        click.echo()
+
+    if entry.get("category"):
+        click.echo(f"  {'category':<14}{entry['category']}")
+    _print_list("tags", entry.get("tags", []))
+    if entry.get("env"):
+        click.echo(
+            f"  {'env':<14}" + click.style(f"{entry['env']} only", fg="yellow")
+        )
+
+    _print_list("models", provides.get("models", []))
+    _print_list("services", provides.get("services", []))
+    _print_list("routes", provides.get("routes", []))
+    _print_list("hooks", provides.get("hooks", []))
+    _print_list("signals", provides.get("signals", []))
+    _print_list("commands", provides.get("commands", []))
+    _print_list("translations", provides.get("translations", []))
+    if entry.get("docker"):
+        _print_list("docker", entry["docker"].get("services", []), color="cyan")
+
+    req_features = requires.get("features", [])
+    if req_features:
+        click.echo()
+        decorated = []
+        for dep in req_features:
+            if dep in installed:
+                decorated.append(dep + click.style(" ✔", fg="green"))
+            else:
+                decorated.append(dep + click.style(" ✗ missing", fg="yellow"))
+        click.echo(f"  {'requires':<14}" + ", ".join(decorated))
+    _print_list("env vars", requires.get("env_vars", []), color="bright_black")
+    _print_list("needs signals", requires.get("signals", []), color="bright_black")
+
+    if index:
+        closure = marketplace.dependency_closure(index, entry["short"])
+        extra = sorted(set(closure) - set(req_features))
+        if extra:
+            _print_list("transitively", extra, color="bright_black")
+
+    if entry.get("used_by"):
+        click.echo()
+        _print_list("used by", entry["used_by"], color="cyan")
+
+    if entry.get("refinement"):
+        refines = entry["refinement"].get("refines")
+        if refines:
+            click.echo()
+            click.echo(
+                f"  {'refines':<14}" + click.style(refines, fg="magenta")
+            )
+
+    pypi = entry.get("pypi")
+    if pypi is not None:
+        click.echo()
+        if pypi.get("published"):
+            label = f"published (latest {pypi.get('latest')})"
+            color = "green" if pypi.get("has_current") else "yellow"
+            if not pypi.get("has_current"):
+                label += " — current tag not on PyPI yet"
+            click.echo(f"  {'pypi':<14}" + click.style(label, fg=color))
+        else:
+            click.echo(
+                f"  {'pypi':<14}"
+                + click.style("not published (dev-only via GitHub)", fg="yellow")
+            )
+
+    gh = entry.get("github") or {}
+    if gh.get("url"):
+        click.echo(f"  {'repo':<14}{gh['url']}")
+
+    click.echo()
+    click.echo(
+        click.style(f"  source: {origin or entry.get('source', '?')}", fg="bright_black")
+    )
+    if entry["short"] not in installed and context.active_app():
+        click.echo()
+        click.echo(
+            "  install with: "
+            + click.style(
+                f"splent feature:install {entry['org']}/{entry['repo']}", bold=True
+            )
+        )
+    click.echo()
+
+
+cli_command = feature_info