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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.13.0
+Version: 1.15.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.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.13.0"
+version = "1.15.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.15.0}/src/splent_cli/cli.py

@@ -3,9 +3,7 @@ import os
 import click
 from dotenv import load_dotenv
 
-from splent_cli.utils.dynamic_imports import get_app
 from splent_cli.utils.command_loader import load_commands
-from splent_cli.utils.db_utils import check_db_connection
 
 load_dotenv()
 
@@ -40,6 +38,8 @@ class SPLENTCLI(click.Group):
 
         self._feature_cmds_cache: dict[str, click.BaseCommand] = {}
         try:
+            from splent_cli.utils.dynamic_imports import get_app
+
             app = get_app()
             with app.app_context():
                 registry = app.extensions.get("splent_feature_commands", {})
@@ -84,6 +84,9 @@ class SPLENTCLI(click.Group):
         command = self.get_command(ctx, cmd_name)
 
         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()
             if getattr(command, "requires_db", False):
                 if not check_db_connection(app):
@@ -109,6 +112,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.15.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.15.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.15.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.15.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: