splent-cli 1.6.0__tar.gz → 1.8.0__tar.gz

{splent_cli-1.6.0/src/splent_cli.egg-info → splent_cli-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.6.0
+Version: 1.8.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
@@ -10,6 +10,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click==8.1.8
 Requires-Dist: packaging>=24.0
+Requires-Dist: requests>=2.31.0
 Provides-Extra: dev
 Requires-Dist: setuptools==80.3.1; extra == "dev"
 Requires-Dist: pytest==8.3.4; extra == "dev"

{splent_cli-1.6.0 → splent_cli-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.6.0"
+version = "1.8.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -14,6 +14,7 @@ license-files = ["LICENSE"]
 dependencies = [
     "click==8.1.8",
     "packaging>=24.0",
+    "requests>=2.31.0",
 ]
 
 [project.optional-dependencies]

{splent_cli-1.6.0 → splent_cli-1.8.0}/src/splent_cli/commands/check/check_pyproject.py

@@ -9,7 +9,6 @@ import click
 import tomllib
 
 from splent_cli.services import context
-from splent_cli.utils.feature_utils import read_features_from_data
 
 
 def _find_missing_pkgs(deps: list) -> list:
@@ -88,29 +87,69 @@ def check_pyproject():
         _ok(f"All {len(deps)} dependencies satisfied")
 
     # Features
-    features = read_features_from_data(data)
-    _ok(f"{len(features)} features declared in [tool.splent.features]")
-
     splent = data.get("tool", {}).get("splent", {})
+    base_feats = splent.get("features", [])
     dev_feats = splent.get("features_dev", [])
     prod_feats = splent.get("features_prod", [])
+
+    _ok(f"{len(base_feats)} features in [tool.splent].features")
     if dev_feats:
         _ok(f"{len(dev_feats)} dev-only features")
     if prod_feats:
         _ok(f"{len(prod_feats)} prod-only features")
 
-    # UVL
-    uvl_cfg = splent.get("uvl", {})
-    uvl_file = uvl_cfg.get("file")
-    if uvl_file:
-        app_path = os.path.join(workspace, product)
-        uvl_path = os.path.join(app_path, "uvl", uvl_file)
-        if os.path.exists(uvl_path):
-            _ok(f"UVL file found: uvl/{uvl_file}")
+    # Check for duplicates across feature lists
+    def _bare_name(entry):
+        name = entry.split("/")[-1] if "/" in entry else entry
+        return name.split("@")[0]
+
+    all_entries = base_feats + dev_feats + prod_feats
+    seen_names = {}
+    for entry in all_entries:
+        bare = _bare_name(entry)
+        seen_names.setdefault(bare, []).append(entry)
+
+    for bare, entries in seen_names.items():
+        if len(entries) > 1:
+            short = bare.replace("splent_feature_", "")
+            _fail(f"Duplicate feature '{short}': {', '.join(entries)}")
+
+    # Check for inconsistent namespaces
+    namespaces = set()
+    for entry in all_entries:
+        if "/" in entry:
+            ns = entry.split("/")[0]
+            namespaces.add(ns)
+    if len(namespaces) > 1:
+        _warn(
+            f"Inconsistent namespaces: {', '.join(sorted(namespaces))} — use one format consistently"
+        )
+
+    # SPL / UVL
+    spl_name = splent.get("spl")
+    if spl_name:
+        uvl_path = os.path.join(
+            workspace, "splent_catalog", spl_name, f"{spl_name}.uvl"
+        )
+        if os.path.isfile(uvl_path):
+            _ok(f"SPL catalog: {spl_name} (UVL found)")
         else:
-            _fail(f"UVL file not found: uvl/{uvl_file}")
+            _fail(
+                f"SPL catalog: {spl_name} — UVL not found at splent_catalog/{spl_name}/{spl_name}.uvl"
+            )
     else:
-        _warn("No UVL file configured")
+        # Legacy fallback
+        uvl_cfg = splent.get("uvl", {})
+        uvl_file = uvl_cfg.get("file")
+        if uvl_file:
+            app_path = os.path.join(workspace, product)
+            uvl_path = os.path.join(app_path, "uvl", uvl_file)
+            if os.path.exists(uvl_path):
+                _ok(f"UVL file found: uvl/{uvl_file} (legacy)")
+            else:
+                _fail(f"UVL file not found: uvl/{uvl_file}")
+        else:
+            _warn("No SPL configured — set [tool.splent].spl in pyproject.toml")
 
     click.echo()
     if fail:

{splent_cli-1.6.0 → splent_cli-1.8.0}/src/splent_cli/commands/database/db_reset.py

@@ -123,6 +123,10 @@ def db_reset(yes):
                         name=name,
                         version=version,
                     )
+            except ImportError as e:
+                if "models" in str(e):
+                    continue
+                click.echo(click.style(f"  ❌ {feat}: {e}", fg="red"))
             except Exception as e:
                 click.echo(click.style(f"  ❌ {feat}: {e}", fg="red"))
 

{splent_cli-1.6.0 → splent_cli-1.8.0}/src/splent_cli/commands/database/db_upgrade.py

@@ -84,6 +84,11 @@ def db_upgrade(feature):
                     name=name,
                     version=version,
                 )
