splent-cli 1.22.2__tar.gz → 1.24.0__tar.gz

{splent_cli-1.22.2/src/splent_cli.egg-info → splent_cli-1.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.22.2
+Version: 1.24.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
@@ -9,9 +9,12 @@ Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click==8.1.8
+Requires-Dist: jinja2>=3.1
 Requires-Dist: packaging>=24.0
+Requires-Dist: python-dotenv>=1.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.31.0
+Requires-Dist: splent_framework<2,>=1.15.0
 Requires-Dist: tomli_w>=1.0.0
 Provides-Extra: dev
 Requires-Dist: setuptools==80.3.1; extra == "dev"

{splent_cli-1.22.2 → splent_cli-1.24.0}/pyproject.toml

@@ -4,18 +4,27 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.22.2"
+version = "1.24.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"
 authors = [{ name = "DiversoLab", email = "diversolab@us.es" }]
 license-files = ["LICENSE"]
 
+# Everything the CLI imports at module level must be listed here (or come
+# with splent_framework, see tests/unit/test_declared_dependencies.py):
+# startup imports every command module, so one undeclared import breaks
+# `splent --help` on a clean `pip install splent_cli`.
 dependencies = [
     "click==8.1.8",
+    "jinja2>=3.1",
     "packaging>=24.0",
+    "python-dotenv>=1.0",
     "pyyaml>=6.0",
     "requests>=2.31.0",
+    # The CLI drives the framework (paths, feature order, migrations, the
+    # app factory) and only works with the same major version of it.
+    "splent_framework>=1.15.0,<2",
     "tomli_w>=1.0.0",
 ]
 

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/cli.py

@@ -1,3 +1,4 @@
+import logging
 import os
 
 import click
@@ -37,6 +38,15 @@ class SPLENTCLI(click.Group):
             return self._feature_cmds_cache
 
         self._feature_cmds_cache: dict[str, click.BaseCommand] = {}
+        # Discovery runs before every command, including the ones a product
+        # that is not built yet (selected, not configured or derived) runs
+        # while getting there. Building its app then fails, and the framework
+        # logged that failure with a full traceback on every single command,
+        # although nothing was wrong. The failure is expected here and
+        # handled below, so the framework's logging is muted for the attempt.
+        debug = bool(os.getenv("SPLENT_DEBUG"))
+        if not debug:
+            logging.disable(logging.CRITICAL)
         try:
             from splent_cli.utils.dynamic_imports import get_app
 
@@ -57,10 +67,13 @@ class SPLENTCLI(click.Group):
                         group.add_command(cmd)
                     self._feature_cmds_cache[group.name] = group
         except Exception as e:
-            if os.getenv("SPLENT_DEBUG"):
+            if debug:
                 click.secho(
                     f"  ⚠ Feature commands not loaded: {e}", fg="yellow", err=True
                 )
+        finally:
+            if not debug:
+                logging.disable(logging.NOTSET)
         return self._feature_cmds_cache
 
     def get_command(self, ctx, cmd_name):

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/check/check_contracts.py

@@ -17,6 +17,7 @@ import click
 import tomllib
 
 from splent_cli.services import context, marketplace, spl_store
+from splent_cli.utils import forge
 
 
 def _snapshot_version_key(pyproject_path: Path) -> tuple:
@@ -65,7 +66,7 @@ def _local_contract_requires(workspace: str, package: str) -> list[str] | None:
 
 
 def _exists_remotely(org: str | None, package: str) -> bool:
-    """Whether a feature not present locally at least exists on GitHub.
+    """Whether a feature not present locally at least exists on the forge.
 
     Answers True whenever the question cannot be settled: no org to look
     under, no network, a rate limit, anything unexpected. A diagnostic that
@@ -78,10 +79,27 @@ def _exists_remotely(org: str | None, package: str) -> bool:
     import urllib.error
     import urllib.request
 
-    # The UVL writes the org the way GitHub spells it ("splent-io"), which is
-    # not the way the filesystem does ("splent_io"), so it is used verbatim.
-    url = f"https://github.com/{org}/{package}"
-    request = urllib.request.Request(url, method="HEAD")
+    # The UVL writes the org the way the forge spells it ("splent-io"), which
+    # is not the way the filesystem does ("splent_io"), so it is used verbatim.
+    #
+    # GitHub keeps the anonymous HEAD against the web URL it has always used.
+    # A self-hosted forge is far likelier to keep its repositories private, and
+    # a private repository answers 404 to a stranger, which would read here as
+    # a feature nobody ever wrote. When such a forge gives us a token we ask
+    # its API instead, with GET because Gitea-compatible routes are registered
+    # for GET alone and answer a HEAD with 405.
+    token = None if forge.is_github() else forge.token()
+    if token:
+        request = urllib.request.Request(
+            f"{forge.api_base()}/repos/{org}/{package}",
+            headers={
+                "Authorization": f"token {token}",
+                "Accept": "application/json",
+                "User-Agent": "splent-cli",
+            },
+        )
+    else:
+        request = urllib.request.Request(forge.web_url(org, package), method="HEAD")
     try:
         with urllib.request.urlopen(request, timeout=10) as response:
             return response.status < 400
@@ -230,7 +248,7 @@ def check_contracts(spl_name):
             click.secho(
                 f"  ✗ {short} is offered by the model but does not exist: "
                 f"{meta.get('org')}/{meta['package']} is not in this workspace, "
-                f"not in the cache and not on GitHub",
+                f"not in the cache and not on {forge.host()}",
                 fg="red",
             )
             click.echo(

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/check/check_env.py

@@ -8,6 +8,8 @@ import sys
 import click
 import importlib.metadata
 
+from splent_cli.utils import forge
+
 
 def _pkg_version(name: str) -> str | None:
     try:
@@ -88,11 +90,12 @@ def check_env():
             f"CLI={'?' if not cli_v else cli_v} / Framework={'?' if not fw_v else fw_v}"
         )
 
-    # Credentials
-    if os.getenv("GITHUB_TOKEN"):
-        _ok("GITHUB_TOKEN set")
+    # Credentials. The forge token is named after the forge in use: asking for
+    # GITHUB_TOKEN on a git.splent.io workspace sent people to the wrong place.
+    if forge.token():
+        _ok(f"{forge.token_env_name()} set ({forge.host()})")
     else:
-        _warn("GITHUB_TOKEN not set")
+        _warn(f"{forge.token_env_name()} not set ({forge.host()})")
 
     if os.getenv("TWINE_PASSWORD") or os.getenv("PYPI_TOKEN"):
         _ok("PyPI token set")

splent_cli-1.24.0/src/splent_cli/commands/check/check_github.py

@@ -0,0 +1,126 @@
+import os
+import urllib.request
+import urllib.error
+import json
+import click
+
+from splent_cli.utils import forge
+
+
+@click.command(
+    "check:github",
+    short_help="Verify forge credentials from .env (GITHUB_USER / forge token)",
+)
+def check_github():
+    # The command keeps its name, but the forge it checks is whatever the
+    # workspace is configured against: github.com by default, a self-hosted
+    # Forgejo when SPLENT_FORGE_HOST says so.
+    forge_host = forge.host()
+    token_var = forge.token_env_name()
+
+    click.echo(click.style(f"\n{forge_host} Credentials Check\n", fg="cyan", bold=True))
+
+    user = os.getenv("GITHUB_USER", "").strip()
+    # Resolved through forge so a self-hosted forge reads SPLENT_FORGE_TOKEN
+    # while GitHub keeps reading GITHUB_TOKEN, as it always has.
+    token = (forge.token() or "").strip()
+
+    # --- presence checks ---
+    if not user:
+        click.echo(click.style("[✖] ", fg="red") + "GITHUB_USER not set in .env")
+        click.secho(
+            "   Run 'splent tokens:setup' for setup instructions.", fg="bright_black"
+        )
+        raise SystemExit(1)
+    click.echo(click.style("[✔] ", fg="green") + f"GITHUB_USER = {user}")
+
+    if not token:
+        click.echo(click.style("[✖] ", fg="red") + f"{token_var} not set in .env")
+        click.secho(
+            "   Run 'splent tokens:setup' for setup instructions.", fg="bright_black"
+        )
+        raise SystemExit(1)
+
+    masked = token[:4] + "*" * (len(token) - 8) + token[-4:]
+    click.echo(click.style("[✔] ", fg="green") + f"{token_var} = {masked}")
+
+    # --- API call ---
+    # Vendor media types are GitHub's own; a Gitea-compatible forge does not
+    # know them and answers plain JSON, so they are only sent to GitHub.
+    headers = {
+        "Authorization": f"token {token}",
+        "Accept": "application/json",
+        "User-Agent": "splent-cli",
+    }
+    if forge.is_github():
+        headers["Accept"] = "application/vnd.github+json"
+        headers["X-GitHub-Api-Version"] = "2022-11-28"
+
+    click.echo(f"\nContacting the {forge_host} API...")
+    req = urllib.request.Request(f"{forge.api_base()}/user", headers=headers)
+
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode())
+            rate_remaining = resp.headers.get("X-RateLimit-Remaining", "?")
+            rate_limit = resp.headers.get("X-RateLimit-Limit", "?")
+    except urllib.error.HTTPError as e:
+        if e.code == 401:
+            click.echo(
+                click.style("[✖] ", fg="red")
+                + "Token invalid or expired (401 Unauthorized)"
+            )
+            click.secho(
+                "   Run 'splent tokens:setup' for instructions on obtaining a valid token.",
+                fg="bright_black",
+            )
+        elif e.code == 403:
+            click.echo(
+                click.style("[✖] ", fg="red")
+                + "Token lacks required permissions (403 Forbidden)"
+            )
+            scope = "repo" if forge.is_github() else "write:repository"
+            click.secho(
+                f"   Run 'splent tokens:setup', the token needs the '{scope}' scope.",
+                fg="bright_black",
+            )
+        else:
+            click.echo(
+                click.style("[✖] ", fg="red") + f"{forge_host} API error: HTTP {e.code}"
+            )
+        raise SystemExit(1)
+    except urllib.error.URLError as e:
+        click.echo(click.style("[✖] ", fg="red") + f"Network error: {e.reason}")
+        raise SystemExit(1)
+
+    # --- validate identity ---
+    api_login = data.get("login", "")
+    if api_login.lower() != user.lower():
+        click.echo(
+            click.style("[⚠] ", fg="yellow")
+            + f"Token belongs to '{api_login}', but GITHUB_USER is '{user}'"
+        )
+    else:
+        click.echo(click.style("[✔] ", fg="green") + f"Authenticated as {api_login}")
+
+    # GitHub calls the display name "name"; a Gitea-compatible forge calls it
+    # "full_name", so without the fallback every Forgejo check reported "-".
+    name = data.get("name") or data.get("full_name") or "-"
+    click.echo(click.style("[✔] ", fg="green") + f"Name: {name}")
+
+    # The plan and the rate limit headers are GitHub's alone. A Gitea-compatible
+    # forge answers /user without either, and printing "-" and "?/? remaining"
+    # would read as a fault rather than as an absence.
+    if forge.is_github():
+        plan = (data.get("plan") or {}).get("name", "-")
+        click.echo(click.style("[✔] ", fg="green") + f"Plan: {plan}")
+        click.echo(
+            click.style("[✔] ", fg="green")
+            + f"Rate limit: {rate_remaining}/{rate_limit} remaining"
+        )
+
+    click.echo()
+    click.secho(f"Credentials for {forge_host} OK.", fg="green")
+
+
+cli_command = check_github

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/check/check_infra.py

