mammoth-cli 2.2.18__tar.gz → 2.2.20__tar.gz

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.18
+Version: 2.2.20
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -17,7 +17,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.15
+Requires-Dist: mammoth-io<0.9,>=0.8.16
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

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

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/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 645; 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 646; 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:
 
@@ -26,7 +26,7 @@ Load only the applicable domain file:
 - [dashboard-style](commands/dashboard-style.md) — 10 published commands
 - [dashboard](commands/dashboard.md) — 96 published commands
 - [data-app](commands/data-app.md) — 12 published commands
-- [dataset](commands/dataset.md) — 21 published commands
+- [dataset](commands/dataset.md) — 22 published commands
 - [doctor](commands/doctor.md) — 1 published commands
 - [external-key](commands/external-key.md) — 4 published commands
 - [file](commands/file.md) — 9 published commands

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/dataset.md

@@ -192,6 +192,16 @@ Result: `DatasetRestoreResult`; mutation `benign_mutation`, confirmation `none`,
 
 Status on release: ran once on CLI 2.0.14 — write sweep 2026-09-18: exit 0 on release with CLI 2.0.14. job 312 restore_datasource -> status success. dataset list --project 21 confirms dataset 49 (name 'stores.csv 2') is back and visible alongside 48. Single invocation only.
 
+### `dataset.search`
+
+Run: `mammoth dataset search`. Exact input fields: `mammoth schema get dataset.search`.
+
+Example: `mammoth dataset search 'New Year Sale'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+
+Result: `DatasetSearchResult`; mutation `read`, confirmation `none`, wait policy `not_async`.
+
+Status on release: untried; no live run recorded.
+
 ### `dataset.trash`
 
 Run: `mammoth dataset trash`. Exact input fields: `mammoth schema get dataset.trash`.

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view.md

@@ -116,7 +116,7 @@ Status on release: ran once on CLI 2.0.18 — fixture-lifecycle sweep 2026-09-19
 
 Run: `mammoth view conditional-format create`. Exact input fields: `mammoth schema get view.conditional-format.create`.
 
-Example: `mammoth view conditional-format create 123 123 --input '{"rule": {"cf_type": "RULE", "payload": {"FORMAT": {"name": "Flag open orders", "color": "red", "applies_to": "row", "column_ids": "[]"}, "CONDITION": {"OR": [{"column_1": {"CONTAINS": {"VALUE": ["Open"]}}}]}}}}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
+Example: `mammoth view conditional-format create 123 123 --input '{"columns": ["Q1", "Q2", "Q3"], "operator": "<", "value": 55, "color": "red"}'`. Placeholders are illustrative; resolve IDs and input from observed reads.
 
 Result: `ViewConditionalFormatCreateResult`; mutation `benign_mutation`, confirmation `none`, wait policy `not_async`.
 

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/bundled_skill/mammoth-cli/references/operations.md

