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

{splent_cli-1.11.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.11.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.11.0 → splent_cli-1.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.11.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"

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.11.0 → splent_cli-1.12.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.11.0 → splent_cli-1.12.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.12.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.12.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.12.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.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.11.0 → splent_cli-1.12.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

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

@@ -1,159 +0,0 @@
-import os
-
-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,
-)
-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
-
-
-@requires_db
-@click.command(
-    "db:reset",
-    short_help="Drop all tables and re-apply migrations from scratch.",
-)
-@click.option("-y", "--yes", is_flag=True, help="Confirm without prompting.")
-@context.requires_product
-def db_reset(yes):
-    """
-    Full database reset: drops ALL tables (data, alembic tracking,
-    splent_migrations), then re-applies existing feature migrations.
-
-    Feature migration files are NOT deleted — only the database is wiped.
-    """
-    app = current_app
-
-    if not yes and not click.confirm(
-        "⚠️  WARNING: This will DROP all tables and clear uploads. Are you sure?",
-        abort=True,
-    ):
-        return
-
-    # --- STEP 1: Drop ALL tables (including alembic_* and splent_migrations) ---
-    # Run every DROP inside a single transaction (engine.begin) so that a
-    # mid-operation connection failure rolls back as a unit rather than
-    # leaving a half-dropped schema. Note: MySQL/MariaDB issue an implicit
-    # COMMIT on DDL, so a full rollback is not guaranteed there; we therefore
-    # also surface explicit partial-state recovery guidance on failure.
-    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)
-
-    # --- STEP 2: Recreate splent_migrations tracking table ---
-    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 e:
-        click.echo(click.style(f"❌ Error creating tracking table: {e}", fg="red"))
-        click.echo(
-            click.style(
-                "⚠️  All tables were dropped but the tracking table could not "
-                "be recreated. Re-run this command once the database is "
-                "reachable to finish the reset.",
-                fg="red",
-            )
-        )
-        raise SystemExit(1)
-
-    # --- STEP 3: Clear uploads ---
-    ctx = click.get_current_context()
-    ctx.invoke(clear_uploads)
-
-    # --- STEP 4: Re-apply all existing feature migrations ---
-    dirs = MigrationManager.get_all_feature_migration_dirs()
-
-    # Build entry→key lookup for manifest updates
-    product_path = PathUtils.get_app_base_dir()
-    product_name = os.getenv("SPLENT_APP", "")
-    entry_lookup = {}
-    for entry in get_features_from_pyproject() or []:
-        key, ns, name, version = resolve_feature_key_from_entry(entry)
-        entry_lookup[name] = (key, ns, name, version)
-
-    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"
-            )
-        )
-        for feat, mdir in dirs.items():
-            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")
-                )
-
-                # Advance lifecycle state to "migrated"
-                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"))
-
-    click.echo(click.style("\n🎉 Database reset complete.", fg="green"))
-
-
-cli_command = db_reset