splent-cli 1.10.0__tar.gz → 1.12.0__tar.gz

{splent_cli-1.10.0/src/splent_cli.egg-info → splent_cli-1.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.10.0
+Version: 1.12.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.10.0 → splent_cli-1.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.10.0"
+version = "1.12.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -63,8 +63,11 @@ where = ["src"]
 testpaths = ["tests"]
 pythonpath = ["src"]
 
-[tool.black]
-line-length = 79
+# Canonical formatter/linter is Ruff (`splent lint` runs `ruff check` +
+# `ruff format`). Ruff's default line length (88) is the project standard;
+# set explicitly here so it is unambiguous.
+[tool.ruff]
+line-length = 88
 
 [project.urls]
 Homepage = "https://github.com/diverso-lab/splent_cli"

{splent_cli-1.10.0 → splent_cli-1.12.0}/src/splent_cli/commands/check/check_infra.py

@@ -209,9 +209,7 @@ def check_infra():
     click.echo(click.style("  Networks", bold=True))
     required_networks: set[str] = set()
     for label, cf in compose_files:
-        result = _run(
-            ["docker", "compose", "-f", cf, "config", "--format", "json"]
-        )
+        result = _run(["docker", "compose", "-f", cf, "config", "--format", "json"])
         if result.returncode != 0:
             continue
         try:
@@ -242,9 +240,7 @@ def check_infra():
     build_count = 0
     for label, cf in compose_files:
         docker_dir = os.path.dirname(cf)
-        result = _run(
-            ["docker", "compose", "-f", cf, "config", "--format", "json"]
-        )
+        result = _run(["docker", "compose", "-f", cf, "config", "--format", "json"])
         if result.returncode != 0:
             continue
         try:
@@ -282,9 +278,7 @@ def check_infra():
     services_depended_on: dict[str, str] = {}  # depended_svc -> by_svc
 
     for label, cf in compose_files:
-        result = _run(
-            ["docker", "compose", "-f", cf, "config", "--format", "json"]
-        )
+        result = _run(["docker", "compose", "-f", cf, "config", "--format", "json"])
         if result.returncode != 0:
             continue
         try:
@@ -321,9 +315,7 @@ def check_infra():
     click.echo(click.style("  Volumes", bold=True))
     all_volumes: dict[str, list[str]] = {}  # vol_name -> [labels]
     for label, cf in compose_files:
-        result = _run(
-            ["docker", "compose", "-f", cf, "config", "--format", "json"]
-        )
+        result = _run(["docker", "compose", "-f", cf, "config", "--format", "json"])
         if result.returncode != 0:
             continue
         try:

{splent_cli-1.10.0 → splent_cli-1.12.0}/src/splent_cli/commands/database/db_migrate.py

@@ -75,9 +75,7 @@ def db_migrate(feature, message, empty):
     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")
-        )
+        click.echo(click.style("❌ --empty requires a FEATURE argument.", fg="red"))
         raise SystemExit(1)
 
     if feature:

splent_cli-1.12.0/src/splent_cli/commands/database/db_reset.py

