splent-cli 1.2.8__tar.gz → 1.4.0__tar.gz

{splent_cli-1.2.8/src/splent_cli.egg-info → splent_cli-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.2.8
+Version: 1.4.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.2.8 → splent_cli-1.4.0}/pyproject.toml

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

@@ -0,0 +1,149 @@
+import os
+
+import click
+from dotenv import load_dotenv
+
+from splent_cli.utils.dynamic_imports import get_app
+from splent_cli.utils.command_loader import load_commands
+from splent_cli.utils.db_utils import check_db_connection
+
+load_dotenv()
+
+
+class SPLENTCLI(click.Group):
+    """
+    Main SPLENT CLI class.
+
+    - Automatically injects the Flask app context for commands marked with `requires_app = True`.
+    - Checks DB connectivity for commands marked with `requires_db = True`.
+    - Discovers CLI commands contributed by features via ``app.extensions["splent_feature_commands"]``.
+    - Displays commands grouped by category for a cleaner, more readable help output.
+    """
+
+    # ── Feature-contributed commands ──────────────────────────────
+
+    def _load_feature_commands(self) -> dict[str, click.BaseCommand]:
+        """Return ``{"feature:<name>": click.Group, ...}`` from the Flask app.
+
+        Each feature that defines CLI commands gets a Click Group registered
+        as ``feature:<short_name>``.  Individual commands become subcommands::
+
+            splent feature:mail config
+            splent feature:mail check --to user@example.com
+
+        Commands are only available when a product is active and the app can
+        be built.  On any failure the result is an empty dict — built-in CLI
+        commands are never affected.
+        """
+        if hasattr(self, "_feature_cmds_cache"):
+            return self._feature_cmds_cache
+
+        self._feature_cmds_cache: dict[str, click.BaseCommand] = {}
+        try:
+            app = get_app()
+            with app.app_context():
+                registry = app.extensions.get("splent_feature_commands", {})
+                for feature_short, commands in registry.items():
+                    group = click.Group(
+                        name=f"feature:{feature_short}",
+                        help=f"Commands contributed by splent_feature_{feature_short}.",
+                    )
+                    group.requires_app = True  # type: ignore[attr-defined]
+                    for cmd in commands:
+                        group.add_command(cmd)
+                    self._feature_cmds_cache[group.name] = group
+        except Exception as e:
+            if os.getenv("SPLENT_DEBUG"):
+                click.secho(f"  ⚠ Feature commands not loaded: {e}", fg="yellow", err=True)
+        return self._feature_cmds_cache
+
+    def get_command(self, ctx, cmd_name):
+        # Built-in commands take priority
+        cmd = super().get_command(ctx, cmd_name)
+        if cmd is not None:
+            return cmd
+        # Fall back to feature-contributed command groups
+        feat_cmds = self._load_feature_commands()
+        return feat_cmds.get(cmd_name)
+
+    def list_commands(self, ctx):
+        builtin = super().list_commands(ctx)
+        feat = sorted(self._load_feature_commands().keys())
+        return builtin + feat
+
+    # ── App context injection ─────────────────────────────────────
+
+    def invoke(self, ctx):
+        cmd_name = ctx.protected_args[0] if ctx.protected_args else None
+        command = self.get_command(ctx, cmd_name)
+
+        if command and getattr(command, "requires_app", False):
+            app = get_app()
+            if getattr(command, "requires_db", False):
+                if not check_db_connection(app):
+                    raise SystemExit(1)
+            with app.app_context():
+                return super().invoke(ctx)
+
+        return super().invoke(ctx)
+
+    def format_commands(self, ctx, formatter):
+        """Group SPLENT commands by category in the CLI help output."""
+        all_cmds = self.list_commands(ctx)
+        groups = {
+            "🌿 Feature Management": [
+                cmd for cmd in all_cmds
+                if cmd.startswith("feature:") and cmd not in self._load_feature_commands()
+            ],
+            "🏗️ Product Management": [
+                cmd for cmd in all_cmds if cmd.startswith("product:")
+            ],
+            "🧬 SPL & Variability": [
+                cmd for cmd in all_cmds if cmd.startswith(("spl:", "uvl:"))
+            ],
+            "🧱 Database": [cmd for cmd in all_cmds if cmd.startswith("db:")],
+            "💾 Cache": [cmd for cmd in all_cmds if cmd.startswith("cache:")],
+            "🧰 Utilities": [
+                cmd
+                for cmd in all_cmds
+                if cmd.startswith(
+                    ("clear:", "env", "select", "info", "version", "doctor", "tokens")
+                )
+            ],
+            "🐍 Development & QA": [
+                cmd
+                for cmd in all_cmds
+                if cmd.startswith(("linter", "test", "coverage", "locust"))
+            ],
+            "🔌 Feature Commands": [
+                cmd for cmd in all_cmds
+                if cmd in self._load_feature_commands()
+            ],
+        }
+        for title, cmds in groups.items():
+            if not cmds:
+                continue
+
+            with formatter.section(title):
+                rows = []
+                for cmd_name in sorted(cmds):
+                    cmd = self.get_command(ctx, cmd_name)
+                    if cmd is None or cmd.hidden:
+                        continue
+                    rows.append((cmd_name, cmd.get_short_help_str()))
+                if rows:
+                    formatter.write_dl(rows)
+
+
+@click.group(cls=SPLENTCLI)
+def cli():
+    """Command-line interface for managing SPLENT products, features, environments, and development workflows."""
+    pass
+
+
+# Automatically load all command modules
+load_commands(cli)
+
+
+if __name__ == "__main__":
+    cli()

