mammoth-cli 2.2.91__tar.gz → 2.2.93__tar.gz

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.91
+Version: 2.2.93
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -18,7 +18,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.12
 Requires-Dist: jsonschema>=4.20
 Requires-Dist: keyring<26,>=25.7
-Requires-Dist: mammoth-io<0.9,>=0.8.45
+Requires-Dist: mammoth-io<0.9,>=0.8.46
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/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.91"
+__version__ = "2.2.93"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/app.py

@@ -428,6 +428,29 @@ def _global_option_flags() -> tuple[frozenset[str], frozenset[str]]:
     return frozenset(every), frozenset(valued)
 
 
+def missing_argument_hint(tokens: Sequence[str]) -> str:
+    """The command's usage line and runnable example, for a ``missing_argument`` error.
+
+    The command is the longest run of leading words that names one; with none, the
+    generic pointer to the schema.
+    """
+    generic = "Check the command schema with 'mammoth schema get'."
+    path_to_command, _ = _command_tree()
+    words = [token for token in tokens if not token.startswith("-")]
+    for length in range(len(words), 0, -1):
+        command_id = path_to_command.get(tuple(words[:length]))
+        if command_id is None:
+            continue
+        slots = " ".join(
+            spec.metavar if spec.required else f"[{spec.metavar}]"
+            for spec in resolve_positionals(command_id)
+        )
+        usage = " ".join(part for part in ("mammoth", *words[:length], slots) if part)
+        example = (command_by_id(command_id) or {}).get("agent_example")
+        return f"Usage: {usage}." + (f" Example: {example}" if example else "")
+    return generic
+
+
 def _corrected_command(tokens: Sequence[str]) -> str | None:
     """Rebuild an invocation with leading global options moved after the command.
 
@@ -747,7 +770,7 @@ class _EnvelopeGroup(TyperGroup):
                         code="missing_argument",
                         message=error_message,
                         exit_status=EXIT_USAGE,
-                        hint="Check the command schema with 'mammoth schema get'.",
+                        hint=missing_argument_hint(tokens),
                     )
                 elif isinstance(error, _typer_click_exceptions.NoSuchOption):
                     option = getattr(error, "option_name", None) or "unknown"
@@ -779,6 +802,8 @@ class _EnvelopeGroup(TyperGroup):
             executor.emit_error(report, machine=True)
         elif report is None:
             error.show()
+            if is_missing_parameter:
+                typer.echo(missing_argument_hint(tokens), err=True)
         else:
             # A no-subcommand error arrives with the help text already on
             # screen, so repeating "run --help" below it would be noise.

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: mammoth-cli
-version: 2.2.91
+version: 2.2.93
 description: "Use Mammoth Analytics from a terminal: install or authenticate the CLI, discover its live command contract, and safely manage projects, data, views, pipelines (join, merge, pivot, filter, clean), dashboards, exports, and handoffs."
 ---
 

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/references/capabilities.md

@@ -1,7 +1,7 @@
 # What is proven on release
 
 Generated from `docs/release-capability-matrix.json`; do not edit by hand.
-The CLI publishes 782 commands. 516 of them bind one of the 545 API operations in the matrix; the remainder are local commands (`schema`, `auth`, `doctor`, `log`, ...) or typed variants that share an operation (`view transform *` commands submit through `view.task.add`, except `rename-columns` and `sort`, which set view display properties through `view.update`). 262 bound commands ran once successfully on release, 1 are not supported there, and the rest are untried. Untried is not broken: discover the contract with `mammoth schema get COMMAND_ID`, run it, and treat the structured error envelope as the answer. Use an untried command normally: confirm a write with the user first, check its result with a read afterwards, and never refuse a command only because it is untried.
+The CLI publishes 785 commands. 516 of them bind one of the 545 API operations in the matrix; the remainder are local commands (`schema`, `auth`, `doctor`, `log`, ...) or typed variants that share an operation (`view transform *` commands submit through `view.task.add`, except `rename-columns` and `sort`, which set view display properties through `view.update`). 262 bound commands ran once successfully on release, 1 are not supported there, and the rest are untried. Untried is not broken: discover the contract with `mammoth schema get COMMAND_ID`, run it, and treat the structured error envelope as the answer. Use an untried command normally: confirm a write with the user first, check its result with a read afterwards, and never refuse a command only because it is untried.
 
 Status meanings:
 

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/references/command-index.md

@@ -1,6 +1,6 @@
 # Published CLI command catalog
 
-This generated catalog is a lookup table for every command in the published CLI manifest, currently 782; each entry carries its release status line. It is a command-contract index, not an assertion that every backend/OpenAPI operation has a CLI binding. For an exact local CLI contract, run `mammoth schema get COMMAND_ID`; `mammoth capability list` is an API-binding inventory and can omit typed/local CLI routes. For focused workflows, read the [recipes index](recipes/index.md). Sensitive structured input must come from a private file or pipe; never put secrets in literal argv.
+This generated catalog is a lookup table for every command in the published CLI manifest, currently 785; each entry carries its release status line. It is a command-contract index, not an assertion that every backend/OpenAPI operation has a CLI binding. For an exact local CLI contract, run `mammoth schema get COMMAND_ID`; `mammoth capability list` is an API-binding inventory and can omit typed/local CLI routes. For focused workflows, read the [recipes index](recipes/index.md). Sensitive structured input must come from a private file or pipe; never put secrets in literal argv.
 
 Load only the applicable domain file:
 
@@ -56,7 +56,7 @@ Load only the applicable domain file:
 - [user](commands/user.md) — 8 published commands
 - [version](commands/version.md) — 1 published commands
 - [view-transform](commands/view-transform.md) — 35 published commands
-- [view](commands/view.md) — 106 published commands
+- [view](commands/view.md) — 109 published commands
 - [webhook](commands/webhook.md) — 7 published commands
 - [workflow](commands/workflow.md) — 23 published commands
 - [workspace](commands/workspace.md) — 33 published commands

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view.md

@@ -122,6 +122,16 @@ Result: `ViewCheckpointUpdateResult`; mutation `benign_mutation`, confirmation `
 
 Status on release: ran once on CLI 2.0.18 — fixture-lifecycle sweep 2026-09-19: exit 0 on release with CLI 2.0.18. First attempt sending a full AddCheckpointSpec body (matching create's shape) failed with invalid_input_field_type; update actually needs body.patches[] (CheckpointPatches/CheckPointPatch…
 
+### `view.column.format.set`
+
+Run: `mammoth view column format set`. Exact input fields: `mammoth schema get view.column.format.set`.
+
+Example: `mammoth view column format set 123 --input '{"formats": {"Admitted": {"date_format": "%d-%b-%Y"}, "Revenue": {"decimal_spec": 2}}, "dataset_id": 456}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `ViewColumnFormatSetResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `view.compare`
 
 Run: `mammoth view compare`. Exact input fields: `mammoth schema get view.compare`.
@@ -162,6 +172,16 @@ Result: `ViewConditionalFormatListResult`; mutation `read`, confirmation `none`,
 
 Status on release: ran once on CLI 2.0.17 — re-verification 2026-09-18 (2.0.16 fixes): exit 0 on release with CLI 2.0.17. With SDK 0.7.9 the one existing rule is returned as [{rule_id, cf_type, FORMAT, CONDITION, ...}]; with SDK 0.7.8 the same call returned [] (mapping keyed by rule id was discarded).…
 
+### `view.conditional-format.replace`
+
+Run: `mammoth view conditional-format replace`. Exact input fields: `mammoth schema get view.conditional-format.replace`.
+
+Example: `mammoth view conditional-format replace 123 456 --input '{"columns": ["Q1", "Q2", "Q3"], "operator": "<", "value": 55, "color": "red"}' --yes`. Illustrative only: append `--yes` after observing an owned target.
+
+Result: `ViewConditionalFormatReplaceResult`; mutation `destructive`, confirmation `prompt_or_yes`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `view.conditional-format.update`
 
 Run: `mammoth view conditional-format update`. Exact input fields: `mammoth schema get view.conditional-format.update`.
@@ -546,6 +566,16 @@ Result: `ViewExportDeleteResult`; mutation `external_effect`, confirmation `yes_
 
 Status on release: ran once on CLI 2.0.14 — write sweep 2026-09-18: exit 0 on release with CLI 2.0.14. Deleted export 2 -> {future_id:null,status:deleted,trigger_id:2}. Single invocation only.
 
+### `view.export.download`
+
+Run: `mammoth view export download`. Exact input fields: `mammoth schema get view.export.download`.
+
+Example: `mammoth view export download 123`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `ViewExportDownloadResult`; mutation `benign_mutation`, confirmation `none`, wait policy `always_wait`.
+
+Status on release: untried; no live run recorded.
+
 ### `view.export.elasticsearch`
 
 Run: `mammoth view export elasticsearch`. Exact input fields: `mammoth schema get view.export.elasticsearch`.

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/references/operations.md

@@ -98,8 +98,10 @@ When several transforms go on the same view in a row (for example filter, sort,
 limit-rows), send them in one `view transform batch VIEW_ID --input '{"steps": [{"op":
 "filter", "input": {...}}, ...]}'` instead of one command each: the pipeline runs once and
 one verified outcome comes back (`row_check`, and `tasks` with each new task's status).
-Each `input` is what that `view transform` command takes. A step cannot use a column an
-earlier step of the batch creates: run those steps first. If a task fails, the batch's tasks
+Each `input` is what that `view transform` command takes. A step can use the columns an
+earlier step adds (`split`, `copy-columns`, or the `new_column` of `substring`, `extract-date`,
+`increment-date`). `split`, `unnest` and `pivot` can be
+batch steps too; `unnest` and `pivot` replace the view's columns, so they go last (and no `sort` step before them). If a task fails, the batch's tasks
 are removed and the error names `steps[i]`.
 
 Prefer a typed `view transform <operation>` command. Its schema is the

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/transforms.md

@@ -86,6 +86,14 @@ A TEXT column that writes numbers with a decimal comma (`1.234,5`) converts with
 defaults to the other mark). `view data profile` lists such a column under
 `summary.mixed_number_format` when its values mix notations.
 
+A TEXT column of dates converts with `"to":"DATE"` and, on the same `conversions` entry,
+`"input_formats":["DD/MM/YYYY","YYYY-MM-DD"]` (every layout the column mixes),
+`"output_format":"DD-Mon-YYYY"` (how it displays) and
+`"input_format_preference":"uk"` or `"us"` (which way `03/04/2024` reads). Formats are
+Postgres date patterns.
+`view column format set` changes only how a DATE or number column
+shows, never its values.
+
 In a math `expression`, write a multi-word display name bare (`Quantity * Unit
 Price`) or quoted (`Quantity * \"Unit Price\"` inside the JSON string).
 

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/commands/browse.py

@@ -17,6 +17,7 @@ from mammoth_cli.errors.envelope import (
     CODE_INVALID_ARGUMENT,
     CODE_MISSING_ARGUMENT,
     CODE_MISSING_FIELD,
+    CODE_RESOURCE_NOT_FOUND,
     CODE_SDK_SYMBOL_UNRESOLVED,
     EXIT_USAGE,
     CliError,
@@ -28,6 +29,31 @@ from mammoth_cli.services.folder_ids import FolderIds
 
 HandlerResult = tuple[Any, dict[str, Any]]
 
+#: The route's resource types are datasource, dataview, label, file_object, report and webhook;
+#: these are the names a caller reaches for instead.
+_RESOURCE_TYPE_ALIASES = {"dataset": "datasource", "folder": "label"}
+
+
+def canonical_resource_type(value: str) -> str:
+    """``value`` (one type, or several joined by commas) with each alias as the route's name."""
+    return ",".join(
+        _RESOURCE_TYPE_ALIASES.get(part.strip(), part.strip()) for part in value.split(",")
+    )
+
+
+def ancestors_needs_a_folder(error: CliError) -> CliError:
+    """``error`` (the 404 for an id that is no folder) as a message saying what to pass."""
+    return CliError(
+        code=error.code,
+        message="browse ancestors needs a FOLDER id; this id is not a folder.",
+        exit_status=error.exit_status,
+        hint=(
+            "A dataset or view has no ancestors of its own: run `mammoth browse resource "
+            "dataset ID` (or `dataview ID`) and pass the parent_resource_id it returns."
+        ),
+        details=error.details,
+    )
+
 
 def _symbol(invocation: Invocation) -> str:
     """Return the reviewed backing SDK symbol for this command."""