@@ -382,17 +382,33 @@ def check_infra():
     else:
         _ok(f"No port conflicts ({len(all_ports)} ports declared)")
 
-    # Check against running containers (query docker ps once, not per-port)
+    # Check against running containers (query docker ps once, not per-port).
+    # The product's own stacks are not conflicts: with the product up, every
+    # declared port is held by exactly the container meant to hold it, and
+    # reporting those as warnings made a healthy product look broken.
+    own_projects = {compose.project_name(product, env)} | {
+        compose.feature_project_name(compose.normalize_feature_ref(f), product, env)
+        for f in features
+    }
     running_conflicts = []
-    ps_result = _run(["docker", "ps", "--format", "{{.ID}}\t{{.Names}}\t{{.Ports}}"])
+    ps_result = _run(
+        [
+            "docker",
+            "ps",
+            "--format",
+            '{{.ID}}\t{{.Names}}\t{{.Label "com.docker.compose.project"}}\t{{.Ports}}',
+        ]
+    )
     if ps_result.returncode == 0:
         ps_lines = ps_result.stdout.splitlines()
         for port in all_ports:
             for line in ps_lines:
-                parts = line.split("\t", 2)
-                if len(parts) < 3:
+                parts = line.split("\t", 3)
+                if len(parts) < 4:
+                    continue
+                cid, name, project, ports_str = parts
+                if project in own_projects:
                     continue
