splent-cli 1.7.0__tar.gz → 1.9.0__tar.gz

{splent_cli-1.7.0/src/splent_cli.egg-info → splent_cli-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.7.0
+Version: 1.9.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.7.0 → splent_cli-1.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.7.0"
+version = "1.9.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.7.0 → splent_cli-1.9.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.7.0 → splent_cli-1.9.0}/src/splent_cli/commands/database/db_migrate.py

@@ -2,6 +2,7 @@ import os
 
 import click
 from flask_migrate import migrate as alembic_migrate
+from flask_migrate import revision as alembic_revision
 
 from splent_cli.utils.decorators import requires_db
 from splent_cli.services import context
@@ -54,14 +55,31 @@ def _is_empty_migration(path: str) -> bool:
 @click.option(
     "-m", "message", default=None, help="Migration message (defaults to feature name)."
 )
+@click.option(
+    "--empty",
+    is_flag=True,
+    help=(
+        "Generate a blank migration (no autogenerate) and keep it for manual "
+        "editing. Required for refinement features that add columns to a base "
+        "feature's table — Alembic cannot autodetect runtime-injected mixins."
+    ),
+)
 @context.requires_product
-def db_migrate(feature, message):
+def db_migrate(feature, message, empty):
     """
     Generate new migration files for features that have schema changes,
     then apply all pending migrations.
 
-    Empty migrations (no schema changes detected) are automatically removed.
+    Empty migrations (no schema changes detected) are automatically removed,
+    unless ``--empty`` is passed, in which case a blank migration is created
+    and kept so you can write ``upgrade()``/``downgrade()`` by hand.
     """
+    if empty and not feature:
+        click.echo(
+            click.style("❌ --empty requires a FEATURE argument.", fg="red")
+        )
+        raise SystemExit(1)
+
     if feature:
         dirs = {}
         mdir = MigrationManager.get_feature_migration_dir(feature)
@@ -108,7 +126,10 @@ def db_migrate(feature, message):
         alembic_logger.setLevel(logging.WARNING)
 
         try:
-            alembic_migrate(directory=mdir, message=message or feat)
+            if empty:
+                alembic_revision(directory=mdir, message=message or feat)
+            else:
+                alembic_migrate(directory=mdir, message=message or feat)
         except Exception as e:
             if os.getenv("SPLENT_DEBUG"):
                 click.secho(
@@ -119,6 +140,21 @@ def db_migrate(feature, message):
 
         after = _count_versions(mdir)
 
+        # A blank migration requested with --empty is intentional: keep it so the
+        # user can fill in upgrade()/downgrade() by hand (e.g. refinement columns).
+        if empty:
+            if after > before:
+                click.echo(
+                    click.style(
+                        f"  📝 {feat}: blank migration generated — "
+                        f"edit upgrade()/downgrade() and run 'splent db:upgrade'",
+                        fg="cyan",
+                    )
+                )
+            else:
+                click.echo(click.style(f"  ✔ {feat}: up to date", fg="green"))
+            continue
+
         # If a new file was generated, check if it's empty (no real schema changes)
         if after > before:
             versions_dir = os.path.join(mdir, "versions")

{splent_cli-1.7.0 → splent_cli-1.9.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.7.0 → splent_cli-1.9.0}/src/splent_cli/commands/feature/feature_release.py

@@ -237,10 +237,27 @@ def _extract_translations(translations_dir: Path) -> list[str]:
     return locales
 
 
+def _strip_docstrings_and_comments(text: str) -> str:
+    """Remove triple-quoted strings (docstrings) and ``#`` comments.
+
+    Signal inference scans for ``define_signal("...")`` / ``connect_signal("...")``
+    calls. The scaffolded ``signals.py`` ships *examples* of those calls inside a
+    module docstring; without stripping them the inferred contract would list
+    example signal names the feature never actually emits (e.g. ``item-created``),
+    causing spurious collisions in ``feature:xray --validate``.
+    """
+    # Drop triple-quoted blocks (both ''' and """).
+    text = re.sub(r'""".*?"""', "", text, flags=re.DOTALL)
+    text = re.sub(r"'''.*?'''", "", text, flags=re.DOTALL)
+    # Drop full-line and trailing comments.
+    text = re.sub(r"#.*", "", text)
+    return text
+
+
 def _extract_signals(signals_path: Path) -> tuple[list[str], list[str]]:
     if not signals_path.exists():
         return [], []
-    text = signals_path.read_text()
+    text = _strip_docstrings_and_comments(signals_path.read_text())
     provided = sorted(
         set(re.findall(r"""define_signal\s*\(\s*['"]([^'"]+)['"]""", text))
     )
@@ -273,14 +290,24 @@ def _scan_dependencies(
                 if f"splent_feature_{short_name}" != own_feature_name:
                     required_features.add(short_name)
 
-        for var in re.findall(
-            r"""os\.(?:getenv|environ\.get)\s*\(\s*['"]([A-Z][A-Z0-9_]+)['"]""", text
-        ):
-            env_vars.add(var)
-        for var in re.findall(
-            r"""os\.environ\s*\[\s*['"]([A-Z][A-Z0-9_]+)['"]""", text
-        ):
-            env_vars.add(var)
+        for line in text.splitlines():
+            stripped = line.lstrip()
+            # Skip comments and docstrings
+            if (
+                stripped.startswith("#")
+                or stripped.startswith('"""')
+                or stripped.startswith("'''")
+            ):
+                continue
+            for var in re.findall(
+                r"""os\.(?:getenv|environ\.get)\s*\(\s*['"]([A-Z][A-Z0-9_]+)['"]""",
+                stripped,
+            ):
+                env_vars.add(var)
+            for var in re.findall(
+                r"""os\.environ\s*\[\s*['"]([A-Z][A-Z0-9_]+)['"]""", stripped
+            ):
+                env_vars.add(var)
 
     return sorted(required_features), sorted(env_vars)
 
@@ -330,12 +357,14 @@ def write_contract(pyproject_path: str, contract: dict, feature_name: str) -> No
     text = path.read_text()
 
     existing_description = f"{feature_name} feature"
+    existing_env = None
     try:
         data = tomllib.loads(text)
         splent_contract = data.get("tool", {}).get("splent", {}).get("contract", {})
         desc = splent_contract.get("description")
         if desc:
             existing_description = desc
+        existing_env = splent_contract.get("env")
     except Exception:
         pass
 
@@ -373,7 +402,8 @@ def write_contract(pyproject_path: str, contract: dict, feature_name: str) -> No
         "# Do not edit manually — re-run `splent feature:contract --write` to refresh.\n"
         "[tool.splent.contract]\n"
         f'description = "{existing_description}"\n'
-        "\n"
+        + (f'env = "{existing_env}"\n' if existing_env else "")
+        + "\n"
         "[tool.splent.contract.provides]\n"
         f"routes     = {_toml_list(contract['routes'])}\n"
         f"blueprints = {_toml_list(contract['blueprints'])}\n"

{splent_cli-1.7.0 → splent_cli-1.9.0}/src/splent_cli/commands/feature/feature_xray.py

@@ -478,16 +478,19 @@ def feature_xray(feature_ref, filter_cat, validate, full):
     if not bp_collisions:
         ok += 1
 
-    # 5. Commands: check for name collisions
-    all_commands: dict[str, list[str]] = {}
+    # 5. Commands: feature-contributed commands are namespaced under
+    # ``feature:<name> <cmd>``, so the same command name in two different
+    # features (e.g. the scaffold's example ``hello``) never actually collides.
+    # We only flag a real duplicate *within* a single feature.
+    cmd_collisions = {}
     for name, fdata in feature_data.items():
-        for cmd in fdata["contract"].get("provides", {}).get("commands", []):
-            all_commands.setdefault(cmd, []).append(name)
-
-    cmd_collisions = {c: fs for c, fs in all_commands.items() if len(fs) > 1}
+        cmds = fdata["contract"].get("provides", {}).get("commands", [])
+        dupes = {c for c in cmds if cmds.count(c) > 1}
+        for c in dupes:
+            cmd_collisions.setdefault(f"{name}:{c}", []).append(name)
     for cmd, features_list in cmd_collisions.items():
         click.secho(
-            f"  ❌ Command '{cmd}' — collision: {', '.join(features_list)}",
+            f"  ❌ Command '{cmd}' — duplicated within feature",
             fg="red",
         )
         fail += 1

{splent_cli-1.7.0 → splent_cli-1.9.0}/src/splent_cli/commands/product/product_containers.py

@@ -235,10 +235,10 @@ def product_docker(env_dev, env_prod):
                 seen.add(key)
                 unique.append((label, port, kind))
 
-        http_services = [(l, p) for l, p, k in unique if k == "http"]
-        tcp_services = [(l, p) for l, p, k in unique if k == "tcp"]
+        http_services = [(lbl, p) for lbl, p, k in unique if k == "http"]
+        tcp_services = [(lbl, p) for lbl, p, k in unique if k == "tcp"]
         all_services = http_services + tcp_services
-        label_width = max((len(l) for l, _ in all_services), default=20) + 2
+        label_width = max((len(lbl) for lbl, _ in all_services), default=20) + 2
 
         if http_services:
             click.secho("  Accessible services:", bold=True)

{splent_cli-1.7.0 → splent_cli-1.9.0}/src/splent_cli/commands/product/product_deploy.py

@@ -268,13 +268,17 @@ def product_deploy(down, ci):
             import time
 
             healthy = False
-            for attempt in range(15):
+            # The production web container is named ``<product>_web_deploy`` —
+            # NOT ``<product>_web`` (that is the dev container). A cold start runs
+            # migrations and compiles assets before gunicorn binds, so allow a
+            # generous window (~90s) before declaring the app unhealthy.
+            for attempt in range(45):
                 try:
                     result = subprocess.run(
                         [
                             "docker",
                             "exec",
-                            f"{product}_web",
+                            f"{product}_web_deploy",
                             "bash",
                             "-c",
                             "curl -s -o /dev/null -w '%{http_code}' http://localhost:5000/",

{splent_cli-1.7.0 → splent_cli-1.9.0}/src/splent_cli/commands/product/product_env.py

@@ -172,7 +172,12 @@ def product_env(generate, merge, env_name, process_all):
             )
             raise SystemExit(1)
 
-        target_env = os.path.join(docker_dir, ".env")
+        # Each environment writes to its own file so a `--prod` merge never
+        # clobbers the development `.env` (which the dev containers read via
+        # env_file). dev → .env, prod → .env.deploy.
+        target_env = os.path.join(
+            docker_dir, ".env.deploy" if env_name == "prod" else ".env"
+        )
         if base_env != target_env:
             shutil.copyfile(base_env, target_env)
 

{splent_cli-1.7.0 → splent_cli-1.9.0}/src/splent_cli/commands/spl/spl_add_feature.py

@@ -74,6 +74,31 @@ def _scan_feature_deps(
 ) -> set[str]:
     """Scan a feature's source for dependencies. Returns set of short_names."""
     deps = set()
+
+    # Refinement features declare the feature they refine in pyproject.toml
+    # ([tool.splent.refinement].refines). That is a hard dependency — the base
+    # feature must load first — so surface it as a constraint even when there is
+    # no Python import or FK between them.
+    pyproject_path = os.path.join(feature_path, "pyproject.toml")
+    if os.path.isfile(pyproject_path):
+        try:
+            import tomllib
+
+            with open(pyproject_path, "rb") as fh:
+                pydata = tomllib.load(fh)
+            refines = (
+                pydata.get("tool", {})
+                .get("splent", {})
+                .get("refinement", {})
+                .get("refines")
+            )
+            if refines and refines != feature_pkg and refines in all_packages:
+                short = pkg_to_short.get(refines)
+                if short:
+                    deps.add(short)
+        except Exception:
+            pass
+
     src_dir = os.path.join(feature_path, "src", "splent_io", feature_pkg)
     if not os.path.isdir(src_dir):
         return deps

{splent_cli-1.7.0 → splent_cli-1.9.0}/src/splent_cli/services/preflight.py

@@ -106,6 +106,56 @@ def run_preflight(*, interactive: bool = True, build_mode: bool = False) -> bool
 
     failed = False
 
+    # Phase 0: pyproject sanity (duplicates, namespaces, SPL)
+    splent_cfg = data.get("tool", {}).get("splent", {})
+    base_feats = splent_cfg.get("features", [])
+    dev_feats = splent_cfg.get("features_dev", [])
+    prod_feats = splent_cfg.get("features_prod", [])
+
+    all_entries = base_feats + dev_feats + prod_feats
+    seen = {}
+    for entry in all_entries:
+        bare = (
+            entry.split("/")[-1].split("@")[0] if "/" in entry else entry.split("@")[0]
+        )
+        seen.setdefault(bare, []).append(entry)
+
+    duplicates = {k: v for k, v in seen.items() if len(v) > 1}
+    if duplicates:
+        if interactive:
+            for bare, entries in duplicates.items():
+                short = bare.replace("splent_feature_", "")
+                click.secho(
+                    f"  pyproject duplicate '{short}': {', '.join(entries)}", fg="red"
+                )
+        failed = True
+    else:
+        namespaces = set()
+        for entry in all_entries:
+            if "/" in entry:
+                namespaces.add(entry.split("/")[0])
+        if len(namespaces) > 1:
+            if interactive:
+                click.secho(
+                    f"  pyproject inconsistent namespaces: {', '.join(sorted(namespaces))}",
+                    fg="yellow",
+                )
+
+    spl_name = splent_cfg.get("spl")
+    if spl_name:
+        uvl_check = os.path.join(
+            workspace, "splent_catalog", spl_name, f"{spl_name}.uvl"
+        )
+        if not os.path.isfile(uvl_check):
+            if interactive:
+                click.secho(
+                    f"  pyproject SPL '{spl_name}' — UVL not found in catalog", fg="red"
+                )
+            failed = True
+
+    if failed:
+        return False
+
     # Phase 1: SAT
     try:
         sat_ok, selected, _, _ = _run_sat_check(workspace, app_name, data, None, False)

{splent_cli-1.7.0 → splent_cli-1.9.0}/src/splent_cli/services/release.py

@@ -260,17 +260,39 @@ def build_and_upload_pypi(path: str):
         raise SystemExit(1)
 
     click.echo("  pypi     uploading...")
+
+    # Expand dist/* ourselves: subprocess runs without a shell, so a literal
+    # "dist/*" would be passed verbatim to twine and never match any file.
+    import glob
+
+    dist_files = sorted(glob.glob(os.path.join(path, "dist", "*")))
+    if not dist_files:
+        click.secho("  error: no built artifacts found in dist/", fg="red")
+        raise SystemExit(1)
+
+    # twine reads TWINE_USERNAME / TWINE_PASSWORD from the environment. The CLI
+    # loads them from the workspace .env (load_dotenv), so they are already in
+    # os.environ — pass it through explicitly. --non-interactive makes twine fail
+    # loudly instead of blocking on a credentials prompt; --skip-existing keeps
+    # re-runs idempotent (a half-uploaded release can be retried safely).
     try:
         subprocess.run(
-            [sys.executable, "-m", "twine", "upload", "dist/*"],
+            [
+                sys.executable,
+                "-m",
+                "twine",
+                "upload",
+                "--non-interactive",
+                "--skip-existing",
+                *dist_files,
+            ],
             env=os.environ.copy(),
             check=True,
             cwd=path,
-            capture_output=True,
         )
     except subprocess.CalledProcessError as e:
         click.secho(
-            f"  error: PyPI upload failed: {e.stderr.strip() if e.stderr else ''}",
+            f"  error: PyPI upload failed (exit {e.returncode}).",
             fg="red",
         )
         click.secho(