model2data-studio 0.1.0__py3-none-any.whl

model2data_studio/mcp_server.py

@@ -0,0 +1,377 @@
+"""The studio as tools an agent can call, over MCP.
+
+The same account, the same API key and the same API as the CLI -- this is the
+CLI's work with a different mouth on it. Which is the point: the studio is
+where a schema is *designed*, with a diagram and a preview to design it
+against, and the agent sitting in someone's editor is where the data is
+wanted. Asking it for "two hundred believable orders from my webshop model"
+should not mean pasting DBML into a chat.
+
+Five tools, in the order someone finds them:
+
+    account          what this key can do, and the caps it is under
+    list_projects    which projects the account has
+    describe_project one project's tables, columns and refs, as text
+    preview_data     generate and return rows inline, capped
+    write_data       generate and write the files, as `generate --out` does
+
+`preview_data` is the one that makes this worth building. An agent that can
+*read* two hundred generated rows can reason about them -- write an assertion
+against them, spot that `shipped_at` precedes `ordered_at`, notice a column
+coming out as placeholder text. `write_data` is for when it has decided and
+wants the fixtures on disk.
+
+Everything the tools resolve -- the seed, the anchor day, the row counts --
+goes through `export.resolve`, the same function the CLI uses, so an agent and
+a pipeline generating from one project with the same arguments get the same
+rows.
+
+Run it as `model2data-studio-mcp`, with MODEL2DATA_STUDIO_KEY in the
+environment; see the README for the client configuration.
+"""
+
+from __future__ import annotations
+
+import csv
+import functools
+import io
+import os
+import zipfile
+from pathlib import Path
+from typing import Any
+
+from . import export
+from .archive import unpack
+from .client import DEFAULT_URL, StudioClient, StudioError
+
+KEY_ENV = "MODEL2DATA_STUDIO_KEY"
+URL_ENV = "MODEL2DATA_STUDIO_URL"
+
+# How much generated data a preview hands back.
+#
+# A tool result is context: it is read by a model, at a cost, and a tool that
+# answers with a megabyte of CSV crowds out the conversation it was called in.
+# Fifty rows is enough to see the shape of a table, spot a column coming out
+# wrong, and write an assertion against it; the row count is always reported in
+# full, so nothing about the run is hidden by the cap. `write_data` is the way
+# to get all of it.
+PREVIEW_ROWS = 50
+PREVIEW_CHARACTERS = 20_000
+
+
+def _client() -> StudioClient:
+    key = os.environ.get(KEY_ENV, "")
+    if not key:
+        # Raised rather than returned so every tool reports it the same way:
+        # this is the one setup mistake that makes all five useless, and the
+        # fix is the same sentence every time.
+        raise StudioError(
+            f"No API key. Set {KEY_ENV} in this server's environment -- create a key in the "
+            f"studio's account menu."
+        )
+    return StudioClient(os.environ.get(URL_ENV) or DEFAULT_URL, key)
+
+
+def _schema_of(saved: dict[str, Any]) -> dict[str, Any]:
+    schema = saved.get("schema")
+    if schema is None:
+        raise StudioError(
+            "This project has no saved schema yet. Open it in the studio once, which is what "
+            "parses the DBML, then try again."
+        )
+    return dict(schema)
+
+
+def describe(saved: dict[str, Any]) -> str:
+    """One project as text a model can read.
+
+    Text rather than the raw IR, deliberately. The IR is a wire format with
+    `notNull` and `compositeKeys` in it; what an agent needs to answer "what is
+    in this database" is the shape, and a line per column is both smaller and
+    clearer than the JSON it came from. The DBML itself is included at the end
+    for anything this summary flattens.
+    """
+    schema = _schema_of(saved)
+    lines = [f"# {saved.get('name') or 'Untitled'}", ""]
+
+    settings = [
+        f"rows: {saved.get('rows', 100)}",
+        f"seed: {saved.get('seed') if saved.get('seed') is not None else 'not pinned'}",
+        f"locale: {saved.get('locale') or 'engine default'}",
+        f"dates anchored on: {saved.get('asOf') or 'the day it is generated'}",
+    ]
+    lines.append("Settings: " + ", ".join(settings))
+    lines.append("")
+
+    for table in schema.get("tables", []):
+        qualified = (
+            f"{table['schemaName']}.{table['name']}" if table.get("schemaName") else table["name"]
+        )
+        lines.append(f"## {qualified}")
+        if table.get("note"):
+            lines.append(f"    {table['note']}")
+        for column in table.get("columns", []):
+            marks = []
+            if column.get("pk"):
+                marks.append("pk")
+            if column.get("notNull"):
+                marks.append("not null")
+            if column.get("unique"):
+                marks.append("unique")
+            # The note is where a generation hint lives (`{"min": 5.99}` and
+            # friends), so it is the most useful thing on the line after the
+            # type -- it is what decides the values that come out.
+            if column.get("note"):
+                marks.append(f"note: {column['note']}")
+            suffix = f"  [{', '.join(marks)}]" if marks else ""
+            lines.append(f"  {column['name']}: {column.get('type', '')}{suffix}")
+        lines.append("")
+
+    refs = schema.get("refs", [])
+    if refs:
+        lines.append("## References")
+        for ref in refs:
+            lines.append(
+                f"  {ref.get('fromTable')}.{ref.get('fromColumn')} "
+                f"{ref.get('relation', '>')} "
+                f"{ref.get('toTable')}.{ref.get('toColumn')}"
+            )
+        lines.append("")
+
+    enums = schema.get("enums", [])
+    if enums:
+        lines.append("## Enums")
+        for enum in enums:
+            lines.append(f"  {enum.get('name')}: {', '.join(enum.get('values', []))}")
+        lines.append("")
+
+    lines.append("## DBML")
+    lines.append(saved.get("dbml", ""))
+    return "\n".join(lines)
+
+
+def preview(archive: bytes, *, rows: int = PREVIEW_ROWS, budget: int = PREVIEW_CHARACTERS) -> str:
+    """The generated archive as CSV a model can read, capped.
+
+    Every table is represented, however many there are: truncating the *tables*
+    would hide one entirely, which is worse than showing fewer rows of each. So
+    the per-table allowance shrinks as the schema grows, and each table says how
+    many rows it really has.
+    """
+    try:
+        bundle = zipfile.ZipFile(io.BytesIO(archive))
+    except zipfile.BadZipFile as error:
+        raise StudioError(
+            f"The studio returned something that isn't an archive: {error}"
+        ) from error
+
+    with bundle:
+        members = [member for member in bundle.infolist() if member.filename.endswith(".csv")]
+        if not members:
+            raise StudioError("The studio's archive had no CSV in it.")
+        share = max(1, budget // len(members))
+        sections = []
+        for member in sorted(members, key=lambda item: item.filename):
+            with bundle.open(member) as handle:
+                text = handle.read().decode("utf-8", errors="replace")
+            reader = list(csv.reader(io.StringIO(text)))
+            header, body = (reader[0], reader[1:]) if reader else ([], [])
+            shown = body[:rows]
+            rendered = "\n".join(",".join(row) for row in [header, *shown])
+            if len(rendered) > share:
+                rendered = rendered[:share].rsplit("\n", 1)[0]
+                shown = shown[: rendered.count("\n")]
+            name = Path(member.filename).stem
+            note = (
+                f"{len(body)} rows"
+                if len(shown) == len(body)
+                else f"first {len(shown)} of {len(body)} rows"
+            )
+            sections.append(f"## {name} ({note})\n{rendered}")
+    return "\n\n".join(sections)
+
+
+def build() -> Any:
+    """The server, built on first use.
+
+    A function rather than a module-level object so that importing this module
+    -- which the tests do, to call the logic above directly -- does not require
+    the MCP SDK to be installed. It is an optional dependency: this package is
+    installed on CI runners that want the CLI and nothing else.
+    """
+    try:
+        # `MCPServer` since mcp 2.0, where it was renamed from `FastMCP`.
+        from mcp.server.mcpserver import MCPServer
+    except ModuleNotFoundError as error:  # pragma: no cover - depends on the install
+        raise StudioError(
+            "The MCP server needs the mcp package (2.0 or newer). Install this with its extra: "
+            "`pip install 'model2data-studio[mcp]'`."
+        ) from error
+
+    from mcp.server.mcpserver.exceptions import ToolError
+
+    def reported(tool):
+        """Let the studio's own sentence reach the model.
+
+        Everything in `client.py` raises `StudioError` with a message written
+        for a person to act on -- a refused key, a plan boundary, a studio that
+        cannot be reached. Left alone, the SDK treats any exception but
+        `ToolError` as a crash and the model is told only "Error executing tool
+        <name>", which is the one thing it cannot act on. So each of these is
+        an anticipated failure, with the message carried.
+        """
+
+        @functools.wraps(tool)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return tool(*args, **kwargs)
+            except StudioError as error:
+                raise ToolError(str(error)) from error
+
+        return wrapper
+
+    server = MCPServer(
+        "model2data-studio",
+        instructions=(
+            "Realistic fake data from a schema designed in model2data studio. "
+            "`list_projects` first if no project id is at hand, `describe_project` to see what "
+            "a project holds, `preview_data` to read rows, `write_data` to put them on disk."
+        ),
+    )
+
+    @server.tool()
+    @reported
+    def account() -> str:
+        """What this API key can do, and the limits its plan is under.
+
+        Worth reading before asking for a lot of rows: the caps are per plan,
+        and a refusal is a 402 rather than a smaller answer.
+        """
+        with _client() as client:
+            usage = client.get_usage()
+            plan = client.get_plan() or {}
+        lines = [f"Plan: {plan.get('name', usage.get('plan', 'unknown'))}"]
+        for label, key in (
+            ("Rows per table", "maxRows"),
+            ("Tables", "maxTables"),
+            ("Projects", "maxProjects"),
+        ):
+            if key in plan:
+                lines.append(f"{label}: {plan[key] if plan[key] is not None else 'unlimited'}")
+        for label, key in (("dbt export", "dbtExport"), ("Shaping", "shaping")):
+            if key in plan:
+                lines.append(f"{label}: {'yes' if plan[key] else 'no'}")
+        return "\n".join(lines)
+
+    @server.tool()
+    @reported
+    def list_projects() -> str:
+        """The account's saved projects: the id to pass to the other tools,
+        the name, and when it was last saved."""
+        with _client() as client:
+            projects = client.list_projects()
+        if not projects:
+            return "This account has no saved projects yet."
+        return "\n".join(
+            f"{project['id']}  {project.get('name') or 'Untitled'}  "
+            f"(saved {project.get('updatedAt', 'at some point')})"
+            for project in projects
+        )
+
+    @server.tool()
+    @reported
+    def describe_project(project_id: str) -> str:
+        """One project's tables, columns, references and enums, as text.
+
+        The column notes are included: a note holding JSON is a generation hint
+        (`{"min": 5.99, "max": 999.99}`, `{"null_rate": 0.4}`), so it is what
+        decides the values a column comes out with.
+        """
+        with _client() as client:
+            return describe(client.get_project(project_id))
+
+    @server.tool()
+    @reported
+    def preview_data(
+        project_id: str,
+        rows: int | None = None,
+        seed: int | None = None,
+        as_of: str | None = None,
+        locale: str | None = None,
+    ) -> str:
+        """Generate this project's data and return the rows themselves.
+
+        Capped at fifty rows a table so the answer stays readable; every table
+        says how many rows it really has. Use `write_data` for the whole set.
+
+        `rows` overrides the project's row count, `seed` pins the values,
+        `as_of` (YYYY-MM-DD) pins the day dates are placed around, and `locale`
+        overrides the project's. Leave them out and the project's own settings
+        are used, which are the ones the studio previewed.
+        """
+        with _client() as client:
+            saved = client.get_project(project_id)
+            resolved = export.resolve(
+                saved,
+                export.Overrides(rows=rows, seed=seed, as_of=as_of, locale=locale),
+            )
+            archive = client.export("csv", resolved.body)
+        head = (
+            f"{saved.get('name') or 'Untitled'}, seed {resolved.seed}, "
+            f"dates anchored on {resolved.anchor:%Y-%m-%d}"
+        )
+        if resolved.picked_seed:
+            # Said every time, because the alternative is an agent reporting
+            # rows nobody can reproduce -- and the fix is one argument.
+            head += "\n(This project has no saved seed, so one was picked. Pass it back as `seed` "
+            head += "to generate these same rows again.)"
+        return f"{head}\n\n{preview(archive)}"
+
+    @server.tool()
+    @reported
+    def write_data(
+        project_id: str,
+        out_dir: str,
+        export_format: str = "csv",
+        rows: int | None = None,
+        seed: int | None = None,
+        as_of: str | None = None,
+        locale: str | None = None,
+        force: bool = False,
+    ) -> str:
+        """Generate this project's data and write the files into `out_dir`.
+
+        `export_format` is "csv" for seed files or "dbt" for a dbt project.
+        Nothing is written if any target file already exists, unless `force` is
+        true -- half-written fixtures are worse than none.
+        """
+        if export_format not in {"csv", "dbt"}:
+            raise StudioError(f'export_format is "csv" or "dbt", not {export_format!r}.')
+        with _client() as client:
+            saved = client.get_project(project_id)
+            resolved = export.resolve(
+                saved,
+                export.Overrides(rows=rows, seed=seed, as_of=as_of, locale=locale),
+            )
+            archive = client.export(export_format, resolved.body)
+        written = unpack(
+            archive,
+            Path(out_dir),
+            force=force,
+            force_hint="Call this again with force=true to replace them.",
+        )
+        lines = [f"Wrote {len(written)} file{'' if len(written) == 1 else 's'} to {out_dir}:"]
+        lines += [f"  {path}" for path in written]
+        lines.append(f"Seed {resolved.seed}, dates anchored on {resolved.anchor:%Y-%m-%d}.")
+        return "\n".join(lines)
+
+    return server
+
+
+def main() -> None:
+    """The entry point. stdio, which is what an editor's MCP client speaks."""
+    build().run()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

model2data_studio-0.1.0.dist-info/METADATA

@@ -0,0 +1,298 @@
+Metadata-Version: 2.5
+Name: model2data-studio
+Version: 0.1.0
+Summary: Generate a model2data studio project's data from the command line, so CI can rebuild fixtures instead of committing them.
+Project-URL: Homepage, https://www.jbanalytica.com/model2data/
+Project-URL: Studio, https://studio.jbanalytica.com
+Project-URL: Pricing, https://www.jbanalytica.com/model2data/pricing/
+Author: JB Analytica
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dbml,dbt,fixtures,mcp,synthetic data,test data
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: mcp>=2.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.6.0; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=2.0.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# model2data-studio CLI
+
+Pull a saved [model2data studio](https://studio.jbanalytica.com) project and
+write its data, so a build can regenerate its fixtures instead of carrying a CSV
+that was right once.
+
+The schema is designed in the studio, where a diagram and a preview make it
+worth designing. This is the part that runs afterwards, unattended, from the
+same saved project — so the seeds a test suite runs against are the ones the
+model says they should be, rather than whatever was committed the day someone
+last remembered to export.
+
+It is deliberately thin: no DBML parser, no generator, no schema knowledge. The
+studio's API does all of that; this only knows how to ask, and where to put the
+answer.
+
+## Install
+
+```bash
+pip install model2data-studio          # or run it without installing:
+uvx model2data-studio --help
+```
+
+It needs an API key from a **Pro** account on the studio: see
+[pricing](https://www.jbanalytica.com/model2data/pricing/). The client is MIT
+licensed; the studio it talks to is not open source.
+
+## Configuration
+
+Two environment variables, both overridable by a flag:
+
+| | flag | default |
+| --- | --- | --- |
+| `MODEL2DATA_STUDIO_KEY` | `--key` | required |
+| `MODEL2DATA_STUDIO_URL` | `--url` | `https://studio.jbanalytica.com` |
+
+Create a key in the studio's account menu. The CLI sends it as a bearer token
+and nothing else — it never prints it, and it is the only thing that identifies
+the account, so put it in your CI provider's secrets rather than in a file.
+
+Leave the key's access on **Generate and export**, which is the default and
+covers everything below: reading a project, generating, exporting. A key with
+**Read only** access is refused by `generate` with a 403 saying so. The two
+levels above it are for things the CLI does not do — **Generate and save** adds
+writing the project back, for a pipeline that pushes a schema up rather than
+pulling data down, and **Full access** adds deleting a project and managing its
+share links. A key that leaks out of a CI log can only do what it was given.
+
+## Commands
+
+```bash
+model2data-studio projects              # id, name, rows, last edited
+model2data-studio whoami                # the plan behind the key, and what it has used
+
+model2data-studio generate --project <id> --out seeds/
+model2data-studio generate --project <id> --out . --format dbt --adapter duckdb
+```
+
+`generate` takes every setting from the saved project — row counts, per-table
+overrides, seed, locale, name — and each flag overrides one of them:
+
+| | |
+| --- | --- |
+| `--format csv\|dbt` | seed CSVs, or a whole dbt project. dbt export is a Pro feature. |
+| `--rows N` | the default row count for every table |
+| `--rows-for TABLE=N` | one table's count, on top of the project's. Repeatable. |
+| `--seed N` | pin the data. Same seed, same rows, forever. |
+| `--as-of YYYY-MM-DD` | pin the day dates and timestamps are anchored on. Defaults to the project's, then today. |
+| `--locale CODE` | which country's people and addresses to generate |
+| `--business-hours` / `--no-business-hours` | weight timestamps toward weekdays and working hours. Pro. |
+| `--growth N` | relative change in activity across the window, e.g. `0.5` for the end being half again as busy as the start. Pro. |
+| `--seasonality N` | strength of an annual cycle peaking in Q4, `0.0`-`1.0`. Pro. |
+| `--skew N` | how unevenly child rows spread over their parents, `0.0`-`1.0`. Pro. |
+| `--name NAME` | the dbt project's name |
+| `--adapter duckdb\|postgres` | the warehouse the dbt project targets |
+| `--force` | replace files already in `--out` |
+| `--check` | compare against `--out` instead of writing to it |
+
+Every run also prints a row count for each table it generated, read back out
+of the CSVs — a quick way to see what actually landed without opening a seed.
+
+**Shaping flags name one field at a time.** `--growth` on its own overrides
+just the growth trend; business hours and seasonality still come from the
+project, the same way `--rows-for orders=9` overrides one table without
+resetting every other one to the base count. Shaping is a Pro feature — a free
+plan's key gets a 402 naming the plan boundary if the project or a flag asks
+for anything but the uniform defaults.
+
+**Pin a seed.** A project without one generates different rows every run, which
+means a diff on every build and no way back to yesterday's data. If the project
+has no seed and you pass no `--seed`, the CLI picks one and prints it, so a run
+that surprised you can at least be reproduced.
+
+**Pin the day too.** Dates and timestamps are generated relative to an anchor
+day, so a seed alone reproduces its rows only for as long as that day is the
+same. The studio pins one whenever a project's seed is on — **Dates as of**, in
+the generation settings — and the CLI reads it back, which is what makes a run
+here reproduce the rows the studio previewed rather than merely yesterday's CLI
+run. `--as-of` overrides it. A project with no day pinned anchors on today — at
+midnight, so every run on the same day agrees — and the CLI prints the day it
+used, the same way it prints a picked seed. A pipeline that `--check`s
+committed fixtures, or that needs a failing build to be reproducible on a
+laptop next week, wants the day pinned one way or the other; with `--seed`, the
+two together name one dataset for good.
+
+**The project must have been opened in the studio at least once** since the
+studio started saving its parse. The API never parses DBML — the browser does,
+and posts the result — so a project with no stored parse has nothing to generate
+from, and the CLI says so rather than failing later.
+
+**`--check` never writes into `--out`.** It regenerates into a scratch
+directory and diffs it against what is already there, printing what changed,
+what is missing and what is left over, then exits 1 if they differ — so a CI
+job can fail a build whose committed fixtures nobody regenerated after a schema
+change, instead of shipping them stale. Exits 0 and prints `Up to date: N
+files` when they match.
+
+## Regenerating dbt seeds in CI
+
+```yaml
+name: Seeds
+
+on: [push]
+
+jobs:
+  seeds:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Regenerate the seeds from the model
+        env:
+          MODEL2DATA_STUDIO_KEY: ${{ secrets.MODEL2DATA_STUDIO_KEY }}
+        run: |
+          uvx model2data-studio generate \
+            --project ${{ vars.MODEL2DATA_PROJECT_ID }} \
+            --out seeds/ --force --seed 1 --as-of 2026-01-01
+
+      - name: Build against them
+        run: uv run dbt build --target ci
+```
+
+`--force` because the checkout already holds the last run's files, and `--seed`
+with `--as-of` because a pipeline that regenerates its fixtures should still be
+able to explain a failure — with a pinned seed and a pinned day, a failing build
+is reproducible on a laptop, however long after it ran.
+
+Nothing is committed back: the seeds exist for the length of the job, and the
+model in the studio is the thing under version control. If you would rather
+commit them, add a step that opens a pull request when `git status` comes back
+dirty — that turns a schema change into a reviewable diff of the data it
+produces.
+
+## Failing CI when the committed fixtures are stale
+
+If seeds are committed rather than regenerated on every run, `--check` is the
+step that catches someone editing the schema in the studio and forgetting to
+pull the new fixtures into the repo:
+
+```yaml
+      - name: Check the committed seeds match the model
+        env:
+          MODEL2DATA_STUDIO_KEY: ${{ secrets.MODEL2DATA_STUDIO_KEY }}
+        run: |
+          uvx model2data-studio generate \
+            --project ${{ vars.MODEL2DATA_PROJECT_ID }} \
+            --out seeds/ --seed 1 --as-of 2026-01-01 --check
+```
+
+It never writes into `seeds/` — only into a scratch directory it diffs against
+what's there — so this is safe to run against the checkout as-is, no `--force`
+needed. `--as-of` is what lets the check pass on any day: the committed seeds
+were generated relative to one day, and without it a schema with a date column
+would compare against rows anchored on today and fail at the first midnight.
+
+## The MCP server: generating from an agent instead of a shell
+
+The same account, the same key, the same API — for the editor rather than the
+terminal. The studio is where a schema is *designed*, with a diagram and a
+preview to design it against; the agent in your editor is where the data is
+wanted, and asking it for "two hundred believable orders from my webshop model"
+should not mean pasting DBML into a chat.
+
+```bash
+uvx --from 'model2data-studio[mcp]' model2data-studio mcp   # the SDK is an extra, see below
+```
+
+`uvx` fetches it on first use, so there is nothing to install beforehand. With
+the package installed (`pip install 'model2data-studio[mcp]'`),
+`model2data-studio-mcp` starts the same server. For Claude Code:
+
+```bash
+claude mcp add model2data-studio \
+  --env MODEL2DATA_STUDIO_KEY=m2d_... \
+  -- uvx --from 'model2data-studio[mcp]' model2data-studio mcp
+```
+
+and for anything that reads a JSON config (Claude Desktop, Cursor, Zed):
+
+```json
+{
+  "mcpServers": {
+    "model2data-studio": {
+      "command": "uvx",
+      "args": ["--from", "model2data-studio[mcp]", "model2data-studio", "mcp"],
+      "env": { "MODEL2DATA_STUDIO_KEY": "m2d_..." }
+    }
+  }
+}
+```
+
+`MODEL2DATA_STUDIO_URL` works here too, for a self-hosted studio.
+
+Five tools:
+
+| | |
+| --- | --- |
+| `account` | the plan and its caps, worth reading before asking for a lot of rows |
+| `list_projects` | the ids to pass to everything else |
+| `describe_project` | one project's tables, columns, refs and enums as text, generation hints included |
+| `preview_data` | generate and return the rows themselves, capped at fifty a table |
+| `write_data` | generate and write the files, as `generate --out` does |
+
+`preview_data` is the one worth having. An agent that can *read* generated rows
+can act on them — write an assertion against them, notice that `shipped_at`
+precedes `ordered_at`, spot a column coming out as placeholder sentences. It
+answers with the rows inline and says how many there really are; `write_data` is
+for when it has decided and wants the fixtures on disk.
+
+Both go through the same `export.resolve` the CLI's `generate` does, so an agent
+and a pipeline asking for the same project with the same arguments get the same
+rows — including the part where an unpinned project has a seed picked for it and
+is told which one, so the answer can be reproduced afterwards.
+
+The MCP SDK is an optional extra rather than a dependency, on purpose: the
+reason this package is two dependencies is that it installs on CI runners next
+to a build that has nothing to do with the studio, and a runner regenerating
+fixtures does not need an MCP SDK.
+
+## Developing
+
+```bash
+cd cli
+uv sync --extra dev
+uv run pytest
+uv run ruff check .
+```
+
+The tests drive the real Typer app, and the MCP tools through the server's own
+`call_tool`, answering their HTTP with an `httpx.MockTransport` — so there is
+nothing to run and nothing to reach.
+
+## Releasing
+
+Bump `version` in `pyproject.toml`, `__version__` in
+`model2data_studio/__init__.py` and both versions in `server.json` (the release
+workflow refuses a tag that disagrees with any of them), merge, then tag the
+merge commit on `main` and push the tag:
+
+```bash
+git tag cli-v0.1.0 && git push origin cli-v0.1.0
+```
+
+`.github/workflows/release-cli.yml` runs the tests, builds, publishes to PyPI
+through trusted publishing (no token stored anywhere) and then lists the new
+version in the MCP registry.
+
+<!-- mcp-name: io.github.JB-Analytica/model2data-studio -->

model2data_studio-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+model2data_studio/__init__.py,sha256=sA57XNDPOECx_Cabxnmbs-o_RiSf7dv3iZ9PK1-iAA8,618
+model2data_studio/archive.py,sha256=laBoCny0jqLnOyWgJre8damSsVAQPjLq2ldf5qkaf7o,2722
+model2data_studio/cli.py,sha256=g9vPETtPF8fZj0jwR1bnKhHzQvl6ZcarYPP7lbRNFFU,16542
+model2data_studio/client.py,sha256=mEMAaXYLfMlnx4adETbAS6AoztnCsMWkzJWq6qO5sgQ,8152
+model2data_studio/export.py,sha256=uj_TLG5PAIP8BKPN-R9pq65pB7l6MjoeOO68EiC9Ffs,7868
+model2data_studio/mcp_server.py,sha256=accMUJkqZrxIiXBN6_RIAoNN6lMAyFcoZBxyEVFujKE,15110
+model2data_studio-0.1.0.dist-info/METADATA,sha256=bVSmjRpna4nFuEd2bc6Meon1DGXXlk1XrW4U6VSy_zQ,12866
+model2data_studio-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+model2data_studio-0.1.0.dist-info/entry_points.txt,sha256=-hhPQO5h4B5kZ_MsHyctSomr7gI6Rh0Nob-J1ak6NQY,122
+model2data_studio-0.1.0.dist-info/licenses/LICENSE,sha256=ChXR0VUP-pJPFIvcQTtqYQD1jW4ojdqahL5qKCWlW6k,1389
+model2data_studio-0.1.0.dist-info/RECORD,,

model2data_studio-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any