-                cid, name, ports_str = parts
                 if f":{port}->" in ports_str:
                     running_conflicts.append((port, name))
 

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/database/db_migrate.py

@@ -1,4 +1,6 @@
 import os
+import shutil
+import subprocess
 
 import click
 from flask_migrate import migrate as alembic_migrate
@@ -46,10 +48,23 @@ def _is_empty_migration(path: str) -> bool:
     return True
 
 
+def _format_migration(path: str) -> None:
+    """Run ``ruff format`` on a freshly generated migration, if ruff exists.
+
+    Alembic writes single quotes and one long create_table() call, which the
+    release gate's ``ruff format --check`` then rejects: the first release of
+    any feature with a model failed lint on a file nobody wrote by hand.
+    """
+    ruff = shutil.which("ruff")
+    if not ruff:
+        return
+    subprocess.run([ruff, "format", "--quiet", path], check=False)
+
+
 @requires_db
 @click.command(
     "db:migrate",
-    short_help="Generate a new migration from model changes and apply it.",
+    short_help="Generate a new migration from model changes (db:upgrade applies it).",
 )
 @click.argument("feature", required=False, default=None)
 @click.option(
@@ -67,8 +82,8 @@ def _is_empty_migration(path: str) -> bool:
 @context.requires_product
 def db_migrate(feature, message, empty):
     """
-    Generate new migration files for features that have schema changes,
-    then apply all pending migrations.
+    Generate new migration files for features that have schema changes.
+    Nothing is applied: run ``splent db:upgrade`` for that.
 
     Empty migrations (no schema changes detected) are automatically removed,
     unless ``--empty`` is passed, in which case a blank migration is created
@@ -158,10 +173,23 @@ def db_migrate(feature, message, empty):
 
         after = _count_versions(mdir)
 
+        newest = None
+        if after > before:
+            versions_dir = os.path.join(mdir, "versions")
+            newest = max(
+                (
+                    os.path.join(versions_dir, f)
+                    for f in os.listdir(versions_dir)
+                    if f.endswith(".py")
+                ),
+                key=os.path.getmtime,
+            )
+
         # 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:
+            if newest:
+                _format_migration(newest)
                 click.echo(
                     click.style(
                         f"  📝 {feat}: blank migration generated — "
@@ -174,20 +202,12 @@ def db_migrate(feature, message, empty):
             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")
-            newest = max(
-                (
-                    os.path.join(versions_dir, f)
-                    for f in os.listdir(versions_dir)
-                    if f.endswith(".py")
-                ),
-                key=os.path.getmtime,
-            )
+        if newest:
             if _is_empty_migration(newest):
                 os.remove(newest)
                 click.echo(click.style(f"  ✔ {feat}: up to date", fg="green"))
             else:
+                _format_migration(newest)
                 click.echo(
                     click.style(f"  📝 {feat}: new migration generated", fg="cyan")
                 )

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/database/db_status.py

@@ -104,8 +104,10 @@ def db_status():
         mdir = dirs.get(feat)
         fs_head = _get_filesystem_head(mdir) if mdir else None
 
-        db_display = db_rev[:12] if db_rev else "—"
-        fs_display = fs_head[:12] if fs_head else "—"
+        # Cut to the column, not to 12: a hex revision is 12 characters but a
+        # named one is not, and "auth0002_role" showed as "auth0002_rol".
+        db_display = db_rev[:col_rev] if db_rev else "—"
+        fs_display = fs_head[:col_rev] if fs_head else "—"
 
         if db_rev and fs_head and db_rev == fs_head:
             status = click.style("✔ synced", fg="green")

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/export/export_puml.py

@@ -817,7 +817,7 @@ def export_puml(
     if not uvl_path:
         click.secho(
             "❌ No UVL file found.\n"
-            "   Set [tool.splent].spl in pyproject.toml (SPL catalog)\n"
+            "   Set [tool.splent].spl in pyproject.toml (the SPL model)\n"
             "   or [tool.splent.uvl].file (legacy).",
             fg="red",
         )

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/feature/feature_contract.py

@@ -233,6 +233,17 @@ def _print_diff(current: dict, inferred: dict) -> bool:
             diff_lines.append(click.style(f"    - archetype: {old_arch}", fg="red"))
         diff_lines.append(click.style(f"    + archetype: {new_arch}", fg="green"))
 
+    # extensible.routes is a boolean; a flip alone is still a change to write
+    old_routes = bool(current.get("extensible_routes", False))
+    new_routes = bool(inferred.get("extensible_routes", False))
+    if old_routes != new_routes:
+        diff_lines.append(
+            click.style(
+                f"    ~ extensible.routes: {old_routes} → {new_routes}",
+                fg="green" if new_routes else "red",
+            )
+        )
+
     for key, label in FIELDS:
         diff_lines.extend(
             _diff_field(label, current.get(key, []), inferred.get(key, []))

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/feature/feature_fork.py

@@ -5,32 +5,46 @@ import requests
 from splent_cli.commands.feature.feature_clone import feature_clone
 from splent_cli.utils.cache_utils import make_feature_writable
 from splent_cli.services import context
+from splent_cli.utils import forge
 from splent_cli.utils.feature_utils import normalize_namespace
 
 
+def _forge_label() -> str:
+    """How to name the forge in a message: the brand on GitHub, the host elsewhere."""
+    return "GitHub" if forge.is_github() else forge.host()
+
+
 @click.command(
     "feature:fork",
-    short_help="Fork a feature on GitHub and clone it locally",
+    short_help="Fork a feature on the forge and clone it locally",
 )
 @click.argument("feature_name", required=True)
 @click.option(
     "--version", "-v", default="v1.0.0", help="Feature version (default: v1.0.0)"
 )
 def feature_fork(feature_name, version):
-    token = os.getenv("GITHUB_TOKEN")
+    token = forge.token()
     github_user = os.getenv("GITHUB_USER")
 
     if not token or not github_user:
-        click.secho("✖ Error: GITHUB_TOKEN and GITHUB_USER must be set", fg="red")
+        click.secho(
+            f"✖ Error: {forge.token_env_name()} and GITHUB_USER must be set", fg="red"
+        )
         raise SystemExit(1)
 
-    upstream_owner = "splent-io"
-    api_url = f"https://api.github.com/repos/{upstream_owner}/{feature_name}/forks"
+    upstream_owner = os.getenv("SPLENT_DEFAULT_ORG", "splent-io")
+    api_url = f"{forge.api_base()}/repos/{upstream_owner}/{feature_name}/forks"
     headers = {
         "Authorization": f"token {token}",
-        "Accept": "application/vnd.github+json",
+        "Accept": (
+            "application/vnd.github+json" if forge.is_github() else "application/json"
+        ),
     }
 
+    # `default_branch_only` is a GitHub-only key. Gitea-compatible forges reject
+    # nothing but understand nothing either, so they get an empty body.
+    payload = {"default_branch_only": False} if forge.is_github() else {}
+
     click.secho(
         f"🔁 Forking {upstream_owner}/{feature_name} into {github_user}...", fg="cyan"
     )
@@ -38,17 +52,17 @@ def feature_fork(feature_name, version):
         resp = requests.post(
             api_url,
             headers=headers,
-            json={"default_branch_only": False},
+            json=payload,
             timeout=30,
         )
     except requests.RequestException as e:
-        click.secho(f"❌ Could not reach GitHub: {e}", fg="red")
+        click.secho(f"❌ Could not reach {_forge_label()}: {e}", fg="red")
         raise SystemExit(2)
 
     if resp.status_code in (403, 429):
         click.secho(
-            "⚠ GitHub API rate limit or access denied. "
-            "Set GITHUB_TOKEN to a token with repo scope and try again.",
+            f"⚠ {_forge_label()} API rate limit or access denied. "
+            f"Set {forge.token_env_name()} to a token with repo scope and try again.",
             fg="yellow",
         )
         if os.getenv("SPLENT_DEBUG"):
@@ -73,22 +87,24 @@ def feature_fork(feature_name, version):
         raise SystemExit(2)
     click.secho(f"🌐 Fork created: {fork_html_url}", fg="green")
 
-    # Esperar a que GitHub lo procese
+    # Esperar a que la forja lo procese
     for i in range(5):
         try:
             r = requests.get(
-                f"https://api.github.com/repos/{github_user}/{feature_name}",
+                f"{forge.api_base()}/repos/{github_user}/{feature_name}",
                 headers=headers,
                 timeout=30,
             )
         except requests.RequestException as e:
-            click.secho(f"⌛ Waiting for GitHub to process fork... ({e})", fg="yellow")
+            click.secho(
+                f"⌛ Waiting for {_forge_label()} to process fork... ({e})", fg="yellow"
+            )
             time.sleep(3)
             continue
         if r.status_code == 200:
             click.secho("✅ Fork is ready.", fg="green")
             break
-        click.secho("⌛ Waiting for GitHub to process fork...", fg="yellow")
+        click.secho(f"⌛ Waiting for {_forge_label()} to process fork...", fg="yellow")
         time.sleep(3)
     else:
         click.secho("⚠ Fork may still be processing.", fg="yellow")

{splent_cli-1.22.2 → splent_cli-1.24.0}/src/splent_cli/commands/feature/feature_impact.py

@@ -65,7 +65,7 @@ def feature_impact(feature_ref):
         click.secho("  pyproject.toml not found.", fg="red")
         raise SystemExit(1)
 
-    uvl = _uvl_path(product_dir)
+    uvl = _uvl_path(product_dir, workspace)
     if not uvl or not os.path.isfile(uvl):
         click.secho("  No UVL file found — cannot compute impact.", fg="red")
         raise SystemExit(1)