{splent_cli-1.2.8 → splent_cli-1.4.0}/src/splent_cli/commands/cache/cache_versions.py

@@ -1,4 +1,5 @@
 from splent_cli.services import context
+from splent_cli.utils.feature_utils import normalize_namespace
 import click
 
 
@@ -17,7 +18,7 @@ def cache_versions(feature_ref: str):
         raise SystemExit(1)
 
     ns, name = feature_ref.split("/", 1)
-    ns_fs = ns.replace("-", "_")
+    ns_fs = normalize_namespace(ns)
 
     workspace = context.workspace()
     ns_dir = workspace / ".splent_cache" / "features" / ns_fs

{splent_cli-1.2.8 → splent_cli-1.4.0}/src/splent_cli/commands/check/check_deps.py

@@ -85,12 +85,15 @@ def _parse_uvl_deps(uvl_path: str) -> tuple[dict[str, str], dict[str, set[str]]]
 
 def _scan_feature_imports(
     feature_path: str, feature_name: str, all_packages: set[str]
-) -> set[str]:
-    """Scan all .py files in a feature and return set of other feature packages imported."""
-    imported: set[str] = set()
+) -> tuple[set[str], set[str]]:
+    """Scan a feature's source code and templates for cross-feature dependencies.
+
+    Returns (python_imports, template_deps) — both sets of package names.
+    """
+    python_imports: set[str] = set()
+    template_deps: set[str] = set()
 
     src_dir = None
-    # Find the src directory
     for org_dir in os.listdir(os.path.join(feature_path, "src")):
         candidate = os.path.join(feature_path, "src", org_dir, feature_name)
         if os.path.isdir(candidate):
