modelith-dbt 0.3.1__tar.gz → 0.3.2__tar.gz

{modelith_dbt-0.3.1 → modelith_dbt-0.3.2}/PKG-INFO

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

{modelith_dbt-0.3.1 → modelith_dbt-0.3.2}/packages/cli/src/mdl_cli/main.py

@@ -87,7 +87,11 @@ def _project_name_from_path(path: Path) -> str:
 
 @app.command()
 def init(
-    path: Path = typer.Argument(Path("."), help="Directory to scaffold in"),
+    path: Path = typer.Argument(
+        None,
+        help="Directory to scaffold in. Defaults to the current directory, except "
+        "`--demo`, which defaults to ~/modelith-demo so it never writes into your repo.",
+    ),
     name: str = typer.Option(
         None,
         help="Project name. Defaults to the target directory name.",
@@ -113,27 +117,36 @@ def init(
     The project name defaults to the target directory (``mdl init my-model`` names
     the project ``my_model``); pass ``--name`` to override. ``--demo`` instead lays
     down a ready-made example you can `serve`, `validate`, `generate`, and `dbt build`
-    with no configuration.
+    with no configuration; with no path it writes to ``~/modelith-demo`` so it never
+    touches the repo you are standing in.
     """
     from mdl_cli.collab import ensure_git_hooks, scaffold_workspace
 
     if demo:
         from mdl_cli.demo import scaffold_demo
 
-        written = scaffold_demo(path)
+        # The demo must never land in the engineer's own repo. With no explicit path
+        # it goes to ~/modelith-demo (portable across mac/Linux/Windows via Path.home);
+        # an explicit `mdl init --demo <path>` still wins.
+        target = path if path is not None else Path.home() / "modelith-demo"
+        written = scaffold_demo(target)
         typer.secho(
-            f"Scaffolded a 7-entity demo model ({len(written)} files) under {path}",
+            f"Scaffolded a 7-entity demo model ({len(written)} files) under {target}",
             fg=typer.colors.GREEN,
         )
         typer.secho(
-            "  Next: mdl serve -m model   (populated ERD)\n"
-            "        mdl validate -m model\n"
-            "        mdl generate -m model -o transform/warehouse\n"
-            "        cd transform/warehouse && dbt build   (needs dbt-duckdb)",
+            f"  Next: mdl serve -m {target}/model   (populated ERD)\n"
+            f"        mdl validate -m {target}/model\n"
+            f"        mdl generate -m {target}/model -o {target}/transform/warehouse\n"
+            f"        cd {target}/transform/warehouse && dbt build   (needs dbt-duckdb)",
             fg=typer.colors.CYAN,
         )
         return
 
+    # Plain init (no --demo): default to the current directory, as before.
+    if path is None:
+        path = Path(".")
+
     if name is None:
         name = _project_name_from_path(path)
 

{modelith_dbt-0.3.1 → modelith_dbt-0.3.2}/packages/cli/tests/test_init_demo.py

@@ -7,6 +7,7 @@ offline with no config, and mint fresh ids each run so two demos never collide.
 from __future__ import annotations
 
 from pathlib import Path
+from unittest import mock
 
 from typer.testing import CliRunner
 
@@ -20,6 +21,26 @@ def _logical_entities(model: Path) -> list[Path]:
     return sorted((model / "logical" / "entities").glob("*.yaml"))
 
 
+def test_init_demo_no_path_defaults_to_home_not_cwd(tmp_path: Path, monkeypatch):
+    """`mdl init --demo` with no path must NOT write into the current directory
+    (the engineer's repo); it defaults to ~/modelith-demo. Regression guard for the
+    pollution bug where the demo scaffolded into whatever repo you were standing in."""
+    home = tmp_path / "home"
+    home.mkdir()
+    cwd = tmp_path / "some_repo"
+    cwd.mkdir()
+    monkeypatch.chdir(cwd)
+    # Path.home() reads $HOME on posix; set it so the test never touches the real home.
+    with mock.patch("mdl_cli.main.Path.home", return_value=home):
+        result = runner.invoke(app, ["init", "--demo"])
+    assert result.exit_code == 0, result.output
+    # the demo landed in ~/modelith-demo ...
+    assert (home / "modelith-demo" / "model" / "mdl-project.yaml").exists()
+    # ... and the cwd (the "repo") is untouched
+    assert not (cwd / "model").exists()
+    assert list(cwd.iterdir()) == []
+
+
 def test_init_demo_scaffolds_a_populated_model(tmp_path: Path):
     """`mdl init --demo` writes a model with 6 to 10 logical entities plus a dbt
     project, and exits 0 (spec §4.2: the first serve shows a real ERD, not a grid)."""

{modelith_dbt-0.3.1 → modelith_dbt-0.3.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.3.1"
+version = "0.3.2"
 description = "Ontology-anchored, git-native data modeling tool for dbt-core teams"
 readme = "README.md"
 requires-python = ">=3.11"

{modelith_dbt-0.3.1 → modelith_dbt-0.3.2}/uv.lock

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

modelith_dbt-0.3.1/docs/new-version-to-pypi.md

@@ -1,31 +0,0 @@
-### Bump up version
-Change in modelith/pyproject.toml and git commit
-
-```
-name = "modelith-dbt"
-version = "0.3.0"
-...
-```
-
-### Tag it
-```
-git tag -a v0.3.0 -m "modelith-dbt 0.3.0" && git push origin v0.3.0
-```
-
-### Clean & Build
-```
-rm -rf dist && uv build
-```
-
-### Check the build
-
-```
-uv run --with twine twine check dist/*
-```
-
-### Publich it to PyPI
-```
-uv run --with twine twine upload dist/* 
-```
-
-Needs API Token: 

modelith_dbt-0.3.1/modelith-gtm-monetisation-spec.md

@@ -1,261 +0,0 @@
-# Modelith Go-to-Market and Monetisation Spec
-
-Status: draft v2
-Owner: dbose
-Scope: the 180-day plan to grow adoption and stand up a revenue line, without taxing the individual engineer who makes the tool spread.
-
-Changelog from v1: pricing anchored to real 2026 comparables (dbt, Grafana, Datafold, Tobiko). New licensing section built on the HashiCorp and Sentry precedents. Datafold reframed as a structural opening. ROI framing borrowed from Tobiko. Positioning of the open-core line validated against Grafana's model.
-
----
-
-## 1. Thesis
-
-Modelith wins the same way dbt did. Bottom-up. An analytics engineer installs a CLI, gets value in one sitting, and tells the next engineer. The company only shows up to pay once the tool is already load-bearing in their pipeline.
-
-So the plan has one rule that overrides everything else: the individual local workflow stays free and un-crippled forever. Every dollar comes from the team plane, where the buyer is a platform lead or a data architect, not the engineer who first ran `mdl init`.
-
-The commercial wedge is not the ERD canvas. Diagramming is how a new user falls in love in the first 30 seconds, but nobody wires a purchase order to a picture. The thing an org pays to keep running is drift enforcement in CI: the gate that fails a pull request when the warehouse no longer matches the committed model. That converts Modelith from a nice local viewer into production infrastructure with a blast radius if it disappears. Everything below is built to march a user from the canvas to that gate.
-
----
-
-## 2. What the comparable platforms actually do
-
-Five companies sell into roughly Modelith's world. Their models, with the lesson for you, from 2026 pricing pages.
-
-| Company | Free tier | Paid entry | Enterprise floor | Meters on | The lesson |
-|---|---|---|---|---|---|
-| dbt Labs | Developer, 1 seat, 3k models/mo, 1 project | Starter $100 / user / mo, 5 seats | Custom, SLA + PrivateLink + 30 projects | seats + models built + projects | a genuinely useful single-seat free product is the whole funnel |
-| Grafana | $0, 3 users, community support, 14-day retention | Pro $19 / mo + usage | $25k / year minimum | active users + usage (series, GB) | OSS stays fully functional; gate enterprise connectors, SSO, reporting, RBAC, support |
-| Datafold | none, no free trial | quote only, sales-gated | quote | data source connections + data volume | its lack of a free tier is your opening (see 2.1) |
-| Tobiko (SQLMesh) | SQLMesh + SQLGlot, full OSS | Tobiko Cloud, managed | quote | managed service + warehouse savings | sell the ROI in warehouse compute and incidents avoided, not features |
-| PostHog | generous usage-based free tier | transparent per-unit usage | volume-discounted | events, recordings, flags | publish self-serve pricing; do not hide it behind a demo |
-
-The pattern across the winners is consistent. Free is a real product, not a trailer. The first paid tier is self-serve with a published price. Enterprise carries a floor around $25k and is where security, deployment, and support live. Grafana is the closest structural match to Modelith and worth copying almost directly: the open-source Grafana is complete on its own, and the money sits in enterprise data-source plugins, SAML and LDAP auth, reporting, role-based access, and a support contract. Map that onto Modelith and the paid layer is the catalog adapters, the SSO header trust, the audit retention, RBAC, and the CI gate. You already built most of it.
-
-### 2.1 Datafold is the opening, not just the competitor
-
-Datafold owns the "diff and drift in CI" category that Modelith's gate competes in. But its pricing is quote-only, sales-gated, with no free tier and no self-serve trial, metered on data-source connections and volume. That is a top-down enterprise motion. It means a single analytics engineer cannot land Datafold on a Tuesday afternoon and show their team by Thursday.
-
-Modelith can. A free CLI with local `mdl drift` is a bottom-up motion Datafold structurally cannot run without cannibalising its own sales-led pricing. So the wedge is not "we diff better." It is "you can adopt us without a procurement cycle, and the gate you fell in love with locally is the same gate your platform team turns on in CI." Name that in the launch content. The incumbent's go-to-market is the gap.
-
----
-
-## 3. The open-core boundary
-
-The core is Apache-2.0 and stays that way (see the licensing covenant in section 8, which is not optional). Do not gate features by crippling the local binary. Gate at the network boundary instead: the paid capabilities are the ones that naturally need a shared server, a shared identity, or a shared enforcement point, so they live in a hosted control plane rather than hidden inside the CLI. This is exactly Grafana's split, and it is why Grafana kept community goodwill through a decade of commercial growth while Elastic and Redis and HashiCorp burned theirs relicensing.
-
-The split, mapped to what already exists in the repo:
-
-| Capability | Where it lives today | Tier |
-|---|---|---|
-| `mdl` CLI: init, validate, generate, reverse, lint | local | Free |
-| Web canvas (`mdl serve` / `mdl studio`), ERD preview | local | Free |
-| VS Code extension: preview-to-side, YAML completion, diagnostics on save | local | Free |
-| Language server (`mdl lsp`) hover, code actions | local | Free |
-| Local `mdl drift` run against a compiled warehouse | local | Free |
-| Single-target dbt emit (pick one platform) | local | Free |
-| Ontology browse and local alignment | local | Free |
-| CI drift enforcement gate (blocking, hosted, with policy + reporting) | server / GitHub App | Team |
-| Centralized ontology sync across repos | server | Team |
-| Hosted glossary/Studio for SMEs with managed identity | server | Team |
-| Multi-target emitters (Snowflake + Redshift + Iceberg + Trino + ODCS + Pydantic + Neo4j in one project) | local, license-gated | Team |
-| Audit log retention and search (the OpenTelemetry sink you built) | server | Team |
-| CODEOWNERS-routed proposal review with PR state | server | Team |
-| Enterprise catalog sync (Collibra adapter, OpenLineage emission) | server + adapter | Enterprise |
-| SSO header trust, SAML/OIDC via proxy, `MDL_AUTH_REQUIRE` | server | Enterprise |
-| Conformance kit for a bespoke governance mapping | server + support | Enterprise |
-| VPC / on-prem deployment, RBAC, SLA, SOC 2 | deployment | Enterprise |
-
-Two features sit on the line and need a deliberate call. Local `mdl drift` run stays free, because an engineer checking drift on their laptop is exactly the taste that sells the gate. The blocking gate that runs in the org's CI, with a shared policy file and a report, is paid, because that is the thing with organisational value and a natural server home. Multi-target emit is the one local feature worth a license key: a solo user needs one warehouse, a platform team needs four, so the count is a clean proxy for "this is a team now."
-
-### Technical gating
-
-- Server-native features (CI gate, ontology sync, catalog sync, hosted Studio, audit retention) are gated by simply being a service you authenticate to. No key-cracking risk, because the code is not shipped.
-- The one local paid feature (multi-target emit) uses a signed license key checked offline. Over the free limit of one target, `mdl generate` prints an upgrade line and the target list it would have emitted. It never deletes work or holds a model hostage. Leaning toward dropping even this and making multi-target a server feature, to keep the OSS binary entirely key-free (see open decisions).
-- Ship `modelith-enterprise` as a separate closed package that depends on the Apache core. The core never imports it. This keeps the license story clean for anyone auditing the OSS.
-
----
-
-## 4. Phase 1: Frictionless onboarding (Days 1 to 30)
-
-Goal: a first-time user reaches a rendered ERD beside their own dbt YAML, with a green `mdl validate`, in under a minute, on the first try, with no config. This is the dbt-Developer-tier lesson made literal: the free experience has to be a complete product.
-
-### 4.1 One-command setup
-
-- Keep `uv tool install modelith-dbt` and `pipx install modelith-dbt` as the two blessed paths. Pin them at the top of the README and the site.
-- VS Code, Cursor, Windsurf: the extension must resolve `mdl` with zero settings when the user did a standard tool install. The detection order already exists (explicit setting, project `.venv`, PATH, conda/virtualenv, per-user install dirs). Add one thing: when detection fails, the extension offers a one-click "install the CLI for me" that runs the `uv` command in an integrated terminal, rather than a docs link.
-- Remote environments and devcontainers: the extension already declares `extensionKind: ["workspace"]`, so the server runs next to dbt and the warehouse creds. Add a `.devcontainer` feature (`ghcr.io/dbose/features/modelith`) so a team adds Modelith to a codespace with one line. Verify the auto-bind on a cold Codespaces boot and a cold Gitpod boot before calling this done.
-
-Acceptance:
-- Fresh machine, no Python project, to `mdl --help` working: under 2 minutes.
-- Fresh VS Code with the extension and a dbt repo open, to canvas rendering: under 30 seconds, no manual path config.
-
-### 4.2 Instant value demonstration
-
-- Ship a sample project inside the package: `mdl init --demo` scaffolds a 6 to 10 entity model with keys, one enumerated domain, one relationship, and a matching set of generated dbt models, so the very first `mdl serve` shows a populated canvas rather than an empty grid. The repo already tracks demo projects as adoption assets; wire one to the init command.
-- The demo must run the full loop offline against DuckDB: `mdl init --demo`, `mdl serve`, edit an attribute on the canvas, `mdl validate`, `mdl generate -o warehouse`, `dbt build`. No warehouse account required to feel the whole thing.
-- Record a 90-second screen capture of exactly that loop and put it above the fold on the site and the README. The canvas moving beside YAML is the entire pitch; show it, do not describe it.
-
-Acceptance:
-- `mdl init --demo && mdl serve` renders a non-empty ERD with no further input.
-- A user with only DuckDB completes model to `dbt build` without creating any external account.
-
-### 4.3 What to instrument now
-
-Stand up privacy-respecting, opt-in telemetry before the launch traffic hits, or you will be blind during the one window when data matters most. Opt-in on first run, one prompt, off by default if declined, and never phone home model contents. Capture command name, success or failure, and a hashed install id. That is enough to compute activation and retention and nothing that reads a customer's schema.
-
-Activation metric for the whole phase: percentage of new installs that reach `mdl validate` passing within 24 hours of first `mdl init`. Target 40 percent by day 30.
-
----
-
-## 5. Phase 2: Distribution and word-of-mouth (Days 31 to 90)
-
-Goal: turn a working tool into a known one, on the three channels where dbt practitioners actually gather.
-
-### 5.1 Targeted community launches
-
-Sequence them, do not fire all at once. Each launch feeds the next with proof.
-
-- Week 5, dbt Slack `#tools-and-tech`: soft launch to the highest-intent, most forgiving audience. Lead with the reverse-engineering demo, since every one of them has a legacy dbt project and no diagram of it. "Point `mdl reverse` at your manifest and get a logical model back" is the hook that gets a data engineer to run one command.
-- Week 7, r/dataengineering: a written teardown, not an ad. Title angle: reverse an existing warehouse into a model, align it to an ontology, and catch the drift, with real command output and the DuckDB demo anyone can reproduce. The recent drug-discovery demo (reverse a real warehouse plus live ontology alignment) is the strongest artifact you have; clean it up and make it the centrepiece.
-- Week 9, Hacker News: Show HN with the single sharpest differentiator, the git-native model where every surface is a client and none owns state. HN rewards an architectural idea with a working repo behind it. Have the maintainer free that whole day to answer every comment in the first three hours, because that thread is the launch. HN also punishes a rug-pull reputation, so lead with the Apache covenant (section 8) in the post itself.
-
-For each launch, prepare the same three proof points and pick the one that fits the audience: live ERD canvas beside YAML, ontology-anchored governance, and the CI drift gate that names which dbt models a change will break.
-
-### 5.2 High-intent content
-
-Write for the engineer typing a specific problem into a search bar, not for a newsletter. Each piece ends at a command they can run.
-
-Launch set, in priority order:
-1. "How to enforce dbt data contracts in VS Code before you open the PR." The flagship. Show diagnostics on save, then the gate.
-2. "Reverse engineer an undocumented dbt project into an ERD in one command." Highest reproducibility, widest audience.
-3. "Catch a breaking schema change before it ships: drift detection in GitHub Actions." This is the paid feature's own top-of-funnel; the article is free, the gate it demonstrates is the Team tier.
-4. "Let a business analyst edit the glossary without a GitHub account." The SME-to-PR story, which no competitor has.
-5. "Adopt drift-in-CI without a procurement cycle." The Datafold-shaped hole from section 2.1, written as a migration path, not a hit piece.
-
-Cadence: one deep piece every two weeks, each with copy-paste commands and the DuckDB demo so a reader reproduces it in five minutes. Cross-post to the personal blog, dev.to, and the relevant subreddit. One canonical URL, the rest with canonical tags.
-
-Metric for the phase: GitHub stars are vanity; track weekly active installs (telemetry) and `mdl reverse` runs, since reverse is the command a serious evaluator runs against their own code.
-
----
-
-## 6. Phase 3: The enterprise bridge (Days 91 to 180)
-
-Goal: convert the teams already running Modelith locally into paying accounts, triggered by the product noticing they became a team.
-
-### 6.1 The freemium split goes live
-
-Ship the Team tier as a real thing a lead can buy with a card, self-serve, no sales call for the first band. This is the PostHog and Grafana Pro lesson: publish the price, let them swipe. Datafold's sales-gate is the thing you are beating, so do not import it. The gated capabilities are the ones from section 3: the blocking CI drift gate, centralized ontology sync, the hosted SME Studio with managed identity, multi-target emit, and audit retention. Local ERD preview, YAML completion, and local diagnostics stay free and get no downgrade, because the moment an individual engineer feels punished, the bottom-up engine stalls.
-
-### 6.2 Product-triggered inbound
-
-This is the mechanism that makes the whole plan self-driving. Modelith can see when a solo project became a team project, from signals it already has, and turn that into a prompt at the exact moment the pain is real.
-
-Detection signals, all local, all already present:
-- The model repo's `git shortlog` shows more than one committer in the last 30 days.
-- The proposal flow has resolved more than one distinct identity (the identity seam records `source` and author on every propose).
-- More than one target platform is configured, or a `set_kg_base_iri` exists, both markers of a shared model rather than a scratchpad.
-
-When two or more of those fire, `mdl` and the extension surface one quiet, dismissible prompt: this looks like a team model, turn on drift enforcement so a breaking change fails the PR instead of reaching the warehouse. One line, a link to enable, and it never nags again once dismissed. No dark patterns, no interrupting a build.
-
-The prompt routes to the Team tier signup, not to a "contact sales" form, for anything under the enterprise band. Sales only enters when the account needs catalog sync, SSO, or a VPC deploy.
-
-Acceptance:
-- The multi-dev detector fires correctly on a two-committer demo repo and stays silent on a solo one.
-- The prompt appears at most once per workspace until dismissed, and dismissal is durable.
-
-### 6.3 First enterprise motion
-
-By day 120, line up three design-partner conversations from the highest-signal inbound (accounts that hit the multi-dev prompt and also touch Collibra, OpenLineage, or an SSO proxy header). Offer the Enterprise tier at a design-partner rate in exchange for a reference and a case study. The conformance kit you already built is the artifact that lets a partner validate their own bespoke catalog mapping in CI, which is the thing that closes a governance buyer.
-
----
-
-## 7. Pricing and packaging
-
-Meter on the unit that tracks value and does not tax adoption. Not per-engineer-seat, because that punishes the exact people who spread the tool. Meter on governed workspaces plus steward seats, the way Datafold meters connections and Grafana meters active users, and let viewers and proposers in for free.
-
-| Tier | Who buys | Unit | Indicative price | Anchored against |
-|---|---|---|---|---|
-| Community | individual engineer | free | $0 | dbt Developer, SQLMesh OSS |
-| Team | platform lead | per governed repo/workspace, includes 3 steward seats | $600 to $1,200 / workspace / month | dbt Starter ($100 x 5 seats = $500 floor), Grafana Pro |
-| Enterprise | data governance / platform org | annual contract | from $30k ACV | Grafana $25k floor, Datafold quote, dbt custom |
-
-The band is deliberately just above dbt Starter's effective floor. A platform team already paying dbt $500-plus a month for five seats will not blink at a comparable number for the tool that stops a bad model reaching the warehouse dbt then builds into. The enterprise floor sits at the category norm, since Grafana's published minimum is $25k and Datafold and dbt both quote north of that.
-
-Notes on the metering choice:
-- Viewers and SME proposers are always free. The whole SME-to-PR story dies if you charge the business analyst a seat; their edits are the reason a platform team buys.
-- Steward seats (the people who approve proposals and own the gate) are the paid seats above the workspace base. That is a small, senior population, which is who to charge.
-- A workspace equals one governed model repo. A company with 4 governed marts pays for 4, which scales with how much of their stack actually depends on Modelith.
-- Publish this. Do not put the Team price behind a demo form. The self-serve price is a competitive weapon against Datafold's quote-only wall.
-
-### 7.1 Sell the ROI, not the feature list
-
-Tobiko sells SQLMesh's cloud on warehouse compute saved, a number a buyer can put in a spreadsheet. Modelith's equivalent is incidents prevented. One breaking schema change that reaches production and silently corrupts a downstream mart costs an org a debugging fire drill, a backfill, and a trust hit with the business. The gate that catches it at PR time, naming the exact dbt models it would break, is cheap against that. Frame the Team tier in those terms on the pricing page: a workspace subscription is less than the cost of one prevented data incident a quarter.
-
-Give a 12-month free Team tier to any project under an OSI-approved open-source license. Cheap goodwill, and it seeds public examples of Modelith-governed repos that become their own top-of-funnel.
-
----
-
-## 8. Licensing: the covenant and the enterprise license
-
-The single biggest reputational risk to an open-core project is the relicensing rug-pull, and the last three years are a graveyard of them. HashiCorp moved Terraform from MPL to the Business Source License in 2023, the community forked it into OpenTofu within months, and the Linux Foundation now hosts the fork. Redis relicensed and the community left for the Valkey fork. Elastic went to SSPL, took years of reputational damage, and later re-added an open license to stop the bleeding. The lesson is uniform: relicensing a project after a community has formed around its open license is read as a betrayal, and the fork that follows takes the mindshare with it.
-
-So the rule for Modelith is a public, dated covenant, stated in the README and the launch posts:
-
-> The `modelith` core (the CLI, canvas, LSP, and everything in the Apache-2.0 packages today) will remain Apache-2.0. New paid capabilities ship as separate components under their own license. The core license will not be revoked or narrowed.
-
-That promise is worth more than any feature, because it is the thing a platform team's architect worries about before they build a workflow on you. Make it loud.
-
-For the paid components, two options, and a recommendation.
-
-- Straight commercial license on `modelith-enterprise` and the hosted control plane. Simple, well understood, and the code is server-side anyway so almost nobody sees it. This is Grafana's enterprise model.
-- Functional Source License (FSL) on the server plane, the model Sentry created. FSL forbids a competitor from using the code to build a competing product for two years, then it automatically converts to Apache or MIT (the delayed-open-source mechanism). It buys protection against a hyperscaler wrapping your hosted Studio and reselling it, while still committing the code to real open source on a timer.
-
-Recommendation: commercial license for `modelith-enterprise` now, because the immediate risk is not a hyperscaler, it is shipping revenue. Hold FSL in reserve for the hosted Studio if and when a cloud provider starts circling. Either way, the Apache core covenant is non-negotiable and comes first.
-
----
-
-## 9. Risk mitigation blueprint
-
-- Do not over-charge engineers. The metering unit in section 7 is the enforcement of this. The individual local tool never degrades, never expires, never nags beyond the single team-detection prompt. If an engineer ever feels the free tier is bait, the flywheel breaks, so treat the free experience as a paid feature in its own right. This is the dbt Developer tier discipline.
-- Make the CI gate genuinely better than a diagram. The gate must do what a static diagram cannot: classify a change as breaking, additive, or cosmetic, and name the exact dbt models a breaking change will take down, at PR time, in under 30 seconds on a 400-model project (the repo already claims this bar; hold it as a hard SLO). That sentence, printed on the PR, is the difference between a convenience and a safeguard nobody will remove.
-- Guard the OSS trust with the covenant in section 8. Every gated feature must have a clear "this needs a server or a team, that is why it costs money" story. The day a community user feels a purely local capability moved behind a paywall, the Hacker News goodwill inverts, and the HashiCorp precedent shows how fast a fork forms.
-- Do not out-run support. A solo maintainer cannot both ship enterprise features and answer a launch-week flood. Stage the launches (section 5.1) so the traffic arrives in waves you can actually respond to, and hold the enterprise motion until the Team tier is self-serve enough to not need you in every deal.
-- Single-maintainer bus factor. Before the enterprise motion, get CI green and badged, publish the contribution guide, and land at least two external contributors on small issues. An enterprise buyer diligences the project's survival, and a one-person repo with no CI is a procurement blocker regardless of how good the code is.
-
----
-
-## 10. Milestones
-
-| Day | Milestone | Proof it worked |
-|---|---|---|
-| 15 | `mdl init --demo` ships; extension one-click CLI install; telemetry opt-in live; Apache covenant published | fresh-machine demo loop under 2 min, recorded |
-| 30 | Site with the 90-second canvas video; activation instrumented; Team price published | 40% of new installs reach passing `mdl validate` in 24h |
-| 45 | dbt Slack launch | first 100 non-author installs |
-| 60 | r/dataengineering teardown + reverse-engineering article | weekly active installs trending up 4 weeks straight |
-| 75 | Show HN | top-half HN placement, maintainer answered every first-3-hour comment |
-| 90 | Content set 1 to 5 published | `mdl reverse` runs from distinct installs across a target you set |
-| 120 | Team tier self-serve live; multi-dev prompt shipped | first paid workspace, prompt fires correctly on team repos |
-| 150 | 3 enterprise design-partner conversations open | one signed design-partner LOI |
-| 180 | First Enterprise contract or design-partner case study | ARR line exists; one public reference |
-
----
-
-## 11. Open decisions
-
-- Hosted control plane build vs the GitHub App path for the CI gate. The App is the faster route to a gate that runs in the customer's CI without you hosting their data; decide before day 90. (Taking this one next.)
-- Whether multi-target emit is worth the license-key machinery, or whether it should just be a Team-server feature to avoid shipping any offline key check at all. Leaning toward the latter to keep the OSS binary key-free.
-- Team price point: validate the $600 to $1,200 band against 5 real platform leads before the pricing page ships. The anchor says it is right; five conversations will say whether it is.
-- FSL vs straight commercial for the hosted Studio. Default commercial now, revisit if a cloud provider starts circling.
-
----
-
-## Sources
-
-- [dbt pricing 2026, Mammoth](https://mammoth.io/blog/dbt-pricing/) and [dbt Labs pricing](https://www.getdbt.com/pricing)
-- [Grafana pricing](https://grafana.com/pricing/)
-- [Datafold pricing 2026, Modern DataTools](https://www.modern-datatools.com/tools/datafold/pricing) and [Datafold pricing](https://www.datafold.com/pricing)
-- [Tobiko launches SQLMesh cloud into GA, The New Stack](https://thenewstack.io/tobiko-launches-its-sqlmesh-based-cloud-service-into-ga/)
-- [PostHog pricing 2026, StackScored](https://www.stackscored.com/pricing/product-analytics/posthog/)
-- [Terraform BSL license change, Spacelift](https://spacelift.io/blog/terraform-license-change) and [OpenTofu manifesto](https://opentofu.org/manifesto/)
-- [Fall 2024 software licensing roundup (FSL, Fair Source, DOSP), FOSSA](https://fossa.com/blog/fall-2024-software-licensing-roundup/) and [Sentry FSL, TechCrunch](https://techcrunch.com/2023/11/20/with-functional-source-license-sentry-wants-to-grant-developers-freedom-without-harmful-free-riding/)

modelith_dbt-0.3.1/sandbox/onboarding/Dockerfile

@@ -1,41 +0,0 @@
-# Phase 1 onboarding sandbox: a CLEAN machine, the way a new engineer's is.
-#
-# The whole point of this image is what it does NOT contain: no uv, no pipx, no
-# global mdl, no project .venv, none of the PATH entries a developer's own shell
-# profile accumulates. debian:stable-slim ships a system Python but no Python
-# packaging tooling, so "fresh machine to `mdl --help`" is tested honestly -
-# including the step where the engineer first has to install uv itself.
-#
-# We install NOTHING Modelith-related at build time on purpose. The build only
-# lays down the bare prerequisites a real fresh machine already has (curl, ca
-# certs, git, the `time` command). Everything the acceptance bars measure -
-# installing uv, `uv tool install modelith-dbt`, the demo loop - happens inside
-# run-phase1.sh at RUN time, where it can be timed and asserted.
-FROM debian:stable-slim
-
-# MODELITH_VERSION pins exactly what a new engineer gets from the blessed path
-# today. Override at build time to test a different release:
-#   docker build --build-arg MODELITH_VERSION=0.3.1 ...
-ARG MODELITH_VERSION=0.3.0
-ENV MODELITH_VERSION=${MODELITH_VERSION}
-
-# Bare prerequisites only. curl to fetch the uv installer, ca-certificates for
-# HTTPS to PyPI, git because dbt/model repos are git-native, and coreutils for a
-# dependable `date`/`time`. Deliberately NOT installing python3-pip, pipx, or uv.
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        curl ca-certificates git coreutils \
-    && rm -rf /var/lib/apt/lists/*
-
-# Run as a non-root user, like a real developer account. uv tool install targets
-# ~/.local/bin for this user, exactly as it would on a laptop.
-RUN useradd -m -s /bin/bash engineer
-USER engineer
-WORKDIR /home/engineer
-
-# The harness is the only thing we copy in. It does the timed install + demo loop.
-COPY --chown=engineer:engineer run-phase1.sh /home/engineer/run-phase1.sh
-
-# Default: run the full Phase 1 acceptance harness. Override with `bash` to poke
-# around interactively (docker run --rm -it modelith-onboarding bash).
-ENTRYPOINT ["/bin/bash", "/home/engineer/run-phase1.sh"]