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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.34.1"
+version = "1.36.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.36.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.36.0}/src/splent_cli/commands/check/check_contracts.py

@@ -18,6 +18,7 @@ import tomllib
 
 from splent_cli.services import context, marketplace, spl_store
 from splent_cli.utils import forge
+from splent_cli.utils.feature_requirements import requirement_names
 
 
 def _snapshot_version_key(pyproject_path: Path) -> tuple:
@@ -58,9 +59,10 @@ def _local_contract_requires(workspace: str, package: str) -> list[str] | None:
             .get("contract", {})
             .get("requires", {})
         )
+        # Names only: an entry may carry a version specifier ("auth>=1.20.0").
         return {
-            "features": requires.get("features", []),
-            "optional": requires.get("features_optional", []),
+            "features": requirement_names(requires.get("features", [])),
+            "optional": requirement_names(requires.get("features_optional", [])),
         }
     return None
 

{splent_cli-1.34.1 → splent_cli-1.36.0}/src/splent_cli/commands/export/export_puml.py

@@ -22,6 +22,7 @@ import click
 from splent_cli.commands.uvl.uvl_utils import extract_implications_from_uvl_text
 from splent_cli.services import context
 from splent_cli.utils import proc
+from splent_cli.utils.feature_requirements import requirement_names
 from splent_cli.utils.feature_utils import normalize_namespace
 from splent_framework.utils.pyproject_reader import PyprojectReader
 
@@ -381,7 +382,9 @@ def _generate_feature_puml(product_name: str, uvl_data: dict, contracts: dict) -
             env_vars = requires.get("env_vars", [])
             if env_vars:
                 details.append(f"**Env vars**: {_puml_join(env_vars)}")
-            req_features = requires.get("features", [])
+            # Names only: an entry may carry a version specifier
+            # ("auth>=1.20.0"), which the diagram has no use for.
+            req_features = requirement_names(requires.get("features", []))
             if req_features:
                 details.append(f"**Requires**: {_puml_join(req_features)}")
 

{splent_cli-1.34.1 → splent_cli-1.36.0}/src/splent_cli/commands/feature/feature_add.py

@@ -16,6 +16,7 @@ from splent_cli.utils.feature_utils import (
 from splent_cli.utils.io_utils import load_toml
 from splent_cli.utils.toml_edit import write_toml
 from splent_cli.utils.manifest import feature_key, remove_feature, set_feature_state
+from splent_cli.utils.ci_workflow import keeps_ci_workflows
 
 
 @click.command(
@@ -35,6 +36,7 @@ from splent_cli.utils.manifest import feature_key, remove_feature, set_feature_s
     flag_value="prod",
     help="Add to features_prod (production only).",
 )
+@keeps_ci_workflows
 def feature_add(full_name, env_scope):
     """
     Adds a local feature (no version, no repo) to the current SPLENT product.

{splent_cli-1.34.1 → splent_cli-1.36.0}/src/splent_cli/commands/feature/feature_attach.py

@@ -17,6 +17,7 @@ from splent_cli.utils.feature_utils import (
 from splent_cli.utils.io_utils import load_toml
 from splent_cli.utils.toml_edit import write_toml
 from splent_cli.utils.manifest import feature_key, remove_feature, set_feature_state
+from splent_cli.utils.ci_workflow import keeps_ci_workflows
 
 
 def _target_lists(env_scope, declared):
@@ -50,6 +51,7 @@ def _target_lists(env_scope, declared):
     flag_value="prod",
     help="Add to features_prod (production only).",
 )
+@keeps_ci_workflows
 def feature_attach(feature_identifier, version, env_scope):
     """
     Attach a cached feature version to the current product.

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

@@ -11,6 +11,11 @@ import click
 from pathlib import Path
 
 from splent_cli.services import context
+from splent_cli.utils.feature_requirements import (
+    parse_requirement,
+    requirement_names,
+    satisfies,
+)
 from splent_cli.utils.feature_utils import normalize_namespace
 from splent_cli.utils.io_utils import load_toml
 
@@ -118,7 +123,9 @@ def _read_contract(cache_path: Path) -> dict:
             "docker": raw.get("provides", {}).get("docker", []),
         },
         "requires": {
-            "features": raw.get("requires", {}).get("features", []),
+            # Names only: an entry may carry a version specifier
+            # ("auth>=1.20.0"), which version_floor_findings reads.
+            "features": requirement_names(raw.get("requires", {}).get("features", [])),
             "env_vars": raw.get("requires", {}).get("env_vars", []),
         },
     }