+        except ImportError as e:
+            if "models" in str(e):
+                # Feature has migrations/ dir but no models module — skip silently
+                continue
+            click.echo(click.style(f"  ❌ {feat}: {e}", fg="red"))
         except Exception as e:
             click.echo(click.style(f"  ❌ {feat}: {e}", fg="red"))
 

{splent_cli-1.6.0 → splent_cli-1.8.0}/src/splent_cli/commands/export/export_puml.py

@@ -149,8 +149,8 @@ def _parse_models(models_path: str) -> list[dict]:
     text = "\n".join(joined_lines)
 
     classes = []
-    # Split by class definition
-    class_blocks = re.split(r"^(class \w+\(.*?\):)", text, flags=re.MULTILINE)
+    # Split by class definition (with or without parentheses for mixins)
+    class_blocks = re.split(r"^(class \w+(?:\(.*?\))?:)", text, flags=re.MULTILINE)
 
     i = 1
     while i < len(class_blocks):
@@ -158,7 +158,7 @@ def _parse_models(models_path: str) -> list[dict]:
         body = class_blocks[i + 1] if i + 1 < len(class_blocks) else ""
         i += 2
 
-        class_m = re.match(r"class (\w+)\(", header)
+        class_m = re.match(r"class (\w+)", header)
         if not class_m:
             continue
         class_name = class_m.group(1)
@@ -213,8 +213,11 @@ def _parse_models(models_path: str) -> list[dict]:
             if rel_m:
                 rel_name = rel_m.group(1)
                 rel_args = rel_m.group(2)
