splent-feature-configurator 0.1.0__tar.gz

splent_feature_configurator-0.1.0/MANIFEST.in

@@ -0,0 +1,8 @@
+# Compiled frontend bundles
+recursive-include src/splent_io/splent_feature_configurator/assets/dist *.js *.css *.map
+
+# Jinja templates (feature views + hook fragments)
+recursive-include src/splent_io/splent_feature_configurator/templates *.html
+
+# Alembic migration config and scripts
+recursive-include src/splent_io/splent_feature_configurator/migrations *.py *.ini *.mako

splent_feature_configurator-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: splent_feature_configurator
+Version: 0.1.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown

splent_feature_configurator-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=80.3.1", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "splent_feature_configurator"
+version = "0.1.0"
+readme = "README.md"
+requires-python = ">=3.13"
+
+dependencies = [
+
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+exclude = ["*.tests", "*.tests.*"]
+
+[tool.splent]
+cli_version = "1.14.0"
+
+# ── Feature Contract (auto-generated) ────────────────────────────────────────
+# Do not edit manually — re-run `splent feature:contract --write` to refresh.
+# Preserved across refreshes: description, category, tags, env, and
+# requires.features_manual (dependencies invisible to static analysis).
+[tool.splent.contract]
+description = "UVL configurator for the SPLENT marketplace. Pick an SPL, select features with live variability validation, and get the exact splent commands to build the product"
+archetype = "light"
+
+[tool.splent.contract.provides]
+routes     = ["/configurator", "/configurator/<spl_name>", "/configurator/<spl_name>/validate"]
+blueprints = []
+models     = []
+commands   = []
+hooks      = []
+services   = ["ConfiguratorService"]
+signals    = []
+translations = []
+docker     = []
+
+[tool.splent.contract.requires]
+features = []
+features_optional = ["marketplace"]
+env_vars = []
+signals  = []
+
+[tool.splent.contract.extensible]
+services  = ["ConfiguratorService"]
+templates = ["configurator/configure.html", "configurator/index.html"]
+models    = []
+hooks     = []
+routes    = false

splent_feature_configurator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

splent_feature_configurator-0.1.0/src/splent_feature_configurator.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: splent_feature_configurator
+Version: 0.1.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown

splent_feature_configurator-0.1.0/src/splent_feature_configurator.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+MANIFEST.in
+pyproject.toml
+src/splent_feature_configurator.egg-info/PKG-INFO
+src/splent_feature_configurator.egg-info/SOURCES.txt
+src/splent_feature_configurator.egg-info/dependency_links.txt
+src/splent_feature_configurator.egg-info/top_level.txt
+src/splent_io/splent_feature_configurator/__init__.py
+src/splent_io/splent_feature_configurator/routes.py
+src/splent_io/splent_feature_configurator/services.py
+src/splent_io/splent_feature_configurator/templates/configurator/_macros.html
+src/splent_io/splent_feature_configurator/templates/configurator/configure.html
+src/splent_io/splent_feature_configurator/templates/configurator/index.html

splent_feature_configurator-0.1.0/src/splent_feature_configurator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

splent_feature_configurator-0.1.0/src/splent_feature_configurator.egg-info/top_level.txt

@@ -0,0 +1 @@
+splent_io

splent_feature_configurator-0.1.0/src/splent_io/splent_feature_configurator/__init__.py

@@ -0,0 +1,19 @@
+from splent_framework.blueprints.base_blueprint import create_blueprint
+from splent_framework.nav.nav_registry import register_nav_item
+from splent_framework.services.service_locator import register_service
+
+from splent_io.splent_feature_configurator.services import ConfiguratorService
+
+configurator_bp = create_blueprint(__name__)
+
+
+def init_feature(app):
+    register_service(app, "ConfiguratorService", ConfiguratorService)
+    # Public storefront navigation entry (composed per-derivation by the theme).
+    register_nav_item(
+        key="configurator", label="Configurator", href="/configurator", order=30
+    )
+
+
+def inject_context_vars(app):
+    return {}

splent_feature_configurator-0.1.0/src/splent_io/splent_feature_configurator/routes.py

@@ -0,0 +1,83 @@
+from flask import abort, jsonify, render_template, request
+from flask_babel import gettext as _
+
+from splent_io.splent_feature_configurator import configurator_bp
+from splent_framework.services.service_locator import service_proxy
+
+configurator_service = service_proxy("ConfiguratorService")
+
+
+def _violation_message(violation: dict) -> str:
+    """Translate a structured violation into a human-readable message."""
+    code = violation.get("code")
+    features = ", ".join(violation.get("features", []))
+    if code == "unknown_feature":
+        return _(
+            "Feature '%(feature)s' does not exist in this SPL",
+            feature=violation.get("feature"),
+        )
+    if code == "unknown_constraint_target":
+        return _(
+            "'%(required_by)s' requires '%(feature)s', which is not in this SPL model",
+            required_by=violation.get("required_by"),
+            feature=violation.get("feature"),
+        )
+    if code == "group_conflict":
+        return _(
+            "Group '%(group)s' is exclusive: choose only one of %(features)s",
+            group=violation.get("group"),
+            features=features,
+        )
+    if code == "group_required":
+        return _(
+            "Group '%(group)s' needs a choice: select one of %(features)s",
+            group=violation.get("group"),
+            features=features,
+        )
+    return str(code)
+
+
+@configurator_bp.route("/configurator", methods=["GET"])
+def index():
+    spls = configurator_service.list_spls()
+    return render_template("configurator/index.html", spls=spls)
+
+
+@configurator_bp.route("/configurator/<spl_name>", methods=["GET"])
+def configure(spl_name):
+    spl = configurator_service.get_spl(spl_name)
+    model = (spl or {}).get("model") or {}
+    if not model.get("features"):
+        abort(404)
+    # Model features absent from the index render marked as "external".
+    tree = configurator_service.feature_tree(
+        model, known_shorts=configurator_service.index_feature_shorts()
+    )
+    return render_template("configurator/configure.html", spl=spl, tree=tree)
+
+
+def _bad_request(message):
+    return jsonify({"error": message}), 400
+
+
+@configurator_bp.route("/configurator/<spl_name>/validate", methods=["POST"])
+def validate_selection(spl_name):
+    # Public anonymous endpoint: malformed JSON must yield a clean 400,
+    # never a 500 with a stacktrace.
+    payload = request.get_json(silent=True)
+    if not isinstance(payload, dict):
+        return _bad_request(_("Request body must be a JSON object"))
+    selected = payload.get("selected") or []
+    if not isinstance(selected, list) or not all(
+        isinstance(short, str) for short in selected
+    ):
+        return _bad_request(_("'selected' must be a list of feature names"))
+    product_name = payload.get("product_name") or ""
+    if not isinstance(product_name, str):
+        return _bad_request(_("'product_name' must be a string"))
+    result = configurator_service.validate(spl_name, selected, product_name)
+    if result is None:
+        abort(404)
+    for violation in result["violations"]:
+        violation["message"] = _violation_message(violation)
+    return jsonify(result)

splent_feature_configurator-0.1.0/src/splent_io/splent_feature_configurator/services.py

@@ -0,0 +1,335 @@
+"""ConfiguratorService — the UVL configurator behind the marketplace.
+
+Given an SPL from the marketplace index, it lets a caller pick a set of
+features and validates the selection against the SPL variability model
+(mandatory features, requires-constraints, alternative groups) without any
+external solver. For a valid selection it produces the exact ``splent``
+commands that build the product.
+
+The marketplace index is obtained through a SOFT dependency on the
+marketplace feature (``MarketplaceService`` via the service locator). When
+that feature is absent the service degrades gracefully and reads the index
+itself: local cache first, then ``SPLENT_INDEX_URL``.
+"""
+
+import json
+import os
+import re
+from pathlib import Path
+
+INDEX_SCHEMA = 1
+INDEX_URL_ENV = "SPLENT_INDEX_URL"
+WORKSPACE_ENV = "WORKING_DIR"
+DEFAULT_WORKSPACE = "/workspace"
+DEFAULT_ORG = "splent-io"
+DEFAULT_PRODUCT_NAME = "my_app"
+
+
+class ConfiguratorService:
+    """Plain service (no DB): index access + variability validation."""
+
+    # ── Marketplace index (soft dependency) ───────────────────────────
+
+    def get_index(self) -> dict | None:
+        """Best marketplace index available, or ``None``.
+
+        Order: marketplace feature → local cache → ``SPLENT_INDEX_URL``.
+        """
+        for source in (
+            self._index_from_marketplace,
+            self._index_from_cache,
+            self._index_from_url,
+        ):
+            index = source()
+            if index is not None:
+                return index
+        return None
+
+    def _index_from_marketplace(self) -> dict | None:
+        """Ask the marketplace feature for the index, if it is installed.
+
+        SOFT dependency: the marketplace feature may not be part of the
+        product (or may still be booting), so every failure — service not
+        registered, no request context, missing method — degrades to the
+        local fallbacks instead of breaking the configurator.
+        """
+        try:
+            from splent_framework.services.service_locator import service_proxy
+
+            marketplace_service = service_proxy("MarketplaceService")
+            for method_name in ("get_index", "index"):
+                method = getattr(marketplace_service, method_name, None)
+                if callable(method):
+                    index = method()
+                    if self._is_index(index):
+                        return index
+        except Exception:
+            return None
+        return None
+
+    def _cache_path(self) -> Path:
+        workspace = os.getenv(WORKSPACE_ENV, DEFAULT_WORKSPACE)
+        return Path(workspace) / ".splent_cache" / "marketplace" / "index.json"
+
+    def _index_from_cache(self) -> dict | None:
+        try:
+            data = json.loads(self._cache_path().read_text())
+        except (OSError, ValueError):
+            return None
+        return data if self._is_index(data) else None
+
+    def _index_from_url(self) -> dict | None:
+        url = os.getenv(INDEX_URL_ENV)
+        if not url:
+            return None
+        import urllib.error
+        import urllib.request
+
+        request = urllib.request.Request(
+            url, headers={"User-Agent": "splent-feature-configurator"}
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=10) as response:
+                data = json.loads(response.read().decode())
+        except (urllib.error.URLError, TimeoutError, ValueError):
+            return None
+        if not self._is_index(data):
+            return None
+        try:  # best-effort: next request is instant and works offline
+            path = self._cache_path()
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+        except OSError:
+            pass
+        return data
+
+    @staticmethod
+    def _is_index(data) -> bool:
+        return isinstance(data, dict) and data.get("schema") == INDEX_SCHEMA
+
+    # ── SPL queries ───────────────────────────────────────────────────
+
+    def list_spls(self) -> list[dict]:
+        """SPL summaries for the chooser page."""
+        index = self.get_index() or {}
+        summaries = []
+        for spl in index.get("spls", []):
+            model = spl.get("model") or {}
+            summaries.append(
+                {
+                    "name": spl.get("name"),
+                    "description": spl.get("description", ""),
+                    "has_model": bool(model.get("features")),
+                    "feature_count": len(model.get("features") or {}),
+                }
+            )
+        return summaries
+
+    def get_spl(self, name: str) -> dict | None:
+        index = self.get_index() or {}
+        for spl in index.get("spls", []):
+            if spl.get("name") == name:
+                return spl
+        return None
+
+    def index_feature_shorts(self) -> set[str]:
+        """Short names of the features published in the marketplace index.
+
+        An SPL model may reference features that are not published in the
+        index (e.g. only available on GitHub/PyPI); callers use this set to
+        mark them as *external* instead of linking to a missing detail page.
+        """
+        index = self.get_index() or {}
+        return {
+            feature.get("short")
+            for feature in index.get("features") or []
+            if isinstance(feature, dict) and feature.get("short")
+        }
+
+    def feature_tree(self, model: dict, known_shorts: set[str] | None = None) -> dict:
+        """Shape the flat model into what the configurator page renders.
+
+        Returns ``{"mandatory": [...], "optional": [...], "groups": [...]}``
+        where each feature dict carries ``short`` plus its index attributes,
+        and each group carries ``owner``, ``kind``, ``members`` and
+        ``required`` (True when its members sit under ``mandatory``).
+
+        When ``known_shorts`` is given, every feature also carries
+        ``external``: True for model features absent from the index.
+        """
+        features = model.get("features") or {}
+
+        def entry(short: str) -> dict:
+            info = {"short": short, **features[short]}
+            if known_shorts is not None:
+                info["external"] = short not in known_shorts
+            return info
+
+        groups = []
+        grouped: set[str] = set()
+        for group in model.get("alternative_groups") or []:
+            members = [m for m in group.get("members", []) if m in features]
+            grouped.update(members)
+            groups.append(
+                {
+                    "owner": group.get("owner"),
+                    "kind": group.get("kind", "alternative"),
+                    "members": [entry(m) for m in members],
+                    "required": any(
+                        features[m].get("presence") == "mandatory" for m in members
+                    ),
+                }
+            )
+        mandatory, optional = [], []
+        for short, info in features.items():
+            if short in grouped:
+                continue
+            bucket = mandatory if info.get("presence") == "mandatory" else optional
+            bucket.append(entry(short))
+        return {"mandatory": mandatory, "optional": optional, "groups": groups}
+
+    # ── Variability validation (own logic, no solver, no network) ─────
+
+    def validate_selection(self, model: dict, selected: list[str]) -> dict:
+        """Validate ``selected`` against the SPL model.
+
+        Applies, in order:
+
+        1. Mandatory features outside alternative groups are always part of
+           the product (auto-added when missing).
+        2. Transitive closure of the requires-constraints ``a => b``
+           (auto-adds every implied feature).
+        3. Alternative groups: an ``alternative`` group admits at most one
+           member; a required group (members under ``mandatory``) admits no
+           empty choice.
+
+        Returns ``{"selection_valid", "selection", "auto_added",
+        "violations"}`` where violations are structured dicts
+        (``code`` + context) so callers can translate them.
+        """
+        features = model.get("features") or {}
+        violations: list[dict] = []
+        auto_added: list[str] = []
+        chosen: set[str] = set()
+
+        for short in selected or []:
+            if short in features:
+                chosen.add(short)
+            else:
+                violations.append({"code": "unknown_feature", "feature": short})
+
+        grouped = {
+            member
+            for group in model.get("alternative_groups") or []
+            for member in group.get("members", [])
+        }
+
+        # 1. mandatory features (outside groups) are always included
+        for short, info in features.items():
+            if (
+                info.get("presence") == "mandatory"
+                and short not in grouped
+                and short not in chosen
+            ):
+                chosen.add(short)
+                auto_added.append(short)
+
+        # 2. transitive closure of a => b constraints
+        constraints = [
+            pair for pair in (model.get("constraints") or []) if len(pair) == 2
+        ]
+        for a, b in constraints:
+            if b not in features:
+                violations.append(
+                    {"code": "unknown_constraint_target", "feature": b, "required_by": a}
+                )
+        applicable = [(a, b) for a, b in constraints if b in features]
+        changed = True
+        while changed:
+            changed = False
+            for a, b in applicable:
+                if a in chosen and b not in chosen:
+                    chosen.add(b)
+                    auto_added.append(b)
+                    changed = True
+
+        # 3. alternative groups
+        for group in model.get("alternative_groups") or []:
+            members = [m for m in group.get("members", []) if m in features]
+            chosen_members = [m for m in members if m in chosen]
+            required = any(
+                features[m].get("presence") == "mandatory" for m in members
+            )
+            if group.get("kind", "alternative") == "alternative" and len(chosen_members) > 1:
+                violations.append(
+                    {
+                        "code": "group_conflict",
+                        "group": group.get("owner"),
+                        "features": chosen_members,
+                    }
+                )
+            if required and not chosen_members:
+                violations.append(
+                    {
+                        "code": "group_required",
+                        "group": group.get("owner"),
+                        "features": members,
+                    }
+                )
+
+        return {
+            "selection_valid": not violations,
+            # final selection in model declaration order (mandatory first)
+            "selection": [s for s in features if s in chosen],
+            "auto_added": auto_added,
+            "violations": violations,
+        }
+
+    # ── Command generation ────────────────────────────────────────────
+
+    def commands_for(
+        self, spl_name: str, model: dict, selection: list[str], product_name: str
+    ) -> list[str]:
+        """The exact splent commands that build the configured product."""
+        features = model.get("features") or {}
+        name = self.normalize_product_name(product_name)
+        commands = [
+            f"splent product:create {name} --spl {spl_name}",
+            f"splent product:select {name}",
+        ]
+        for short in selection:
+            info = features.get(short) or {}
+            package = info.get("package")
+            if not package:
+                continue
+            org = info.get("org") or DEFAULT_ORG
+            # feature:install clones the repo when it is not in the workspace
+            # yet (feature:add only registers already-cloned editable repos),
+            # so the recipe works for marketplace users starting from scratch.
+            commands.append(f"splent feature:install {org}/{package}")
+        commands.append("splent product:resolve")
+        commands.append("splent product:derive --dev")
+        return commands
+
+    @staticmethod
+    def normalize_product_name(name: str) -> str:
+        slug = re.sub(r"[^a-z0-9_]+", "_", (name or "").strip().lower()).strip("_")
+        return slug or DEFAULT_PRODUCT_NAME
+
+    # ── Entry point used by the routes ────────────────────────────────
+
+    def validate(
+        self, spl_name: str, selected: list[str], product_name: str = ""
+    ) -> dict | None:
+        """Full validation for one SPL. ``None`` when the SPL is unknown."""
+        spl = self.get_spl(spl_name)
+        model = (spl or {}).get("model") or {}
+        if not model.get("features"):
+            return None
+        result = self.validate_selection(model, selected)
+        result["commands"] = (
+            self.commands_for(spl_name, model, result["selection"], product_name)
+            if result["selection_valid"]
+            else []
+        )
+        return result

splent_feature_configurator-0.1.0/src/splent_io/splent_feature_configurator/templates/configurator/_macros.html

@@ -0,0 +1,24 @@
+{# Configurator building blocks (feather icons as inline SVG).
+   All styling lives in skin_store.css. #}
+
+{% set ICON_PATHS = {
+    "layers": '<polygon points="12 2 2 7 12 12 22 7 12 2"></polygon><polyline points="2 17 12 22 22 17"></polyline><polyline points="2 12 12 17 22 12"></polyline>',
+    "check": '<polyline points="20 6 9 17 4 12"></polyline>',
+    "check-circle": '<path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"></path><polyline points="22 4 12 14.01 9 11.01"></polyline>',
+    "alert-triangle": '<path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"></path><line x1="12" y1="9" x2="12" y2="13"></line><line x1="12" y1="17" x2="12.01" y2="17"></line>',
+    "x-circle": '<circle cx="12" cy="12" r="10"></circle><line x1="15" y1="9" x2="9" y2="15"></line><line x1="9" y1="9" x2="15" y2="15"></line>',
+    "copy": '<rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>',
+    "terminal": '<polyline points="4 17 10 11 4 5"></polyline><line x1="12" y1="19" x2="20" y2="19"></line>',
+    "arrow-right": '<line x1="5" y1="12" x2="19" y2="12"></line><polyline points="12 5 19 12 12 19"></polyline>',
+    "arrow-left": '<line x1="19" y1="12" x2="5" y2="12"></line><polyline points="12 19 5 12 12 5"></polyline>',
+    "git-branch": '<line x1="6" y1="3" x2="6" y2="15"></line><circle cx="18" cy="6" r="3"></circle><circle cx="6" cy="18" r="3"></circle><path d="M18 9a9 9 0 0 1-9 9"></path>',
+    "sliders": '<line x1="4" y1="21" x2="4" y2="14"></line><line x1="4" y1="10" x2="4" y2="3"></line><line x1="12" y1="21" x2="12" y2="12"></line><line x1="12" y1="8" x2="12" y2="3"></line><line x1="20" y1="21" x2="20" y2="16"></line><line x1="20" y1="12" x2="20" y2="3"></line><line x1="1" y1="14" x2="7" y2="14"></line><line x1="9" y1="8" x2="15" y2="8"></line><line x1="17" y1="16" x2="23" y2="16"></line>',
+    "plus": '<line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line>',
+    "lock": '<rect x="3" y="11" width="18" height="11" rx="2" ry="2"></rect><path d="M7 11V7a5 5 0 0 1 10 0v4"></path>',
+    "zap": '<polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"></polygon>',
+} %}
+
+{% macro icon(name, size=16) -%}
+<svg class="store-icon" width="{{ size }}" height="{{ size }}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">{{ ICON_PATHS.get(name, "") | safe }}</svg>
+{%- endmacro %}
+

splent_feature_configurator-0.1.0/src/splent_io/splent_feature_configurator/templates/configurator/configure.html

@@ -0,0 +1,312 @@
+{% extends "public_base.html" %}
+{% import "configurator/_macros.html" as ck %}
+
+{% block title %}{{ _("Configurator") }} · {{ spl.name }}{% endblock %}
+
+{% block hero %}
+<section class="store-hero store-hero--slim">
+    <div class="container">
+        <h1 class="store-hero__title">{{ spl.name }}</h1>
+        {% if spl.description %}<p class="store-hero__subtitle">{{ spl.description }}</p>{% endif %}
+    </div>
+</section>
+{% endblock %}
+
+{% block content %}
+<div class="container"
+     id="configurator"
+     data-validate-url="{{ url_for('configurator.validate_selection', spl_name=spl.name) }}">
+
+    <nav class="store-crumbs">
+        <a class="store-backlink" href="{{ url_for('configurator.index') }}">
+            {{ ck.icon("arrow-left", 14) }}{{ _("All product lines") }}
+        </a>
+    </nav>
+
+    <div class="cfg-cols">
+
+        {# ── Step 2: feature selection ──────────────────────────────────── #}
+        <div>
+            <div class="cfg-field">
+                <label for="cfg-product-name" class="cfg-field__label">{{ _("Product name") }}</label>
+                <input type="text" class="cfg-field__input" id="cfg-product-name"
+                       value="my_app" autocomplete="off" spellcheck="false"
+                       aria-describedby="cfg-product-name-help">
+                <p id="cfg-product-name-help" class="cfg-field__help">
+                    {{ _("Lowercase letters, digits and underscores.") }}
+                </p>
+            </div>
+
+            {% if tree.mandatory %}
+            <section class="cfg-section">
+                <h2 class="cfg-section__title">{{ ck.icon("lock") }}{{ _("Core features") }}</h2>
+                <p class="cfg-section__hint">{{ _("Always included in every product of this line.") }}</p>
+                <div class="cfg-options">
+                    {% for feature in tree.mandatory %}
+                    <label class="cfg-option cfg-option--locked" for="cfg-f-{{ feature.short }}">
+                        <input class="cfg-option__input" type="checkbox" checked disabled
+                               id="cfg-f-{{ feature.short }}" data-feature="{{ feature.short }}">
+                        <span class="cfg-option__box">
+                            <span class="cfg-option__mark">{{ ck.icon("check", 12) }}</span>
+                            <span>
+                                <span class="cfg-option__name">{{ feature.short }}{% if feature.external %} <span class="cfg-option__ext">{{ _("external") }}</span>{% endif %}</span>
+                                <span class="cfg-option__pkg">{{ feature.org }}/{{ feature.package }}</span>
+                            </span>
+                        </span>
+                    </label>
+                    {% endfor %}
+                </div>
+            </section>
+            {% endif %}
+
+            {% for group in tree.groups %}
+            <section class="cfg-section">
+                <h2 class="cfg-section__title">{{ ck.icon("git-branch") }}{{ group.owner }}</h2>
+                <p class="cfg-section__hint">
+                    {% if group.required %}
+                    {{ _("Exclusive group. Pick exactly one.") }}
+                    {% else %}
+                    {{ _("Exclusive group. Pick one at most.") }}
+                    {% endif %}
+                </p>
+                <div class="cfg-options">
+                    {% for member in group.members %}
+                    <label class="cfg-option cfg-option--radio" for="cfg-f-{{ member.short }}">
+                        <input class="cfg-option__input" type="radio"
+                               name="cfg-group-{{ group.owner }}" value="{{ member.short }}"
+                               id="cfg-f-{{ member.short }}" data-feature="{{ member.short }}"
+                               {% if group.required and loop.first %}checked{% endif %}>
+                        <span class="cfg-option__box">
+                            <span class="cfg-option__mark">{{ ck.icon("check", 12) }}</span>
+                            <span>
+                                <span class="cfg-option__name">{{ member.short }}{% if member.external %} <span class="cfg-option__ext">{{ _("external") }}</span>{% endif %}</span>
+                                <span class="cfg-option__pkg">{{ member.org }}/{{ member.package }}</span>
+                            </span>
+                        </span>
+                    </label>
+                    {% endfor %}
+                    {% if not group.required %}
+                    <label class="cfg-option cfg-option--radio" for="cfg-g-{{ group.owner }}-none">
+                        <input class="cfg-option__input" type="radio"
+                               name="cfg-group-{{ group.owner }}" value=""
+                               id="cfg-g-{{ group.owner }}-none" checked>
+                        <span class="cfg-option__box">
+                            <span class="cfg-option__mark">{{ ck.icon("check", 12) }}</span>
+                            <span>
+                                <span class="cfg-option__name">{{ _("None") }}</span>
+                                <span class="cfg-option__pkg">{{ _("skip this group") }}</span>
+                            </span>
+                        </span>
+                    </label>
+                    {% endif %}
+                </div>
+            </section>
+            {% endfor %}
+
+            {% if tree.optional %}
+            <section class="cfg-section">
+                <h2 class="cfg-section__title">{{ ck.icon("plus") }}{{ _("Optional features") }}</h2>
+                <p class="cfg-section__hint">{{ _("Dependencies are added automatically as you select.") }}</p>
+                <div class="cfg-options">
+                    {% for feature in tree.optional %}
+                    <label class="cfg-option" for="cfg-f-{{ feature.short }}" data-auto-label="{{ _('required by your selection') }}">
+                        <input class="cfg-option__input" type="checkbox"
+                               id="cfg-f-{{ feature.short }}" data-feature="{{ feature.short }}">
+                        <span class="cfg-option__box">
+                            <span class="cfg-option__mark">{{ ck.icon("check", 12) }}</span>
+                            <span>
+                                <span class="cfg-option__name">{{ feature.short }}{% if feature.external %} <span class="cfg-option__ext">{{ _("external") }}</span>{% endif %}</span>
+                                <span class="cfg-option__pkg">{{ feature.org }}/{{ feature.package }}</span>
+                            </span>
+                        </span>
+                    </label>
+                    {% endfor %}
+                </div>
+            </section>
+            {% endif %}
+        </div>
+
+        {# ── Step 3: live validation + commands (sticky) ────────────────── #}
+        <aside class="cfg-panel">
+
+            <div id="cfg-status-valid" class="cfg-status cfg-status--valid is-hidden" role="status">
+                <span class="cfg-status__head">{{ ck.icon("check-circle", 18) }}{{ _("Valid selection") }}</span>
+            </div>
+
+            <div id="cfg-status-invalid" class="cfg-status cfg-status--invalid is-hidden" role="alert">
+                <span class="cfg-status__head">{{ ck.icon("x-circle", 18) }}{{ _("Invalid selection") }}</span>
+                <ul id="cfg-violations"></ul>
+            </div>
+
+            <div id="cfg-status-error" class="cfg-status cfg-status--error is-hidden" role="alert">
+                <span class="cfg-status__head">{{ ck.icon("alert-triangle", 18) }}{{ _("Could not validate the selection. Check your connection and try again.") }}</span>
+            </div>
+
+            <section id="cfg-auto-section" class="cfg-aside-block cfg-aside-block--auto is-hidden">
+                <h3 class="cfg-aside-block__title">{{ ck.icon("zap") }}{{ _("Added automatically") }}</h3>
+                <p class="cfg-aside-block__hint">{{ _("Required by your selection or by the product line.") }}</p>
+                <div id="cfg-auto" class="store-chipset"></div>
+            </section>
+
+            <section id="cfg-commands-section" class="cfg-aside-block is-hidden">
+                <h3 class="cfg-aside-block__title">{{ ck.icon("terminal") }}{{ _("Build commands") }}</h3>
+                <p class="cfg-aside-block__hint">{{ _("Run these in your SPLENT workspace.") }}</p>
+                <div class="store-terminal store-terminal--lines">
+                    <pre id="cfg-commands"></pre>
+                </div>
+                <div class="cfg-terminal-actions">
+                    <button type="button" id="cfg-copy" class="store-copy"
+                            data-label="{{ _('Copy commands') }}" data-label-copied="{{ _('Copied') }}">
+                        {{ ck.icon("copy") }}<span id="cfg-copy-label">{{ _("Copy commands") }}</span>
+                    </button>
+                </div>
+            </section>
+
+        </aside>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+(function () {
+    "use strict";
+
+    var root = document.getElementById("configurator");
+    if (!root) { return; }
+
+    var validateUrl = root.dataset.validateUrl;
+    var nameInput = document.getElementById("cfg-product-name");
+    var statusValid = document.getElementById("cfg-status-valid");
+    var statusInvalid = document.getElementById("cfg-status-invalid");
+    var statusError = document.getElementById("cfg-status-error");
+    var violationsList = document.getElementById("cfg-violations");
+    var autoSection = document.getElementById("cfg-auto-section");
+    var autoBox = document.getElementById("cfg-auto");
+    var commandsSection = document.getElementById("cfg-commands-section");
+    var commandsPre = document.getElementById("cfg-commands");
+    var copyButton = document.getElementById("cfg-copy");
+    var copyLabel = document.getElementById("cfg-copy-label");
+
+    function collectSelected() {
+        var selected = [];
+        root.querySelectorAll("input[data-feature]").forEach(function (input) {
+            if (input.checked && input.dataset.auto !== "1") {
+                selected.push(input.dataset.feature);
+            }
+        });
+        return selected;
+    }
+
+    function paintAutoAdded(autoAdded) {
+        // Auto-required features show as checked + locked in the tree itself,
+        // so "comments pulls in post" is visible where the user is looking.
+        root.querySelectorAll("input[data-feature]").forEach(function (input) {
+            var card = input.closest("label") || input.parentElement;
+            var isAuto = autoAdded.indexOf(input.dataset.feature) !== -1;
+            if (isAuto && !input.checked) {
+                input.checked = true;
+                input.dataset.auto = "1";
+                input.disabled = true;
+                if (card) { card.classList.add("cfg-option--auto"); }
+            } else if (!isAuto && input.dataset.auto === "1") {
+                input.checked = false;
+                delete input.dataset.auto;
+                input.disabled = false;
+                if (card) { card.classList.remove("cfg-option--auto"); }
+            }
+        });
+    }
+
+    function show(el) { el.classList.remove("is-hidden"); }
+    function hide(el) { el.classList.add("is-hidden"); }
+
+    function render(data) {
+        hide(statusError);
+
+        violationsList.textContent = "";
+        (data.violations || []).forEach(function (violation) {
+            var item = document.createElement("li");
+            item.textContent = violation.message || violation.code;
+            violationsList.appendChild(item);
+        });
+
+        paintAutoAdded(data.auto_added || []);
+
+        autoBox.textContent = "";
+        (data.auto_added || []).forEach(function (short) {
+            var badge = document.createElement("span");
+            badge.className = "store-chip store-chip--amber";
+            badge.textContent = short;
+            autoBox.appendChild(badge);
+        });
+        if ((data.auto_added || []).length) { show(autoSection); } else { hide(autoSection); }
+
+        if (data.selection_valid) {
+            show(statusValid);
+            hide(statusInvalid);
+            commandsPre.textContent = (data.commands || []).join("\n");
+            show(commandsSection);
+        } else {
+            hide(statusValid);
+            show(statusInvalid);
+            hide(commandsSection);
+        }
+    }
+
+    var timer = null;
+    var requestSeq = 0;
+
+    function validate() {
+        var seq = ++requestSeq;
+        fetch(validateUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                selected: collectSelected(),
+                product_name: nameInput ? nameInput.value : ""
+            })
+        })
+            .then(function (response) {
+                if (!response.ok) { throw new Error("HTTP " + response.status); }
+                return response.json();
+            })
+            .then(function (data) {
+                if (seq === requestSeq) { render(data); }
+            })
+            .catch(function () {
+                if (seq === requestSeq) {
+                    hide(statusValid);
+                    hide(statusInvalid);
+                    hide(commandsSection);
+                    hide(autoSection);
+                    show(statusError);
+                }
+            });
+    }
+
+    function scheduleValidate() {
+        clearTimeout(timer);
+        timer = setTimeout(validate, 200);
+    }
+
+    root.addEventListener("change", scheduleValidate);
+    if (nameInput) { nameInput.addEventListener("input", scheduleValidate); }
+
+    if (copyButton) {
+        copyButton.addEventListener("click", function () {
+            var text = commandsPre.textContent;
+            if (!navigator.clipboard) { return; }
+            navigator.clipboard.writeText(text).then(function () {
+                copyLabel.textContent = copyButton.dataset.labelCopied;
+                setTimeout(function () {
+                    copyLabel.textContent = copyButton.dataset.label;
+                }, 1500);
+            });
+        });
+    }
+
+    validate();
+})();
+</script>
+{% endblock %}

splent_feature_configurator-0.1.0/src/splent_io/splent_feature_configurator/templates/configurator/index.html

@@ -0,0 +1,46 @@
+{% extends "public_base.html" %}
+{% import "configurator/_macros.html" as ck %}
+
+{% block title %}{{ _("Configurator") }} · {{ site.name }}{% endblock %}
+
+{% block hero %}
+<section class="store-hero store-hero--slim">
+    <div class="container">
+        <h1 class="store-hero__title">{{ _("Product configurator") }}</h1>
+        <p class="store-hero__subtitle">{{ _("Pick a line, select its features with live validation, and copy the exact splent commands.") }}</p>
+    </div>
+</section>
+{% endblock %}
+
+{% block content %}
+<div class="container">
+    {% if spls %}
+    <div class="cfg-spl-grid">
+        {% for spl in spls %}
+        <article class="cfg-spl-card">
+            <header class="store-spl-card__head">
+                {{ ck.icon("layers", 22) }}
+                <h2 class="store-spl-card__name">{{ spl.name }}</h2>
+            </header>
+            <p class="cfg-spl-card__desc">{{ spl.description or _("No description available.") }}</p>
+            <footer class="cfg-spl-card__foot">
+                {% if spl.has_model %}
+                <span class="cfg-spl-card__count">{{ _("%(count)s features", count=spl.feature_count) }}</span>
+                <a class="btn btn-primary btn-sm" href="{{ url_for('configurator.configure', spl_name=spl.name) }}">
+                    {{ _("Configure") }} {{ ck.icon("arrow-right", 14) }}
+                </a>
+                {% else %}
+                <span class="store-badge">{{ _("Model not published") }}</span>
+                {% endif %}
+            </footer>
+        </article>
+        {% endfor %}
+    </div>
+    {% else %}
+    <div class="store-empty">
+        {{ ck.icon("alert-triangle", 34) }}
+        <p>{{ _("The marketplace index is not available right now. Try again once the index has been built or SPLENT_INDEX_URL is configured.") }}</p>
+    </div>
+    {% endif %}
+</div>
+{% endblock %}