@@ -98,27 +101,46 @@ def _scan_feature_imports(
             break
 
     if not src_dir:
-        return imported
+        return python_imports, template_deps
+
+    # Map blueprint names to package names for template dependency detection
+    # Convention: blueprint name is the feature short name (e.g. "auth" for splent_feature_auth)
+    bp_to_pkg = {}
+    for pkg in all_packages:
+        short = pkg.replace("splent_feature_", "")
+        bp_to_pkg[short] = pkg
 
     for root, _, files in os.walk(src_dir):
         for f in files:
-            if not f.endswith(".py"):
-                continue
             filepath = os.path.join(root, f)
-            try:
-                with open(filepath, "r", encoding="utf-8") as fh:
-                    content = fh.read()
-            except (OSError, PermissionError):
-                continue
 
-            # Find imports: from splent_io.splent_feature_X... or import splent_io.splent_feature_X
-            for match in re.findall(
-                r"(?:from|import)\s+splent_io\.(splent_feature_\w+)", content
-            ):
-                if match != feature_name and match in all_packages:
-                    imported.add(match)
+            if f.endswith(".py"):
+                try:
+                    with open(filepath, "r", encoding="utf-8") as fh:
+                        content = fh.read()
+                except (OSError, PermissionError):
+                    continue
+
+                for match in re.findall(
+                    r"(?:from|import)\s+splent_io\.(splent_feature_\w+)", content
+                ):
+                    if match != feature_name and match in all_packages:
+                        python_imports.add(match)
+
+            elif f.endswith(".html"):
+                try:
+                    with open(filepath, "r", encoding="utf-8") as fh:
+                        content = fh.read()
+                except (OSError, PermissionError):
+                    continue
 
-    return imported
+                # Detect url_for('blueprint.endpoint', ...) references to other features
+                for bp_name in re.findall(r"url_for\s*\(\s*['\"](\w+)\.", content):
+                    pkg = bp_to_pkg.get(bp_name)
+                    if pkg and pkg != feature_name:
+                        template_deps.add(pkg)
+
+    return python_imports, template_deps
 
 
 # ---------------------------------------------------------------------------
@@ -174,20 +196,24 @@ def check_deps():
     product = context.require_app()
     product_dir = os.path.join(workspace, product)
 
-    # Read UVL
+    # Read UVL (catalog or legacy)
     try:
         reader = PyprojectReader.for_product(product_dir)
-        uvl_cfg = reader.uvl_config
+        # 1. Catalog: [tool.splent].spl
+        spl_name = reader.splent_config.get("spl")
+        if spl_name:
+            uvl_path = os.path.join(workspace, "splent_catalog", spl_name, f"{spl_name}.uvl")
+        else:
+            # 2. Legacy: [tool.splent.uvl].file
+            uvl_file = reader.uvl_config.get("file")
+            if not uvl_file:
+                click.secho("  [✖] No UVL configured. Set [tool.splent].spl or [tool.splent.uvl].file.", fg="red")
+                raise SystemExit(1)
+            uvl_path = os.path.join(product_dir, "uvl", uvl_file)
     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.", 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")
         raise SystemExit(1)
@@ -217,40 +243,42 @@ def check_deps():
             )
             continue
 
-        actual_imports = _scan_feature_imports(fpath, pkg_name, all_packages)
+        py_imports, tpl_deps = _scan_feature_imports(fpath, pkg_name, all_packages)
         allowed = allowed_deps.get(pkg_name, set())
+        all_deps = py_imports | tpl_deps
 
-        if not actual_imports:
+        if not all_deps:
             click.echo(
                 click.style("  [✔] ", fg="green")
                 + click.style(f"{short}", bold=True)
-                + " — no cross-feature imports"
+                + " — no cross-feature dependencies"
             )
             ok += 1
             continue
 
         has_violation = False
-        for imp in sorted(actual_imports):
+
+        for imp in sorted(all_deps):
             imp_short = pkg_to_short.get(imp, imp)
+            source = "imports" if imp in py_imports else "references (template)"
 
             if imp in allowed:
                 click.echo(
                     click.style("  [✔] ", fg="green")
                     + click.style(f"{short}", bold=True)
-                    + f" imports {imp_short}"
+                    + f" {source} {imp_short}"
                     + click.style(
                         f"  (allowed: {short} => {imp_short})", fg="bright_black"
                     )
                 )
                 ok += 1
             else:
