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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: modelith-dbt
-Version: 0.6.2
+Version: 0.6.3
 Summary: Ontology-anchored, git-native data modeling tool for dbt-core teams
 License: Apache-2.0
 License-File: LICENSE
@@ -204,6 +204,39 @@ in and dims the rest.
 
 ![The ER canvas with a relationship line running from one entity's foreign-key attribute row to the referenced entity's primary-key row, with crow's-foot cardinality](docs/assets/canvas.png)
 
+## Documentation
+
+`mdl docs generate` produces a static documentation site for the model, the way
+`dbt docs generate` does for a dbt project:
+
+```bash
+mdl docs generate            # -> target/mdl-docs/
+```
+
+The output is a self-contained, offline HTML bundle (no server, no network): a left
+tree-view of every logical model grouped by subject area, a structured page per entity
+(attributes, keys, relationships, ontology alignment with confidence, stewardship,
+where-used), a per-entity ER diagram of its neighbourhood
+(`--neighbourhood-radius`, default 2), an overview with the full ERD, and a glossary.
+Because it is just files, commit it, publish it to a wiki, S3, or GitHub Pages
+(`--base-url` sets the sub-path), or open `index.html` straight from disk. Diagrams are
+Mermaid, rendered client-side by a vendored copy.
+
+Preview it locally with a server, or open it as a tab inside VS Code (**Modelith:
+Open Docs** in the Reverse Review title bar):
+
+```bash
+mdl docs serve               # regenerates, then serves at /mdl-docs
+```
+
+`mdl status` tells you where the workspace stands and what to do next — no models yet,
+proposals to review, docs to generate, drift to check — and is what drives the
+next-action rows in the VS Code panel:
+
+```bash
+mdl status                   # or: mdl status --format json
+```
+
 ## In VS Code
 
 Install the extension from the marketplace (Open VSX — see
@@ -211,7 +244,7 @@ Install the extension from the marketplace (Open VSX — see
 from the packaged `.vsix`:
 
 ```bash
-code --install-extension vscode/modelith-vscode-0.3.7.vsix
+code --install-extension vscode/modelith-vscode-0.3.11.vsix
 ```
 
 The extension does not bundle its own copy of the canvas. It launches `mdl serve`

{modelith_dbt-0.6.2 → modelith_dbt-0.6.3}/README.md

@@ -178,6 +178,39 @@ in and dims the rest.
 
 ![The ER canvas with a relationship line running from one entity's foreign-key attribute row to the referenced entity's primary-key row, with crow's-foot cardinality](docs/assets/canvas.png)
 
+## Documentation
+
+`mdl docs generate` produces a static documentation site for the model, the way
+`dbt docs generate` does for a dbt project:
+
+```bash
+mdl docs generate            # -> target/mdl-docs/
+```
+
+The output is a self-contained, offline HTML bundle (no server, no network): a left
+tree-view of every logical model grouped by subject area, a structured page per entity
+(attributes, keys, relationships, ontology alignment with confidence, stewardship,
+where-used), a per-entity ER diagram of its neighbourhood
+(`--neighbourhood-radius`, default 2), an overview with the full ERD, and a glossary.
+Because it is just files, commit it, publish it to a wiki, S3, or GitHub Pages
+(`--base-url` sets the sub-path), or open `index.html` straight from disk. Diagrams are
+Mermaid, rendered client-side by a vendored copy.
+
+Preview it locally with a server, or open it as a tab inside VS Code (**Modelith:
+Open Docs** in the Reverse Review title bar):
+
+```bash
+mdl docs serve               # regenerates, then serves at /mdl-docs
+```
+
+`mdl status` tells you where the workspace stands and what to do next — no models yet,
+proposals to review, docs to generate, drift to check — and is what drives the
+next-action rows in the VS Code panel:
+
+```bash
+mdl status                   # or: mdl status --format json
+```
+
 ## In VS Code
 
 Install the extension from the marketplace (Open VSX — see
@@ -185,7 +218,7 @@ Install the extension from the marketplace (Open VSX — see
 from the packaged `.vsix`:
 
 ```bash
-code --install-extension vscode/modelith-vscode-0.3.7.vsix
+code --install-extension vscode/modelith-vscode-0.3.11.vsix
 ```
 
 The extension does not bundle its own copy of the canvas. It launches `mdl serve`

{modelith_dbt-0.6.2 → modelith_dbt-0.6.3}/hatch_build.py

@@ -33,6 +33,7 @@ FORCE_INCLUDE = {
     "packages/emit-graph/src/mdl_emit_graph": "mdl_emit_graph",
     "packages/emit-erd/src/mdl_emit_erd": "mdl_emit_erd",
     "packages/reverse/src/mdl_reverse": "mdl_reverse",
+    "packages/docs/src/mdl_docs": "mdl_docs",
     "packages/ontology/src/mdl_ontology": "mdl_ontology",
     "packages/emit-semantic/src/mdl_emit_semantic": "mdl_emit_semantic",
     "packages/governance/src/mdl_governance": "mdl_governance",

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

@@ -47,12 +47,14 @@ gov_app = typer.Typer(help="Governance: plan/apply/pull/conformance against a ca
 catalog_app = typer.Typer(
     help="Cross-repo model catalog: publish/browse model repos (base-tier, no governance)."
 )
+docs_app = typer.Typer(help="Generate and serve a static documentation site (dbt-docs style).")
 app.add_typer(ontology_app, name="ontology")
 app.add_typer(emit_app, name="emit")
 app.add_typer(export_app, name="export")
 app.add_typer(import_app, name="import")
 app.add_typer(gov_app, name="gov")
 app.add_typer(catalog_app, name="catalog")
+app.add_typer(docs_app, name="docs")
 
 
 def _mdl_version() -> str:
@@ -1155,13 +1157,103 @@ def ontology_check(
         raise typer.Exit(1)
 
 
+@ontology_app.command("status")
+def ontology_status(
+    model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),
+    fmt: str = typer.Option("text", "--format", help="text|json"),
+) -> None:
+    """Proposed ontology alignments awaiting review + industry-coverage summary.
+
+    The JSON form is what the VS Code Ontology view consumes; `promote`/`clear`
+    (with the ref uri) act on the rows it lists."""
+    import json as _json
+
+    repo = _load(model_dir)
+    model = repo.model
+
+    # Refs across conceptual entities and terms, split by review state so the UI can
+    # show the flow. Only refs EXPLICITLY marked `status: proposed` (what `mdl ontology
+    # align` writes) are the review queue; a ref with an accepted status, or with NO
+    # status at all (a hand-authored / already-established alignment), is the done side.
+    proposed: list[dict] = []
+    accepted: list[dict] = []
+    for kind, objs in (
+        ("conceptual_entity", model.conceptual_entities.values()),
+        ("term", model.terms.values()),
+    ):
+        for obj in objs:
+            for ref in obj.ontology_refs:
+                row = {
+                    "id": obj.id,
+                    "name": obj.name,
+                    "kind": kind,
+                    "uri": ref.uri,
+                    "predicate": ref.predicate,
+                    "layer": ref.layer,
+                    "confidence": ref.confidence,
+                    "resolved_via": ref.resolved_via,
+                }
+                if getattr(ref, "status", None) == "proposed":
+                    proposed.append(row)
+                else:
+                    accepted.append(row)
+    proposed.sort(key=lambda r: (-(r["confidence"] or 0.0), r["name"], r["uri"]))
+    accepted.sort(key=lambda r: (r["name"], r["uri"]))
+
+    # Industry-alignment coverage, computed inline from the model so `ontology status`
+    # works on a BASE install: importing mdl_ontology (even for the pure coverage_report)
+    # pulls in the optional RDF stack via its package __init__, which a base install
+    # lacks. This mirrors mdl_ontology.layers.coverage_report over core concepts.
+    total_core = with_industry = exempt = 0
+    uncovered: list[str] = []
+    for obj in [*model.conceptual_entities.values(), *model.terms.values()]:
+        if getattr(obj, "ontology_layer", None) != "core":
+            continue
+        total_core += 1
+        if any(r.uri for r in obj.ontology_refs):
+            with_industry += 1
+        elif getattr(obj, "no_industry_equivalent", False):
+            exempt += 1
+        else:
+            uncovered.append(obj.name)
+    pct = round(100.0 * (with_industry + exempt) / total_core, 1) if total_core else 100.0
+    coverage = {
+        "coverage_pct": pct,
+        "total_core": total_core,
+        "core_with_industry": with_industry,
+        "core_exempt": exempt,
+        "core_uncovered": sorted(uncovered),
+    }
+    payload = {"proposed": proposed, "accepted": accepted, "coverage": coverage}
+
+    if fmt == "json":
+        typer.echo(_json.dumps(payload, indent=2))
+        return
+    if proposed:
+        typer.secho(f"{len(proposed)} proposed alignment(s) awaiting review:", fg=typer.colors.CYAN)
+        for r in proposed:
+            conf = f"{r['confidence']:.2f}" if r["confidence"] is not None else "—"
+            typer.echo(f"  {r['name']} -> {r['uri']}  [{r['layer'] or '?'}, conf {conf}]")
+    else:
+        typer.secho("no proposed alignments — all reviewed", fg=typer.colors.GREEN)
+    typer.echo("")
+    typer.secho(
+        f"industry alignment coverage: {coverage['coverage_pct']}% "
+        f"({coverage['core_with_industry']}+{coverage['core_exempt']}/"
+        f"{coverage['total_core']} core terms)",
+        fg=typer.colors.CYAN,
+    )
+
+
 @ontology_app.command("promote")
 def ontology_promote(
     name: str = typer.Argument(..., help="Conceptual entity or term name"),
     model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),
+    uri: str = typer.Option(None, "--uri", help="Promote only this ref (else all proposed)"),
 ) -> None:
     """Promote a proposed ontology alignment to accepted (§5.1: SMEs propose,
-    architects promote)."""
+    architects promote). With --uri, promote just that ref (used by the VS Code
+    Ontology view, where each row is one ref)."""
     from mdl_core.commands import CommandError, apply_command
 
     repo = _load(model_dir)
@@ -1171,14 +1263,46 @@ def ontology_promote(
     if obj is None:
         typer.secho(f"no conceptual entity or term {name!r}", fg=typer.colors.RED, err=True)
         raise typer.Exit(1)
+    args = {"id": obj.id}
+    if uri:
+        args["uri"] = uri
     try:
-        apply_command(model_dir, "promote_alignment", {"id": obj.id})
+        apply_command(model_dir, "promote_alignment", args)
     except (CommandError, FileNotFoundError) as e:
         typer.secho(str(e), fg=typer.colors.RED, err=True)
         raise typer.Exit(1) from e
     typer.secho(f"alignment on {name!r} promoted to accepted", fg=typer.colors.GREEN)
 
 
+@ontology_app.command("reject")
+def ontology_reject(
+    name: str = typer.Argument(..., help="Conceptual entity or term name"),
+    model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),
+    uri: str = typer.Option(None, "--uri", help="Remove only this ref (else all)"),
+) -> None:
+    """Reject a proposed ontology alignment: remove the ref. With --uri, remove just
+    that one (used by the VS Code Ontology view). Rejecting a proposal simply drops
+    it; a later `mdl ontology align` may re-propose from fresh evidence."""
+    from mdl_core.commands import CommandError, apply_command
+
+    repo = _load(model_dir)
+    candidates = [*repo.model.conceptual_entities.values(), *repo.model.terms.values()]
+    objs = {o.name: o for o in candidates}
+    obj = objs.get(name)
+    if obj is None:
+        typer.secho(f"no conceptual entity or term {name!r}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+    args = {"id": obj.id}
+    if uri:
+        args["uri"] = uri
+    try:
+        apply_command(model_dir, "clear_alignment", args)
+    except (CommandError, FileNotFoundError) as e:
+        typer.secho(str(e), fg=typer.colors.RED, err=True)
+        raise typer.Exit(1) from e
+    typer.secho(f"alignment on {name!r} removed", fg=typer.colors.GREEN)
+
+
 @ontology_app.command("vendor")
 def ontology_vendor(
     source: str = typer.Argument("fibo", help="Vocabulary to vendor (fibo)"),
@@ -2796,6 +2920,103 @@ def serve(
     run_server(model_dir, host=host, port=port, read_only=read_only)
 
 
+@docs_app.command("generate")
+def docs_generate(
+    model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),
+    out: Path = typer.Option(
+        None, "--out", "-o", help="Output dir (default: <model-dir>/target/mdl-docs)"
+    ),
+    base_url: str = typer.Option(
+        "", "--base-url", help="URL prefix for publishing under a sub-path"
+    ),
+    neighbourhood_radius: int = typer.Option(
+        2, "--neighbourhood-radius", help="Hops of related entities in each entity's ERD"
+    ),
+) -> None:
+    """Generate a static, self-contained documentation site (dbt-docs style).
+
+    The output opens offline (no server) and is safe to commit or publish to a wiki,
+    S3, or GitHub Pages. It carries a left model tree-view, a structured page per
+    entity with a neighbourhood ERD, an overview diagram, and a glossary."""
+    from mdl_docs import render_site
+
+    from mdl_core.status import assess
+
+    repo = _load(model_dir)
+    # Base the default output on the RESOLVED model dir (repo.root), so `-m .` at a repo
+    # root writes to <model>/target/mdl-docs — the same place `mdl docs serve` and the
+    # server's /mdl-docs mount look — not ./target/mdl-docs beside the wrong dir.
+    dest = out or (repo.root / "target" / "mdl-docs")
+    status = assess(repo.root, model=repo.model)
+    files = render_site(
+        repo.model,
+        dest,
+        base_url=base_url,
+        neighbourhood_radius=neighbourhood_radius,
+        status_summary=status.to_dict(),
+    )
+    typer.secho(
+        f"Wrote {len(files)} files to {dest}  (open {dest / 'index.html'})",
+        fg=typer.colors.GREEN,
+    )
+    from mdl_cli import telemetry
+
+    telemetry.emit("docs_generated", {"entities": len(repo.model.logical_entities)})
+
+
+@docs_app.command("serve")
+def docs_serve(
+    model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),
+    host: str = typer.Option("127.0.0.1", "--host"),
+    port: int = typer.Option(4820, "--port", "-p"),
+    regenerate: bool = typer.Option(
+        True, "--regenerate/--no-regenerate", help="Regenerate the site before serving"
+    ),
+) -> None:
+    """Generate (unless --no-regenerate) and serve the docs site at /mdl-docs."""
+    from mdl_server.app import serve as run_server
+
+    from mdl_core.repo import find_project_root
+
+    if regenerate:
+        docs_generate(model_dir=model_dir, out=None, base_url="", neighbourhood_radius=2)
+    # Resolve the model dir the same way _load does (so `-m .` at a repo root finds the
+    # child model/), and hand the RESOLVED dir to the server, or its /mdl-docs mount
+    # would look under the unresolved path and 404.
+    resolved = find_project_root(model_dir)
+    typer.secho(
+        f"Modelith docs: http://{host}:{port}/mdl-docs  (model: {resolved})",
+        fg=typer.colors.CYAN,
+    )
+    run_server(resolved, host=host, port=port, read_only=True)
+
+
+@app.command()
+def status(
+    model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),
+    manifest: Path = typer.Option(None, "--manifest", help="dbt manifest for the drift signal"),
+    fmt: str = typer.Option("text", "--format", help="text|json"),
+) -> None:
+    """Where is this workspace, and what should I do next? Ranked next-actions from the
+    current model + .mdl state. `--format json` is what the VS Code panel consumes."""
+    import json as _json
+
+    from mdl_core.status import assess
+
+    st = assess(model_dir, manifest=manifest)
+    if fmt == "json":
+        typer.echo(_json.dumps(st.to_dict(), indent=2))
+        return
+    typer.secho(st.summary, fg=typer.colors.CYAN)
+    if st.next_actions:
+        typer.echo("\nNext actions:")
+        for a in st.next_actions:
+            typer.echo(f"  - {a.title}")
+            typer.echo(f"      {a.detail}")
+            if a.cli:
+                typer.secho(f"      $ {a.cli}", fg=typer.colors.BRIGHT_BLACK)
+
+
 @app.command()
 def studio(
     model_dir: Path = typer.Option(Path("."), "--model-dir", "-m"),

modelith_dbt-0.6.3/packages/cli/tests/test_docs_status_cli.py

@@ -0,0 +1,106 @@
+"""CLI: `mdl docs generate`, `mdl status`, and the server /mdl-docs route."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from mdl_cli.main import app
+
+_CORE_TESTS = Path(__file__).resolve().parents[2] / "core" / "tests"
+sys.path.insert(0, str(_CORE_TESTS))
+from model_builders import write_model  # noqa: E402
+
+runner = CliRunner()
+
+
+def test_docs_generate_writes_site(tmp_path):
+    write_model(tmp_path)
+    r = runner.invoke(app, ["docs", "generate", "-m", str(tmp_path)])
+    assert r.exit_code == 0, r.output
+    site = tmp_path / "target" / "mdl-docs"
+    assert (site / "index.html").is_file()
+    assert (site / "glossary.html").is_file()
+    assert (site / "assets" / "mermaid.min.js").is_file()
+    assert list((site / "entities").glob("*.html"))
+
+
+def test_docs_generate_custom_out_and_radius(tmp_path):
+    write_model(tmp_path)
+    out = tmp_path / "custom-docs"
+    r = runner.invoke(
+        app,
+        ["docs", "generate", "-m", str(tmp_path), "-o", str(out), "--neighbourhood-radius", "1"],
+    )
+    assert r.exit_code == 0, r.output
+    assert (out / "index.html").is_file()
+
+
+def test_status_text(tmp_path):
+    write_model(tmp_path)
+    r = runner.invoke(app, ["status", "-m", str(tmp_path)])
+    assert r.exit_code == 0, r.output
+    assert "Next actions" in r.output
+
+
+def test_commands_run_from_repo_root_above_model(tmp_path):
+    """The reported UX bug: from a repo root whose model is in model/, `mdl docs
+    generate` / `mdl status` must just work (auto-descend), not error."""
+    model = tmp_path / "model"
+    model.mkdir()
+    write_model(model)
+    # generate from the ROOT, not the model dir
+    r = runner.invoke(app, ["docs", "generate", "-m", str(tmp_path)])
+    assert r.exit_code == 0, r.output
+    # docs land under the resolved model dir, where the server also looks
+    assert (model / "target" / "mdl-docs" / "index.html").is_file()
+    assert not (tmp_path / "target").exists()  # NOT beside the repo root
+    r2 = runner.invoke(app, ["status", "-m", str(tmp_path)])
+    assert r2.exit_code == 0, r2.output
+
+
+def test_status_json_shape(tmp_path):
+    write_model(tmp_path)
+    r = runner.invoke(app, ["status", "-m", str(tmp_path), "--format", "json"])
+    assert r.exit_code == 0, r.output
+    data = json.loads(r.output)
+    assert data["entity_count"] > 0
+    assert "next_actions" in data and isinstance(data["next_actions"], list)
+    # docs not generated yet -> the generate action is offered
+    assert any(a["id"] == "docs-generate" for a in data["next_actions"])
+
+
+def test_server_serves_generated_docs(tmp_path):
+    write_model(tmp_path)
+    assert runner.invoke(app, ["docs", "generate", "-m", str(tmp_path)]).exit_code == 0
+
+    from fastapi.testclient import TestClient
+    from mdl_server.app import create_app
+
+    client = TestClient(create_app(tmp_path, read_only=True))
+    assert client.get("/mdl-docs/").status_code == 200
+    assert client.get("/mdl-docs/glossary.html").status_code == 200
+    # /mdl-docs (no trailing slash) MUST redirect to /mdl-docs/, or the page's relative
+    # asset links resolve at the server root and the stylesheet 404s (unstyled page).
+    noslash = client.get("/mdl-docs", follow_redirects=False)
+    assert noslash.status_code in (307, 308)
+    assert noslash.headers["location"].rstrip("/").endswith("mdl-docs")
+    # and the stylesheet resolves under the trailing-slash path
+    assert client.get("/mdl-docs/assets/docs.css").status_code == 200
+    # path traversal is refused (URL-encoded so it reaches the handler unnormalised)
+    escaped = client.get("/mdl-docs/%2e%2e%2f%2e%2e%2fmdl-project.yaml")
+    assert escaped.status_code == 404
+    # a genuinely missing docs page is a 404, not a fallthrough
+    assert client.get("/mdl-docs/entities/does-not-exist.html").status_code == 404
+
+
+def test_server_docs_absent_is_404(tmp_path):
+    write_model(tmp_path)  # no docs generated
+    from fastapi.testclient import TestClient
+    from mdl_server.app import create_app
+
+    client = TestClient(create_app(tmp_path, read_only=True))
+    assert client.get("/mdl-docs/").status_code == 404

modelith_dbt-0.6.3/packages/cli/tests/test_ontology_status_cli.py

@@ -0,0 +1,83 @@
+"""CLI: `mdl ontology status` (JSON review queue + coverage) and promote/reject by uri."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from mdl_cli.main import app
+from mdl_core.commands import apply_command
+from mdl_core.repo import ModelRepo
+
+_CORE_TESTS = Path(__file__).resolve().parents[2] / "core" / "tests"
+sys.path.insert(0, str(_CORE_TESTS))
+from model_builders import write_model  # noqa: E402
+
+runner = CliRunner()
+
+_URI = "https://spec.edmcouncil.org/fibo/Party"
+
+
+def _seed_proposed(model_dir: Path) -> str:
+    """Add a proposed alignment to the first conceptual entity; return its name."""
+    ce = next(iter(ModelRepo.load(model_dir).model.conceptual_entities.values()))
+    apply_command(
+        model_dir,
+        "set_alignment",
+        {"id": ce.id, "aligns_to": _URI, "alignment": "skos:closeMatch",
+         "status": "proposed", "ref_layer": "industry"},
+    )
+    return ce.name
+
+
+def test_status_lists_proposed_and_coverage(tmp_path):
+    write_model(tmp_path)
+    name = _seed_proposed(tmp_path)
+    r = runner.invoke(app, ["ontology", "status", "-m", str(tmp_path), "--format", "json"])
+    assert r.exit_code == 0, r.output
+    data = json.loads(r.output)
+    assert any(p["name"] == name and p["uri"] == _URI for p in data["proposed"])
+    assert "accepted" in data  # the done side of the flow, even if empty
+    assert "coverage_pct" in data["coverage"]
+
+
+def test_status_splits_proposed_and_accepted(tmp_path):
+    """A promoted ref moves from `proposed` to `accepted` — the flow the panel draws."""
+    write_model(tmp_path)
+    name = _seed_proposed(tmp_path)
+    runner.invoke(app, ["ontology", "promote", name, "-m", str(tmp_path), "--uri", _URI])
+    data = json.loads(
+        runner.invoke(app, ["ontology", "status", "-m", str(tmp_path), "--format", "json"]).output
+    )
+    assert not any(p["uri"] == _URI for p in data["proposed"])
+    assert any(a["name"] == name and a["uri"] == _URI for a in data["accepted"])
+
+
+def test_promote_by_uri_clears_the_queue(tmp_path):
+    write_model(tmp_path)
+    name = _seed_proposed(tmp_path)
+    assert runner.invoke(
+        app, ["ontology", "promote", name, "-m", str(tmp_path), "--uri", _URI]
+    ).exit_code == 0
+    r = runner.invoke(app, ["ontology", "status", "-m", str(tmp_path), "--format", "json"])
+    assert not json.loads(r.output)["proposed"]  # promoted -> no longer proposed
+
+
+def test_reject_by_uri_removes_the_ref(tmp_path):
+    write_model(tmp_path)
+    name = _seed_proposed(tmp_path)
+    assert runner.invoke(
+        app, ["ontology", "reject", name, "-m", str(tmp_path), "--uri", _URI]
+    ).exit_code == 0
+    r = runner.invoke(app, ["ontology", "status", "-m", str(tmp_path), "--format", "json"])
+    assert not json.loads(r.output)["proposed"]
+
+
+def test_status_empty_when_nothing_proposed(tmp_path):
+    write_model(tmp_path)
+    r = runner.invoke(app, ["ontology", "status", "-m", str(tmp_path), "--format", "json"])
+    assert r.exit_code == 0, r.output
+    assert json.loads(r.output)["proposed"] == []

{modelith_dbt-0.6.2 → modelith_dbt-0.6.3}/packages/cli/tests/test_telemetry.py

@@ -264,7 +264,13 @@ def test_main_wrapper_records_validate_pass_and_fail(tmp_path, monkeypatch):
     CliRunner().invoke(cli_main.app, ["init", "--demo", str(tmp_path)])
     monkeypatch.setattr("mdl_cli.telemetry.ensure_consent", lambda: False)
 
-    for target, expected in [(str(tmp_path / "model"), 0), (str(tmp_path), 1)]:
+    # A model-less dir for the failure case: an empty sibling with no mdl-project.yaml
+    # anywhere below it (tmp_path itself would now resolve DOWN into its single model/
+    # child and pass — the intended run-from-repo-root behaviour).
+    empty = tmp_path / "no-model-here"
+    empty.mkdir()
+
+    for target, expected in [(str(tmp_path / "model"), 0), (str(empty), 1)]:
         recorded: list = []
         monkeypatch.setattr(
             "mdl_cli.telemetry.record",

{modelith_dbt-0.6.2 → modelith_dbt-0.6.3}/packages/core/src/mdl_core/repo.py

@@ -40,13 +40,18 @@ PROJECT_FILE = "mdl-project.yaml"
 
 def find_project_root(start: Path) -> Path:
     """The model directory for `start`: `start` itself if it holds an
-    `mdl-project.yaml`, else the nearest ancestor that does, else `start` unchanged.
-
-    This is what lets every command run from ANYWHERE inside a model — a nested
-    working dir, or the project root one level above — instead of forcing the user to
-    `cd` into the exact folder holding the project file (issue #7). Returning `start`
-    unchanged when nothing is found keeps the caller's "no mdl-project.yaml in <dir>"
-    error pointing at the directory the user actually named."""
+    `mdl-project.yaml`, else the nearest ancestor that does, else the single immediate
+    child that does (the "I'm at the repo root, the model is in model/" case), else
+    `start` unchanged.
+
+    This is what lets every command run from ANYWHERE around a model — a nested working
+    dir, the project root one level above, OR the repo root one level above the model
+    dir (the layout `mdl init --workspace` scaffolds: model/ beside transform/) —
+    instead of forcing the user to `cd` into the exact folder holding the project file
+    (issue #7). The downward step fires ONLY when exactly one immediate child qualifies,
+    so an ambiguous layout (two model dirs) still falls through to the helpful
+    "the model is in <names>/" error rather than silently picking one. Returning `start`
+    unchanged when nothing is found keeps that error pointing at the named directory."""
     start = Path(start)
     # A file path is meaningless as a root; resolve to its directory first.
     base = start if start.is_dir() else start.parent
@@ -54,6 +59,14 @@ def find_project_root(start: Path) -> Path:
     for d in (base, *base.parents):
         if (d / PROJECT_FILE).is_file():
             return d
+    # Nothing walking up — try one level down: a single child holding the project file
+    # is the unambiguous "repo root, model in model/" case.
+    try:
+        children = [p.parent for p in base.glob(f"*/{PROJECT_FILE}") if p.is_file()]
+    except OSError:
+        children = []
+    if len(children) == 1:
+        return children[0]
     return start