modelith-dbt 0.6.0__tar.gz → 0.6.2__tar.gz

{modelith_dbt-0.6.0 → modelith_dbt-0.6.2}/.gitignore

@@ -35,3 +35,4 @@ demo/**/dbt_packages/
 
 # Container-generated YAML-schema settings (paths are machine-specific).
 .vscode/settings.json
+.claude/worktrees/

{modelith_dbt-0.6.0 → modelith_dbt-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: modelith-dbt
-Version: 0.6.0
+Version: 0.6.2
 Summary: Ontology-anchored, git-native data modeling tool for dbt-core teams
 License: Apache-2.0
 License-File: LICENSE

modelith_dbt-0.6.2/packages/cli/src/mdl_cli/__main__.py

@@ -0,0 +1,14 @@
+"""Module entry point so `python -m mdl_cli` runs the CLI.
+
+This is the last-resort invocation the VS Code extension falls back to on
+locked-down Windows/macOS boxes where the `mdl` / `mdl.exe` console script is
+installed but not on the GUI process's PATH (e.g. a `pip install --user` whose
+`%APPDATA%\\Python\\Python3xx\\Scripts` dir was never added to PATH). Given ANY
+interpreter that can import `mdl_cli`, `python -m mdl_cli` reaches the same
+`main()` the console script wraps, so no PATH surgery is required.
+"""
+
+from mdl_cli.main import main
+
+if __name__ == "__main__":
+    main()

{modelith_dbt-0.6.0 → modelith_dbt-0.6.2}/packages/cli/src/mdl_cli/main.py

@@ -55,6 +55,37 @@ app.add_typer(gov_app, name="gov")
 app.add_typer(catalog_app, name="catalog")
 
 
+def _mdl_version() -> str:
+    """The installed modelith-dbt version, from package metadata (works for a wheel and an
+    editable install). Falls back to 'unknown' rather than raising if metadata is absent."""
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        return version("modelith-dbt")
+    except PackageNotFoundError:  # pragma: no cover - only if run from a non-installed tree
+        return "unknown"
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"mdl {_mdl_version()}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _root(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show the installed mdl version and exit.",
+        is_eager=True,
+        callback=_version_callback,
+    ),
+) -> None:
+    """Modelith: ontology-anchored, git-native data modeling for dbt."""
+
+
 def _load(model_dir: Path) -> ModelRepo:
     try:
         return ModelRepo.load(model_dir)
@@ -1582,17 +1613,36 @@ def diff_cmd(
     model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),
     base: str = typer.Option("HEAD", "--base", help="git ref to compare against"),
     head: str = typer.Option(None, "--head", help="git ref (default: the working tree)"),
+    against: Path = typer.Option(
+        None,
+        "--against",
+        help="Compare against ANOTHER model directory (name-keyed, for two independent "
+        "reverses like model/ vs model-reversed-v1/ that have different ULIDs). Overrides "
+        "--base/--head.",
+    ),
     fmt: str = typer.Option("text", "--format", help="text|json|markdown"),
 ) -> None:
-    """Semantic diff of the model against a git ref.
+    """Semantic diff of the model against a git ref (or, with --against, another model dir).
 
-    Objects are keyed by ULID, so a rename is one cosmetic change rather than an
-    entity removed plus another added."""
-    from mdl_server.git_models import RefLoadError, model_at_ref, model_at_working_tree
-
-    from mdl_core.diff import diff_models
+    Objects are keyed by ULID against a git ref, so a rename is one cosmetic change rather
+    than an entity removed plus another added. With --against, objects are keyed by NAME
+    instead — two independently reverse-engineered models have different ULIDs, so name
+    keying shows the real delta rather than a total rewrite."""
+    from mdl_core.diff import diff_models, diff_models_by_name
     from mdl_core.diff_render import render_json, render_markdown, render_text
 
