splent-cli 1.34.1__tar.gz → 1.35.0__tar.gz

{splent_cli-1.34.1/src/splent_cli.egg-info → splent_cli-1.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.34.1
+Version: 1.35.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 License-Expression: LGPL-3.0-or-later

{splent_cli-1.34.1 → splent_cli-1.35.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.34.1"
+version = "1.35.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.34.1 → splent_cli-1.35.0}/src/splent_cli/cli.py

@@ -11,6 +11,15 @@ from splent_cli.utils.command_loader import load_commands
 load_dotenv()
 
 
+def _missing_module(exc: BaseException) -> str | None:
+    """The module whose absence made building the app fail, if that is why."""
+    while exc is not None:
+        if isinstance(exc, ModuleNotFoundError) and exc.name:
+            return exc.name
+        exc = exc.__cause__ or exc.__context__
+    return None
+
+
 class SPLENTCLI(click.Group):
     """
     Main SPLENT CLI class.
@@ -101,15 +110,53 @@ class SPLENTCLI(click.Group):
 
     # ── App context injection ─────────────────────────────────────
 
+    def _delegate_to_the_product(self, ctx) -> None:
+        """Run this command in the product's web container, and exit with its
+        code; return when that container is not running.
+
+        Called only when the app cannot be built here: building it imports
+        what the features declare, which the product's image installs and the
+        CLI's may not (see services/web_container.py).
+        """
+        from splent_cli.services import web_container
+
+        product = os.getenv("SPLENT_APP")
+        if not product or web_container.is_product_container():
+            return
+        if not web_container.running(web_container.name(product)):
+            return
+        argv = [*ctx.protected_args, *ctx.args]
+        raise SystemExit(web_container.delegate(product, argv))
+
     def invoke(self, ctx):
         cmd_name = ctx.protected_args[0] if ctx.protected_args else None
         command = self.get_command(ctx, cmd_name)
 
+        # A feature's own commands are only found by building the app, so
+        # here they may be missing although the product has them.
+        if command is None and cmd_name and cmd_name.startswith("feature:"):
+            self._delegate_to_the_product(ctx)
+
         if command and getattr(command, "requires_app", False):
             from splent_cli.utils.dynamic_imports import get_app
             from splent_cli.utils.db_utils import check_db_connection
 
-            app = get_app()
+            try:
+                app = get_app()
+            except Exception as exc:
+                missing = _missing_module(exc)
+                if missing is None:
+                    raise
+                # Only then: where the app builds here, the command runs here
+                # with the tools the CLI image has (ruff formats migrations).
+                self._delegate_to_the_product(ctx)
+                product = os.getenv("SPLENT_APP", "The product")
+                raise click.ClickException(
+                    f"{product}'s features need {missing}, which the product's "
+                    "image installs and the CLI's does not.\n"
+                    "  Start the product (splent product:up --dev) and run the "
+                    "command again: it then runs in the product's web container."
+                ) from exc
             if getattr(command, "requires_db", False):
                 if not check_db_connection(app):
                     raise SystemExit(1)

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_compat.py

@@ -411,6 +411,141 @@ def _analyse_all(labeled_contracts: list[tuple[str, dict]]) -> list[dict]:
     return sorted(findings, key=lambda f: SEVERITY_ORDER[f["severity"]])
 
 
+def _contract_env(path: Path) -> str | None:
+    """The environment a feature's contract confines it to, if any."""
+    pyproject = path / "pyproject.toml"
+    if not pyproject.exists():
+        return None
+    data = load_toml(pyproject, what=f"pyproject.toml for {path.name}")
+    return data.get("tool", {}).get("splent", {}).get("contract", {}).get("env")
+
+
+def env_scope_findings(workspace: str, product_dir: str) -> list[dict]:
+    """Features confined to one environment, in a list that installs them in
+    the other.
+
+    mailhog and phpmyadmin declare env = "dev" in their contract. In the base
+    list the production image installed them too, phpMyAdmin with autologin
+    to the database, and nothing said so.
+    """
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    reader = PyprojectReader.for_product(product_dir)
+    lists = {
+        "features": reader.features,
+        "features_dev": reader.features_dev,
+        "features_prod": reader.features_prod,
+    }
+    findings = []
+    for key, entries in lists.items():
+        for entry in entries:
+            ns, name, version = _parse_pyproject_entry(entry)
+            path = product_feature_dir(workspace, product_dir, ns, name, version)
+            if path is None:
+                continue
+            scope = _contract_env(path)
+            short = name.removeprefix("splent_feature_")
+            if scope == "dev" and key != "features_dev":
+                message = (
+                    f"{short} is a development tool (its contract says env = "
+                    f'"dev"), but [tool.splent] {key} puts it in the production '
+                    "image too. Move it to features_dev."
+                )
+            elif scope == "prod" and key == "features_dev":
+                message = (
+                    f"{short} only runs in production (its contract says env = "
+                    '"prod"), but it is in [tool.splent] features_dev. Move it '
+                    "to features_prod."
+                )
+            else:
+                continue
+            findings.append(
+                {
+                    "severity": "error",
+                    "field": "env",
+                    "message": message,
+                    "features": [short],
+                }
+            )
+    return findings
+
+
+def _joins_the_shared_network(compose_file: Path) -> bool:
+    """Whether a compose file puts its services on the shared splent_network
+    instead of the product's own (``name: ${SPLENT_NETWORK:-splent_network}``)."""
+    import yaml
+
+    try:
+        data = yaml.safe_load(compose_file.read_text()) or {}
+    except (OSError, yaml.YAMLError):
+        return False
+    networks = data.get("networks") or {}
+    spec = networks.get("splent_network")
+    if not isinstance(spec, dict) or not spec.get("external"):
+        return False
+    return "SPLENT_NETWORK" not in str(spec.get("name", ""))
+
+
+def network_findings(workspace: str, product_dir: str) -> list[dict]:
+    """Feature services the product cannot reach.
+
+    Each product has a network of its own, and a feature's services join it
+    through SPLENT_NETWORK. mailhog and phpmyadmin named the shared network
+    instead, so the app could not send mail to Mailhog and phpMyAdmin could
+    not reach the database, and nothing said why.
+    """
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    reader = PyprojectReader.for_product(product_dir)
+    findings = []
+    for entry in reader.features + reader.features_dev + reader.features_prod:
+        ns, name, version = _parse_pyproject_entry(entry)
+        path = product_feature_dir(workspace, product_dir, ns, name, version)
+        if path is None:
+            continue
+        files = sorted((path / "docker").glob("docker-compose*.yml"))
+        if any(_joins_the_shared_network(f) for f in files):
+            short = name.removeprefix("splent_feature_")
+            findings.append(
+                {
+                    "severity": "error",
+                    "field": "docker",
+                    "message": (
+                        f"{short}'s services join the shared splent_network, "
+                        "where the product's app cannot reach them. Its compose "
+                        "file needs name: ${SPLENT_NETWORK:-splent_network} "
+                        "under networks.splent_network."
+                    ),
+                    "features": [short],
+                }
+            )
+    return findings
+
+
+def naming_findings(workspace: str, product_dir: str) -> list[dict]:
+    """Features named after a product (auth_uvlhub). A warning, so the debt
+    shows in every validation until the product drops them."""
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    from splent_cli.utils.feature_naming import product_suffix, product_suffix_message
+
+    reader = PyprojectReader.for_product(product_dir)
+    findings = []
+    for entry in reader.features + reader.features_dev + reader.features_prod:
+        _, name, _ = _parse_pyproject_entry(entry)
+        product = product_suffix(name, workspace)
+        if product:
+            findings.append(
+                {
+                    "severity": "warning",
+                    "field": "name",
+                    "message": product_suffix_message(name, product),
+                    "features": [name.removeprefix("splent_feature_")],
+                }
+            )
+    return findings
+
+
 def run_all_product_check(workspace: str, product_dir: str) -> list[dict]:
     """Run the full product compatibility check. Returns findings list."""
     try:

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_create.py

@@ -9,6 +9,7 @@ from splent_cli.utils.feature_utils import (
     require_valid_feature_ref,
 )
 from splent_cli.services import context
+from splent_cli.utils.feature_naming import product_suffix, product_suffix_message
 
 from splent_cli.utils.running_version import cli_version as _running_cli_version
 
@@ -223,6 +224,12 @@ def make_feature(full_name, feature_type, docker):
 
     # --- Target directory (workspace root for editable features) ---
     workspace = str(context.workspace())
+
+    product = product_suffix(feature_name, workspace)
+    if product:
+        click.secho(f"❌ {product_suffix_message(feature_name, product)}", fg="red")
+        raise SystemExit(1)
+
     feature_dir = os.path.join(workspace, feature_name)
     src_path = os.path.join(feature_dir, "src", org_safe, feature_name)
 

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_detach.py

@@ -25,7 +25,7 @@ from splent_cli.utils.manifest import (
 
 @click.command(
     "feature:detach",
-    short_help="Unregister a versioned feature from the active product (cache is kept).",
+    short_help="Unpin a released version: the entry goes back to editable (cache is kept).",
 )
 @click.argument("feature_identifier", required=True)
 @click.argument("version", required=True)
@@ -36,9 +36,10 @@ from splent_cli.utils.manifest import (
 )
 def feature_detach(feature_identifier, version, force):
     """
-    Detach a versioned feature from the active product.
+    Unpin a released version, the reverse of feature:attach.
 
-    - Removes namespace/feature@version from pyproject.toml
+    - Drops @version from the entry in pyproject.toml, which stays as the
+      bare, editable namespace/feature (feature:remove takes it out)
     - Removes symlink in features/<namespace>/
     - Leaves .splent_cache intact
     """

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_env.py

@@ -119,7 +119,10 @@ def feature_env(feature_name, generate, env_name):
 
     if selected:
         try:
-            shutil.copy(selected, env_file)
+            # copyfile, not copy: a pinned feature's cache is read-only, and
+            # copying the mode made its .env read-only too, so product:env
+            # --merge failed writing __FEATURE_HOST_DIR__ into it.
+            shutil.copyfile(selected, env_file)
         except OSError as exc:
             click.echo(f"❌ Failed to create {env_file} from {selected}: {exc}")
             raise SystemExit(1)

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_refine.py

@@ -14,6 +14,7 @@ from pathlib import Path
 import click
 
 from splent_cli.services import context
+from splent_cli.utils.feature_naming import product_suffix, product_suffix_message
 from splent_cli.utils.feature_utils import normalize_namespace, read_features_from_data
 from splent_cli.utils.refinement_facts import (
     FeatureSource,
@@ -1009,6 +1010,12 @@ def feature_refinement(refiner_name):
     # A feature other features refine cannot refine anything (a chain)
     _refuse_if_refined(_get_product_features(workspace, product), refiner_name)
 
+    # A refiner named after a product is a product patch, not variability.
+    named_after = product_suffix(refiner_name, workspace)
+    if named_after:
+        click.secho(f"  {product_suffix_message(refiner_name, named_after)}", fg="red")
+        raise SystemExit(1)
+
     # Check if refinement already configured
     refiner_data = load_toml(refiner_pyproject, what=f"{refiner_name} pyproject.toml")
     existing_refinement = (

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_remove.py

@@ -24,7 +24,7 @@ from splent_cli.utils.manifest import (
 
 @click.command(
     "feature:remove",
-    short_help="Unregister an editable feature from the active product (keeps files).",
+    short_help="Remove a feature from the active product, pinned or editable (keeps files).",
 )
 @click.argument("feature_name", required=True)
 @click.option("--namespace", "-n", help="Namespace (defaults to 'splent-io').")
@@ -47,9 +47,10 @@ from splent_cli.utils.manifest import (
 )
 def feature_remove(feature_name, namespace, env_scope, force):
     """
-    Removes a local feature (no version, no repo) from the current SPLENT product:
-    - Removes entry from [features] in pyproject.toml
-    - Removes symlink under /workspace/<product>/features/<namespace>/<feature_name>
+    Removes a feature from the current SPLENT product, pinned or editable:
+    - Removes its entry from the feature lists in pyproject.toml
+    - Removes its symlink under /workspace/<product>/features/<namespace>/
+    The checkout and the cached release stay on disk.
 
     \b
     Without flags every list is searched (features, features_dev, features_prod).

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/feature/feature_test.py

@@ -13,7 +13,7 @@ from splent_cli.utils.feature_utils import (
     get_normalize_feature_name_in_splent_format,
     parse_feature_entry,
 )
-from splent_cli.services import context
+from splent_cli.services import context, web_container
 
 
 # Test levels in execution order (default = first three)
@@ -21,28 +21,13 @@ TEST_LEVELS = ("unit", "integration", "functional", "e2e", "load")
 DEFAULT_LEVELS = ("unit", "integration", "functional")
 
 
-def _is_product_container() -> bool:
-    """Whether this process already runs inside the product's web container.
-
-    SPLENT_CONTAINER is the explicit answer when set (the CLI container says
-    "cli", product images say "product"); /.dockerenv covers containers older
-    than the variable.
-    """
-    container = os.getenv("SPLENT_CONTAINER")
-    if container:
-        return container != "cli"
-    return os.path.exists("/.dockerenv")
+# Shared with every command that needs the product's app (see cli.py).
+_is_product_container = web_container.is_product_container
+_container_running = web_container.running
 
 
 def _web_container() -> str:
-    return f"{context.require_app()}_web"
-
-
-def _container_running(name: str) -> bool:
-    result = run(
-        ["docker", "ps", "-q", "-f", f"name=^{name}$"], check=False, capture=True
-    )
-    return result.returncode == 0 and bool(result.stdout.strip())
+    return web_container.name(context.require_app())
 
 
 _PASSTHROUGH_ENV = ("PYTEST_ADDOPTS", "PYTHONDONTWRITEBYTECODE")

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/product/product_resolve.py

@@ -9,7 +9,7 @@ from splent_cli.utils.feature_utils import (
     parse_feature_entry,
     read_features_from_data,
 )
-from splent_cli.utils.cache_utils import make_feature_writable
+from splent_cli.utils.cache_utils import make_feature_writable, restore_snapshot
 
 
 def _splent_list(data: dict, key: str) -> list[str]:
@@ -194,11 +194,18 @@ def product_sync(ctx, force, yes, mode=None, strict=False):
                         failed += 1
                         continue
 
+            restored = [] if cloned else restore_snapshot(cache_dir)
             _create_symlink(cache_dir, product_features_dir, link_path)
             marker = click.style("  ✓", fg="green")
             label = f"  {short:<{max_w_r}}"
             ver = click.style(f"  {version}", dim=True)
             src = click.style("  cached" if not cloned else "  cloned", dim=True)
+            if restored:
+                src += click.style(
+                    f"  restored {len(restored)} file(s) to the release: "
+                    + ", ".join(restored),
+                    fg="yellow",
+                )
             tag = _feature_env_tag(entry, dev_set, prod_set)
             click.echo(f"  {marker}{label}{ver}{src}{tag}")
 

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/product/product_sync_template.py

@@ -2,8 +2,9 @@ import click
 from pathlib import Path
 
 from splent_cli.services import context
-from splent_cli.utils.io_utils import atomic_write
+from splent_cli.utils.io_utils import atomic_write, load_toml
 from splent_cli.utils.template_drift import (
+    CLI_VERSION,
     PRODUCT_GROUPS,
     count_changed_lines,
     file_diff,
@@ -12,6 +13,23 @@ from splent_cli.utils.template_drift import (
     resolve_product_dir,
     resolve_product_rel,
 )
+from splent_cli.utils.toml_edit import write_toml
+
+
+def _record_cli_version(product_path: Path) -> None:
+    """Store the CLI whose templates the product now matches.
+
+    product:drift reports it as "generated with CLI vX". Only product:create
+    wrote it, so a product brought fully up to date kept naming the CLI it was
+    created with. A partial sync (--scripts, --docker...) leaves it alone,
+    because the other groups may still be older.
+    """
+    pyproject = product_path / "pyproject.toml"
+    data = load_toml(pyproject, what="pyproject.toml")
+    splent = data.setdefault("tool", {}).setdefault("splent", {})
+    if splent.get("cli_version") != CLI_VERSION:
+        splent["cli_version"] = CLI_VERSION
+        write_toml(pyproject, data)
 
 
 @click.command(
@@ -112,6 +130,8 @@ def product_sync_template(
                 changes[rel_path] = (abs_path, expected, n)
 
     if not changes:
+        if not filter_active and not dry_run:
+            _record_cli_version(product_path)
         click.echo()
         click.secho("  ✅ All SPLENT-owned files are already up to date.", fg="green")
         click.echo()
@@ -138,6 +158,8 @@ def product_sync_template(
         # Atomic: an interrupted run never leaves a half-written script.
         atomic_write(abs_path, expected)
         click.secho(f"  ✔  {rel_path}", fg="green")
+    if not filter_active:
+        _record_cli_version(product_path)
 
     click.echo()
     click.secho("  Done.", fg="cyan")

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/commands/product/product_validate.py

@@ -110,9 +110,17 @@ def _run_sat_check(workspace, app_name, data, feature_list, print_config):
 
 def _run_compat_check(workspace, product_dir):
     """Run contract compatibility check. Returns (findings, errors, warnings)."""
-    from splent_cli.commands.feature.feature_compat import run_all_product_check
+    from splent_cli.commands.feature.feature_compat import (
+        env_scope_findings,
+        naming_findings,
+        network_findings,
+        run_all_product_check,
+    )
 
     findings = run_all_product_check(workspace, product_dir)
+    findings += env_scope_findings(workspace, product_dir)
+    findings += network_findings(workspace, product_dir)
+    findings += naming_findings(workspace, product_dir)
     errors = [f for f in findings if f["severity"] == "error"]
     warnings = [f for f in findings if f["severity"] == "warning"]
     return findings, errors, warnings

splent_cli-1.35.0/src/splent_cli/services/web_container.py

@@ -0,0 +1,66 @@
+"""Running a command inside the product's web container.
+
+The product's app imports every feature, and therefore every third-party
+package the features declare. Those are installed in the product's image,
+never in the CLI's, which every product on the machine shares. A command
+that builds the app in the CLI container died on the first such import
+(identities needs authlib), so db:upgrade, db:seed and the features' own
+commands only worked for products whose features needed nothing beyond the
+framework. The web container is where the app already runs, with all of it.
+"""
+
+import os
+import shlex
+import sys
+
+from splent_cli.utils.proc import run
+
+
+def is_product_container() -> bool:
+    """Whether this process already runs inside the product's web container.
+
+    SPLENT_CONTAINER is the explicit answer when set (the CLI container says
+    "cli", product images say "product"); /.dockerenv covers containers older
+    than the variable.
+    """
+    container = os.getenv("SPLENT_CONTAINER")
+    if container:
+        return container != "cli"
+    return os.path.exists("/.dockerenv")
+
+
+def name(product: str) -> str:
+    return f"{product}_web"
+
+
+def running(container: str) -> bool:
+    result = run(
+        ["docker", "ps", "-q", "-f", f"name=^{container}$"], check=False, capture=True
+    )
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
+def delegate(product: str, argv: list[str]) -> int:
+    """Run ``splent <argv>`` in the product's web container; its exit code.
+
+    With a terminal the exec gets one too, so prompts, colours and Ctrl-C
+    behave as they do here.
+    """
+    command = " ".join(shlex.quote(a) for a in ["splent", *argv])
+    tty = ["-t"] if sys.stdin.isatty() and sys.stdout.isatty() else []
+    result = run(
+        [
+            "docker",
+            "exec",
+            "-i",
+            *tty,
+            "-e",
+            f"SPLENT_APP={product}",
+            name(product),
+            "bash",
+            "-lc",
+            command,
+        ],
+        check=False,
+    )
+    return result.returncode

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/templates/product/product_ci_validate.yml.j2

@@ -48,3 +48,18 @@ jobs:
 
       - name: Generate the deploy artifacts
         run: splent product:build --no-image
+
+      # What the build writes is versioned, so a host deploys from a clone.
+      # A change to the features or the configuration that skipped
+      # product:build left them behind, and the CI said nothing.
+      - name: The versioned deploy artifacts are the ones the product generates
+        working-directory: {{ product_name }}
+        run: |
+          paths="deploy docker/requirements.lock splent.contracts.json docker/spl"
+          if [ -n "$(git status --porcelain -- $paths)" ]; then
+            git status --short -- $paths
+            git --no-pager diff --stat -- $paths
+            echo "These differ from what splent product:build generates."
+            echo "Run splent product:build and commit them."
+            exit 1
+          fi

{splent_cli-1.34.1 → splent_cli-1.35.0}/src/splent_cli/utils/cache_utils.py

@@ -58,6 +58,40 @@ def make_feature_readonly(path: str) -> None:
             _chmod(os.path.join(root, name), lambda m: m & ~_WRITE_BITS)
 
 
+def restore_snapshot(path: str) -> list[str]:
+    """Put back what in a cached feature differs from its tag; the paths restored.
+
+    A snapshot is its tag, read-only, but files can still drift: a CLI that
+    copied snapshots without their modes left nginx 1.2.0's entrypoint script
+    without its exec bit, and nginx restarted in a loop while every check
+    said the release was in place. Untracked files (the docker/.env a product
+    generates) are left alone. Only the restored files are made read-only
+    again, so that .env stays writable for product:env.
+    """
+    import subprocess
+
+    if not os.path.isdir(os.path.join(path, ".git")):
+        return []
+    status = subprocess.run(
+        ["git", "-C", path, "status", "--porcelain", "--untracked-files=no"],
+        capture_output=True,
+        text=True,
+    )
+    if status.returncode != 0:
+        return []
+    changed = [line[3:] for line in status.stdout.splitlines() if line.strip()]
+    if not changed:
+        return []
+    subprocess.run(
+        ["git", "-C", path, "checkout", "--", *changed],
+        capture_output=True,
+        text=True,
+    )
+    for rel in changed:
+        _chmod(os.path.join(path, rel), lambda m: m & ~_WRITE_BITS)
+    return changed
+
+
 def make_feature_writable(path: str) -> None:
     """Restore write permissions across a cached feature so it can be edited
     or deleted.

splent_cli-1.35.0/src/splent_cli/utils/feature_naming.py

@@ -0,0 +1,58 @@
+"""A feature is named for what it does, never for the product that uses it.
+
+auth_uvlhub, signup_uvlhub, profile_planner... each holds what one product
+wanted from a base feature: a slot, a setting, its own markup, its texts.
+No other product can choose it, and while it exists the base never grows the
+extension point every product needed. What a product alone wants belongs in
+the product (its templates, seeders and configuration); what several want
+belongs in the base, as a slot, a registry or a setting.
+"""
+
+from pathlib import Path
+
+from splent_cli.utils.template_drift import not_a_product_reason
+
+# Words a product's name carries that say nothing about which product it is.
+GENERIC_WORDS = {"app", "splent", "product", "site", "web"}
+
+
+def product_brands(workspace: str | Path) -> dict[str, str]:
+    """``{brand: product}`` for the products at the workspace root.
+
+    The brand is the product's name without its generic words: uvlhub for
+    uvlhub_splent, innosoft for innosoft_app, egc for egc_wiki.
+    """
+    brands: dict[str, str] = {}
+    root = Path(workspace)
+    if not root.is_dir():
+        return brands
+    for entry in root.iterdir():
+        if not entry.is_dir() or entry.name.startswith((".", "splent_")):
+            continue
+        if not_a_product_reason(entry) is not None:
+            continue
+        words = [w for w in entry.name.split("_") if w and w not in GENERIC_WORDS]
+        if words:
+            brands[words[0]] = entry.name
+    return brands
+
+
+def product_suffix(feature_name: str, workspace: str | Path) -> str | None:
+    """The product a feature's name ends with (``auth_uvlhub``: uvlhub_splent),
+    or None. A name that is the brand alone (``marketplace``) is a domain."""
+    short = feature_name.removeprefix("splent_feature_")
+    head, sep, last = short.rpartition("_")
+    if not sep or not head:
+        return None
+    return product_brands(workspace).get(last)
+
+
+def product_suffix_message(feature_name: str, product: str) -> str:
+    short = feature_name.removeprefix("splent_feature_")
+    return (
+        f"{short} is named after the product {product}. A feature is named for "
+        "what it does, so another product can choose it. What only this "
+        "product wants goes in the product (templates, seeders, "
+        "[tool.splent.config]); what several want goes in the base feature, "
+        "as a slot, a registry or a setting."
+    )