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

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.11.0"
+version = "1.13.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/src/splent_cli/commands/database/db_reset.py

@@ -0,0 +1,267 @@
+import glob
+import importlib
+import os
+import tomllib
+
+import click
+from flask import current_app
+from flask_migrate import upgrade as alembic_upgrade
+from sqlalchemy import text, MetaData
+
+from splent_cli.utils.decorators import requires_db
+from splent_cli.services import context
+from splent_cli.utils.lifecycle import advance_state, resolve_feature_key_from_entry
+from splent_framework.db import db
+from splent_framework.managers.migration_manager import (
+    MigrationManager,
+    SPLENT_MIGRATIONS_TABLE,
+    alembic_version_table,
+)
+from splent_framework.utils.feature_utils import get_features_from_pyproject
+from splent_framework.utils.path_utils import PathUtils
+from splent_cli.commands.clear.clear_uploads import clear_uploads
+
+
+# =====================================================================
+# Helpers for the per-feature reset
+# =====================================================================
+def _normalize(feature_name: str) -> str:
+    """Accept 'projects' or 'splent_feature_projects' -> full package name."""
+    short = feature_name.split("/")[-1].replace("splent_feature_", "")
+    return f"splent_feature_{short}"
+
+
+def _tables_owned_by(feature_full: str) -> list[str]:
+    """Tables whose model classes live in the given feature's package."""
+    import_name = f"splent_io.{feature_full}"
+    try:
+        importlib.import_module(f"{import_name}.models")
+    except Exception:
+        pass
+    tables = []
+    for mapper in db.Model.registry.mappers:
+        cls = mapper.class_
+        if getattr(cls, "__module__", "").startswith(import_name):
+            tables.append(cls.__table__.name)
+    return sorted(set(tables))
+
+
+def _refiners_of(feature_full: str, product_path: str) -> list[str]:
+    """Installed features whose [tool.splent.refinement].refines == feature."""
+    refiners = []
+    pattern = os.path.join(product_path, "features", "*", "*", "pyproject.toml")
+    for pp in glob.glob(pattern):
+        try:
+            with open(pp, "rb") as f:
+                data = tomllib.load(f)
+        except Exception:
+            continue
+        ref = data.get("tool", {}).get("splent", {}).get("refinement", {})
+        if ref.get("refines") == feature_full:
+            name = data.get("project", {}).get("name", "")
+            if name:
+                refiners.append(name)
+    return refiners
+
+
+def _reapply(app, feats: list[str], entry_lookup: dict, product_path, product_name):
+    dirs = MigrationManager.get_all_feature_migration_dirs()
+    for feat in feats:
+        mdir = dirs.get(feat)
+        if not mdir:
+            continue
+        try:
+            alembic_upgrade(directory=mdir)
+            revision = MigrationManager.get_current_feature_revision(feat, db.engine)
+            MigrationManager.update_feature_status(app, feat, revision)
+            click.echo(click.style(f"  ✅ {feat} → {revision or 'head'}", fg="green"))
+            info = entry_lookup.get(feat)
+            if info:
+                key, ns, name, version = info
+                advance_state(
+                    product_path,
+                    product_name,
+                    key,
+                    to="migrated",
+                    namespace=ns,
+                    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"))
+
+
+def _entry_lookup() -> dict:
+    lookup = {}
+    for entry in get_features_from_pyproject() or []:
+        key, ns, name, version = resolve_feature_key_from_entry(entry)
+        lookup[name] = (key, ns, name, version)
+    return lookup
+
+
+# =====================================================================
+# Command
+# =====================================================================
+@requires_db
+@click.command(
+    "db:reset",
+    short_help="Drop all tables (or just one feature's) and re-apply migrations.",
+)
+@click.argument("feature_name", required=False)
+@click.option("-y", "--yes", is_flag=True, help="Confirm without prompting.")
+@context.requires_product
+def db_reset(feature_name, yes):
+    """Reset the database.
+
+    With no argument: drops ALL tables and re-applies every feature migration.
+
+    With FEATURE_NAME (e.g. ``db:reset projects``): drops only the tables that
+    feature owns, clears their migration tracking, and re-applies that
+    feature's migrations plus any feature that refines it — leaving every other
+    feature's data untouched. Useful after changing a model/refinement.
+    """
+    app = current_app
+    product_path = PathUtils.get_app_base_dir()
+    product_name = os.getenv("SPLENT_APP", "")
+
+    if feature_name:
+        _reset_one_feature(app, feature_name, yes, product_path, product_name)
+        return
+
+    _reset_everything(app, yes, product_path, product_name)
+
+
+def _reset_one_feature(app, feature_name, yes, product_path, product_name):
+    feature_full = _normalize(feature_name)
+    tables = _tables_owned_by(feature_full)
+    refiners = _refiners_of(feature_full, product_path)
+    feats = [feature_full] + refiners
+
+    if not tables:
+        click.secho(
+            f"⚠️  '{feature_full}' owns no tables (nothing to drop). "
+            f"If it is a refinement, reset the base feature instead.",
+            fg="yellow",
+        )
+        return
+
+    click.echo()
+    click.secho(f"Reset feature: {feature_full}", fg="cyan", bold=True)
+    click.echo(f"  tables to drop : {', '.join(tables)}")
+    if refiners:
+        click.echo(f"  also re-applies: {', '.join(refiners)} (refiners)")
+    if not yes and not click.confirm(
+        "⚠️  This drops those tables and re-applies their migrations. Continue?",
+        abort=True,
+    ):
+        return
+
+    # Drop the feature's tables
+    with db.engine.begin() as conn:
+        conn.execute(text("SET FOREIGN_KEY_CHECKS = 0"))
+        for t in tables:
+            conn.execute(text(f"DROP TABLE IF EXISTS `{t}`"))
+            click.echo(click.style(f"   Dropped {t}", fg="bright_black"))
+        conn.execute(text("SET FOREIGN_KEY_CHECKS = 1"))
+
+    # Clear migration tracking for the feature and its refiners — both the
+    # central splent_migrations row AND each feature's alembic version table —
+    # so their migrations are re-applied from scratch onto the fresh tables.
+    with db.engine.begin() as conn:
+        conn.execute(text("SET FOREIGN_KEY_CHECKS = 0"))
+        for feat in feats:
+            conn.execute(
+                text(f"DELETE FROM `{SPLENT_MIGRATIONS_TABLE}` WHERE feature = :f"),
+                {"f": feat},
+            )
+            conn.execute(text(f"DROP TABLE IF EXISTS `{alembic_version_table(feat)}`"))
+        conn.execute(text("SET FOREIGN_KEY_CHECKS = 1"))
+
+    click.secho("⬆️  Re-applying migrations...", fg="cyan")
+    _reapply(app, feats, _entry_lookup(), product_path, product_name)
+    click.secho(f"\n🎉 Feature '{feature_full}' reset complete.", fg="green")
+
+
+def _reset_everything(app, yes, product_path, product_name):
+    if not yes and not click.confirm(
+        "⚠️  WARNING: This will DROP all tables and clear uploads. Are you sure?",
+        abort=True,
+    ):
+        return
+
+    click.echo(click.style("🗑️  Dropping all tables...", fg="yellow"))
+    try:
+        with db.engine.begin() as conn:
+            conn.execute(text("SET FOREIGN_KEY_CHECKS = 0"))
+            meta = MetaData()
+            meta.reflect(bind=db.engine)
+            for table in meta.sorted_tables:
+                conn.execute(text(f"DROP TABLE IF EXISTS `{table.name}`"))
+                click.echo(click.style(f"   Dropped {table.name}", fg="bright_black"))
+            conn.execute(text("SET FOREIGN_KEY_CHECKS = 1"))
+        click.echo(click.style("✅ All tables dropped.", fg="yellow"))
+    except Exception as e:
+        click.echo(click.style(f"❌ Error dropping tables: {e}", fg="red"))
+        click.echo(
+            click.style(
+                "⚠️  The database may now be in a PARTIAL state: some tables "
+                "may have been dropped while others remain.\n"
+                "   To recover, re-run this command once the database is "
+                "reachable again (it is safe to repeat — drops use "
+                "DROP TABLE IF EXISTS), or manually drop the remaining "
+                "tables / re-create the schema from migrations.",
+                fg="red",
+            )
+        )
+        raise SystemExit(1)
+
+    click.echo(click.style("📋 Recreating splent_migrations table...", fg="cyan"))
+    try:
+        with db.engine.begin() as conn:
+            conn.execute(
+                text(
+                    f"""
+                    CREATE TABLE IF NOT EXISTS `{SPLENT_MIGRATIONS_TABLE}` (
+                        `feature`        VARCHAR(255) NOT NULL,
+                        `last_migration` VARCHAR(255) DEFAULT NULL,
+                        PRIMARY KEY (`feature`)
+                    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+                    """
+                )
+            )
+    except Exception as exc:
+        # The drop above succeeded, so the schema is empty but the migration
+        # tracking table is gone: surface the partial state instead of a raw
+        # traceback, and tell the operator how to converge.
+        click.echo(
+            click.style(
+                f"Failed to recreate the migration tracking table `{SPLENT_MIGRATIONS_TABLE}`: {exc}\n"
+                "The database is empty but untracked. Re-run 'splent db:reset' once the "
+                "database connection is back.",
+                fg="red",
+            )
+        )
+        raise SystemExit(1)
+
+    ctx = click.get_current_context()
+    ctx.invoke(clear_uploads)
+
+    dirs = MigrationManager.get_all_feature_migration_dirs()
+    if not dirs:
+        click.echo(click.style("⚠️  No feature migrations found.", fg="yellow"))
+    else:
+        click.echo(
+            click.style(
+                f"⬆️  Applying migrations for {len(dirs)} features...", fg="cyan"
+            )
+        )
+        _reapply(app, list(dirs.keys()), _entry_lookup(), product_path, product_name)
+
+    click.echo(click.style("\n🎉 Database reset complete.", fg="green"))
+
+
+cli_command = db_reset

{splent_cli-1.11.0 → splent_cli-1.13.0}/src/splent_cli/commands/feature/feature_unlock.py

@@ -4,7 +4,6 @@ import tomllib
 import click
 import requests
 from splent_cli.services import context, compose
-from splent_cli.utils.feature_utils import read_features_from_data
 from splent_cli.utils.cache_utils import make_feature_writable
 from splent_cli.utils.proc import run
 from splent_cli.utils.io_utils import load_toml, atomic_write
@@ -343,7 +342,16 @@ def feature_edit(feature_name, edit_all, force):
     with open(pyproject_path, "rb") as f:
         data = tomllib.load(f)
 
-    features = read_features_from_data(data)
+    # Look across all feature lists (features, features_dev, features_prod) so
+    # that dev/prod-only features (e.g. admin) can also be unlocked, not just
+    # the default `features` list.
+    splent_cfg = data.get("tool", {}).get("splent", {})
+    features = [
+        entry
+        for key in ("features", "features_dev", "features_prod")
+        for entry in (splent_cfg.get(key) or [])
+        if isinstance(entry, str)
+    ]
 
     # ── Single feature ────────────────────────────────────────────────
     if feature_name:

splent_cli-1.13.0/src/splent_cli/commands/locust.py

@@ -0,0 +1,140 @@
+"""splent locust — load testing for the active product.
+
+Locust runs inside the product's web container, which already has
+splent_framework and every installed feature importable, so no extra image is
+built. Discovery is done by splent_framework's locustfile bootstrap (1.7.1+),
+which finds each feature's locustfile on its own; a feature argument narrows it
+through SPLENT_LOCUSTFILES.
+
+The web interface listens on port 8089 inside the container. Products
+scaffolded by this CLI publish that port; for an older product add
+"8089:8089" to the web service's ports and recreate the container.
+"""
+
+import os
+import shlex
+
+import click
+
+from splent_cli.services import context
+from splent_cli.utils.proc import require_docker, run
+
+# Feature locustfile locations, relative to the workspace. Kept in sync with
+# splent_framework.bootstraps.locustfile_bootstrap.DEFAULT_PATTERNS.
+FEATURE_LOCUSTFILE_PATTERNS = (
+    "features/*/{feature}/tests/load/locustfile.py",
+    "features/*/{feature}/tests/locustfile.py",
+    "features/*/{feature}/src/*/*/tests/load/locustfile.py",
+    "app/features/{feature}/tests/locustfile.py",
+)
+
+# Resolved inside the container: the framework bootstrap that discovers and
+# re-exports every feature's HttpUser classes.
+BOOTSTRAP_SNIPPET = (
+    "locust -f \"$(python -c 'import splent_framework.bootstraps.locustfile_bootstrap as m; "
+    "print(m.__file__)')\" --web-host 0.0.0.0"
+)
+
+
+def _web_container() -> str:
+    return f"{context.require_app()}_web"
+
+
+def _container_running(name: str) -> bool:
+    result = run(
+        ["docker", "ps", "-q", "-f", f"name=^{name}$"], check=False, capture=True
+    )
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
+def _locust_installed(name: str) -> bool:
+    result = run(
+        ["docker", "exec", name, "python", "-c", "import locust"],
+        check=False,
+        capture=True,
+    )
+    return result.returncode == 0
+
+
+def _feature_patterns(feature: str) -> str:
+    return ",".join(p.format(feature=feature) for p in FEATURE_LOCUSTFILE_PATTERNS)
+
+
+def _feature_has_locustfile(workspace: str, feature: str) -> bool:
+    import glob
+
+    for pattern in FEATURE_LOCUSTFILE_PATTERNS:
+        if glob.glob(os.path.join(workspace, pattern.format(feature=feature))):
+            return True
+    return False
+
+
+@click.command(
+    "locust", short_help="Run Locust load tests inside the product web container."
+)
+@click.argument("feature", required=False)
+@context.requires_product
+def locust(feature):
+    require_docker()
+    container = _web_container()
+
+    if not _container_running(container):
+        raise click.ClickException(
+            f"Container '{container}' is not running. Start the product first: splent product:up"
+        )
+
+    if not _locust_installed(container):
+        raise click.ClickException(
+            f"locust is not installed in '{container}'.\n"
+            'Add "locust" to [project.optional-dependencies].dev in the product\'s '
+            "pyproject.toml and rebuild (splent product:derive), or install it once "
+            f"with: docker exec {container} pip install locust"
+        )
+
+    workspace = str(context.workspace())
+    env_args = ["-e", "WORKING_DIR=/workspace"]
+    if feature:
+        if not _feature_has_locustfile(workspace, feature):
+            raise click.ClickException(
+                f"No locustfile found for feature '{feature}'. Looked under: "
+                + ", ".join(FEATURE_LOCUSTFILE_PATTERNS)
+            )
+        env_args += ["-e", f"SPLENT_LOCUSTFILES={_feature_patterns(feature)}"]
+
+    check = run(
+        ["docker", "exec", container, "sh", "-c", "pgrep -f 'locust' >/dev/null"],
+        check=False,
+        capture=True,
+    )
+    if check.returncode == 0:
+        click.echo("Locust is already running in the product container.")
+        return
+
+    cmd = ["docker", "exec", "-d", *env_args, container, "sh", "-c", BOOTSTRAP_SNIPPET]
+    click.echo(f"Command: {' '.join(shlex.quote(c) for c in cmd)}")
+    run(cmd)
+    click.echo(click.style("Locust is running at http://localhost:8089", fg="green"))
+    click.echo("Stop it with: splent locust:stop")
+
+
+@click.command(
+    "locust:stop", short_help="Stop the Locust process in the product web container."
+)
+@context.requires_product
+def locust_stop():
+    require_docker()
+    container = _web_container()
+
+    if not _container_running(container):
+        click.echo(f"Container '{container}' is not running; nothing to stop.")
+        return
+
+    result = run(
+        ["docker", "exec", container, "sh", "-c", "pkill -f 'locust' || true"],
+        check=False,
+        capture=True,
+    )
+    if result.returncode == 0:
+        click.echo("Locust stopped.")
+    else:
+        click.echo("No Locust process was running.")

{splent_cli-1.11.0 → splent_cli-1.13.0}/src/splent_cli/commands/spl/spl_add_feature.py

@@ -219,45 +219,42 @@ def spl_add_feature(spl_name, feature_package, org):
     with open(uvl_path, "r", encoding="utf-8") as f:
         lines = f.read().splitlines()
 
-    # Find the line before "constraints" to insert the feature
-    insert_idx = None
-    constraints_idx = None
-    for i, line in enumerate(lines):
-        if line.strip() == "constraints":
-            constraints_idx = i
-            insert_idx = i
-            break
-
-    if insert_idx is None:
-        insert_idx = len(lines)
-
-    # The line-insertion below assumes "constraints" lives on its own line.
-    # If it doesn't (e.g. malformed or unexpected layout), bail out before
-    # touching the file rather than silently corrupting the model.
-    if detected_deps and constraints_idx is None:
-        click.secho(
-            f"  ❌ No 'constraints' section found in {uvl_path}.\n"
-            f"     Refusing to edit: the UVL layout is not what this command "
-            f"expects (a 'constraints' header on its own line). "
-            f"Add the feature and constraints manually.",
-            fg="red",
-        )
-        raise SystemExit(1)
-
-    # Insert feature declaration
-    feature_line = (
-        f"\t\toptional\n\t\t\t{short_name} {{org '{org}', package '{feature_package}'}}"
+    # Locate the (optional) "constraints" header and an existing "optional" group.
+    # A fresh SPL has neither. UVL rejects an EMPTY "constraints" section, so we
+    # only create that section when there is at least one constraint to add.
+    constraints_idx = next(
+        (i for i, line in enumerate(lines) if line.strip() == "constraints"), None
     )
-    lines.insert(insert_idx, feature_line)
+    optional_idx = next(
+        (i for i, line in enumerate(lines) if line.strip() == "optional"), None
+    )
+
+    # Insert the feature under a SINGLE shared "optional" group, reusing it if it
+    # already exists (so repeated calls don't emit multiple 'optional' headers,
+    # which produced invalid UVL). The feature goes just before "constraints" if
+    # present, otherwise at the end of the features block. Indentation is tabs
+    # throughout, consistent with spl:create.
+    feat_at = constraints_idx if constraints_idx is not None else len(lines)
+    feature_decl = f"\t\t\t{short_name} {{org '{org}', package '{feature_package}'}}"
+    if optional_idx is not None:
+        lines.insert(feat_at, feature_decl)
+        if constraints_idx is not None:
+            constraints_idx += 1
+    else:
+        lines.insert(feat_at, "\t\toptional")
+        lines.insert(feat_at + 1, feature_decl)
+        if constraints_idx is not None:
+            constraints_idx += 2
 
-    # Insert constraints after "constraints" line
-    if detected_deps and constraints_idx is not None:
-        # constraints_idx shifted by 1 due to insertion above
+    # Add constraints, creating the section on demand (never leave it empty).
+    if detected_deps:
+        if constraints_idx is None:
+            lines.append("constraints")
+            constraints_idx = len(lines) - 1
+        ci = constraints_idx
         for dep in sorted(detected_deps):
-            constraints_idx += (
-                2  # +1 for feature line (2 lines), +1 for each constraint
-            )
-            lines.insert(constraints_idx, f"\t{short_name} => {dep}")
+            ci += 1
+            lines.insert(ci, f"\t{short_name} => {dep}")
 
     # Back up the original UVL, then write atomically so a crash mid-write can
     # never leave a half-written / truncated model.

splent_cli-1.13.0/src/splent_cli/commands/spl/spl_compare.py

@@ -0,0 +1,88 @@
+import click
+
+from splent_cli.services import context
+from splent_cli.utils.feature_utils import (
+    load_product_features,
+    parse_feature_entry,
+)
+
+
+def _load_feature_map(product_name: str) -> dict[tuple[str, str], str]:
+    """Return {(org, package): "org/package"} for a product in the workspace.
+
+    Features are keyed by (organisation, package) so that two features only
+    match when BOTH the org/user and the package coincide. The version is
+    ignored on purpose — a product on v1.2.0 and another on v1.3.0 of the same
+    feature still share that feature.
+    """
+    product_dir = context.workspace() / product_name
+    if not (product_dir / "pyproject.toml").is_file():
+        raise click.ClickException(
+            f"Product not found: '{product_name}' (no pyproject.toml in {product_dir})"
+        )
+
+    feature_map: dict[tuple[str, str], str] = {}
+    for entry in load_product_features(str(product_dir)):
+        org, package, _version = parse_feature_entry(entry)
+        feature_map[(org, package)] = f"{org}/{package}"
+    return feature_map
+
+
+def _print_block(title: str, color: str, keys: list[tuple[str, str]]) -> None:
+    click.secho(f"  {title} ({len(keys)})", fg=color, bold=True)
+    if not keys:
+        click.secho("    —", fg="bright_black")
+    for org, package in keys:
+        click.echo(f"    {org}/{package}")
+    click.echo()
+
+
+@click.command(
+    "spl:compare",
+    short_help="Compare the features of two products (shared vs product-specific)",
+)
+@click.argument("product_a")
+@click.argument("product_b")
+@context.requires_detached
+def spl_compare(product_a, product_b):
+    """Compare two products in the workspace by their feature sets.
+
+    Reports the features they SHARE and the features SPECIFIC to each one.
+    Matching is done by organisation/package — two features are "the same"
+    only when both the org (or user) and the package name coincide.
+
+    \b
+    Example:
+        splent spl:compare innosoft_app diversolab_app
+    """
+    a = _load_feature_map(product_a)
+    b = _load_feature_map(product_b)
+
+    a_keys, b_keys = set(a), set(b)
+    shared = sorted(a_keys & b_keys)
+    only_a = sorted(a_keys - b_keys)
+    only_b = sorted(b_keys - a_keys)
+
+    union = a_keys | b_keys
+    reuse_pct = (len(shared) / len(union) * 100) if union else 0.0
+
+    click.echo()
+    click.secho(f"  {product_a}  ↔  {product_b}", fg="cyan", bold=True)
+    click.echo(
+        f"  {len(a_keys)} feature(s) in {product_a}"
+        f"   ·   {len(b_keys)} feature(s) in {product_b}"
+    )
+    reuse_color = "green" if reuse_pct >= 50 else "yellow"
+    click.secho(
+        f"  Reuse: {len(shared)}/{len(union)} shared ({reuse_pct:.0f}%)",
+        fg=reuse_color,
+        bold=True,
+    )
+    click.echo()
+
+    _print_block("Shared", "green", shared)
+    _print_block(f"Only in {product_a}", "yellow", only_a)
+    _print_block(f"Only in {product_b}", "magenta", only_b)
+
+
+cli_command = spl_compare

{splent_cli-1.11.0 → splent_cli-1.13.0}/src/splent_cli/commands/spl/spl_create.py

@@ -35,7 +35,10 @@ def spl_create(name):
 
     # {name}.uvl
     uvl_path = os.path.join(spl_dir, f"{name}.uvl")
-    uvl_content = f"features\n    {name}\n        mandatory\n\nconstraints\n"
+    # A fresh SPL has no features yet — emit a minimal VALID model (just the
+    # root, no empty 'mandatory'/'optional' group, which UVL rejects). Tabs are
+    # used for indentation, consistent with spl:add-feature.
+    uvl_content = f"features\n\t{name}\n"
     with open(uvl_path, "w") as f:
         f.write(uvl_content)
 

{splent_cli-1.11.0 → splent_cli-1.13.0}/src/splent_cli/utils/dynamic_imports.py

@@ -10,6 +10,10 @@ from splent_framework.utils.path_utils import PathUtils
 from splent_cli.utils.io_utils import load_toml
 from splent_cli.utils.proc import run
 
+# What the operator actually exported, captured before any .env is applied.
+# Precedence from here on: shell environment > product .env > workspace .env.
+_shell_env = dict(os.environ)
+
 load_dotenv()
 
 _app_instance = None
@@ -21,7 +25,13 @@ dotenv_path = None
 if module_name:
     dotenv_path = PathUtils.get_app_env_file()
     if os.path.exists(dotenv_path):
+        # The product's .env beats the workspace .env, hence override=True.
+        # But it must never beat the process environment: a product .env
+        # carries container paths (WORKING_DIR=/workspace/), and blindly
+        # overriding made the CLI unusable from the host, because whatever
+        # WORKING_DIR the operator exported was clobbered on import.
         load_dotenv(dotenv_path, override=True)
+        os.environ.update(_shell_env)
 
 
 def install_features_if_needed():

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.11.0
+Version: 1.13.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.11.0 → splent_cli-1.13.0}/src/splent_cli.egg-info/SOURCES.txt

@@ -134,6 +134,7 @@ src/splent_cli/commands/release/release_core.py
 src/splent_cli/commands/spl/__init__.py
 src/splent_cli/commands/spl/spl_add_constraints.py
 src/splent_cli/commands/spl/spl_add_feature.py
+src/splent_cli/commands/spl/spl_compare.py
 src/splent_cli/commands/spl/spl_configurations.py
 src/splent_cli/commands/spl/spl_create.py
 src/splent_cli/commands/spl/spl_deps.py