+    if against is not None:
+        base_model = _load(model_dir).model
+        head_model = _load(against).model
+        d = diff_models_by_name(
+            base_model, head_model,
+            base_label=str(model_dir), head_label=str(against),
+        )
+        _emit_diff(d, fmt, render_json, render_markdown, render_text)
+        return
+
+    from mdl_server.git_models import RefLoadError, model_at_ref, model_at_working_tree
+
     try:
         base_model = model_at_ref(model_dir, base)
         head_model = (
@@ -1605,6 +1655,10 @@ def diff_cmd(
     d = diff_models(
         base_model, head_model, base_label=base, head_label=head or "working copy"
     )
+    _emit_diff(d, fmt, render_json, render_markdown, render_text)
+
+
+def _emit_diff(d, fmt, render_json, render_markdown, render_text) -> None:
     if fmt == "json":
         typer.echo(json.dumps(render_json(d), indent=2))
     elif fmt == "markdown":
@@ -2641,6 +2695,21 @@ def model_context(model_dir: Path = typer.Option(Path("."), "--model-dir", "-m")
     typer.echo(json.dumps(get_model_context(_load(model_dir).model), default=str))
 
 
+@model_app.command("render")
+def model_render(model_dir: Path = typer.Option(Path("."), "--model-dir", "-m")) -> None:
+    """Print the model as canonical, ULID-free, name-keyed text.
+
+    Two independently reverse-engineered models describe the same warehouse with
+    DIFFERENT ULIDs, so a raw YAML diff reports everything as changed. This canonical
+    render is deterministic and identity-free, so diffing two renders (VS Code's diff,
+    or `diff`/`git diff --no-index`) shows the real semantic delta — an added column, a
+    new foreign key — with no ULID noise. Backs `mdl diff --against` and the VS Code
+    "Compare Reversed Models" command."""
+    from mdl_core.render_canonical import render_canonical
+
+    typer.echo(render_canonical(_load(model_dir).model), nl=False)
+
+
 @model_app.command("entities")
 def model_entities(
     model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),

modelith_dbt-0.6.2/packages/cli/tests/test_diff_against_cli.py

@@ -0,0 +1,58 @@
+"""`mdl model render` + `mdl diff --against <dir>` — the compare-reversed-models CLI.
+
+Two independent reverses have different ULIDs, so `--against` keys by name: identical
+models diff to nothing, a real change shows the delta. `model render` emits the ULID-free
+canonical text the VS Code compare feeds to native diff.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from mdl_cli.demo import scaffold_demo
+from mdl_cli.main import app
+
+runner = CliRunner()
+
+
+def _demo(root: Path) -> Path:
+    scaffold_demo(root)
+    return root / "model"
+
+
+def test_model_render_is_ulid_free(tmp_path):
+    model = _demo(tmp_path)
+    r = runner.invoke(app, ["model", "render", "-m", str(model)])
+    assert r.exit_code == 0, r.output
+    assert "entity" in r.output
+    import re
+    assert not re.search(r"\b[0-9A-HJKMNP-TV-Z]{26}\b", r.output), "a ULID leaked into render"
+
+
+def test_diff_against_identical_copy_is_empty(tmp_path):
+    model = _demo(tmp_path)
+    # a byte copy is the same model with the SAME ULIDs -> also empty, but exercises the path
+    import shutil
+    other = tmp_path / "model-copy"
+    shutil.copytree(model, other)
+    r = runner.invoke(app, ["diff", "-m", str(model), "--against", str(other)])
+    assert r.exit_code == 0, r.output
+    assert "no changes" in r.output
+
+
+def test_diff_against_detects_a_change(tmp_path):
+    model = _demo(tmp_path)
+    import shutil
+    other = tmp_path / "model-2"
+    shutil.copytree(model, other)
+    # drop one entity file from `other` so the diff reports it removed (by name)
+    ent_dir = other / "logical" / "entities"
+    victims = sorted(ent_dir.glob("*.yaml"))
+    assert victims, "demo should have logical entities"
+    victims[0].unlink()
+    r = runner.invoke(app, ["diff", "-m", str(model), "--against", str(other)])
+    # a removed entity is breaking -> exit 2, and named in the output
+    assert r.exit_code == 2, r.output
+    assert "removed" in r.output.lower()

modelith_dbt-0.6.2/packages/cli/tests/test_version.py

@@ -0,0 +1,35 @@
+"""`mdl --version` / `-V` — the root-callback version flag.
+
+Regression guard: before this, the root app had no callback, so `--version` fell through
+to a usage error (and, on newer Typer, crashed the telemetry wrapper). It must now print
+the installed version and exit 0, without disturbing subcommand dispatch.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+from typer.testing import CliRunner
+
+from mdl_cli.main import app
+
+runner = CliRunner()
+
+
+def test_version_flag_prints_and_exits_zero():
+    r = runner.invoke(app, ["--version"])
+    assert r.exit_code == 0, r.output
+    assert r.output.strip() == f"mdl {version('modelith-dbt')}"
+
+
+def test_short_version_flag():
+    r = runner.invoke(app, ["-V"])
+    assert r.exit_code == 0, r.output
+    assert r.output.strip().startswith("mdl ")
+
+
+def test_root_callback_does_not_break_subcommands():
+    # a normal command still dispatches (help for a leaf command)
+    r = runner.invoke(app, ["validate", "--help"])
+    assert r.exit_code == 0
+    assert "Validate the model" in r.output

{modelith_dbt-0.6.0 → modelith_dbt-0.6.2}/packages/core/src/mdl_core/diff.py

@@ -547,6 +547,106 @@ def _diff_attributes(base: LogicalEntity, head: LogicalEntity) -> list[ObjectCha
     return out
 
 
+def diff_models_by_name(
+    base: Model,
+    head: Model,
+    *,
+    base_label: str = "base",
+    head_label: str = "head",
+) -> ModelDiff:
+    """Compare two models keyed by NAME rather than ULID.
+
+    The ULID-keyed `diff_models` is right when the two models share lineage (two git refs
+    of the same repo). But two INDEPENDENTLY reverse-engineered models (e.g. `model/` and
+    `model-reversed-v1/` from two `mdl reverse` runs) describe the same warehouse with
+    DIFFERENT ULIDs, so ULID keying reports every object as removed+added. This matches
+    objects by name instead: it rewrites the head model's ULIDs to the base model's ULID
+    for each same-named object (logical entity + its attributes by (entity, attr) name,
+    relationships and key groups by name), then delegates to the unchanged `diff_models`
+    — so all the classification, severity and rendering are reused. Head-only names keep
+    their own ULIDs and show as added; base-only names show as removed."""
+    import copy
+
+    head = copy.deepcopy(head)
+
+    remap: dict[str, str] = {}  # head ULID -> base ULID, for every same-named object
+
+    # Every top-level table is keyed by object NAME. Build base name->id per table, then
+    # map each head object with a matching name onto the base id.
+    for table in _TABLES:
+        base_by_name = {
+            _name_of(o): o.id for o in getattr(base, table, {}).values() if _name_of(o)
+        }
+        for o in getattr(head, table, {}).values():
+            n = _name_of(o)
+            if n and n in base_by_name:
+                remap[o.id] = base_by_name[n]
+
+    # Attributes are nested in logical entities, keyed by (entity name, attr name).
+    base_attr: dict[tuple[str, str], str] = {}
+    for e in base.logical_entities.values():
+        for a in e.attributes:
+            base_attr[(e.name, a.name)] = a.id
+    for he in head.logical_entities.values():
+        for a in he.attributes:
+            key = (he.name, a.name)
+            if key in base_attr:
+                remap[a.id] = base_attr[key]
+
+    _apply_remap(head, remap)
+    return diff_models(base, head, base_label=base_label, head_label=head_label)
+
+
+def _apply_remap(model: Model, remap: dict[str, str]) -> None:
+    """Rewrite every ULID in `model` that appears in `remap` (in place): object ids across
+    all name-keyed tables, attribute ids, and the cross-references (logical->conceptual
+    `realises`, relationship ends, key-group entity + members) that must stay consistent so
+    diff_models still resolves them. Then re-key each table dict by the new id."""
+    def r(u):
+        return remap.get(u, u) if u else u
+
+    # simple-id tables (no internal cross-refs beyond the id itself)
+    for table in ("subject_areas", "conceptual_entities", "terms", "domains",
+                  "code_sets", "categories", "physical_tables"):
+        coll = getattr(model, table, None)
+        if not coll:
+            continue
+        rekeyed = {}
+        for obj in coll.values():
+            if hasattr(obj, "id"):
+                obj.id = r(obj.id)
+            rekeyed[obj.id] = obj
+        setattr(model, table, rekeyed)
+
+    new_le = {}
+    for le in model.logical_entities.values():
+        le.id = r(le.id)
+        for a in le.attributes:
+            a.id = r(a.id)
+        if le.realises:
+            le.realises = r(le.realises)
+        new_le[le.id] = le
+    model.logical_entities = new_le
+
+    new_rel = {}
+    for rel in model.relationships.values():
+        rel.id = r(rel.id)
+        rel.from_.entity = r(rel.from_.entity)
+        rel.from_.attributes = [r(a) for a in rel.from_.attributes]
+        rel.to.entity = r(rel.to.entity)
+        rel.to.attributes = [r(a) for a in rel.to.attributes]
+        new_rel[rel.id] = rel
+    model.relationships = new_rel
+
+    new_kg = {}
+    for kg in model.key_groups.values():
+        kg.id = r(kg.id)
+        kg.entity = r(kg.entity)
+        kg.members = [r(m) for m in kg.members]
+        new_kg[kg.id] = kg
+    model.key_groups = new_kg
+
+
 def diff_models(
     base: Model | None,
     head: Model | None,

modelith_dbt-0.6.2/packages/core/src/mdl_core/render_canonical.py

@@ -0,0 +1,132 @@
+"""Render a Model as canonical, name-keyed, ULID-free text — the human diff surface.
+
+Two independently reverse-engineered models describe the same warehouse with DIFFERENT
+ULIDs, so a raw YAML diff (or the ULID-keyed `diff_models`) reports every object as
+removed+added even when they are semantically identical. This renders a model as a
+deterministic, ULID-free document keyed on NAMES, ordered stably, so feeding two such
+documents to a line differ (VS Code's `vscode.diff`, or `diff`/`git diff --no-index`)
+shows the real semantic delta — an added column, a new foreign key — with no ULID noise.
+
+The format is compact, one block per logical entity in name order:
+
+    entity customer
+      customer_id      bigint    not null  [pk]
+      region_id        bigint              [fk -> region]
+      legal_name       string    not null
+      email            string
+      --
+      -> region  (many_to_one via region_id)
+
+Keys come from a `pk` KeyGroup when present (authoritative) else `role: business_key`;
+foreign keys from relationships whose many-side (`from`) is this entity. Everything is
+name-resolved so the text carries no identifiers.
+"""
+
+from __future__ import annotations
+
+from mdl_core.ir import Attribute, LogicalEntity, Model
+
+# column widths for the aligned attribute lines (name / type), kept modest so long names
+# wrap gracefully rather than pushing the flags off-screen in a narrow diff pane.
+_NAME_W = 24
+_TYPE_W = 12
+
+
+def render_canonical(model: Model) -> str:
+    """The canonical text for one model (see module docstring). Deterministic and
+    ULID-free, so two renders diff on meaning, not identity."""
+    ent_name = {e.id: e.name for e in model.logical_entities.values()}
+    attr_name = {
+        a.id: a.name for e in model.logical_entities.values() for a in e.attributes
+    }
+
+    # Primary key per entity. A `pk` KeyGroup is authoritative when present; otherwise the
+    # legacy `role: business_key` convention (which is what `mdl reverse` writes) marks the
+    # key columns. Union both so the render is correct either way. Alternate/unique key
+    # groups annotate their members too.
+    pk_members: dict[str, set[str]] = {}
+    unique_members: dict[str, set[str]] = {}
+    for e in model.logical_entities.values():
+        bks = {a.name for a in e.attributes if a.role == "business_key"}
+        if bks:
+            pk_members.setdefault(e.id, set()).update(bks)
+    for kg in model.key_groups.values():
+        target = pk_members if kg.type == "pk" else unique_members
+        names = {attr_name.get(m) for m in kg.members if attr_name.get(m)}
+        target.setdefault(kg.entity, set()).update(n for n in names if n)
+
+    # foreign keys: relationship whose many-side (`from`) is this entity -> the one-side
+    # (`to`) entity, via the from-side attribute names. Keyed by (entity_id) -> list of
+    # (fk_column_name, target_entity_name, cardinality) plus a per-column fk target map.
+    fk_by_entity: dict[str, list[tuple[str, str, str]]] = {}
+    fk_col_target: dict[str, dict[str, str]] = {}  # entity_id -> {col_name: target_name}
+    for rel in model.relationships.values():
+        src = rel.from_.entity
+        tgt_name = ent_name.get(rel.to.entity)
+        if tgt_name is None:
+            continue
+        cols = [attr_name.get(a) for a in rel.from_.attributes]
+        cols = [c for c in cols if c]
+        col_label = ", ".join(cols) if cols else "?"
+        fk_by_entity.setdefault(src, []).append((col_label, tgt_name, rel.cardinality))
+        for c in cols:
+            fk_col_target.setdefault(src, {})[c] = tgt_name
+
+    lines: list[str] = []
+    project = getattr(model.config, "name", None) or "model"
+    lines.append(f"# model: {project}")
+    lines.append("")
+
+    for entity in sorted(model.logical_entities.values(), key=lambda e: e.name):
+        _render_entity(
+            entity, lines, pk_members, unique_members, fk_col_target, fk_by_entity
+        )
+        lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _render_entity(
+    entity: LogicalEntity,
+    lines: list[str],
+    pk_members: dict[str, set[str]],
+    unique_members: dict[str, set[str]],
+    fk_col_target: dict[str, dict[str, str]],
+    fk_by_entity: dict[str, list[tuple[str, str, str]]],
+) -> None:
+    header = f"entity {entity.name}"
+    if entity.pattern:
+        header += f"  [{entity.pattern}]"
+    if entity.unmanaged:
+        header += "  [unmanaged]"
+    lines.append(header)
+
+    pk = pk_members.get(entity.id, set())
+    uniq = unique_members.get(entity.id, set())
+    fk_targets = fk_col_target.get(entity.id, {})
+    # attributes in declared order (order is meaningful and stable across a re-reverse)
+    for attr in entity.attributes:
+        lines.append(_attr_line(attr, pk, uniq, fk_targets))
+
+    rels = sorted(fk_by_entity.get(entity.id, []))
+    if rels:
+        lines.append("  --")
+        for col, tgt, card in rels:
+            lines.append(f"  -> {tgt}  ({card} via {col})")
+
+
+def _attr_line(
+    attr: Attribute, pk: set[str], uniq: set[str], fk_targets: dict[str, str]
+) -> str:
+    name = attr.name.ljust(_NAME_W)
+    typ = (attr.domain or "").ljust(_TYPE_W)
+    null = "not null" if not attr.nullable else "        "
+    flags: list[str] = []
+    if attr.name in pk:
+        flags.append("pk")
+    if attr.name in fk_targets:
+        flags.append(f"fk -> {fk_targets[attr.name]}")
+    if attr.name in uniq and attr.name not in pk:
+        flags.append("unique")
+    flag_str = ("  [" + ", ".join(flags) + "]") if flags else ""
+    return f"  {name} {typ} {null}{flag_str}".rstrip()

modelith_dbt-0.6.2/packages/core/tests/test_render_canonical.py

@@ -0,0 +1,114 @@
+"""Canonical render + name-keyed diff — the compare-reversed-models surface.
+
+The point of both: two independently reverse-engineered models describe the same warehouse
+with DIFFERENT ULIDs, so a raw/ULID diff reports everything as changed. The canonical render
+is ULID-free and name-ordered (so two renders of the same model are byte-identical), and
+diff_models_by_name matches on names (so the diff shows the real semantic delta).
+"""
+
+from __future__ import annotations
+
+from mdl_core.diff import diff_models, diff_models_by_name
+from mdl_core.ids import new_ulid
+from mdl_core.ir import (
+    Attribute,
+    LogicalEntity,
+    Model,
+    ProjectConfig,
+    Relationship,
+    RelationshipEnd,
+)
+from mdl_core.render_canonical import render_canonical
+
+
+def _model(seed: str = "") -> Model:
+    """A small model: customer -> region (FK), with a PK on each. `seed` is unused except
+    that fresh ULIDs are minted each call, so two calls are the SAME model with DIFFERENT
+    ULIDs — exactly the two-independent-reverses case."""
+    m = Model(ProjectConfig(name="wh"))
+    reg_id, cust_id = new_ulid(), new_ulid()
+    reg_pk, reg_name = new_ulid(), new_ulid()
+    cust_pk, cust_fk, cust_nm = new_ulid(), new_ulid(), new_ulid()
+    m.add(LogicalEntity(id=reg_id, name="region", attributes=[
+        Attribute(id=reg_pk, name="region_id", domain="bigint", role="business_key", nullable=False),
+        Attribute(id=reg_name, name="region_name", domain="string", nullable=True),
+    ]))
+    m.add(LogicalEntity(id=cust_id, name="customer", attributes=[
+        Attribute(id=cust_pk, name="customer_id", domain="bigint", role="business_key", nullable=False),
+        Attribute(id=cust_fk, name="region_id", domain="bigint", nullable=True),
+        Attribute(id=cust_nm, name="legal_name", domain="string", nullable=False),
+    ]))
+    m.add(Relationship(
+        id=new_ulid(), name="customer_in_region",
+        **{"from": RelationshipEnd(entity=cust_id, attributes=[cust_fk])},
+        to=RelationshipEnd(entity=reg_id, attributes=[reg_pk]),
+        cardinality="many_to_one",
+    ))
+    return m
+
+
+# --- canonical render --------------------------------------------------------
+
+
+def test_render_is_ulid_free_and_deterministic():
+    r = render_canonical(_model())
+    assert "01" not in r or "customer" in r  # sanity: it's readable text
+    # no 26-char ULID literals leak into the render
+    import re
+    assert not re.search(r"\b[0-9A-HJKMNP-TV-Z]{26}\b", r), "a ULID leaked into the render"
+
+
+def test_two_independent_models_render_identically():
+    # THE point: same model, different ULIDs -> byte-identical canonical text.
+    assert render_canonical(_model()) == render_canonical(_model())
+
+
+def test_render_shows_pk_fk_nullability():
+    r = render_canonical(_model())
+    assert "customer_id" in r and "[pk]" in r
+    assert "fk -> region" in r
+    assert "not null" in r
+    assert "-> region  (many_to_one via region_id)" in r
+
+
+# --- name-keyed diff ---------------------------------------------------------
+
+
+def test_by_name_diff_of_identical_models_is_empty():
+    # two independent reverses of the same warehouse -> no changes (not a total rewrite).
+    d = diff_models_by_name(_model(), _model())
+    assert not d, f"expected no changes, got {[o.display_name for o in d.objects]}"
+
+
+def test_ulid_diff_of_the_same_two_models_is_all_noise():
+    # contrast: the ULID-keyed diff sees them as completely different (the bug we avoid).
+    d = diff_models(_model(), _model())
+    assert d  # lots of spurious added/removed
+    kinds = {o.change.value for o in d.objects}
+    assert "added" in kinds and "removed" in kinds
+
+
+def test_by_name_diff_detects_added_column():
+    base = _model()
+    head = _model()
+    cust = next(e for e in head.logical_entities.values() if e.name == "customer")
+    cust.attributes.append(Attribute(id=new_ulid(), name="email", domain="string", nullable=True))
+    d = diff_models_by_name(base, head)
+    assert d
+    # the only change is the added attribute on customer
+    changed = [o for o in d.objects if o.object_kind == "logical_entity" and o.change.value == "modified"]
+    assert any("customer" in (o.display_name or "") for o in changed)
+
+
+def test_by_name_diff_detects_new_relationship():
+    base = _model()
+    head = _model()
+    # add a self-ish FK: customer.legal_name is nonsense as an FK, but add a real new entity+rel
+    prod_id, prod_pk = new_ulid(), new_ulid()
+    head.add(LogicalEntity(id=prod_id, name="product", attributes=[
+        Attribute(id=prod_pk, name="product_id", domain="bigint", role="business_key", nullable=False),
+    ]))
+    d = diff_models_by_name(base, head)
+    assert d
+    added = [o.display_name for o in d.objects if o.change.value == "added"]
+    assert any("product" in (n or "").lower() for n in added)

{modelith_dbt-0.6.0 → modelith_dbt-0.6.2}/pyproject.toml

@@ -3,7 +3,7 @@
 # project, so the install name is `modelith-dbt` (install: uv tool install
 # modelith-dbt). The command stays `mdl`; the import modules stay mdl_*.
 name = "modelith-dbt"
-version = "0.6.0"
+version = "0.6.2"
 description = "Ontology-anchored, git-native data modeling tool for dbt-core teams"
 readme = "README.md"
 requires-python = ">=3.11"

{modelith_dbt-0.6.0 → modelith_dbt-0.6.2}/uv.lock

@@ -938,7 +938,7 @@ requires-dist = [
 
 [[package]]
 name = "modelith-dbt"
-version = "0.6.0"
+version = "0.6.2"
 source = { editable = "." }
 dependencies = [
     { name = "dbt-artifacts-parser" },

{modelith_dbt-0.6.0 → modelith_dbt-0.6.2}/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "modelith-vscode",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "modelith-vscode",
-      "version": "0.3.8",
+      "version": "0.3.9",
       "license": "Apache-2.0",
       "dependencies": {
         "vscode-languageclient": "^9.0.1"

{modelith_dbt-0.6.0 → modelith_dbt-0.6.2}/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "modelith-vscode",
   "displayName": "Modelith",
   "description": "Ontology-anchored, git-native data modeling for dbt — validate, generate, drift, and the Modelith canvas inside VS Code.",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "publisher": "BosonResearch",
   "license": "Apache-2.0",
   "icon": "icon.png",
@@ -141,6 +141,11 @@
         "title": "Modelith: Reverse from a Live Database",
         "icon": "$(database)"
       },
+      {
+        "command": "modelith.compareReversed",
+        "title": "Modelith: Compare Reversed Models",
+        "icon": "$(git-compare)"
+      },
       {
         "command": "modelith.reverseEngineer",
         "title": "Reverse Engineer to a Modelith Model",
@@ -266,7 +271,7 @@
         "modelith.mdlPath": {
           "type": "string",
           "default": "",
-          "description": "Path to the mdl executable. Empty = auto-detect (.venv/bin/mdl → mdl on PATH → `uv run mdl`)."
+          "markdownDescription": "Path to the `mdl` executable (`mdl.exe` on Windows), the folder that contains it (e.g. `...\\Python313\\Scripts`), or a command on PATH. Set this if auto-detect can't find your install. Empty = auto-detect: a workspace `.venv`, PATH, well-known install dirs, your selected Python interpreter's Scripts/bin dir, then `python -m mdl_cli`. Find your path with `where mdl` (Windows) or `which mdl`."
         },
         "modelith.modelDir": {
           "type": "string",
@@ -472,9 +477,14 @@
           "group": "navigation@2"
         },
         {
-          "command": "modelith.reverseRefresh",
+          "command": "modelith.compareReversed",
           "when": "view == modelithReverse",
           "group": "navigation@3"
+        },
+        {
+          "command": "modelith.reverseRefresh",
+          "when": "view == modelithReverse",
+          "group": "navigation@4"
         }
       ],
       "view/item/context": [