@@ -38,7 +38,11 @@ case-insensitive substring match over every page, returned as short rows
 (id, name, rows, cols) with `matched`. Do not page `dataset list` by hand;
 `limit` is at most 100. To find the dataset that holds given columns, pass
 `dataset find --input '{"columns": ["Order ID", "Region"]}'` (the name is then
-optional). A `browse` search hit carries `dataset_id` or `view_id`: use those,
+optional). To find the dataset that holds a value you were given (a campaign,
+a region, a product) when its name does not say, run `dataset search TERM`: it
+returns the project's datasets whose name, column names or sampled column
+values contain TERM, each with the matched column and value. `dataset find`
+and `browse` search match names only. A `browse` search hit carries `dataset_id` or `view_id`: use those,
 never the tree `id`.
 
 ```bash
@@ -172,6 +176,15 @@ them, so never report them as access denied. Pass `include_non_members: true`
 only when the user asks about projects they are not in; each row then carries
 `member`.
 
+## Conditional formatting
+
+Colour cells in many columns by one threshold in a single command:
+`view conditional-format create --input '{"columns": ["Q1", "Q2"], "operator": "<", "value": 55, "color": "red"}'`
+(display names). Each cell is judged by its own value, so this makes one rule
+per column in that one call and returns every created rule id. `applies_to: "row"`
+makes one rule that colours whole rows when any (`match: "any"`, default) or all
+(`"all"`) of the columns match. A raw `rule` body still works.
+
 ## Exports
 
 First inspect `view.export.list/get` for existing configuration and the exact

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/commands/dataset.py

@@ -395,6 +395,48 @@ def dataset_find(invocation: Invocation) -> HandlerResult:
     return result, meta
 
 
+#: Matches kept per dataset in a ``dataset search`` row; the rest are counted, not listed.
+_SEARCH_MATCHES_PER_DATASET = 5
+
+
+def _search_row(hit: dict[str, Any]) -> dict[str, Any]:
+    """One ``dataset search`` row: the dataset and the first places its content matched."""
+    matches = hit.get("matches") or []
+    row: dict[str, Any] = {
+        "id": hit.get("id"),
+        "name": hit.get("name"),
+        "matches": matches[:_SEARCH_MATCHES_PER_DATASET],
+    }
+    if len(matches) > _SEARCH_MATCHES_PER_DATASET:
+        row["more_matches"] = len(matches) - _SEARCH_MATCHES_PER_DATASET
+    return row
+
+
+def dataset_search(invocation: Invocation) -> HandlerResult:
+    """Find the project's datasets whose name, column names or sampled values hold TERM.
+
+    Read-only: one server call. Each match names where the term was found (``name``,
+    ``column`` or ``value``) with the column and the sampled value, so the dataset that
+    holds "New Year Sale" in a ``campaign`` column is found without knowing its name.
+    Sampled values come from the profile, which keeps up to 30 per text column, so a
+    dataset never profiled matches on name and columns only.
+    """
+    term = _require_string_positional(invocation, "term")
+    project_id = require_project(invocation)
+    with open_service(invocation) as (service, auth):
+        data = service.call(
+            "mammoth.api.datasets.DatasetsAPI.search", term=term, project_id=project_id
+        )
+    hits = data.get("datasets", []) if isinstance(data, dict) else []
+    kept, omitted = fit_budget([_search_row(h) for h in hits if isinstance(h, dict)])
+    result: dict[str, Any] = {"term": term, "datasets": kept, "matched": len(hits)}
+    if omitted:
+        result["omitted"] = omitted
+    if note := ambiguity_note(len(hits), term):
+        result["note"] = note
+    return result, _meta(invocation, auth.workspace_id, project_id)
+
+
 def dataset_list(invocation: Invocation) -> HandlerResult:
     """List datasets in the active project, newest first, each with what tells them apart.
 

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/commands/registry.py

@@ -318,6 +318,7 @@ HANDLERS: dict[str, Handler] = {
     # dataset family
     "dataset.find": dataset_cmd.dataset_find,
     "dataset.list": dataset_cmd.dataset_list,
+    "dataset.search": dataset_cmd.dataset_search,
     "dataset.get": dataset_cmd.dataset_get,
     "dataset.batch-data": dataset_cmd.dataset_batch_data,
     "dataset.data": dataset_cmd.dataset_data,

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/commands/view.py

@@ -50,8 +50,10 @@ from mammoth_cli.runtime.confirm import (
     POLICY_YES_ALWAYS,
     enforce_confirmation,
 )
+from mammoth_cli.runtime.dryrun import DryRunStop
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.session import open_service, require_project
+from mammoth_cli.services import conditional_format as cf_rules
 from mammoth_cli.services import read_queries, text_dates
 from mammoth_cli.services.conditions import CONDITION_KWARG, compile_condition
 from mammoth_cli.services.dashboard_review import UPLOAD_NOTE, upload_hints
@@ -2132,24 +2134,89 @@ def view_exportable_config_apply(invocation: Invocation) -> HandlerResult:
 
 
 def view_conditional_format_create(invocation: Invocation) -> HandlerResult:
-    """Create a conditional-format rule on a dataview. ``rule`` is required."""
+    """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.
+
+    Per-cell means one rule per column, all made in this one call. A raw ``rule`` body still
+    works instead.
+    """  # noqa: E501
     project_id = require_project(invocation)
     dataview_id = _require_int_positional_at(invocation, 0, "view id")
-    document = invocation.load_input()
-    rule = _require_field(document, "rule")
-    assert document is not None
+    document = invocation.load_input() or {}
+    has_typed = any(field in document for field in cf_rules.TYPED_FIELDS)
+    if "rule" in document and has_typed:
+        raise CliError(
+            code=cf_rules.CODE_INVALID_RULE,
+            message="Pass either 'rule' or the typed fields (columns, operator, value, color).",
+            exit_status=EXIT_USAGE,
+        )
+    if "rule" not in document and not has_typed:
+        _require_field(document, "rule")
     with open_service(invocation) as (service, auth):
         dataset_id = _resolve_dataset_id(service, invocation, dataview_id, document)
-        data = service.call(
-            _symbol(invocation),
-            dataset_id=dataset_id,
-            dataview_id=dataview_id,
-            rule=rule,
-            project_id=project_id,
-        )
+        if has_typed:
+            metadata = _dataview_metadata(service, dataset_id, dataview_id, project_id)
+            column_map, column_types = _column_maps(metadata)
+            rules = cf_rules.build_rules(document, column_map, column_types)
+        else:
+            cf_rules.validate_rule(document["rule"])
+            rules = [document["rule"]]
+        data = _create_cf_rules(service, invocation, rules, (dataset_id, dataview_id, project_id))
     return data, _meta(invocation, auth.workspace_id, project_id)
 
 
+def _cf_sequence(rule: Any) -> int:
+    return rule.get("SEQUENCE", -1) if isinstance(rule, dict) else -1
+
+
+def _create_cf_rules(
+    service: Any, invocation: Invocation, rules: list[dict[str, Any]], scope: tuple[Any, ...]
+) -> Any:
+    """POST each rule in turn; a mid-way failure names the rule ids already created.
+
+    Every response is the dataview's whole rule map; the new rule has the highest SEQUENCE.
+    """
+    dataset_id, dataview_id, project_id = scope
+    ids: list[str] = []
+    data: Any = None
+    for rule in rules:
+        try:
+            data = service.call(
+                _symbol(invocation),
+                dataset_id=dataset_id,
+                dataview_id=dataview_id,
+                rule=rule,
+                project_id=project_id,
+            )
+        except DryRunStop as stop:
+            stop.record["rules"] = rules  # every body that would be sent, not just the first
+            raise
+        except CliError as error:
+            if ids:
+                error.details = {**error.details, "created_rule_ids": ids}
+                error.message += f" Rules already created before the failure: {ids}."
+            raise
+        if isinstance(data, dict) and data:
+            ids.append(max(data, key=lambda k: _cf_sequence(data[k])))
+    if len(rules) == 1:
+        return data
+    note = f"{len(rules)} rules, one per column, so each cell is coloured by its own value."
+    return {"created_rule_ids": ids, "rules_created": len(rules), "note": note}
+
+
+def _column_maps(metadata: list[dict[str, Any]]) -> tuple[dict[str, str], dict[str, str]]:
+    """Display -> internal name and display -> type maps from a view's column metadata."""
+    names: dict[str, str] = {}
+    types: dict[str, str] = {}
+    for column in metadata:
+        internal = column.get(_INTERNAL_NAME_KEY)
+        display = column.get(_DISPLAY_NAME_KEY)
+        if isinstance(internal, str) and isinstance(display, str):
+            names[display] = internal
+            if isinstance(column.get("type"), str):
+                types[display] = column["type"]
+    return names, types
+
+
 def view_conditional_format_delete_all(invocation: Invocation) -> HandlerResult:
     """Delete a conditional-format rule on a dataview. Prompt or ``--yes``.
 

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/errors/envelope.py

@@ -111,6 +111,7 @@ ERROR_SUMMARIES: dict[str, str] = {
     "invalid_argument": _S_BAD_REQUEST,
     "invalid_argument_combination": _S_BAD_REQUEST,
     "invalid_arguments": _S_BAD_REQUEST,
+    "invalid_rule": "A conditional-format rule wasn't valid.",
     "invalid_condition": "A filter condition wasn't valid.",
     "invalid_condition_value": "A filter condition used a value that isn't valid.",
     "invalid_config_value": _S_SETUP,

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/services/command_contract.py

@@ -350,6 +350,24 @@ _VIEW_DATA_PROFILE_FIELDS = (
     FieldSpec("limit", required=False, annotation=int, default=50),
 )
 
+# view.conditional-format.create: ``rule`` (raw body) stays accepted; the typed fields build one
+# rule per column (per-cell threshold) or one row rule (see
+# mammoth_cli.services.conditional_format). ``rule`` is therefore optional here -- the handler
+# requires one form or the other.
+_VIEW_CF_CREATE_FIELDS = (
+    FieldSpec("dataset_id", required=True, annotation=int),
+    FieldSpec("rule", required=False, annotation=dict[str, Any] | None, default=None),
+    FieldSpec("columns", required=False, annotation=list[str] | None, default=None),
+    FieldSpec("operator", required=False, annotation=str | None, default=None),
+    FieldSpec("value", required=False, annotation=Any, default=None),
+    FieldSpec("color", required=False, annotation=str | None, default=None),
+    FieldSpec("name", required=False, annotation=str | None, default=None),
+    FieldSpec(
+        "applies_to", required=False, annotation=Literal["row", "columns"] | None, default=None
+    ),
+    FieldSpec("match", required=False, annotation=Literal["any", "all"] | None, default=None),
+)
+
 # dashboard.filter.add/remove are CLI composites over canvas get + canvas save
 # (DashboardsAPI.canvas_save is named in the manifest as the SDK anchor); the
 # canvas body is built by the handler, so the document carries only the filter.
@@ -388,6 +406,7 @@ _LOCAL_COMMANDS = frozenset(
         "context.project.status",
         "context.project.use",
         "dataset.find",
+        "dataset.search",
         "doctor",
         "project.check",
         "project.ensure",
@@ -759,6 +778,8 @@ def resolve_command_contract(command_id: str) -> ResolvedCommandContract | None:
         special_fields = _DASHBOARD_FILTER_ADD_FIELDS
     elif command_id == "dashboard.filter.remove":
         special_fields = _DASHBOARD_FILTER_REMOVE_FIELDS
+    elif command_id == "view.conditional-format.create":
+        special_fields = _VIEW_CF_CREATE_FIELDS
     elif command_id == "dashboard.filter.list":
         special_fields = ()
     local_fields = _LOCAL_CONTRACT_FIELDS.get(command_id, ()) if is_local else None

mammoth_cli-2.2.20/mammoth_cli/services/conditional_format.py

@@ -0,0 +1,131 @@
+"""Build and check the conditional-format rule body ``view conditional-format create`` sends.
+
+The release route takes ``{"cf_type": "RULE", "payload": {"FORMAT", "CONDITION"}}``. One
+rule is ``FORMAT.applies_to`` ``"columns"`` with ``column_ids`` (a JSON-encoded list of
+internal names) or ``"row"``, plus a ``CONDITION`` group. The evaluator checks CONDITION per row
+and colours every ``column_ids`` cell, so the typed fields build one rule per column for a
+per-cell threshold, or one row rule.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from mammoth_cli.errors.envelope import EXIT_USAGE, CliError
+from mammoth_cli.services.conditions import compile_condition
+
+CODE_INVALID_RULE = "invalid_rule"
+APPLIES_TO = ("row", "columns")
+_EMPTY_COLUMN_IDS = "[]"
+MATCH = ("any", "all")
+TYPED_FIELDS = ("columns", "operator", "value", "color", "name", "applies_to", "match")
+_NO_VALUE_OPERATORS = frozenset({"IS_EMPTY", "IS_NOT_EMPTY"})
+
+
+def _invalid(message: str, hint: str | None = None) -> CliError:
+    return CliError(code=CODE_INVALID_RULE, message=message, exit_status=EXIT_USAGE, hint=hint)
+
+
+def _check_format(fmt: Any) -> None:
+    """Mirror the backend's FORMAT validation so a bad rule fails before any request."""
+    if not isinstance(fmt, dict):
+        raise _invalid("A RULE payload needs a FORMAT object.")
+    applies_to = fmt.get("applies_to")
+    if applies_to not in APPLIES_TO:
+        raise _invalid(
+            f"FORMAT.applies_to must be one of {', '.join(APPLIES_TO)}; got {applies_to!r}.",
+            "Use 'row' to colour whole rows, or 'columns' with column_ids.",
+        )
+    column_ids = fmt.get("column_ids", _EMPTY_COLUMN_IDS)
+    empty = column_ids == _EMPTY_COLUMN_IDS
+    if applies_to == "row" and not empty:
+        raise _invalid("FORMAT.column_ids must be '[]' when applies_to is 'row'.")
+    if applies_to == "columns" and empty:
+        raise _invalid("FORMAT.column_ids must not be '[]' when applies_to is 'columns'.")
+
+
+def validate_rule(rule: Any) -> None:
+    """Raise ``invalid_rule`` when a raw rule's FORMAT has a bad ``applies_to``/``column_ids``.
+
+    Everything else about the body (cf_type, CONDITION) is left to the backend, which
+    owns those shapes; only the FORMAT enum was reaching it unchecked.
+    """
+    payload = rule.get("payload") if isinstance(rule, dict) else None
+    if isinstance(payload, dict) and "FORMAT" in payload:
+        _check_format(payload["FORMAT"])
+
+
+def _resolve_columns(names: Any, column_map: dict[str, str]) -> list[str]:
+    if not isinstance(names, list) or not names or not all(isinstance(n, str) for n in names):
+        raise _invalid("'columns' must be a non-empty list of column names.")
+    missing = [name for name in names if name not in column_map]
+    if missing:
+        raise _invalid(
+            f"Unknown column(s): {', '.join(missing)}.",
+            "Use display names of the view's columns: " + ", ".join(sorted(column_map)),
+        )
+    return list(dict.fromkeys(names))
+
+
+def _leaf(column: str, document: dict[str, Any]) -> dict[str, Any]:
+    leaf: dict[str, Any] = {"column": column, "operator": document["operator"]}
+    if "value" in document:
+        leaf["value"] = document["value"]
+    return leaf
+
+
+def _require_typed(document: dict[str, Any]) -> None:
+    for field in ("columns", "operator", "color"):
+        if document.get(field) is None:
+            raise _invalid(
+                f"The typed form needs '{field}'.",
+                'Many columns, one command: --input \'{"columns": ["A", "B"], '
+                '"operator": "<", "value": 55, "color": "red"}\'.',
+            )
+
+
+def _label(document: dict[str, Any]) -> str:
+    operator = str(document["operator"])
+    if operator.upper() in _NO_VALUE_OPERATORS:
+        return operator
+    return f"{operator} {document.get('value')}"
+
+
+def _rule(fmt: dict[str, Any], condition: dict[str, Any]) -> dict[str, Any]:
+    rule = {"cf_type": "RULE", "payload": {"FORMAT": fmt, "CONDITION": condition}}
+    validate_rule(rule)
+    return rule
+
+
+def build_rules(
+    document: dict[str, Any], column_map: dict[str, str], column_types: dict[str, str]
+) -> list[dict[str, Any]]:
+    """RULE entries for the typed fields.
+
+    The evaluator judges CONDITION once per ROW and then colours every ``column_ids`` cell, so a
+    threshold per cell needs one rule per column (each condition on its own column). Only
+    ``applies_to: row`` is one rule: ``match`` any (OR, default) or all (AND) of the columns.
+    """
+    _require_typed(document)
+    names = _resolve_columns(document["columns"], column_map)
+    color, label = document["color"], _label(document)
+
+    def condition(name: str) -> dict[str, Any]:
+        return compile_condition(_leaf(name, document)).build(column_map, column_types)
+
+    if document.get("applies_to") == "row":
+        match = document.get("match") or "any"
+        if match not in MATCH:
+            raise _invalid(f"match must be one of {', '.join(MATCH)}; got {match!r}.")
+        fmt = {"name": document.get("name") or f"{', '.join(names)} {label}"[:80]}
+        fmt |= {"color": color, "applies_to": "row", "column_ids": "[]"}
+        group = {"OR" if match == "any" else "AND": [condition(n) for n in names]}
+        return [_rule(fmt, group)]
+    rules = []
+    for name in names:
+        title = f"{document['name']}: {name}" if document.get("name") else f"{name} {label}"
+        fmt = {"name": title, "color": color, "applies_to": "columns"}
+        fmt["column_ids"] = json.dumps([column_map[name]])
+        rules.append(_rule(fmt, {"OR": [condition(name)]}))
+    return rules

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/services/input_fields.py

@@ -226,22 +226,13 @@ _EXAMPLE_INPUT_HINTS: dict[str, dict[str, Any]] = {
     },
     "view.ai.profile": {"dataset_id": 456, "action": "insights"},
     "connector.query.generate": {"query": "Total sales for January"},
-    # HighlightEntry: cf_type + payload{FORMAT, CONDITION keyed by internal
-    # column name}; the create response and ``conditional-format list`` carry
-    # the generated rule_id that delete-all needs.
+    # One rule over many columns; the create response and ``conditional-format
+    # list`` carry the generated rule_id that delete-all needs.
     "view.conditional-format.create": {
-        "rule": {
-            "cf_type": "RULE",
-            "payload": {
-                "FORMAT": {
-                    "name": "Flag open orders",
-                    "color": "red",
-                    "applies_to": "row",
-                    "column_ids": "[]",
-                },
-                "CONDITION": {"OR": [{"column_1": {"CONTAINS": {"VALUE": ["Open"]}}}]},
-            },
-        }
+        "columns": ["Q1", "Q2", "Q3"],
+        "operator": "<",
+        "value": 55,
+        "color": "red",
     },
     "view.conditional-format.delete-all": {"rule_id": "bca0ff33bd6f8ed1"},
     "dataset.bulk-delete": {"dataset_ids": [456, 457]},

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/mammoth_cli/services/positionals.py

@@ -650,6 +650,16 @@ POSITIONAL_OVERRIDES: dict[str, tuple[PositionalSpec, ...]] = {
             example_value="sales",
         ),
     ),
+    "dataset.search": (
+        PositionalSpec(
+            name="term",
+            type=str,
+            required=True,
+            help="Text to find in dataset names, column names or sampled column values "
+            "(case-insensitive, at least 2 characters).",
+            example_value="New Year Sale",
+        ),
+    ),
     "folder.find": (
         PositionalSpec(
             name="name_substring",

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "mammoth-cli"
-version = "2.2.18"
+version = "2.2.20"
 description = "Command-line interface for the Mammoth Analytics platform"
 authors = [{name = "Mammoth Analytics", email = "support@mammoth.io"}]
 readme = "README.md"
 license = "LicenseRef-Proprietary"
 requires-python = ">=3.12,<3.15"
 dependencies = [
-    "mammoth-io (>=0.8.15,<0.9)",
+    "mammoth-io (>=0.8.16,<0.9)",
     "typer (>=0.27,<0.28)",
     "rich (>=15,<16)",
     "platformdirs (>=4.10,<5)",

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/spec/manifests/commands/dataset.yaml

@@ -818,6 +818,46 @@ commands:
   undo_test: null
   known_restrictions: null
   reviewed_by: primary
+- command_id: dataset.search
+  command_path: dataset search
+  disposition: command
+  alias_of: null
+  operation_ids: []
+  positionals:
+  - name: term
+    type: str
+    required: true
+    metavar: TERM
+    falls_back_to_field: null
+    help: Text to find in dataset names, column names or sampled column values (case-insensitive,
+      at least 2 characters).
+  options: []
+  sdk_symbol: mammoth_cli.commands.dataset.search
+  sdk_conversion: Call mammoth_cli.commands.dataset.search with validated request fields.
+  request_model: DatasetSearchRequest
+  result_model: DatasetSearchResult
+  mutation_class: read
+  confirmation: none
+  wait_policy: not_async
+  pagination_policy: none
+  acceptance_evidence: live_read_only
+  live_test: null
+  live_exemption_reason: Read-only composite over the project's datasets search route.
+  contract_fixture: null
+  required_fixture_guard: null
+  secret_fields: []
+  human_example: mammoth dataset search TERM --help
+  agent_example: mammoth dataset search 'New Year Sale'
+  unit_tests:
+  - UT-DATASET-SEARCH
+  contract_tests:
+  - CT-DATASET-SEARCH-HUMAN
+  - CT-DATASET-SEARCH-JSON
+  - CT-DATASET-SEARCH-ERROR
+  draft_test: null
+  undo_test: null
+  known_restrictions: null
+  reviewed_by: primary
 - command_id: dataset.trash
   command_path: dataset trash
   disposition: command

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/spec/manifests/commands/view.yaml

@@ -593,9 +593,8 @@ commands:
   required_fixture_guard: null
   secret_fields: []
   human_example: mammoth view conditional-format create VIEW_ID --help
-  agent_example: 'mammoth view conditional-format create 123 123 --input ''{"rule": {"cf_type": "RULE",
-    "payload": {"FORMAT": {"name": "Flag open orders", "color": "red", "applies_to": "row", "column_ids":
-    "[]"}, "CONDITION": {"OR": [{"column_1": {"CONTAINS": {"VALUE": ["Open"]}}}]}}}}'''
+  agent_example: 'mammoth view conditional-format create 123 123 --input ''{"columns": ["Q1", "Q2",
+    "Q3"], "operator": "<", "value": 55, "color": "red"}'''
   unit_tests:
   - UT-VIEW-CONDITIONAL-FORMAT-CREATE
   contract_tests:
@@ -604,9 +603,10 @@ commands:
   - CT-VIEW-CONDITIONAL-FORMAT-CREATE-ERROR
   draft_test: null
   undo_test: null
-  known_restrictions: 'rule is forwarded verbatim and dispatches. The release backend requires {"cf_type":
-    "RULE"|"COLOR_SCALE", "payload": {...}} with a CONDITION (RULE) or scale (COLOR_SCALE) inside payload;
-    other shapes return HTTP 400 4GENR007. Untyped; no working payload observed yet.'
+  known_restrictions: 'columns + operator + value + color colour each cell by its own value: one RULE
+    per column, created in this one call (applies_to columns, the default). applies_to row makes
+    one rule over any/all (match) of the columns. A raw rule body ({"cf_type": "RULE"|"COLOR_SCALE",
+    "payload": {...}}) still works instead; applies_to must be row or columns.'
   reviewed_by: primary
 - command_id: view.conditional-format.delete-all
   command_path: view conditional-format delete-all

{mammoth_cli-2.2.18 → mammoth_cli-2.2.20}/spec/manifests/sdk-methods.yaml

@@ -3833,6 +3833,18 @@ methods:
   pagination_policy: null
   secret_fields: []
   reviewed_by: primary
+- sdk_symbol: mammoth.api.datasets.DatasetsAPI.search
+  implementation_origin: mammoth.api.datasets.DatasetsAPI.search
+  signature: 'search(self, term: ''str'', workspace_id: ''int | None'' = None, project_id: ''int | None'' = None) -> ''dict[str, Any]'''
+  openapi_operation_ids: []
+  canonical_command: null
+  alias_of: null
+  no_command_reason: SDK-only helper; no reviewed CLI command.
+  mutation_class: null
+  wait_policy: null
+  pagination_policy: null
+  secret_fields: []
+  reviewed_by: primary
 - sdk_symbol: mammoth.api.datasets.DatasetsAPI.trash
   implementation_origin: mammoth.api.datasets.DatasetsAPI.trash
   signature: 'trash(self, dataset_id: ''int'', workspace_id: ''int | None'' = None, project_id: ''int | None'' = None) -> ''dict[str, Any]'''