-                target_m = re.match(r"(\w+)", rel_args)
-                target = target_m.group(1) if target_m else "?"
+                # Target can be unquoted (User) or quoted ("User" / 'User')
+                target_m = re.match(r"""[\"']?(\w+)[\"']?""", rel_args)
+                target = target_m.group(1) if target_m else None
+                if not target:
+                    continue
                 uselist = "uselist=False" not in rel_args
                 relationships.append(
                     {
@@ -668,11 +671,16 @@ def _render_exports(
         )
     except subprocess.CalledProcessError as e:
         click.secho("❌ PlantUML failed to render diagram.", fg="red")
-        if os.getenv("SPLENT_DEBUG"):
-            stderr = e.stderr
-            if isinstance(stderr, bytes):
-                stderr = stderr.decode(errors="replace")
-            click.secho(stderr[:500], fg="bright_black")
+        stderr = e.stderr
+        if isinstance(stderr, bytes):
+            stderr = stderr.decode(errors="replace")
+        if stderr:
+            click.secho(stderr.strip(), fg="bright_black")
+        stdout = e.stdout
+        if isinstance(stdout, bytes):
+            stdout = stdout.decode(errors="replace")
+        if stdout:
+            click.secho(stdout.strip(), fg="bright_black")
         return
 
     try:
@@ -780,21 +788,41 @@ def export_puml(
     product = context.require_app()
     product_dir = os.path.join(workspace, product)
 
-    # Read UVL
-    try:
-        uvl_cfg = PyprojectReader.for_product(product_dir).uvl_config
-    except (FileNotFoundError, RuntimeError) as e:
-        click.secho(f"❌ Cannot read pyproject.toml: {e}", fg="red")
-        raise SystemExit(1)
-
-    uvl_file = uvl_cfg.get("file")
-    if not uvl_file:
-        click.secho("❌ No UVL file configured in [tool.splent.uvl].", fg="red")
-        raise SystemExit(1)
-
-    uvl_path = os.path.join(product_dir, "uvl", uvl_file)
-    if not os.path.isfile(uvl_path):
-        click.secho(f"❌ UVL file not found: {uvl_path}", fg="red")
+    # Read UVL — try SPL catalog first, fall back to legacy [tool.splent.uvl]
+    import tomllib
+
+    uvl_path = None
+    pyproject_path = os.path.join(product_dir, "pyproject.toml")
+    if os.path.isfile(pyproject_path):
+        with open(pyproject_path, "rb") as f:
+            pydata = tomllib.load(f)
+        spl_name = pydata.get("tool", {}).get("splent", {}).get("spl")
+        if spl_name:
+            candidate = os.path.join(
+                workspace, "splent_catalog", spl_name, f"{spl_name}.uvl"
+            )
+            if os.path.isfile(candidate):
+                uvl_path = candidate
+
+    # Legacy fallback: [tool.splent.uvl].file
+    if not uvl_path:
+        try:
+            uvl_cfg = PyprojectReader.for_product(product_dir).uvl_config
+            uvl_file = uvl_cfg.get("file")
+            if uvl_file:
+                candidate = os.path.join(product_dir, "uvl", uvl_file)
+                if os.path.isfile(candidate):
+                    uvl_path = candidate
+        except (FileNotFoundError, RuntimeError):
+            pass
+
+    if not uvl_path:
+        click.secho(
+            "❌ No UVL file found.\n"
+            "   Set [tool.splent].spl in pyproject.toml (SPL catalog)\n"
+            "   or [tool.splent.uvl].file (legacy).",
+            fg="red",
+        )
         raise SystemExit(1)
 
     click.echo(f"📖 Reading UVL model: {uvl_path}")
@@ -848,6 +876,53 @@ def export_puml(
                     if parsed:
                         all_models[package] = parsed
                     break
+        # Apply refinement mixins: merge mixin attributes into target models
+        for package, fpath in feature_paths.items():
+            pyproject_path = os.path.join(fpath, "pyproject.toml")
+            if not os.path.isfile(pyproject_path):
+                continue
+            import tomllib as _tomllib
+
+            with open(pyproject_path, "rb") as f:
+                feat_data = _tomllib.load(f)
+            extends = (
+                feat_data.get("tool", {})
+                .get("splent", {})
+                .get("refinement", {})
+                .get("extends", {})
+                .get("models", [])
+            )
+            if not extends:
+                continue
+            # Parse the mixin's models.py
+            mixin_models = []
+            src_root = os.path.join(fpath, "src")
+            if os.path.isdir(src_root):
+                for org_dir in os.listdir(src_root):
+                    mpath = os.path.join(src_root, org_dir, package, "models.py")
+                    if os.path.isfile(mpath):
+                        mixin_models = _parse_models(mpath)
+                        break
+            # Merge each mixin into its target model
+            for ext in extends:
+                target_name = ext.get("target")
+                mixin_name = ext.get("mixin")
+                if not target_name or not mixin_name:
+                    continue
+                # Find the mixin class in parsed mixin_models
+                mixin_cls = next(
+                    (m for m in mixin_models if m["name"] == mixin_name), None
+                )
+                if not mixin_cls:
+                    continue
+                # Find the target model across all parsed features
+                for feat_models in all_models.values():
+                    for model in feat_models:
+                        if model["name"] == target_name:
+                            model["attributes"].extend(mixin_cls["attributes"])
+                            model["methods"].extend(mixin_cls["methods"])
+                            break
+
         click.echo(
             f"📋 Parsed models from {len(all_models)}/{len(feature_paths)} features."
         )

{splent_cli-1.6.0 → splent_cli-1.8.0}/src/splent_cli/commands/feature/feature_add.py

@@ -59,6 +59,25 @@ def feature_add(full_name, env_scope):
         )
         raise SystemExit(1)
 
+    # ── Auto-detect env scope from feature contract ───────────────────
+    if not env_scope:
+        feat_pyproject = os.path.join(feature_dir, "pyproject.toml")
+        if os.path.isfile(feat_pyproject):
+            with open(feat_pyproject, "rb") as f:
+                feat_data = tomllib.load(f)
+            contract_env = (
+                feat_data.get("tool", {})
+                .get("splent", {})
+                .get("contract", {})
+                .get("env")
+            )
+            if contract_env:
+                env_scope = contract_env
+                click.echo(
+                    click.style("  scope    ", dim=True)
+                    + f"contract declares env={contract_env} → features_{contract_env}"
+                )
+
     # ── Update pyproject.toml ─────────────────────────────────────────
     pyproject_path = os.path.join(workspace, product, "pyproject.toml")
     if not os.path.exists(pyproject_path):

{splent_cli-1.6.0 → splent_cli-1.8.0}/src/splent_cli/commands/feature/feature_attach.py

@@ -64,6 +64,27 @@ def feature_attach(feature_identifier, version, env_scope):
 
     short = feature_name.replace("splent_feature_", "")
 
+    # ── Auto-detect env scope from feature contract ───────────────────
+    if not env_scope:
+        feat_pyproject = os.path.join(versioned_dir, "pyproject.toml")
+        if os.path.isfile(feat_pyproject):
+            import tomllib as _tomllib
+
+            with open(feat_pyproject, "rb") as f:
+                feat_data = _tomllib.load(f)
+            contract_env = (
+                feat_data.get("tool", {})
+                .get("splent", {})
+                .get("contract", {})
+                .get("env")
+            )
+            if contract_env:
+                env_scope = contract_env
+                click.echo(
+                    click.style("  scope    ", dim=True)
+                    + f"contract declares env={contract_env} → features_{contract_env}"
+                )
+
     # ── Update pyproject.toml ─────────────────────────────────────────
     full_name = f"{namespace}/{feature_name}@{version}"
     bare_name = f"{namespace}/{feature_name}"

{splent_cli-1.6.0 → splent_cli-1.8.0}/src/splent_cli/commands/feature/feature_env.py

@@ -45,19 +45,26 @@ def feature_env(feature_name, generate, env_name):
     with open(pyproject_path, "rb") as f:
         data = tomllib.load(f)
 
-    feature_entries = read_features_from_data(data)
+    # 2️⃣ Determinar entorno (antes de leer features, para incluir features_dev/prod)
+    env_from_var = os.getenv("SPLENT_ENV")
+    if not env_name and env_from_var:
+        env_name = env_from_var
+        click.echo(f"🌍 Using SPLENT_ENV={env_name}")
+    elif not env_name:
+        click.echo("❌ You must specify --dev, --prod, or define SPLENT_ENV=dev|prod.")
+        raise SystemExit(1)
+
+    feature_entries = read_features_from_data(data, env_name)
     if not feature_entries:
         click.echo("❌ No features declared in pyproject.toml.")
         raise SystemExit(1)
 
-    # 2️⃣ Buscar la feature pedida con su versión
+    # 3️⃣ Buscar la feature pedida con su versión
     feature_entry = next(
         (f for f in feature_entries if f.startswith(feature_name)), None
     )
     if not feature_entry:
-        click.echo(
-            f"❌ Feature '{feature_name}' not found in [features] section of {pyproject_path}"
-        )
+        click.echo(f"❌ Feature '{feature_name}' not found in pyproject.toml")
         raise SystemExit(1)
 
     # Derive org_safe from the entry itself (e.g. "splent_io/splent_feature_auth@v1")
@@ -68,15 +75,6 @@ def feature_env(feature_name, generate, env_name):
         org_safe = "splent_io"
         entry_basename = feature_entry
 
-    # 3️⃣ Determinar entorno
-    env_from_var = os.getenv("SPLENT_ENV")
-    if not env_name and env_from_var:
-        env_name = env_from_var
-        click.echo(f"🌍 Using SPLENT_ENV={env_name}")
-    elif not env_name:
-        click.echo("❌ You must specify --dev, --prod, or define SPLENT_ENV=dev|prod.")
-        raise SystemExit(1)
-
     # 4️⃣ Ruta del symlink del producto (con versión incluida)
     symlink_path = os.path.join(
         workspace, product, "features", org_safe, entry_basename

splent_cli-1.8.0/src/splent_cli/commands/feature/feature_impact.py

@@ -0,0 +1,161 @@
+"""
+splent feature:impact
+
+Shows the full dependency impact of a feature within the active product:
+what it requires, what depends on it, and what would break if removed.
+
+All dependency information is resolved from the product's UVL constraints.
+"""
+
+import os
+
+import click
+
+from splent_cli.services import context
+from splent_cli.commands.feature.feature_order import (
+    _uvl_path,
+    _build_requires_map,
+    _build_reverse_map,
+    _closure,
+    _parse_entry,
+)
+from splent_framework.utils.pyproject_reader import PyprojectReader
+
+
+def _short_name(pkg: str) -> str:
+    """splent_feature_auth → auth"""
+    return pkg.removeprefix("splent_feature_")
+
+
+@click.command(
+    "feature:impact",
+    short_help="Show the dependency impact of adding or removing a feature.",
+)
+@click.argument("feature_ref", required=True)
+def feature_impact(feature_ref):
+    """
+    Show what FEATURE_REF depends on and what depends on it.
+
+    Reads the product's UVL constraints to build a bidirectional dependency
+    graph and shows:
+
+    \b
+      1. Dependencies — features this one requires to work.
+      2. Dependents   — features that require this one.
+      3. Impact       — transitive set of features that would break
+                        if this feature were removed.
+
+    FEATURE_REF can be a short name (auth) or full package name
+    (splent_feature_auth).
+
+    \b
+    Examples:
+        splent feature:impact auth
+        splent feature:impact splent_feature_mail
+    """
+    product = context.require_app()
+    workspace = str(context.workspace())
+    product_dir = os.path.join(workspace, product)
+
+    try:
+        reader = PyprojectReader.for_product(product_dir)
+        env = os.getenv("SPLENT_ENV")
+        features_raw = reader.features_for_env(env)
+    except FileNotFoundError:
+        click.secho("  pyproject.toml not found.", fg="red")
+        raise SystemExit(1)
+
+    uvl = _uvl_path(product_dir)
+    if not uvl or not os.path.isfile(uvl):
+        click.secho("  No UVL file found — cannot compute impact.", fg="red")
+        raise SystemExit(1)
+
+    # Normalize input: accept "auth" or "splent_feature_auth"
+    target = feature_ref
+    if target.startswith("splent_feature_"):
+        target = target[len("splent_feature_") :]
+    pkg_target = f"splent_feature_{target}"
+
+    # Build declared feature set
+    declared_pkgs = set()
+    for entry in features_raw:
+        _, name, _ = _parse_entry(entry)
+        declared_pkgs.add(name)
+
+    if pkg_target not in declared_pkgs:
+        click.secho(f"  '{feature_ref}' is not declared in this product.", fg="red")
+        raise SystemExit(1)
+
+    # Build dependency graphs
+    requires_map = _build_requires_map(uvl)
+    reverse_map = _build_reverse_map(requires_map)
+
+    # Direct dependencies (what I need)
+    direct_deps = requires_map.get(pkg_target, [])
+
+    # Full dependency closure (transitive: what I need, and what they need, etc.)
+    all_deps = _closure(pkg_target, requires_map, declared_pkgs)
+
+    # Direct dependents (who needs me)
+    direct_dependents = reverse_map.get(pkg_target, [])
+
+    # Full reverse closure (transitive: who breaks if I'm removed)
+    all_affected = _closure(pkg_target, reverse_map, declared_pkgs)
+
+    # ── Output ────────────────────────────────────────────────────────
+
+    click.echo()
+    click.secho(f"  feature:impact — {target}", bold=True)
+    click.echo(click.style(f"  Product: {product}", fg="bright_black"))
+    click.echo(click.style(f"  UVL:     {os.path.basename(uvl)}", fg="bright_black"))
+
+    # Section 1: What I depend on
+    click.echo()
+    click.secho("  Depends on", bold=True)
+
+    if not all_deps:
+        click.echo(click.style("    (none) — this feature is independent", fg="green"))
+    else:
+        direct_set = set(direct_deps)
+        for dep in all_deps:
+            marker = "direct" if dep in direct_set else "transitive"
+            icon = "→" if marker == "direct" else "  →"
+            color = "cyan" if marker == "direct" else "bright_black"
+            click.echo(
+                f"    {icon} {click.style(_short_name(dep), fg=color)}  ({marker})"
+            )
+
+    # Section 2: Who depends on me + impact
+    click.echo()
+    click.secho("  Depended on by", bold=True)
+
+    if not all_affected:
+        click.echo(click.style("    (none) — safe to remove", fg="green"))
+    else:
+        direct_set = set(direct_dependents)
+        for dep in all_affected:
+            marker = "direct" if dep in direct_set else "transitive"
+            icon = "←" if marker == "direct" else "  ←"
+            color = "red" if marker == "direct" else "yellow"
+            click.echo(
+                f"    {icon} {click.style(_short_name(dep), fg=color)}  ({marker})"
+            )
+
+    # Section 3: Summary
+    click.echo()
+    if all_affected:
+        click.secho(
+            f"  Removing {target} would break {len(all_affected)} feature(s).",
+            fg="red",
+            bold=True,
+        )
+    else:
+        click.secho(
+            f"  Removing {target} has no impact on other features.",
+            fg="green",
+            bold=True,
+        )
+    click.echo()
+
+
+cli_command = feature_impact