-                # Check if the reverse is declared (inverted dependency)
                 reverse_allowed = allowed_deps.get(imp, set())
                 if pkg_name in reverse_allowed:
                     click.echo(
                         click.style("  [✖] ", fg="red")
                         + click.style(f"{short}", bold=True)
-                        + f" imports {imp_short}"
+                        + f" {source} {imp_short}"
                         + click.style(
                             f"  INVERTED — UVL says {imp_short} => {short}, not the reverse",
                             fg="red",
@@ -260,7 +288,7 @@ def check_deps():
                     click.echo(
                         click.style("  [✖] ", fg="red")
                         + click.style(f"{short}", bold=True)
-                        + f" imports {imp_short}"
+                        + f" {source} {imp_short}"
                         + click.style(
                             f"  UNDECLARED — no UVL constraint between {short} and {imp_short}",
                             fg="red",
@@ -269,9 +297,6 @@ def check_deps():
                 violations += 1
                 has_violation = True
 
-        if not has_violation:
-            pass  # all imports were OK, already printed
-
     click.echo()
     if violations:
         click.secho(

{splent_cli-1.2.8 → splent_cli-1.4.0}/src/splent_cli/commands/check/check_features.py

@@ -10,7 +10,7 @@ import click
 import tomllib
 
 from splent_cli.services import context
-from splent_cli.utils.feature_utils import read_features_from_data
+from splent_cli.utils.feature_utils import normalize_namespace, read_features_from_data
 
 
 def _pkg_installed(name: str) -> bool:
@@ -72,7 +72,7 @@ def check_features():
         # Parse entry
         if "/" in entry:
             org_raw, rest = entry.split("/", 1)
-            org_safe = org_raw.replace("-", "_").replace(".", "_")
+            org_safe = normalize_namespace(org_raw)
         else:
             org_safe = "splent_io"
             rest = entry

splent_cli-1.4.0/src/splent_cli/commands/check/check_infra.py

@@ -0,0 +1,222 @@
+"""
+check:infra — Validate Docker infrastructure declarations (ports, services, containers, networks).
+"""
+
+import os
+import subprocess
+import json
+
+import click
+import tomllib
+
+from splent_cli.services import context, compose
+from splent_cli.utils.feature_utils import read_features_from_data
+
+
+def _parse_compose_ports(compose_file: str) -> list[tuple[int, str, str]]:
+    """Return [(host_port, service_name, source_label)] from a compose file."""
+    result = subprocess.run(
+        ["docker", "compose", "-f", compose_file, "config", "--format", "json"],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return []
+    try:
+        config = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return []
+
+    ports = []
+    for svc_name, svc in config.get("services", {}).items():
+        for port in svc.get("ports", []):
+            published = port.get("published") if isinstance(port, dict) else None
+            if published:
+                try:
+                    ports.append((int(published), svc_name, compose_file))
+                except (ValueError, TypeError):
+                    pass
+    return ports
+
+
+def _parse_compose_services(compose_file: str) -> list[tuple[str, str, str]]:
+    """Return [(service_name, container_name_or_None, source_label)]."""
+    result = subprocess.run(
+        ["docker", "compose", "-f", compose_file, "config", "--format", "json"],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return []
+    try:
+        config = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return []
+
+    services = []
+    for svc_name, svc in config.get("services", {}).items():
+        container_name = svc.get("container_name")
+        services.append((svc_name, container_name, compose_file))
+    return services
+
+
+@click.command("check:infra", short_help="Validate Docker infrastructure (ports, services, networks).")
+def check_infra():
+    """Check for port conflicts, duplicate services, container name collisions,
+    and network availability across all features and the product."""
+    workspace = str(context.workspace())
+    product = context.require_app()
+    product_path = os.path.join(workspace, product)
+    pyproject_path = os.path.join(product_path, "pyproject.toml")
+
+    ok = fail = warn = 0
+
+    def _ok(msg):
+        nonlocal ok
+        ok += 1
+        click.echo(click.style("  [OK] ", fg="green") + msg)
+
+    def _fail(msg):
+        nonlocal fail
+        fail += 1
+        click.echo(click.style("  [FAIL] ", fg="red") + msg)
+
+    def _warn(msg):
+        nonlocal warn
+        warn += 1
+        click.echo(click.style("  [WARN] ", fg="yellow") + msg)
+
+    click.echo()
+    click.echo(click.style("  Infrastructure check", bold=True))
+    click.echo()
+
+    if not os.path.exists(pyproject_path):
+        _fail("pyproject.toml not found")
+        raise SystemExit(1)
+
+    with open(pyproject_path, "rb") as f:
+        data = tomllib.load(f)
+
+    env = os.getenv("SPLENT_ENV", "dev")
+    features = read_features_from_data(data, env)
+
+    # Collect all compose files
+    compose_files: list[tuple[str, str]] = []  # (label, path)
+
+    for feat in features:
+        clean = compose.normalize_feature_ref(feat)
+        bare_name = clean.split("/")[-1] if "/" in clean else clean
+        feat_base = os.path.dirname(compose.feature_docker_dir(workspace, bare_name))
+        cf = compose.resolve_file(feat_base, env)
+        if cf:
+            compose_files.append((bare_name, cf))
+
+    cf = compose.resolve_file(product_path, env)
+    if cf:
+        compose_files.append((product, cf))
+
+    # --- Check 1: Port conflicts between declarations ---
+    click.echo(click.style("  Ports", bold=True))
+    all_ports: dict[int, list[str]] = {}  # port -> [labels]
+    for label, cf in compose_files:
+        for host_port, svc_name, _ in _parse_compose_ports(cf):
+            all_ports.setdefault(host_port, []).append(f"{label}/{svc_name}")
+
+    port_conflicts = {p: srcs for p, srcs in all_ports.items() if len(srcs) > 1}
+    if port_conflicts:
+        for port, sources in sorted(port_conflicts.items()):
+            _fail(f"Port {port} declared by multiple services: {', '.join(sources)}")
+    else:
+        _ok(f"No port conflicts ({len(all_ports)} ports declared)")
+
+    # Check against running containers
+    running_conflicts = []
+    for port in all_ports:
+        result = subprocess.run(
+            ["docker", "ps", "--format", "{{.ID}}\t{{.Names}}\t{{.Ports}}"],
+            capture_output=True, text=True,
+        )
+        for line in result.stdout.splitlines():
+            parts = line.split("\t", 2)
+            if len(parts) < 3:
+                continue
+            cid, name, ports_str = parts
+            if f":{port}->" in ports_str:
+                running_conflicts.append((port, name))
+
+    if running_conflicts:
+        for port, cname in running_conflicts:
+            _warn(f"Port {port} already in use by running container: {cname}")
+    else:
+        _ok("No conflicts with running containers")
+
+    # --- Check 2: Service name collisions ---
+    click.echo()
+    click.echo(click.style("  Services", bold=True))
+    all_services: dict[str, list[str]] = {}  # svc_name -> [labels]
+    all_container_names: dict[str, list[str]] = {}  # container_name -> [labels]
+
+    for label, cf in compose_files:
+        for svc_name, container_name, _ in _parse_compose_services(cf):
+            all_services.setdefault(svc_name, []).append(label)
+            if container_name:
+                all_container_names.setdefault(container_name, []).append(label)
+
+    svc_conflicts = {s: srcs for s, srcs in all_services.items() if len(srcs) > 1}
+    if svc_conflicts:
+        for svc, sources in sorted(svc_conflicts.items()):
+            _warn(f"Service '{svc}' defined by multiple features: {', '.join(sources)}")
+    else:
+        _ok(f"No service name collisions ({len(all_services)} services)")
+
+    cn_conflicts = {c: srcs for c, srcs in all_container_names.items() if len(srcs) > 1}
+    if cn_conflicts:
+        for cn, sources in sorted(cn_conflicts.items()):
+            _fail(f"Container name '{cn}' used by multiple features: {', '.join(sources)}")
+    else:
+        _ok(f"No container name collisions ({len(all_container_names)} named containers)")
+
+    # --- Check 3: Network availability ---
+    click.echo()
+    click.echo(click.style("  Networks", bold=True))
+    required_networks: set[str] = set()
+    for label, cf in compose_files:
+        result = subprocess.run(
+            ["docker", "compose", "-f", cf, "config", "--format", "json"],
+            capture_output=True, text=True,
+        )
+        if result.returncode != 0:
+            continue
+        try:
+            config = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            continue
+        for net_name, net_def in config.get("networks", {}).items():
+            if isinstance(net_def, dict) and net_def.get("external"):
+                required_networks.add(net_name)
+
+    if required_networks:
+        existing_networks = subprocess.run(
+            ["docker", "network", "ls", "--format", "{{.Name}}"],
+            capture_output=True, text=True,
+        ).stdout.splitlines()
+        for net in sorted(required_networks):
+            if net in existing_networks:
+                _ok(f"Network '{net}' exists")
+            else:
+                _fail(f"External network '{net}' does not exist (run: docker network create {net})")
+    else:
+        _ok("No external networks required")
+
+    # --- Summary ---
+    click.echo()
+    total = ok + fail + warn
+    if fail:
+        click.secho(f"  {fail} check(s) failed, {warn} warning(s), {ok} passed.", fg="red")
+        raise SystemExit(1)
+    elif warn:
+        click.secho(f"  All passed with {warn} warning(s) ({ok} checks OK).", fg="yellow")
+    else:
+        click.secho(f"  All {ok} checks passed.", fg="green")
+    click.echo()
+
+
+cli_command = check_infra