@@ -0,0 +1,253 @@
+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"))
+    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
+                """
+            )
+        )
+
+    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.10.0 → splent_cli-1.12.0}/src/splent_cli/commands/database/db_seed.py

@@ -179,9 +179,7 @@ def db_seed(reset, yes, module):
             break
         except Exception as e:
             click.echo(
-                click.style(
-                    f"❌ Error in {seeder.__class__.__name__}: {e}", fg="red"
-                )
+                click.style(f"❌ Error in {seeder.__class__.__name__}: {e}", fg="red")
             )
             success = False
             break

{splent_cli-1.10.0 → splent_cli-1.12.0}/src/splent_cli/commands/doctor.py

@@ -68,7 +68,9 @@ def _check_workspace_precondition():
     wd = os.getenv("WORKING_DIR")
     workspace = wd or os.getcwd()
     if not wd:
-        problems.append("WORKING_DIR is not set (falling back to the current directory)")
+        problems.append(
+            "WORKING_DIR is not set (falling back to the current directory)"
+        )
     elif not os.path.isdir(wd):
         problems.append(f"WORKING_DIR points to a missing directory: {wd}")
 

{splent_cli-1.10.0 → splent_cli-1.12.0}/src/splent_cli/commands/feature/feature_clone.py

@@ -6,7 +6,7 @@ import click
 from splent_cli.services import context
 from splent_cli.utils.cache_utils import make_feature_readonly
 from splent_cli.utils.feature_utils import normalize_namespace
-from splent_cli.utils.proc import run, require_tool
+from splent_cli.utils.proc import require_tool
 
 
 DEFAULT_NAMESPACE = os.getenv("SPLENT_DEFAULT_NAMESPACE", "splent_io")
@@ -20,8 +20,15 @@ DEFAULT_NAMESPACE = os.getenv("SPLENT_DEFAULT_NAMESPACE", "splent_io")
 def _get_latest_tag(namespace, repo) -> str | None:
     """Fetch the highest semver tag from GitHub. Returns None if unreachable or no tags."""
     api_url = f"https://api.github.com/repos/{namespace}/{repo}/tags?per_page=100"
+    # Authenticate when a token is present so version resolution also works for
+    # PRIVATE feature repos (an unauthenticated call 404s on those) and to raise
+    # the API rate limit.
+    headers = {}
+    token = os.getenv("GITHUB_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
     try:
-        r = requests.get(api_url, timeout=5)
+        r = requests.get(api_url, headers=headers, timeout=5)
         r.raise_for_status()
         tags = r.json()
         if not tags:
@@ -42,16 +49,6 @@ def _get_latest_tag(namespace, repo) -> str | None:
         return None
 
 
-def _build_repo_url(namespace, repo):
-    """Build the Git URL, trying SSH first with HTTPS fallback.
-
-    Returns a tuple (real_url, display_url) where display_url never contains a token.
-    """
-    from splent_cli.utils.git_url import build_git_url
-
-    return build_git_url(namespace, repo)
-
-
 def _parse_full_name(full_name: str):
     """
     full_name = <namespace>/<repo>[@version]
@@ -115,9 +112,6 @@ def feature_clone(full_name):
             )
             raise SystemExit(1)
 
-    # Build Git URL based on your ownership
-    fork_url, display_url = _build_repo_url(namespace, repo)
-
     # Local destination
     namespace_safe = normalize_namespace(namespace)
     workspace = str(context.workspace())
@@ -137,98 +131,51 @@ def feature_clone(full_name):
         "Install Git from https://git-scm.com/downloads and make sure it is on your PATH.",
     )
 