@@ -213,7 +239,8 @@ def browse_resource(invocation: Invocation) -> HandlerResult:
         )
     with open_service(invocation) as (service, auth):
         folders = FolderIds(service)
-        if str(resource_type) == "label":
+        resource_type = canonical_resource_type(str(resource_type))
+        if resource_type == "label":
             object_id = folders.label(project_id, int(object_id))
         data = service.call(
             _symbol(invocation),
@@ -230,7 +257,14 @@ def browse_ancestors(invocation: Invocation) -> HandlerResult:
     project_id = require_project(invocation)
     resource_id = _require_int_positional(invocation, "resource id")
     with open_service(invocation) as (service, auth):
-        found = service.call(_symbol(invocation), resource_id=resource_id, project_id=project_id)
+        try:
+            found = service.call(
+                _symbol(invocation), resource_id=resource_id, project_id=project_id
+            )
+        except CliError as exc:
+            if exc.code != CODE_RESOURCE_NOT_FOUND:
+                raise
+            raise ancestors_needs_a_folder(exc) from exc
         data = FolderIds(service).open_data(found, project_id)
     return data, _meta(invocation, auth.workspace_id, project_id)
 
@@ -238,7 +272,8 @@ def browse_ancestors(invocation: Invocation) -> HandlerResult:
 def browse_search(invocation: Invocation) -> HandlerResult:
     """Search resources across every project of the workspace (resources v2).
 
-    ``resource_type`` ``dataset`` means the route's ``datasource``. Each dataset hit
+    ``resource_type`` ``dataset`` means the route's ``datasource``, ``folder`` its ``label``.
+    Each dataset hit
     carries ``dataset_id`` and each view hit ``view_id``: pass those, never the tree ``id``.
     """
     document = invocation.load_input() or {}
@@ -246,6 +281,8 @@ def browse_search(invocation: Invocation) -> HandlerResult:
     _forward_optional(
         document, kwargs, ("search", "resource_type", "cursor", "limit", "sort", "fields")
     )
+    if isinstance(kwargs.get("resource_type"), str):
+        kwargs["resource_type"] = canonical_resource_type(kwargs["resource_type"])
     with open_service(invocation) as (service, auth):
         data = FolderIds(service).open_data(service.call(_symbol(invocation), **kwargs), None)
     return _with_object_ids(data), _meta(invocation, auth.workspace_id, None)

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/commands/dashboard.py

@@ -618,10 +618,13 @@ def dashboard_share(invocation: Invocation) -> HandlerResult:
     assert document is not None
     _forward_optional(document, kwargs, ("users",))
     with open_service(invocation) as (service, auth):
+        was_published = _was_published(service, dashboard_id)
+        if not was_published:
+            refuse_viewer_share_before_publish(dashboard_id, type_of_auth, kwargs.get("users"))
         unpublished = (
             " (not published yet: sharing alone does not publish it; run dashboard action "
             'with {"action":"publish-presentation"} to publish)'
-            if not _was_published(service, dashboard_id)
+            if not was_published
             else ""
         )
         enforce_confirmation(
@@ -638,6 +641,33 @@ def dashboard_share(invocation: Invocation) -> HandlerResult:
     return data, _meta(invocation, auth.workspace_id)
 
 
+def refuse_viewer_share_before_publish(
+    dashboard_id: int, type_of_auth: str, users: list[dict[str, Any]] | None
+) -> None:
+    """Refuse, as the server does, a ``mammoth`` share that gives viewer access before a publish.
+
+    The server (``_apply_mammoth_recipients``) refuses the whole request when any user is
+    shared as a viewer (the default role) and the board has no published version.
+    """
+    if type_of_auth != "mammoth":
+        return
+    for user in users or []:
+        shared = user.get("shared", True)
+        shared = shared.lower() in ("true", "1", "yes", "on") if isinstance(shared, str) else shared
+        if shared and user.get("role") != "dashboard_editor":
+            raise CliError(
+                code="dashboard_not_published",
+                message=f"Dashboard {dashboard_id} is not published; viewers cannot be invited.",
+                exit_status=EXIT_USAGE,
+                hint=(
+                    "Publish it first: mammoth dashboard action "
+                    f'{dashboard_id} --input \'{{"action": "publish-presentation"}}\' --yes, '
+                    "then share. Or share only users with role dashboard_editor."
+                ),
+                details={"dashboard_id": dashboard_id},
+            )
+
+
 def _share_readback(service: Any, dashboard_id: int) -> dict[str, Any]:
     """The board's share state as ``dashboard get`` reports it after a share."""
     board = _dump_model(service.call(_DASHBOARD_GET, dashboard_id=dashboard_id))

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/commands/dataset.py

@@ -35,7 +35,7 @@ from mammoth_cli.runtime.confirm import (
 )
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.new_data import with_file_upload_path
-from mammoth_cli.runtime.session import open_service, require_project
+from mammoth_cli.runtime.session import open_service, require_project, resolved_project
 from mammoth_cli.services.delete_check import ensure_deleted, find_dependents
 from mammoth_cli.services.field_enums import DATA_PULL_FILE_VALUES, allowed_values_text
 from mammoth_cli.services.listing import (
@@ -761,17 +761,22 @@ def dataset_list(invocation: Invocation) -> HandlerResult:
     datasets" never needs paging: read ``total`` with the first page's newest names.
     For a list of names (e.g. "which files can I see?") pass ``names: true``: ONE call
     returns up to 500 bare ``{id, name}`` rows, newest first, with ``total`` and ``more``.
+    With no project set it returns ``{project_id, project_name, id, name}`` rows from every
+    project the caller can open, from one workspace search (the newest 500 at most).
     ``full: true`` returns the raw ``{id, name}`` list instead. ``name`` keeps only datasets
     whose name contains it (case-insensitive) across every page, as short rows without
     column lists; ``limit``/``offset`` then page over the matches.
     """
-    project_id = require_project(invocation)
     document = invocation.load_input() or {}
+    name = document.get("name")
+    wants_names = document.get("names") and not (isinstance(name, str) and name.strip())
+    if wants_names and resolved_project(invocation) is None:
+        return _dataset_names_everywhere(invocation)
+    project_id = require_project(invocation)
     _validate_paging(document)
     kwargs: dict[str, Any] = {"project_id": project_id}
     _forward_optional(document, kwargs, ("limit", "offset", "sort"))
-    name = document.get("name")
-    if document.get("names") and not (isinstance(name, str) and name.strip()):
+    if wants_names:
         return _dataset_names(invocation, project_id, document)
     if isinstance(name, str) and name.strip():
         return _dataset_name_search(invocation, project_id, name.strip(), document)
@@ -817,6 +822,42 @@ def _dataset_names(
     return result, _meta(invocation, auth.workspace_id, project_id)
 
 
+def _dataset_names_everywhere(invocation: Invocation) -> HandlerResult:
+    """``dataset list`` with ``names`` and no project: the names of every reachable project.
+
+    One workspace search (100 hits a page, the route's cap) lists the datasets of the
+    projects the caller can open, under the same access rules as ``project list``; one
+    ``project list`` read supplies the project names. Capped at ``_SEARCH_PAGES`` pages.
+    """
+    with open_service(invocation) as (service, auth):
+        hits, cut = search_hits(service, "datasource", "", fields="minimal")
+        names = {p.get("id"): p.get("name") for p in _visible_projects(service)}
+    rows = [
+        {
+            "project_id": hit["project_id"],
+            "project_name": names[hit["project_id"]],
+            "id": hit["object_id"],
+            "name": hit.get("name"),
+        }
+        for hit in hits
+        if hit.get("project_id") in names
+    ]
+    kept, _cut = fit_budget(rows[:NAMES_MAX_ROWS], budget=NAMES_DATA_BUDGET)
+    result: dict[str, Any] = {
+        "datasets": kept,
+        "shown": len(kept),
+        "total": len(rows),
+        "projects": len({row["project_id"] for row in rows}),
+    }
+    if cut or len(kept) < len(rows):
+        result["more"] = True
+        result["note"] = (
+            f"Only the newest {len(kept)} names were read; pass --project to list one "
+            "project's names, or name to find one."
+        )
+    return result, _meta(invocation, auth.workspace_id, None)
+
+
 def _dataset_total(service: Any, project_id: int, page: dict[str, Any], offset: int) -> int:
     """The project's whole dataset count. The list route sends none, so a page that
     is the last one counts itself; otherwise the ids are read once, here, in one call."""
@@ -1036,6 +1077,45 @@ def _validate_paging(document: dict[str, Any]) -> None:
             )
 
 
+def _batch_column_ids(
+    service: Any, dataset_id: int, project_id: int, columns: str | list[str]
+) -> str:
+    """The comma-separated column ids the batch-data route wants, from names or ids."""
+    response = service.call(_DATASET_GET_SYMBOL, dataset_id=dataset_id, project_id=project_id)
+    dataset = response.get("dataset", response) if isinstance(response, dict) else {}
+    schema = dataset.get("data_schema") if isinstance(dataset, dict) else None
+    return resolve_batch_columns(schema, dataset_id, columns)
+
+
+def resolve_batch_columns(schema: Any, dataset_id: int, columns: str | list[str]) -> str:
+    """Column ids, comma-separated, for names or ids in ``columns`` (a list or one string).
+
+    The batch-data route refuses display names with a bare "invalid columns"; the dataset
+    schema maps each ``c_name`` to its ``c_id``. An id passes through; a name the schema
+    lacks is refused with the names it has.
+    """
+    if not isinstance(schema, list):
+        raise CliError(
+            code=CODE_API_ERROR,
+            message=f"Could not read dataset {dataset_id}'s columns to resolve 'columns'.",
+            exit_status=EXIT_API,
+        )
+    wanted = [n.strip() for n in columns.split(",")] if isinstance(columns, str) else columns
+    ids = {c["c_id"] for c in schema if isinstance(c, dict) and "c_id" in c}
+    by_name = {c["c_name"]: c["c_id"] for c in schema if isinstance(c, dict) and "c_name" in c}
+    resolved = [name if name in ids else by_name.get(name) for name in wanted]
+    missing = [name for name, found in zip(wanted, resolved, strict=True) if found is None]
+    if missing:
+        raise CliError(
+            code="unknown_column",
+            message=f"Column(s) not in dataset {dataset_id}: {', '.join(missing)}.",
+            exit_status=EXIT_USAGE,
+            hint="Use column names or ids from `mammoth dataset get`.",
+            details={"columns": missing, "available": sorted(by_name)},
+        )
+    return ",".join(str(found) for found in resolved)
+
+
 def dataset_batch_data(invocation: Invocation) -> HandlerResult:
     """Fetch data for a specific dataset batch."""
     project_id = require_project(invocation)
@@ -1050,6 +1130,9 @@ def dataset_batch_data(invocation: Invocation) -> HandlerResult:
     }
     _forward_optional(document, kwargs, ("columns", "limit", "offset", "timeout", "poll_interval"))
     with open_service(invocation) as (service, auth):
+        if kwargs.get("columns"):
+            columns = kwargs["columns"]
+            kwargs["columns"] = _batch_column_ids(service, dataset_id, project_id, columns)
         data = service.call(_symbol(invocation), **kwargs)
     return data, _meta(invocation, auth.workspace_id, project_id)
 

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/commands/help_summaries.json

@@ -583,10 +583,12 @@
   "view.checkpoint.get": "Get one checkpoint by id.",
   "view.checkpoint.list": "List checkpoints on a dataview, with optional filters from '--input'.",
   "view.checkpoint.update": "Update one checkpoint by id. 'body' is required.",
+  "view.column.format.set": "Set how columns display (date or number format; a view display setting, not a task).",
   "view.compare": "Compare dataviews pairwise: rows, column differences and checksums (read-only).",
   "view.conditional-format.create": "Colour cells in many columns by one threshold in a single command (columns + operator + value + color): each cell is judged by its own value. applies_to=row colours whole rows when any/all of the columns match.",
   "view.conditional-format.delete-all": "Delete a conditional-format rule on a dataview. Prompt or '--yes'.",
   "view.conditional-format.list": "List conditional-format rules on a dataview.",
+  "view.conditional-format.replace": "Replace every conditional-format rule on a view with new ones in one call.",
   "view.conditional-format.update": "Update a conditional-format rule on a dataview. 'rule' is required.",
   "view.create": "Create a view from a dataset. Dataset id is positional; name/clone_from optional.",
   "view.data-check.create": "Create a data check on a dataview. 'body' is required.",
@@ -625,6 +627,7 @@
   "view.export.csv": "Export a dataview to a local CSV file.",
   "view.export.dataset": "Run one of the SDK's typed 'View.export' destination helpers.",
   "view.export.delete": "Delete one export by id. Always requires '--yes'.",
+  "view.export.download": "Download a dataview to a local file as csv, xlsx, json, ndjson, xml, yaml or parquet.",
   "view.export.elasticsearch": "Run one of the SDK's typed 'View.export' destination helpers.",
   "view.export.email": "Run one of the SDK's typed 'View.export' destination helpers.",
   "view.export.ftp": "Run one of the SDK's typed 'View.export' destination helpers.",
@@ -689,7 +692,7 @@
   "view.transform.increment-date": "Increment a date column. 'column'/'delta' required.",
   "view.transform.join": "Join another view. 'foreign_view'/'join_type'/'on'/'select' required.",
   "view.transform.json-extract": "Extract fields from a JSON column. 'column' is required.",
-  "view.transform.limit-rows": "Limit the row count. 'n' is required.",
+  "view.transform.limit-rows": "Limit the row count. 'n' (or its alias 'limit') is required.",
   "view.transform.lookup": "Look up values from another view. 'source'/'lookup_view_id'/'key'/",
   "view.transform.math": "Evaluate a math expression into a column. 'expression' is required.",
   "view.transform.pivot": "Pivot with aggregations. 'group_by'/'aggregations' required.",

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/commands/registry.py

@@ -885,6 +885,9 @@ _TARGETS: dict[str, str] = {
         "mammoth_cli.commands.view:view_conditional_format_delete_all"
     ),
     "view.conditional-format.list": "mammoth_cli.commands.view:view_conditional_format_list",
+    "view.conditional-format.replace": (
+        "mammoth_cli.commands.view:view_conditional_format_replace"
+    ),
     "view.conditional-format.update": "mammoth_cli.commands.view:view_conditional_format_update",
     "view.checkpoint.create": "mammoth_cli.commands.view:view_checkpoint_create",
     "view.checkpoint.delete": "mammoth_cli.commands.view:view_checkpoint_delete",
@@ -924,6 +927,7 @@ _TARGETS: dict[str, str] = {
     "view.task.update": "mammoth_cli.commands.view:view_task_update",
     "view.export.create": "mammoth_cli.commands.view:view_export_create",
     "view.export.csv": "mammoth_cli.commands.view:view_export_csv",
+    "view.export.download": "mammoth_cli.commands.view:view_export_download",
     "view.export.delete": "mammoth_cli.commands.view:view_export_delete",
     "view.export.get": "mammoth_cli.commands.view:view_export_get",
     "view.export.list": "mammoth_cli.commands.view:view_export_list",
@@ -1005,6 +1009,7 @@ _TARGETS: dict[str, str] = {
     "view.transform.generate-sql": "mammoth_cli.commands.view_ops:view_transform_generate_sql",
     "view.transform.increment-date": "mammoth_cli.commands.view_ops:view_transform_increment_date",
     "view.transform.join": "mammoth_cli.commands.view_ops:view_transform_join",
+    "view.column.format.set": "mammoth_cli.commands.view_ops:view_column_format_set",
     "view.transform.json-extract": "mammoth_cli.commands.view_ops:view_transform_json_extract",
     "view.transform.limit-rows": "mammoth_cli.commands.view_ops:view_transform_limit_rows",
     "view.transform.lookup": "mammoth_cli.commands.view_ops:view_transform_lookup",

{mammoth_cli-2.2.91 → mammoth_cli-2.2.93}/mammoth_cli/commands/schema.py

@@ -224,6 +224,10 @@ _COMMAND_DISCOVERY_PURPOSES = {
     "file.delete": "delete remove uploaded source file csv",
     "file.list": "list show uploaded source files csv",
     "view.export.csv": "export download local CSV file artifact",
+    "view.export.download": (
+        "export download local file artifact xlsx excel json ndjson xml yaml parquet "
+        "file type format"
+    ),
     "view.export.dataset": (
         "send copy branch out create save the result rows into a new project from an "
         "existing append appending union stack monthly rows across datasets views "
@@ -431,6 +435,15 @@ _COMMAND_DISCOVERY_PURPOSES = {
     "view.transform.rename-columns": (
         "rename column columns header headers relabel change column name names title"
     ),
+    "view.column.format.set": (
+        "format display column date format number format decimals decimal places currency "
+        "symbol percent percentage thousands separator show dates as how values look grid "
+        "date display"
+    ),
+    "view.conditional-format.replace": (
+        "replace redo reset change all conditional formatting rules highlight colour color "
+        "existing rules in one call"
+    ),
     "view.transform.replace": "find replace substitute text value in columns",
     "view.transform.set-values": (
         "set values assign overwrite blank empty default where condition label "
@@ -952,7 +965,8 @@ IN_PLACE_RECIPE = (
     "EDITS THE GIVEN VIEW IN PLACE: this adds a step to the view and changes that view "
     "and its dataset's output. To make a NEW dataset and leave the source untouched: "
     "`mammoth view create SOURCE_DATASET_ID` (working view), do the steps on that working "
-    "view, then `mammoth view export dataset WORKING_VIEW_ID` (add dataset_name only if the user named it)."
+    "view, then `mammoth view export dataset WORKING_VIEW_ID` "
+    "(add dataset_name only if the user named it)."
 )
 _IN_PLACE_KEYWORDS = (
     "new dataset create make in place edits given view working view source untouched"
@@ -1183,17 +1197,53 @@ def _accepted_fields(record: dict[str, Any]) -> list[dict[str, Any]] | None:
     ]
 
 
+_INLINE_SCHEMA_MAX_CHARS = 3000
+#: A restrictions note (where a nested input shape often lives) is inlined up to this long.
+_INLINE_NOTES_MAX_CHARS = 700
+
+
 def _compact_accepted_fields(record: dict[str, Any]) -> list[dict[str, Any]] | None:
-    """``_accepted_fields`` without the per-field JSON Schema.
+    """``_accepted_fields`` with a nested JSON Schema only where the type name is not enough.
 
     A find result inlines this for its top matches: enough to compose a call
-    (name, type, required, enum) without the nested-schema detail ``schema
-    get`` returns.
+    (name, type, required, enum) without a follow-up ``schema get``. A
+    non-scalar field (e.g. convert-type's ``conversions``) also carries its
+    JSON Schema, unless that would be larger than ``_INLINE_SCHEMA_MAX_CHARS``.
     """
     fields = _accepted_fields(record)
     if fields is None:
         return None
-    return [{key: field[key] for key in ("name", "type", "required", "enum")} for field in fields]
+    compact: list[dict[str, Any]] = []
+    for field in fields:
+        item = {key: field[key] for key in ("name", "type", "required", "enum")}
+        schema = field.get("schema")
+        if (
+            schema is not None
+            and not _is_scalar_field_schema(schema)
+            and len(json.dumps(schema, default=str)) <= _INLINE_SCHEMA_MAX_CHARS
+        ):
+            item["schema"] = schema
+        compact.append(item)
+    return compact
+
+
+def input_contract(command_id: str) -> dict[str, Any] | None:
+    """The input shape a rejected call should have used: fields (with nested shapes) and an example.
+
+    Attached to input-validation errors so the caller can correct the call
+    without a ``schema get`` round trip. ``None`` for a command with no
+    manifest record or no accepted fields.
+    """
+    record = command_by_id(command_id)
+    if record is None:
+        return None
+    fields = _compact_accepted_fields(record)
+    if fields is None:
+        return None
+    contract: dict[str, Any] = {"command_id": command_id, "accepted_fields": fields}
+    if record.get("agent_example"):
+        contract["agent_example"] = record["agent_example"]
+    return contract
 
 
 def _externally_supplied_fields(command_id: str) -> frozenset[str]:
@@ -2215,6 +2265,10 @@ def _inline_call_detail(entries: list[dict[str, Any]]) -> None:
             entry["accepted_fields"] = fields
         if record.get("agent_example"):
             entry["agent_example"] = record["agent_example"]
+        notes = record.get("known_restrictions")
+        if isinstance(notes, str) and notes:
+            cut = notes[:_INLINE_NOTES_MAX_CHARS]
+            entry["known_restrictions"] = cut + ("..." if len(notes) > len(cut) else "")
 
 
 def _inline_picks(page: list[dict[str, Any]], offset: int) -> list[dict[str, Any]]: