mammoth-cli 2.2.21__tar.gz → 2.2.23__tar.gz

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.21
+Version: 2.2.23
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/mammoth_cli/__init__.py

@@ -6,7 +6,7 @@ not implement a second HTTP client and does not call private SDK members.
 
 from __future__ import annotations
 
-__version__ = "2.2.21"
+__version__ = "2.2.23"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/ai.md

@@ -8,7 +8,7 @@ Run: `mammoth ai condition generate`. Exact input fields: `mammoth schema get ai
 
 Example: `mammoth ai condition generate 123 --input '{"intent": "Summarize revenue by region"}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
 
-Result: `AiConditionGenerateResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
+Result: `AiConditionGenerateResult`; mutation `read`, confirmation `none`, wait policy `not_async`.
 
 Status on release: ran once on CLI 2.0.14 — write sweep 2026-09-18: exit 0 on release with CLI 2.0.14. Generated: lower("region") = 'east' (CD01). First attempt without dataview_id failed with job_failed/CD02 Dataview 4 not found (defaulted to wrong dataview) -- dataview_id must be passed explicitly. S…
 
@@ -18,7 +18,7 @@ Run: `mammoth ai expression generate`. Exact input fields: `mammoth schema get a
 
 Example: `mammoth ai expression generate 123 --input '{"intent": "Summarize revenue by region", "mode": "sample"}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
 
-Result: `AiExpressionGenerateResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
+Result: `AiExpressionGenerateResult`; mutation `read`, confirmation `none`, wait policy `not_async`.
 
 Status on release: ran once on CLI 2.0.15 — re-verification 2026-09-18: exit 2 on release with CLI 2.0.15. Fix held: invalid mode surfaced as invalid_arguments with the SDK message before any request was sent: {"error":{"code":"invalid_arguments","message":"`mode` must be 'math' or 'metric', got 'sampl…
 

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/mammoth_cli/commands/dataset.py

@@ -10,7 +10,7 @@ seam to the public SDK method named by the command's reviewed manifest
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Protocol
 
 from mammoth_cli.errors.envelope import (
     CODE_INVALID_ARGUMENT,
@@ -44,6 +44,13 @@ from mammoth_cli.services.listing import (
 HandlerResult = tuple[Any, dict[str, Any]]
 
 
+_DATASET_GET_SYMBOL = "mammoth.api.datasets.DatasetsAPI.get"
+
+
+class _SdkCaller(Protocol):
+    def call(self, sdk_symbol: str, /, **kwargs: object) -> object: ...
+
+
 def _symbol(invocation: Invocation) -> str:
     """Return the reviewed backing SDK symbol for this command."""
     record = command_by_id(invocation.command_id)
@@ -803,12 +810,16 @@ def dataset_create(invocation: Invocation) -> HandlerResult:
     assert document is not None
     _forward_optional(document, kwargs, ("folder_resource_id",))
     with open_service(invocation) as (service, auth):
+        if invocation.dry_run:
+            _predict_final_name(invocation, service, dataset_spec, project_id)
         data = service.call(_symbol(invocation), **kwargs)
         # ``datasets.create`` returns a bare job handle and never waits. Block on
         # it here (honoring ``--job-timeout``) so the command reports a finished
         # dataset id instead of a job id the caller must poll separately.
         settled = service.wait_if_job(data)
-    return _created_dataset(data, settled), _meta(invocation, auth.workspace_id, project_id)
+        result = _created_dataset(data, settled)
+        _add_final_name(service, result, dataset_spec, project_id)
+    return result, _meta(invocation, auth.workspace_id, project_id)
 
 
 def _created_dataset(handle: Any, settled: Any) -> dict[str, Any]:
@@ -836,6 +847,105 @@ def _created_dataset(handle: Any, settled: Any) -> dict[str, Any]:
     return result
 
 
+#: Pages (of 100) read to predict a final name; past it the answer is "a suffix may be added".
+_NAME_PROBE_PAGES = 20
+
+
+def _requested_name(dataset_spec: object) -> str | None:
+    """The name the caller asked for: ``ds_name`` (clone, cloud) or ``name`` (sketch)."""
+    if not isinstance(dataset_spec, dict):
+        return None
+    for key in ("ds_name", "name"):
+        if isinstance(dataset_spec.get(key), str) and dataset_spec[key]:
+            return str(dataset_spec[key])
+    return None
+
+
+def _project_dataset_names(service: _SdkCaller, project_id: int) -> tuple[set[str], bool]:
+    """Every dataset name in the project and whether all of them were read."""
+    names: set[str] = set()
+    for page in range(_NAME_PROBE_PAGES):
+        data = service.call(
+            "mammoth.api.datasets.DatasetsAPI.list",
+            project_id=project_id,
+            limit=100,
+            offset=page * 100,
+        )
+        rows = data.get("datasets", []) if isinstance(data, dict) else []
+        names.update(r["name"] for r in rows if isinstance(r, dict) and "name" in r)
+        if len(rows) < 100:
+            return names, True
+    return names, False
+
+
+def _name_impact(requested: str, names: set[str], complete: bool) -> dict[str, Any]:
+    """The dry-run prediction for ``requested`` against the project's dataset ``names``."""
+    if requested not in names:
+        free: dict[str, Any] = {"requested_name": requested, "name_taken": False}
+        if complete:
+            return {**free, "final_name": requested}
+        return {**free, "note": "Not all datasets were read; a numeric suffix is added if taken."}
+    impact: dict[str, Any] = {"requested_name": requested, "name_taken": True}
+    if not complete:
+        impact["note"] = f"'{requested}' is taken; a numeric suffix will be added to the name."
+        return impact
+    suffix = next(i for i in range(2, len(names) + 3) if f"{requested} {i}" not in names)
+    impact["final_name"] = f"{requested} {suffix}"
+    impact["note"] = (
+        f"'{requested}' is taken; the dataset will be named '{impact['final_name']}'. "
+        "Ask the user whether to use a different name."
+    )
+    return impact
+
+
+def _predict_final_name(
+    invocation: Invocation, service: _SdkCaller, dataset_spec: object, project_id: int
+) -> None:
+    """Dry run: say whether the requested name is taken and what the server will name it.
+
+    The server (``Datasource.get_unique_name``) tries ``name``, ``name 2``, ``name 3``...
+    against the project's live dataset names, so the answer is computed the same way.
+    """
+    requested = _requested_name(dataset_spec)
+    if requested is not None:
+        names, complete = _project_dataset_names(service, project_id)
+        object.__setattr__(invocation, "predicted_impact", _name_impact(requested, names, complete))
+
+
+def _add_final_name(
+    service: _SdkCaller, result: dict[str, Any], dataset_spec: object, project_id: int
+) -> None:
+    """Add the name the server actually gave the new dataset to a create result.
+
+    The server appends a suffix when the requested name is taken, so the
+    requested name is not the dataset's name. The dataset already exists, so a failed
+    lookup must not fail (and invite a duplicate) create; it is reported in ``note``.
+    """
+    dataset_id = result.get("dataset_id")
+    if dataset_id is None:
+        return
+    try:
+        record = service.call(
+            _DATASET_GET_SYMBOL, dataset_id=dataset_id, project_id=project_id, fields="id,name"
+        )
+    except CliError as exc:  # the service maps every SDK API/HTTP error to CliError
+        result["note"] = (
+            f"Created dataset {dataset_id}; its final name could not be read back "
+            f"({exc.code}). Run dataset get {dataset_id}."
+        )
+        return
+    if not isinstance(record, dict):
+        return
+    name = record.get("dataset", record).get("name")
+    if not isinstance(name, str):
+        return
+    result["name"] = name
+    requested = _requested_name(dataset_spec)
+    if requested is not None and requested != name:
+        result["requested_name"] = requested
+        result["note"] = f"The name '{requested}' was taken, so the dataset is named '{name}'."
+
+
 def dataset_create_from_pdf(invocation: Invocation) -> HandlerResult:
     """Create dataset(s) from tables extracted out of a PDF file."""
     project_id = require_project(invocation)

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/mammoth_cli/commands/project.py

@@ -580,9 +580,9 @@ def _report_line(where: str, warning: dict[str, Any]) -> str:
     return f"{subject}: {warning.get('issue')}. {warning.get('detail', '')}".strip()
 
 
-def _scoped_dataset_id(invocation: Invocation) -> int | None:
-    """The DATASET_ID that narrows ``project check`` to one dataset, or None."""
-    raw = invocation.positional("dataset_id")
+def _scoped_id(invocation: Invocation, name: str) -> int | None:
+    """The integer positional ``name`` (``dataset_id``, ``view_id``), or None if omitted."""
+    raw = invocation.positional(name)
     if raw is None:
         return None
     try:
@@ -590,11 +590,28 @@ def _scoped_dataset_id(invocation: Invocation) -> int | None:
     except ValueError as exc:
         raise CliError(
             code=CODE_INVALID_ARGUMENT,
-            message=f"The dataset id argument '{raw}' is not an integer.",
+            message=f"The {name.replace('_', ' ')} argument '{raw}' is not an integer.",
             exit_status=EXIT_USAGE,
         ) from exc
 
 
+def _scoped_dataset_id(invocation: Invocation) -> int | None:
+    """The DATASET_ID that narrows ``project check`` to one dataset, or None."""
+    return _scoped_id(invocation, "dataset_id")
+
+
+def _scoped_view_id(invocation: Invocation, dataset_id: int | None) -> int | None:
+    """The VIEW_ID that picks which view of DATASET_ID ``project check`` reads, or None."""
+    view_id = _scoped_id(invocation, "view_id")
+    if view_id is not None and dataset_id is None:
+        raise CliError(
+            code=CODE_INVALID_ARGUMENT,
+            message="A view id needs its dataset: project check PROJECT_ID DATASET_ID VIEW_ID.",
+            exit_status=EXIT_USAGE,
+        )
+    return view_id
+
+
 def _datasets_to_check(service: Any, project_id: int, scoped: int | None) -> list[Any]:
     """Every dataset of the project, or only the named one -- never a walk when scoped."""
     if scoped is not None:
@@ -647,14 +664,16 @@ def _map_checks[T](
         )
 
 
-def _preview_dataset(service: Any, _auth: Any, args: tuple[Any, int | None]) -> dict[str, Any]:
+def _preview_dataset(
+    service: Any, _auth: Any, args: tuple[Any, int | None, int | None]
+) -> dict[str, Any]:
     from mammoth_cli.commands.view import upload_preview
 
-    dataset, project_id = args
+    dataset, project_id, view_id = args
     dataset_id = dataset.get("id") if isinstance(dataset, dict) else None
     if not isinstance(dataset_id, int):
         return {"preview_error": "dataset entry has no integer id"}
-    return upload_preview(service, dataset_id, project_id)
+    return upload_preview(service, dataset_id, project_id, view_id)
 
 
 def _check_dashboard(invocation: Invocation) -> Callable[[Any, Any, Any], dict[str, Any]]:
@@ -678,6 +697,7 @@ def _dataset_entry(dataset: dict[str, Any], preview: dict[str, Any]) -> dict[str
         "dataset_id": dataset.get("id"),
         "dataset_name": dataset.get("name"),
         "view_id": preview["view_id"],
+        "view_name": preview.get("view_name"),
         "row_count": preview.get("row_count"),
         "column_warnings": preview.get("column_warnings", []),
         "column_checks": preview["column_checks"],
@@ -711,6 +731,7 @@ def _dataset_status(dataset: dict[str, Any], preview: dict[str, Any]) -> dict[st
     return {
         **row,
         "view_id": preview["view_id"],
+        "view_name": preview.get("view_name"),
         "freshness": preview.get("freshness", {"state": "unknown"}),
         "data_quality": {
             "warnings": len(preview.get("column_warnings", [])),
@@ -745,7 +766,9 @@ def project_check(invocation: Invocation) -> HandlerResult:
     one line per finding; ``resources`` has one status row per dataset and
     dashboard (freshness apart from data quality, or the error that stopped
     its check). Resources are checked several at once. Given a DATASET_ID it
-    reads only that dataset's first view (no dataset list, no dashboards).
+    reads only that dataset's first view (no dataset list, no dashboards);
+    given VIEW_ID as well it reads that view instead. Every status row names
+    the ``view_id`` and ``view_name`` it checked.
     Cold-agent evals (2.0.41) left one column's blanks undecided in every
     run, because the warning sat in an earlier result.
     """
@@ -758,6 +781,7 @@ def project_check(invocation: Invocation) -> HandlerResult:
     skipped: list[dict[str, Any]] = []
     statuses: list[dict[str, Any]] = []
     scoped_dataset = _scoped_dataset_id(invocation)
+    scoped_view = _scoped_view_id(invocation, scoped_dataset)
     with open_service(invocation) as (service, auth):
         every_dataset = _datasets_to_check(service, project_id, scoped_dataset)
         datasets = every_dataset[:_CHECK_MAX_DATASETS]
@@ -773,7 +797,7 @@ def project_check(invocation: Invocation) -> HandlerResult:
             invocation,
             service,
             auth,
-            [(dataset, project_id) for dataset in datasets],
+            [(dataset, project_id, scoped_view) for dataset in datasets],
             _preview_dataset,
         )
         for dataset, preview in zip(datasets, previews, strict=True):
@@ -788,13 +812,14 @@ def project_check(invocation: Invocation) -> HandlerResult:
                 )
                 continue
             entry = _dataset_entry(dataset, preview)
-            if "other_views" in preview:
+            if "other_views" in preview and scoped_view is None:
                 to_report.append(_other_views_line(dataset, preview))
             views.append(entry)
             checked.append(
                 {
                     "dataset_id": dataset["id"],
                     "view_id": preview["view_id"],
+                    "view_name": preview.get("view_name"),
                     "rows_checked": preview["column_checks"]["rows_checked"],
                 }
             )
@@ -834,7 +859,13 @@ def project_check(invocation: Invocation) -> HandlerResult:
         "checked": checked,
         "skipped": skipped,
         **(
-            {"scope": {"dataset_id": scoped_dataset, "dashboards": "not checked"}}
+            {
+                "scope": {
+                    "dataset_id": scoped_dataset,
+                    **({"view_id": scoped_view} if scoped_view else {}),
+                    "dashboards": "not checked",
+                }
+            }
             if scoped_dataset
             else {}
         ),

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/mammoth_cli/commands/view.py

@@ -4096,8 +4096,17 @@ _DATAVIEW_LIST_SYMBOL = "mammoth.api.dataviews.DataviewsAPI.list"
 _UPLOAD_SAMPLE_ROWS = 3
 
 
-def upload_preview(service: Any, dataset_id: int, project_id: int | None) -> dict[str, Any]:
-    """The first view of a new dataset: columns, types, sample rows, warnings.
+def _select_view(views: list[Any], view_id: int | None) -> dict[str, Any] | None:
+    """The view with ``view_id``, or the first (most recent) one when none is named."""
+    if view_id is None:
+        return views[0]
+    return next((v for v in views if isinstance(v, dict) and v.get("id") == view_id), None)
+
+
+def upload_preview(
+    service: Any, dataset_id: int, project_id: int | None, view_id: int | None = None
+) -> dict[str, Any]:
+    """A view of a dataset (the first unless ``view_id``): columns, types, sample rows, warnings.
 
     ``before_dashboard`` names the columns to add before any dashboard is
     made (revenue from a unit price and a quantity), since a dashboard does
@@ -4116,16 +4125,19 @@ def upload_preview(service: Any, dataset_id: int, project_id: int | None) -> dic
         views = listing.get("dataviews") if isinstance(listing, dict) else None
         if not isinstance(views, list) or not views or not isinstance(views[0], dict):
             return {"preview_error": f"dataset {dataset_id} has no view to preview"}
+        chosen = _select_view(views, view_id)
+        if chosen is None:
+            return {"preview_error": f"dataset {dataset_id} has no view {view_id}"}
         # A dataset with more than one live view has one previewed here; the
         # rest are named (id + name) so a caller (``project.check``) can say
         # a view besides the one checked exists, rather than silently acting
         # on the single view this function happens to preview.
         other_views = [
             {"id": other.get("id"), "name": other.get("name")}
-            for other in views[1:]
-            if isinstance(other, dict) and isinstance(other.get("id"), int)
+            for other in views
+            if other is not chosen and isinstance(other, dict) and isinstance(other.get("id"), int)
         ]
-        record = apply_column_renames(views[0])
+        record = apply_column_renames(chosen)
         view_id = record.get("id")
         if not isinstance(view_id, int):
             return {"preview_error": f"dataset {dataset_id}'s first view has no id"}
@@ -4150,6 +4162,7 @@ def upload_preview(service: Any, dataset_id: int, project_id: int | None) -> dic
     checks, warnings = _check_columns(rows, types, view_id, dataset_id)
     preview: dict[str, Any] = {
         "view_id": view_id,
+        "view_name": record.get("name"),
         "row_count": record.get("row_count"),
         "columns": types,
         "sample_rows": rows[:_UPLOAD_SAMPLE_ROWS],

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/mammoth_cli/commands/view_ops.py

@@ -61,6 +61,7 @@ from mammoth_cli.runtime.session import open_service, resolved_project
 from mammoth_cli.services.command_contract import bind_command_inputs
 from mammoth_cli.services.conditions import CONDITION_KWARG
 from mammoth_cli.services.input_fields import TASK_COUNT_FIELD
+from mammoth_cli.services.sql_check import check_sql_binds
 from mammoth_cli.services.write_impact import (
     ImpactRead,
     Measure,
@@ -923,7 +924,30 @@ def view_transform_add_sql(invocation: Invocation) -> HandlerResult:
     _require_field(document, "query")
     assert document is not None
     kwargs = _bind_transform_inputs(invocation, document)
-    return _dispatch_view(invocation, view_id, "add_sql", **kwargs)
+    return _dispatch_view(
+        invocation, view_id, "add_sql", prepare=_sql_binding_check(invocation, view_id), **kwargs
+    )
+
+
+def _sql_binding_check(
+    invocation: Invocation, view_id: int
+) -> Callable[[Any, int, dict[str, Any]], Any]:
+    """A ``prepare`` hook: a dry run fails with ``would_fail`` when the SQL names a column
+    the step cannot bind (see :mod:`mammoth_cli.services.sql_check`). A real run is unchanged."""
+
+    def check(service: Any, dataset_id: int, kwargs: dict[str, Any]) -> Any:
+        if invocation.dry_run:
+            view = service.call(
+                _DATAVIEW_GET_SYMBOL,
+                dataset_id=dataset_id,
+                dataview_id=view_id,
+                project_id=resolved_project(invocation),
+            )
+            if isinstance(view, dict):
+                check_sql_binds(str(kwargs.get("query", "")), view)
+        return None
+
+    return check
 
 
 def view_transform_ai(invocation: Invocation) -> HandlerResult:

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/mammoth_cli/errors/envelope.py

@@ -56,6 +56,7 @@ CODE_JOB_FAILED = "job_failed"
 CODE_INTERRUPTED = "interrupted"
 CODE_UNSUPPORTED_CONTRACT = "unsupported_contract"
 CODE_NO_OP = "no_op"
+CODE_WOULD_FAIL = "would_fail"
 
 # User-safe, one-line summaries shown to the customer instead of the model-facing
 # ``message``/``hint``. Plain language only: no command names, ids, field names
@@ -173,6 +174,7 @@ ERROR_SUMMARIES: dict[str, str] = {
     "upgrade_failed": "The update didn't complete.",
     "usage_error": _S_BAD_REQUEST,
     "view_in_draft": "This view is still a draft and can't be used yet.",
+    "would_fail": "This step would fail when it runs, so it was not added.",
 }
 
 #: Shown for a code with no entry (a runtime backstop only; the exhaustiveness

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/mammoth_cli/services/positionals.py

@@ -395,14 +395,22 @@ POSITIONAL_OVERRIDES: dict[str, tuple[PositionalSpec, ...]] = {
     # active project). The SDK signature marks it required or omits it, so the
     # dual-sourced optional locator is authored here.
     "project.get": _optional_project_id(),
-    # ``project check PROJECT_ID DATASET_ID`` narrows the check to one dataset.
+    # ``project check PROJECT_ID DATASET_ID [VIEW_ID]`` narrows the check to one dataset,
+    # and to one of its views (its first, most recent one when VIEW_ID is omitted).
     "project.check": (
         *_optional_project_id(),
         PositionalSpec(
             name="dataset_id",
             type=int,
             required=False,
-            help="Check only this dataset's first view; no other dataset or dashboard is read.",
+            help="Check only this dataset (its first view unless VIEW_ID is given); "
+            "no other dataset or dashboard is read.",
+        ),
+        PositionalSpec(
+            name="view_id",
+            type=int,
+            required=False,
+            help="Check this view of DATASET_ID instead of its first (most recent) one.",
         ),
     ),
     "project.needs-attention": _optional_project_id(),

mammoth_cli-2.2.23/mammoth_cli/services/sql_check.py

@@ -0,0 +1,87 @@
+"""Check a SQL step's column names against what it will bind to, before it is added.
+
+``FROM "view:<id>"`` binds to the names the pipeline produced (the ``metadata`` of the
+view's latest data), not to a display-only rename (``display_properties.COLUMN_NAMES``),
+which ``view get`` shows. A query naming the renamed column is accepted by the CLI and
+fails in the backend's DuckDB with a Binder Error, so a dry run says so first.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+
+from mammoth_cli.errors.envelope import CODE_WOULD_FAIL, EXIT_USAGE, CliError
+
+_STRING = re.compile(r"'(?:[^']|'')*'")
+_QUOTED = re.compile(r'"((?:[^"]|"")+)"')
+_ALIAS = re.compile(r'\bAS\s+("(?:[^"]|"")+"|\w+)|("(?:[^"]|"")+"|\w+)\s+AS\s*\(', re.IGNORECASE)
+_TABLE = re.compile(r'\b(?:FROM|JOIN)\s+("(?:[^"]|"")+")', re.IGNORECASE)
+_VIEW_REF = re.compile(r"view:\d+")
+
+
+def _unquote(name: str) -> str:
+    return name[1:-1].replace('""', '"') if name.startswith('"') else name
+
+
+def _declared(query: str) -> set[str]:
+    """Names the query itself introduces (aliases, CTEs) or reads as a table."""
+    aliases = {_unquote(a or b) for a, b in _ALIAS.findall(query)}
+    tables = {_unquote(t) for t in _TABLE.findall(query)}
+    return {name.casefold() for name in aliases | tables}
+
+
+def _identifiers(query: str, renamed: Mapping[str, str]) -> list[str]:
+    """Quoted identifiers, plus any bare word that is a renamed column's new name."""
+    found = [m for m in _QUOTED.findall(query) if not _VIEW_REF.fullmatch(m)]
+    words = {w.casefold() for w in re.findall(r"\w+", _QUOTED.sub(" ", query))}
+    found += [new for new in renamed if new.casefold() in words]
+    return list(dict.fromkeys(name.replace('""', '"') for name in found))
+
+
+def _renames(view: Mapping[str, object]) -> dict[str, str]:
+    """``{new name: pipeline name}`` for each display-only rename of the view."""
+    display = view.get("display_properties")
+    names = display.get("COLUMN_NAMES") if isinstance(display, dict) else None
+    metadata = view.get("metadata")
+    if not isinstance(names, dict) or not isinstance(metadata, list):
+        return {}
+    by_internal = {c.get("internal_name"): c.get("display_name") for c in metadata}
+    return {new: by_internal[i] for i, new in names.items() if by_internal.get(i)}
+
+
+def check_sql_binds(query: str, view: Mapping[str, object]) -> None:
+    """Raise ``would_fail`` when ``query`` names a column the step cannot bind.
+
+    Args:
+        query: The step's SQL.
+        view: The raw ``dataview get`` record (its ``metadata`` is the bindable schema).
+
+    Raises:
+        CliError: ``would_fail``, with the unknown name and the candidate columns.
+    """
+    metadata = view.get("metadata")
+    rows = metadata if isinstance(metadata, list) else []
+    columns = [
+        str(c["display_name"]) for c in rows if isinstance(c, dict) and c.get("display_name")
+    ]
+    if not columns:
+        return
+    renamed = _renames(view)
+    text = _STRING.sub("''", query)
+    known = {c.casefold() for c in columns} | _declared(text)
+    for name in _identifiers(text, renamed):
+        if name.casefold() not in known:
+            raise _unbound(name, columns, renamed.get(name))
+
+
+def _unbound(name: str, columns: list[str], was: str | None) -> CliError:
+    hint = f'Use "{was}": "{name}" is only a display name for it.' if was else None
+    return CliError(
+        code=CODE_WOULD_FAIL,
+        message=f'Referenced column "{name}" not found. Candidate bindings: '
+        + ", ".join(f'"{c}"' for c in columns),
+        exit_status=EXIT_USAGE,
+        hint=hint or "Use one of the candidate columns; nothing was added.",
+        details={"unknown_column": name, "candidate_columns": columns},
+    )

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mammoth-cli"
-version = "2.2.21"
+version = "2.2.23"
 description = "Command-line interface for the Mammoth Analytics platform"
 authors = [{name = "Mammoth Analytics", email = "support@mammoth.io"}]
 readme = "README.md"

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/spec/manifests/commands/ai.yaml

@@ -18,12 +18,11 @@ commands:
   sdk_conversion: Call mammoth.api.ai.AIAPI.condition_generate with validated request fields.
   request_model: AiConditionGenerateRequest
   result_model: AiConditionGenerateResult
-  mutation_class: benign_mutation
-  edits_target: false
+  mutation_class: read
   confirmation: none
   wait_policy: not_async
   pagination_policy: none
-  acceptance_evidence: live_disposable_project
+  acceptance_evidence: live_read_only
   live_test: LT-AI-CONDITION-GENERATE
   live_exemption_reason: null
   contract_fixture: null
@@ -41,7 +40,6 @@ commands:
   undo_test: null
   known_restrictions: null
   reviewed_by: primary
-  no_readback: "generates a condition preview; nothing is persisted to read back"
 - command_id: ai.expression.generate
   command_path: ai expression generate
   disposition: command
@@ -60,12 +58,11 @@ commands:
   sdk_conversion: Call mammoth.api.ai.AIAPI.expression_generate with validated request fields.
   request_model: AiExpressionGenerateRequest
   result_model: AiExpressionGenerateResult
-  mutation_class: benign_mutation
-  edits_target: false
+  mutation_class: read
   confirmation: none
   wait_policy: not_async
   pagination_policy: none
-  acceptance_evidence: live_disposable_project
+  acceptance_evidence: live_read_only
   live_test: LT-AI-EXPRESSION-GENERATE
   live_exemption_reason: null
   contract_fixture: null
@@ -84,7 +81,6 @@ commands:
   undo_test: null
   known_restrictions: null
   reviewed_by: primary
-  no_readback: "generates an expression preview; nothing is persisted to read back"
 - command_id: ai.retention.condition
   command_path: ai retention condition
   disposition: command

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/spec/manifests/commands/dataset.yaml

@@ -252,6 +252,8 @@ commands:
     dataset/view IDs and delete only IDs created by this task. A weburl dataset is a one-time copy that
     keeps no source details to refresh from, so automation's run_data_retrieval task cannot refresh it
     (only a cloud-connected dataset can be refreshed); say so rather than scheduling a refresh for it.
+    The result's name is the dataset's real name; when the requested name was taken the server adds a suffix,
+    and requested_name and note say so. Use name, not the name you asked for.
   reviewed_by: primary
 - command_id: dataset.create-from-pdf
   command_path: dataset create-from-pdf

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/spec/manifests/commands/project.yaml

@@ -98,7 +98,13 @@ commands:
     required: false
     metavar: DATASET_ID
     falls_back_to_field: null
-    help: Check only this dataset's first view; no other dataset or dashboard is read.
+    help: Check only this dataset (its first view unless VIEW_ID is given); no other dataset or dashboard is read.
+  - name: view_id
+    type: int
+    required: false
+    metavar: VIEW_ID
+    falls_back_to_field: null
+    help: Check this view of DATASET_ID instead of its first (most recent) one.
   options: []
   sdk_symbol: mammoth_cli.commands.project.project_check
   sdk_conversion: Call mammoth_cli.commands.project.project_check with validated request fields.
@@ -124,7 +130,7 @@ commands:
   - CT-PROJECT-CHECK-ERROR
   draft_test: null
   undo_test: null
-  known_restrictions: Reads the first view of each dataset (the one uploads and the playbooks use) and one data page per view, six resources at a time. `resources` has one status row per dataset and dashboard with its freshness (in_sync, out_of_sync or running, with data_updated_at) kept apart from its data quality (warning count), or the error that stopped its check. Given DATASET_ID it reads only that dataset's first view and skips the dashboards.
+  known_restrictions: Reads the first view of each dataset (the one uploads and the playbooks use) and one data page per view, six resources at a time. `resources` has one status row per dataset and dashboard with its freshness (in_sync, out_of_sync or running, with data_updated_at) kept apart from its data quality (warning count), or the error that stopped its check. Given DATASET_ID it reads only that dataset's first view and skips the dashboards; also given VIEW_ID it reads that view instead. Every status row names the view_id and view_name it checked, so compare it with the view the work was on.
   reviewed_by: primary
 - command_id: project.checkpoint.list
   command_path: project checkpoint list

{mammoth_cli-2.2.21 → mammoth_cli-2.2.23}/spec/manifests/sdk-catalog.source.yaml

@@ -421,14 +421,14 @@ sdk_methods:
 - sdk_symbol: mammoth.api.ai.AIAPI.condition_generate
   canonical_command: ai.condition.generate
   alias_of: null
-  mutation_class: null
+  mutation_class: read
   wait_policy: null
   pagination_policy: null
   openapi_operation_ids: []
 - sdk_symbol: mammoth.api.ai.AIAPI.expression_generate
   canonical_command: ai.expression.generate
   alias_of: null
-  mutation_class: null
+  mutation_class: read
   wait_policy: null
   pagination_policy: null
   openapi_operation_ids: []