-    click.secho(f"⬇️ Cloning {display_url}@{version}", fg="cyan")
-
-    # Try clone the specific tag/branch (suppress git noise). Capture output so
-    # we can tell WHY it failed instead of blindly assuming "version not found".
-    result = run(
-        [
-            "git",
-            "-c",
-            "advice.detachedHead=false",
-            "clone",
-            "--depth",
-            "1",
-            "--branch",
-            version,
-            "--quiet",
-            fork_url,
-            local_path,
-        ],
-        check=False,
-        capture=True,
+    from splent_cli.utils.git_url import (
+        clone as git_clone,
+        CLONE_SUCCESS,
+        CLONE_REF_NOT_FOUND,
     )
 
-    if result.returncode != 0:
-        shutil.rmtree(local_path, ignore_errors=True)
-        stderr = (result.stderr or result.stdout or "").strip()
-        stderr_lc = stderr.lower()
-
-        # A genuinely missing ref is the ONLY case where falling back to main is
-        # correct. git reports it as e.g.:
-        #   "Remote branch <x> not found in upstream origin"
-        #   "Could not find remote branch <x> to clone"
-        ref_not_found = (
-            "remote branch" in stderr_lc and "not found" in stderr_lc
-        ) or "could not find remote branch" in stderr_lc
-
-        # Auth / network / repo-access failures must NOT silently install main.
-        auth_or_network = any(
-            token in stderr_lc
-            for token in (
-                "authentication failed",
-                "permission denied",
-                "could not read from remote repository",
-                "repository not found",
-                "could not resolve host",
-                "connection timed out",
-                "connection refused",
-                "network is unreachable",
-                "failed to connect",
-                "ssl",
-                "tls",
-            )
+    click.secho(f"⬇️ Cloning {namespace}/{repo}@{version}", fg="cyan")
+
+    # Always try SSH first, then HTTPS (GITHUB_TOKEN if set, else anonymous). The
+    # transport is decided per repo from the real clone result (see
+    # git_url.clone), so a working SSH key that simply can't read THIS repo no
+    # longer blocks the HTTPS path.
+    outcome, used_url, stderr = git_clone(namespace, repo, local_path, ref=version)
+
+    # A genuinely missing tag/branch is the ONLY case where falling back to the
+    # default branch is correct (the repo itself was reachable).
+    if outcome == CLONE_REF_NOT_FOUND:
+        click.secho(
+            f"⚠️ Version '{version}' not found. Cloning default branch instead.",
+            fg="yellow",
         )
+        outcome, used_url, stderr = git_clone(namespace, repo, local_path, ref=None)
 
-        if ref_not_found and not auth_or_network:
-            click.secho(
-                f"⚠️ Version '{version}' not found. Cloning main instead.", fg="yellow"
-            )
-            fallback = run(
-                ["git", "clone", "--depth", "1", "--quiet", fork_url, local_path],
-                check=False,
-                capture=True,
-            )
-            if fallback.returncode != 0:
-                shutil.rmtree(local_path, ignore_errors=True)
-                detail = (fallback.stderr or fallback.stdout or "").strip()
-                click.secho(
-                    f"❌ Repository '{namespace}/{repo}' not found or not accessible.",
-                    fg="red",
-                )
-                if detail:
-                    click.secho(detail, fg="red")
-                raise SystemExit(1)
-        else:
-            # Network / auth / unknown git failure: do NOT fall back to main,
-            # which would silently install the wrong (unpinned) code.
-            click.secho(
-                f"❌ Failed to clone '{namespace}/{repo}@{version}'.", fg="red"
-            )
-            click.secho(
-                "This looks like a network, authentication, or repository-access "
-                "problem rather than a missing version. Check your connection and "
-                "credentials, then try again.",
-                fg="red",
-            )
-            if stderr:
-                click.secho(stderr, fg="red")
-            raise SystemExit(1)
+    if outcome != CLONE_SUCCESS:
+        shutil.rmtree(local_path, ignore_errors=True)
+        click.secho(
+            f"❌ Repository '{namespace}/{repo}' not found or not accessible "
+            "(tried SSH and HTTPS).",
+            fg="red",
+        )
+        click.secho(
+            "Check your network, that the repo exists, and that you have read "
+            "access — an SSH key authorised for the repo, or a GITHUB_TOKEN with "
+            "read scope in your .env.",
+            fg="red",
+        )
+        if stderr:
+            click.secho(stderr, fg="red")
+        raise SystemExit(1)
 
     # Lock files as read-only to prevent accidental edits on pinned features
     make_feature_readonly(local_path)
 
     click.secho(
-        f"✅ Feature '{namespace}/{repo}@{version}' cloned successfully.", fg="green"
+        f"✅ Feature '{namespace}/{repo}@{version}' cloned successfully ({used_url}).",
+        fg="green",
     )
     click.secho(f"🔒 Cached (read-only) at: {local_path}", fg="blue")

{splent_cli-1.10.0 → splent_cli-1.12.0}/src/splent_cli/commands/feature/feature_compile.py

@@ -157,9 +157,7 @@ def _compile_in_container(container_id, feature, watch, production, workspace, p
             raise click.ClickException(
                 f"'{run_cmd[0]}' is not installed or not on PATH.\n{tool_hint}"
             )
-        click.echo(
-            click.style(f"👀 Watching {feature} in {mode} mode...", fg="blue")
-        )
+        click.echo(click.style(f"👀 Watching {feature} in {mode} mode...", fg="blue"))
     else:
         result = run(run_cmd, check=False, tool_hint=tool_hint)
         if result.returncode != 0:

{splent_cli-1.10.0 → splent_cli-1.12.0}/src/splent_cli/commands/feature/feature_env.py

@@ -121,9 +121,7 @@ def feature_env(feature_name, generate, env_name):
         try:
             shutil.copy(selected, env_file)
         except OSError as exc:
-            click.echo(
-                f"❌ Failed to create {env_file} from {selected}: {exc}"
-            )
+            click.echo(f"❌ Failed to create {env_file} from {selected}: {exc}")
             raise SystemExit(1)
         click.echo(
             f"📄 Created {feature_entry}/docker/.env from {os.path.basename(selected)}"

{splent_cli-1.10.0 → splent_cli-1.12.0}/src/splent_cli/commands/feature/feature_install.py

@@ -241,7 +241,8 @@ def feature_install(feature_identifier, env_scope, mode, version):
             )
             if result.returncode != 0:
                 click.secho(
-                    f"  Clone failed: {(result.stderr or '').strip()}", fg="red"
+                    f"  Clone failed: {(result.stderr or '').strip()}",
+                    fg="red",
                 )
                 raise SystemExit(1)
         else:
@@ -291,9 +292,7 @@ def feature_install(feature_identifier, env_scope, mode, version):
                         check=False,
                     )
                     if dep.returncode != 0:
-                        click.secho(
-                            f"  Installing dependency {m} failed.", fg="red"
-                        )
+                        click.secho(f"  Installing dependency {m} failed.", fg="red")
                         raise SystemExit(1)
 
         # Attach to product
@@ -315,32 +314,27 @@ def feature_install(feature_identifier, env_scope, mode, version):
             # Clone to workspace root as editable
             click.echo(click.style("  clone    ", dim=True) + f"{short} (editable)")
             from splent_cli.commands.feature.feature_clone import (
-                _build_repo_url,
                 _get_latest_tag,
             )
+            from splent_cli.utils.git_url import (
+                clone as git_clone,
+                CLONE_SUCCESS,
+                CLONE_REF_NOT_FOUND,
+            )
 
+            # SSH first, then HTTPS (per repo). ref=tag (None → default branch).
             tag = _get_latest_tag(namespace_github, feature_name)
-            repo_url, _ = _build_repo_url(namespace_github, feature_name)
-            branch = tag or "main"
-            clone = run(
-                [
-                    "git",
-                    "clone",
-                    "--depth",
-                    "1",
-                    "--branch",
-                    branch,
-                    "--quiet",
-                    repo_url,
-                    feature_dir,
-                ],
-                check=False,
-                capture=True,
+            outcome, _used, err = git_clone(
+                namespace_github, feature_name, feature_dir, ref=tag
             )
-            if clone.returncode != 0:
+            if outcome == CLONE_REF_NOT_FOUND:
+                outcome, _used, err = git_clone(
+                    namespace_github, feature_name, feature_dir, ref=None
+                )
+            if outcome != CLONE_SUCCESS:
                 click.secho(
-                    f"  Could not clone {namespace_github}/{feature_name}: "
-                    f"{(clone.stderr or '').strip()}",
+                    f"  Could not clone {namespace_github}/{feature_name} "
+                    f"(tried SSH and HTTPS): {err}",
                     fg="red",
                 )
                 raise SystemExit(1)
@@ -386,9 +380,7 @@ def feature_install(feature_identifier, env_scope, mode, version):
                         check=False,
                     )
                     if dep.returncode != 0:
-                        click.secho(
-                            f"  Installing dependency {m} failed.", fg="red"
-                        )
+                        click.secho(f"  Installing dependency {m} failed.", fg="red")
                         raise SystemExit(1)
 
         # Add to product
@@ -454,7 +446,8 @@ def feature_install(feature_identifier, env_scope, mode, version):
         )
         if result.returncode != 0:
             click.secho(
-                f"  Docker failed: {(result.stderr or '').strip()}", fg="yellow"
+                f"  Docker failed: {(result.stderr or '').strip()}",
+                fg="yellow",
             )
 
     click.echo()