@@ -266,8 +273,16 @@ def _resolve_all_product_features(
     if not features_raw:
         raise SystemExit("  No features declared in pyproject.toml.")
 
+    return _resolve_entries(features_raw, product_dir, workspace)
+
+
+def _resolve_entries(
+    entries: list[str], product_dir: str, workspace: str
+) -> list[tuple[str, Path]]:
+    """Feature entries of the product as ``(label, path)``, skipping, with a
+    warning, those that are not in the workspace."""
     resolved = []
-    for entry in features_raw:
+    for entry in entries:
         ns, name, version = _parse_pyproject_entry(entry)
         label = f"{name}@{version}" if version else name
         if version:
@@ -411,16 +426,308 @@ def _analyse_all(labeled_contracts: list[tuple[str, dict]]) -> list[dict]:
     return sorted(findings, key=lambda f: SEVERITY_ORDER[f["severity"]])
 
 
-def run_all_product_check(workspace: str, product_dir: str) -> list[dict]:
-    """Run the full product compatibility check. Returns findings list."""
+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 _written_requires(path: Path) -> dict[str, list]:
+    """The requires lists of a feature's contract, entries as written."""
+    pyproject = path / "pyproject.toml"
+    if not pyproject.exists():
+        return {}
+    data = load_toml(pyproject, what=f"pyproject.toml for {path.name}")
+    requires = (
+        data.get("tool", {}).get("splent", {}).get("contract", {}).get("requires", {})
+    )
+    if not isinstance(requires, dict):
+        return {}
+    return {
+        key: requires.get(key)
+        for key in ("features", "features_manual", "features_optional")
+        if isinstance(requires.get(key), list)
+    }
+
+
+def _project_version(path: Path) -> str | None:
+    pyproject = path / "pyproject.toml"
+    if not pyproject.exists():
+        return None
+    data = load_toml(pyproject, what=f"pyproject.toml for {path.name}")
+    version = data.get("project", {}).get("version")
+    return str(version) if version else None
+
+
+def version_floor_findings(labeled_paths: list[tuple[str, Path]]) -> list[dict]:
+    """Requirements whose version specifier the product's copy does not meet.
+
+    A requires entry may say which releases of another feature it works with
+    (``auth>=1.20.0``), because it calls an API that release added. Against
+    a version the product pins, a miss is an error: the product would run a
+    release the feature was never written for. Against an editable feature
+    it is a warning, read from the working copy's ``[project].version``,
+    since that copy is not released yet. A specifier that is not PEP 440 is
+    an error, and a feature the product lacks is reported elsewhere.
+    """
+    present: dict[str, tuple[str, Path, str | None]] = {}
+    for label, path in labeled_paths:
+        name, _, version = label.partition("@")
+        present[name.removeprefix("splent_feature_")] = (label, path, version or None)
+
+    findings: list[dict] = []
+    for label, path in labeled_paths:
+        short = label.split("@", 1)[0].removeprefix("splent_feature_")
+        seen: set[tuple[str, str]] = set()
+        for key, entries in _written_requires(path).items():
+            for entry in entries:
+                try:
+                    req = parse_requirement(entry)
+                except ValueError as e:
+                    findings.append(
+                        {
+                            "severity": "error",
+                            "field": "requires",
+                            "values": [str(entry)],
+                            "features": [label],
+                            "message": f"In {short}'s requires.{key}, {e}.",
+                        }
+                    )
+                    continue
+                if not req.specifier or (req.name, req.specifier) in seen:
+                    continue
+                seen.add((req.name, req.specifier))
+                target = present.get(req.name)
+                if target is None:
+                    continue
+                target_label, target_path, pinned = target
+                if pinned:
+                    met = satisfies(req.specifier, pinned)
+                    if met is None:
+                        findings.append(
+                            {
+                                "severity": "warning",
+                                "field": "requires",
+                                "values": [str(req)],
+                                "features": [label, target_label],
+                                "message": (
+                                    f"{short} requires {req}, and the product pins "
+                                    f"{req.name} at {pinned}, which is not a "
+                                    "version that can be compared."
+                                ),
+                            }
+                        )
+                    elif not met:
+                        findings.append(
+                            {
+                                "severity": "error",
+                                "field": "requires",
+                                "values": [str(req)],
+                                "features": [label, target_label],
+                                "message": (
+                                    f"{short} requires {req}, but the product pins "
+                                    f"{req.name} at {pinned}. Pin a release of "
+                                    f"{req.name} that satisfies it."
+                                ),
+                            }
+                        )
+                    continue
+                working = _project_version(target_path)
+                met = satisfies(req.specifier, working) if working else None
+                if met is False or met is None:
+                    found = (
+                        f"the working copy of {req.name} is {working}"
+                        if working
+                        else f"the version of the working copy of {req.name} "
+                        "cannot be read"
+                    )
+                    findings.append(
+                        {
+                            "severity": "warning",
+                            "field": "requires",
+                            "values": [str(req)],
+                            "features": [label, target_label],
+                            "message": (
+                                f"{short} requires {req}, and {found} "
+                                f"([project].version). Release {req.name} at a "
+                                "version that satisfies it before the product "
+                                "pins it."
+                            ),
+                        }
+                    )
+    return findings
+
+
+def _environment_only_features(
+    product_dir: str, workspace: str, env: str | None
+) -> list[tuple[str, Path]]:
+    """The features ``features_<env>`` adds to the base list, resolved."""
+    from splent_framework.utils.pyproject_reader import PyprojectReader
+
+    env = context.normalize_env(env)
+    if not env:
+        return []
+    try:
+        reader = PyprojectReader.for_product(product_dir)
+        base = set(reader.features)
+        extra = [e for e in reader.features_for_env(env) if e not in base]
+    except (FileNotFoundError, ValueError):
+        return []
+    return _resolve_entries(extra, product_dir, workspace)
+
+
+def run_all_product_check(
+    workspace: str, product_dir: str, env: str | None = None
+) -> list[dict]:
+    """Run the full product compatibility check. Returns findings list.
+
+    The collisions are checked between the base features. The version
+    floors are checked across the features the product loads in ``env``
+    (SPLENT_ENV when None, ``dev`` when that is unset too), base plus
+    ``features_dev`` or ``features_prod``, the selection phase 1 checks.
+    """
     try:
         labeled_paths = _resolve_all_product_features(product_dir, workspace)
     except SystemExit:
         return []
     if not labeled_paths:
         return []
+    if env is None:
+        env = os.getenv("SPLENT_ENV") or "dev"
     labeled_contracts = [(lbl, _read_contract(path)) for lbl, path in labeled_paths]
-    return _analyse_all(labeled_contracts)
+    findings = _analyse_all(labeled_contracts) + version_floor_findings(
+        labeled_paths + _environment_only_features(product_dir, workspace, env)
+    )
+    return sorted(findings, key=lambda f: SEVERITY_ORDER[f["severity"]])
 
 
 # ─────────────────────────────────────────────────────────────────────────────